recurrents

src/main/kotlin/space/luminic/finance/services/TransactionServiceImpl.kt

@@ -5,6 +5,7 @@ import space.luminic.finance.dtos.TransactionDTO
 import space.luminic.finance.models.NotFoundException
 import space.luminic.finance.models.Transaction
 import space.luminic.finance.repos.TransactionRepo
+import space.luminic.finance.services.gpt.CategorizeService
 
 @Service
 class TransactionServiceImpl(
@@ -12,6 +13,7 @@ class TransactionServiceImpl(
     private val categoryService: CategoryService,
     private val transactionRepo: TransactionRepo,
     private val authService: AuthService,
+    private val categorizeService: CategorizeService,
 ) : TransactionService {
     override fun getTransactions(
         spaceId: Int,
@@ -19,14 +21,15 @@ class TransactionServiceImpl(
         sortBy: String,
         sortDirection: String
     ): List<Transaction> {
-        return transactionRepo.findAllBySpaceId(spaceId)
+        val transactions = transactionRepo.findAllBySpaceId(spaceId)
+        return transactions
     }
 
     override fun getTransaction(
         spaceId: Int,
         transactionId: Int
     ): Transaction {
-        spaceService.getSpace(spaceId)
+        spaceService.getSpace(spaceId, null)
         return transactionRepo.findBySpaceIdAndId(spaceId, transactionId)
             ?: throw NotFoundException("Transaction with id $transactionId not found")
     }
@@ -36,8 +39,9 @@ class TransactionServiceImpl(
         transaction: TransactionDTO.CreateTransactionDTO
     ): Int {
         val userId = authService.getSecurityUserId()
-        val space = spaceService.getSpace(spaceId)
-        val category = categoryService.getCategory(spaceId, transaction.categoryId)
+        val space = spaceService.getSpace(spaceId, null)
+
+        val category = transaction.categoryId?.let { categoryService.getCategory(spaceId, it) }
         val transaction = Transaction(
             space = space,
             type = transaction.type,
@@ -47,26 +51,43 @@ class TransactionServiceImpl(
             amount = transaction.amount,
             fees = transaction.fees,
             date = transaction.date,
+            recurrentId = transaction.recurrentId,
         )
         return transactionRepo.create(transaction, userId)
     }
 
+    override fun batchCreate(spaceId: Int, transactions: List<TransactionDTO.CreateTransactionDTO>, createdById: Int?) {
+        val userId = createdById ?: authService.getSecurityUserId()
+        val space = spaceService.getSpace(spaceId, userId)
+        val transactionsToCreate = mutableListOf<Transaction>()
+        transactions.forEach { transaction ->
+            val category = transaction.categoryId?.let { categoryService.getCategory(spaceId, it) }
+            transactionsToCreate.add(
+                Transaction(
+                    space = space,
+                    type = transaction.type,
+                    kind = transaction.kind,
+                    category = category,
+                    comment = transaction.comment,
+                    amount = transaction.amount,
+                    fees = transaction.fees,
+                    date = transaction.date,
+                    recurrentId = transaction.recurrentId,
+                )
+            )
+        }
+        transactionRepo.createBatch(transactionsToCreate, userId)
+
+    }
+
     override fun updateTransaction(
         spaceId: Int,
         transactionId: Int,
         transaction: TransactionDTO.UpdateTransactionDTO
     ): Int {
-        val space = spaceService.getSpace(spaceId)
+        val space = spaceService.getSpace(spaceId, null)
         val existingTransaction = getTransaction(space.id!!, transactionId)
-        val newCategory = categoryService.getCategory(spaceId, transaction.categoryId)
-//        val id: Int,
-//        val type: TransactionType = TransactionType.EXPENSE,
-//        val kind: TransactionKind = TransactionKind.INSTANT,
-//        val category: Int,
-//        val comment: String,
-//        val amount: BigDecimal,
-//        val fees: BigDecimal = BigDecimal.ZERO,
-//        val date: Instant
+        val newCategory = transaction.categoryId?.let { categoryService.getCategory(spaceId, it) }
         val updatedTransaction = Transaction(
             id = existingTransaction.id,
             space = existingTransaction.space,
@@ -81,16 +102,24 @@ class TransactionServiceImpl(
             isDeleted = existingTransaction.isDeleted,
             isDone = transaction.isDone,
             createdBy = existingTransaction.createdBy,
-            createdAt = existingTransaction.createdAt
-
+            createdAt = existingTransaction.createdAt,
+            tgChatId = existingTransaction.tgChatId,
+            tgMessageId = existingTransaction.tgMessageId,
         )
+        if (existingTransaction.category == null && updatedTransaction.category != null) {
+            categorizeService.notifyThatCategorySelected(updatedTransaction)
+        }
         return transactionRepo.update(updatedTransaction)
     }
 
     override fun deleteTransaction(spaceId: Int, transactionId: Int) {
-        val space = spaceService.getSpace(spaceId)
+        val space = spaceService.getSpace(spaceId, null)
         getTransaction(space.id!!, transactionId)
         transactionRepo.delete(transactionId)
     }
 
+    override fun deleteByRecurrentId(spaceId: Int, recurrentId: Int) {
+        TODO("Not yet implemented")
+    }
+
 }