opms_backend/opms_parent/app/service/cust/cust_customer_invoice_header.go

package cust

import (
	"context"
	"database/sql"
	"fmt"

	dao "dashoo.cn/micro/app/dao/cust"
	model "dashoo.cn/micro/app/model/cust"
	"dashoo.cn/opms_libary/micro_srv"
	"dashoo.cn/opms_libary/myerrors"
	"dashoo.cn/opms_libary/request"

	"github.com/gogf/gf/os/gtime"
	"github.com/gogf/gf/util/gvalid"
)

type CustCustomerInvoiceHeaderService struct {
	Dao         *dao.CustCustomerInvoiceHeaderDao
	CustomerDao *dao.CustCustomerDao
	Tenant      string
	userInfo    request.UserInfo
}

func NewCustCustomerInvoiceHeaderService(ctx context.Context) (*CustCustomerInvoiceHeaderService, error) {
	tenant, err := micro_srv.GetTenant(ctx)
	if err != nil {
		return nil, fmt.Errorf("获取组合码异常：%s", err.Error())
	}
	// 获取用户信息
	userInfo, err := micro_srv.GetUserInfo(ctx)
	if err != nil {
		return nil, fmt.Errorf("获取用户信息异常：%s", err.Error())
	}
	return &CustCustomerInvoiceHeaderService{
		Dao:         dao.NewCustCustomerInvoiceHeaderDao(tenant),
		CustomerDao: dao.NewCustCustomerDao(tenant),
		Tenant:      tenant,
		userInfo:    userInfo,
	}, nil
}

func (s CustCustomerInvoiceHeaderService) Get(ctx context.Context, id int) (*model.CustCustomerInvoiceHeader, error) {
	ent, err := s.Dao.Where("Id = ?", id).One()
	if err != nil {
		return nil, err
	}
	if ent == nil {
		return nil, myerrors.TipsError("开票抬头不存在")
	}
	return ent, nil
}

func (s CustCustomerInvoiceHeaderService) List(ctx context.Context, req *model.CustCustomerInvoiceHeaderListReq) (int, []*model.CustCustomerInvoiceHeader, error) {
	dao := &s.Dao.CustCustomerInvoiceHeaderDao
	if req.SearchText != "" {
		likestr := fmt.Sprintf("%%%s%%", req.SearchText)
		dao = dao.Where("(cuct_name LIKE ? || company_name LIKE ? || tax_no LIKE ?)", likestr, likestr, likestr)
	}
	if req.CustId != 0 {
		dao = dao.Where("cust_id = ?", req.CustId)
	}
	if req.CuctName != "" {
		likestr := fmt.Sprintf("%%%s%%", req.CuctName)
		dao = dao.Where("cuct_name like ?", likestr)
	}
	if req.CompanyName != "" {
		likestr := fmt.Sprintf("%%%s%%", req.CompanyName)
		dao = dao.Where("company_name like ?", likestr)
	}
	if req.TaxNo != "" {
		likestr := fmt.Sprintf("%%%s%%", req.TaxNo)
		dao = dao.Where("tax_no like ?", likestr)
	}
	if req.BeginTime != "" {
		dao = dao.Where("created_time > ?", req.BeginTime)
	}
	if req.EndTime != "" {
		dao = dao.Where("created_time < ?", req.EndTime)
	}

	total, err := dao.Count()
	if err != nil {
		return 0, nil, err
	}
	if req.PageNum != 0 {
		dao = dao.Page(req.GetPage())
	}
	orderby := "created_time desc"
	if req.OrderBy != "" {
		orderby = req.OrderBy
	}
	dao = dao.Order(orderby)

	ents := []*model.CustCustomerInvoiceHeader{}
	err = dao.Structs(&ents)
	if err != nil && err != sql.ErrNoRows {
		return 0, nil, err
	}
	return total, ents, err
}

func (s CustCustomerInvoiceHeaderService) Add(ctx context.Context, req *model.CustCustomerInvoiceHeaderAddReq) (int, error) {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return 0, myerrors.TipsError(validErr.Current().Error())
	}

	ent, err := s.CustomerDao.Where("id = ?", req.CustId).One()
	if err != nil {
		return 0, err
	}
	if ent == nil {
		return 0, myerrors.TipsError(fmt.Sprintf("客户:%d 不存在", req.CustId))
	}

	id, err := s.Dao.InsertAndGetId(model.CustCustomerInvoiceHeader{
		CustId:      req.CustId,
		CuctName:    ent.CustName,
		CompanyName: req.CompanyName,
		TaxNo:       req.TaxNo,
		Address:     req.Address,
		Telephone:   req.Telephone,
		BankNo:      req.BankNo,
		Remark:      req.Remark,
		CreatedBy:   int(s.userInfo.Id),
		CreatedName: s.userInfo.NickName,
		CreatedTime: gtime.Now(),
		UpdatedBy:   int(s.userInfo.Id),
		UpdatedName: s.userInfo.NickName,
		UpdatedTime: gtime.Now(),
	})
	if err != nil {
		return 0, err
	}
	return int(id), err
}

func (s CustCustomerInvoiceHeaderService) Update(ctx context.Context, req *model.CustCustomerInvoiceHeaderUpdateReq) error {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return myerrors.TipsError(validErr.Current().Error())
	}

	ent, err := s.Dao.Where("id = ?", req.Id).One()
	if err != nil {
		return err
	}
	if ent == nil {
		return myerrors.TipsError(fmt.Sprintf("开票抬头不存在: %d", req.Id))
	}

	dao := &s.Dao.CustCustomerInvoiceHeaderDao
	toupdate := map[string]interface{}{}
	if req.CompanyName != "" {
		toupdate["company_name"] = req.CompanyName
	}
	if req.TaxNo != "" {
		toupdate["tax_no"] = req.TaxNo
	}
	if req.Address != "" {
		toupdate["address"] = req.Address
	}
	if req.Telephone != "" {
		toupdate["telephone"] = req.Telephone
	}
	if req.BankNo != "" {
		toupdate["bank_no"] = req.BankNo
	}
	if req.Remark != nil {
		toupdate["remark"] = *req.Remark
	}
	if len(toupdate) != 0 {
		toupdate["updated_by"] = int(s.userInfo.Id)
		toupdate["updated_name"] = s.userInfo.NickName
		toupdate["updated_time"] = gtime.Now()
		_, err = dao.Where("Id", req.Id).Data(toupdate).Update()
		if err != nil {
			return err
		}
	}
	return nil
}

func (s CustCustomerInvoiceHeaderService) Delete(ctx context.Context, id []int) error {
	if len(id) == 0 {
		return nil
	}
	_, err := s.Dao.Where("Id  IN (?)", id).Delete()
	return err
}