support batch update tags for transactions

This commit is contained in:
MaysWind
2026-04-26 00:52:44 +08:00
parent bab7a0041b
commit 1e38d1b18b
29 changed files with 924 additions and 6 deletions
+285
View File
@@ -1588,6 +1588,291 @@ func (a *TransactionsApi) TransactionBatchUpdateAccountsHandler(c *core.WebConte
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)
}
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)
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)
}
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)
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)
}
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)
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
+1
View File
@@ -45,4 +45,5 @@ var (
ErrCannotMoveTransactionFromOrToHiddenAccount = NewNormalError(NormalSubcategoryTransaction, 38, http.StatusBadRequest, "cannot move transaction from or to hidden account")
ErrCannotMoveTransactionFromOrToParentAccount = NewNormalError(NormalSubcategoryTransaction, 39, http.StatusBadRequest, "cannot move transaction from or to parent account")
ErrCannotMoveTransactionBetweenAccountsWithDifferentCurrencies = NewNormalError(NormalSubcategoryTransaction, 40, http.StatusBadRequest, "cannot move transaction between accounts with different currencies")
ErrCannotAddTagsToTooManyTransactionsOneTime = NewNormalError(NormalSubcategoryTransaction, 41, http.StatusBadRequest, "cannot add tags to too many transactions one time")
)
+19 -2
View File
@@ -327,17 +327,34 @@ type TransactionGetRequest struct {
// TransactionBatchUpdateCategoryRequest represents all parameters of transaction batch update category request
type TransactionBatchUpdateCategoryRequest struct {
TransactionIds []string `json:"transactionIds,string" binding:"required"`
TransactionIds []string `json:"transactionIds" binding:"required"`
CategoryId int64 `json:"categoryId,string" binding:"required"`
}
// TransactionBatchUpdateAccountRequest represents all parameters of transaction batch update account request
type TransactionBatchUpdateAccountRequest struct {
TransactionIds []string `json:"transactionIds,string" binding:"required"`
TransactionIds []string `json:"transactionIds" binding:"required"`
AccountId int64 `json:"accountId,string" binding:"required"`
IsDestinationAccount bool `json:"isDestinationAccount"`
}
// TransactionBatchAddTagsRequest represents all parameters of transaction batch add tags request
type TransactionBatchAddTagsRequest struct {
TransactionIds []string `json:"transactionIds" binding:"required"`
TagIds []string `json:"tagIds" binding:"required"`
}
// TransactionBatchRemoveTagsRequest represents all parameters of transaction batch remove tags request
type TransactionBatchRemoveTagsRequest struct {
TransactionIds []string `json:"transactionIds" binding:"required"`
TagIds []string `json:"tagIds" binding:"required"`
}
// TransactionBatchClearTagsRequest represents all parameters of transaction batch clear tags request
type TransactionBatchClearTagsRequest struct {
TransactionIds []string `json:"transactionIds" binding:"required"`
}
// TransactionMoveBetweenAccountsRequest represents all parameters of moving all transactions between accounts request
type TransactionMoveBetweenAccountsRequest struct {
FromAccountId int64 `json:"fromAccountId,string" binding:"required,min=1"`
+158 -4
View File
@@ -1033,7 +1033,7 @@ func (s *TransactionService) ModifyTransaction(c core.Context, transaction *mode
}
// Get and verify tags
err = s.isTagsValid(sess, transaction, transactionTagIndexes, addTagIds)
err = s.isTagsValid(sess, transaction.Uid, transactionTagIndexes, addTagIds)
if err != nil {
return err
@@ -1373,6 +1373,160 @@ func (s *TransactionService) BatchUpdateTransactionsCategory(c core.Context, uid
})
}
// BatchAddTagsToTransactions batch adds tags to transactions
func (s *TransactionService) BatchAddTagsToTransactions(c core.Context, uid int64, transactions []*models.Transaction, addTransactionTagIds map[int64][]int64) error {
if uid <= 0 {
return errs.ErrUserIdInvalid
}
if len(addTransactionTagIds) < 1 {
return errs.ErrTransactionIdInvalid
}
now := time.Now().Unix()
transactionTagIndexes := make([]*models.TransactionTagIndex, 0, len(addTransactionTagIds))
transactionsMap := make(map[int64]*models.Transaction, len(transactions))
transactionTagIdsMap := make(map[int64]bool, 0)
for i := 0; i < len(transactions); i++ {
transaction := transactions[i]
transactionsMap[transaction.TransactionId] = transaction
}
for transactionId, tagIds := range addTransactionTagIds {
if transactionId <= 0 {
return errs.ErrTransactionIdInvalid
}
transaction, exists := transactionsMap[transactionId]
if !exists || transaction == nil {
return errs.ErrTransactionNotFound
}
tagIds = utils.ToUniqueInt64Slice(tagIds)
for i := 0; i < len(tagIds); i++ {
tagId := tagIds[i]
if tagId <= 0 {
return errs.ErrTransactionTagIdInvalid
}
transactionTagIndexes = append(transactionTagIndexes, &models.TransactionTagIndex{
Uid: uid,
Deleted: false,
TransactionTime: transaction.TransactionTime,
TagId: tagId,
TransactionId: transactionId,
CreatedUnixTime: now,
UpdatedUnixTime: now,
})
transactionTagIdsMap[tagId] = true
}
}
tagIndexUuids := s.GenerateUuids(uuid.UUID_TYPE_TAG_INDEX, uint16(len(transactionTagIndexes)))
if len(tagIndexUuids) < len(transactionTagIndexes) {
return errs.ErrCannotAddTagsToTooManyTransactionsOneTime
}
for i := 0; i < len(transactionTagIndexes); i++ {
transactionTagIndexes[i].TagIndexId = tagIndexUuids[i]
}
tagIds := make([]int64, 0, len(transactionTagIdsMap))
for tagId := range transactionTagIdsMap {
tagIds = append(tagIds, tagId)
}
return s.UserDataDB(uid).DoTransaction(c, func(sess *xorm.Session) error {
// Get and verify tags
err := s.isTagsValid(sess, uid, transactionTagIndexes, tagIds)
if err != nil {
return err
}
for i := 0; i < len(transactionTagIndexes); i++ {
transactionTagIndex := transactionTagIndexes[i]
_, err := sess.Insert(transactionTagIndex)
if err != nil {
return err
}
}
return nil
})
}
// BatchRemoveTagsFromTransactions batch removes tags from transactions
func (s *TransactionService) BatchRemoveTagsFromTransactions(c core.Context, uid int64, transactionIds []int64, tagIds []int64) error {
if uid <= 0 {
return errs.ErrUserIdInvalid
}
if len(transactionIds) < 1 {
return errs.ErrTransactionIdInvalid
}
uniqueTransactionIds := utils.ToUniqueInt64Slice(transactionIds)
uniqueTagIds := utils.ToUniqueInt64Slice(tagIds)
now := time.Now().Unix()
tagIndexUpdateModel := &models.TransactionTagIndex{
Deleted: true,
DeletedUnixTime: now,
}
return s.UserDataDB(uid).DoTransaction(c, func(sess *xorm.Session) error {
deletedRows, err := sess.Cols("deleted", "deleted_unix_time").Where("uid=? AND deleted=?", uid, false).In("transaction_id", uniqueTransactionIds).In("tag_id", uniqueTagIds).Update(tagIndexUpdateModel)
if err != nil {
return err
} else if deletedRows < 1 {
return errs.ErrTransactionTagNotFound
}
return nil
})
}
// BatchClearAllTagsFromTransactions batch clears all tags from transactions
func (s *TransactionService) BatchClearAllTagsFromTransactions(c core.Context, uid int64, transactionIds []int64) error {
if uid <= 0 {
return errs.ErrUserIdInvalid
}
if len(transactionIds) < 1 {
return errs.ErrTransactionIdInvalid
}
uniqueTransactionIds := utils.ToUniqueInt64Slice(transactionIds)
now := time.Now().Unix()
tagIndexUpdateModel := &models.TransactionTagIndex{
Deleted: true,
DeletedUnixTime: now,
}
return s.UserDataDB(uid).DoTransaction(c, func(sess *xorm.Session) error {
deletedRows, err := sess.Cols("deleted", "deleted_unix_time").Where("uid=? AND deleted=?", uid, false).In("transaction_id", uniqueTransactionIds).Update(tagIndexUpdateModel)
if err != nil {
return err
} else if deletedRows < 1 {
return errs.ErrTransactionTagNotFound
}
return nil
})
}
// MoveAllTransactionsBetweenAccounts moves all transactions from one account to another account, and combine balance modification transactions if necessary
func (s *TransactionService) MoveAllTransactionsBetweenAccounts(c core.Context, uid int64, fromAccountId int64, toAccountId int64) error {
if uid <= 0 {
@@ -2317,7 +2471,7 @@ func (s *TransactionService) doCreateTransaction(c core.Context, database *datas
}
// Get and verify tags
err = s.isTagsValid(sess, transaction, transactionTagIndexes, tagIds)
err = s.isTagsValid(sess, transaction.Uid, transactionTagIndexes, tagIds)
if err != nil {
return err
@@ -2954,10 +3108,10 @@ func (s *TransactionService) isCategoryValid(sess *xorm.Session, transaction *mo
return nil
}
func (s *TransactionService) isTagsValid(sess *xorm.Session, transaction *models.Transaction, transactionTagIndexes []*models.TransactionTagIndex, tagIds []int64) error {
func (s *TransactionService) isTagsValid(sess *xorm.Session, uid int64, transactionTagIndexes []*models.TransactionTagIndex, tagIds []int64) error {
if len(transactionTagIndexes) > 0 {
var tags []*models.TransactionTag
err := sess.Where("uid=? AND deleted=?", transaction.Uid, false).In("tag_id", tagIds).Find(&tags)
err := sess.Where("uid=? AND deleted=?", uid, false).In("tag_id", tagIds).Find(&tags)
if err != nil {
return err