Updated signUp logic to include username check in NameTransaction table

app/constants/Module.scala

@@ -43,6 +43,7 @@ object Module {
   val BLOCKCHAIN_TRANSACTION_MINT = "BLOCKCHAIN_TRANSACTION_MINT"
   val BLOCKCHAIN_TRANSACTION_NUB = "BLOCKCHAIN_TRANSACTION_NUB"
   val BLOCKCHAIN_TRANSACTION_BURN = "BLOCKCHAIN_TRANSACTION_BURN"
+  val BLOCKCHAIN_NAME_TRANSACTION = "BLOCKCHAIN_NAME_TRANSACTION"
 
   val MASTER_TRANSACTION_SESSION_TOKEN = "MASTER_TRANSACTION_SESSION_TOKEN"
   val MASTER_TRANSACTION_PUSH_NOTIFICATION_TOKEN = "MASTER_TRANSACTION_PUSH_NOTIFICATION_TOKEN"

app/constants/Response.scala

@@ -157,6 +157,9 @@ object Response {
   val NFT_ALREADY_SOLD = new Failure("NFT_ALREADY_SOLD")
   val SIGNING_FAILED = new Failure("SIGNING_FAILED")
   val TRANSACTION_NOT_FOUND = new Failure("TRANSACTION_NOT_FOUND")
+  val NAME_TRANSACTION_INSERT_FAILED = new Failure("NAME_TRANSACTION_INSERT_FAILED")
+  val NAME_TRANSACTION_UPSERT_FAILED = new Failure("NAME_TRANSACTION_INSERT_FAILED")
+  val NAME_TRANSACTION_NOT_FOUND = new Failure("NAME_TRANSACTION_NOT_FOUND")
 
   class Failure(private val response: String) {
     val message: String = PREFIX + FAILURE_PREFIX + response

app/controllers/AccountController.scala

@@ -24,6 +24,7 @@ class AccountController @Inject()(
                                    masterKeys: master.Keys,
                                    masterTransactionSessionTokens: masterTransaction.SessionTokens,
                                    masterTransactionPushNotificationTokens: masterTransaction.PushNotificationTokens,
+                                   nameTransactions: masterTransaction.NameTransactions,
                                    withUsernameToken: WithUsernameToken,
                                    withLoginActionAsync: WithLoginActionAsync,
                                    utilitiesNotification: utilities.Notification,
@@ -282,11 +283,14 @@ class AccountController @Inject()(
   }
 
   def checkUsernameAvailable(username: String): Action[AnyContent] = withoutLoginActionAsync { implicit loginState =>
-    implicit request =>
+    implicit request => {
       val verifiedMnemonicExists = masterKeys.Service.checkVerifiedKeyExists(username)
+      val usernameExists = nameTransactions.Service.findByUsername(username)
       for {
         verifiedMnemonicExists <- verifiedMnemonicExists
-      } yield if (!verifiedMnemonicExists) Ok else NoContent
+        usernameExists <- usernameExists
+      } yield if (!verifiedMnemonicExists && usernameExists.isEmpty) Ok else NoContent
+    }
   }
 
   def forgetPasswordForm(): Action[AnyContent] = withoutLoginAction { implicit request =>

app/models/masterTransaction/NameTransaction.scala

@@ -0,0 +1,105 @@
+package models.masterTransaction
+
+import play.api.Logger
+import play.api.db.slick.DatabaseConfigProvider
+import slick.jdbc.JdbcProfile
+
+import javax.inject.{Inject, Singleton}
+import scala.concurrent.{ExecutionContext, Future}
+import scala.util.{Failure, Success}
+import exceptions.BaseException
+import org.postgresql.util.PSQLException
+import play.db.NamedDatabase
+
+case class NameTransaction(username: String, email: Option[String], idString: String, isClaimed: Boolean)
+
+@Singleton
+class NameTransactions @Inject()(
+                                  @NamedDatabase("explorer")
+                                  protected val databaseConfigProvider: DatabaseConfigProvider
+                                )(implicit executionContext: ExecutionContext) {
+
+  val databaseConfig = databaseConfigProvider.get[JdbcProfile]
+  val db = databaseConfig.db
+
+  private implicit val logger: Logger = Logger(this.getClass)
+  private implicit val module: String = constants.Module.BLOCKCHAIN_NAME_TRANSACTION
+
+  import databaseConfig.profile.api._
+
+  private[models] val nameTransactionTable = TableQuery[NameTransactionTable]
+
+  case class NameTransactionSerialized(username: String, email: Option[String], idString: String, isClaimed: Boolean) {
+    def deserialize: NameTransaction = NameTransaction(username = username, email = email, idString = idString, isClaimed = isClaimed)
+  }
+
+  def serialize(nameTransaction: NameTransaction): NameTransactionSerialized =
+    NameTransactionSerialized(
+      username = nameTransaction.username,
+      email = nameTransaction.email,
+      idString = nameTransaction.idString,
+      isClaimed = nameTransaction.isClaimed
+    )
+
+  // Insert new NameTransaction
+  def add(nameTransaction: NameTransaction): Future[String] = db.run((nameTransactionTable returning nameTransactionTable.map(_.idString) += serialize(nameTransaction)).asTry).map {
+    case Success(result) => result
+    case Failure(exception) => exception match {
+      case psqlException: PSQLException => throw new BaseException(constants.Response.NAME_TRANSACTION_INSERT_FAILED, psqlException)
+    }
+  }
+
+  // Upsert (insert or update) NameTransaction
+  def upsert(nameTransaction: NameTransaction): Future[Int] = db.run(nameTransactionTable.insertOrUpdate(serialize(nameTransaction)).asTry).map {
+    case Success(result) => result
+    case Failure(exception) => exception match {
+      case psqlException: PSQLException => throw new BaseException(constants.Response.NAME_TRANSACTION_UPSERT_FAILED, psqlException)
+    }
+  }
+
+  // Fetch by idString
+  private def tryGetByIdString(idString: String): Future[NameTransactionSerialized] = db.run(nameTransactionTable.filter(_.idString === idString).result.head.asTry).map {
+    case Success(result) => result
+    case Failure(exception) => exception match {
+      case noSuchElementException: NoSuchElementException => throw new BaseException(constants.Response.NAME_TRANSACTION_NOT_FOUND, noSuchElementException)
+    }
+  }
+
+  // Fetch by username
+  private def tryGetByUsername(username: String): Future[NameTransactionSerialized] = db.run(nameTransactionTable.filter(_.username === username).result.head.asTry).map {
+    case Success(result) => result
+    case Failure(exception) => exception match {
+      case noSuchElementException: NoSuchElementException => throw new BaseException(constants.Response.NAME_TRANSACTION_NOT_FOUND, noSuchElementException)
+    }
+  }
+
+  // Get NameTransaction by idString
+  def getByIdString(idString: String): Future[Option[NameTransactionSerialized]] = db.run(nameTransactionTable.filter(_.idString === idString).result.headOption)
+
+  // Get NameTransaction by username
+  def getByUsername(username: String): Future[Option[NameTransactionSerialized]] = db.run(nameTransactionTable.filter(_.username === username).result.headOption)
+
+  private[models] class NameTransactionTable(tag: Tag) extends Table[NameTransactionSerialized](tag, "NameTransaction") {
+
+    def * = (username, email, idString, isClaimed) <> (NameTransactionSerialized.tupled, NameTransactionSerialized.unapply)
+
+    def username = column[String]("username")
+    def email = column[Option[String]]("email")
+    def idString = column[String]("idString", O.PrimaryKey)
+    def isClaimed = column[Boolean]("isClaimed")
+  }
+
+  // Service to provide additional functionality
+  object Service {
+    def tryGet(idString: String): Future[NameTransaction] = tryGetByIdString(idString).map(_.deserialize)
+
+    def tryFindByUsername(username: String): Future[NameTransaction] = tryGetByUsername(username).map(_.deserialize)
+
+    def insertOrUpdate(nameTransaction: NameTransaction): Future[Int] = upsert(nameTransaction)
+
+    def get(idString: String): Future[Option[NameTransaction]] = getByIdString(idString).map(_.map(_.deserialize))
+
+    def findByUsername(username: String): Future[Option[NameTransaction]] = getByUsername(username).map(_.map(_.deserialize))
+  }
+
+}

conf/evolutions/default/1.sql

@@ -119,6 +119,15 @@ CREATE TABLE IF NOT EXISTS MASTER_TRANSACTION."SessionToken"
     PRIMARY KEY ("accountId")
 );
 
+CREATE TABLE IF NOT EXISTS MASTER_TRANSACTION."NameTransaction"
+(
+    "username" VARCHAR NOT NULL,
+    "email" VARCHAR,
+    "idString" VARCHAR NOT NULL,
+    "isClaimed" BOOLEAN NOT NULL,
+    PRIMARY KEY ("username", "idString")
+);
+
 ALTER TABLE MASTER."Wallet"
     ADD CONSTRAINT Wallet_Account_Id FOREIGN KEY ("accountId") REFERENCES MASTER."Account" ("id");
 ALTER TABLE MASTER."NFT"
@@ -208,6 +217,7 @@ DROP TABLE IF EXISTS MASTER."Wallet" CASCADE;
 
 DROP TABLE IF EXISTS MASTER_TRANSACTION."PushNotificationToken" CASCADE;
 DROP TABLE IF EXISTS MASTER_TRANSACTION."SessionToken" CASCADE;
+DROP TABLE IF EXISTS MASTER_TRANSACTION."NameTransaction" CASCADE;
 
 DROP SCHEMA IF EXISTS MASTER CASCADE;
 DROP SCHEMA IF EXISTS MASTER_TRANSACTION CASCADE;