opms_backend/opms_parent/app/service/base/base_district.go

package base

import (
	"context"

	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/util/gconv"

	"dashoo.cn/micro/app/dao/base"
	model "dashoo.cn/micro/app/model/base"
	"dashoo.cn/micro/app/service"
)

type districtService struct {
	*service.ContextService
	Dao       *base.BaseDistrictDao
	DetailDao *base.BaseSalesRegionDetailDao
	RegionDao *base.BaseSalesRegionDao
}

func NewDistrictService(ctx context.Context) (svc *districtService, err error) {
	svc = new(districtService)
	if svc.ContextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = base.NewBaseDistrictDao(svc.Tenant)
	svc.DetailDao = base.NewBaseSalesRegionDetailDao(svc.Tenant)
	svc.RegionDao = base.NewBaseSalesRegionDao(svc.Tenant)
	return svc, nil
}

//GetProvincesList 所属区域列表
func (s *districtService) GetProvincesList(Id int64) (treeList []*model.ProvincesTree, err error) {
	ms := make(map[int]*model.ProvincesTree)
	var distributorList []model.BaseDistrict
	err = s.Dao.Order("id asc").Scan(&distributorList)
	if err != nil {
		g.Log().Error(err)
		return
	}

	for _, v := range distributorList {
		ms[v.Id] = &model.ProvincesTree{
			Id:       v.Id,
			ParentId: v.ParentId,
			DistName: v.DistName,
		}
	}
	for _, v := range ms {
		if _, ok := ms[v.ParentId]; ok {
			ms[v.ParentId].Children = append(ms[v.ParentId].Children, v)
			continue
		}
		treeList = append(treeList, v)
	}
	s.SortToProvince(treeList)
	return
}

// SortToProvince 省市区排序
func (s *districtService) SortToProvince(treeList []*model.ProvincesTree) []*model.ProvincesTree {
	length := len(treeList)
	for i := 0; i < length-1; i++ {
		for j := i + 1; j < length; j++ {
			if treeList[i].Id > treeList[j].Id {
				treeList[i], treeList[j] = treeList[j], treeList[i]
			}
		}
	}
	for i := 0; i < length; i++ {
		treeList[i].Children = s.SortToProvince(treeList[i].Children)
	}
	return treeList
}

// GetProvinceList 返回所有省份的
func (s *districtService) GetProvinceList() (list []*model.Province, err error) {

	err = s.Dao.Where(base.BaseDistrict.Columns.ParentId, 0).Scan(&list)
	if err != nil {
		g.Log().Error(err)
		return
	}

	return
}

//GetRegionsProvinceList 区域下所有的省份
func (s *districtService) GetRegionsProvinceList() (region []*model.Region, err error) {

	err = s.RegionDao.Fields(s.RegionDao.Columns.RegionDesc, s.RegionDao.Columns.Id).Scan(&region)
	if err != nil {
		g.Log().Error(err)
		return
	}
	var districtList []int
	for _, v := range region {
		districtList = append(districtList, v.Id)
	}
	list, err := s.Dao.M.As("dis").RightJoin("base_sales_region_detail deftail", "dis.id = deftail.province_code").
		Fields("dis.dist_name,dis.id,deftail.region_id").Where("deftail.region_id in (?)", districtList).All()
	if err != nil {
		g.Log().Error(err)
		return
	}
	ms := make(map[int][]*model.District)
	for _, v := range list.List() {
		ms[gconv.Int(v["region_id"])] = append(ms[gconv.Int(v["region_id"])], &model.District{
			Id:         gconv.Int(v["id"]),
			RegionDesc: gconv.String(v["dist_name"]),
			RegionId:   gconv.Int(v["region_id"]),
		})
	}
	for _, v := range region {
		v.Children = ms[v.Id]
	}
	return
}