package api import ( "encoding/json" "fmt" "io" "math" "sort" "strings" "time" orderedmap "github.com/wk8/go-ordered-map/v2" "github.com/mayswind/ezbookkeeping/pkg/converters" "github.com/mayswind/ezbookkeeping/pkg/converters/converter" "github.com/mayswind/ezbookkeeping/pkg/converters/datatable" "github.com/mayswind/ezbookkeeping/pkg/core" "github.com/mayswind/ezbookkeeping/pkg/duplicatechecker" "github.com/mayswind/ezbookkeeping/pkg/errs" "github.com/mayswind/ezbookkeeping/pkg/log" "github.com/mayswind/ezbookkeeping/pkg/models" "github.com/mayswind/ezbookkeeping/pkg/services" "github.com/mayswind/ezbookkeeping/pkg/settings" "github.com/mayswind/ezbookkeeping/pkg/utils" ) const pageCountForAccountStatement = 1000 const pageCountForMovingAccountTransactions = 1000 // TransactionsApi represents transaction api type TransactionsApi struct { ApiUsingConfig ApiUsingDuplicateChecker transactions *services.TransactionService transactionCategories *services.TransactionCategoryService transactionTags *services.TransactionTagService transactionPictures *services.TransactionPictureService accounts *services.AccountService users *services.UserService } // Initialize a transaction api singleton instance var ( Transactions = &TransactionsApi{ ApiUsingConfig: ApiUsingConfig{ container: settings.Container, }, ApiUsingDuplicateChecker: ApiUsingDuplicateChecker{ ApiUsingConfig: ApiUsingConfig{ container: settings.Container, }, container: duplicatechecker.Container, }, transactions: services.Transactions, transactionCategories: services.TransactionCategories, transactionTags: services.TransactionTags, transactionPictures: services.TransactionPictures, accounts: services.Accounts, users: services.Users, } ) // TransactionCountHandler returns transaction total count of current user func (a *TransactionsApi) TransactionCountHandler(c *core.WebContext) (any, *errs.Error) { var transactionCountReq models.TransactionCountRequest err := c.ShouldBindQuery(&transactionCountReq) if err != nil { log.Warnf(c, "[transactions.TransactionCountHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } uid := c.GetCurrentUid() allAccountIds, err := a.accounts.GetAccountOrSubAccountIds(c, transactionCountReq.AccountIds, uid) if err != nil { log.Warnf(c, "[transactions.TransactionCountHandler] get account error, because %s", err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allCategoryIds, err := a.transactionCategories.GetCategoryOrSubCategoryIds(c, transactionCountReq.CategoryIds, uid) if err != nil { log.Warnf(c, "[transactions.TransactionCountHandler] get transaction category error, because %s", err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } noTags := transactionCountReq.TagFilter == models.TransactionNoTagFilterValue var tagFilters []*models.TransactionTagFilter if !noTags { tagFilters, err = models.ParseTransactionTagFilter(transactionCountReq.TagFilter) if err != nil { log.Warnf(c, "[transactions.TransactionCountHandler] parse transaction filters error, because %s", err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } } totalCount, err := a.transactions.GetTransactionCount(c, uid, transactionCountReq.MaxTime, transactionCountReq.MinTime, transactionCountReq.Type, allCategoryIds, allAccountIds, tagFilters, noTags, transactionCountReq.AmountFilter, transactionCountReq.Keyword, transactionCountReq.MustHavePictures) if err != nil { log.Errorf(c, "[transactions.TransactionCountHandler] failed to get transaction count for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } countResp := &models.TransactionCountResponse{ TotalCount: totalCount, } return countResp, nil } // TransactionListHandler returns transaction list of current user func (a *TransactionsApi) TransactionListHandler(c *core.WebContext) (any, *errs.Error) { var transactionListReq models.TransactionListByMaxTimeRequest err := c.ShouldBindQuery(&transactionListReq) if err != nil { log.Warnf(c, "[transactions.TransactionListHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionListHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } uid := c.GetCurrentUid() user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionListHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } allAccountIds, err := a.accounts.GetAccountOrSubAccountIds(c, transactionListReq.AccountIds, uid) if err != nil { log.Warnf(c, "[transactions.TransactionListHandler] get account error, because %s", err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allCategoryIds, err := a.transactionCategories.GetCategoryOrSubCategoryIds(c, transactionListReq.CategoryIds, uid) if err != nil { log.Warnf(c, "[transactions.TransactionListHandler] get transaction category error, because %s", err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } noTags := transactionListReq.TagFilter == models.TransactionNoTagFilterValue var tagFilters []*models.TransactionTagFilter if !noTags { tagFilters, err = models.ParseTransactionTagFilter(transactionListReq.TagFilter) if err != nil { log.Warnf(c, "[transactions.TransactionListHandler] parse transaction tag filters error, because %s", err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } } var totalCount int64 if transactionListReq.WithCount { totalCount, err = a.transactions.GetTransactionCount(c, uid, transactionListReq.MaxTime, transactionListReq.MinTime, transactionListReq.Type, allCategoryIds, allAccountIds, tagFilters, noTags, transactionListReq.AmountFilter, transactionListReq.Keyword, transactionListReq.MustHavePictures) if err != nil { log.Errorf(c, "[transactions.TransactionListHandler] failed to get transaction count for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } } transactions, err := a.transactions.GetTransactionsByMaxTime(c, uid, transactionListReq.MaxTime, transactionListReq.MinTime, transactionListReq.Type, allCategoryIds, allAccountIds, tagFilters, noTags, transactionListReq.AmountFilter, transactionListReq.Keyword, transactionListReq.MustHavePictures, transactionListReq.Page, transactionListReq.Count, true, true) if err != nil { log.Errorf(c, "[transactions.TransactionListHandler] failed to get transactions earlier than \"%d\" for user \"uid:%d\", because %s", transactionListReq.MaxTime, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } hasMore := false var nextTimeSequenceId *int64 if len(transactions) > int(transactionListReq.Count) { hasMore = true nextTimeSequenceId = &transactions[transactionListReq.Count].TransactionTime transactions = transactions[:transactionListReq.Count] } accountMap, categoryMap, tagMap, allTransactionTagIds, pictureInfoMap, err := a.getTransactionEssentialDataByTransactionIds(c, user, transactions, transactionListReq.WithPictures, transactionListReq.TrimCategory, transactionListReq.TrimTag) if err != nil { log.Errorf(c, "[transactions.TransactionListHandler] failed to get essential data for assembling transaction result for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } transactions = a.filterTransactions(c, uid, transactions, accountMap) transactionResult, err := a.getTransactionResponseListResult(c, user, transactions, accountMap, categoryMap, tagMap, allTransactionTagIds, pictureInfoMap, clientTimezone, transactionListReq.WithPictures, transactionListReq.TrimAccount, transactionListReq.TrimCategory, transactionListReq.TrimTag) if err != nil { log.Errorf(c, "[transactions.TransactionListHandler] failed to assemble transaction result for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } transactionResps := &models.TransactionInfoPageWrapperResponse{ Items: transactionResult, } if hasMore { transactionResps.NextTimeSequenceId = nextTimeSequenceId } if transactionListReq.WithCount { transactionResps.TotalCount = &totalCount } return transactionResps, nil } // TransactionMonthListHandler returns all transaction list of current user by month func (a *TransactionsApi) TransactionMonthListHandler(c *core.WebContext) (any, *errs.Error) { var transactionListReq models.TransactionListInMonthByPageRequest err := c.ShouldBindQuery(&transactionListReq) if err != nil { log.Warnf(c, "[transactions.TransactionMonthListHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionMonthListHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } uid := c.GetCurrentUid() user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionMonthListHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } allAccountIds, err := a.accounts.GetAccountOrSubAccountIds(c, transactionListReq.AccountIds, uid) if err != nil { log.Warnf(c, "[transactions.TransactionMonthListHandler] get account error, because %s", err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allCategoryIds, err := a.transactionCategories.GetCategoryOrSubCategoryIds(c, transactionListReq.CategoryIds, uid) if err != nil { log.Warnf(c, "[transactions.TransactionMonthListHandler] get transaction category error, because %s", err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } noTags := transactionListReq.TagFilter == models.TransactionNoTagFilterValue var tagFilters []*models.TransactionTagFilter if !noTags { tagFilters, err = models.ParseTransactionTagFilter(transactionListReq.TagFilter) if err != nil { log.Warnf(c, "[transactions.TransactionMonthListHandler] parse transaction tag filters error, because %s", err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } } transactions, err := a.transactions.GetTransactionsInMonthByPage(c, uid, transactionListReq.Year, transactionListReq.Month, transactionListReq.Type, allCategoryIds, allAccountIds, tagFilters, noTags, transactionListReq.AmountFilter, transactionListReq.Keyword, transactionListReq.MustHavePictures) if err != nil { log.Errorf(c, "[transactions.TransactionMonthListHandler] failed to get transactions in month \"%d-%d\" for user \"uid:%d\", because %s", transactionListReq.Year, transactionListReq.Month, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } accountMap, categoryMap, tagMap, allTransactionTagIds, pictureInfoMap, err := a.getTransactionEssentialDataByTransactionIds(c, user, transactions, transactionListReq.WithPictures, transactionListReq.TrimCategory, transactionListReq.TrimTag) if err != nil { log.Errorf(c, "[transactions.TransactionMonthListHandler] failed to get essential data for assembling transaction result for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } transactions = a.filterTransactions(c, uid, transactions, accountMap) transactionResult, err := a.getTransactionResponseListResult(c, user, transactions, accountMap, categoryMap, tagMap, allTransactionTagIds, pictureInfoMap, clientTimezone, transactionListReq.WithPictures, transactionListReq.TrimAccount, transactionListReq.TrimCategory, transactionListReq.TrimTag) if err != nil { log.Errorf(c, "[transactions.TransactionMonthListHandler] failed to assemble transaction result for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } transactionResps := &models.TransactionInfoPageWrapperResponse2{ Items: transactionResult, TotalCount: int64(transactionResult.Len()), } return transactionResps, nil } // TransactionListAllHandler returns all transaction list of current user func (a *TransactionsApi) TransactionListAllHandler(c *core.WebContext) (any, *errs.Error) { var transactionAllListReq models.TransactionAllListRequest err := c.ShouldBindQuery(&transactionAllListReq) if err != nil { log.Warnf(c, "[transactions.TransactionListAllHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionListAllHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } uid := c.GetCurrentUid() user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionListAllHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } allAccountIds, err := a.accounts.GetAccountOrSubAccountIds(c, transactionAllListReq.AccountIds, uid) if err != nil { log.Warnf(c, "[transactions.TransactionListAllHandler] get account error, because %s", err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allCategoryIds, err := a.transactionCategories.GetCategoryOrSubCategoryIds(c, transactionAllListReq.CategoryIds, uid) if err != nil { log.Warnf(c, "[transactions.TransactionListAllHandler] get transaction category error, because %s", err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } noTags := transactionAllListReq.TagFilter == models.TransactionNoTagFilterValue var tagFilters []*models.TransactionTagFilter if !noTags { tagFilters, err = models.ParseTransactionTagFilter(transactionAllListReq.TagFilter) if err != nil { log.Warnf(c, "[transactions.TransactionListAllHandler] parse transaction tag filters error, because %s", err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } } maxTransactionTime := int64(math.MaxInt64) minTransactionTime := int64(0) if transactionAllListReq.EndTime > 0 { maxTransactionTime = utils.GetMaxTransactionTimeFromUnixTime(transactionAllListReq.EndTime) } if transactionAllListReq.StartTime > 0 { minTransactionTime = utils.GetMinTransactionTimeFromUnixTime(transactionAllListReq.StartTime) } allTransactions, err := a.transactions.GetAllSpecifiedTransactions(c, uid, maxTransactionTime, minTransactionTime, transactionAllListReq.Type, allCategoryIds, allAccountIds, tagFilters, noTags, transactionAllListReq.AmountFilter, transactionAllListReq.Keyword, transactionAllListReq.MustHavePictures, pageCountForDataExport, true) if err != nil { log.Errorf(c, "[transactions.TransactionListAllHandler] failed to get all transactions for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } var accountMap map[int64]*models.Account var categoryMap map[int64]*models.TransactionCategory var tagMap map[int64]*models.TransactionTag var allTransactionTagIds map[int64][]int64 var pictureInfoMap map[int64][]*models.TransactionPictureInfo if minTransactionTime == 0 && maxTransactionTime == math.MaxInt64 && len(allCategoryIds) < 1 && len(allAccountIds) < 1 && len(tagFilters) < 1 && transactionAllListReq.AmountFilter == "" && transactionAllListReq.Keyword == "" { accountMap, categoryMap, tagMap, allTransactionTagIds, pictureInfoMap, err = a.getTransactionAllEssentialData(c, user, transactionAllListReq.WithPictures, transactionAllListReq.TrimCategory, transactionAllListReq.TrimTag) } else { accountMap, categoryMap, tagMap, allTransactionTagIds, pictureInfoMap, err = a.getTransactionEssentialDataByTransactionIds(c, user, allTransactions, transactionAllListReq.WithPictures, transactionAllListReq.TrimCategory, transactionAllListReq.TrimTag) } if err != nil { log.Errorf(c, "[transactions.TransactionListAllHandler] failed to get essential data for assembling transaction result for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allTransactions = a.filterTransactions(c, uid, allTransactions, accountMap) transactionResult, err := a.getTransactionResponseListResult(c, user, allTransactions, accountMap, categoryMap, tagMap, allTransactionTagIds, pictureInfoMap, clientTimezone, transactionAllListReq.WithPictures, transactionAllListReq.TrimAccount, transactionAllListReq.TrimCategory, transactionAllListReq.TrimTag) if err != nil { log.Errorf(c, "[transactions.TransactionListAllHandler] failed to assemble transaction result for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } return transactionResult, nil } // TransactionReconciliationStatementHandler returns transaction reconciliation statement list of current user func (a *TransactionsApi) TransactionReconciliationStatementHandler(c *core.WebContext) (any, *errs.Error) { var reconciliationStatementRequest models.TransactionReconciliationStatementRequest err := c.ShouldBindQuery(&reconciliationStatementRequest) if err != nil { log.Warnf(c, "[transactions.TransactionReconciliationStatementHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionReconciliationStatementHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } uid := c.GetCurrentUid() user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionReconciliationStatementHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } account, err := a.accounts.GetAccountByAccountId(c, uid, reconciliationStatementRequest.AccountId) if err != nil { log.Errorf(c, "[transactions.TransactionReconciliationStatementHandler] failed to get account \"id:%d\" for user \"uid:%d\", because %s", reconciliationStatementRequest.AccountId, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } if account.Type != models.ACCOUNT_TYPE_SINGLE_ACCOUNT { log.Errorf(c, "[transactions.TransactionReconciliationStatementHandler] account \"id:%d\" for user \"uid:%d\" is not a single account", reconciliationStatementRequest.AccountId, uid) return nil, errs.ErrAccountTypeInvalid } maxTransactionTime := int64(0) if reconciliationStatementRequest.EndTime > 0 { maxTransactionTime = utils.GetMaxTransactionTimeFromUnixTime(reconciliationStatementRequest.EndTime) } minTransactionTime := int64(0) if reconciliationStatementRequest.StartTime > 0 { minTransactionTime = utils.GetMinTransactionTimeFromUnixTime(reconciliationStatementRequest.StartTime) } transactionsWithAccountBalance, totalInflows, totalOutflows, openingBalance, closingBalance, err := a.transactions.GetAllTransactionsInOneAccountWithAccountBalanceByMaxTime(c, uid, pageCountForAccountStatement, maxTransactionTime, minTransactionTime, reconciliationStatementRequest.AccountId, account.Category) if err != nil { log.Errorf(c, "[transactions.TransactionReconciliationStatementHandler] failed to get transactions from \"%d\" to \"%d\" for user \"uid:%d\", because %s", reconciliationStatementRequest.StartTime, reconciliationStatementRequest.EndTime, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } transactions := make([]*models.Transaction, len(transactionsWithAccountBalance)) transactionAccountBalanceMap := make(map[int64]*models.TransactionWithAccountBalance, len(transactionsWithAccountBalance)) for i := 0; i < len(transactionsWithAccountBalance); i++ { transactionWithBalance := transactionsWithAccountBalance[i] transactions[i] = transactionWithBalance.Transaction transactionAccountBalanceMap[transactionWithBalance.TransactionId] = transactionWithBalance transactionAccountBalanceMap[transactionWithBalance.RelatedId] = transactionWithBalance } allAccountIds := make([]int64, 0, len(transactions)*2) for i := 0; i < len(transactions); i++ { allAccountIds = append(allAccountIds, transactions[i].AccountId) if transactions[i].Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN || transactions[i].Type == models.TRANSACTION_DB_TYPE_TRANSFER_OUT { allAccountIds = append(allAccountIds, transactions[i].RelatedAccountId) } } allAccounts, err := a.accounts.GetAccountsByAccountIds(c, uid, utils.ToUniqueInt64Slice(allAccountIds)) if err != nil { log.Errorf(c, "[transactions.TransactionReconciliationStatementHandler] failed to get essential data for assembling transaction result for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } transactionResult, err := a.getTransactionResponseListResult(c, user, transactions, allAccounts, nil, nil, nil, nil, clientTimezone, false, true, true, true) if err != nil { log.Errorf(c, "[transactions.TransactionReconciliationStatementHandler] failed to assemble transaction result for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } responseItems := make([]*models.TransactionReconciliationStatementResponseItem, len(transactionResult)) for i := 0; i < len(transactionResult); i++ { transactionResult := transactionResult[i] accountOpeningBalance := int64(0) accountClosingBalance := int64(0) if transactionWithBalance, exists := transactionAccountBalanceMap[transactionResult.Id]; exists { accountOpeningBalance = transactionWithBalance.AccountOpeningBalance accountClosingBalance = transactionWithBalance.AccountClosingBalance } else { log.Warnf(c, "[transactions.TransactionReconciliationStatementHandler] missing account balance for transaction \"id:%d\" of user \"uid:%d\"", transactionResult.Id, uid) } responseItems[i] = &models.TransactionReconciliationStatementResponseItem{ TransactionInfoResponse: transactionResult, AccountOpeningBalance: accountOpeningBalance, AccountClosingBalance: accountClosingBalance, } } reconciliationStatementResp := &models.TransactionReconciliationStatementResponse{ Transactions: responseItems, TotalInflows: totalInflows, TotalOutflows: totalOutflows, OpeningBalance: openingBalance, ClosingBalance: closingBalance, } return reconciliationStatementResp, nil } // TransactionStatisticsHandler returns transaction statistics of current user func (a *TransactionsApi) TransactionStatisticsHandler(c *core.WebContext) (any, *errs.Error) { var statisticReq models.TransactionStatisticRequest err := c.ShouldBindQuery(&statisticReq) if err != nil { log.Warnf(c, "[transactions.TransactionStatisticsHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionStatisticsHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } noTags := statisticReq.TagFilter == models.TransactionNoTagFilterValue var tagFilters []*models.TransactionTagFilter if !noTags { tagFilters, err = models.ParseTransactionTagFilter(statisticReq.TagFilter) if err != nil { log.Warnf(c, "[transactions.TransactionStatisticsHandler] parse transaction tag filters error, because %s", err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } } uid := c.GetCurrentUid() totalAmounts, err := a.transactions.GetAccountsAndCategoriesTotalInflowAndOutflow(c, uid, statisticReq.StartTime, statisticReq.EndTime, tagFilters, noTags, statisticReq.Keyword, clientTimezone, statisticReq.UseTransactionTimezone) if err != nil { log.Errorf(c, "[transactions.TransactionStatisticsHandler] failed to get accounts and categories total income and expense for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } statisticResp := &models.TransactionStatisticResponse{ StartTime: statisticReq.StartTime, EndTime: statisticReq.EndTime, } statisticResp.Items = make([]*models.TransactionStatisticResponseItem, len(totalAmounts)) for i := 0; i < len(totalAmounts); i++ { totalAmountItem := totalAmounts[i] statisticResp.Items[i] = &models.TransactionStatisticResponseItem{ CategoryId: totalAmountItem.CategoryId, AccountId: totalAmountItem.AccountId, TotalAmount: totalAmountItem.Amount, } if totalAmountItem.Type == models.TRANSACTION_DB_TYPE_TRANSFER_OUT || totalAmountItem.Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN { statisticResp.Items[i].RelatedAccountId = totalAmountItem.RelatedAccountId statisticResp.Items[i].RelatedAccountType, _ = totalAmountItem.Type.ToTransactionRelatedAccountType() } } return statisticResp, nil } // TransactionStatisticsTrendsHandler returns transaction statistics trends of current user func (a *TransactionsApi) TransactionStatisticsTrendsHandler(c *core.WebContext) (any, *errs.Error) { var statisticTrendsReq models.TransactionStatisticTrendsRequest err := c.ShouldBindQuery(&statisticTrendsReq) if err != nil { log.Warnf(c, "[transactions.TransactionStatisticsTrendsHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionStatisticsTrendsHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } startYear, startMonth, endYear, endMonth, err := statisticTrendsReq.GetNumericYearMonthRange() if err != nil { log.Warnf(c, "[transactions.TransactionStatisticsTrendsHandler] cannot parse year month, because %s", err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } noTags := statisticTrendsReq.TagFilter == models.TransactionNoTagFilterValue var tagFilters []*models.TransactionTagFilter if !noTags { tagFilters, err = models.ParseTransactionTagFilter(statisticTrendsReq.TagFilter) if err != nil { log.Warnf(c, "[transactions.TransactionStatisticsTrendsHandler] parse transaction tag filters error, because %s", err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } } uid := c.GetCurrentUid() allMonthlyTotalAmounts, err := a.transactions.GetAccountsAndCategoriesMonthlyInflowAndOutflow(c, uid, startYear, startMonth, endYear, endMonth, tagFilters, noTags, statisticTrendsReq.Keyword, clientTimezone, statisticTrendsReq.UseTransactionTimezone) if err != nil { log.Errorf(c, "[transactions.TransactionStatisticsTrendsHandler] failed to get accounts and categories total income and expense for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } statisticTrendsResp := make(models.TransactionStatisticTrendsResponseItemSlice, 0, len(allMonthlyTotalAmounts)) for yearMonth, monthlyTotalAmounts := range allMonthlyTotalAmounts { monthlyStatisticResp := &models.TransactionStatisticTrendsResponseItem{ Year: yearMonth / 100, Month: yearMonth % 100, Items: make([]*models.TransactionStatisticResponseItem, len(monthlyTotalAmounts)), } for i := 0; i < len(monthlyTotalAmounts); i++ { totalAmountItem := monthlyTotalAmounts[i] monthlyStatisticResp.Items[i] = &models.TransactionStatisticResponseItem{ CategoryId: totalAmountItem.CategoryId, AccountId: totalAmountItem.AccountId, TotalAmount: totalAmountItem.Amount, } if totalAmountItem.Type == models.TRANSACTION_DB_TYPE_TRANSFER_OUT || totalAmountItem.Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN { monthlyStatisticResp.Items[i].RelatedAccountId = totalAmountItem.RelatedAccountId monthlyStatisticResp.Items[i].RelatedAccountType, _ = totalAmountItem.Type.ToTransactionRelatedAccountType() } } statisticTrendsResp = append(statisticTrendsResp, monthlyStatisticResp) } sort.Sort(statisticTrendsResp) return statisticTrendsResp, nil } // TransactionStatisticsAssetTrendsHandler returns transaction statistics asset trends of current user func (a *TransactionsApi) TransactionStatisticsAssetTrendsHandler(c *core.WebContext) (any, *errs.Error) { var statisticAssetTrendsReq models.TransactionStatisticAssetTrendsRequest err := c.ShouldBindQuery(&statisticAssetTrendsReq) if err != nil { log.Warnf(c, "[transactions.TransactionStatisticsAssetTrendsHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionStatisticsAssetTrendsHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } uid := c.GetCurrentUid() maxTransactionTime := int64(0) if statisticAssetTrendsReq.EndTime > 0 { maxTransactionTime = utils.GetMaxTransactionTimeFromUnixTime(statisticAssetTrendsReq.EndTime) } minTransactionTime := int64(0) if statisticAssetTrendsReq.StartTime > 0 { minTransactionTime = utils.GetMinTransactionTimeFromUnixTime(statisticAssetTrendsReq.StartTime) } accountDailyBalances, err := a.transactions.GetAllAccountsDailyOpeningAndClosingBalance(c, uid, maxTransactionTime, minTransactionTime, clientTimezone) if err != nil { log.Errorf(c, "[transactions.TransactionStatisticsAssetTrendsHandler] failed to get transactions from \"%d\" to \"%d\" for user \"uid:%d\", because %s", statisticAssetTrendsReq.StartTime, statisticAssetTrendsReq.EndTime, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } statisticAssetTrendsResp := make(models.TransactionStatisticAssetTrendsResponseItemSlice, 0) for yearMonthDay, dailyAccountBalances := range accountDailyBalances { dailyStatisticResp := &models.TransactionStatisticAssetTrendsResponseItem{ Year: yearMonthDay / 10000, Month: (yearMonthDay % 10000) / 100, Day: yearMonthDay % 100, Items: make([]*models.TransactionStatisticAssetTrendsResponseDataItem, len(dailyAccountBalances)), } for i := 0; i < len(dailyAccountBalances); i++ { accountBalance := dailyAccountBalances[i] dailyStatisticResp.Items[i] = &models.TransactionStatisticAssetTrendsResponseDataItem{ AccountId: accountBalance.AccountId, AccountOpeningBalance: accountBalance.AccountOpeningBalance, AccountClosingBalance: accountBalance.AccountClosingBalance, } } statisticAssetTrendsResp = append(statisticAssetTrendsResp, dailyStatisticResp) } sort.Sort(statisticAssetTrendsResp) return statisticAssetTrendsResp, nil } // TransactionAmountsHandler returns transaction amounts of current user func (a *TransactionsApi) TransactionAmountsHandler(c *core.WebContext) (any, *errs.Error) { var transactionAmountsReq models.TransactionAmountsRequest err := c.ShouldBindQuery(&transactionAmountsReq) if err != nil { log.Warnf(c, "[transactions.TransactionAmountsHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } requestItems, err := transactionAmountsReq.GetTransactionAmountsRequestItems() if err != nil { log.Warnf(c, "[transactions.TransactionAmountsHandler] get request item failed, because %s", err.Error()) return nil, errs.ErrQueryItemsInvalid } if len(requestItems) < 1 { log.Warnf(c, "[transactions.TransactionAmountsHandler] parse request failed, because there are no valid items") return nil, errs.ErrQueryItemsEmpty } if len(requestItems) > 20 { log.Warnf(c, "[transactions.TransactionAmountsHandler] parse request failed, because there are too many items") return nil, errs.ErrQueryItemsTooMuch } excludeAccountIds := make([]int64, 0) excludeCategoryIds := make([]int64, 0) if transactionAmountsReq.ExcludeAccountIds != "" { excludeAccountIds, err = utils.StringArrayToInt64Array(strings.Split(transactionAmountsReq.ExcludeAccountIds, ",")) if err != nil { return nil, errs.ErrAccountIdInvalid } } if transactionAmountsReq.ExcludeCategoryIds != "" { excludeCategoryIds, err = utils.StringArrayToInt64Array(strings.Split(transactionAmountsReq.ExcludeCategoryIds, ",")) if err != nil { return nil, errs.ErrTransactionCategoryIdInvalid } } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionAmountsHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } uid := c.GetCurrentUid() accounts, err := a.accounts.GetAllAccountsByUid(c, uid) accountMap := a.accounts.GetAccountMapByList(accounts) if err != nil { log.Errorf(c, "[transactions.TransactionAmountsHandler] failed to get all accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } amountsResp := orderedmap.New[string, *models.TransactionAmountsResponseItem]() for i := 0; i < len(requestItems); i++ { requestItem := requestItems[i] incomeAmounts, expenseAmounts, err := a.transactions.GetAccountsTotalIncomeAndExpense(c, uid, requestItem.StartTime, requestItem.EndTime, excludeAccountIds, excludeCategoryIds, clientTimezone, transactionAmountsReq.UseTransactionTimezone) if err != nil { log.Errorf(c, "[transactions.TransactionAmountsHandler] failed to get transaction amounts item for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } amountsMap := make(map[string]*models.TransactionAmountsResponseItemAmountInfo) for accountId, incomeAmount := range incomeAmounts { account, exists := accountMap[accountId] if !exists { log.Warnf(c, "[transactions.TransactionAmountsHandler] cannot find account for account \"id:%d\" of user \"uid:%d\"", accountId, uid) continue } totalAmounts, exists := amountsMap[account.Currency] if !exists { totalAmounts = &models.TransactionAmountsResponseItemAmountInfo{ Currency: account.Currency, IncomeAmount: 0, ExpenseAmount: 0, } } totalAmounts.IncomeAmount += incomeAmount amountsMap[account.Currency] = totalAmounts } for accountId, expenseAmount := range expenseAmounts { account, exists := accountMap[accountId] if !exists { log.Warnf(c, "[transactions.TransactionAmountsHandler] cannot find account for account \"id:%d\" of user \"uid:%d\"", accountId, uid) continue } totalAmounts, exists := amountsMap[account.Currency] if !exists { totalAmounts = &models.TransactionAmountsResponseItemAmountInfo{ Currency: account.Currency, IncomeAmount: 0, ExpenseAmount: 0, } } totalAmounts.ExpenseAmount += expenseAmount amountsMap[account.Currency] = totalAmounts } allTotalAmounts := make(models.TransactionAmountsResponseItemAmountInfoSlice, 0) for _, totalAmounts := range amountsMap { allTotalAmounts = append(allTotalAmounts, totalAmounts) } sort.Sort(allTotalAmounts) amountsResp.Set(requestItem.Name, &models.TransactionAmountsResponseItem{ StartTime: requestItem.StartTime, EndTime: requestItem.EndTime, Amounts: allTotalAmounts, }) } return amountsResp, nil } // TransactionGetHandler returns one specific transaction of current user func (a *TransactionsApi) TransactionGetHandler(c *core.WebContext) (any, *errs.Error) { var transactionGetReq models.TransactionGetRequest err := c.ShouldBindQuery(&transactionGetReq) if err != nil { log.Warnf(c, "[transactions.TransactionGetHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionGetHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } uid := c.GetCurrentUid() user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionGetHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } transaction, err := a.transactions.GetTransactionByTransactionId(c, uid, transactionGetReq.Id) if err != nil { log.Errorf(c, "[transactions.TransactionGetHandler] failed to get transaction \"id:%d\" for user \"uid:%d\", because %s", transactionGetReq.Id, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } if transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN { transaction = a.transactions.GetRelatedTransferTransaction(transaction) } accountIds := make([]int64, 0, 2) accountIds = append(accountIds, transaction.AccountId) if transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_OUT { accountIds = append(accountIds, transaction.RelatedAccountId) accountIds = utils.ToUniqueInt64Slice(accountIds) } accountMap, err := a.accounts.GetAccountsByAccountIds(c, uid, accountIds) if _, exists := accountMap[transaction.AccountId]; !exists { log.Warnf(c, "[transactions.TransactionGetHandler] account of transaction \"id:%d\" does not exist for user \"uid:%d\"", transaction.TransactionId, uid) return nil, errs.ErrTransactionNotFound } if transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_OUT { if _, exists := accountMap[transaction.RelatedAccountId]; !exists { log.Warnf(c, "[transactions.TransactionGetHandler] related account of transaction \"id:%d\" does not exist for user \"uid:%d\"", transaction.TransactionId, uid) return nil, errs.ErrTransactionNotFound } } allTransactionTagIds, err := a.transactionTags.GetAllTagIdsOfTransactions(c, uid, []int64{transaction.TransactionId}) if err != nil { log.Errorf(c, "[transactions.TransactionGetHandler] failed to get transactions tag ids for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } var category *models.TransactionCategory var tagMap map[int64]*models.TransactionTag var pictureInfos []*models.TransactionPictureInfo if !transactionGetReq.TrimCategory { category, err = a.transactionCategories.GetCategoryByCategoryId(c, uid, transaction.CategoryId) if err != nil { log.Errorf(c, "[transactions.TransactionGetHandler] failed to get transactions category for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } } if !transactionGetReq.TrimTag { tagMap, err = a.transactionTags.GetTagsByTagIds(c, uid, utils.ToUniqueInt64Slice(a.transactionTags.GetTransactionTagIds(allTransactionTagIds))) if err != nil { log.Errorf(c, "[transactions.TransactionGetHandler] failed to get transactions tags for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } } if transactionGetReq.WithPictures && a.CurrentConfig().EnableTransactionPictures { pictureInfos, err = a.transactionPictures.GetPictureInfosByTransactionId(c, uid, transaction.TransactionId) if err != nil { log.Errorf(c, "[transactions.TransactionGetHandler] failed to get transactions pictures for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } } transactionEditable := transaction.IsEditable(user, clientTimezone, accountMap[transaction.AccountId], accountMap[transaction.RelatedAccountId]) transactionTagIds := allTransactionTagIds[transaction.TransactionId] transactionResp := transaction.ToTransactionInfoResponse(transactionTagIds, transactionEditable) if !transactionGetReq.TrimAccount { if sourceAccount := accountMap[transaction.AccountId]; sourceAccount != nil { transactionResp.SourceAccount = sourceAccount.ToAccountInfoResponse() } if destinationAccount := accountMap[transaction.RelatedAccountId]; destinationAccount != nil { transactionResp.DestinationAccount = destinationAccount.ToAccountInfoResponse() } } if !transactionGetReq.TrimCategory { if category != nil { transactionResp.Category = category.ToTransactionCategoryInfoResponse() } } if !transactionGetReq.TrimTag { transactionResp.Tags = a.getTransactionTagInfoResponses(transactionTagIds, tagMap) } if transactionGetReq.WithPictures && a.CurrentConfig().EnableTransactionPictures { transactionResp.Pictures = a.GetTransactionPictureInfoResponseList(pictureInfos) } return transactionResp, nil } // TransactionCreateHandler saves a new transaction by request parameters for current user func (a *TransactionsApi) TransactionCreateHandler(c *core.WebContext) (any, *errs.Error) { var transactionCreateReq models.TransactionCreateRequest err := c.ShouldBindJSON(&transactionCreateReq) if err != nil { log.Warnf(c, "[transactions.TransactionCreateHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionCreateHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } tagIds, err := utils.StringArrayToInt64Array(transactionCreateReq.TagIds) if err != nil { log.Warnf(c, "[transactions.TransactionCreateHandler] parse tag ids failed, because %s", err.Error()) return nil, errs.ErrTransactionTagIdInvalid } if len(tagIds) > models.MaximumTagsCountOfTransaction { return nil, errs.ErrTransactionHasTooManyTags } pictureIds, err := utils.StringArrayToInt64Array(transactionCreateReq.PictureIds) if err != nil { log.Warnf(c, "[transactions.TransactionCreateHandler] parse picture ids failed, because %s", err.Error()) return nil, errs.ErrTransactionPictureIdInvalid } if len(pictureIds) > models.MaximumPicturesCountOfTransaction { return nil, errs.ErrTransactionHasTooManyPictures } if transactionCreateReq.Type < models.TRANSACTION_TYPE_MODIFY_BALANCE || transactionCreateReq.Type > models.TRANSACTION_TYPE_TRANSFER { log.Warnf(c, "[transactions.TransactionCreateHandler] transaction type is invalid") return nil, errs.ErrTransactionTypeInvalid } if transactionCreateReq.Type == models.TRANSACTION_TYPE_MODIFY_BALANCE && transactionCreateReq.CategoryId != 0 { log.Warnf(c, "[transactions.TransactionCreateHandler] balance modification transaction cannot set category id") return nil, errs.ErrBalanceModificationTransactionCannotSetCategory } if transactionCreateReq.Type != models.TRANSACTION_TYPE_TRANSFER && transactionCreateReq.DestinationAccountId != 0 { log.Warnf(c, "[transactions.TransactionCreateHandler] non-transfer transaction destination account cannot be set") return nil, errs.ErrTransactionDestinationAccountCannotBeSet } else if transactionCreateReq.Type == models.TRANSACTION_TYPE_TRANSFER && transactionCreateReq.SourceAccountId == transactionCreateReq.DestinationAccountId { log.Warnf(c, "[transactions.TransactionCreateHandler] transfer transaction source account must not be destination account") return nil, errs.ErrTransactionSourceAndDestinationIdCannotBeEqual } if transactionCreateReq.Type != models.TRANSACTION_TYPE_TRANSFER && transactionCreateReq.DestinationAmount != 0 { log.Warnf(c, "[transactions.TransactionCreateHandler] non-transfer transaction destination amount cannot be set") return nil, errs.ErrTransactionDestinationAmountCannotBeSet } uid := c.GetCurrentUid() user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionCreateHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } transaction := a.createNewTransactionModel(uid, &transactionCreateReq, c.ClientIP()) allUsedAccounts, err := a.getTransactionUsedAccounts(c, uid, []*models.Transaction{transaction}) if err != nil { log.Errorf(c, "[transactions.TransactionCreateHandler] failed to get transaction used accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } transactionEditable := user.CanEditTransactionByTransactionTime(transaction.TransactionTime, clientTimezone, allUsedAccounts[transaction.AccountId], allUsedAccounts[transaction.RelatedAccountId]) if !transactionEditable { return nil, errs.ErrCannotCreateTransactionWithThisTransactionTime } var pictureInfos []*models.TransactionPictureInfo if len(pictureIds) > 0 { pictureInfos, err = a.transactionPictures.GetNewPictureInfosByPictureIds(c, uid, pictureIds) if err != nil { log.Errorf(c, "[transactions.TransactionCreateHandler] failed to get transactions pictures for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } notExistsPictureIds := utils.Int64SliceMinus(pictureIds, a.transactionPictures.GetTransactionPictureIds(pictureInfos)) if len(notExistsPictureIds) > 0 { log.Errorf(c, "[transactions.TransactionCreateHandler] some pictures \"ids:%s\" does not exists for user \"uid:%d\"", strings.Join(utils.Int64ArrayToStringArray(notExistsPictureIds), ","), uid) return nil, errs.ErrTransactionPictureNotFound } } if a.CurrentConfig().EnableDuplicateSubmissionsCheck && transactionCreateReq.ClientSessionId != "" { found, remark := a.GetSubmissionRemark(duplicatechecker.DUPLICATE_CHECKER_TYPE_NEW_TRANSACTION, uid, transactionCreateReq.ClientSessionId) if found { log.Infof(c, "[transactions.TransactionCreateHandler] another transaction \"id:%s\" has been created for user \"uid:%d\"", remark, uid) transactionId, err := utils.StringToInt64(remark) if err == nil { transaction, err = a.transactions.GetTransactionByTransactionId(c, uid, transactionId) if err != nil { log.Errorf(c, "[transactions.TransactionCreateHandler] failed to get existed transaction \"id:%d\" for user \"uid:%d\", because %s", transactionId, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } transactionResp := transaction.ToTransactionInfoResponse(tagIds, transactionEditable) transactionResp.Pictures = a.GetTransactionPictureInfoResponseList(pictureInfos) return transactionResp, nil } } } err = a.transactions.CreateTransaction(c, transaction, tagIds, pictureIds) if err != nil { log.Errorf(c, "[transactions.TransactionCreateHandler] failed to create transaction \"id:%d\" for user \"uid:%d\", because %s", transaction.TransactionId, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } log.Infof(c, "[transactions.TransactionCreateHandler] user \"uid:%d\" has created a new transaction \"id:%d\" successfully", uid, transaction.TransactionId) a.SetSubmissionRemarkIfEnable(duplicatechecker.DUPLICATE_CHECKER_TYPE_NEW_TRANSACTION, uid, transactionCreateReq.ClientSessionId, utils.Int64ToString(transaction.TransactionId)) transactionResp := transaction.ToTransactionInfoResponse(tagIds, transactionEditable) transactionResp.Pictures = a.GetTransactionPictureInfoResponseList(pictureInfos) return transactionResp, nil } // TransactionModifyHandler saves an existed transaction by request parameters for current user func (a *TransactionsApi) TransactionModifyHandler(c *core.WebContext) (any, *errs.Error) { var transactionModifyReq models.TransactionModifyRequest err := c.ShouldBindJSON(&transactionModifyReq) if err != nil { log.Warnf(c, "[transactions.TransactionModifyHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionModifyHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } tagIds, err := utils.StringArrayToInt64Array(transactionModifyReq.TagIds) if err != nil { log.Warnf(c, "[transactions.TransactionModifyHandler] parse tag ids failed, because %s", err.Error()) return nil, errs.ErrTransactionTagIdInvalid } if len(tagIds) > models.MaximumTagsCountOfTransaction { return nil, errs.ErrTransactionHasTooManyTags } pictureIds, err := utils.StringArrayToInt64Array(transactionModifyReq.PictureIds) if err != nil { log.Warnf(c, "[transactions.TransactionModifyHandler] parse picture ids failed, because %s", err.Error()) return nil, errs.ErrTransactionPictureIdInvalid } if len(pictureIds) > models.MaximumPicturesCountOfTransaction { return nil, errs.ErrTransactionHasTooManyPictures } uid := c.GetCurrentUid() user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionModifyHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } transaction, err := a.transactions.GetTransactionByTransactionId(c, uid, transactionModifyReq.Id) if err != nil { log.Errorf(c, "[transactions.TransactionModifyHandler] failed to get transaction \"id:%d\" for user \"uid:%d\", because %s", transactionModifyReq.Id, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } if transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN { log.Warnf(c, "[transactions.TransactionModifyHandler] cannot modify transaction \"id:%d\" for user \"uid:%d\", because transaction type is transfer in", transactionModifyReq.Id, uid) return nil, errs.ErrTransactionTypeInvalid } if transaction.Type == models.TRANSACTION_DB_TYPE_MODIFY_BALANCE && transactionModifyReq.CategoryId != 0 { log.Warnf(c, "[transactions.TransactionModifyHandler] balance modification transaction cannot set category id") return nil, errs.ErrBalanceModificationTransactionCannotSetCategory } else if transaction.Type != models.TRANSACTION_DB_TYPE_MODIFY_BALANCE && transactionModifyReq.CategoryId == 0 { log.Warnf(c, "[transactions.TransactionModifyHandler] non-balance modification transaction must set category id") return nil, errs.ErrIncompleteOrIncorrectSubmission } allTransactionTagIds, err := a.transactionTags.GetAllTagIdsOfTransactions(c, uid, []int64{transaction.TransactionId}) if err != nil { log.Errorf(c, "[transactions.TransactionModifyHandler] failed to get transactions tag ids for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } transactionTagIds := allTransactionTagIds[transaction.TransactionId] if transactionTagIds == nil { transactionTagIds = make([]int64, 0, 0) } transactionPictureInfos, err := a.transactionPictures.GetPictureInfosByTransactionId(c, uid, transaction.TransactionId) if err != nil { log.Errorf(c, "[transactions.TransactionModifyHandler] failed to get transaction picture infos for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } transactionPictureIds := a.transactionPictures.GetTransactionPictureIds(transactionPictureInfos) newTransaction := &models.Transaction{ TransactionId: transaction.TransactionId, Uid: uid, CategoryId: transactionModifyReq.CategoryId, TransactionTime: utils.GetMinTransactionTimeFromUnixTime(transactionModifyReq.Time), TimezoneUtcOffset: transactionModifyReq.UtcOffset, AccountId: transactionModifyReq.SourceAccountId, Amount: transactionModifyReq.SourceAmount, HideAmount: transactionModifyReq.HideAmount, Comment: transactionModifyReq.Comment, } if transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_OUT { newTransaction.RelatedAccountId = transactionModifyReq.DestinationAccountId newTransaction.RelatedAccountAmount = transactionModifyReq.DestinationAmount } if transactionModifyReq.GeoLocation != nil { newTransaction.GeoLongitude = transactionModifyReq.GeoLocation.Longitude newTransaction.GeoLatitude = transactionModifyReq.GeoLocation.Latitude } if newTransaction.CategoryId == transaction.CategoryId && utils.GetUnixTimeFromTransactionTime(newTransaction.TransactionTime) == utils.GetUnixTimeFromTransactionTime(transaction.TransactionTime) && newTransaction.TimezoneUtcOffset == transaction.TimezoneUtcOffset && newTransaction.AccountId == transaction.AccountId && newTransaction.Amount == transaction.Amount && (transaction.Type != models.TRANSACTION_DB_TYPE_TRANSFER_OUT || newTransaction.RelatedAccountId == transaction.RelatedAccountId) && (transaction.Type != models.TRANSACTION_DB_TYPE_TRANSFER_OUT || newTransaction.RelatedAccountAmount == transaction.RelatedAccountAmount) && newTransaction.HideAmount == transaction.HideAmount && newTransaction.Comment == transaction.Comment && newTransaction.GeoLongitude == transaction.GeoLongitude && newTransaction.GeoLatitude == transaction.GeoLatitude && utils.Int64SliceEquals(tagIds, transactionTagIds) && utils.Int64SliceEquals(pictureIds, transactionPictureIds) { return nil, errs.ErrNothingWillBeUpdated } allUsedAccounts, err := a.getTransactionUsedAccounts(c, uid, []*models.Transaction{transaction, newTransaction}) if err != nil { log.Errorf(c, "[transactions.TransactionModifyHandler] failed to get transaction used accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } transactionEditable := user.CanEditTransactionByTransactionTime(transaction.TransactionTime, clientTimezone, allUsedAccounts[transaction.AccountId], allUsedAccounts[transaction.RelatedAccountId]) newTransactionEditable := user.CanEditTransactionByTransactionTime(newTransaction.TransactionTime, clientTimezone, allUsedAccounts[newTransaction.AccountId], allUsedAccounts[newTransaction.RelatedAccountId]) if !transactionEditable || !newTransactionEditable { return nil, errs.ErrCannotModifyTransactionWithThisTransactionTime } var addTransactionTagIds []int64 var removeTransactionTagIds []int64 if !utils.Int64SliceEquals(tagIds, transactionTagIds) { removeTransactionTagIds = transactionTagIds addTransactionTagIds = tagIds } addTransactionPictureIds := utils.Int64SliceMinus(pictureIds, transactionPictureIds) removeTransactionPictureIds := utils.Int64SliceMinus(transactionPictureIds, pictureIds) var newPictureInfos []*models.TransactionPictureInfo if !utils.Int64SliceEquals(pictureIds, transactionPictureIds) { oldAndNewPictureIds := transactionPictureIds oldAndNewPictureInfoMap := a.transactionPictures.GetPictureInfoMapByList(transactionPictureInfos) if len(addTransactionPictureIds) > 0 { addPictureInfos, err := a.transactionPictures.GetNewPictureInfosByPictureIds(c, uid, addTransactionPictureIds) if err != nil { log.Errorf(c, "[transactions.TransactionModifyHandler] failed to get transactions pictures for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } oldAndNewPictureIds = append(oldAndNewPictureIds, a.transactionPictures.GetTransactionPictureIds(addPictureInfos)...) notExistsPictureIds := utils.Int64SliceMinus(pictureIds, oldAndNewPictureIds) if len(notExistsPictureIds) > 0 { log.Errorf(c, "[transactions.TransactionModifyHandler] some pictures \"ids:%s\" does not exists for user \"uid:%d\"", strings.Join(utils.Int64ArrayToStringArray(notExistsPictureIds), ","), uid) return nil, errs.ErrTransactionPictureNotFound } for i := 0; i < len(addPictureInfos); i++ { oldAndNewPictureInfoMap[addPictureInfos[i].PictureId] = addPictureInfos[i] } } for i := 0; i < len(pictureIds); i++ { pictureId := pictureIds[i] pictureInfo, exists := oldAndNewPictureInfoMap[pictureId] if exists { newPictureInfos = append(newPictureInfos, pictureInfo) } } } err = a.transactions.ModifyTransaction(c, newTransaction, len(transactionTagIds), addTransactionTagIds, removeTransactionTagIds, addTransactionPictureIds, removeTransactionPictureIds) if err != nil { log.Errorf(c, "[transactions.TransactionModifyHandler] failed to update transaction \"id:%d\" for user \"uid:%d\", because %s", transactionModifyReq.Id, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } log.Infof(c, "[transactions.TransactionModifyHandler] user \"uid:%d\" has updated transaction \"id:%d\" successfully", uid, transactionModifyReq.Id) newTransaction.Type = transaction.Type newTransactionResp := newTransaction.ToTransactionInfoResponse(tagIds, transactionEditable) newTransactionResp.Pictures = a.GetTransactionPictureInfoResponseList(newPictureInfos) return newTransactionResp, nil } // TransactionBatchUpdateCategoriesHandler batch updates categories of transactions by request parameters for current user func (a *TransactionsApi) TransactionBatchUpdateCategoriesHandler(c *core.WebContext) (any, *errs.Error) { var transactionBatchUpdateReq models.TransactionBatchUpdateCategoryRequest err := c.ShouldBindJSON(&transactionBatchUpdateReq) if err != nil { log.Warnf(c, "[transactions.TransactionBatchUpdateCategoriesHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionBatchUpdateCategoriesHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } transactionIds, err := utils.StringArrayToInt64Array(transactionBatchUpdateReq.TransactionIds) if err != nil { log.Warnf(c, "[transactions.TransactionBatchUpdateCategoriesHandler] parse transaction ids failed, because %s", err.Error()) return nil, errs.ErrTransactionIdInvalid } uid := c.GetCurrentUid() user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionBatchUpdateCategoriesHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } category, err := a.transactionCategories.GetCategoryByCategoryId(c, uid, transactionBatchUpdateReq.CategoryId) if err != nil { log.Errorf(c, "[transactions.TransactionBatchUpdateCategoriesHandler] failed to get category \"id:%d\" for user \"uid:%d\", because %s", transactionBatchUpdateReq.CategoryId, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } if category.ParentCategoryId == models.LevelOneTransactionCategoryParentId { log.Warnf(c, "[transactions.TransactionBatchUpdateCategoriesHandler] transaction category \"id:%d\" is not a sub category", category.CategoryId) return nil, errs.ErrCannotUsePrimaryCategoryForTransaction } var expectedTransactionType models.TransactionDbType if category.Type == models.CATEGORY_TYPE_EXPENSE { expectedTransactionType = models.TRANSACTION_DB_TYPE_EXPENSE } else if category.Type == models.CATEGORY_TYPE_INCOME { expectedTransactionType = models.TRANSACTION_DB_TYPE_INCOME } else if category.Type == models.CATEGORY_TYPE_TRANSFER { expectedTransactionType = models.TRANSACTION_DB_TYPE_TRANSFER_OUT } transactions, err := a.transactions.GetTransactionsByTransactionIds(c, uid, transactionIds) if err != nil { log.Errorf(c, "[transactions.TransactionBatchUpdateCategoriesHandler] failed to get transactions for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allUsedAccounts, err := a.getTransactionUsedAccounts(c, uid, transactions) if err != nil { log.Errorf(c, "[transactions.TransactionBatchUpdateCategoriesHandler] failed to get transaction used accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allTransactionIds := make([]int64, 0, len(transactions)) for i := 0; i < len(transactions); i++ { transaction := transactions[i] if transaction.Type != expectedTransactionType { log.Warnf(c, "[transactions.TransactionBatchUpdateCategoriesHandler] transaction \"id:%d\" type is not expected type \"%d\" for user \"uid:%d\"", transaction.TransactionId, expectedTransactionType, uid) return nil, errs.ErrTransactionTypeInvalid } transactionEditable := user.CanEditTransactionByTransactionTime(transaction.TransactionTime, clientTimezone, allUsedAccounts[transaction.AccountId], allUsedAccounts[transaction.RelatedAccountId]) if !transactionEditable { log.Warnf(c, "[transactions.TransactionBatchUpdateCategoriesHandler] transaction \"id:%d\" is not editable for user \"uid:%d\"", transaction.TransactionId, uid) return nil, errs.ErrCannotModifyTransactionWithThisTransactionTime } allTransactionIds = append(allTransactionIds, transaction.TransactionId) if transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_OUT { allTransactionIds = append(allTransactionIds, transaction.RelatedId) } } err = a.transactions.BatchUpdateTransactionsCategory(c, uid, allTransactionIds, category.CategoryId) if err != nil { log.Errorf(c, "[transactions.TransactionBatchUpdateCategoriesHandler] failed to batch update transactions category for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } log.Infof(c, "[transactions.TransactionBatchUpdateCategoriesHandler] user \"uid:%d\" has batch updated category of %d transactions successfully", uid, len(transactionBatchUpdateReq.TransactionIds)) return true, nil } // TransactionBatchUpdateAccountsHandler batch updates accounts of transactions by request parameters for current user func (a *TransactionsApi) TransactionBatchUpdateAccountsHandler(c *core.WebContext) (any, *errs.Error) { var transactionBatchUpdateReq models.TransactionBatchUpdateAccountRequest err := c.ShouldBindJSON(&transactionBatchUpdateReq) if err != nil { log.Warnf(c, "[transactions.TransactionBatchUpdateAccountsHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionBatchUpdateAccountsHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } transactionIds, err := utils.StringArrayToInt64Array(transactionBatchUpdateReq.TransactionIds) if err != nil { log.Warnf(c, "[transactions.TransactionBatchUpdateAccountsHandler] parse transaction ids failed, because %s", err.Error()) return nil, errs.ErrTransactionIdInvalid } uid := c.GetCurrentUid() user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionBatchUpdateAccountsHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } allAccounts, err := a.accounts.GetAllAccountsByUid(c, uid) if err != nil { log.Errorf(c, "[transactions.TransactionBatchUpdateAccountsHandler] failed to get all accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } accountMap := a.accounts.GetAccountMapByList(allAccounts) account, exists := accountMap[transactionBatchUpdateReq.AccountId] if !exists || account == nil { log.Warnf(c, "[transactions.TransactionBatchUpdateAccountsHandler] account \"id:%d\" does not exist for user \"uid:%d\"", transactionBatchUpdateReq.AccountId, uid) return nil, errs.ErrAccountNotFound } if account.Hidden { log.Warnf(c, "[transactions.TransactionBatchUpdateAccountsHandler] account \"id:%d\" is hidden for user \"uid:%d\"", account.AccountId, uid) return nil, errs.ErrCannotMoveTransactionFromOrToHiddenAccount } if account.Type == models.ACCOUNT_TYPE_MULTI_SUB_ACCOUNTS { log.Warnf(c, "[transactions.TransactionBatchUpdateAccountsHandler] account \"id:%d\" is a parent account, cannot be used for transaction of user \"uid:%d\"", account.AccountId, uid) return nil, errs.ErrCannotModifyTransactionInParentAccount } transactions, err := a.transactions.GetTransactionsByTransactionIds(c, uid, transactionIds) if err != nil { log.Errorf(c, "[transactions.TransactionBatchUpdateAccountsHandler] failed to get transactions for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } for i := 0; i < len(transactions); i++ { transaction := transactions[i] if transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN { log.Warnf(c, "[transactions.TransactionBatchUpdateAccountsHandler] cannot modify transaction \"id:%d\" for user \"uid:%d\", because transaction type is transfer in", transaction.TransactionId, uid) return nil, errs.ErrTransactionTypeInvalid } if transactionBatchUpdateReq.IsDestinationAccount && transaction.Type != models.TRANSACTION_DB_TYPE_TRANSFER_OUT { log.Warnf(c, "[transactions.TransactionBatchUpdateAccountsHandler] cannot update destination account of non-transfer transaction \"id:%d\" for user \"uid:%d\"", transaction.TransactionId, uid) return nil, errs.ErrTransactionDestinationAccountCannotBeSet } if !transactionBatchUpdateReq.IsDestinationAccount && account.AccountId == transaction.RelatedAccountId { log.Warnf(c, "[transactions.TransactionBatchUpdateAccountsHandler] cannot update account to same destination account of transaction \"id:%d\" for user \"uid:%d\"", transaction.TransactionId, uid) return nil, errs.ErrTransactionSourceAndDestinationIdCannotBeEqual } else if transactionBatchUpdateReq.IsDestinationAccount && account.AccountId == transaction.AccountId { log.Warnf(c, "[transactions.TransactionBatchUpdateAccountsHandler] cannot update destination account to same source account of transaction \"id:%d\" for user \"uid:%d\"", transaction.TransactionId, uid) return nil, errs.ErrTransactionSourceAndDestinationIdCannotBeEqual } var oldAccount *models.Account if !transactionBatchUpdateReq.IsDestinationAccount { oldAccount = accountMap[transaction.AccountId] } else if transactionBatchUpdateReq.IsDestinationAccount { oldAccount = accountMap[transaction.RelatedAccountId] } if oldAccount == nil { log.Warnf(c, "[transactions.TransactionBatchUpdateAccountsHandler] the original account of transaction \"id:%d\" does not exist for user \"uid:%d\"", transaction.TransactionId, uid) return nil, errs.ErrAccountNotFound } if oldAccount.Hidden { log.Warnf(c, "[transactions.TransactionBatchUpdateAccountsHandler] the original account of transaction \"id:%d\" is hidden for user \"uid:%d\"", transaction.TransactionId, uid) return nil, errs.ErrCannotMoveTransactionFromOrToHiddenAccount } if oldAccount.Currency != account.Currency { log.Warnf(c, "[transactions.TransactionBatchUpdateAccountsHandler] cannot update account of transaction \"id:%d\", because the original account currency \"%s\" is different from updated account currency \"%s\" for user \"uid:%d\"", transaction.TransactionId, oldAccount.Currency, account.Currency, uid) return nil, errs.ErrCannotMoveTransactionBetweenAccountsWithDifferentCurrencies } newSourceAccount := accountMap[transaction.AccountId] newDestinationAccount := accountMap[transaction.RelatedAccountId] if !transactionBatchUpdateReq.IsDestinationAccount && transaction.AccountId != account.AccountId { newSourceAccount = account } else if transactionBatchUpdateReq.IsDestinationAccount && transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_OUT && transaction.RelatedAccountId != account.AccountId { newDestinationAccount = account } transactionEditable := user.CanEditTransactionByTransactionTime(transaction.TransactionTime, clientTimezone, accountMap[transaction.AccountId], accountMap[transaction.RelatedAccountId]) newTransactionEditable := user.CanEditTransactionByTransactionTime(transaction.TransactionTime, clientTimezone, newSourceAccount, newDestinationAccount) if !transactionEditable || !newTransactionEditable { log.Warnf(c, "[transactions.TransactionBatchUpdateAccountsHandler] transaction \"id:%d\" is not editable for user \"uid:%d\"", transaction.TransactionId, uid) return nil, errs.ErrCannotModifyTransactionWithThisTransactionTime } } updatedCount := 0 for i := 0; i < len(transactions); i++ { transaction := transactions[i] if !transactionBatchUpdateReq.IsDestinationAccount && transaction.AccountId != account.AccountId { transaction.AccountId = account.AccountId } else if transactionBatchUpdateReq.IsDestinationAccount && transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_OUT && transaction.RelatedAccountId != account.AccountId { transaction.RelatedAccountId = account.AccountId } else { log.Warnf(c, "[transactions.TransactionBatchUpdateAccountsHandler] skip updating transaction \"id:%d\", because the original account is same as updated account for user \"uid:%d\"", transaction.TransactionId, uid) continue } err = a.transactions.ModifyTransaction(c, transaction, 0, nil, nil, nil, nil) if err != nil { log.Errorf(c, "[transactions.TransactionBatchUpdateAccountsHandler] failed to update transaction \"id:%d\" for user \"uid:%d\", because %s", transaction.TransactionId, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } updatedCount++ } if updatedCount < 1 { return nil, errs.ErrNothingWillBeUpdated } log.Infof(c, "[transactions.TransactionBatchUpdateAccountsHandler] user \"uid:%d\" has batch updated account of %d transactions successfully", uid, updatedCount) return true, nil } // TransactionBatchAddTagsHandler batch add tags to transactions by request parameters for current user func (a *TransactionsApi) TransactionBatchAddTagsHandler(c *core.WebContext) (any, *errs.Error) { var transactionBatchUpdateReq models.TransactionBatchAddTagsRequest err := c.ShouldBindJSON(&transactionBatchUpdateReq) if err != nil { log.Warnf(c, "[transactions.TransactionBatchAddTagsHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionBatchAddTagsHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } transactionIds, err := utils.StringArrayToInt64Array(transactionBatchUpdateReq.TransactionIds) if err != nil { log.Warnf(c, "[transactions.TransactionBatchAddTagsHandler] parse transaction ids failed, because %s", err.Error()) return nil, errs.ErrTransactionIdInvalid } tagIds, err := utils.StringArrayToInt64Array(transactionBatchUpdateReq.TagIds) if err != nil { log.Warnf(c, "[transactions.TransactionBatchAddTagsHandler] parse tag ids failed, because %s", err.Error()) return nil, errs.ErrTransactionTagIdInvalid } tagIds = utils.ToUniqueInt64Slice(tagIds) uid := c.GetCurrentUid() user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionBatchAddTagsHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } tags, err := a.transactionTags.GetTagsByTagIds(c, uid, tagIds) if err != nil { log.Errorf(c, "[transactions.TransactionBatchAddTagsHandler] failed to get tags for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } if len(tags) != len(tagIds) { log.Warnf(c, "[transactions.TransactionBatchAddTagsHandler] some tags do not exist for user \"uid:%d\"", uid) return nil, errs.ErrTransactionTagNotFound } transactions, err := a.transactions.GetTransactionsByTransactionIds(c, uid, transactionIds) if err != nil { log.Errorf(c, "[transactions.TransactionBatchAddTagsHandler] failed to get transactions for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allUsedAccounts, err := a.getTransactionUsedAccounts(c, uid, transactions) if err != nil { log.Errorf(c, "[transactions.TransactionBatchAddTagsHandler] failed to get transaction used accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } transactionTagIndexes, err := a.transactionTags.GetAllTagIdsOfTransactions(c, uid, transactionIds) if err != nil { log.Errorf(c, "[transactions.TransactionBatchAddTagsHandler] failed to get transactions tag indexes for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allNewTransactionTagIndexes := make(map[int64][]int64, len(transactions)) for i := 0; i < len(transactions); i++ { transaction := transactions[i] if transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN { log.Warnf(c, "[transactions.TransactionBatchAddTagsHandler] cannot modify transaction \"id:%d\" for user \"uid:%d\", because transaction type is transfer in", transaction.TransactionId, uid) return nil, errs.ErrTransactionTypeInvalid } transactionEditable := user.CanEditTransactionByTransactionTime(transaction.TransactionTime, clientTimezone, allUsedAccounts[transaction.AccountId], allUsedAccounts[transaction.RelatedAccountId]) if !transactionEditable { log.Warnf(c, "[transactions.TransactionBatchAddTagsHandler] transaction \"id:%d\" is not editable for user \"uid:%d\"", transaction.TransactionId, uid) return nil, errs.ErrCannotModifyTransactionWithThisTransactionTime } existedTagIds := transactionTagIndexes[transaction.TransactionId] existedTagIdsMap := make(map[int64]bool, len(existedTagIds)) for j := 0; j < len(existedTagIds); j++ { existedTagIdsMap[existedTagIds[j]] = true } var newTagIds []int64 for j := 0; j < len(tagIds); j++ { tagId := tagIds[j] if _, exists := existedTagIdsMap[tagId]; !exists { newTagIds = append(newTagIds, tagId) } } allNewTransactionTagIndexes[transaction.TransactionId] = newTagIds } err = a.transactions.BatchAddTagsToTransactions(c, uid, transactions, allNewTransactionTagIndexes) if err != nil { log.Errorf(c, "[transactions.TransactionBatchAddTagsHandler] failed to batch update transactions tags for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } log.Infof(c, "[transactions.TransactionBatchAddTagsHandler] user \"uid:%d\" has batch updated tag of %d transactions successfully", uid, len(allNewTransactionTagIndexes)) return true, nil } // TransactionBatchRemoveTagsHandler batch remove tags from transactions by request parameters for current user func (a *TransactionsApi) TransactionBatchRemoveTagsHandler(c *core.WebContext) (any, *errs.Error) { var transactionBatchUpdateReq models.TransactionBatchRemoveTagsRequest err := c.ShouldBindJSON(&transactionBatchUpdateReq) if err != nil { log.Warnf(c, "[transactions.TransactionBatchRemoveTagsHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionBatchRemoveTagsHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } transactionIds, err := utils.StringArrayToInt64Array(transactionBatchUpdateReq.TransactionIds) if err != nil { log.Warnf(c, "[transactions.TransactionBatchRemoveTagsHandler] parse transaction ids failed, because %s", err.Error()) return nil, errs.ErrTransactionIdInvalid } tagIds, err := utils.StringArrayToInt64Array(transactionBatchUpdateReq.TagIds) if err != nil { log.Warnf(c, "[transactions.TransactionBatchRemoveTagsHandler] parse tag ids failed, because %s", err.Error()) return nil, errs.ErrTransactionTagIdInvalid } tagIds = utils.ToUniqueInt64Slice(tagIds) uid := c.GetCurrentUid() user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionBatchRemoveTagsHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } tags, err := a.transactionTags.GetTagsByTagIds(c, uid, tagIds) if err != nil { log.Errorf(c, "[transactions.TransactionBatchRemoveTagsHandler] failed to get tags for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } if len(tags) != len(tagIds) { log.Warnf(c, "[transactions.TransactionBatchRemoveTagsHandler] some tags do not exist for user \"uid:%d\"", uid) return nil, errs.ErrTransactionTagNotFound } transactions, err := a.transactions.GetTransactionsByTransactionIds(c, uid, transactionIds) if err != nil { log.Errorf(c, "[transactions.TransactionBatchRemoveTagsHandler] failed to get transactions for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allUsedAccounts, err := a.getTransactionUsedAccounts(c, uid, transactions) if err != nil { log.Errorf(c, "[transactions.TransactionBatchRemoveTagsHandler] failed to get transaction used accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allTransactionIds := make([]int64, 0, len(transactions)) for i := 0; i < len(transactions); i++ { transaction := transactions[i] if transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN { log.Warnf(c, "[transactions.TransactionBatchRemoveTagsHandler] cannot modify transaction \"id:%d\" for user \"uid:%d\", because transaction type is transfer in", transaction.TransactionId, uid) return nil, errs.ErrTransactionTypeInvalid } transactionEditable := user.CanEditTransactionByTransactionTime(transaction.TransactionTime, clientTimezone, allUsedAccounts[transaction.AccountId], allUsedAccounts[transaction.RelatedAccountId]) if !transactionEditable { log.Warnf(c, "[transactions.TransactionBatchRemoveTagsHandler] transaction \"id:%d\" is not editable for user \"uid:%d\"", transaction.TransactionId, uid) return nil, errs.ErrCannotModifyTransactionWithThisTransactionTime } allTransactionIds = append(allTransactionIds, transaction.TransactionId) } err = a.transactions.BatchRemoveTagsFromTransactions(c, uid, allTransactionIds, tagIds) if err != nil { log.Errorf(c, "[transactions.TransactionBatchRemoveTagsHandler] failed to batch update transactions tags for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } log.Infof(c, "[transactions.TransactionBatchRemoveTagsHandler] user \"uid:%d\" has batch updated tag of %d transactions successfully", uid, len(allTransactionIds)) return true, nil } // TransactionBatchClearTagsHandler batch clear all tags from transactions by request parameters for current user func (a *TransactionsApi) TransactionBatchClearTagsHandler(c *core.WebContext) (any, *errs.Error) { var transactionBatchUpdateReq models.TransactionBatchClearTagsRequest err := c.ShouldBindJSON(&transactionBatchUpdateReq) if err != nil { log.Warnf(c, "[transactions.TransactionBatchClearTagsHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionBatchClearTagsHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } transactionIds, err := utils.StringArrayToInt64Array(transactionBatchUpdateReq.TransactionIds) if err != nil { log.Warnf(c, "[transactions.TransactionBatchClearTagsHandler] parse transaction ids failed, because %s", err.Error()) return nil, errs.ErrTransactionIdInvalid } uid := c.GetCurrentUid() user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionBatchClearTagsHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } transactions, err := a.transactions.GetTransactionsByTransactionIds(c, uid, transactionIds) if err != nil { log.Errorf(c, "[transactions.TransactionBatchClearTagsHandler] failed to get transactions for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allUsedAccounts, err := a.getTransactionUsedAccounts(c, uid, transactions) if err != nil { log.Errorf(c, "[transactions.TransactionBatchClearTagsHandler] failed to get transaction used accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allTransactionIds := make([]int64, 0, len(transactions)) for i := 0; i < len(transactions); i++ { transaction := transactions[i] if transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN { log.Warnf(c, "[transactions.TransactionBatchClearTagsHandler] cannot modify transaction \"id:%d\" for user \"uid:%d\", because transaction type is transfer in", transaction.TransactionId, uid) return nil, errs.ErrTransactionTypeInvalid } transactionEditable := user.CanEditTransactionByTransactionTime(transaction.TransactionTime, clientTimezone, allUsedAccounts[transaction.AccountId], allUsedAccounts[transaction.RelatedAccountId]) if !transactionEditable { log.Warnf(c, "[transactions.TransactionBatchClearTagsHandler] transaction \"id:%d\" is not editable for user \"uid:%d\"", transaction.TransactionId, uid) return nil, errs.ErrCannotModifyTransactionWithThisTransactionTime } allTransactionIds = append(allTransactionIds, transaction.TransactionId) } err = a.transactions.BatchClearAllTagsFromTransactions(c, uid, allTransactionIds) if err != nil { log.Errorf(c, "[transactions.TransactionBatchClearTagsHandler] failed to batch update transactions tags for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } log.Infof(c, "[transactions.TransactionBatchClearTagsHandler] user \"uid:%d\" has batch updated tag of %d transactions successfully", uid, len(allTransactionIds)) return true, nil } // TransactionMoveAllBetweenAccountsHandler moves all transactions from one account to another account for current user func (a *TransactionsApi) TransactionMoveAllBetweenAccountsHandler(c *core.WebContext) (any, *errs.Error) { var transactionMoveReq models.TransactionMoveBetweenAccountsRequest err := c.ShouldBindJSON(&transactionMoveReq) if err != nil { log.Warnf(c, "[transactions.TransactionMoveAllBetweenAccountsHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionMoveAllBetweenAccountsHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } uid := c.GetCurrentUid() user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionMoveAllBetweenAccountsHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } if transactionMoveReq.FromAccountId == transactionMoveReq.ToAccountId { return nil, errs.ErrCannotMoveTransactionToSameAccount } accountMap, err := a.accounts.GetAccountsByAccountIds(c, uid, []int64{transactionMoveReq.FromAccountId, transactionMoveReq.ToAccountId}) if err != nil { log.Errorf(c, "[transactions.TransactionMoveAllBetweenAccountsHandler] failed to get accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } fromAccount, exists := accountMap[transactionMoveReq.FromAccountId] if !exists { return nil, errs.ErrSourceAccountNotFound } toAccount, exists := accountMap[transactionMoveReq.ToAccountId] if !exists { return nil, errs.ErrDestinationAccountNotFound } if fromAccount.Hidden || toAccount.Hidden { return nil, errs.ErrCannotMoveTransactionFromOrToHiddenAccount } if fromAccount.Type == models.ACCOUNT_TYPE_MULTI_SUB_ACCOUNTS || toAccount.Type == models.ACCOUNT_TYPE_MULTI_SUB_ACCOUNTS { return nil, errs.ErrCannotMoveTransactionFromOrToParentAccount } if fromAccount.Currency != toAccount.Currency { return nil, errs.ErrCannotMoveTransactionBetweenAccountsWithDifferentCurrencies } transactions, err := a.transactions.GetAllSpecifiedTransactions(c, uid, 0, 0, 0, nil, []int64{fromAccount.AccountId}, nil, false, "", "", false, pageCountForMovingAccountTransactions, true) if err != nil { log.Errorf(c, "[transactions.TransactionMoveAllBetweenAccountsHandler] failed to get all transactions of account \"id:%d\" for user \"uid:%d\", because %s", fromAccount.AccountId, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allUsedAccounts, err := a.getTransactionUsedAccounts(c, uid, transactions) if err != nil { log.Errorf(c, "[transactions.TransactionMoveAllBetweenAccountsHandler] failed to get transaction used accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } for i := 0; i < len(transactions); i++ { transaction := transactions[i] transactionEditable := user.CanEditTransactionByTransactionTime(transaction.TransactionTime, clientTimezone, allUsedAccounts[transaction.AccountId], allUsedAccounts[transaction.RelatedAccountId]) newTransactionEditable := transactionEditable if transaction.AccountId == fromAccount.AccountId { newTransactionEditable = user.CanEditTransactionByTransactionTime(transaction.TransactionTime, clientTimezone, toAccount, allUsedAccounts[transaction.RelatedAccountId]) } else if transaction.RelatedAccountId == fromAccount.AccountId { newTransactionEditable = user.CanEditTransactionByTransactionTime(transaction.TransactionTime, clientTimezone, allUsedAccounts[transaction.AccountId], toAccount) } if !transactionEditable || !newTransactionEditable { log.Warnf(c, "[transactions.TransactionMoveAllBetweenAccountsHandler] transaction \"id:%d\" is not editable for user \"uid:%d\"", transaction.TransactionId, uid) return nil, errs.ErrCannotModifyTransactionWithThisTransactionTime } } err = a.transactions.MoveAllTransactionsBetweenAccounts(c, uid, fromAccount.AccountId, toAccount.AccountId) if err != nil { log.Errorf(c, "[transactions.TransactionMoveAllBetweenAccountsHandler] failed to move all transactions from account \"id:%d\" to account \"id:%d\" for user \"uid:%d\", because %s", transactionMoveReq.FromAccountId, transactionMoveReq.ToAccountId, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } log.Infof(c, "[transactions.TransactionMoveAllBetweenAccountsHandler] user \"uid:%d\" has moved all transactions from account \"id:%d\" to account \"id:%d\" successfully", uid, transactionMoveReq.FromAccountId, transactionMoveReq.ToAccountId) return true, nil } // TransactionDeleteHandler deletes an existed transaction by request parameters for current user func (a *TransactionsApi) TransactionDeleteHandler(c *core.WebContext) (any, *errs.Error) { var transactionDeleteReq models.TransactionDeleteRequest err := c.ShouldBindJSON(&transactionDeleteReq) if err != nil { log.Warnf(c, "[transactions.TransactionDeleteHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionDeleteHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } uid := c.GetCurrentUid() user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionDeleteHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } transaction, err := a.transactions.GetTransactionByTransactionId(c, uid, transactionDeleteReq.Id) if err != nil { log.Errorf(c, "[transactions.TransactionDeleteHandler] failed to get transaction \"id:%d\" for user \"uid:%d\", because %s", transactionDeleteReq.Id, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } if transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN { log.Warnf(c, "[transactions.TransactionDeleteHandler] cannot delete transaction \"id:%d\" for user \"uid:%d\", because transaction type is transfer in", transactionDeleteReq.Id, uid) return nil, errs.ErrTransactionTypeInvalid } allUsedAccounts, err := a.getTransactionUsedAccounts(c, uid, []*models.Transaction{transaction}) if err != nil { log.Errorf(c, "[transactions.TransactionDeleteHandler] failed to get transaction used accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } transactionEditable := user.CanEditTransactionByTransactionTime(transaction.TransactionTime, clientTimezone, allUsedAccounts[transaction.AccountId], allUsedAccounts[transaction.RelatedAccountId]) if !transactionEditable { return nil, errs.ErrCannotDeleteTransactionWithThisTransactionTime } err = a.transactions.DeleteTransaction(c, uid, transactionDeleteReq.Id) if err != nil { log.Errorf(c, "[transactions.TransactionDeleteHandler] failed to delete transaction \"id:%d\" for user \"uid:%d\", because %s", transactionDeleteReq.Id, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } log.Infof(c, "[transactions.TransactionDeleteHandler] user \"uid:%d\" has deleted transaction \"id:%d\"", uid, transactionDeleteReq.Id) return true, nil } // TransactionBatchDeleteHandler deletes existed transactions by request parameters for current user func (a *TransactionsApi) TransactionBatchDeleteHandler(c *core.WebContext) (any, *errs.Error) { var transactionBatchDeleteReq models.TransactionBatchDeleteRequest err := c.ShouldBindJSON(&transactionBatchDeleteReq) if err != nil { log.Warnf(c, "[transactions.TransactionBatchDeleteHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionBatchDeleteHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } transactionIds, err := utils.StringArrayToInt64Array(transactionBatchDeleteReq.Ids) if err != nil { log.Warnf(c, "[transactions.TransactionBatchDeleteHandler] parse transaction ids failed, because %s", err.Error()) return nil, errs.ErrTransactionIdInvalid } uid := c.GetCurrentUid() user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionBatchDeleteHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } if !a.users.IsPasswordEqualsUserPassword(transactionBatchDeleteReq.Password, user) { return nil, errs.ErrUserPasswordWrong } transactions, err := a.transactions.GetTransactionsByTransactionIds(c, uid, transactionIds) if err != nil { log.Errorf(c, "[transactions.TransactionBatchDeleteHandler] failed to get transactions for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allUsedAccounts, err := a.getTransactionUsedAccounts(c, uid, transactions) if err != nil { log.Errorf(c, "[transactions.TransactionBatchDeleteHandler] failed to get transaction used accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } for i := 0; i < len(transactions); i++ { transaction := transactions[i] transactionEditable := user.CanEditTransactionByTransactionTime(transaction.TransactionTime, clientTimezone, allUsedAccounts[transaction.AccountId], allUsedAccounts[transaction.RelatedAccountId]) if !transactionEditable { log.Warnf(c, "[transactions.TransactionBatchDeleteHandler] transaction \"id:%d\" is not editable for user \"uid:%d\"", transaction.TransactionId, uid) return nil, errs.ErrCannotDeleteTransactionWithThisTransactionTime } } deletedCount := 0 for i := 0; i < len(transactions); i++ { transaction := transactions[i] err = a.transactions.DeleteTransaction(c, uid, transaction.TransactionId) if err != nil { log.Errorf(c, "[transactions.TransactionBatchDeleteHandler] failed to delete transaction \"id:%d\" for user \"uid:%d\", because %s", transaction.TransactionId, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } deletedCount++ } log.Infof(c, "[transactions.TransactionBatchDeleteHandler] user \"uid:%d\" has deleted %d transactions", uid, deletedCount) return true, nil } // TransactionParseImportCustomFileDataHandler returns the parsed file data by request parameters for current user func (a *TransactionsApi) TransactionParseImportCustomFileDataHandler(c *core.WebContext) (any, *errs.Error) { uid := c.GetCurrentUid() form, err := c.MultipartForm() if err != nil { log.Errorf(c, "[transactions.TransactionParseImportCustomFileDataHandler] failed to get multi-part form data for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.ErrParameterInvalid } fileTypes := form.Value["fileType"] if len(fileTypes) < 1 || fileTypes[0] == "" { return nil, errs.ErrImportFileTypeIsEmpty } fileType := fileTypes[0] if !converters.IsCustomFileFormatFileType(fileType) { return nil, errs.Or(err, errs.ErrImportFileTypeNotSupported) } fileEncodings := form.Value["fileEncoding"] fileEncoding := "" if len(fileEncodings) > 0 { fileEncoding = fileEncodings[0] } dataParser, err := converters.CreateNewCustomFileFormatTransactionDataParser(fileType, fileEncoding) if err != nil { return nil, errs.Or(err, errs.ErrImportFileTypeNotSupported) } importFiles := form.File["file"] if len(importFiles) < 1 { log.Warnf(c, "[transactions.TransactionParseImportCustomFileDataHandler] there is no import file in request for user \"uid:%d\"", uid) return nil, errs.ErrNoFilesUpload } if importFiles[0].Size < 1 { log.Warnf(c, "[transactions.TransactionParseImportCustomFileDataHandler] the size of import file in request is zero for user \"uid:%d\"", uid) return nil, errs.ErrUploadedFileEmpty } if importFiles[0].Size > int64(a.CurrentConfig().MaxImportFileSize) { log.Warnf(c, "[transactions.TransactionParseImportCustomFileDataHandler] the upload file size \"%d\" exceeds the maximum size \"%d\" of import file for user \"uid:%d\"", importFiles[0].Size, a.CurrentConfig().MaxImportFileSize, uid) return nil, errs.ErrExceedMaxUploadFileSize } importFile, err := importFiles[0].Open() if err != nil { log.Errorf(c, "[transactions.TransactionParseImportCustomFileDataHandler] failed to get import file from request for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.ErrOperationFailed } defer importFile.Close() fileData, err := io.ReadAll(importFile) if err != nil { log.Errorf(c, "[transactions.TransactionParseImportCustomFileDataHandler] failed to read import file data for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } allLines, err := dataParser.ParseDataLines(c, fileData) if err != nil { log.Errorf(c, "[transactions.TransactionParseImportCustomFileDataHandler] failed to parse import file data for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } return allLines, nil } // TransactionParseImportFileHandler returns the parsed transaction data by request parameters for current user func (a *TransactionsApi) TransactionParseImportFileHandler(c *core.WebContext) (any, *errs.Error) { uid := c.GetCurrentUid() form, err := c.MultipartForm() if err != nil { log.Errorf(c, "[transactions.TransactionParseImportFileHandler] failed to get multi-part form data for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.ErrParameterInvalid } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionParseImportFileHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } fileTypes := form.Value["fileType"] if len(fileTypes) < 1 || fileTypes[0] == "" { return nil, errs.ErrImportFileTypeIsEmpty } fileType := fileTypes[0] textualOptions := form.Value["options"] textualOption := "" if len(textualOptions) > 0 { textualOption = textualOptions[0] } additionalOptions := converter.ParseImporterOptions(textualOption) var dataImporter converter.TransactionDataImporter if converters.IsCustomFileFormatFileType(fileType) { fileEncodings := form.Value["fileEncoding"] fileEncoding := "" if len(fileEncodings) > 0 { fileEncoding = fileEncodings[0] } columnMappings := form.Value["columnMapping"] if len(columnMappings) < 1 || columnMappings[0] == "" { return nil, errs.ErrImportFileColumnMappingInvalid } var columnIndexMapping = map[datatable.TransactionDataTableColumn]int{} err = json.Unmarshal([]byte(columnMappings[0]), &columnIndexMapping) if err != nil { log.Errorf(c, "[transactions.TransactionParseImportFileHandler] failed to parse column mapping for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.ErrImportFileColumnMappingInvalid } transactionTypeMappings := form.Value["transactionTypeMapping"] if len(transactionTypeMappings) < 1 || transactionTypeMappings[0] == "" { return nil, errs.ErrImportFileTransactionTypeMappingInvalid } var transactionTypeNameMapping = map[string]models.TransactionType{} err = json.Unmarshal([]byte(transactionTypeMappings[0]), &transactionTypeNameMapping) if err != nil { log.Errorf(c, "[transactions.TransactionParseImportFileHandler] failed to parse transaction type mapping for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.ErrImportFileTransactionTypeMappingInvalid } hasHeaderLines := form.Value["hasHeaderLine"] hasHeaderLine := false if len(hasHeaderLines) > 0 { hasHeaderLine = hasHeaderLines[0] == "true" } timeFormats := form.Value["timeFormat"] if len(timeFormats) < 1 || timeFormats[0] == "" { return nil, errs.ErrImportFileTransactionTimeFormatInvalid } timezoneFormats := form.Value["timezoneFormat"] timezoneFormat := "" if len(timezoneFormats) > 0 { timezoneFormat = timezoneFormats[0] } amountDecimalSeparators := form.Value["amountDecimalSeparator"] amountDecimalSeparator := "" if len(amountDecimalSeparators) > 0 { amountDecimalSeparator = amountDecimalSeparators[0] } amountDigitGroupingSymbols := form.Value["amountDigitGroupingSymbol"] amountDigitGroupingSymbol := "" if len(amountDigitGroupingSymbols) > 0 { amountDigitGroupingSymbol = amountDigitGroupingSymbols[0] } geoLocationSeparators := form.Value["geoSeparator"] geoLocationSeparator := "" if len(geoLocationSeparators) > 0 { geoLocationSeparator = geoLocationSeparators[0] } geoLocationOrders := form.Value["geoOrder"] geoLocationOrder := "" if len(geoLocationOrders) > 0 { geoLocationOrder = geoLocationOrders[0] } transactionTagSeparators := form.Value["tagSeparator"] transactionTagSeparator := "" if len(transactionTagSeparators) > 0 { transactionTagSeparator = transactionTagSeparators[0] } dataImporter, err = converters.CreateNewCustomTransactionDataImporter(fileType, fileEncoding, columnIndexMapping, transactionTypeNameMapping, hasHeaderLine, timeFormats[0], timezoneFormat, amountDecimalSeparator, amountDigitGroupingSymbol, geoLocationSeparator, geoLocationOrder, transactionTagSeparator) } else { dataImporter, err = converters.GetTransactionDataImporter(fileType) } if err != nil { return nil, errs.Or(err, errs.ErrImportFileTypeNotSupported) } importFiles := form.File["file"] if len(importFiles) < 1 { log.Warnf(c, "[transactions.TransactionParseImportFileHandler] there is no import file in request for user \"uid:%d\"", uid) return nil, errs.ErrNoFilesUpload } if importFiles[0].Size < 1 { log.Warnf(c, "[transactions.TransactionParseImportFileHandler] the size of import file in request is zero for user \"uid:%d\"", uid) return nil, errs.ErrUploadedFileEmpty } if importFiles[0].Size > int64(a.CurrentConfig().MaxImportFileSize) { log.Warnf(c, "[transactions.TransactionParseImportFileHandler] the upload file size \"%d\" exceeds the maximum size \"%d\" of import file for user \"uid:%d\"", importFiles[0].Size, a.CurrentConfig().MaxImportFileSize, uid) return nil, errs.ErrExceedMaxUploadFileSize } importFile, err := importFiles[0].Open() if err != nil { log.Errorf(c, "[transactions.TransactionParseImportFileHandler] failed to get import file from request for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.ErrOperationFailed } defer importFile.Close() fileData, err := io.ReadAll(importFile) if err != nil { log.Errorf(c, "[transactions.TransactionParseImportFileHandler] failed to read import file data for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionParseImportFileHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } if user.FeatureRestriction.Contains(core.USER_FEATURE_RESTRICTION_TYPE_IMPORT_TRANSACTION) { return nil, errs.ErrNotPermittedToPerformThisAction } accounts, err := a.accounts.GetAllAccountsByUid(c, user.Uid) if err != nil { log.Errorf(c, "[transactions.TransactionParseImportFileHandler] failed to get accounts for user \"uid:%d\", because %s", user.Uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } accountMap := a.accounts.GetVisibleAccountNameMapByList(accounts) categories, err := a.transactionCategories.GetAllCategoriesByUid(c, user.Uid, 0, -1) if err != nil { log.Errorf(c, "[transactions.TransactionParseImportFileHandler] failed to get categories for user \"uid:%d\", because %s", user.Uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } expenseCategoryMap, incomeCategoryMap, transferCategoryMap := a.transactionCategories.GetVisibleSubCategoryNameMapByList(categories) tags, err := a.transactionTags.GetAllTagsByUid(c, user.Uid) if err != nil { log.Errorf(c, "[transactions.TransactionParseImportFileHandler] failed to get tags for user \"uid:%d\", because %s", user.Uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } tagMap := a.transactionTags.GetVisibleTagNameMapByList(tags) parsedTransactions, _, _, _, _, _, err := dataImporter.ParseImportedData(c, user, fileData, clientTimezone, additionalOptions, accountMap, expenseCategoryMap, incomeCategoryMap, transferCategoryMap, tagMap) if err != nil { log.Errorf(c, "[transactions.TransactionParseImportFileHandler] failed to parse imported data for user \"uid:%d\", because %s", user.Uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } parsedTransactionRespsList := parsedTransactions.ToImportTransactionResponseList() if len(parsedTransactionRespsList) < 1 { return nil, errs.ErrNoDataToImport } parsedTransactionResps := &models.ImportTransactionResponsePageWrapper{ Items: parsedTransactionRespsList, TotalCount: int64(len(parsedTransactionRespsList)), } return parsedTransactionResps, nil } // TransactionImportHandler imports transactions by request parameters for current user func (a *TransactionsApi) TransactionImportHandler(c *core.WebContext) (any, *errs.Error) { var transactionImportReq models.TransactionImportRequest err := c.ShouldBindJSON(&transactionImportReq) if err != nil { log.Warnf(c, "[transactions.TransactionImportHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } clientTimezone, err := c.GetClientTimezone() if err != nil { log.Warnf(c, "[transactions.TransactionImportHandler] cannot get client timezone, because %s", err.Error()) return nil, errs.ErrClientTimezoneOffsetInvalid } uid := c.GetCurrentUid() if a.CurrentConfig().EnableDuplicateSubmissionsCheck && transactionImportReq.ClientSessionId != "" { found, remark := a.GetSubmissionRemark(duplicatechecker.DUPLICATE_CHECKER_TYPE_IMPORT_TRANSACTIONS, uid, transactionImportReq.ClientSessionId) if found { items := strings.Split(remark, ":") if len(items) >= 2 { if items[0] == "finished" { log.Infof(c, "[transactions.TransactionImportHandler] another \"%s\" transactions has been imported for user \"uid:%d\"", items[1], uid) count, err := utils.StringToInt(items[1]) if err == nil { return count, nil } } else if items[0] == "processing" { return nil, errs.ErrRepeatedRequest } } else { log.Warnf(c, "[transactions.TransactionImportHandler] another transaction import task may be executing, but remark \"%s\" is invalid", remark) } } } newTransactionTagIdsMap := make(map[int][]int64, len(transactionImportReq.Transactions)) for i := 0; i < len(transactionImportReq.Transactions); i++ { transactionCreateReq := transactionImportReq.Transactions[i] tagIds, err := utils.StringArrayToInt64Array(transactionCreateReq.TagIds) if err != nil { log.Warnf(c, "[transactions.TransactionImportHandler] parse tag ids failed of transaction \"index:%d\", because %s", i, err.Error()) return nil, errs.ErrTransactionTagIdInvalid } if len(tagIds) > models.MaximumTagsCountOfTransaction { return nil, errs.ErrTransactionHasTooManyTags } if transactionCreateReq.Type < models.TRANSACTION_TYPE_MODIFY_BALANCE || transactionCreateReq.Type > models.TRANSACTION_TYPE_TRANSFER { log.Warnf(c, "[transactions.TransactionImportHandler] transaction type of transaction \"index:%d\" is invalid", i) return nil, errs.ErrTransactionTypeInvalid } if transactionCreateReq.Type == models.TRANSACTION_TYPE_MODIFY_BALANCE && transactionCreateReq.CategoryId != 0 { log.Warnf(c, "[transactions.TransactionImportHandler] balance modification transaction \"index:%d\" cannot set category id", i) return nil, errs.ErrBalanceModificationTransactionCannotSetCategory } if transactionCreateReq.Type != models.TRANSACTION_TYPE_TRANSFER && transactionCreateReq.DestinationAccountId != 0 { log.Warnf(c, "[transactions.TransactionImportHandler] non-transfer transaction \"index:%d\" destination account cannot be set", i) return nil, errs.ErrTransactionDestinationAccountCannotBeSet } else if transactionCreateReq.Type == models.TRANSACTION_TYPE_TRANSFER && transactionCreateReq.SourceAccountId == transactionCreateReq.DestinationAccountId { log.Warnf(c, "[transactions.TransactionImportHandler] transfer transaction \"index:%d\" source account must not be destination account", i) return nil, errs.ErrTransactionSourceAndDestinationIdCannotBeEqual } if transactionCreateReq.Type != models.TRANSACTION_TYPE_TRANSFER && transactionCreateReq.DestinationAmount != 0 { log.Warnf(c, "[transactions.TransactionImportHandler] non-transfer transaction \"index:%d\" destination amount cannot be set", i) return nil, errs.ErrTransactionDestinationAmountCannotBeSet } newTransactionTagIdsMap[i] = tagIds } user, err := a.users.GetUserById(c, uid) if err != nil { if !errs.IsCustomError(err) { log.Errorf(c, "[transactions.TransactionImportHandler] failed to get user, because %s", err.Error()) } return nil, errs.ErrUserNotFound } if user.FeatureRestriction.Contains(core.USER_FEATURE_RESTRICTION_TYPE_IMPORT_TRANSACTION) { return nil, errs.ErrNotPermittedToPerformThisAction } newTransactions := make([]*models.Transaction, len(transactionImportReq.Transactions)) for i := 0; i < len(transactionImportReq.Transactions); i++ { transactionCreateReq := transactionImportReq.Transactions[i] transaction := a.createNewTransactionModel(uid, transactionCreateReq, c.ClientIP()) newTransactions[i] = transaction } allUsedAccounts, err := a.getTransactionUsedAccounts(c, uid, newTransactions) if err != nil { log.Errorf(c, "[transactions.TransactionImportHandler] failed to get transaction used accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } for i := 0; i < len(newTransactions); i++ { transaction := newTransactions[i] transactionEditable := user.CanEditTransactionByTransactionTime(transaction.TransactionTime, clientTimezone, allUsedAccounts[transaction.AccountId], allUsedAccounts[transaction.RelatedAccountId]) if !transactionEditable { log.Warnf(c, "[transactions.TransactionImportHandler] transaction \"index:%d\" is not editable for user \"uid:%d\"", i, uid) return nil, errs.ErrCannotCreateTransactionWithThisTransactionTime } } err = a.transactions.BatchCreateTransactions(c, user.Uid, newTransactions, newTransactionTagIdsMap, func(currentProcess float64) { a.SetSubmissionRemarkIfEnable(duplicatechecker.DUPLICATE_CHECKER_TYPE_IMPORT_TRANSACTIONS, uid, transactionImportReq.ClientSessionId, fmt.Sprintf("processing:%.2f", currentProcess)) }) count := len(newTransactions) if err != nil { a.RemoveSubmissionRemarkIfEnable(duplicatechecker.DUPLICATE_CHECKER_TYPE_IMPORT_TRANSACTIONS, uid, transactionImportReq.ClientSessionId) log.Errorf(c, "[transactions.TransactionImportHandler] failed to import %d transactions for user \"uid:%d\", because %s", count, uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } log.Infof(c, "[transactions.TransactionImportHandler] user \"uid:%d\" has imported %d transactions successfully", uid, count) a.SetSubmissionRemarkIfEnable(duplicatechecker.DUPLICATE_CHECKER_TYPE_IMPORT_TRANSACTIONS, uid, transactionImportReq.ClientSessionId, fmt.Sprintf("finished:%d", count)) return count, nil } // TransactionImportProcessHandler returns the process of specified transaction import task by request parameters for current user func (a *TransactionsApi) TransactionImportProcessHandler(c *core.WebContext) (any, *errs.Error) { var transactionImportProcessReq models.TransactionImportProcessRequest err := c.ShouldBindQuery(&transactionImportProcessReq) if err != nil { log.Warnf(c, "[transactions.TransactionImportProcessHandler] parse request failed, because %s", err.Error()) return nil, errs.NewIncompleteOrIncorrectSubmissionError(err) } uid := c.GetCurrentUid() if !a.CurrentConfig().EnableDuplicateSubmissionsCheck { return nil, nil } found, remark := a.GetSubmissionRemark(duplicatechecker.DUPLICATE_CHECKER_TYPE_IMPORT_TRANSACTIONS, uid, transactionImportProcessReq.ClientSessionId) if !found { return nil, nil } items := strings.Split(remark, ":") if len(items) < 2 { return nil, nil } if items[0] == "finished" { return 100, nil } else if items[0] != "processing" { return nil, nil } process, err := utils.StringToFloat64(items[1]) if err != nil { log.Warnf(c, "[transactions.TransactionImportProcessHandler] parse process failed, because %s", err.Error()) return nil, nil } if process < 0 { return nil, nil } else if process >= 100 { process = 100 } return process, nil } func (a *TransactionsApi) filterTransactions(c *core.WebContext, uid int64, transactions []*models.Transaction, accountMap map[int64]*models.Account) []*models.Transaction { finalTransactions := make([]*models.Transaction, 0, len(transactions)) for i := 0; i < len(transactions); i++ { transaction := transactions[i] if _, exists := accountMap[transaction.AccountId]; !exists { log.Warnf(c, "[transactions.filterTransactions] account of transaction \"id:%d\" does not exist for user \"uid:%d\"", transaction.TransactionId, uid) continue } if transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN || transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_OUT { if _, exists := accountMap[transaction.RelatedAccountId]; !exists { log.Warnf(c, "[transactions.filterTransactions] related account of transaction \"id:%d\" does not exist for user \"uid:%d\"", transaction.TransactionId, uid) continue } } finalTransactions = append(finalTransactions, transaction) } return finalTransactions } func (a *TransactionsApi) getTransactionTagInfoResponses(tagIds []int64, allTransactionTags map[int64]*models.TransactionTag) []*models.TransactionTagInfoResponse { allTags := make([]*models.TransactionTagInfoResponse, 0, len(tagIds)) for i := 0; i < len(tagIds); i++ { tag := allTransactionTags[tagIds[i]] if tag == nil { continue } allTags = append(allTags, tag.ToTransactionTagInfoResponse()) } return allTags } func (a *TransactionsApi) getTransactionAllEssentialData(c *core.WebContext, user *models.User, withPictures bool, trimCategory bool, trimTag bool) (accountMap map[int64]*models.Account, categoryMap map[int64]*models.TransactionCategory, tagMap map[int64]*models.TransactionTag, allTransactionTagIds map[int64][]int64, pictureInfoMap map[int64][]*models.TransactionPictureInfo, err error) { uid := user.Uid allAccounts, err := a.accounts.GetAllAccountsByUid(c, uid) if err != nil { log.Errorf(c, "[transactions.getTransactionAllEssentialData] failed to get all accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, nil, nil, nil, nil, err } accountMap = a.accounts.GetAccountMapByList(allAccounts) allTagIndexes, err := a.transactionTags.GetAllTagIdsOfAllTransactions(c, uid) if err != nil { log.Errorf(c, "[transactions.getTransactionAllEssentialData] failed to get all transactions tag ids for user \"uid:%d\", because %s", uid, err.Error()) return nil, nil, nil, nil, nil, err } allTransactionTagIds = a.transactionTags.GetGroupedTransactionTagIds(allTagIndexes) if !trimCategory { allCategories, err := a.transactionCategories.GetAllCategoriesByUid(c, uid, 0, -1) if err != nil { log.Errorf(c, "[transactions.getTransactionAllEssentialData] failed to get all transactions categories for user \"uid:%d\", because %s", uid, err.Error()) return nil, nil, nil, nil, nil, err } categoryMap = a.transactionCategories.GetCategoryMapByList(allCategories) } if !trimTag { allTags, err := a.transactionTags.GetAllTagsByUid(c, uid) if err != nil { log.Errorf(c, "[transactions.getTransactionAllEssentialData] failed to get all transactions tags for user \"uid:%d\", because %s", uid, err.Error()) return nil, nil, nil, nil, nil, err } tagMap = a.transactionTags.GetTagMapByList(allTags) } if withPictures && a.CurrentConfig().EnableTransactionPictures { pictureInfoMap, err = a.transactionPictures.GetAllPictureInfosOfAllTransactions(c, uid) if err != nil { log.Errorf(c, "[transactions.getTransactionAllEssentialData] failed to get all transactions pictures for user \"uid:%d\", because %s", uid, err.Error()) return nil, nil, nil, nil, nil, err } } return accountMap, categoryMap, tagMap, allTransactionTagIds, pictureInfoMap, nil } func (a *TransactionsApi) getTransactionEssentialDataByTransactionIds(c *core.WebContext, user *models.User, transactions []*models.Transaction, withPictures bool, trimCategory bool, trimTag bool) (accountMap map[int64]*models.Account, categoryMap map[int64]*models.TransactionCategory, tagMap map[int64]*models.TransactionTag, allTransactionTagIds map[int64][]int64, pictureInfoMap map[int64][]*models.TransactionPictureInfo, err error) { uid := user.Uid transactionIds := make([]int64, len(transactions)) accountIds := make([]int64, 0, len(transactions)*2) categoryIds := make([]int64, 0, len(transactions)) for i := 0; i < len(transactions); i++ { transactionId := transactions[i].TransactionId if transactions[i].Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN { transactionId = transactions[i].RelatedId } transactionIds[i] = transactionId accountIds = append(accountIds, transactions[i].AccountId) if transactions[i].Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN || transactions[i].Type == models.TRANSACTION_DB_TYPE_TRANSFER_OUT { accountIds = append(accountIds, transactions[i].RelatedAccountId) } categoryIds = append(categoryIds, transactions[i].CategoryId) } accountMap, err = a.accounts.GetAccountsByAccountIds(c, uid, utils.ToUniqueInt64Slice(accountIds)) if err != nil { log.Errorf(c, "[transactions.getTransactionEssentialDataByTransactionIds] failed to get accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, nil, nil, nil, nil, err } allTransactionTagIds, err = a.transactionTags.GetAllTagIdsOfTransactions(c, uid, transactionIds) if err != nil { log.Errorf(c, "[transactions.getTransactionEssentialDataByTransactionIds] failed to get transactions tag ids for user \"uid:%d\", because %s", uid, err.Error()) return nil, nil, nil, nil, nil, err } if !trimCategory { categoryMap, err = a.transactionCategories.GetCategoriesByCategoryIds(c, uid, utils.ToUniqueInt64Slice(categoryIds)) if err != nil { log.Errorf(c, "[transactions.getTransactionEssentialDataByTransactionIds] failed to get transactions categories for user \"uid:%d\", because %s", uid, err.Error()) return nil, nil, nil, nil, nil, err } } if !trimTag { tagMap, err = a.transactionTags.GetTagsByTagIds(c, uid, utils.ToUniqueInt64Slice(a.transactionTags.GetTransactionTagIds(allTransactionTagIds))) if err != nil { log.Errorf(c, "[transactions.getTransactionEssentialDataByTransactionIds] failed to get transactions tags for user \"uid:%d\", because %s", uid, err.Error()) return nil, nil, nil, nil, nil, err } } if withPictures && a.CurrentConfig().EnableTransactionPictures { pictureInfoMap, err = a.transactionPictures.GetPictureInfosByTransactionIds(c, uid, utils.ToUniqueInt64Slice(a.transactions.GetTransactionIds(transactions))) if err != nil { log.Errorf(c, "[transactions.getTransactionEssentialDataByTransactionIds] failed to get transactions pictures for user \"uid:%d\", because %s", uid, err.Error()) return nil, nil, nil, nil, nil, err } } return accountMap, categoryMap, tagMap, allTransactionTagIds, pictureInfoMap, nil } func (a *TransactionsApi) getTransactionUsedAccounts(c *core.WebContext, uid int64, transactions []*models.Transaction) (map[int64]*models.Account, error) { accountIds := make([]int64, 0, len(transactions)*2) for i := 0; i < len(transactions); i++ { accountIds = append(accountIds, transactions[i].AccountId) if transactions[i].Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN || transactions[i].Type == models.TRANSACTION_DB_TYPE_TRANSFER_OUT { accountIds = append(accountIds, transactions[i].RelatedAccountId) } } accountMap, err := a.accounts.GetAccountsByAccountIds(c, uid, utils.ToUniqueInt64Slice(accountIds)) if err != nil { log.Errorf(c, "[transactions.getTransactionUsedAccounts] failed to get accounts for user \"uid:%d\", because %s", uid, err.Error()) return nil, errs.Or(err, errs.ErrOperationFailed) } for i := 0; i < len(transactions); i++ { if _, exists := accountMap[transactions[i].AccountId]; !exists { log.Warnf(c, "[transactions.getTransactionUsedAccounts] account of transaction \"id:%d\" does not exist for user \"uid:%d\"", transactions[i].TransactionId, uid) return nil, errs.ErrSourceAccountNotFound } if transactions[i].Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN || transactions[i].Type == models.TRANSACTION_DB_TYPE_TRANSFER_OUT { if _, exists := accountMap[transactions[i].RelatedAccountId]; !exists { log.Warnf(c, "[transactions.getTransactionUsedAccounts] related account of transaction \"id:%d\" does not exist for user \"uid:%d\"", transactions[i].TransactionId, uid) return nil, errs.ErrDestinationAccountNotFound } } } return accountMap, nil } func (a *TransactionsApi) getTransactionResponseListResult(c *core.WebContext, user *models.User, transactions []*models.Transaction, allAccounts map[int64]*models.Account, categoryMap map[int64]*models.TransactionCategory, tagMap map[int64]*models.TransactionTag, allTransactionTagIds map[int64][]int64, pictureInfoMap map[int64][]*models.TransactionPictureInfo, clientTimezone *time.Location, withPictures bool, trimAccount bool, trimCategory bool, trimTag bool) (models.TransactionInfoResponseSlice, error) { result := make(models.TransactionInfoResponseSlice, len(transactions)) for i := 0; i < len(transactions); i++ { transaction := transactions[i] if transaction.Type == models.TRANSACTION_DB_TYPE_TRANSFER_IN { transaction = a.transactions.GetRelatedTransferTransaction(transaction) } transactionEditable := transaction.IsEditable(user, clientTimezone, allAccounts[transaction.AccountId], allAccounts[transaction.RelatedAccountId]) transactionTagIds := allTransactionTagIds[transaction.TransactionId] result[i] = transaction.ToTransactionInfoResponse(transactionTagIds, transactionEditable) if !trimAccount { if sourceAccount := allAccounts[transaction.AccountId]; sourceAccount != nil { result[i].SourceAccount = sourceAccount.ToAccountInfoResponse() } if destinationAccount := allAccounts[transaction.RelatedAccountId]; destinationAccount != nil { result[i].DestinationAccount = destinationAccount.ToAccountInfoResponse() } } if !trimCategory && categoryMap != nil { if category := categoryMap[transaction.CategoryId]; category != nil { result[i].Category = category.ToTransactionCategoryInfoResponse() } } if !trimTag && tagMap != nil && transactionTagIds != nil { result[i].Tags = a.getTransactionTagInfoResponses(transactionTagIds, tagMap) } if withPictures && a.CurrentConfig().EnableTransactionPictures && pictureInfoMap != nil { pictureInfos, exists := pictureInfoMap[transaction.TransactionId] if exists { result[i].Pictures = a.GetTransactionPictureInfoResponseList(pictureInfos) } } } sort.Sort(result) return result, nil } func (a *TransactionsApi) createNewTransactionModel(uid int64, transactionCreateReq *models.TransactionCreateRequest, clientIp string) *models.Transaction { var transactionDbType models.TransactionDbType if transactionCreateReq.Type == models.TRANSACTION_TYPE_MODIFY_BALANCE { transactionDbType = models.TRANSACTION_DB_TYPE_MODIFY_BALANCE } else if transactionCreateReq.Type == models.TRANSACTION_TYPE_EXPENSE { transactionDbType = models.TRANSACTION_DB_TYPE_EXPENSE } else if transactionCreateReq.Type == models.TRANSACTION_TYPE_INCOME { transactionDbType = models.TRANSACTION_DB_TYPE_INCOME } else if transactionCreateReq.Type == models.TRANSACTION_TYPE_TRANSFER { transactionDbType = models.TRANSACTION_DB_TYPE_TRANSFER_OUT } transaction := &models.Transaction{ Uid: uid, Type: transactionDbType, CategoryId: transactionCreateReq.CategoryId, TransactionTime: utils.GetMinTransactionTimeFromUnixTime(transactionCreateReq.Time), TimezoneUtcOffset: transactionCreateReq.UtcOffset, AccountId: transactionCreateReq.SourceAccountId, Amount: transactionCreateReq.SourceAmount, HideAmount: transactionCreateReq.HideAmount, Comment: transactionCreateReq.Comment, CreatedIp: clientIp, } if transactionCreateReq.Type == models.TRANSACTION_TYPE_TRANSFER { transaction.RelatedAccountId = transactionCreateReq.DestinationAccountId transaction.RelatedAccountAmount = transactionCreateReq.DestinationAmount } if transactionCreateReq.GeoLocation != nil { transaction.GeoLongitude = transactionCreateReq.GeoLocation.Longitude transaction.GeoLatitude = transactionCreateReq.GeoLocation.Latitude } return transaction }