lims_adapter/service/account/account.go

package account

import (
	"dashoo.cn/micro_libary/request"
	"database/sql"
	"errors"
	"fmt"
	"github.com/gogf/gf/os/gtime"
	dao "lims_adapter/dao/account"
	account "lims_adapter/model/account"
	"math"
	"strconv"
)

// Service 账号相关
type Service struct {
	Dao    *dao.SettleAccountMainDao
	Tenant string
}

type AccountService struct {
	Dao    *dao.BaseAccountDao
	Tenant string
}

func NewAccountSrv(tenant string) AccountService {
	return AccountService{Dao: dao.NewBaseAccountDao(tenant), Tenant: tenant}
}

// AddAccount 添加财务账号
func (s AccountService) Save(req *account.BaseAccount, user request.UserInfo) error {
	now := gtime.Now()
	if req.Id == 0 {
		req.CreateUserId = int(user.Id)
		req.CreateBy = user.RealName
		req.CreateOn = now
	} else {
		var original account.BaseAccount
		err := s.Dao.Where("Id=?", req.Id).Scan(&original)
		if err != nil {
			return err
		}
		if req.MainUserId != original.MainUserId { // 更换了主用户，需要进行校验
			count, err := s.Dao.DB.Model("settle_account_bill").Where(fmt.Sprintf("(Status='0' OR Status='1') AND AccountId='%v'", original.Id)).Count()
			if err != nil {
				return err
			}
			if count > 0 {
				return errors.New("该主用户存在未结算的已出账单，不可更改")
			}

			// 该主用户存在未结算的未出账单（判断的是该主用户所有的账号）
			count, err = s.Dao.DB.Model("settle_account_main").Where(fmt.Sprintf("AccountStatus<>'1' AND MainUserId='%v'", original.MainUserId)).Count()
			if err != nil {
				return err
			}
			if count > 0 {
				return errors.New("该主用户存在未结算的未出账单，不可更改")
			}
		}
	}
	req.UpdateUserId = int(user.Id)
	req.UpdateBy = user.RealName
	req.UpdateOn = now

	_, err := s.Dao.Save(req)
	return err
}

// AccountList 财务账号分页查询
func (s AccountService) AccountList(req *account.AccountReq, user request.UserInfo) (infos account.BaseAccountRsp, err error) {
	current := req.PageNun
	size := req.PageSize
	model := s.Dao.DB.Model("base_account a")
	if req.Account != "" {
		model = model.WhereLike("Account", "%"+req.Account+"%")
	}
	if req.RealName != "" {
		model = model.WhereLike("MainUser", "%"+req.RealName+"%")
	}
	if req.AccountName != "" {
		model = model.WhereLike("AccountName", "%"+req.AccountName+"%")
	}
	if req.IsSelf != "1" { // 1 查看全部；其他 查看自己
		model = model.Where("MainUserId", user.Id)
	}
	infos.Total, err = model.Count()
	if err != nil {
		return infos, err
	}
	err = model.Fields("a.*").Page(current, size).Order("CreateOn DESC").Scan(&infos.Records)
	return infos, nil
}

// DepositAccount 充值账户
func (s AccountService) DepositAccount(req *account.BaseAccountResp) error {
	_, err := s.Dao.M.Update(fmt.Sprintf("Surplus='%v',Available='%v'", req.Surplus, req.Available), "Id = "+strconv.Itoa(req.Id))
	return err
}

// 计算费用
func (s AccountService) Calculate(req *account.CalculateAmountReq) error {
	var main account.SettleAccountMain
	var detail account.SettleAccountDetail
	var baseAccount account.BaseAccount

	// 获取结算明细记录
	result, err := s.Dao.DB.Model("settle_account_main").Where(fmt.Sprintf("AppointId='%v'", req.AppointId)).FindOne()
	if err != nil {
		if err != sql.ErrNoRows {
			return err
		} else {
			// 预约没有对应的结算明细记录，返回
			return nil
		}
	}
	err = result.Struct(&main)
	if err != nil && err != sql.ErrNoRows {
		return err
	}
	if main.Id == 0 { // 预约没有对应的结算明细记录，返回
		return nil
	}

	// 获取费用明细记录
	result, err = s.Dao.DB.Model("settle_account_detail").Where(fmt.Sprintf("pid='%v' AND PaymentType='0'", main.Id)).FindOne()
	if err != nil {
		return err
	}
	err = result.Struct(&detail)
	if err != nil {
		return err
	}

	// 获取账号信息
	result, err = s.Dao.DB.Model("base_account").Where(fmt.Sprintf("MainUserId='%v'", main.MainUserId)).Order("Advance ASC, Id ASC").FindOne()
	if err != nil {
		return err
	}
	err = result.Struct(&baseAccount)
	if err != nil {
		return err
	}

	// 计算费用
	discount := float64(1) // 计算折扣
	if detail.Data5 != "" {
		d, _ := strconv.ParseFloat(detail.Data5, 64)
		discount = 1 - d/100
	}

	oldAmount := detail.PaymentAccount
	main.ActualStartDate = req.SignInTime
	main.ActualEndDate = req.SignOutTime

	span := req.SignOutTime.Sub(req.SignInTime)
	main.FeeTime = int(math.Ceil(span.Minutes()))
	main.ActualMachineHour = main.FeeTime
	detail.ActualMinutes = strconv.Itoa(main.FeeTime)
	detail.Minutes = strconv.Itoa(main.FeeTime)

	detail.PaymentAccount = float64(main.ActualMachineHour) * detail.UnitPrice * discount / 60 // 计算实际费用
	diffValue := oldAmount - detail.PaymentAccount
	main.TotalPrice -= diffValue // 计算实际费用

	baseAccount.Available += diffValue // 账户可用金额返还

	tx, err := s.Dao.DB.Begin()
	if err != nil {
		return err
	}

	_, err = tx.Save("settle_account_main", main)
	if err != nil {
		tx.Rollback()
		return err
	}
	_, err = tx.Save("settle_account_detail", detail)
	if err != nil {
		tx.Rollback()
		return err
	}
	_, err = tx.Save("base_account", baseAccount)
	if err != nil {
		tx.Rollback()
		return err
	}

	return tx.Commit()
}

// 通过从账户，查询主账户 财务账号信息
func (s AccountService) GetBaseAccountById(req *account.SubAccountReq) (infos account.BaseAccountRsp, err error) {
	// 先判断是主用户还是从用户
	infos.Total, err = s.Dao.DB.Model("master_user").Where(fmt.Sprintf("UserId='%v'", req.SubId)).Count()
	if err != nil {
		return infos, err
	}
	if infos.Total == 0 {
		// 主用户表没有 所以是从用户 进行连表查询
		model := s.Dao.DB.Model("base_account a").LeftJoin("base_user_relation b", "a.MainUserId=b.Pid")
		if req.SubId != "" {
			model = model.Where(fmt.Sprintf("b.UserId='%v'", req.SubId))
		}
		err = model.Fields("a.*").Order("Advance ASC, a.Id ASC").Scan(&infos.Records)
		if err != nil {
			return infos, err
		}
		return infos, nil
	} else if infos.Total > 0 {
		// 是主用户
		model := s.Dao.DB.Model("base_account a")
		if req.SubId != "" {
			model = model.Where(fmt.Sprintf("a.MainUserId='%v'", req.SubId))
		}
		err = model.Fields("a.*").Order("Advance ASC, a.Id ASC").Scan(&infos.Records)
		if err != nil {
			return infos, err
		}
		return infos, nil
	}
	return infos, nil
}