Credit Card Support

src/main/kotlin/core/models/UiModel.kt

@@ -8,7 +8,13 @@ enum class NotificationType(val color: Color) {
     SUCCESS(Color.Green)
 }
 
-enum class PasswordSort(val value: String) {
+data class CredentialDisplay(
+    val title: String,
+    val description: String,
+    val favorite: Boolean
+)
+
+enum class CredentialSort(val value: String) {
     NAME("Name"),
     FAVORITE("Favorite"),
     CREATED("Created"),

src/main/kotlin/core/models/criteria/CredentialSearchCriteria.kt

@@ -0,0 +1,9 @@
+package core.models.criteria
+
+import core.models.CredentialSort
+import java.util.*
+
+data class CredentialSearchCriteria(
+    val userId: UUID?,
+    val sort: CredentialSort
+)

src/main/kotlin/core/models/dto/CreditCardDto.kt

@@ -0,0 +1,14 @@
+package core.models.dto
+
+import repository.user.User
+
+data class CreditCardDto(
+    var user: User,
+    var name: String,
+    var owner: User,
+    var number: String,
+    var cvc: Int?,
+    var pin: Int?,
+    var expiryDate: String,
+    var notes: String?
+)

src/main/kotlin/di/AppModule.kt

@@ -15,6 +15,8 @@ import org.koin.dsl.module
 import org.koin.java.KoinJavaComponent
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
+import repository.creditcard.CreditCardRepository
+import repository.creditcard.impl.CreditCardRepositoryImpl
 import repository.password.PasswordRepository
 import repository.password.impl.PasswordRepositoryImpl
 import repository.user.UserRepository
@@ -55,6 +57,8 @@ val repositoryModule = module {
 
     single<PasswordRepository> { PasswordRepositoryImpl(get(), get { parametersOf(PasswordRepository::class.java) }) }
 
+    single<CreditCardRepository> { CreditCardRepositoryImpl(get(), get { parametersOf(CreditCardRepository::class.java) }) }
+
 }
 
 val viewModelModule = module {
@@ -65,9 +69,9 @@ val viewModelModule = module {
 
     factory { ForgotPasswordScreenModel(get()) }
 
-    factory { SecVaultScreenModel(get(), get()) }
+    factory { SecVaultScreenModel(get(), get(), get()) }
 
-    factory { PasswordMgntScreenModel(get(), get(), get()) }
+    factory { PasswordMgntScreenModel(get(), get(), get(), get()) }
 
 }
 

src/main/kotlin/repository/creditcard/CreditCardExposedEntity.kt

@@ -0,0 +1,43 @@
+package repository.creditcard
+
+import org.jetbrains.exposed.dao.UUIDEntity
+import org.jetbrains.exposed.dao.UUIDEntityClass
+import org.jetbrains.exposed.dao.id.EntityID
+import repository.AuditableTable
+import repository.user.User
+import repository.user.UsersTable
+import java.util.*
+
+object CreditCardTable : AuditableTable(name = "credit_cards") {
+    val user = reference("user_id", UsersTable)
+    val name = varchar("name", length = 255)
+    val owner = reference("owner_id", UsersTable)
+    val number = varchar("number", length = 255)
+    val cvc = integer("cvc").nullable()
+    val pin = integer("pin").nullable()
+    val expiryDate = varchar("expiry_date", length = 5)
+    val notes = text("notes").nullable()
+    val favorite = bool("favorite").default(false)
+    val deleted = bool("deleted").default(false)
+}
+
+class CreditCard(id: EntityID<UUID>) : UUIDEntity(id) {
+    companion object : UUIDEntityClass<CreditCard>(CreditCardTable)
+
+    var user by User referencedOn CreditCardTable.user
+    var name by CreditCardTable.name
+    var owner by User referencedOn CreditCardTable.owner
+    var number by CreditCardTable.number
+    var cvc by CreditCardTable.cvc
+    var pin by CreditCardTable.pin
+    var expiryDate by CreditCardTable.expiryDate
+    var notes by CreditCardTable.notes
+    var favorite by CreditCardTable.favorite
+    var deleted by CreditCardTable.deleted
+
+    var creationDateTime by CreditCardTable.creationDateTime
+    var createdBy by CreditCardTable.createdBy
+    var lastUpdateDateTime by CreditCardTable.lastUpdateDateTime
+    var lastUpdatedBy by CreditCardTable.lastUpdatedBy
+    var version by CreditCardTable.version
+}

src/main/kotlin/repository/creditcard/CreditCardRepository.kt

@@ -0,0 +1,14 @@
+package repository.creditcard
+
+import core.models.Result
+import core.models.criteria.CredentialSearchCriteria
+import core.models.dto.CreditCardDto
+import repository.creditcard.projection.CreditCardSummary
+
+interface CreditCardRepository {
+
+    suspend fun findSummaries(searchCriteria: CredentialSearchCriteria): Result<List<CreditCardSummary>>
+
+    suspend fun save(creditCardDto: CreditCardDto): Result<Boolean>
+
+}

src/main/kotlin/repository/creditcard/impl/CreditCardRepositoryImpl.kt

@@ -0,0 +1,97 @@
+package repository.creditcard.impl
+
+import core.models.CredentialSort
+import core.models.Result
+import core.models.criteria.CredentialSearchCriteria
+import core.models.dto.CreditCardDto
+import kotlinx.coroutines.delay
+import org.jetbrains.exposed.sql.Database
+import org.jetbrains.exposed.sql.Expression
+import org.jetbrains.exposed.sql.SortOrder
+import org.jetbrains.exposed.sql.andWhere
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.slf4j.Logger
+import repository.common.errors.DatabaseError
+import repository.creditcard.CreditCard
+import repository.creditcard.CreditCardRepository
+import repository.creditcard.CreditCardTable
+import repository.creditcard.projection.CreditCardSummary
+
+class CreditCardRepositoryImpl(
+    private val db: Database,
+    private val logger: Logger
+) : CreditCardRepository {
+
+    override suspend fun findSummaries(searchCriteria: CredentialSearchCriteria): Result<List<CreditCardSummary>> {
+        delay(550)
+        return try {
+            return transaction(db) {
+                val query = CreditCardTable.select(
+                    listOf(
+                        CreditCardTable.id,
+                        CreditCardTable.name,
+                        CreditCardTable.number,
+                        CreditCardTable.favorite
+                    )
+                )
+
+                searchCriteria.userId?.let {
+                    query.andWhere { CreditCardTable.user eq it }
+                }
+
+                query.orderBy(toSort(searchCriteria.sort), toOrder(searchCriteria.sort)).map { resultRow ->
+                    CreditCardSummary(
+                        id = resultRow[CreditCardTable.id].value,
+                        name = resultRow[CreditCardTable.name],
+                        number = resultRow[CreditCardTable.number],
+                        favorite = resultRow[CreditCardTable.favorite]
+                    )
+                }
+            }.let { Result.Success(it) }
+        } catch (e: Exception) {
+            logger.error(e.message, e)
+            Result.Error(DatabaseError.fromException(e).extractMessage())
+        }
+    }
+
+    override suspend fun save(creditCardDto: CreditCardDto): Result<Boolean> {
+        return try {
+            return transaction(db) {
+                CreditCard.new {
+                    this.user = creditCardDto.user
+                    this.expiryDate = creditCardDto.expiryDate
+                    this.number = creditCardDto.number
+                    this.cvc = creditCardDto.cvc
+                    this.pin = creditCardDto.pin
+                    this.notes = creditCardDto.notes
+                    this.owner = creditCardDto.owner
+                    this.name = creditCardDto.name
+                    this.createdBy = creditCardDto.user.userName
+                    this.lastUpdatedBy = creditCardDto.user.userName
+                }
+            }.let {
+                Result.Success(true)
+            }
+        } catch (e: Exception) {
+            logger.error(e.message, e)
+            Result.Error(DatabaseError.fromException(e).extractMessage())
+        }
+    }
+
+    private fun toSort(sort: CredentialSort): Expression<*> {
+        return when (sort) {
+            CredentialSort.NAME -> CreditCardTable.name
+            CredentialSort.CREATED -> CreditCardTable.createdBy
+            CredentialSort.FAVORITE -> CreditCardTable.favorite
+        }
+    }
+
+    private fun toOrder(sort: CredentialSort): SortOrder {
+        return when (sort) {
+            CredentialSort.NAME -> SortOrder.ASC
+            CredentialSort.CREATED -> SortOrder.ASC
+            CredentialSort.FAVORITE -> SortOrder.DESC
+        }
+    }
+
+}

src/main/kotlin/repository/creditcard/projection/CreditCardSummary.kt

@@ -0,0 +1,10 @@
+package repository.creditcard.projection
+
+import java.util.*
+
+data class CreditCardSummary(
+    val id: UUID,
+    val name: String,
+    val number: String,
+    val favorite: Boolean
+)

src/main/kotlin/repository/password/PasswordRepository.kt

@@ -1,13 +1,13 @@
 package repository.password
 
 import core.models.Result
-import core.models.criteria.PasswordSearchCriteria
+import core.models.criteria.CredentialSearchCriteria
 import core.models.dto.PasswordDto
 import repository.password.projection.PasswordSummary
 
 interface PasswordRepository {
 
-    suspend fun findSummaries(searchCriteria: PasswordSearchCriteria): Result<List<PasswordSummary>>
+    suspend fun findSummaries(searchCriteria: CredentialSearchCriteria): Result<List<PasswordSummary>>
 
     suspend fun save(password: PasswordDto): Result<Boolean>
 

src/main/kotlin/repository/password/impl/PasswordRepositoryImpl.kt

@@ -1,8 +1,8 @@
 package repository.password.impl
 
-import core.models.PasswordSort
+import core.models.CredentialSort
 import core.models.Result
-import core.models.criteria.PasswordSearchCriteria
+import core.models.criteria.CredentialSearchCriteria
 import core.models.dto.PasswordDto
 import kotlinx.coroutines.delay
 import org.jetbrains.exposed.sql.Database
@@ -23,7 +23,7 @@ class PasswordRepositoryImpl(
     private val logger: Logger
 ) : PasswordRepository {
 
-    override suspend fun findSummaries(searchCriteria: PasswordSearchCriteria): Result<List<PasswordSummary>> {
+    override suspend fun findSummaries(searchCriteria: CredentialSearchCriteria): Result<List<PasswordSummary>> {
         delay(550)
         return try {
             return transaction(db) {
@@ -81,19 +81,19 @@ class PasswordRepositoryImpl(
         }
     }
 
-    private fun toSort(sort: PasswordSort): Expression<*> {
+    private fun toSort(sort: CredentialSort): Expression<*> {
         return when (sort) {
-            PasswordSort.NAME -> PasswordsTable.name
-            PasswordSort.CREATED -> PasswordsTable.createdBy
-            PasswordSort.FAVORITE -> PasswordsTable.favorite
+            CredentialSort.NAME -> PasswordsTable.name
+            CredentialSort.CREATED -> PasswordsTable.createdBy
+            CredentialSort.FAVORITE -> PasswordsTable.favorite
         }
     }
 
-    private fun toOrder(sort: PasswordSort): SortOrder {
+    private fun toOrder(sort: CredentialSort): SortOrder {
         return when (sort) {
-            PasswordSort.NAME -> SortOrder.ASC
-            PasswordSort.CREATED -> SortOrder.ASC
-            PasswordSort.FAVORITE -> SortOrder.DESC
+            CredentialSort.NAME -> SortOrder.ASC
+            CredentialSort.CREATED -> SortOrder.ASC
+            CredentialSort.FAVORITE -> SortOrder.DESC
         }
     }