add transaction template

pkg/api/data_managements.go

@@ -27,6 +27,7 @@ type DataManagementsApi struct {
 	transactions             *services.TransactionService
 	categories               *services.TransactionCategoryService
 	tags                     *services.TransactionTagService
+	templates                *services.TransactionTemplateService
 }
 
 // Initialize a data management api singleton instance
@@ -40,6 +41,7 @@ var (
 		transactions:             services.Transactions,
 		categories:               services.TransactionCategories,
 		tags:                     services.TransactionTags,
+		templates:                services.TransactionTemplates,
 	}
 )
 
@@ -84,11 +86,19 @@ func (a *DataManagementsApi) DataStatisticsHandler(c *core.Context) (any, *errs.
 		return nil, errs.ErrOperationFailed
 	}
 
+	totalTransactionTemplateCount, err := a.templates.GetTotalTemplateCountByUid(c, uid)
+
+	if err != nil {
+		log.ErrorfWithRequestId(c, "[data_managements.DataStatisticsHandler] failed to get total transaction template count for user \"uid:%d\", because %s", uid, err.Error())
+		return nil, errs.ErrOperationFailed
+	}
+
 	dataStatisticsResp := &models.DataStatisticsResponse{
 		TotalAccountCount:             totalAccountCount,
 		TotalTransactionCategoryCount: totalTransactionCategoryCount,
 		TotalTransactionTagCount:      totalTransactionTagCount,
 		TotalTransactionCount:         totalTransactionCount,
+		TotalTransactionTemplateCount: totalTransactionTemplateCount,
 	}
 
 	return dataStatisticsResp, nil
@@ -140,6 +150,13 @@ func (a *DataManagementsApi) ClearDataHandler(c *core.Context) (any, *errs.Error
 		return nil, errs.Or(err, errs.ErrOperationFailed)
 	}
 
+	err = a.templates.DeleteAllTemplates(c, uid)
+
+	if err != nil {
+		log.ErrorfWithRequestId(c, "[data_managements.ClearDataHandler] failed to delete all transaction templates, because %s", err.Error())
+		return nil, errs.Or(err, errs.ErrOperationFailed)
+	}
+
 	log.InfofWithRequestId(c, "[data_managements.ClearDataHandler] user \"uid:%d\" has cleared all data", uid)
 	return true, nil
 }

pkg/api/transaction_templates.go

@@ -0,0 +1,333 @@
+package api
+
+import (
+	"sort"
+	"strings"
+
+	"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"
+)
+
+// TransactionTemplatesApi represents transaction template api
+type TransactionTemplatesApi struct {
+	templates *services.TransactionTemplateService
+}
+
+// Initialize a transaction template api singleton instance
+var (
+	TransactionTemplates = &TransactionTemplatesApi{
+		templates: services.TransactionTemplates,
+	}
+)
+
+// TemplateListHandler returns transaction template list of current user
+func (a *TransactionTemplatesApi) TemplateListHandler(c *core.Context) (any, *errs.Error) {
+	var templateListReq models.TransactionTemplateListRequest
+	err := c.ShouldBindQuery(&templateListReq)
+
+	if err != nil {
+		log.WarnfWithRequestId(c, "[transaction_templates.TemplateListHandler] parse request failed, because %s", err.Error())
+		return nil, errs.NewIncompleteOrIncorrectSubmissionError(err)
+	}
+
+	uid := c.GetCurrentUid()
+	templates, err := a.templates.GetAllTemplatesByUid(c, uid, templateListReq.TemplateType)
+
+	if err != nil {
+		log.ErrorfWithRequestId(c, "[transaction_templates.TemplateListHandler] failed to get templates for user \"uid:%d\", because %s", uid, err.Error())
+		return nil, errs.Or(err, errs.ErrOperationFailed)
+	}
+
+	templateResps := make(models.TransactionTemplateInfoResponseSlice, len(templates))
+	serverUtcOffset := utils.GetServerTimezoneOffsetMinutes()
+
+	for i := 0; i < len(templates); i++ {
+		templateResps[i] = templates[i].ToTransactionTemplateInfoResponse(serverUtcOffset)
+	}
+
+	sort.Sort(templateResps)
+
+	return templateResps, nil
+}
+
+// TemplateGetHandler returns one specific transaction template of current user
+func (a *TransactionTemplatesApi) TemplateGetHandler(c *core.Context) (any, *errs.Error) {
+	var templateGetReq models.TransactionTemplateGetRequest
+	err := c.ShouldBindQuery(&templateGetReq)
+
+	if err != nil {
+		log.WarnfWithRequestId(c, "[transaction_templates.TemplateGetHandler] parse request failed, because %s", err.Error())
+		return nil, errs.NewIncompleteOrIncorrectSubmissionError(err)
+	}
+
+	uid := c.GetCurrentUid()
+	template, err := a.templates.GetTemplateByTemplateId(c, uid, templateGetReq.Id)
+
+	if err != nil {
+		log.ErrorfWithRequestId(c, "[transaction_templates.TemplateGetHandler] failed to get template \"id:%d\" for user \"uid:%d\", because %s", templateGetReq.Id, uid, err.Error())
+		return nil, errs.Or(err, errs.ErrOperationFailed)
+	}
+
+	serverUtcOffset := utils.GetServerTimezoneOffsetMinutes()
+	templateResp := template.ToTransactionTemplateInfoResponse(serverUtcOffset)
+
+	return templateResp, nil
+}
+
+// TemplateCreateHandler saves a new transaction template by request parameters for current user
+func (a *TransactionTemplatesApi) TemplateCreateHandler(c *core.Context) (any, *errs.Error) {
+	var templateCreateReq models.TransactionTemplateCreateRequest
+	err := c.ShouldBindJSON(&templateCreateReq)
+
+	if err != nil {
+		log.WarnfWithRequestId(c, "[transaction_templates.TemplateCreateHandler] parse request failed, because %s", err.Error())
+		return nil, errs.NewIncompleteOrIncorrectSubmissionError(err)
+	}
+
+	uid := c.GetCurrentUid()
+
+	maxOrderId, err := a.templates.GetMaxDisplayOrder(c, uid, templateCreateReq.TemplateType)
+
+	if err != nil {
+		log.ErrorfWithRequestId(c, "[transaction_templates.TemplateCreateHandler] failed to get max display order for user \"uid:%d\", because %s", uid, err.Error())
+		return nil, errs.Or(err, errs.ErrOperationFailed)
+	}
+
+	serverUtcOffset := utils.GetServerTimezoneOffsetMinutes()
+	template := a.createNewTemplateModel(uid, &templateCreateReq, maxOrderId+1)
+
+	if settings.Container.Current.EnableDuplicateSubmissionsCheck && templateCreateReq.ClientSessionId != "" {
+		found, remark := duplicatechecker.Container.Get(duplicatechecker.DUPLICATE_CHECKER_TYPE_NEW_TEMPLATE, uid, templateCreateReq.ClientSessionId)
+
+		if found {
+			log.InfofWithRequestId(c, "[transaction_templates.TemplateCreateHandler] another template \"id:%s\" has been created for user \"uid:%d\"", remark, uid)
+			templateId, err := utils.StringToInt64(remark)
+
+			if err == nil {
+				template, err = a.templates.GetTemplateByTemplateId(c, uid, templateId)
+
+				if err != nil {
+					log.ErrorfWithRequestId(c, "[transaction_templates.TemplateCreateHandler] failed to get existed template \"id:%d\" for user \"uid:%d\", because %s", templateId, uid, err.Error())
+					return nil, errs.Or(err, errs.ErrOperationFailed)
+				}
+
+				templateResp := template.ToTransactionTemplateInfoResponse(serverUtcOffset)
+
+				return templateResp, nil
+			}
+		}
+	}
+
+	err = a.templates.CreateTemplate(c, template)
+
+	if err != nil {
+		log.ErrorfWithRequestId(c, "[transaction_templates.TemplateCreateHandler] failed to create template \"id:%d\" for user \"uid:%d\", because %s", template.TemplateId, uid, err.Error())
+		return nil, errs.Or(err, errs.ErrOperationFailed)
+	}
+
+	log.InfofWithRequestId(c, "[transaction_templates.TemplateCreateHandler] user \"uid:%d\" has created a new template \"id:%d\" successfully", uid, template.TemplateId)
+
+	duplicatechecker.Container.Set(duplicatechecker.DUPLICATE_CHECKER_TYPE_NEW_TEMPLATE, uid, templateCreateReq.ClientSessionId, utils.Int64ToString(template.TemplateId))
+	templateResp := template.ToTransactionTemplateInfoResponse(serverUtcOffset)
+
+	return templateResp, nil
+}
+
+// TemplateModifyNameHandler updates the name of an existed transaction template by request parameters for current user
+func (a *TransactionTemplatesApi) TemplateModifyNameHandler(c *core.Context) (any, *errs.Error) {
+	var templateModifyReq models.TransactionTemplateModifyNameRequest
+	err := c.ShouldBindJSON(&templateModifyReq)
+
+	if err != nil {
+		log.WarnfWithRequestId(c, "[transaction_templates.TemplateModifyNameHandler] parse request failed, because %s", err.Error())
+		return nil, errs.NewIncompleteOrIncorrectSubmissionError(err)
+	}
+
+	uid := c.GetCurrentUid()
+	template, err := a.templates.GetTemplateByTemplateId(c, uid, templateModifyReq.Id)
+
+	if err != nil {
+		log.ErrorfWithRequestId(c, "[transaction_templates.TemplateModifyNameHandler] failed to get template \"id:%d\" for user \"uid:%d\", because %s", templateModifyReq.Id, uid, err.Error())
+		return nil, errs.Or(err, errs.ErrOperationFailed)
+	}
+
+	if templateModifyReq.Name == template.Name {
+		return nil, errs.ErrNothingWillBeUpdated
+	}
+
+	newTemplate := &models.TransactionTemplate{
+		TemplateId: template.TemplateId,
+		Uid:        template.Uid,
+		Name:       templateModifyReq.Name,
+	}
+
+	err = a.templates.ModifyTemplateName(c, newTemplate)
+
+	if err != nil {
+		log.ErrorfWithRequestId(c, "[transaction_templates.TemplateModifyNameHandler] failed to update template \"id:%d\" for user \"uid:%d\", because %s", templateModifyReq.Id, uid, err.Error())
+		return nil, errs.Or(err, errs.ErrOperationFailed)
+	}
+
+	log.InfofWithRequestId(c, "[transaction_templates.TemplateModifyNameHandler] user \"uid:%d\" has updated template \"id:%d\" successfully", uid, templateModifyReq.Id)
+
+	serverUtcOffset := utils.GetServerTimezoneOffsetMinutes()
+	template.Name = newTemplate.Name
+	templateResp := template.ToTransactionTemplateInfoResponse(serverUtcOffset)
+
+	return templateResp, nil
+}
+
+// TemplateModifyHandler saves an existed transaction template by request parameters for current user
+func (a *TransactionTemplatesApi) TemplateModifyHandler(c *core.Context) (any, *errs.Error) {
+	var templateModifyReq models.TransactionTemplateModifyRequest
+	err := c.ShouldBindJSON(&templateModifyReq)
+
+	if err != nil {
+		log.WarnfWithRequestId(c, "[transaction_templates.TemplateModifyHandler] parse request failed, because %s", err.Error())
+		return nil, errs.NewIncompleteOrIncorrectSubmissionError(err)
+	}
+
+	uid := c.GetCurrentUid()
+	template, err := a.templates.GetTemplateByTemplateId(c, uid, templateModifyReq.Id)
+
+	if err != nil {
+		log.ErrorfWithRequestId(c, "[transaction_templates.TemplateModifyHandler] failed to get template \"id:%d\" for user \"uid:%d\", because %s", templateModifyReq.Id, uid, err.Error())
+		return nil, errs.Or(err, errs.ErrOperationFailed)
+	}
+
+	newTemplate := &models.TransactionTemplate{
+		TemplateId:           template.TemplateId,
+		Uid:                  uid,
+		Type:                 templateModifyReq.Type,
+		CategoryId:           templateModifyReq.CategoryId,
+		AccountId:            templateModifyReq.SourceAccountId,
+		TagIds:               strings.Join(templateModifyReq.TagIds, ","),
+		Amount:               templateModifyReq.SourceAmount,
+		RelatedAccountId:     templateModifyReq.DestinationAccountId,
+		RelatedAccountAmount: templateModifyReq.DestinationAmount,
+		Comment:              templateModifyReq.Comment,
+	}
+
+	if newTemplate.Type == template.Type &&
+		newTemplate.CategoryId == template.CategoryId &&
+		newTemplate.AccountId == template.AccountId &&
+		newTemplate.TagIds == template.TagIds &&
+		newTemplate.Amount == template.Amount &&
+		newTemplate.RelatedAccountId == template.RelatedAccountId &&
+		newTemplate.RelatedAccountAmount == template.RelatedAccountAmount &&
+		newTemplate.Comment == template.Comment {
+		return nil, errs.ErrNothingWillBeUpdated
+	}
+
+	err = a.templates.ModifyTemplate(c, newTemplate)
+
+	if err != nil {
+		log.ErrorfWithRequestId(c, "[transaction_templates.TemplateModifyHandler] failed to update template \"id:%d\" for user \"uid:%d\", because %s", templateModifyReq.Id, uid, err.Error())
+		return nil, errs.Or(err, errs.ErrOperationFailed)
+	}
+
+	log.InfofWithRequestId(c, "[transaction_templates.TemplateModifyHandler] user \"uid:%d\" has updated template \"id:%d\" successfully", uid, templateModifyReq.Id)
+
+	serverUtcOffset := utils.GetServerTimezoneOffsetMinutes()
+	newTemplate.Name = template.Name
+	newTemplate.DisplayOrder = template.DisplayOrder
+	newTemplate.Hidden = template.Hidden
+	templateResp := newTemplate.ToTransactionTemplateInfoResponse(serverUtcOffset)
+
+	return templateResp, nil
+}
+
+// TemplateHideHandler hides an transaction template by request parameters for current user
+func (a *TransactionTemplatesApi) TemplateHideHandler(c *core.Context) (any, *errs.Error) {
+	var templateHideReq models.TransactionTemplateHideRequest
+	err := c.ShouldBindJSON(&templateHideReq)
+
+	if err != nil {
+		log.WarnfWithRequestId(c, "[transaction_templates.TemplateHideHandler] parse request failed, because %s", err.Error())
+		return nil, errs.NewIncompleteOrIncorrectSubmissionError(err)
+	}
+
+	uid := c.GetCurrentUid()
+	err = a.templates.HideTemplate(c, uid, []int64{templateHideReq.Id}, templateHideReq.Hidden)
+
+	if err != nil {
+		log.ErrorfWithRequestId(c, "[transaction_templates.TemplateHideHandler] failed to hide template \"id:%d\" for user \"uid:%d\", because %s", templateHideReq.Id, uid, err.Error())
+		return nil, errs.Or(err, errs.ErrOperationFailed)
+	}
+
+	log.InfofWithRequestId(c, "[transaction_templates.TemplateHideHandler] user \"uid:%d\" has hidden template \"id:%d\"", uid, templateHideReq.Id)
+	return true, nil
+}
+
+// TemplateMoveHandler moves display order of existed transaction templates by request parameters for current user
+func (a *TransactionTemplatesApi) TemplateMoveHandler(c *core.Context) (any, *errs.Error) {
+	var templateMoveReq models.TransactionTemplateMoveRequest
+	err := c.ShouldBindJSON(&templateMoveReq)
+
+	if err != nil {
+		log.WarnfWithRequestId(c, "[transaction_templates.CategoryMoveHandler] parse request failed, because %s", err.Error())
+		return nil, errs.NewIncompleteOrIncorrectSubmissionError(err)
+	}
+
+	uid := c.GetCurrentUid()
+	templates := make([]*models.TransactionTemplate, len(templateMoveReq.NewDisplayOrders))
+
+	for i := 0; i < len(templateMoveReq.NewDisplayOrders); i++ {
+		newDisplayOrder := templateMoveReq.NewDisplayOrders[i]
+		template := &models.TransactionTemplate{
+			Uid:          uid,
+			TemplateId:   newDisplayOrder.Id,
+			DisplayOrder: newDisplayOrder.DisplayOrder,
+		}
+
+		templates[i] = template
+	}
+
+	err = a.templates.ModifyTemplateDisplayOrders(c, uid, templates)
+
+	if err != nil {
+		log.ErrorfWithRequestId(c, "[transaction_templates.TemplateMoveHandler] failed to move templates for user \"uid:%d\", because %s", uid, err.Error())
+		return nil, errs.Or(err, errs.ErrOperationFailed)
+	}
+
+	log.InfofWithRequestId(c, "[transaction_templates.TemplateMoveHandler] user \"uid:%d\" has moved templates", uid)
+	return true, nil
+}
+
+// TemplateDeleteHandler deletes an existed transaction template by request parameters for current user
+func (a *TransactionTemplatesApi) TemplateDeleteHandler(c *core.Context) (any, *errs.Error) {
+	var templateDeleteReq models.TransactionTemplateDeleteRequest
+	err := c.ShouldBindJSON(&templateDeleteReq)
+
+	if err != nil {
+		log.WarnfWithRequestId(c, "[transaction_templates.TemplateDeleteHandler] parse request failed, because %s", err.Error())
+		return nil, errs.NewIncompleteOrIncorrectSubmissionError(err)
+	}
+
+	uid := c.GetCurrentUid()
+	err = a.templates.DeleteTemplate(c, uid, templateDeleteReq.Id)
+
+	if err != nil {
+		log.ErrorfWithRequestId(c, "[transaction_templates.TemplateDeleteHandler] failed to delete template \"id:%d\" for user \"uid:%d\", because %s", templateDeleteReq.Id, uid, err.Error())
+		return nil, errs.Or(err, errs.ErrOperationFailed)
+	}
+
+	log.InfofWithRequestId(c, "[transaction_templates.TemplateDeleteHandler] user \"uid:%d\" has deleted template \"id:%d\"", uid, templateDeleteReq.Id)
+	return true, nil
+}
+
+func (a *TransactionTemplatesApi) createNewTemplateModel(uid int64, templateCreateReq *models.TransactionTemplateCreateRequest, order int32) *models.TransactionTemplate {
+	return &models.TransactionTemplate{
+		Uid:          uid,
+		TemplateType: templateCreateReq.TemplateType,
+		Name:         templateCreateReq.Name,
+		Type:         models.TRANSACTION_TYPE_EXPENSE,
+		DisplayOrder: order,
+	}
+}

pkg/duplicatechecker/duplicate_checker_type.go

@@ -9,4 +9,5 @@ const (
 	DUPLICATE_CHECKER_TYPE_NEW_ACCOUNT     DuplicateCheckerType = 1
 	DUPLICATE_CHECKER_TYPE_NEW_CATEGORY    DuplicateCheckerType = 2
 	DUPLICATE_CHECKER_TYPE_NEW_TRANSACTION DuplicateCheckerType = 3
+	DUPLICATE_CHECKER_TYPE_NEW_TEMPLATE    DuplicateCheckerType = 4
 )

pkg/errs/error.go

@@ -29,6 +29,7 @@ const (
 	NormalSubcategoryTag            = 7
 	NormalSubcategoryDataManagement = 8
 	NormalSubcategoryMapProxy       = 9
+	NormalSubcategoryTemplate       = 10
 )
 
 // Error represents the specific error returned to user

pkg/errs/transaction_template.go

@@ -0,0 +1,9 @@
+package errs
+
+import "net/http"
+
+// Error codes related to transaction templates
+var (
+	ErrTransactionTemplateIdInvalid = NewNormalError(NormalSubcategoryTemplate, 0, http.StatusBadRequest, "transaction template id is invalid")
+	ErrTransactionTemplateNotFound  = NewNormalError(NormalSubcategoryTemplate, 1, http.StatusBadRequest, "transaction template not found")
+)

pkg/models/data_management.go

@@ -11,4 +11,5 @@ type DataStatisticsResponse struct {
 	TotalTransactionCategoryCount int64 `json:"totalTransactionCategoryCount,string"`
 	TotalTransactionTagCount      int64 `json:"totalTransactionTagCount,string"`
 	TotalTransactionCount         int64 `json:"totalTransactionCount,string"`
+	TotalTransactionTemplateCount int64 `json:"totalTransactionTemplateCount,string"`
 }

pkg/models/transaction_template.go

@@ -0,0 +1,159 @@
+package models
+
+import (
+	"strings"
+
+	"github.com/mayswind/ezbookkeeping/pkg/utils"
+)
+
+// TransactionTemplateType represents transaction template type in database
+type TransactionTemplateType byte
+
+// Transaction template types
+const (
+	TRANSACTION_TEMPLATE_TYPE_NORMAL TransactionTemplateType = 1
+)
+
+// TransactionTemplate represents transaction template stored in database
+type TransactionTemplate struct {
+	TemplateId           int64                   `xorm:"PK"`
+	Uid                  int64                   `xorm:"INDEX(IDX_transaction_uid_deleted_template_type_order) NOT NULL"`
+	Deleted              bool                    `xorm:"INDEX(IDX_transaction_uid_deleted_template_type_order) NOT NULL"`
+	TemplateType         TransactionTemplateType `xorm:"INDEX(IDX_transaction_uid_deleted_template_type_order) NOT NULL"`
+	Name                 string                  `xorm:"VARCHAR(32) NOT NULL"`
+	Type                 TransactionType         `xorm:"NOT NULL"`
+	CategoryId           int64                   `xorm:"NOT NULL"`
+	AccountId            int64                   `xorm:"NOT NULL"`
+	TagIds               string                  `xorm:"VARCHAR(255) NOT NULL"`
+	Amount               int64                   `xorm:"NOT NULL"`
+	RelatedAccountId     int64                   `xorm:"NOT NULL"`
+	RelatedAccountAmount int64                   `xorm:"NOT NULL"`
+	Comment              string                  `xorm:"VARCHAR(255) NOT NULL"`
+	DisplayOrder         int32                   `xorm:"INDEX(IDX_transaction_uid_deleted_template_type_order) NOT NULL"`
+	Hidden               bool                    `xorm:"NOT NULL"`
+	CreatedUnixTime      int64
+	UpdatedUnixTime      int64
+	DeletedUnixTime      int64
+}
+
+// TransactionTemplateListRequest represents all parameters of transaction template list request
+type TransactionTemplateListRequest struct {
+	TemplateType TransactionTemplateType `form:"templateType" binding:"required,min=1,max=1"`
+}
+
+// TransactionTemplateGetRequest represents all parameters of transaction template getting request
+type TransactionTemplateGetRequest struct {
+	Id int64 `form:"id,string" binding:"required,min=1"`
+}
+
+// TransactionTemplateCreateRequest represents all parameters of transaction template creation request
+type TransactionTemplateCreateRequest struct {
+	TemplateType    TransactionTemplateType `json:"templateType" binding:"required,min=1,max=1"`
+	Name            string                  `json:"name" binding:"required,notBlank,max=32"`
+	ClientSessionId string                  `json:"clientSessionId"`
+}
+
+// TransactionTemplateModifyNameRequest represents all parameters of transaction template name modification request
+type TransactionTemplateModifyNameRequest struct {
+	Id   int64  `json:"id,string" binding:"required,min=1"`
+	Name string `json:"name" binding:"required,notBlank,max=32"`
+}
+
+// TransactionTemplateModifyRequest represents all parameters of transaction template modification request
+type TransactionTemplateModifyRequest struct {
+	Id                   int64           `json:"id,string" binding:"required,min=1"`
+	Type                 TransactionType `json:"type" binding:"required"`
+	CategoryId           int64           `json:"categoryId,string"`
+	SourceAccountId      int64           `json:"sourceAccountId,string" binding:"required,min=1"`
+	DestinationAccountId int64           `json:"destinationAccountId,string" binding:"min=0"`
+	SourceAmount         int64           `json:"sourceAmount" binding:"min=-99999999999,max=99999999999"`
+	DestinationAmount    int64           `json:"destinationAmount" binding:"min=-99999999999,max=99999999999"`
+	TagIds               []string        `json:"tagIds"`
+	Comment              string          `json:"comment" binding:"max=255"`
+}
+
+// TransactionTemplateHideRequest represents all parameters of transaction template hiding request
+type TransactionTemplateHideRequest struct {
+	Id     int64 `json:"id,string" binding:"required,min=1"`
+	Hidden bool  `json:"hidden"`
+}
+
+// TransactionTemplateMoveRequest represents all parameters of transaction template moving request
+type TransactionTemplateMoveRequest struct {
+	NewDisplayOrders []*TransactionTemplateNewDisplayOrderRequest `json:"newDisplayOrders"`
+}
+
+// TransactionTemplateNewDisplayOrderRequest represents a data pair of id and display order
+type TransactionTemplateNewDisplayOrderRequest struct {
+	Id           int64 `json:"id,string" binding:"required,min=1"`
+	DisplayOrder int32 `json:"displayOrder"`
+}
+
+// TransactionTemplateDeleteRequest represents all parameters of transaction template deleting request
+type TransactionTemplateDeleteRequest struct {
+	Id int64 `json:"id,string" binding:"required,min=1"`
+}
+
+type TransactionTemplateInfoResponse struct {
+	*TransactionInfoResponse
+	TemplateType TransactionTemplateType `json:"templateType"`
+	Name         string                  `json:"name"`
+	DisplayOrder int32                   `json:"displayOrder"`
+	Hidden       bool                    `json:"hidden"`
+}
+
+// ToTransactionInfoResponse returns a view-object according to database model
+func (t *TransactionTemplate) ToTransactionInfoResponse(utcOffset int16) *TransactionInfoResponse {
+	tagIds := make([]string, 0, 0)
+
+	if t.TagIds != "" {
+		tagIds = strings.Split(t.TagIds, ",")
+	}
+
+	return &TransactionInfoResponse{
+		Id:                   t.TemplateId,
+		TimeSequenceId:       utils.GetMinTransactionTimeFromUnixTime(t.CreatedUnixTime),
+		Type:                 t.Type,
+		CategoryId:           t.CategoryId,
+		Time:                 0,
+		UtcOffset:            utcOffset,
+		SourceAccountId:      t.AccountId,
+		DestinationAccountId: t.RelatedAccountId,
+		SourceAmount:         t.Amount,
+		DestinationAmount:    t.RelatedAccountAmount,
+		HideAmount:           false,
+		TagIds:               tagIds,
+		Comment:              t.Comment,
+		GeoLocation:          nil,
+		Editable:             true,
+	}
+}
+
+// ToTransactionTemplateInfoResponse returns a view-object according to database model
+func (t *TransactionTemplate) ToTransactionTemplateInfoResponse(utcOffset int16) *TransactionTemplateInfoResponse {
+	return &TransactionTemplateInfoResponse{
+		TransactionInfoResponse: t.ToTransactionInfoResponse(utcOffset),
+		TemplateType:            t.TemplateType,
+		Name:                    t.Name,
+		DisplayOrder:            t.DisplayOrder,
+		Hidden:                  t.Hidden,
+	}
+}
+
+// TransactionTemplateInfoResponseSlice represents the slice data structure of TransactionTemplateInfoResponse
+type TransactionTemplateInfoResponseSlice []*TransactionTemplateInfoResponse
+
+// Len returns the count of items
+func (s TransactionTemplateInfoResponseSlice) Len() int {
+	return len(s)
+}
+
+// Swap swaps two items
+func (s TransactionTemplateInfoResponseSlice) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+// Less reports whether the first item is less than the second one
+func (s TransactionTemplateInfoResponseSlice) Less(i, j int) bool {
+	return s[i].DisplayOrder < s[j].DisplayOrder
+}

pkg/services/transaction_templates.go

@@ -0,0 +1,261 @@
+package services
+
+import (
+	"time"
+	"xorm.io/xorm"
+
+	"github.com/mayswind/ezbookkeeping/pkg/core"
+	"github.com/mayswind/ezbookkeeping/pkg/datastore"
+	"github.com/mayswind/ezbookkeeping/pkg/errs"
+	"github.com/mayswind/ezbookkeeping/pkg/models"
+	"github.com/mayswind/ezbookkeeping/pkg/uuid"
+)
+
+// TransactionTemplateService represents transaction template service
+type TransactionTemplateService struct {
+	ServiceUsingDB
+	ServiceUsingUuid
+}
+
+// Initialize a transaction template service singleton instance
+var (
+	TransactionTemplates = &TransactionTemplateService{
+		ServiceUsingDB: ServiceUsingDB{
+			container: datastore.Container,
+		},
+		ServiceUsingUuid: ServiceUsingUuid{
+			container: uuid.Container,
+		},
+	}
+)
+
+// GetTotalTemplateCountByUid returns total template count of user
+func (s *TransactionTemplateService) GetTotalTemplateCountByUid(c *core.Context, uid int64) (int64, error) {
+	if uid <= 0 {
+		return 0, errs.ErrUserIdInvalid
+	}
+
+	count, err := s.UserDataDB(uid).NewSession(c).Where("uid=? AND deleted=?", uid, false).Count(&models.TransactionTemplate{})
+
+	return count, err
+}
+
+// GetAllTemplatesByUid returns all transaction template models of user
+func (s *TransactionTemplateService) GetAllTemplatesByUid(c *core.Context, uid int64, templateType models.TransactionTemplateType) ([]*models.TransactionTemplate, error) {
+	if uid <= 0 {
+		return nil, errs.ErrUserIdInvalid
+	}
+
+	var templates []*models.TransactionTemplate
+	err := s.UserDataDB(uid).NewSession(c).Where("uid=? AND deleted=? AND template_type=?", uid, false, templateType).Find(&templates)
+
+	return templates, err
+}
+
+// GetTemplateByTemplateId returns a transaction template model according to transaction template id
+func (s *TransactionTemplateService) GetTemplateByTemplateId(c *core.Context, uid int64, templateId int64) (*models.TransactionTemplate, error) {
+	if uid <= 0 {
+		return nil, errs.ErrUserIdInvalid
+	}
+
+	if templateId <= 0 {
+		return nil, errs.ErrTransactionTemplateIdInvalid
+	}
+
+	template := &models.TransactionTemplate{}
+	has, err := s.UserDataDB(uid).NewSession(c).ID(templateId).Where("uid=? AND deleted=?", uid, false).Get(template)
+
+	if err != nil {
+		return nil, err
+	} else if !has {
+		return nil, errs.ErrTransactionTemplateNotFound
+	}
+
+	return template, nil
+}
+
+// GetMaxDisplayOrder returns the max display order
+func (s *TransactionTemplateService) GetMaxDisplayOrder(c *core.Context, uid int64, templateType models.TransactionTemplateType) (int32, error) {
+	if uid <= 0 {
+		return 0, errs.ErrUserIdInvalid
+	}
+
+	template := &models.TransactionTemplate{}
+	has, err := s.UserDataDB(uid).NewSession(c).Cols("uid", "deleted", "display_order").Where("uid=? AND deleted=? AND template_type=?", uid, false, templateType).OrderBy("display_order desc").Limit(1).Get(template)
+
+	if err != nil {
+		return 0, err
+	}
+
+	if has {
+		return template.DisplayOrder, nil
+	} else {
+		return 0, nil
+	}
+}
+
+// CreateTemplate saves a new transaction template model to database
+func (s *TransactionTemplateService) CreateTemplate(c *core.Context, template *models.TransactionTemplate) error {
+	if template.Uid <= 0 {
+		return errs.ErrUserIdInvalid
+	}
+
+	template.TemplateId = s.GenerateUuid(uuid.UUID_TYPE_TEMPLATE)
+
+	if template.TemplateId < 1 {
+		return errs.ErrSystemIsBusy
+	}
+
+	template.Deleted = false
+	template.CreatedUnixTime = time.Now().Unix()
+	template.UpdatedUnixTime = time.Now().Unix()
+
+	return s.UserDataDB(template.Uid).DoTransaction(c, func(sess *xorm.Session) error {
+		_, err := sess.Insert(template)
+		return err
+	})
+}
+
+// ModifyTemplate saves an existed transaction template model to database
+func (s *TransactionTemplateService) ModifyTemplate(c *core.Context, template *models.TransactionTemplate) error {
+	if template.Uid <= 0 {
+		return errs.ErrUserIdInvalid
+	}
+
+	template.UpdatedUnixTime = time.Now().Unix()
+
+	return s.UserDataDB(template.Uid).DoTransaction(c, func(sess *xorm.Session) error {
+		updatedRows, err := sess.ID(template.TemplateId).Cols("type", "category_id", "account_id", "tag_ids", "amount", "related_account_id", "related_account_amount", "comment", "updated_unix_time").Where("uid=? AND deleted=?", template.Uid, false).Update(template)
+
+		if err != nil {
+			return err
+		} else if updatedRows < 1 {
+			return errs.ErrTransactionTemplateNotFound
+		}
+
+		return err
+	})
+}
+
+// ModifyTemplateName updates the name of an existed transaction template model to database
+func (s *TransactionTemplateService) ModifyTemplateName(c *core.Context, template *models.TransactionTemplate) error {
+	if template.Uid <= 0 {
+		return errs.ErrUserIdInvalid
+	}
+
+	template.UpdatedUnixTime = time.Now().Unix()
+
+	return s.UserDataDB(template.Uid).DoTransaction(c, func(sess *xorm.Session) error {
+		updatedRows, err := sess.ID(template.TemplateId).Cols("name", "updated_unix_time").Where("uid=? AND deleted=?", template.Uid, false).Update(template)
+
+		if err != nil {
+			return err
+		} else if updatedRows < 1 {
+			return errs.ErrTransactionTemplateNotFound
+		}
+
+		return err
+	})
+}
+
+// HideTemplate updates hidden field of given transaction templates
+func (s *TransactionTemplateService) HideTemplate(c *core.Context, uid int64, ids []int64, hidden bool) error {
+	if uid <= 0 {
+		return errs.ErrUserIdInvalid
+	}
+
+	now := time.Now().Unix()
+
+	updateModel := &models.TransactionTemplate{
+		Hidden:          hidden,
+		UpdatedUnixTime: now,
+	}
+
+	return s.UserDataDB(uid).DoTransaction(c, func(sess *xorm.Session) error {
+		updatedRows, err := sess.Cols("hidden", "updated_unix_time").Where("uid=? AND deleted=?", uid, false).In("template_id", ids).Update(updateModel)
+
+		if err != nil {
+			return err
+		} else if updatedRows < 1 {
+			return errs.ErrTransactionTemplateNotFound
+		}
+
+		return err
+	})
+}
+
+// ModifyTemplateDisplayOrders updates display order of given transaction templates
+func (s *TransactionTemplateService) ModifyTemplateDisplayOrders(c *core.Context, uid int64, templates []*models.TransactionTemplate) error {
+	if uid <= 0 {
+		return errs.ErrUserIdInvalid
+	}
+
+	for i := 0; i < len(templates); i++ {
+		templates[i].UpdatedUnixTime = time.Now().Unix()
+	}
+
+	return s.UserDataDB(uid).DoTransaction(c, func(sess *xorm.Session) error {
+		for i := 0; i < len(templates); i++ {
+			template := templates[i]
+			updatedRows, err := sess.ID(template.TemplateId).Cols("display_order", "updated_unix_time").Where("uid=? AND deleted=?", uid, false).Update(template)
+
+			if err != nil {
+				return err
+			} else if updatedRows < 1 {
+				return errs.ErrTransactionTemplateNotFound
+			}
+		}
+
+		return nil
+	})
+}
+
+// DeleteTemplate deletes an existed transaction template from database
+func (s *TransactionTemplateService) DeleteTemplate(c *core.Context, uid int64, templateId int64) error {
+	if uid <= 0 {
+		return errs.ErrUserIdInvalid
+	}
+
+	now := time.Now().Unix()
+
+	updateModel := &models.TransactionTemplate{
+		Deleted:         true,
+		DeletedUnixTime: now,
+	}
+
+	return s.UserDataDB(uid).DoTransaction(c, func(sess *xorm.Session) error {
+		deletedRows, err := sess.ID(templateId).Cols("deleted", "deleted_unix_time").Where("uid=? AND deleted=?", uid, false).Update(updateModel)
+
+		if err != nil {
+			return err
+		} else if deletedRows < 1 {
+			return errs.ErrTransactionTemplateNotFound
+		}
+
+		return err
+	})
+}
+
+// DeleteAllTemplates deletes all existed transaction templates from database
+func (s *TransactionTemplateService) DeleteAllTemplates(c *core.Context, uid int64) error {
+	if uid <= 0 {
+		return errs.ErrUserIdInvalid
+	}
+
+	now := time.Now().Unix()
+
+	updateModel := &models.TransactionTemplate{
+		Deleted:         true,
+		DeletedUnixTime: now,
+	}
+
+	return s.UserDataDB(uid).DoTransaction(c, func(sess *xorm.Session) error {
+		_, err := sess.Cols("deleted", "deleted_unix_time").Where("uid=? AND deleted=?", uid, false).Update(updateModel)
+
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+}

pkg/utils/datetimes.go

@@ -178,6 +178,14 @@ func GetTimezoneOffsetMinutes(timezone *time.Location) int16 {
 	return tzMinuteOffset
 }
 
+// GetServerTimezoneOffsetMinutes returns offset minutes of current server timezone
+func GetServerTimezoneOffsetMinutes() int16 {
+	_, tzOffset := time.Now().Zone()
+	tzMinuteOffset := int16(tzOffset / 60)
+
+	return tzMinuteOffset
+}
+
 // FormatTimezoneOffset returns "+/-HH:MM" format of timezone
 func FormatTimezoneOffset(timezone *time.Location) string {
 	tzMinutesOffset := GetTimezoneOffsetMinutes(timezone)

pkg/uuid/uuid_type.go

@@ -12,4 +12,5 @@ const (
 	UUID_TYPE_CATEGORY    UuidType = 4
 	UUID_TYPE_TAG         UuidType = 5
 	UUID_TYPE_TAG_INDEX   UuidType = 6
+	UUID_TYPE_TEMPLATE    UuidType = 7
 )