Browse Source

server: Update playsonify to 1.2.0

scalafmt-draft
Alexis Hernandez 7 years ago
parent
commit
b4442b3d98
  1. 2
      server/app/com/xsn/explorer/data/BalanceDataHandler.scala
  2. 2
      server/app/com/xsn/explorer/data/anorm/BalancePostgresDataHandler.scala
  3. 2
      server/app/com/xsn/explorer/data/anorm/dao/BalancePostgresDAO.scala
  4. 2
      server/app/com/xsn/explorer/data/anorm/interpreters/FieldOrderingSQLInterpreter.scala
  5. 6
      server/app/com/xsn/explorer/data/async/BalanceFutureDataHandler.scala
  6. 22
      server/app/com/xsn/explorer/errors/paginatedQueryErrors.scala
  7. 2
      server/app/com/xsn/explorer/models/Address.scala
  8. 2
      server/app/com/xsn/explorer/models/Blockhash.scala
  9. 2
      server/app/com/xsn/explorer/models/Confirmations.scala
  10. 2
      server/app/com/xsn/explorer/models/Height.scala
  11. 2
      server/app/com/xsn/explorer/models/Size.scala
  12. 2
      server/app/com/xsn/explorer/models/TransactionId.scala
  13. 10
      server/app/com/xsn/explorer/models/base/Count.scala
  14. 3
      server/app/com/xsn/explorer/models/base/FieldOrdering.scala
  15. 10
      server/app/com/xsn/explorer/models/base/Limit.scala
  16. 10
      server/app/com/xsn/explorer/models/base/Offset.scala
  17. 9
      server/app/com/xsn/explorer/models/base/OrderingCondition.scala
  18. 3
      server/app/com/xsn/explorer/models/base/OrderingQuery.scala
  19. 3
      server/app/com/xsn/explorer/models/base/PaginatedQuery.scala
  20. 15
      server/app/com/xsn/explorer/models/base/PaginatedResult.scala
  21. 14
      server/app/com/xsn/explorer/models/base/WrappedInt.scala
  22. 16
      server/app/com/xsn/explorer/models/base/WrappedString.scala
  23. 3
      server/app/com/xsn/explorer/parsers/BalanceOrderingParser.scala
  24. 64
      server/app/com/xsn/explorer/parsers/FieldOrderingParser.scala
  25. 3
      server/app/com/xsn/explorer/parsers/MasternodeOrderingParser.scala
  26. 3
      server/app/com/xsn/explorer/processors/BlockEventsProcessor.scala
  27. 10
      server/app/com/xsn/explorer/services/BalanceService.scala
  28. 10
      server/app/com/xsn/explorer/services/MasternodeService.scala
  29. 3
      server/app/com/xsn/explorer/services/TransactionService.scala
  30. 37
      server/app/com/xsn/explorer/services/validators/PaginatedQueryValidator.scala
  31. 3
      server/app/com/xsn/explorer/tasks/BackwardsSynchronizerTask.scala
  32. 3
      server/app/com/xsn/explorer/tasks/FirstBlockSynchronizerTask.scala
  33. 27
      server/app/com/xsn/explorer/util/Extensions.scala
  34. 2
      server/app/controllers/BalancesController.scala
  35. 2
      server/app/controllers/MasternodesController.scala
  36. 2
      server/build.sbt
  37. 2
      server/test/com/xsn/explorer/data/BalancePostgresDataHandlerSpec.scala
  38. 11
      server/test/com/xsn/explorer/processors/BlockEventsProcessorSpec.scala
  39. 2
      server/test/controllers/BalancesControllerSpec.scala

2
server/app/com/xsn/explorer/data/BalanceDataHandler.scala

@ -1,8 +1,8 @@
package com.xsn.explorer.data package com.xsn.explorer.data
import com.alexitc.playsonify.core.ApplicationResult import com.alexitc.playsonify.core.ApplicationResult
import com.alexitc.playsonify.models.{FieldOrdering, PaginatedQuery, PaginatedResult}
import com.xsn.explorer.models.Balance import com.xsn.explorer.models.Balance
import com.xsn.explorer.models.base.{FieldOrdering, PaginatedQuery, PaginatedResult}
import com.xsn.explorer.models.fields.BalanceField import com.xsn.explorer.models.fields.BalanceField
import scala.language.higherKinds import scala.language.higherKinds

2
server/app/com/xsn/explorer/data/anorm/BalancePostgresDataHandler.scala

@ -3,11 +3,11 @@ package com.xsn.explorer.data.anorm
import javax.inject.Inject import javax.inject.Inject
import com.alexitc.playsonify.core.ApplicationResult import com.alexitc.playsonify.core.ApplicationResult
import com.alexitc.playsonify.models.{FieldOrdering, PaginatedQuery, PaginatedResult}
import com.xsn.explorer.data.BalanceBlockingDataHandler import com.xsn.explorer.data.BalanceBlockingDataHandler
import com.xsn.explorer.data.anorm.dao.BalancePostgresDAO import com.xsn.explorer.data.anorm.dao.BalancePostgresDAO
import com.xsn.explorer.errors.BalanceUnknownError import com.xsn.explorer.errors.BalanceUnknownError
import com.xsn.explorer.models.Balance import com.xsn.explorer.models.Balance
import com.xsn.explorer.models.base.{FieldOrdering, PaginatedQuery, PaginatedResult}
import com.xsn.explorer.models.fields.BalanceField import com.xsn.explorer.models.fields.BalanceField
import org.scalactic.{Good, One, Or} import org.scalactic.{Good, One, Or}
import play.api.db.Database import play.api.db.Database

2
server/app/com/xsn/explorer/data/anorm/dao/BalancePostgresDAO.scala

@ -4,10 +4,10 @@ import java.sql.Connection
import javax.inject.Inject import javax.inject.Inject
import anorm._ import anorm._
import com.alexitc.playsonify.models.{Count, FieldOrdering, PaginatedQuery}
import com.xsn.explorer.data.anorm.interpreters.FieldOrderingSQLInterpreter import com.xsn.explorer.data.anorm.interpreters.FieldOrderingSQLInterpreter
import com.xsn.explorer.data.anorm.parsers.BalanceParsers._ import com.xsn.explorer.data.anorm.parsers.BalanceParsers._
import com.xsn.explorer.models.Balance import com.xsn.explorer.models.Balance
import com.xsn.explorer.models.base.{Count, FieldOrdering, PaginatedQuery}
import com.xsn.explorer.models.fields.BalanceField import com.xsn.explorer.models.fields.BalanceField
class BalancePostgresDAO @Inject() (fieldOrderingSQLInterpreter: FieldOrderingSQLInterpreter) { class BalancePostgresDAO @Inject() (fieldOrderingSQLInterpreter: FieldOrderingSQLInterpreter) {

2
server/app/com/xsn/explorer/data/anorm/interpreters/FieldOrderingSQLInterpreter.scala

@ -1,6 +1,6 @@
package com.xsn.explorer.data.anorm.interpreters package com.xsn.explorer.data.anorm.interpreters
import com.xsn.explorer.models.base.{FieldOrdering, OrderingCondition} import com.alexitc.playsonify.models.{FieldOrdering, OrderingCondition}
class FieldOrderingSQLInterpreter { class FieldOrderingSQLInterpreter {

6
server/app/com/xsn/explorer/data/async/BalanceFutureDataHandler.scala

@ -2,11 +2,11 @@ package com.xsn.explorer.data.async
import javax.inject.Inject import javax.inject.Inject
import com.alexitc.playsonify.core.FutureApplicationResult import com.alexitc.playsonify.core.{FutureApplicationResult, FuturePaginatedResult}
import com.alexitc.playsonify.models.{FieldOrdering, PaginatedQuery}
import com.xsn.explorer.data.{BalanceBlockingDataHandler, BalanceDataHandler} import com.xsn.explorer.data.{BalanceBlockingDataHandler, BalanceDataHandler}
import com.xsn.explorer.executors.DatabaseExecutionContext import com.xsn.explorer.executors.DatabaseExecutionContext
import com.xsn.explorer.models.Balance import com.xsn.explorer.models.Balance
import com.xsn.explorer.models.base.{FieldOrdering, PaginatedQuery, PaginatedResult}
import com.xsn.explorer.models.fields.BalanceField import com.xsn.explorer.models.fields.BalanceField
import scala.concurrent.Future import scala.concurrent.Future
@ -20,7 +20,7 @@ class BalanceFutureDataHandler @Inject() (
blockingDataHandler.upsert(balance) blockingDataHandler.upsert(balance)
} }
override def get(query: PaginatedQuery, ordering: FieldOrdering[BalanceField]): FutureApplicationResult[PaginatedResult[Balance]] = Future { override def get(query: PaginatedQuery, ordering: FieldOrdering[BalanceField]): FuturePaginatedResult[Balance] = Future {
blockingDataHandler.get(query, ordering) blockingDataHandler.get(query, ordering)
} }
} }

22
server/app/com/xsn/explorer/errors/paginatedQueryErrors.scala

@ -1,22 +0,0 @@
package com.xsn.explorer.errors
import com.alexitc.playsonify.models.{FieldValidationError, InputValidationError, PublicError}
import play.api.i18n.{Lang, MessagesApi}
sealed trait PaginatedQueryError
case object PaginatedQueryOffsetError extends PaginatedQueryError with InputValidationError {
override def toPublicErrorList(messagesApi: MessagesApi)(implicit lang: Lang): List[PublicError] = {
val message = messagesApi("error.paginatedQuery.offset.invalid")
val error = FieldValidationError("offset", message)
List(error)
}
}
case class PaginatedQueryLimitError(maxValue: Int) extends PaginatedQueryError with InputValidationError {
override def toPublicErrorList(messagesApi: MessagesApi)(implicit lang: Lang): List[PublicError] = {
val message = messagesApi("error.paginatedQuery.limit.invalid", maxValue)
val error = FieldValidationError("limit", message)
List(error)
}
}

2
server/app/com/xsn/explorer/models/Address.scala

@ -2,7 +2,7 @@ package com.xsn.explorer.models
import javax.xml.bind.DatatypeConverter import javax.xml.bind.DatatypeConverter
import com.xsn.explorer.models.base.WrappedString import com.alexitc.playsonify.models.WrappedString
import play.api.libs.json._ import play.api.libs.json._
import scala.util.Try import scala.util.Try

2
server/app/com/xsn/explorer/models/Blockhash.scala

@ -1,6 +1,6 @@
package com.xsn.explorer.models package com.xsn.explorer.models
import com.xsn.explorer.models.base.WrappedString import com.alexitc.playsonify.models.WrappedString
import play.api.libs.json._ import play.api.libs.json._
class Blockhash private (val string: String) extends AnyVal with WrappedString class Blockhash private (val string: String) extends AnyVal with WrappedString

2
server/app/com/xsn/explorer/models/Confirmations.scala

@ -1,6 +1,6 @@
package com.xsn.explorer.models package com.xsn.explorer.models
import com.xsn.explorer.models.base.WrappedInt import com.alexitc.playsonify.models.WrappedInt
import play.api.libs.json.{JsPath, Reads} import play.api.libs.json.{JsPath, Reads}
case class Confirmations(int: Int) extends AnyVal with WrappedInt case class Confirmations(int: Int) extends AnyVal with WrappedInt

2
server/app/com/xsn/explorer/models/Height.scala

@ -1,6 +1,6 @@
package com.xsn.explorer.models package com.xsn.explorer.models
import com.xsn.explorer.models.base.WrappedInt import com.alexitc.playsonify.models.WrappedInt
import play.api.libs.json.{JsPath, Reads} import play.api.libs.json.{JsPath, Reads}
case class Height(int: Int) extends AnyVal with WrappedInt case class Height(int: Int) extends AnyVal with WrappedInt

2
server/app/com/xsn/explorer/models/Size.scala

@ -1,6 +1,6 @@
package com.xsn.explorer.models package com.xsn.explorer.models
import com.xsn.explorer.models.base.WrappedInt import com.alexitc.playsonify.models.WrappedInt
import play.api.libs.json.{JsPath, Reads} import play.api.libs.json.{JsPath, Reads}
case class Size(int: Int) extends AnyVal with WrappedInt case class Size(int: Int) extends AnyVal with WrappedInt

2
server/app/com/xsn/explorer/models/TransactionId.scala

@ -1,6 +1,6 @@
package com.xsn.explorer.models package com.xsn.explorer.models
import com.xsn.explorer.models.base.WrappedString import com.alexitc.playsonify.models.WrappedString
import play.api.libs.json._ import play.api.libs.json._
class TransactionId private (val string: String) extends AnyVal with WrappedString class TransactionId private (val string: String) extends AnyVal with WrappedString

10
server/app/com/xsn/explorer/models/base/Count.scala

@ -1,10 +0,0 @@
package com.xsn.explorer.models.base
import play.api.libs.json.{JsNumber, Writes}
case class Count(int: Int) extends AnyVal
object Count {
implicit val writes: Writes[Count] = Writes[Count] { count => JsNumber(count.int) }
}

3
server/app/com/xsn/explorer/models/base/FieldOrdering.scala

@ -1,3 +0,0 @@
package com.xsn.explorer.models.base
case class FieldOrdering[+A](field: A, orderingCondition: OrderingCondition)

10
server/app/com/xsn/explorer/models/base/Limit.scala

@ -1,10 +0,0 @@
package com.xsn.explorer.models.base
import play.api.libs.json.{JsNumber, Writes}
case class Limit(int: Int) extends AnyVal
object Limit {
implicit val writes: Writes[Limit] = Writes[Limit] { limit => JsNumber(limit.int) }
}

10
server/app/com/xsn/explorer/models/base/Offset.scala

@ -1,10 +0,0 @@
package com.xsn.explorer.models.base
import play.api.libs.json.{JsNumber, Writes}
case class Offset(int: Int) extends AnyVal
object Offset {
implicit val writes: Writes[Offset] = Writes[Offset] { offset => JsNumber(offset.int) }
}

9
server/app/com/xsn/explorer/models/base/OrderingCondition.scala

@ -1,9 +0,0 @@
package com.xsn.explorer.models.base
sealed trait OrderingCondition
object OrderingCondition {
case object AscendingOrder extends OrderingCondition
case object DescendingOrder extends OrderingCondition
}

3
server/app/com/xsn/explorer/models/base/OrderingQuery.scala

@ -1,3 +0,0 @@
package com.xsn.explorer.models.base
case class OrderingQuery(string: String) extends AnyVal

3
server/app/com/xsn/explorer/models/base/PaginatedQuery.scala

@ -1,3 +0,0 @@
package com.xsn.explorer.models.base
case class PaginatedQuery(offset: Offset, limit: Limit)

15
server/app/com/xsn/explorer/models/base/PaginatedResult.scala

@ -1,15 +0,0 @@
package com.xsn.explorer.models.base
import play.api.libs.json.{Json, OWrites, Writes}
case class PaginatedResult[T](offset: Offset, limit: Limit, total: Count, data: List[T])
object PaginatedResult {
implicit def writes[T](implicit writesT: Writes[T]): Writes[PaginatedResult[T]] = OWrites[PaginatedResult[T]] { result =>
Json.obj(
"offset" -> result.offset,
"limit" -> result.limit,
"total" -> result.total,
"data" -> result.data
)
}
}

14
server/app/com/xsn/explorer/models/base/WrappedInt.scala

@ -1,14 +0,0 @@
package com.xsn.explorer.models.base
import play.api.libs.json.{JsNumber, Writes}
trait WrappedInt extends Any {
def int: Int
}
object WrappedInt {
implicit val writes: Writes[WrappedInt] = {
Writes[WrappedInt] { wrapped => JsNumber(wrapped.int) }
}
}

16
server/app/com/xsn/explorer/models/base/WrappedString.scala

@ -1,16 +0,0 @@
package com.xsn.explorer.models.base
import play.api.libs.json.{JsString, Writes}
trait WrappedString extends Any {
def string: String
override def toString: String = string
}
object WrappedString {
implicit val writes: Writes[WrappedString] = {
Writes[WrappedString] { wrapped => JsString(wrapped.string) }
}
}

3
server/app/com/xsn/explorer/parsers/BalanceOrderingParser.scala

@ -1,6 +1,7 @@
package com.xsn.explorer.parsers package com.xsn.explorer.parsers
import com.xsn.explorer.models.base.OrderingCondition import com.alexitc.playsonify.models.OrderingCondition
import com.alexitc.playsonify.parsers.FieldOrderingParser
import com.xsn.explorer.models.fields.BalanceField import com.xsn.explorer.models.fields.BalanceField
class BalanceOrderingParser extends FieldOrderingParser[BalanceField] { class BalanceOrderingParser extends FieldOrderingParser[BalanceField] {

64
server/app/com/xsn/explorer/parsers/FieldOrderingParser.scala

@ -1,64 +0,0 @@
package com.xsn.explorer.parsers
import com.alexitc.playsonify.core.{ApplicationErrors, ApplicationResult}
import com.xsn.explorer.errors.{InvalidOrderingConditionError, InvalidOrderingError, UnknownOrderingFieldError}
import com.xsn.explorer.models.base.{FieldOrdering, OrderingCondition, OrderingQuery}
import org.scalactic._
trait FieldOrderingParser[+A] {
protected def parseField(unsafeField: String): Option[A]
protected def defaultField: A
protected def defaultOrderingCondition: OrderingCondition = OrderingCondition.AscendingOrder
/**
* Accepts values in the format field[:condition], being condition
* an optional argument allowing the these values:
* - asc: for ascending order.
* - desc: for descending order.
*
* The empty string is also accepted returning a default ordering.
*/
def from(orderByQuery: OrderingQuery): ApplicationResult[FieldOrdering[A]] = {
Option(orderByQuery.string)
.filter(_.nonEmpty)
.map { string => from(string.split(":")) }
.getOrElse {
val ordering = FieldOrdering(defaultField, defaultOrderingCondition)
Good(ordering)
}
}
private def from(parts: Seq[String]): FieldOrdering[A] Or ApplicationErrors = parts match {
case Seq(unsafeField) =>
for {
field <- getFieldResult(unsafeField)
} yield FieldOrdering(field, defaultOrderingCondition)
case Seq(unsafeField, unsafeOrderingCondition) =>
Accumulation.withGood(
getFieldResult(unsafeField),
getOrderingConditionResult(unsafeOrderingCondition)) { FieldOrdering.apply }
case _ =>
Bad(InvalidOrderingError).accumulating
}
private def getFieldResult(unsafeField: String) = {
val maybe = parseField(unsafeField)
Or.from(maybe, One(UnknownOrderingFieldError))
}
private def getOrderingConditionResult(unsafeOrderingCondition: String) = {
val maybe = parseOrderingCondition(unsafeOrderingCondition)
Or.from(maybe, One(InvalidOrderingConditionError))
}
protected def parseOrderingCondition(unsafeOrderingCondition: String): Option[OrderingCondition] = unsafeOrderingCondition match {
case "asc" => Some(OrderingCondition.AscendingOrder)
case "desc" => Some(OrderingCondition.DescendingOrder)
case _ => None
}
}

3
server/app/com/xsn/explorer/parsers/MasternodeOrderingParser.scala

@ -1,6 +1,7 @@
package com.xsn.explorer.parsers package com.xsn.explorer.parsers
import com.xsn.explorer.models.base.OrderingCondition import com.alexitc.playsonify.models.OrderingCondition
import com.alexitc.playsonify.parsers.FieldOrderingParser
import com.xsn.explorer.models.fields.MasternodeField import com.xsn.explorer.models.fields.MasternodeField
class MasternodeOrderingParser extends FieldOrderingParser[MasternodeField] { class MasternodeOrderingParser extends FieldOrderingParser[MasternodeField] {

3
server/app/com/xsn/explorer/processors/BlockEventsProcessor.scala

@ -3,14 +3,13 @@ package com.xsn.explorer.processors
import javax.inject.Inject import javax.inject.Inject
import com.alexitc.playsonify.core.FutureApplicationResult import com.alexitc.playsonify.core.FutureApplicationResult
import com.alexitc.playsonify.core.FutureOr.Implicits.FutureOps import com.alexitc.playsonify.core.FutureOr.Implicits.{FutureListOps, FutureOps}
import com.xsn.explorer.data.DatabaseSeeder import com.xsn.explorer.data.DatabaseSeeder
import com.xsn.explorer.data.async.{BlockFutureDataHandler, DatabaseFutureSeeder} import com.xsn.explorer.data.async.{BlockFutureDataHandler, DatabaseFutureSeeder}
import com.xsn.explorer.errors.BlockNotFoundError import com.xsn.explorer.errors.BlockNotFoundError
import com.xsn.explorer.models.rpc.Block import com.xsn.explorer.models.rpc.Block
import com.xsn.explorer.models.{Blockhash, Transaction} import com.xsn.explorer.models.{Blockhash, Transaction}
import com.xsn.explorer.services.{TransactionService, XSNService} import com.xsn.explorer.services.{TransactionService, XSNService}
import com.xsn.explorer.util.Extensions.FutureApplicationResultExt
import org.scalactic.{Bad, Good, One} import org.scalactic.{Bad, Good, One}
import org.slf4j.LoggerFactory import org.slf4j.LoggerFactory

10
server/app/com/xsn/explorer/services/BalanceService.scala

@ -2,13 +2,13 @@ package com.xsn.explorer.services
import javax.inject.Inject import javax.inject.Inject
import com.alexitc.playsonify.core.FutureApplicationResult
import com.alexitc.playsonify.core.FutureOr.Implicits.{FutureOps, OrOps} import com.alexitc.playsonify.core.FutureOr.Implicits.{FutureOps, OrOps}
import com.alexitc.playsonify.core.FuturePaginatedResult
import com.alexitc.playsonify.models.{OrderingQuery, PaginatedQuery}
import com.alexitc.playsonify.validators.PaginatedQueryValidator
import com.xsn.explorer.data.async.BalanceFutureDataHandler import com.xsn.explorer.data.async.BalanceFutureDataHandler
import com.xsn.explorer.models.Balance import com.xsn.explorer.models.Balance
import com.xsn.explorer.models.base.{OrderingQuery, PaginatedQuery, PaginatedResult}
import com.xsn.explorer.parsers.BalanceOrderingParser import com.xsn.explorer.parsers.BalanceOrderingParser
import com.xsn.explorer.services.validators.PaginatedQueryValidator
import scala.concurrent.ExecutionContext import scala.concurrent.ExecutionContext
@ -18,9 +18,9 @@ class BalanceService @Inject() (
balanceFutureDataHandler: BalanceFutureDataHandler)( balanceFutureDataHandler: BalanceFutureDataHandler)(
implicit ec: ExecutionContext) { implicit ec: ExecutionContext) {
def get(paginatedQuery: PaginatedQuery, orderingQuery: OrderingQuery): FutureApplicationResult[PaginatedResult[Balance]] = { def get(paginatedQuery: PaginatedQuery, orderingQuery: OrderingQuery): FuturePaginatedResult[Balance] = {
val result = for { val result = for {
validatedQuery <- paginatedQueryValidator.validate(paginatedQuery).toFutureOr validatedQuery <- paginatedQueryValidator.validate(paginatedQuery, 100).toFutureOr
ordering <- balanceOrderingParser.from(orderingQuery).toFutureOr ordering <- balanceOrderingParser.from(orderingQuery).toFutureOr
balances <- balanceFutureDataHandler.get(validatedQuery, ordering).toFutureOr balances <- balanceFutureDataHandler.get(validatedQuery, ordering).toFutureOr
} yield balances } yield balances

10
server/app/com/xsn/explorer/services/MasternodeService.scala

@ -2,13 +2,13 @@ package com.xsn.explorer.services
import javax.inject.Inject import javax.inject.Inject
import com.alexitc.playsonify.core.FutureApplicationResult
import com.alexitc.playsonify.core.FutureOr.Implicits.{FutureOps, OrOps} import com.alexitc.playsonify.core.FutureOr.Implicits.{FutureOps, OrOps}
import com.xsn.explorer.models.base._ import com.alexitc.playsonify.core.FuturePaginatedResult
import com.alexitc.playsonify.models._
import com.alexitc.playsonify.validators.PaginatedQueryValidator
import com.xsn.explorer.models.fields.MasternodeField import com.xsn.explorer.models.fields.MasternodeField
import com.xsn.explorer.models.rpc.Masternode import com.xsn.explorer.models.rpc.Masternode
import com.xsn.explorer.parsers.MasternodeOrderingParser import com.xsn.explorer.parsers.MasternodeOrderingParser
import com.xsn.explorer.services.validators.PaginatedQueryValidator
import scala.concurrent.ExecutionContext import scala.concurrent.ExecutionContext
@ -18,9 +18,9 @@ class MasternodeService @Inject() (
xsnService: XSNService)( xsnService: XSNService)(
implicit ec: ExecutionContext) { implicit ec: ExecutionContext) {
def getMasternodes(paginatedQuery: PaginatedQuery, orderingQuery: OrderingQuery): FutureApplicationResult[PaginatedResult[Masternode]] = { def getMasternodes(paginatedQuery: PaginatedQuery, orderingQuery: OrderingQuery): FuturePaginatedResult[Masternode] = {
val result = for { val result = for {
validatedQuery <- queryValidator.validate(paginatedQuery).toFutureOr validatedQuery <- queryValidator.validate(paginatedQuery, 2000).toFutureOr
ordering <- masternodeOrderingParser.from(orderingQuery).toFutureOr ordering <- masternodeOrderingParser.from(orderingQuery).toFutureOr
masternodes <- xsnService.getMasternodes().toFutureOr masternodes <- xsnService.getMasternodes().toFutureOr
} yield build(masternodes, validatedQuery, ordering) } yield build(masternodes, validatedQuery, ordering)

3
server/app/com/xsn/explorer/services/TransactionService.scala

@ -3,11 +3,10 @@ package com.xsn.explorer.services
import javax.inject.Inject import javax.inject.Inject
import com.alexitc.playsonify.core.FutureApplicationResult import com.alexitc.playsonify.core.FutureApplicationResult
import com.alexitc.playsonify.core.FutureOr.Implicits.{FutureOps, OrOps} import com.alexitc.playsonify.core.FutureOr.Implicits.{FutureListOps, FutureOps, OrOps}
import com.xsn.explorer.errors.{TransactionFormatError, TransactionNotFoundError} import com.xsn.explorer.errors.{TransactionFormatError, TransactionNotFoundError}
import com.xsn.explorer.models.rpc.TransactionVIN import com.xsn.explorer.models.rpc.TransactionVIN
import com.xsn.explorer.models.{Transaction, TransactionDetails, TransactionId, TransactionValue} import com.xsn.explorer.models.{Transaction, TransactionDetails, TransactionId, TransactionValue}
import com.xsn.explorer.util.Extensions.FutureApplicationResultExt
import org.scalactic.{Bad, Good, One, Or} import org.scalactic.{Bad, Good, One, Or}
import scala.concurrent.{ExecutionContext, Future} import scala.concurrent.{ExecutionContext, Future}

37
server/app/com/xsn/explorer/services/validators/PaginatedQueryValidator.scala

@ -1,37 +0,0 @@
package com.xsn.explorer.services.validators
import com.alexitc.playsonify.core.ApplicationResult
import com.xsn.explorer.errors.{PaginatedQueryLimitError, PaginatedQueryOffsetError}
import com.xsn.explorer.models.base.{Limit, Offset, PaginatedQuery}
import org.scalactic.{Accumulation, Bad, Good}
class PaginatedQueryValidator {
private val MinOffset = 0
private val LimitRange = 1 to 100
def validate(query: PaginatedQuery): ApplicationResult[PaginatedQuery] = {
Accumulation.withGood(
validateOffset(query.offset),
validateLimit(query.limit)) {
PaginatedQuery.apply
}
}
private def validateOffset(offset: Offset): ApplicationResult[Offset] = {
if (offset.int >= MinOffset) {
Good(offset)
} else {
Bad(PaginatedQueryOffsetError).accumulating
}
}
private def validateLimit(limit: Limit): ApplicationResult[Limit] = {
if (LimitRange contains limit.int) {
Good(limit)
} else {
Bad(PaginatedQueryLimitError(LimitRange.last)).accumulating
}
}
}

3
server/app/com/xsn/explorer/tasks/BackwardsSynchronizerTask.scala

@ -3,14 +3,13 @@ package com.xsn.explorer.tasks
import javax.inject.{Inject, Singleton} import javax.inject.{Inject, Singleton}
import com.alexitc.playsonify.core.FutureApplicationResult import com.alexitc.playsonify.core.FutureApplicationResult
import com.alexitc.playsonify.core.FutureOr.Implicits.{FutureOps, OrOps} import com.alexitc.playsonify.core.FutureOr.Implicits.{FutureListOps, FutureOps, OrOps}
import com.xsn.explorer.data.DatabaseSeeder import com.xsn.explorer.data.DatabaseSeeder
import com.xsn.explorer.data.async.{BlockFutureDataHandler, DatabaseFutureSeeder} import com.xsn.explorer.data.async.{BlockFutureDataHandler, DatabaseFutureSeeder}
import com.xsn.explorer.errors.BlockNotFoundError import com.xsn.explorer.errors.BlockNotFoundError
import com.xsn.explorer.models.rpc.Block import com.xsn.explorer.models.rpc.Block
import com.xsn.explorer.models.{Blockhash, Height} import com.xsn.explorer.models.{Blockhash, Height}
import com.xsn.explorer.services.{TransactionService, XSNService} import com.xsn.explorer.services.{TransactionService, XSNService}
import com.xsn.explorer.util.Extensions.FutureApplicationResultExt
import org.scalactic.{Bad, Good, One, Or} import org.scalactic.{Bad, Good, One, Or}
import org.slf4j.LoggerFactory import org.slf4j.LoggerFactory

3
server/app/com/xsn/explorer/tasks/FirstBlockSynchronizerTask.scala

@ -3,13 +3,12 @@ package com.xsn.explorer.tasks
import javax.inject.{Inject, Singleton} import javax.inject.{Inject, Singleton}
import com.alexitc.playsonify.core.FutureApplicationResult import com.alexitc.playsonify.core.FutureApplicationResult
import com.alexitc.playsonify.core.FutureOr.Implicits.{FutureOps, OrOps} import com.alexitc.playsonify.core.FutureOr.Implicits.{FutureListOps, FutureOps, OrOps}
import com.xsn.explorer.data.DatabaseSeeder import com.xsn.explorer.data.DatabaseSeeder
import com.xsn.explorer.data.async.{BlockFutureDataHandler, DatabaseFutureSeeder} import com.xsn.explorer.data.async.{BlockFutureDataHandler, DatabaseFutureSeeder}
import com.xsn.explorer.errors.BlockNotFoundError import com.xsn.explorer.errors.BlockNotFoundError
import com.xsn.explorer.models.{Blockhash, Height} import com.xsn.explorer.models.{Blockhash, Height}
import com.xsn.explorer.services.{TransactionService, XSNService} import com.xsn.explorer.services.{TransactionService, XSNService}
import com.xsn.explorer.util.Extensions.FutureApplicationResultExt
import org.scalactic.{Bad, Good, One, Or} import org.scalactic.{Bad, Good, One, Or}
import org.slf4j.LoggerFactory import org.slf4j.LoggerFactory

27
server/app/com/xsn/explorer/util/Extensions.scala

@ -1,10 +1,5 @@
package com.xsn.explorer.util package com.xsn.explorer.util
import com.alexitc.playsonify.core.{FutureApplicationResult, FutureOr}
import org.scalactic.{Bad, Good}
import scala.concurrent.{ExecutionContext, Future}
object Extensions { object Extensions {
private val SatoshiScale = 100000000L private val SatoshiScale = 100000000L
@ -15,28 +10,6 @@ object Extensions {
} }
} }
implicit class FutureApplicationResultExt[+A](val inner: List[FutureApplicationResult[A]]) extends AnyVal {
def toFutureOr(implicit ec: ExecutionContext): FutureOr[List[A]] = {
val futureList = Future.sequence(inner)
val future = futureList.map { resultList =>
val errorsMaybe = resultList
.flatMap(_.swap.toOption)
.reduceLeftOption(_ ++ _)
.map(_.distinct)
errorsMaybe
.map(Bad(_))
.getOrElse {
val valueList = resultList.flatMap(_.toOption)
Good(valueList)
}
}
new FutureOr(future)
}
}
implicit class ListOptionExt[+A](val inner: List[Option[A]]) extends AnyVal { implicit class ListOptionExt[+A](val inner: List[Option[A]]) extends AnyVal {
def everything: Option[List[A]] = { def everything: Option[List[A]] = {
if (inner.forall(_.isDefined)) { if (inner.forall(_.isDefined)) {

2
server/app/controllers/BalancesController.scala

@ -2,7 +2,7 @@ package controllers
import javax.inject.Inject import javax.inject.Inject
import com.xsn.explorer.models.base.{Limit, Offset, OrderingQuery, PaginatedQuery} import com.alexitc.playsonify.models.{Limit, Offset, OrderingQuery, PaginatedQuery}
import com.xsn.explorer.services.BalanceService import com.xsn.explorer.services.BalanceService
import controllers.common.{MyJsonController, MyJsonControllerComponents} import controllers.common.{MyJsonController, MyJsonControllerComponents}

2
server/app/controllers/MasternodesController.scala

@ -2,7 +2,7 @@ package controllers
import javax.inject.Inject import javax.inject.Inject
import com.xsn.explorer.models.base.{Limit, Offset, OrderingQuery, PaginatedQuery} import com.alexitc.playsonify.models.{Limit, Offset, OrderingQuery, PaginatedQuery}
import com.xsn.explorer.services.MasternodeService import com.xsn.explorer.services.MasternodeService
import controllers.common.{MyJsonController, MyJsonControllerComponents} import controllers.common.{MyJsonController, MyJsonControllerComponents}

2
server/build.sbt

@ -22,7 +22,7 @@ scalacOptions ++= Seq(
) )
val playsonifyVersion = "1.1.0" val playsonifyVersion = "1.2.0"
lazy val root = (project in file(".")) lazy val root = (project in file("."))
.enablePlugins(PlayScala) .enablePlugins(PlayScala)

2
server/test/com/xsn/explorer/data/BalancePostgresDataHandlerSpec.scala

@ -1,12 +1,12 @@
package com.xsn.explorer.data package com.xsn.explorer.data
import com.alexitc.playsonify.models._
import com.xsn.explorer.data.anorm.BalancePostgresDataHandler import com.xsn.explorer.data.anorm.BalancePostgresDataHandler
import com.xsn.explorer.data.anorm.dao.BalancePostgresDAO import com.xsn.explorer.data.anorm.dao.BalancePostgresDAO
import com.xsn.explorer.data.anorm.interpreters.FieldOrderingSQLInterpreter import com.xsn.explorer.data.anorm.interpreters.FieldOrderingSQLInterpreter
import com.xsn.explorer.data.common.PostgresDataHandlerSpec import com.xsn.explorer.data.common.PostgresDataHandlerSpec
import com.xsn.explorer.helpers.DataHelper import com.xsn.explorer.helpers.DataHelper
import com.xsn.explorer.models.Balance import com.xsn.explorer.models.Balance
import com.xsn.explorer.models.base._
import com.xsn.explorer.models.fields.BalanceField import com.xsn.explorer.models.fields.BalanceField
import org.scalactic.Good import org.scalactic.Good

11
server/test/com/xsn/explorer/processors/BlockEventsProcessorSpec.scala

@ -1,25 +1,20 @@
package com.xsn.explorer.processors package com.xsn.explorer.processors
import com.alexitc.playsonify.core.FutureApplicationResult import com.alexitc.playsonify.models._
import com.xsn.explorer.data.anorm.dao.{BalancePostgresDAO, BlockPostgresDAO, StatisticsPostgresDAO, TransactionPostgresDAO} import com.xsn.explorer.data.anorm.dao.{BalancePostgresDAO, BlockPostgresDAO, StatisticsPostgresDAO, TransactionPostgresDAO}
import com.xsn.explorer.data.anorm.interpreters.FieldOrderingSQLInterpreter import com.xsn.explorer.data.anorm.interpreters.FieldOrderingSQLInterpreter
import com.xsn.explorer.data.anorm.{BalancePostgresDataHandler, BlockPostgresDataHandler, DatabasePostgresSeeder, StatisticsPostgresDataHandler} import com.xsn.explorer.data.anorm.{BalancePostgresDataHandler, BlockPostgresDataHandler, DatabasePostgresSeeder, StatisticsPostgresDataHandler}
import com.xsn.explorer.data.async.{BlockFutureDataHandler, DatabaseFutureSeeder} import com.xsn.explorer.data.async.{BlockFutureDataHandler, DatabaseFutureSeeder}
import com.xsn.explorer.data.common.PostgresDataHandlerSpec import com.xsn.explorer.data.common.PostgresDataHandlerSpec
import com.xsn.explorer.errors.{BlockNotFoundError, TransactionNotFoundError}
import com.xsn.explorer.helpers.{BlockLoader, Executors, FileBasedXSNService} import com.xsn.explorer.helpers.{BlockLoader, Executors, FileBasedXSNService}
import com.xsn.explorer.models.base._
import com.xsn.explorer.models.fields.BalanceField import com.xsn.explorer.models.fields.BalanceField
import com.xsn.explorer.models.rpc.{Block, Transaction} import com.xsn.explorer.models.rpc.Block
import com.xsn.explorer.models.{Blockhash, TransactionId}
import com.xsn.explorer.processors.BlockEventsProcessor.{NewBlockAppended, RechainDone} import com.xsn.explorer.processors.BlockEventsProcessor.{NewBlockAppended, RechainDone}
import com.xsn.explorer.services.TransactionService import com.xsn.explorer.services.TransactionService
import org.scalactic.{Bad, Good} import org.scalactic.Good
import org.scalatest.BeforeAndAfter import org.scalatest.BeforeAndAfter
import org.scalatest.concurrent.ScalaFutures import org.scalatest.concurrent.ScalaFutures
import scala.concurrent.Future
class BlockEventsProcessorSpec extends PostgresDataHandlerSpec with ScalaFutures with BeforeAndAfter { class BlockEventsProcessorSpec extends PostgresDataHandlerSpec with ScalaFutures with BeforeAndAfter {
lazy val dataHandler = new BlockPostgresDataHandler(database, new BlockPostgresDAO) lazy val dataHandler = new BlockPostgresDataHandler(database, new BlockPostgresDAO)

2
server/test/controllers/BalancesControllerSpec.scala

@ -1,10 +1,10 @@
package controllers package controllers
import com.alexitc.playsonify.core.ApplicationResult import com.alexitc.playsonify.core.ApplicationResult
import com.alexitc.playsonify.models._
import com.xsn.explorer.data.BalanceBlockingDataHandler import com.xsn.explorer.data.BalanceBlockingDataHandler
import com.xsn.explorer.helpers.DataHelper import com.xsn.explorer.helpers.DataHelper
import com.xsn.explorer.models.Balance import com.xsn.explorer.models.Balance
import com.xsn.explorer.models.base._
import com.xsn.explorer.models.fields.BalanceField import com.xsn.explorer.models.fields.BalanceField
import controllers.common.MyAPISpec import controllers.common.MyAPISpec
import org.scalactic.Good import org.scalactic.Good

Loading…
Cancel
Save