opms_backend/opms_admin/app/service/base_region_auth.go

package service

import (
	"context"
	"dashoo.cn/micro/app/dao"
	"dashoo.cn/micro/app/model"
	"database/sql"
	"fmt"
	"github.com/gogf/gf/errors/gerror"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/os/gtime"
	"github.com/gogf/gf/util/gconv"
)

type regionService struct {
	*contextService

	Dao *dao.BaseRegionAuthDao
}

func NewRegionService(ctx context.Context) (svc *regionService, err error) {
	svc = new(regionService)
	if svc.contextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = dao.NewBaseRegionAuthDao(svc.Tenant)
	return svc, nil
}

// GetList 用户产品线列表
func (s *regionService) GetList(req *model.BaseRegionAuthSearchReq) (regions []*model.BaseRegionAuth, err error) {
	regionModel := s.Dao.M
	if req.UserId != 0 {
		regionModel = regionModel.Where("user_id", req.UserId)
	}
	if req.UserName != "" {
		regionModel = regionModel.Where("user_name", req.UserName)
	}
	if req.UserPost != "" {
		regionModel = regionModel.Where("user_post", req.UserPost)
	}
	if req.UserPhone != "" {
		regionModel = regionModel.Where("user_phone", req.UserPhone)
	}
	if req.SaleRegionId != 0 {
		regionModel = regionModel.Where("sale_region_id", req.SaleRegionId)
	}
	if req.SaleRegionName != "" {
		regionModel = regionModel.Where("sale_region_name", req.SaleRegionName)
	}
	if req.ProvinceId != 0 {
		regionModel = regionModel.Where("province_id", req.ProvinceId)
	}
	if req.ProvinceName != "" {
		regionModel = regionModel.Where("province_name", req.ProvinceName)
	}
	if req.CityId != 0 {
		regionModel = regionModel.Where("city_id", req.CityId)
	}
	if req.CityName != "" {
		regionModel = regionModel.Where("city_name", req.CityName)
	}

	err = regionModel.Order("id ASC").Scan(&regions)
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("获取数据失败")
	}
	return
}

// Save 创建或更新数据
func (s *regionService) Save(req *model.SaveBaseRegionAuthReq) (err error) {
	var newRegions []*model.BaseRegionAuth

	// 标记删除旧数据
	oldRegions, err := s.Dao.Where(fmt.Sprintf("user_id='%v' AND sale_region_id='%v'", req.UserId, req.SaleRegionId)).FindAll()
	if err != nil {
		return err
	}

	// 填入新数据
	for _, region := range req.Regions {
		isNew := true
		for _, old := range oldRegions {
			if region.ProvinceId == old.ProvinceId && region.CityId == old.CityId {
				isNew = false
				break
			}
		}
		if isNew {
			data := &model.BaseRegionAuth{
				UserId:         req.UserId,
				UserName:       req.UserName,
				UserPhone:      req.UserPhone,
				UserPost:       req.UserPost,
				SaleRegionId:   req.SaleRegionId,
				SaleRegionName: req.SaleRegionName,
				ProvinceId:     region.ProvinceId,
				ProvinceName:   region.ProvinceName,
				CityId:         region.CityId,
				CityName:       region.CityName,
				Remark:         region.Remark,
			}
			SetCreatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
			SetUpdatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())

			newRegions = append(newRegions, data)
		}
	}
	// 标记删除旧数据
	for index, old := range oldRegions {
		isDelete := true
		for _, region := range req.Regions {
			if region.ProvinceId == old.ProvinceId && region.CityId == old.CityId {
				isDelete = false
				break
			}
		}
		if isDelete {
			// 标记删除
			oldRegions[index].DeletedTime = gtime.Now()
			// 将删除数据存入切片中
			newRegions = append(newRegions, oldRegions[index])
		}
	}
	if len(newRegions) > 0 {
		_, err = s.Dao.Save(newRegions)
	}

	return
}

func (s *regionService) GetRegionUsers(req *model.SysUserSearchReq) (total int, regions []*model.ReturnBaseRegionAuth, err error) {
	userService, err := NewUserService(s.Ctx)
	if err != nil {
		return 0, nil, err
	}

	//total, users, err := userService.GetUsersByDeptEx(req)
	req.Status = "10"
	total, users, err := userService.GetUserList(req)
	if err != nil {
		return 0, nil, err
	}

	var userIds []int
	for _, user := range users {
		userIds = append(userIds, user.Id)
	}

	allRegions, err := s.Dao.Where("user_id IN (?)", userIds).Order("user_id ASC, id ASC").FindAll()
	if err != nil && err != sql.ErrNoRows {
		return 0, nil, err
	}
	for _, user := range users {
		var data model.ReturnBaseRegionAuth
		data.UserId = user.Id
		data.UserName = user.NickName
		data.UserPost = "" // TODO 暂时为空
		data.UserPhone = user.Phone
		for _, region := range allRegions {
			if user.Id == region.UserId {
				if data.RegionInfo == "" {
					data.SaleRegionId = gconv.String(region.SaleRegionId)
					data.SaleRegionName = region.SaleRegionName
					data.ProvinceId = gconv.String(region.ProvinceId)
					data.ProvinceName = region.ProvinceName
					data.CityId = gconv.String(region.CityId)
					data.CityName = region.CityName
					data.RegionInfo = region.SaleRegionName + "-" + region.ProvinceName + "-" + region.CityName
				} else {
					data.SaleRegionId += "," + gconv.String(region.SaleRegionId)
					data.SaleRegionName += "," + region.SaleRegionName
					data.ProvinceId += "," + gconv.String(region.ProvinceId)
					data.ProvinceName += "," + region.ProvinceName
					data.CityId += "," + gconv.String(region.CityId)
					data.CityName += "," + region.CityName
					data.RegionInfo += region.SaleRegionName + "-" + region.ProvinceName + "-" + region.CityName
				}
			}
		}

		regions = append(regions, &data)
	}

	return
}

// 获取当前用户 地区授权
func (s *regionService) getCurrentUserRegionAuth(userId ...int) ([]string, error) {
	defaultUser := s.GetCxtUserId()
	if len(userId) > 0 {
		defaultUser = userId[0]
	}
	result, err := s.Dao.Where(s.Dao.C.UserId, defaultUser).Fields(s.Dao.C.CityId).Array()
	if err != nil {
		return nil, err
	}
	return gconv.Strings(result), nil
}

// 获取当前用户地区省份授权
func (s *regionService) GetCurrentUserProvinceAuth(userId ...int) (g.Map, error) {
	defaultUser := s.GetCxtUserId()
	if len(userId) > 0 {
		defaultUser = userId[0]
	}
	authList, err := s.Dao.Where(s.Dao.C.UserId, defaultUser).Fields(s.Dao.C.ProvinceId, s.Dao.C.ProvinceName).Distinct().All()
	if err != nil {
		return nil, err
	}
	if len(authList) == 0 {
		return nil, err
	}
	provinceList := make(g.ListStrStr, 0)
	for _, v := range authList {
		provinceList = append(provinceList, g.MapStrStr{
			"id":         "auth" + gconv.String(v.ProvinceId),
			"regionCode": gconv.String(v.ProvinceId),
			"regionDesc": v.ProvinceName,
		})
	}
	result := g.Map{
		"id":         "auth99999999",
		"regionCode": "99999999",
		"regionDesc": "负责区域",
		"children":   provinceList,
	}
	return result, nil
}