package service

import (
	"fmt"
	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/utils/tool_funs"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/creditAccount/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/creditAccount/query"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/event/subscriber"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/domain/service"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/infrastructure/dao"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/infrastructure/utils"
	"strconv"
	"time"
)

// CreditAccountService 账期结算单服务
type CreditAccountService struct {
}

// CreateCreditAccount 账期结算
func (creditAccountService *CreditAccountService) CreateCreditAccount(createCreditAccountCommand *command.CreateCreditAccountCommand) (interface{}, error) {
	if err := createCreditAccountCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err1 := transactionContext.StartTransaction(); err1 != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err1.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	// 公司REST服务初始化
	var companyService service.CompanyService
	if value, err2 := factory.CreateCompanyService(map[string]interface{}{}); err2 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err2.Error())
	} else {
		companyService = value
	}

	// 获取公司信息
	var company *domain.Company
	if data, err3 := companyService.CompanyFrom(createCreditAccountCommand.CompanyId); err3 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取公司信息失败")
	} else {
		company = data
	}

	// 组织机构REST服务初始化
	var organizationService service.OrgService
	if value, err4 := factory.CreateOrganizationService(map[string]interface{}{}); err4 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err4.Error())
	} else {
		organizationService = value
	}

	// 获取组织机构信息
	var organization *domain.Org
	if data, err5 := organizationService.OrgFrom(createCreditAccountCommand.CompanyId, createCreditAccountCommand.OrgId); err5 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取组织机构失败")
	} else {
		organization = data
	}

	// 用户REST服务初始化
	var userService service.UserService
	if value, err6 := factory.CreateUserService(map[string]interface{}{}); err6 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err6.Error())
	} else {
		userService = value
	}

	// 获取操作人
	var operator *domain.User
	if data, err7 := userService.OperatorFrom(createCreditAccountCommand.CompanyId, createCreditAccountCommand.OrgId, createCreditAccountCommand.UserId); err7 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取操作人失败")
	} else {
		operator = data
	}

	// 账期结算单仓储初始化
	var creditAccountRepository domain.CreditAccountRepository
	if value, err8 := factory.CreateCreditAccountRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err8 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err8.Error())
	} else {
		creditAccountRepository = value
	}

	// 账期结算单DAO初始化
	var creditAccountDao *dao.CreditAccountDao
	if value, err9 := factory.CreateCreditAccountDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err9 != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err9.Error())
	} else {
		creditAccountDao = value
	}

	// 账期结算消息推送领域服务初始化
	var estimateDividendsService service.EstimateDividendsService
	if value, err := factory.CreateEstimateDividendsService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		estimateDividendsService = value
		_ = estimateDividendsService.Subscribe(&subscriber.MessageServiceSubscriber{
			//TransactionContext: transactionContext.(*pgTransaction.TransactionContext),
		})
	}

	// 分红预算单仓储初始化
	var dividendsEstimateRepository domain.DividendsEstimateRepository
	if value, err10 := factory.CreateDividendsEstimateRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err10 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err10.Error())
	} else {
		dividendsEstimateRepository = value
	}

	// 批量转换分红预算单号列表
	dividendsEstimateIds, err := utils.SliceAtoi(createCreditAccountCommand.DividendsEstimateIds)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "分红预算单号类型错误")
	}

	// 获取所选分红预算单
	if _, dividendsEstimates, err11 := dividendsEstimateRepository.Find(map[string]interface{}{
		"dividendsEstimateIds": dividendsEstimateIds,
	}); err11 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err11.Error())
	} else {
		// 校验共创用户是否一致
		if len(dividendsEstimates) > 0 {
			for i, _ := range dividendsEstimates {
				if dividendsEstimates[i].DividendsUser.UserId != dividendsEstimates[0].DividendsUser.UserId {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "请勾选同一个共创用户进行结算")
				}
			}
		}

		// 校验分红预算单是否可以进行预算
		for _, dividendsEstimate := range dividendsEstimates {
			if dividendsEstimate.DividendsAccountStatus == 2 {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "请勾选“待结算”的分红单结算")
			}
			if dividendsEstimate.IsCanceled {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "请勾选未取消的分红单结算")
			}
		}

		// 预算明细
		var accountDetail []*domain.AccountDetail
		var settlementAmount float64
		var goodAmountCount float64
		for _, dividendsEstimate := range dividendsEstimates {
			accountDetail = append(accountDetail, &domain.AccountDetail{
				DividendsEstimateOrderId:     dividendsEstimate.DividendsEstimateId,
				DividendsEstimateOrderNumber: dividendsEstimate.DividendsEstimateOrderNumber,
				DividendsType:                dividendsEstimate.DividendsType,
				DividendsAmount:              dividendsEstimate.DividendsAmount,
				OrderGoodId:                  dividendsEstimate.OrderGoodId,
				OrderGoodAmount:              dividendsEstimate.OrderGoodAmount,
				CooperationContractNumber:    dividendsEstimate.CooperationContractNumber,
			})

			settlementAmount = settlementAmount + dividendsEstimate.DividendsAmount

			goodAmountCount = goodAmountCount + dividendsEstimate.OrderGoodAmount
		}

		// 生成账期结算单号
		creditAccountNumber, err12 := creditAccountDao.GenerateCreditAccountNumber(map[string]interface{}{
			"companyId": createCreditAccountCommand.CompanyId,
		})
		if err12 != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, "生成账期结算单号错误")
		}

		// 生成账期结算单
		newCreditAccount := &domain.CreditAccount{
			ActuallyPaidAmount:    0,
			CreditAccountOrderNum: creditAccountNumber,
			PaymentStatus:         1,
			PaymentTime:           time.Time{},
			SettlementAmount:      settlementAmount,
			SettlementTime:        time.Now(),
			Participator: &domain.Participator{ // 共创参与
				UserId:     dividendsEstimates[0].DividendsUser.UserId,
				UserBaseId: dividendsEstimates[0].DividendsUser.UserBaseId,
				Org:        dividendsEstimates[0].DividendsUser.Org,
				Orgs:       dividendsEstimates[0].DividendsUser.Orgs,
				Department: dividendsEstimates[0].DividendsUser.Department,
				Roles:      dividendsEstimates[0].DividendsUser.Roles,
				UserInfo:   dividendsEstimates[0].DividendsUser.UserInfo,
				UserName:   dividendsEstimates[0].DividendsUser.UserInfo.UserName,
				UserPhone:  dividendsEstimates[0].DividendsUser.UserPhone,
				UserType:   dividendsEstimates[0].DividendsUser.UserType,
				Status:     dividendsEstimates[0].DividendsUser.Status,
				Company:    dividendsEstimates[0].DividendsUser.Company,
			},
			AccountDetail:              accountDetail, // 结算明细，多笔分红预算单
			PaymentDocumentAttachments: nil,
			Org:                        organization,
			Company:                    company,
			Operator:                   operator,
			OperateTime:                time.Now(),
			CreatedAt:                  time.Now(),
			DeletedAt:                  time.Time{},
			UpdatedAt:                  time.Time{},
			GoodAmountCount:            goodAmountCount,
			CooperationContractNumber:  "", // TODO 弃用
		}

		if creditAccount, err13 := creditAccountRepository.Save(newCreditAccount); err13 != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err13.Error())
		} else {
			// 变更分红预算单结算状态
			for i, _ := range dividendsEstimates {
				dividendsEstimates[i].DividendsAccountStatus = 2
				dividendsEstimates[i].CreditAccountId = creditAccount.CreditAccountId
			}
			_, err3 := dividendsEstimateRepository.UpdateMany(dividendsEstimates)
			if err3 != nil {
				return nil, err3
			}
			if err14 := transactionContext.CommitTransaction(); err14 != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, err14.Error())
			}

			// 消息推送
			var accountData []service.EstimateData
			for _, detail := range creditAccount.AccountDetail {
				accountData = append(accountData, service.EstimateData{
					CreditAccountOrderNum:        creditAccount.CreditAccountOrderNum,
					SettlementAmount:             fmt.Sprint(creditAccount.SettlementAmount),
					CreditAccountId:              creditAccount.CreditAccountId,
					DividendsEstimateId:          detail.DividendsEstimateOrderId,
					DividendsEstimateOrderNumber: detail.DividendsEstimateOrderNumber,
					UserId:                       creditAccount.Participator.UserId,
					UserBaseId:                   creditAccount.Participator.UserBaseId,
					OrgId:                        creditAccount.Org.OrgId,
					CompanyId:                    creditAccount.Company.CompanyId,
				})
			}
			if err15 := estimateDividendsService.Estimate(accountData); err15 != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err15.Error())
			}

			return creditAccount, nil
		}
	}
}

// CreditAccountRanking 账期结算单排名
func (creditAccountService *CreditAccountService) CreditAccountRanking(creditAccountRankingQuery *query.CreditAccountRankingQuery) (interface{}, error) {
	if err := creditAccountRankingQuery.ValidateQuery(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return nil, nil
}

// GetCreditAccount 返回账期结算单详情
func (creditAccountService *CreditAccountService) GetCreditAccount(getCreditAccountQuery *query.GetCreditAccountQuery) (interface{}, error) {
	if err := getCreditAccountQuery.ValidateQuery(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	var creditAccountRepository domain.CreditAccountRepository
	if value, err := factory.CreateCreditAccountRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		creditAccountRepository = value
	}
	creditAccount, err := creditAccountRepository.FindOne(map[string]interface{}{"creditAccountId": getCreditAccountQuery.CreditAccountId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if creditAccount == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(getCreditAccountQuery.CreditAccountId, 10)))
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return creditAccount, nil
	}
}

// ListCreditAccount 返回账期结算单列表
func (creditAccountService *CreditAccountService) ListCreditAccount(listCreditAccountQuery *query.ListCreditAccountQuery) (interface{}, error) {
	if err := listCreditAccountQuery.ValidateQuery(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	var creditAccountRepository domain.CreditAccountRepository
	if value, err := factory.CreateCreditAccountRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		creditAccountRepository = value
	}
	if count, creditAccounts, err := creditAccountRepository.Find(tool_funs.SimpleStructToMap(listCreditAccountQuery)); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return map[string]interface{}{
			"grid": map[string]interface{}{
				"total": count,
				"list":  creditAccounts,
			},
		}, nil
	}
}

// PayCreditAccount 支付分红
func (creditAccountService *CreditAccountService) PayCreditAccount(payCreditAccountCommand *command.PayCreditAccountCommand) (interface{}, error) {
	if err := payCreditAccountCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	// 参数类型转换
	creditAccountId, _ := strconv.ParseInt(payCreditAccountCommand.CreditAccountId, 10, 64)

	// 账期结算仓储初始化
	var creditAccountRepository domain.CreditAccountRepository
	if value, err1 := factory.CreateCreditAccountRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err1 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err1.Error())
	} else {
		creditAccountRepository = value
	}

	// 分红预算单仓储初始化
	var dividendsEstimateRepository domain.DividendsEstimateRepository
	if value, err2 := factory.CreateDividendsEstimateRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err2 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err2.Error())
	} else {
		dividendsEstimateRepository = value
	}

	// 账期支付消息推送领域服务初始化
	var payCreditAccountService service.PayCreditAccountService
	if value, err := factory.CreatePayCreditAccountService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		payCreditAccountService = value
		_ = payCreditAccountService.Subscribe(&subscriber.MessageServiceSubscriber{
			//TransactionContext: transactionContext.(*pgTransaction.TransactionContext),
		})
	}

	// 获取待支付的账期结算单
	creditAccount, err := creditAccountRepository.FindOne(map[string]interface{}{
		"creditAccountId": creditAccountId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if creditAccount == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(creditAccountId, 10)))
	}
	if err2 := creditAccount.Update(tool_funs.SimpleStructToMap(payCreditAccountCommand)); err2 != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err2.Error())
	}

	// 支付更新设置
	creditAccount.PaymentStatus = 2
	creditAccount.PaymentTime = time.Now()

	if creditAccountSaved, err4 := creditAccountRepository.Save(creditAccount); err4 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err4.Error())
	} else {
		// 更新账期结算单相关的分红预算单的分红结算状态
		var dividendsEstimateIds []int64
		for _, accountDetail := range creditAccount.AccountDetail {
			dividendsEstimateIds = append(dividendsEstimateIds, accountDetail.DividendsEstimateOrderId)
		}
		if count, dividendsEstimates, err3 := dividendsEstimateRepository.Find(map[string]interface{}{
			"dividendsEstimateIds": dividendsEstimateIds,
			"offsetLimit":          false,
		}); err3 != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err4.Error())
		} else {
			if count > 0 {
				for i, _ := range dividendsEstimates {
					dividendsEstimates[i].PaymentStatus = int32(2)
				}
				if _, err5 := dividendsEstimateRepository.UpdateMany(dividendsEstimates); err5 != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err5.Error())
				}
			}
		}

		if err3 := transactionContext.CommitTransaction(); err3 != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err3.Error())
		}

		// 支付消息推送
		var payData []service.PayData
		payData = append(payData, service.PayData{
			CreditAccountOrderNum: creditAccountSaved.CreditAccountOrderNum,
			SettlementAmount:      fmt.Sprint(creditAccountSaved.SettlementAmount),
			ActuallyPaidAmount:    fmt.Sprint(creditAccountSaved.ActuallyPaidAmount),
			CreditAccountId:       creditAccountSaved.CreditAccountId,
			UserId:                creditAccountSaved.Participator.UserId,
			UserBaseId:            creditAccountSaved.Participator.UserBaseId,
			OrgId:                 creditAccountSaved.Org.OrgId,
			CompanyId:             creditAccountSaved.Company.CompanyId,
		})
		if err5 := payCreditAccountService.Pay(payData); err5 != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err5.Error())
		}

		return creditAccountSaved, nil
	}
}

// RemoveCreditAccount 移除账期结算单
func (creditAccountService *CreditAccountService) RemoveCreditAccount(removeCreditAccountCommand *command.RemoveCreditAccountCommand) (interface{}, error) {
	if err := removeCreditAccountCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	// 账期结算单仓储初始化
	var creditAccountRepository domain.CreditAccountRepository
	if value, err := factory.CreateCreditAccountRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		creditAccountRepository = value
	}

	// 分红预算单仓储初始化
	var dividendsEstimateRepository domain.DividendsEstimateRepository
	if value, err := factory.CreateDividendsEstimateRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsEstimateRepository = value
	}

	// 获取账期阶段单
	creditAccount, err := creditAccountRepository.FindOne(map[string]interface{}{
		"creditAccountId": removeCreditAccountCommand.CreditAccountId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if creditAccount == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(removeCreditAccountCommand.CreditAccountId, 10)))
	}
	if creditAccountRemoved, err := creditAccountRepository.Remove(creditAccount); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		// 相关分红预算单ID列表
		dividendsEstimateIds := make([]int64, 0)

		for _, accountDetail := range creditAccount.AccountDetail {
			dividendsEstimateIds = append(dividendsEstimateIds, accountDetail.DividendsEstimateOrderId)
		}

		// 更新相关分红预算单结算状态
		if count, dividendsEstimates, err := dividendsEstimateRepository.Find(map[string]interface{}{
			"dividendsEstimateIds": dividendsEstimateIds,
		}); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		} else {
			if count > 0 {
				for i, dividendsEstimate := range dividendsEstimates {
					if !dividendsEstimate.IsCanceled {
						dividendsEstimates[i].DividendsAccountStatus = int32(1)
					}
				}
				// 保存分红预算单
				_, err3 := dividendsEstimateRepository.UpdateMany(dividendsEstimates)
				if err3 != nil {
					return nil, err3
				}
			}
		}

		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return creditAccountRemoved, nil
	}
}

// SearchCreditAccount 查询账期结算单
func (creditAccountService *CreditAccountService) SearchCreditAccount(searchCreditAccountQuery *query.SearchCreditAccountQuery) (interface{}, error) {
	if err := searchCreditAccountQuery.ValidateQuery(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	var creditAccountRepository domain.CreditAccountRepository
	if value, err := factory.CreateCreditAccountRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		creditAccountRepository = value
	}
	if count, creditAccounts, err := creditAccountRepository.Find(tool_funs.SimpleStructToMap(searchCreditAccountQuery)); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return map[string]interface{}{
			"grid": map[string]interface{}{
				"total": count,
				"list":  creditAccounts,
			},
		}, nil
	}
}

// UpdateCreditAccount 更新账期结算单
func (creditAccountService *CreditAccountService) UpdateCreditAccount(updateCreditAccountCommand *command.UpdateCreditAccountCommand) (interface{}, error) {
	if err := updateCreditAccountCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	var creditAccountRepository domain.CreditAccountRepository
	if value, err := factory.CreateCreditAccountRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		creditAccountRepository = value
	}
	creditAccount, err := creditAccountRepository.FindOne(map[string]interface{}{"creditAccountId": updateCreditAccountCommand.CreditAccountId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if creditAccount == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(updateCreditAccountCommand.CreditAccountId, 10)))
	}
	if err := creditAccount.Update(tool_funs.SimpleStructToMap(updateCreditAccountCommand)); err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	if creditAccount, err := creditAccountRepository.Save(creditAccount); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return creditAccount, nil
	}
}

func NewCreditAccountService(options map[string]interface{}) *CreditAccountService {
	newCreditAccountService := &CreditAccountService{}
	return newCreditAccountService
}