video-factory/shortdrama/controller/customer_controller.go

package controller

import (
	"context"
	"errors"

	"video-factory/shortdrama/consts/public"
	"video-factory/shortdrama/dao"
	"video-factory/shortdrama/middleware"
	"video-factory/shortdrama/model/dto"
	"video-factory/shortdrama/service"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gtime"
)

type customer struct{}

var Customer = new(customer)

type createCustomerRes struct {
	Id int64 `json:"id"`
}

func (c *customer) Create(ctx context.Context, req *dto.CreateCustomerReq) (res *createCustomerRes, err error) {
	agentId := req.AgentId
	if agentId == 0 {
		r := g.RequestFromCtx(ctx)
		agentId = middleware.GetUserId(r)
	}
	user, err := service.AuthService.CreateCustomer(ctx, req.Phone, req.Name, req.Address, agentId)
	if err != nil {
		return nil, err
	}
	return &createCustomerRes{Id: user.Id}, nil
}

func (c *customer) List(ctx context.Context, req *dto.ListCustomerReq) (res *dto.ListCustomerRes, err error) {
	type customerRow struct {
		Id        int64       `orm:"id"`
		Phone     string      `orm:"phone"`
		Name      string      `orm:"name"`
		Province  string      `orm:"province"`
		Region    string      `orm:"region"`
		Address   string      `orm:"address"`
		AgentId   int64       `orm:"agent_id"`
		AgentName string      `orm:"agent_name"`
		Balance   int64       `orm:"balance"`
		CreatedAt *gtime.Time `orm:"created_at"`
	}

	m := g.DB().Model(public.TableNameUser+" u").
		InnerJoin(public.TableNameCustomerProfile+" cp", "cp.user_id = u.id").
		LeftJoin(public.TableNameUser+" au", "au.id = cp.agent_id").
		Where("u.role", "customer")

	if req.AgentId > 0 {
		m = m.Where("cp.agent_id", req.AgentId)
	}
	if req.Keyword != "" {
		m = m.Where("u.name LIKE ? OR u.phone LIKE ?", "%"+req.Keyword+"%", "%"+req.Keyword+"%")
	}
	if req.Phone != "" {
		m = m.Where("u.phone LIKE ?", "%"+req.Phone+"%")
	}
	if req.Province != "" {
		m = m.Where("u.province = ?", req.Province)
	}
	if req.Region != "" {
		m = m.Where("u.region = ?", req.Region)
	}
	if req.AgentName != "" {
		m = m.Where("au.name LIKE ? OR au.username LIKE ? OR au.phone LIKE ?", "%"+req.AgentName+"%", "%"+req.AgentName+"%", "%"+req.AgentName+"%")
	}

	var rows []*customerRow
	total, err := m.Count()
	if err != nil {
		return nil, err
	}
	err = m.Fields(
		"u.id", "u.phone", "u.name", "u.province", "u.region", "u.address", "u.created_at",
		"cp.agent_id", "cp.balance",
		"au.name agent_name",
	).Page(req.Page, req.PageSize).OrderAsc("u.id").Scan(&rows)
	if err != nil {
		return nil, err
	}

	items := make([]*dto.ListCustomerItem, len(rows))
	for i, r := range rows {
		createdAt := ""
		if r.CreatedAt != nil {
			createdAt = r.CreatedAt.Format("Y-m-d H:i:s")
		}
		items[i] = &dto.ListCustomerItem{
			Id:        r.Id,
			Phone:     r.Phone,
			Name:      r.Name,
			Province:  r.Province,
			Region:    r.Region,
			Address:   r.Address,
			AgentId:   r.AgentId,
			AgentName: r.AgentName,
			Balance:   r.Balance,
			CreatedAt: createdAt,
		}
	}
	return &dto.ListCustomerRes{List: items, Total: total, Page: req.Page, PageSize: req.PageSize}, nil
}

func (c *customer) Detail(ctx context.Context, req *struct{ Id int64 }) (res *dto.CustomerDetail, err error) {
	user, err := dao.User.GetOne(ctx, req.Id)
	if err != nil || user == nil {
		return nil, err
	}
	profile, _ := dao.CustomerProfile.Get(ctx, req.Id)
	balance := service.AuthService.GetBalance(ctx, req.Id)
	return &dto.CustomerDetail{User: user, Profile: profile, Balance: balance}, nil
}

func (c *customer) Update(ctx context.Context, req *dto.UpdateCustomerReq) (res *struct{}, err error) {
	r := g.RequestFromCtx(ctx)
	agentId := middleware.GetUserId(r)
	if ap, _ := dao.AgentProfile.Get(ctx, agentId); ap != nil && ap.ExpiredAt != nil && ap.ExpiredAt.Before(gtime.Now()) {
		return nil, errors.New("代理商已过期，无法编辑客户")
	}

	m := g.Map{}
	if req.Phone != "" {
		m["phone"] = req.Phone
	}
	if req.Name != "" {
		m["name"] = req.Name
	}
	if req.Address != "" {
		m["address"] = req.Address
		// re-extract province and region from the updated address
		province, region, err := service.AuthService.ExtractRegionFromAddress(ctx, req.Address)
		if err != nil {
			return nil, err
		}
		m["province"] = province
		m["region"] = region
	}
	if len(m) == 0 {
		return nil, nil
	}
	return nil, dao.User.UpdateFields(ctx, req.Id, m)
}