server: added new api endpoint for paginated transaction list

vhurryharry · vhurryharry · commit b547fbe777e1 · 2020-08-27T00:24:47.000-04:00
diff --git a/server/app/com/xsn/explorer/data/TransactionDataHandler.scala b/server/app/com/xsn/explorer/data/TransactionDataHandler.scala
@@ -22,6 +22,12 @@ trait TransactionDataHandler[F[_]] {
 
   def getOutput(txid: TransactionId, index: Int): F[Transaction.Output]
 
+  def get(
+      limit: Limit,
+      lastSeenTxid: Option[TransactionId],
+      orderingCondition: OrderingCondition
+  ): F[List[TransactionInfo]]
+
   def getByBlockhash(
       blockhash: Blockhash,
       limit: Limit,
diff --git a/server/app/com/xsn/explorer/data/anorm/TransactionPostgresDataHandler.scala b/server/app/com/xsn/explorer/data/anorm/TransactionPostgresDataHandler.scala
@@ -45,6 +45,18 @@ class TransactionPostgresDataHandler @Inject()(
       Or.from(maybe, One(TransactionError.OutputNotFound(txid, index)))
   }
 
+  override def get(
+      limit: Limit,
+      lastSeenTxid: Option[TransactionId],
+      orderingCondition: OrderingCondition
+  ): ApplicationResult[List[TransactionInfo]] = withConnection { implicit conn =>
+    val transactions = lastSeenTxid
+      .map { transactionPostgresDAO.get(_, limit, orderingCondition) }
+      .getOrElse { transactionPostgresDAO.get(limit, orderingCondition) }
+
+    Good(transactions)
+  }
+
   override def getByBlockhash(
       blockhash: Blockhash,
       limit: Limit,
diff --git a/server/app/com/xsn/explorer/data/anorm/dao/TransactionPostgresDAO.scala b/server/app/com/xsn/explorer/data/anorm/dao/TransactionPostgresDAO.scala
@@ -311,6 +311,57 @@ class TransactionPostgresDAO @Inject()(
       .as(parseTransactionWithValues.*)
   }
 
+  def get(limit: Limit, orderingCondition: OrderingCondition)(implicit conn: Connection): List[TransactionInfo] = {
+
+    val order = toSQL(orderingCondition)
+
+    SQL(
+      s"""
+        |SELECT t.txid, t.blockhash, t.time, t.size, t.height,
+        |       (SELECT COALESCE(SUM(value), 0) FROM transaction_inputs WHERE txid = t.txid) AS sent,
+        |       (SELECT COALESCE(SUM(value), 0) FROM transaction_outputs WHERE txid = t.txid) AS received
+        |FROM transactions t JOIN blocks USING (blockhash)
+        |ORDER BY t.height $order
+        |LIMIT {limit}
+      """.stripMargin
+    ).on(
+        'limit -> limit.int
+      )
+      .as(parseTransactionInfo.*)
+  }
+
+  def get(lastSeenTxid: TransactionId, limit: Limit, orderingCondition: OrderingCondition)(
+      implicit conn: Connection
+  ): List[TransactionInfo] = {
+
+    val order = toSQL(orderingCondition)
+    val comparator = orderingCondition match {
+      case OrderingCondition.DescendingOrder => "<"
+      case OrderingCondition.AscendingOrder => ">"
+    }
+
+    SQL(
+      s"""
+        |WITH CTE AS (
+        |  SELECT height AS lastSeenHeight
+        |  FROM transactions
+        |  WHERE txid = {lastSeenTxid}
+        |)
+        |SELECT t.txid, t.blockhash, t.time, t.size, t.height,
+        |       (SELECT COALESCE(SUM(value), 0) FROM transaction_inputs WHERE txid = t.txid) AS sent,
+        |       (SELECT COALESCE(SUM(value), 0) FROM transaction_outputs WHERE txid = t.txid) AS received
+        |FROM CTE CROSS JOIN transactions t JOIN blocks USING (blockhash)
+        |WHERE t.height $comparator lastSeenHeight
+        |ORDER BY t.height $order
+        |LIMIT {limit}
+      """.stripMargin
+    ).on(
+        'limit -> limit.int,
+        'lastSeenTxid -> lastSeenTxid.toBytesBE.toArray
+      )
+      .as(parseTransactionInfo.*)
+  }
+
   def getTransactionsWithIOBy(blockhash: Blockhash, limit: Limit)(
       implicit conn: Connection
   ): List[Transaction.HasIO] = {
diff --git a/server/app/com/xsn/explorer/data/anorm/parsers/TransactionParsers.scala b/server/app/com/xsn/explorer/data/anorm/parsers/TransactionParsers.scala
@@ -4,6 +4,7 @@ import anorm.SqlParser._
 import anorm.~
 import com.xsn.explorer.models._
 import com.xsn.explorer.models.persisted.{AddressTransactionDetails, Transaction}
+import com.xsn.explorer.models.values._
 
 object TransactionParsers {
 
@@ -16,6 +17,7 @@ object TransactionParsers {
   val parseSent = get[BigDecimal]("sent")
   val parseValue = get[BigDecimal]("value")
   val parseHexScript = parseHexString("hex_script")
+  val parseHeight = int("height").map(Height.apply)
 
   val parseTransaction = (parseTransactionId() ~ parseBlockhashBytes() ~ parseTime ~ parseSize).map {
     case txid ~ blockhash ~ time ~ size => Transaction(txid, blockhash, time, size)
@@ -32,6 +34,18 @@ object TransactionParsers {
       TransactionWithValues(txid, blockhash, time, size, sent, received)
   }
 
+  val parseTransactionInfo = (parseTransactionId() ~
+    parseBlockhashBytes() ~
+    parseTime ~
+    parseSize ~
+    parseSent ~
+    parseReceived ~
+    parseHeight).map {
+
+    case txid ~ blockhash ~ time ~ size ~ sent ~ received ~ height =>
+      TransactionInfo(txid, blockhash, time, size, sent, received, height)
+  }
+
   val parseTransactionInput =
     (parseFromTxid ~ parseFromOutputIndex ~ parseIndex ~ parseValue ~ parseAddresses)
       .map {
diff --git a/server/app/com/xsn/explorer/data/async/TransactionFutureDataHandler.scala b/server/app/com/xsn/explorer/data/async/TransactionFutureDataHandler.scala
@@ -45,6 +45,16 @@ class TransactionFutureDataHandler @Inject()(
       }
     }
 
+  override def get(
+      limit: Limit,
+      lastSeenTxid: Option[TransactionId],
+      orderingCondition: OrderingCondition
+  ): FutureApplicationResult[List[TransactionInfo]] = retryableFutureDataHandler.retrying {
+    Future {
+      blockingDataHandler.get(limit, lastSeenTxid, orderingCondition)
+    }
+  }
+
   override def getByBlockhash(
       blockhash: Blockhash,
       limit: Limit,
diff --git a/server/app/com/xsn/explorer/models/TransactionInfo.scala b/server/app/com/xsn/explorer/models/TransactionInfo.scala
@@ -0,0 +1,19 @@
+package com.xsn.explorer.models
+
+import com.xsn.explorer.models.values.{Blockhash, Height, Size, TransactionId}
+import play.api.libs.json.{Json, Writes}
+
+case class TransactionInfo(
+    id: TransactionId,
+    blockhash: Blockhash,
+    time: Long,
+    size: Size,
+    sent: BigDecimal,
+    received: BigDecimal,
+    height: Height
+)
+
+object TransactionInfo {
+
+  implicit val writes: Writes[TransactionInfo] = Json.writes[TransactionInfo]
+}
diff --git a/server/app/com/xsn/explorer/services/TransactionService.scala b/server/app/com/xsn/explorer/services/TransactionService.scala
@@ -48,6 +48,23 @@ class TransactionService @Inject()(
     result.toFuture
   }
 
+  def get(
+      limit: Limit,
+      lastSeenTxidString: Option[String],
+      orderingConditionString: String
+  ): FutureApplicationResult[WrappedResult[List[TransactionInfo]]] = {
+    val result = for {
+      _ <- paginatedQueryValidator.validate(PaginatedQuery(Offset(0), limit), maxTransactionsPerQuery).toFutureOr
+
+      lastSeenTxid <- validate(lastSeenTxidString, transactionIdValidator.validate).toFutureOr
+      orderingCondition <- orderingConditionParser.parseReuslt(orderingConditionString).toFutureOr
+
+      r <- transactionFutureDataHandler.get(limit, lastSeenTxid, orderingCondition).toFutureOr
+    } yield WrappedResult(r)
+
+    result.toFuture
+  }
+
   def getByBlockhash(
       blockhashString: String,
       limit: Limit,
diff --git a/server/app/controllers/TransactionsController.scala b/server/app/controllers/TransactionsController.scala
@@ -3,15 +3,28 @@ package controllers
 import com.alexitc.playsonify.core.FutureOr.Implicits.FutureOps
 import com.xsn.explorer.models.request.SendRawTransactionRequest
 import com.xsn.explorer.services.TransactionRPCService
+import com.xsn.explorer.services.TransactionService
+import com.alexitc.playsonify.models.pagination.Limit
 import controllers.common.{MyJsonController, MyJsonControllerComponents}
 import javax.inject.Inject
 import play.api.libs.json.Json
 
-class TransactionsController @Inject()(transactionRPCService: TransactionRPCService, cc: MyJsonControllerComponents)
+class TransactionsController @Inject()(transactionRPCService: TransactionRPCService, transactionService: TransactionService, cc: MyJsonControllerComponents)
     extends MyJsonController(cc) {
 
   import Context._
 
+  def getTransactions(limit: Int, lastSeenTxid: Option[String], orderingCondition: String) = public { _ =>
+    transactionService
+      .get(Limit(limit), lastSeenTxid, orderingCondition)
+      .toFutureOr
+      .map { value =>
+        val response = Ok(Json.toJson(value))
+        response.withHeaders("Cache-Control" -> "public, max-age=60")
+      }
+      .toFuture
+  }
+
   def getTransaction(txid: String) = public { _ =>
     transactionRPCService
       .getTransactionDetails(txid)
diff --git a/server/conf/evolutions/default/25.sql b/server/conf/evolutions/default/25.sql
@@ -0,0 +1,8 @@
+
+# --- !Ups
+ALTER TABLE transactions
+    ADD COLUMN height SERIAL;
+
+# --- !Downs
+ALTER TABLE transactions
+    DROP COLUMN height;
diff --git a/server/conf/routes b/server/conf/routes
@@ -6,6 +6,7 @@
 GET   /health                controllers.HealthController.check()
 # GET   /maintenance           controllers.MaintenanceController.run(query: String ?= "")
 
+GET   /transactions              controllers.TransactionsController.getTransactions(limit: Int ?= 10, lastSeenTxid: Option[String], order: String ?= "desc")
 GET   /transactions/:txid        controllers.TransactionsController.getTransaction(txid: String)
 GET   /transactions/:txid/raw    controllers.TransactionsController.getRawTransaction(txid: String)
 POST  /transactions              controllers.TransactionsController.sendRawTransaction()
diff --git a/server/test/com/xsn/explorer/data/TransactionPostgresDataHandlerSpec.scala b/server/test/com/xsn/explorer/data/TransactionPostgresDataHandlerSpec.scala
@@ -9,7 +9,7 @@ import com.xsn.explorer.helpers.Converters._
 import com.xsn.explorer.helpers.DataHandlerObjects._
 import com.xsn.explorer.helpers.DataHelper._
 import com.xsn.explorer.helpers.{DataGenerator, LedgerHelper, TransactionLoader}
-import com.xsn.explorer.models.{BlockReward, PoWBlockRewards}
+import com.xsn.explorer.models.{BlockReward, PoWBlockRewards, TransactionInfo}
 import com.xsn.explorer.models.fields.TransactionField
 import com.xsn.explorer.models.persisted.Transaction
 import com.xsn.explorer.models.rpc.Block
@@ -203,6 +203,64 @@ class TransactionPostgresDataHandlerSpec extends PostgresDataHandlerSpec with Be
     testOrdering("asc", OrderingCondition.AscendingOrder)
   }
 
+  "get with scroll" should {
+    val address = randomAddress
+    val blockhash = randomBlockhash
+    val inputs = List(
+      Transaction.Input(dummyTransaction.id, 0, 1, 100, address),
+      Transaction.Input(dummyTransaction.id, 1, 2, 200, address)
+    )
+
+    val outputs = List(
+      Transaction.Output(randomTransactionId, 0, BigDecimal(50), randomAddress, randomHexString()),
+      Transaction.Output(randomTransactionId, 1, BigDecimal(250), randomAddress, HexString.from("00").get)
+    )
+
+    val transactions = List.fill(4)(randomTransactionId).zip(List(321L, 320L, 319L, 319L)).map {
+      case (txid, time) =>
+        Transaction.HasIO(Transaction(txid, blockhash, time, Size(1000)), inputs, outputs.map(_.copy(txid = txid)))
+    }
+
+    val block = randomBlock(blockhash = blockhash).copy(transactions = transactions.map(_.id))
+
+    def prepare() = {
+      createBlock(block, transactions)
+    }
+
+    "return the last element without last seen tx" in {
+      prepare()
+      val txWithIO = transactions(3)
+      val expected = TransactionInfo(
+        txWithIO.id, txWithIO.blockhash, txWithIO.time, txWithIO.size, BigDecimal(300), BigDecimal(300), Height(0)
+      )
+      val result = dataHandler.get(Limit(1), None, OrderingCondition.DescendingOrder).get
+
+      result.head.copy(height = Height(0)) mustEqual expected
+    }
+
+    "return the next elements given the last seen tx" in {
+      prepare()
+
+      val lastSeenTxid = transactions(3).id
+      
+      val txWithIO = transactions(2)
+      val expected = TransactionInfo(
+        txWithIO.id, txWithIO.blockhash, txWithIO.time, txWithIO.size, BigDecimal(300), BigDecimal(300), Height(0)
+      )
+
+      val result = dataHandler.get(Limit(1), Option(lastSeenTxid), OrderingCondition.DescendingOrder).get
+
+      result.head.copy(height = Height(0)) mustEqual expected
+    }
+
+    "return no elements on unknown lastSeenTransaction" in {
+      val lastSeenTxid = createTransactionId("00041e4fe89466faa734d6207a7ef6115fa1dd33f7156b006ffff6bb85a79eb8")
+      val result = dataHandler.get(Limit(1), Option(lastSeenTxid), OrderingCondition.DescendingOrder).get
+
+      result must be(empty)
+    }
+  }
+
   "spending an output" should {
     "use the right values" in {
       val address = randomAddress
diff --git a/server/test/com/xsn/explorer/helpers/TransactionDummyDataHandler.scala b/server/test/com/xsn/explorer/helpers/TransactionDummyDataHandler.scala
@@ -21,6 +21,12 @@ class TransactionDummyDataHandler extends TransactionBlockingDataHandler {
 
   override def getOutput(txid: TransactionId, index: Int): ApplicationResult[Transaction.Output] = ???
 
+  override def get(
+      limit: pagination.Limit,
+      lastSeenTxid: Option[TransactionId],
+      orderingCondition: OrderingCondition
+  ): ApplicationResult[List[TransactionInfo]] = ???
+
   override def getByBlockhash(
       blockhash: Blockhash,
       limit: pagination.Limit,
diff --git a/server/test/controllers/TransactionsControllerSpec.scala b/server/test/controllers/TransactionsControllerSpec.scala
@@ -31,6 +31,15 @@ class TransactionsControllerSpec extends MyAPISpec {
     }
   }
 
+  private val lastTransaction = TransactionWithValues(
+    createTransactionId("92c51e4fe89466faa734d6207a7ef6115fa1dd33f7156b006fafc6bb85a79eb8"),
+    createBlockhash("ad22f0dcea2fdaa357aac6eab00695cf07b487e34113598909f625c24629c981"),
+    12312312L,
+    Size(1000),
+    sent = 50,
+    received = 200
+  )
+
   override val application = guiceApplicationBuilder
     .overrides(bind[XSNService].to(customXSNService))
     .overrides(bind[TransactionBlockingDataHandler].to(transactionDataHandler))
@@ -200,6 +209,48 @@ class TransactionsControllerSpec extends MyAPISpec {
     }
   }
 
+  "GET /transactions" should {
+    def url(lastSeenTxId: Option[String], limit: Int) = s"/transactions?limit=$limit&lastSeenTxId=$lastSeenTxId"
+
+    "return the last transactions without lastSeenTxId" in {
+      pending
+      val limit = 5
+      val response = GET(url(None, limit))
+
+      status(response) mustEqual OK
+      val json = contentAsJson(response)
+      val data = (json \ "data").as[List[JsValue]]
+      data.size mustEqual 5
+
+      val item = data.head
+      (item \ "id").as[String] mustEqual lastTransaction.id.string
+      (item \ "blockhash").as[String] mustEqual lastTransaction.blockhash.string
+      (item \ "time").as[Long] mustEqual lastTransaction.time
+      (item \ "size").as[Int] mustEqual lastTransaction.size.int
+      (item \ "sent").as[BigDecimal] mustEqual lastTransaction.sent
+      (item \ "received").as[BigDecimal] mustEqual lastTransaction.received
+    }
+
+    "return the last transactions with lastSeenTxId" in {
+      pending
+      val limit = 5
+      val response = GET(url(None, limit))
+
+      status(response) mustEqual OK
+      val json = contentAsJson(response)
+      val data = (json \ "data").as[List[JsValue]]
+      data.size mustEqual 5
+
+      val item = data.head
+      (item \ "id").as[String] mustEqual lastTransaction.id.string
+      (item \ "blockhash").as[String] mustEqual lastTransaction.blockhash.string
+      (item \ "time").as[Long] mustEqual lastTransaction.time
+      (item \ "size").as[Int] mustEqual lastTransaction.size.int
+      (item \ "sent").as[BigDecimal] mustEqual lastTransaction.sent
+      (item \ "received").as[BigDecimal] mustEqual lastTransaction.received
+    }
+  }
+
   "GET transactions/:txid/lite" should {
     def url(txid: String) = s"/transactions/$txid/lite"
 
