Update qiwi models in more java-friendly way

UnknownNPC · Aug 20, 2019 · 9049d08 · 9049d08
1 parent 80f03a3
commit 9049d08
Show file tree

Hide file tree

Showing 11 changed files with 90 additions and 95 deletions.
diff --git a/qiwi/src/main/scala/com/github/unknownnpc/psw/qiwi/QiwiAPI.scala b/qiwi/src/main/scala/com/github/unknownnpc/psw/qiwi/QiwiAPI.scala
@@ -4,8 +4,7 @@ import java.util.Optional
 
 import com.github.unknownnpc.psw.api.APIException
 import com.github.unknownnpc.psw.qiwi.action.{RetrieveAccountBalanceAction, RetrieveTransferHistoryAction}
-import com.github.unknownnpc.psw.qiwi.model.QiwiModel.WalletHistory.{NextPage, ReqSources, ReqTransferType, StartEndDates}
-import com.github.unknownnpc.psw.qiwi.model.QiwiModel.{AccountBalance, WalletHistory}
+import com.github.unknownnpc.psw.qiwi.model._
 import com.github.unknownnpc.psw.qiwi.serializer.QiwiSerializer._
 import org.apache.http.impl.client.{CloseableHttpClient, HttpClients}
 
@@ -27,18 +26,18 @@ private[qiwi] class QiwiAPI(token: String, httpClient: CloseableHttpClient) {
     */
   def retrieveTransferHistory(personId: String, rows: Int = 10,
                               operation: Option[ReqTransferType.Value] = Some(ReqTransferType.ALL),
-                              sources: List[ReqSources.Value] = List.empty, startEndDates: Option[StartEndDates] = None,
-                              nextPage: Option[NextPage] = None): Either[APIException, WalletHistory.Response] = {
+                              sources: List[ReqSources.Value] = List.empty, startEndDates: Option[WalletHistory#StartEndDates] = None,
+                              nextPage: Option[WalletHistory#NextPage] = None): Either[APIException, WalletHistoryResponse] = {
     RetrieveTransferHistoryAction(httpClient).run(
-      WalletHistory.Request(token, personId, rows, operation, sources, startEndDates, nextPage)
+      WalletHistoryRequest(token, personId, rows, operation, sources, startEndDates, nextPage)
     )
   }
 
   def retrieveTransferHistoryJava(personId: String, rows: Optional[Integer],
                                   operation: Optional[ReqTransferType.Value],
                                   sources: java.util.List[ReqSources.Value],
-                                  startEndDates: Optional[StartEndDates],
-                                  nextPage: Optional[NextPage]): Either[APIException, WalletHistory.Response] = {
+                                  startEndDates: Optional[WalletHistory#StartEndDates],
+                                  nextPage: Optional[WalletHistory#NextPage]): Either[APIException, WalletHistoryResponse] = {
     retrieveTransferHistory(personId,
       rows.orElse(10),
       Option(operation.orElse(ReqTransferType.ALL)),
@@ -55,15 +54,15 @@ private[qiwi] class QiwiAPI(token: String, httpClient: CloseableHttpClient) {
     * @param personId the personId valie, eg: 30501234567
     * @return the entity with response or error
     */
-  def retrieveAccountBalance(personId: String): Either[APIException, AccountBalance.Response] = {
+  def retrieveAccountBalance(personId: String): Either[APIException, AccountBalanceResponse] = {
     RetrieveAccountBalanceAction(httpClient).run(
-      AccountBalance.Request(token, personId)
+      AccountBalanceRequest(token, personId)
     )
   }
 
-  def retrieveAccountBalanceJava(personId: String): Either[APIException, AccountBalance.Response] = {
+  def retrieveAccountBalanceJava(personId: String): Either[APIException, AccountBalanceResponse] = {
     RetrieveAccountBalanceAction(httpClient).run(
-      AccountBalance.Request(token, personId)
+      AccountBalanceRequest(token, personId)
     )
   }
 

diff --git a/qiwi/src/main/scala/com/github/unknownnpc/psw/qiwi/action/RetrieveAccountBalanceAction.scala b/qiwi/src/main/scala/com/github/unknownnpc/psw/qiwi/action/RetrieveAccountBalanceAction.scala
@@ -2,12 +2,12 @@ package com.github.unknownnpc.psw.qiwi.action
 
 import com.github.unknownnpc.psw.api.action.ActionContext
 import com.github.unknownnpc.psw.api.executor.RestHttpExecutor
-import com.github.unknownnpc.psw.qiwi.model.QiwiModel.AccountBalance.{Request, Response}
+import com.github.unknownnpc.psw.qiwi.model.{AccountBalanceRequest, AccountBalanceResponse}
 import org.apache.http.client.methods.HttpGet
 import org.apache.http.impl.client.CloseableHttpClient
 
 private[qiwi] trait RetrieveAccountBalanceAction extends
-  ActionContext[Request, Response, HttpGet, String] with RestHttpExecutor[HttpGet]
+  ActionContext[AccountBalanceRequest, AccountBalanceResponse, HttpGet, String] with RestHttpExecutor[HttpGet]
 
 object RetrieveAccountBalanceAction {
 

diff --git a/.../src/main/scala/com/github/unknownnpc/psw/qiwi/action/RetrieveTransferHistoryAction.scala b/.../src/main/scala/com/github/unknownnpc/psw/qiwi/action/RetrieveTransferHistoryAction.scala
@@ -2,12 +2,12 @@ package com.github.unknownnpc.psw.qiwi.action
 
 import com.github.unknownnpc.psw.api.action.ActionContext
 import com.github.unknownnpc.psw.api.executor.RestHttpExecutor
-import com.github.unknownnpc.psw.qiwi.model.QiwiModel.WalletHistory.{Request, Response}
+import com.github.unknownnpc.psw.qiwi.model.{WalletHistoryRequest, WalletHistoryResponse}
 import org.apache.http.client.methods.HttpGet
 import org.apache.http.impl.client.CloseableHttpClient
 
 private[qiwi] trait RetrieveTransferHistoryAction extends
-  ActionContext[Request, Response, HttpGet, String] with RestHttpExecutor[HttpGet]
+  ActionContext[WalletHistoryRequest, WalletHistoryResponse, HttpGet, String] with RestHttpExecutor[HttpGet]
 
 object RetrieveTransferHistoryAction {
 

diff --git a/qiwi/src/main/scala/com/github/unknownnpc/psw/qiwi/model/AccountBalance.scala b/qiwi/src/main/scala/com/github/unknownnpc/psw/qiwi/model/AccountBalance.scala
@@ -0,0 +1,12 @@
+package com.github.unknownnpc.psw.qiwi.model
+
+trait AccountBalance
+
+case class AccountBalanceRequest(apiToken: String, wallet: String)
+
+case class AccountBalanceResponse(accounts: List[AccountBalanceResponseAccount])
+case class AccountBalanceResponseAccount(alias: String, fsAlias: String, bankAlias: String,
+                                         title: String, `type`: AccountBalanceResponseAccountType, hasBalance: Boolean, balance: AccountBalanceResponseAccountBalance,
+                                         currency: Int, defaultAccount: Boolean)
+case class AccountBalanceResponseAccountType(id: String, title: String)
+case class AccountBalanceResponseAccountBalance(amount: BigDecimal, currency: Int)
diff --git a/qiwi/src/main/scala/com/github/unknownnpc/psw/qiwi/model/QiwiModel.scala b/qiwi/src/main/scala/com/github/unknownnpc/psw/qiwi/model/QiwiModel.scala
diff --git a/qiwi/src/main/scala/com/github/unknownnpc/psw/qiwi/model/WalletHistory.scala b/qiwi/src/main/scala/com/github/unknownnpc/psw/qiwi/model/WalletHistory.scala
@@ -0,0 +1,44 @@
+package com.github.unknownnpc.psw.qiwi.model
+
+import java.util.Date
+
+object ReqTransferType extends Enumeration {
+  type ReqTransferType = Value
+  val ALL, IN, OUT, QIWI_CARD = Value
+}
+
+/**
+  * Should be as passed as serial number from 0, eg: MK eqs 4.
+  */
+object ReqSources extends Enumeration {
+  type ReqSources = Value
+  val QW_RUB, QW_USD, QW_EUR, CARD, MK = Value
+}
+
+object ResStatus extends Enumeration {
+  type ResStatus = Value
+  val WAITING, SUCCESS, ERROR = Value
+}
+
+trait WalletHistory {
+  type StartEndDates = (Date, Date)
+  type NextPage = (Date, Long)
+}
+
+case class WalletHistoryRequest(apiToken: String, personId: String, rows: Int = 10,
+                                operation: Option[ReqTransferType.Value] = Some(ReqTransferType.ALL),
+                                sources: List[ReqSources.Value] = List.empty, startEndDates: Option[WalletHistory#StartEndDates] = None,
+                                nextPage: Option[WalletHistory#NextPage] = None)
+
+case class WalletHistoryResponse(data: List[WalletHistoryResponseData], nextTxnId: Option[Long], nextTxnDate: Option[Date])
+
+case class WalletHistoryResponseData(txnId: Long, personId: Long, date: Date, errorCode: Long, error: String, status: ResStatus.Value,
+                                     statusText: String, trmTxnId: String, account: String, sum: WalletHistoryResponseAmountCurrency, total: WalletHistoryResponseAmountCurrency,
+                                     provider: WalletHistoryResponseProvider, comment: String, currencyRate: BigDecimal, chequeReady: Option[Boolean],
+                                     bankDocumentAvailable: Option[Boolean], bankDocumentReady: Option[Boolean], repeatPaymentEnabled: Option[Boolean],
+                                     favoritePaymentEnabled: Option[Boolean], regularPaymentEnabled: Option[Boolean])
+
+case class WalletHistoryResponseAmountCurrency(amount: BigDecimal, currency: String)
+
+case class WalletHistoryResponseProvider(id: Long, shortName: String, longName: String, logoUrl: String, description: String,
+                                         keys: String, siteUrl: String)
diff --git a/...main/scala/com/github/unknownnpc/psw/qiwi/serializer/AccountBalanceReqResSerializer.scala b/...main/scala/com/github/unknownnpc/psw/qiwi/serializer/AccountBalanceReqResSerializer.scala
@@ -1,14 +1,14 @@
 package com.github.unknownnpc.psw.qiwi.serializer
 
 import com.github.unknownnpc.psw.api.Serializer
-import com.github.unknownnpc.psw.qiwi.model.QiwiModel.AccountBalance.{Request, Response}
+import com.github.unknownnpc.psw.qiwi.model.{AccountBalanceRequest, AccountBalanceResponse}
 import org.apache.http.client.methods.HttpGet
 
-private[serializer] class AccountBalanceReqResSerializer extends Serializer[Request, Response, HttpGet, String] {
+private[serializer] class AccountBalanceReqResSerializer extends Serializer[AccountBalanceRequest, AccountBalanceResponse, HttpGet, String] {
 
   private val urlTarget: String = "https://edge.qiwi.com/funding-sources/v2/persons/%s/accounts"
 
-  override def toReq(req: Request): HttpGet = {
+  override def toReq(req: AccountBalanceRequest): HttpGet = {
     val fullRequestUrl = String.format(urlTarget, req.wallet)
     val httpGet = new HttpGet(fullRequestUrl)
     httpGet.setHeader("Authorization", "Bearer " + req.apiToken)
@@ -17,13 +17,13 @@ private[serializer] class AccountBalanceReqResSerializer extends Serializer[Requ
     httpGet
   }
 
-  override def fromRes(out: String): Response = {
+  override def fromRes(out: String): AccountBalanceResponse = {
     import org.json4s._
     import org.json4s.native.Serialization
     import org.json4s.native.Serialization.read
     implicit val formats = Serialization.formats(NoTypeHints)
 
-    read[Response](out)
+    read[AccountBalanceResponse](out)
   }
 
 }
diff --git a/qiwi/src/main/scala/com/github/unknownnpc/psw/qiwi/serializer/QiwiSerializer.scala b/qiwi/src/main/scala/com/github/unknownnpc/psw/qiwi/serializer/QiwiSerializer.scala
@@ -1,12 +1,12 @@
 package com.github.unknownnpc.psw.qiwi.serializer
 
 import com.github.unknownnpc.psw.api.Serializer
-import com.github.unknownnpc.psw.qiwi.model.QiwiModel.{AccountBalance, WalletHistory}
+import com.github.unknownnpc.psw.qiwi.model.{AccountBalanceRequest, AccountBalanceResponse, WalletHistoryRequest, WalletHistoryResponse}
 import org.apache.http.client.methods.HttpGet
 
 private[qiwi] object QiwiSerializer {
 
-  implicit val walletHistoryReqResSerializer: Serializer[WalletHistory.Request, WalletHistory.Response, HttpGet, String] = new WalletHistoryReqResSerializer
-  implicit val accountBalanceReqResSerializer: Serializer[AccountBalance.Request, AccountBalance.Response, HttpGet, String] = new AccountBalanceReqResSerializer
+  implicit val walletHistoryReqResSerializer: Serializer[WalletHistoryRequest, WalletHistoryResponse, HttpGet, String] = new WalletHistoryReqResSerializer
+  implicit val accountBalanceReqResSerializer: Serializer[AccountBalanceRequest, AccountBalanceResponse, HttpGet, String] = new AccountBalanceReqResSerializer
 
 }
diff --git a/.../main/scala/com/github/unknownnpc/psw/qiwi/serializer/WalletHistoryReqResSerializer.scala b/.../main/scala/com/github/unknownnpc/psw/qiwi/serializer/WalletHistoryReqResSerializer.scala
@@ -4,12 +4,12 @@ import java.text.SimpleDateFormat
 import java.util.{Date, TimeZone}
 
 import com.github.unknownnpc.psw.api.Serializer
-import com.github.unknownnpc.psw.qiwi.model.QiwiModel.WalletHistory.{Request, ResStatus, Response}
+import com.github.unknownnpc.psw.qiwi.model.{ResStatus, WalletHistoryRequest, WalletHistoryResponse}
 import org.apache.http.client.methods.HttpGet
 import org.json4s.CustomSerializer
 import org.json4s.JsonAST.JString
 
-private[serializer] class WalletHistoryReqResSerializer extends Serializer[Request, Response, HttpGet, String] {
+private[serializer] class WalletHistoryReqResSerializer extends Serializer[WalletHistoryRequest, WalletHistoryResponse, HttpGet, String] {
 
   private val urlTarget: String = "https://edge.qiwi.com/payment-history/v2/persons/%s/payments?rows=%s&"
 
@@ -24,7 +24,7 @@ private[serializer] class WalletHistoryReqResSerializer extends Serializer[Reque
     setTimeZone(TimeZone.getTimeZone("GMT"))
   }
 
-  override def toReq(req: Request): HttpGet = {
+  override def toReq(req: WalletHistoryRequest): HttpGet = {
 
     def queryParam(name: String, value: String): String = s"$name=$value"
 
@@ -51,13 +51,13 @@ private[serializer] class WalletHistoryReqResSerializer extends Serializer[Reque
     httpGet
   }
 
-  override def fromRes(out: String): Response = {
+  override def fromRes(out: String): WalletHistoryResponse = {
     import org.json4s._
     import org.json4s.native.Serialization
     import org.json4s.native.Serialization.read
     implicit val formats = Serialization.formats(NoTypeHints) + CustomDateSerializer + ResStatusSerializer
 
-    read[Response](out)
+    read[WalletHistoryResponse](out)
   }
 
   object CustomDateSerializer extends CustomSerializer[Date](_ => ( {

diff --git a/.../scala/com/github/unknownnpc/psw/qiwi/serializer/AccountBalanceReqResSerializerTest.scala b/.../scala/com/github/unknownnpc/psw/qiwi/serializer/AccountBalanceReqResSerializerTest.scala
@@ -1,12 +1,12 @@
 package com.github.unknownnpc.psw.qiwi.serializer
 
-import com.github.unknownnpc.psw.qiwi.model.QiwiModel.AccountBalance.Request
+import com.github.unknownnpc.psw.qiwi.model.AccountBalanceRequest
 import org.scalatest.{FunSpec, Matchers}
 
 class AccountBalanceReqResSerializerTest extends FunSpec with Matchers {
 
   it("should serialize to request correctly when all params exist") {
-    val request = Request("token", "personId")
+    val request = AccountBalanceRequest("token", "personId")
     val requestSample = QiwiSerializer.accountBalanceReqResSerializer.toReq(request)
     requestSample should not be null
     requestSample.getAllHeaders.toList should have size 2
@@ -15,7 +15,7 @@ class AccountBalanceReqResSerializerTest extends FunSpec with Matchers {
 
   it("should serialize to request with valid headers") {
     val token = "token123"
-    val request = Request(token, "wallet")
+    val request = AccountBalanceRequest(token, "wallet")
     val requestSample = QiwiSerializer.accountBalanceReqResSerializer.toReq(request)
     requestSample.getAllHeaders.head.getName shouldBe "Authorization"
     requestSample.getAllHeaders.head.getValue shouldBe s"Bearer $token"

diff --git a/...t/scala/com/github/unknownnpc/psw/qiwi/serializer/WalletHistoryReqResSerializerTest.scala b/...t/scala/com/github/unknownnpc/psw/qiwi/serializer/WalletHistoryReqResSerializerTest.scala
@@ -2,15 +2,15 @@ package com.github.unknownnpc.psw.qiwi.serializer
 
 import java.util.Date
 
-import com.github.unknownnpc.psw.qiwi.model.QiwiModel.WalletHistory.{ReqSources, ReqTransferType, Request, ResStatus}
+import com.github.unknownnpc.psw.qiwi.model.{ReqSources, ReqTransferType, ResStatus, WalletHistoryRequest}
 import org.scalatest.{FunSpec, Matchers}
 
 class WalletHistoryReqResSerializerTest extends FunSpec with Matchers {
 
   it("should serialize to request correctly when all params exist") {
     val fromDate = new Date(10000)
     val toDate = new Date(20000)
-    val request = Request(
+    val request = WalletHistoryRequest(
       "token", "personId", 11, Some(ReqTransferType.IN), sources = List(ReqSources.QW_EUR, ReqSources.CARD),
       Some(fromDate, toDate), Some(toDate, 2L)
     )
@@ -24,7 +24,7 @@ class WalletHistoryReqResSerializerTest extends FunSpec with Matchers {
   }
 
   it("should serialize to request correctly when all params default") {
-    val request = Request("token", "wallet", 11)
+    val request = WalletHistoryRequest("token", "wallet", 11)
     val requestSample = QiwiSerializer.walletHistoryReqResSerializer.toReq(request)
     requestSample should not be null
     requestSample.getAllHeaders.toList should have size 2
@@ -33,7 +33,7 @@ class WalletHistoryReqResSerializerTest extends FunSpec with Matchers {
 
   it("should serialize to request with valid headers") {
     val token = "token123"
-    val request = Request(token, "wallet", 11)
+    val request = WalletHistoryRequest(token, "wallet", 11)
     val requestSample = QiwiSerializer.walletHistoryReqResSerializer.toReq(request)
     requestSample.getAllHeaders.head.getName shouldBe "Authorization"
     requestSample.getAllHeaders.head.getValue shouldBe s"Bearer $token"