upgraded all packages

.bsp/sbt.json

@@ -0,0 +1 @@
+{"name":"sbt","version":"1.9.7","bspVersion":"2.1.0-M1","languages":["scala"],"argv":["/usr/lib/jvm/java-17-amazon-corretto/bin/java","-Xms100m","-Xmx100m","-classpath","/home/jcole/.cache/sbt/boot/sbt-launch/1.9.7/sbt-launch-1.9.7.jar","-Dsbt.script=/usr/bin/sbt","xsbt.boot.Boot","-bsp"]}

app/com/coleji/neptune/API/CacheableResult.scala

@@ -102,12 +102,10 @@ trait CacheableResult[T <: ParamsObject, U] {
 						CacheableResult.resultMap.remove(cacheKey)
 					}
 				})
-				p.future.onFailure({
-					case _: Throwable => {
-						CacheableResult.waiting(cacheKey) -= p
-						if (CacheableResult.waiting(cacheKey).isEmpty) {
-							CacheableResult.resultMap.remove(cacheKey)
-						}
+				p.future.failed.foreach(e => {
+					CacheableResult.waiting(cacheKey) -= p
+					if (CacheableResult.waiting(cacheKey).isEmpty) {
+						CacheableResult.resultMap.remove(cacheKey)
 					}
 				})
 				p.future
@@ -129,11 +127,9 @@ trait CacheableResult[T <: ParamsObject, U] {
 					println("done son; completing all queued")
 					result
 				}))
-				p.future.onFailure({
-					case _: Throwable => {
-						println("Failure detected; cleaning up")
-						CacheableResult.inUse.remove(cacheKey)
-					}
+				p.future.failed.foreach(e => {
+					println("Failure detected; cleaning up")
+					CacheableResult.inUse.remove(cacheKey)
 				})
 				p.future
 			}

app/com/coleji/neptune/API/ResultError.scala

@@ -13,7 +13,7 @@ case class ResultError (
 case class ParseError(
 	code: String,
 	message: String,
-	parseErrors: Seq[(String, Seq[String])]
+	parseErrors: collection.Seq[(String, collection.Seq[String])]
 ) {
 	implicit val format = Json.format[ParseError]
 	def asJsObject: JsObject = JsObject(Map("error" -> Json.toJson(this)))
@@ -37,7 +37,7 @@ object ResultError {
 		message="JSON parameters were not correct."
 	)
 
-	val PARSE_FAILURE: Seq[(JsPath, Seq[JsonValidationError])] => JsObject = (errors: Seq[(JsPath, Seq[JsonValidationError])]) => ParseError(
+	val PARSE_FAILURE: collection.Seq[(JsPath, collection.Seq[JsonValidationError])] => JsObject = (errors: collection.Seq[(JsPath, collection.Seq[JsonValidationError])]) => ParseError(
 		code="parse_failure",
 		message="Request was not valid.",
 		parseErrors=errors.map(t => (t._1.toString(), t._2.flatMap(errs => errs.messages)))

app/com/coleji/neptune/Core/Boot/ServerBootLoader.scala

@@ -2,8 +2,8 @@ package com.coleji.neptune.Core.Boot
 
 import com.coleji.neptune.Core._
 import com.coleji.neptune.Util.PropertiesWrapper
-import com.redis.RedisClientPool
 import play.api.inject.ApplicationLifecycle
+import redis.clients.jedis.JedisPool
 
 import scala.concurrent.Future
 
@@ -62,7 +62,7 @@ object ServerBootLoader {
 			println("Using DB Driver: " + dbDriver)
 
 			val dbConnection = getDBPools(dbDriver)
-			val redisPool = new RedisClientPool(paramFile.getOptionalString("RedisHost").getOrElse("localhost"), 6379)
+			val redisPool = new JedisPool(paramFile.getOptionalString("RedisHost").getOrElse("localhost"), 6379)
 			lifecycle match {
 				case Some(lc) => lc.addStopHook(() => Future.successful({
 					println("****************************    Stop hook: closing pools  **********************")

app/com/coleji/neptune/Core/CacheableFactory.scala

@@ -39,7 +39,7 @@ abstract class CacheableFactory[T_KeyConfig, T_Result] {
 				} catch {
 					case e: InvalidClassException => {
 						val rte = new RuntimeException("****** Deserialization failed for cache key " + key, e)
-						Sentry.capture(rte)
+						Sentry.captureException(rte)
 						rte.printStackTrace()
 						populate(rc, config)
 					}

app/com/coleji/neptune/Core/ParsedRequest.scala

@@ -46,7 +46,7 @@ object ParsedRequest {
 	} catch {
 		case e: Throwable => {
 			PA.logger.error("Failure to parse request", e)
-			Sentry.capture(e)
+			Sentry.captureException(e)
 			throw e
 	}}
 

app/com/coleji/neptune/Core/PermissionsAuthority.scala

@@ -9,10 +9,10 @@ import com.coleji.neptune.Exception.{CORSException, MuteEmailException, PostBody
 import com.coleji.neptune.IO.PreparedQueries.{PreparedQueryForSelect, PreparedQueryForUpdateOrDelete}
 import com.coleji.neptune.Storable.{ResultSetWrapper, StorableClass, StorableObject}
 import com.coleji.neptune.Util.{Initializable, PropertiesWrapper}
-import com.redis.RedisClientPool
 import io.sentry.Sentry
 import play.api.libs.json.{JsResultException, JsValue}
 import play.api.mvc.{Result, Results}
+import redis.clients.jedis.JedisPool
 
 import java.time.LocalDateTime
 import java.time.format.DateTimeFormatter
@@ -25,7 +25,7 @@ class PermissionsAuthority private[Core] (
 	val systemParams: SystemServerParameters,
 	val customParams: PropertiesWrapper,
 	dbGateway: DatabaseGateway,
-	redisPool: RedisClientPool,
+	redisPool: JedisPool,
 	paPostBoot: PropertiesWrapper => Unit,
 )  {
 	println(s"inside PermissionsAuthority constructor: test mode: ${systemParams.isTestMode}, readOnlyDatabase: ${systemParams.readOnlyDatabase}")
@@ -88,28 +88,28 @@ class PermissionsAuthority private[Core] (
 				case Success(r: Result) => Success(r)
 				case Failure(e: Throwable) => {
 					logger.error(e.getMessage, e)
-					Sentry.capture(e)
+					Sentry.captureException(e)
 					Success(Results.Status(400)(ResultError.UNKNOWN.asJsObject))
 				}
 			})
 		} catch {
 			case _: UnauthorizedAccessException => Future(Results.Status(400)(ResultError.UNAUTHORIZED.asJsObject))
 			case _: CORSException => Future(Results.Status(400)(ResultError.UNAUTHORIZED.asJsObject))
 			case e: PostBodyNotJSONException => {
-				Sentry.capture(e)
+				Sentry.captureException(e)
 				Future(Results.Status(400)(ResultError.NOT_JSON.asJsObject))
 			}
 			case e: JsResultException => {
-				Sentry.capture(e)
+				Sentry.captureException(e)
 				Future(Results.Status(400)(ResultError.PARSE_FAILURE(e.errors)))
 			}
 			case e: MuteEmailException => {
-				Sentry.capture(e)
+				Sentry.captureException(e)
 				Future(Results.Status(400)(ResultError.UNKNOWN.asJsObject))
 			}
 			case e: Throwable => {
 				logger.error(e.getMessage, e)
-				Sentry.capture(e)
+				Sentry.captureException(e)
 				Future(Results.Status(400)(ResultError.UNKNOWN.asJsObject))
 			}
 		}

app/com/coleji/neptune/Core/RedisBroker.scala

@@ -1,13 +1,22 @@
 package com.coleji.neptune.Core
 
-import com.redis.RedisClientPool
+import redis.clients.jedis.{Jedis, JedisPool}
 
-class RedisBroker private[Core](val clientPool: RedisClientPool)  extends CacheBroker {
-	override def set(key: String, value: String): Unit = clientPool.withClient(c => c.set(key, value))
+import scala.util.Using
 
-	override def get(key: String): Option[String] = clientPool.withClient(c => c.get(key))
+class RedisBroker private[Core](val clientPool: JedisPool)  extends CacheBroker {
+	override def set(key: String, value: String): Unit = withResource(c => c.set(key, value))
 
-	override def peek(key: String): Boolean = clientPool.withClient(c => c.strlen(key).exists(_ > 0))
+	override def get(key: String): Option[String] = withResource(c => Option(c.get(key)))
 
-	override def delete(key: String): Unit = clientPool.withClient(c => c.del(key))
+	override def peek(key: String): Boolean = withResource(c => Option(c.strlen(key)).exists(_ > 0))
+
+	override def delete(key: String): Unit = withResource(c => c.del(key))
+
+	private def withResource[T](cmd: Jedis => T): T = {
+		val t = Using (clientPool.getResource) { jedis =>
+			cmd(jedis)
+		}
+		t.get
+	}
 }

app/com/coleji/neptune/Core/RequestCache.scala

@@ -7,15 +7,15 @@ import com.coleji.neptune.Storable.Fields.DatabaseField
 import com.coleji.neptune.Storable.StorableQuery.{QueryBuilder, QueryBuilderResultRow}
 import com.coleji.neptune.Storable.{Filter, StorableClass, StorableObject}
 import com.coleji.neptune.Util.PropertiesWrapper
-import com.redis.RedisClientPool
+import redis.clients.jedis.JedisPool
 
 // TODO: Some sort of security on the CacheBroker so arbitrary requests can't see the authentication tokens
 // TODO: mirror all PB methods on RC so the RC can either pull from redis or dispatch to oracle etc
 sealed abstract class RequestCache private[Core](
 	val userName: String,
 	serverParams: PropertiesWrapper,
 	dbGateway: DatabaseGateway,
-	redisPool: RedisClientPool
+	redisPool: JedisPool
 )(implicit val PA: PermissionsAuthority) {
 	def companion: RequestCacheObject[_]
 
@@ -94,7 +94,7 @@ abstract class LockedRequestCache(
 	override val userName: String,
 	serverParams: PropertiesWrapper,
 	dbGateway: DatabaseGateway,
-	redisPool: RedisClientPool,
+	redisPool: JedisPool,
 ) extends RequestCache(userName, serverParams, dbGateway, redisPool) {
 
 }
@@ -103,7 +103,7 @@ abstract class UnlockedRequestCache(
 	override val userName: String,
 	serverParams: PropertiesWrapper,
 	dbGateway: DatabaseGateway,
-	redisPool: RedisClientPool,
+	redisPool: JedisPool,
 ) extends RequestCache(userName, serverParams, dbGateway, redisPool) {
 	def getObjectById[T <: StorableClass](obj: StorableObject[T], id: Int, fieldShutter: Set[DatabaseField[_]]): Option[T] =
 		pb.getObjectById(obj, id, fieldShutter)

app/com/coleji/neptune/Core/RequestCacheObject.scala

@@ -2,14 +2,14 @@ package com.coleji.neptune.Core
 
 import com.coleji.neptune.Exception.UserTypeMismatchException
 import com.coleji.neptune.Util.PropertiesWrapper
-import com.redis.RedisClientPool
+import redis.clients.jedis.JedisPool
 
 abstract class RequestCacheObject[T <: RequestCache] {
 	val EMPTY_NONCE = "$EMPTY_AUTH_NONCE$"
 	val SEC_COOKIE_NAME_PUBLIC = "CBIDB-SEC"
 	val SEC_COOKIE_NAME_STAFF = "CBIDB-SEC-STAFF"
 
-	def create(userName: String, serverParams: PropertiesWrapper, dbGateway: DatabaseGateway, redisPool: RedisClientPool): T
+	def create(userName: String, serverParams: PropertiesWrapper, dbGateway: DatabaseGateway, redisPool: JedisPool): T
 
 	def test(allowed: Set[RequestCacheObject[_]]): Unit = {
 		if (!allowed.contains(this)) throw new UserTypeMismatchException()

app/com/coleji/neptune/Core/RootRequestCache.scala

@@ -1,10 +1,10 @@
 package com.coleji.neptune.Core
 
 import com.coleji.neptune.Util.PropertiesWrapper
-import com.redis.RedisClientPool
+import redis.clients.jedis.JedisPool
 
 
-class RootRequestCache(override val userName: String, serverParams: PropertiesWrapper, dbGateway: DatabaseGateway, redisPool: RedisClientPool)(implicit PA: PermissionsAuthority)
+class RootRequestCache(override val userName: String, serverParams: PropertiesWrapper, dbGateway: DatabaseGateway, redisPool: JedisPool)(implicit PA: PermissionsAuthority)
 extends UnlockedRequestCache(userName, serverParams, dbGateway, redisPool) {
 	override def companion: RequestCacheObject[RootRequestCache] = RootRequestCache
 }
@@ -13,10 +13,10 @@ object RootRequestCache extends RequestCacheObject[RootRequestCache] {
 	val uniqueUserName = "ROOT"
 	val ROOT_AUTH_HEADER = "origin-root"
 
-	override def create(userName: String, serverParams: PropertiesWrapper, dbGateway: DatabaseGateway, redisPool: RedisClientPool): RootRequestCache =
+	override def create(userName: String, serverParams: PropertiesWrapper, dbGateway: DatabaseGateway, redisPool: JedisPool): RootRequestCache =
 		new RootRequestCache(userName, serverParams, dbGateway, redisPool)
 
-	def create(serverParams: PropertiesWrapper, dbGateway: DatabaseGateway, redisPool: RedisClientPool): RootRequestCache = create(uniqueUserName, serverParams, dbGateway, redisPool)
+	def create(serverParams: PropertiesWrapper, dbGateway: DatabaseGateway, redisPool: JedisPool): RootRequestCache = create(uniqueUserName, serverParams, dbGateway, redisPool)
 
 	override def getAuthenticatedUsernameInRequest(
 		request: ParsedRequest,

app/com/coleji/neptune/Storable/FieldValues/DoubleFieldValue.scala

@@ -11,7 +11,7 @@ class DoubleFieldValue(instance: StorableClass, @transient fieldInner: DoubleDat
 	override def asJSValue: JsValue = JsNumber(super.get)
 
 	override def updateFromJsValue(v: JsValue): Boolean = v match {
-		case n: JsNumber => update(n.value.doubleValue())
+		case n: JsNumber => update(n.value.doubleValue)
 		case JsNull => throw new Exception("JsNull provided to nonnull field " + field.getRuntimeFieldName)
 		case _ => false
 	}

app/com/coleji/neptune/Storable/FieldValues/NullableDoubleFieldValue.scala

@@ -14,7 +14,7 @@ class NullableDoubleFieldValue(instance: StorableClass, @transient fieldInner: N
 	}
 
 	override def updateFromJsValue(v: JsValue): Boolean = v match {
-		case n: JsNumber => update(Some(n.value.doubleValue()))
+		case n: JsNumber => update(Some(n.value.doubleValue))
 		case JsNull => update(None)
 		case _ => false
 	}

app/com/coleji/neptune/Util/Currency.scala

@@ -81,6 +81,8 @@ object Currency {
 		override def toDouble(x: Currency): Double = x.cents.toDouble
 
 		override def compare(x: Currency, y: Currency): Int = if (x.cents > y.cents) 1 else if (x.cents < y.cents) -1 else 0
+
+		override def parseString(str: String): Option[Currency] = None
 	}
 
 }

app/org/sailcbi/APIServer/Api/Endpoints/Member/APWelcomePackage.scala

@@ -131,7 +131,7 @@ class APWelcomePackage @Inject()(ws: WSClient)(implicit val exec: ExecutionConte
 			// do this async, user doesnt need to wait for it.
 			if (stripeCustomerIdOption.isEmpty) {
 				stripe.createStripeCustomerFromPerson(rc, personId).map({
-					case f: NetFailure[_, _] => Sentry.capture("Failed to create stripe customerId for person " + personId)
+					case f: NetFailure[_, _] => Sentry.captureMessage("Failed to create stripe customerId for person " + personId)
 					case s: NetSuccess[_, _] =>
 				})
 			}

app/org/sailcbi/APIServer/Api/Endpoints/Member/JPWelcomePackage.scala

@@ -65,7 +65,7 @@ class JPWelcomePackage @Inject()(ws: WSClient)(implicit val exec: ExecutionConte
 			// do this async, user doesnt need to wait for it.
 			if (stripeCustomerIdOption.isEmpty) {
 				stripe.createStripeCustomerFromPerson(rc, personId).map({
-					case f: NetFailure[_, _] => Sentry.capture("Failed to create stripe customerId for person " + personId)
+					case f: NetFailure[_, _] => Sentry.captureMessage("Failed to create stripe customerId for person " + personId)
 					case s: NetSuccess[_, _] =>
 				})
 			}

app/org/sailcbi/APIServer/Api/Endpoints/PDFReports/RunApClassRoster.scala

@@ -4,7 +4,7 @@ import akka.stream.scaladsl.Source
 import akka.util.ByteString
 import com.coleji.neptune.Core.{ParsedRequest, PermissionsAuthority}
 import org.apache.pdfbox.pdmodel.PDDocument
-import org.apache.pdfbox.pdmodel.font.PDType1Font
+import org.apache.pdfbox.pdmodel.font.{PDType1Font, Standard14Fonts}
 import org.sailcbi.APIServer.Reports.ApClassRoster.ApClassRoster
 import org.sailcbi.APIServer.Reports.ApClassRoster.Loader.{ApClassRosterLiveLoader, ApClassRosterLiveParameter}
 import org.sailcbi.APIServer.UserTypes.StaffRequestCache
@@ -24,7 +24,7 @@ class RunApClassRoster @Inject() (implicit exec: ExecutionContext) extends Injec
 			val output = new ByteArrayOutputStream()
 			val document: PDDocument = new PDDocument()
 
-			val pdfFont = PDType1Font.HELVETICA
+			val pdfFont = new PDType1Font(Standard14Fonts.FontName.HELVETICA)
 			val fontSize = 13
 
 			val model = ApClassRosterLiveLoader(ApClassRosterLiveParameter(instanceId), rc)

app/org/sailcbi/APIServer/Api/Endpoints/PDFReports/RunDailyCloseReport.scala

@@ -4,7 +4,7 @@ import akka.stream.scaladsl.Source
 import akka.util.ByteString
 import com.coleji.neptune.Core.{ParsedRequest, PermissionsAuthority}
 import org.apache.pdfbox.pdmodel.PDDocument
-import org.apache.pdfbox.pdmodel.font.PDType1Font
+import org.apache.pdfbox.pdmodel.font.{PDType1Font, Standard14Fonts}
 import org.sailcbi.APIServer.Reports.DailyCloseReport.DailyCloseReport
 import org.sailcbi.APIServer.Reports.DailyCloseReport.Loader.{DailyCloseReportLiveLoader, DailyCloseReportLiveParameter}
 import org.sailcbi.APIServer.UserTypes.StaffRequestCache
@@ -25,7 +25,7 @@ class RunDailyCloseReport @Inject() (implicit val exec: ExecutionContext) extend
 			val output = new ByteArrayOutputStream()
 			val document: PDDocument = new PDDocument()
 
-			val pdfFont = PDType1Font.HELVETICA
+			val pdfFont = new PDType1Font(Standard14Fonts.FontName.HELVETICA)
 			val fontSize = 13
 
 			val model = DailyCloseReportLiveLoader(DailyCloseReportLiveParameter(closeId), rc)

app/org/sailcbi/APIServer/Api/Endpoints/Security/ForgotPassword.scala

@@ -61,7 +61,7 @@ class ForgotPassword @Inject()(implicit exec: ExecutionContext) extends Injected
 						)
 						override def registerOutParameters: Map[String, Int] = Map.empty
 
-						override def getOutResults(cs: CallableStatement): Unit = Unit
+						override def getOutResults(cs: CallableStatement): Unit = ()
 
 						override def getQuery: String = "email_pkg.public_reset_pw(?, ?)"
 					}

app/org/sailcbi/APIServer/Entities/cacheable/SignoutsToday.scala

@@ -184,7 +184,7 @@ object SignoutsToday extends CacheableFactory[Null, IndexedSeq[Signout]]{
 		).reverse.take(MAX_RECORDS_TO_RETURN)
 
 		if (signouts.size > MAX_RECORDS_TO_RETURN) {
-			Sentry.capture("Today's signouts had " + signouts.size + " results, sending an abridged list to client")
+			Sentry.captureMessage("Today's signouts had " + signouts.size + " results, sending an abridged list to client")
 		}
 
 		val ret = signoutsToReturn