126 lines
4.8 KiB
Kotlin
126 lines
4.8 KiB
Kotlin
package space.luminic.finance.services
|
|
|
|
import org.springframework.stereotype.Service
|
|
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(
|
|
private val spaceService: SpaceService,
|
|
private val categoryService: CategoryService,
|
|
private val transactionRepo: TransactionRepo,
|
|
private val authService: AuthService,
|
|
private val categorizeService: CategorizeService,
|
|
) : TransactionService {
|
|
override fun getTransactions(
|
|
spaceId: Int,
|
|
filter: TransactionService.TransactionsFilter,
|
|
sortBy: String,
|
|
sortDirection: String
|
|
): List<Transaction> {
|
|
val transactions = transactionRepo.findAllBySpaceId(spaceId, filter)
|
|
return transactions
|
|
}
|
|
|
|
override fun getTransaction(
|
|
spaceId: Int,
|
|
transactionId: Int
|
|
): Transaction {
|
|
spaceService.getSpace(spaceId, null)
|
|
return transactionRepo.findBySpaceIdAndId(spaceId, transactionId)
|
|
?: throw NotFoundException("Transaction with id $transactionId not found")
|
|
}
|
|
|
|
override fun createTransaction(
|
|
spaceId: Int,
|
|
transaction: TransactionDTO.CreateTransactionDTO
|
|
): Int {
|
|
val userId = authService.getSecurityUserId()
|
|
val space = spaceService.getSpace(spaceId, null)
|
|
|
|
val category = transaction.categoryId?.let { categoryService.getCategory(spaceId, it) }
|
|
val transaction = 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,
|
|
)
|
|
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, null)
|
|
val existingTransaction = getTransaction(space.id!!, transactionId)
|
|
val newCategory = transaction.categoryId?.let { categoryService.getCategory(spaceId, it) }
|
|
val updatedTransaction = Transaction(
|
|
id = existingTransaction.id,
|
|
space = existingTransaction.space,
|
|
parent = existingTransaction.parent,
|
|
type = transaction.type,
|
|
kind = transaction.kind,
|
|
category = newCategory,
|
|
comment = transaction.comment,
|
|
amount = transaction.amount,
|
|
fees = transaction.fees,
|
|
date = transaction.date,
|
|
isDeleted = existingTransaction.isDeleted,
|
|
isDone = transaction.isDone,
|
|
createdBy = existingTransaction.createdBy,
|
|
createdAt = existingTransaction.createdAt,
|
|
tgChatId = existingTransaction.tgChatId,
|
|
tgMessageId = existingTransaction.tgMessageId,
|
|
)
|
|
if ((existingTransaction.category == null && updatedTransaction.category != null) || (existingTransaction.category?.id != updatedTransaction.category?.id)) {
|
|
categorizeService.notifyThatCategorySelected(updatedTransaction)
|
|
}
|
|
|
|
return transactionRepo.update(updatedTransaction)
|
|
}
|
|
|
|
override fun deleteTransaction(spaceId: Int, transactionId: Int) {
|
|
val space = spaceService.getSpace(spaceId, null)
|
|
getTransaction(space.id!!, transactionId)
|
|
transactionRepo.delete(transactionId)
|
|
}
|
|
|
|
override fun deleteByRecurrentId(spaceId: Int, recurrentId: Int) {
|
|
TODO("Not yet implemented")
|
|
}
|
|
|
|
} |