Check IP

Author: zargarzadehm

app/controllers/Controller.scala

@@ -107,7 +107,7 @@ class Controller @Inject()(userAction: UserAction, userActionOption: UserActionO
       val address = request.body.hcursor.downField("address").as[String].getOrElse(throw new Throwable("address field must exist"))
       val assetId = request.body.hcursor.downField("assetId").as[String].getOrElse(throw new Throwable("assetId field must exist"))
       verifyRecaptcha(challenge)
-      if (paymentTokenDao.exists(request.user.username, address, Conf.ergoAssets(assetId.toInt).name)) {
+      if (paymentTokenDao.exists(request.user.username, address, request.ip, Conf.ergoAssets(assetId.toInt).name)) {
         BadRequest(
           s"""{
              |  "message": "This address has already received ${Conf.ergoAssets(assetId.toInt).name} assets."
@@ -118,7 +118,7 @@ class Controller @Inject()(userAction: UserAction, userActionOption: UserActionO
         val proxy_info = selectRandomProxyInfo(Conf.proxyInfos)
         val txId = createReward.sendAsset(address, proxy_info.get, Conf.ergoAssets(assetId.toInt)).replaceAll("\"", "")
         if (txId.nonEmpty) {
-          paymentTokenDao.insertConsiderOldPayment(TokenPayment(request.user.username, address, Conf.ergoAssets(assetId.toInt).assets("erg"), Conf.ergoAssets(assetId.toInt).name, txId))
+          paymentTokenDao.insertConsiderOldPayment(TokenPayment(request.user.username, address, Conf.ergoAssets(assetId.toInt).assets("erg"), Conf.ergoAssets(assetId.toInt).name, request.ip, txId))
           Ok(
             s"""{
                |  "txId": "${Conf.explorerFrontUrl}/en/transactions/${txId}"

app/controllers/actions/UserAction.scala

@@ -4,12 +4,11 @@ import java.time.{LocalDateTime, ZoneOffset}
 import scala.concurrent.{ExecutionContext, Future}
 import javax.inject._
 import play.api.mvc._
-
 import models.User
-import utils.Util.{AuthException, NotVerifiedException}
-import utils.Util
+import utils.Util.{AuthException, NotValidIP, NotVerifiedException}
+import utils.{Conf, Util}
 
-class UserRequest[A](val user: User, request: Request[A]) extends WrappedRequest[A](request)
+class UserRequest[A](val user: User, val ip: String, request: Request[A]) extends WrappedRequest[A](request)
 
 class UserAction @Inject() (val parser: BodyParsers.Default)(implicit val executionContext: ExecutionContext)
   extends ActionBuilder[UserRequest, AnyContent]
@@ -25,6 +24,7 @@ class UserAction @Inject() (val parser: BodyParsers.Default)(implicit val execut
       .flatMap(DAOs._1.getUser)
     val validUser = user.getOrElse(throw AuthException())
     if (!validUser.verified) throw NotVerifiedException()
-    new UserRequest(validUser, request)
+    val ip = request.headers.get(Conf.ipField).getOrElse(throw NotValidIP())
+    new UserRequest(validUser, ip, request)
   }
 }

app/dao/PaymentTokenDAO.scala

@@ -26,9 +26,10 @@ trait PaymentTokenComponent { self: HasDatabaseConfigProvider[JdbcProfile] =>
     def type_tokens = column[String]("TYPE_TOKENS")
     def tx_id = column[String]("TXID")
     def username = column[String]("USERNAME")
+    def ip = column[String]("IP")
     def created_time = column[LocalDateTime]("CREATED_TIME", O.Default(LocalDateTime.now()))
     def done = column[Boolean]("DONE", O.Default(false))
-    def * = (username, address, erg_amount, type_tokens, tx_id, created_time, done) <> (TokenPayment.tupled, TokenPayment.unapply)
+    def * = (username, address, erg_amount, type_tokens, ip, tx_id, created_time, done) <> (TokenPayment.tupled, TokenPayment.unapply)
     def user_token = index("USER_TOKEN", (username, type_tokens), unique = true)
   }
 
@@ -38,9 +39,10 @@ trait PaymentTokenComponent { self: HasDatabaseConfigProvider[JdbcProfile] =>
     def type_tokens = column[String]("TYPE_TOKENS")
     def tx_id = column[String]("TXID")
     def username = column[String]("USERNAME")
+    def ip = column[String]("IP")
     def created_time = column[LocalDateTime]("CREATED_TIME")
     def done = column[Boolean]("DONE")
-    def * = (username, address, erg_amount, type_tokens, tx_id, created_time, done) <> (TokenPayment.tupled, TokenPayment.unapply)
+    def * = (username, address, erg_amount, type_tokens, ip, tx_id, created_time, done) <> (TokenPayment.tupled, TokenPayment.unapply)
     def user_token = index("USER_TOKEN_ARCHIVE", (username, type_tokens, created_time), unique = true)
   }
 
@@ -92,9 +94,9 @@ class PaymentTokenDAO @Inject() (protected val dbConfigProvider: DatabaseConfigP
    * @param type_tokens Type batch of assets
    * @return boolean result
    */
-  def exists(username: String, address: String, type_tokens: String): Boolean = {
+  def exists(username: String, address: String, ip: String, type_tokens: String): Boolean = {
     val res = db.run(tokenPayments.filter(payment => {
-      (payment.address === address || payment.username === username) && (payment.type_tokens === type_tokens)
+      (payment.address === address || payment.username === username || payment.ip === ip) && (payment.type_tokens === type_tokens)
     } ).exists.result)
     Await.result(res, Duration.Inf)
   }

app/models/Models.scala

@@ -8,7 +8,7 @@ import play.api.mvc.Session
 import scala.collection.mutable
 
 case class Payment(address: String, amount: Long, txid: String)
-case class TokenPayment(username: String, address: String, amount: Long, typeTokens: String, txid: String, createdTime: LocalDateTime = LocalDateTime.now(), done: Boolean = false)
+case class TokenPayment(username: String, address: String, amount: Long, typeTokens: String, ip: String, txid: String, createdTime: LocalDateTime = LocalDateTime.now(), done: Boolean = false)
 case class User(discordId: String, username: String, email: String, verified: Boolean)
 object UserObj {
   def apply(discordId: String, username: String, discriminator: String, email: String, verified: Boolean): Option[User] ={

app/utils/Conf.scala

@@ -79,6 +79,8 @@ object Conf {
   lazy val paymentMonitorThreadInterval: Long = readKey(config, "paymentMonitorThreadInterval", "86400").toLong
   lazy val thresholdDayIgnorePayments: Long = readKey(config, "thresholdDayIgnorePayments", "5").toLong
 
+  lazy val ipField: String = readKey(config, "ip-field", "cf-connecting-ip")
+
   def readKey(config: Configuration, key: String, default: String = null): String = {
     try {
       if(config.has(key)) config.getOptional[String](key).get

app/utils/CreateReward.scala

@@ -28,7 +28,7 @@ class CreateReward @Inject()(networkIObject: NetworkIObject, explorer: Explorer)
         if (proxyData._3.nonEmpty) {
           var tokens: Seq[ErgoToken] = Seq.empty
           proxyData._3.foreach( token => {
-            if (assetConfig.assets.get(token._1).isDefined) {
+            if (assetConfig.assets.contains(token._1)) {
               if ((token._2 - assetConfig.assets(token._1)) > 0)
                 tokens = tokens :+ new ErgoToken(token._1, token._2 - assetConfig.assets(token._1))
             }
@@ -66,7 +66,7 @@ class CreateReward @Inject()(networkIObject: NetworkIObject, explorer: Explorer)
         boxes :+= walletInput
         val ergCondition = totalInputValue >= (assetConfig.assets("erg") + Conf.defaultTxFee + Conf.minErg)
         val assetsCondition= assetConfig.assets.filterNot(_._1.equals("erg")).map(asset => {
-          if (totalInputAssets.get(asset._1).isDefined) totalInputAssets(asset._1) >= asset._2
+          if (totalInputAssets.contains(asset._1)) totalInputAssets(asset._1) >= asset._2
           else false
         }).reduceOption(_&&_)
         if (ergCondition && assetsCondition.getOrElse(true)) return (boxes, totalInputValue, totalInputAssets, true)

app/utils/Util.scala

@@ -34,6 +34,7 @@ object Util {
   final case class AuthException(private val message: String = "Authenticate Failed") extends Throwable(message)
   final case class NotVerifiedException(private val message: String = "Your discord account don't verified") extends Throwable(message)
   final case class DuplicateRequestException(private val message: String = s"This user has already received assets") extends Throwable(message)
+  final case class NotValidIP(private val message: String = "Your IP is not valid") extends Throwable(message)
 
   def validateAddress(address: String): Boolean = {
     try{

conf/evolutions/default/3.sql

@@ -0,0 +1,7 @@
+-- !Ups
+ALTER TABLE TOKEN_PAYMENT ADD IP VARCHAR(100) DEFAULT null;
+ALTER TABLE TOKEN_PAYMENT_ARCHIVE ADD IP VARCHAR(100) DEFAULT null;
+
+-- !Downs
+ALTER TABLE TOKEN_PAYMENT DROP IP;
+ALTER TABLE TOKEN_PAYMENT_ARCHIVE DROP IP;