yintai2/app/admin/service/resource.go

package service

import (
	"fmt"
	"net/http"
	"strings"
	"time"
	"yintai-api/app/admin/request"
	"yintai-api/app/common/dao"
	err2 "yintai-api/app/common/err"
	"yintai-api/app/common/model"
	"yintai-api/base/global"

	"github.com/smbrave/goutil"
	"github.com/spf13/cast"
	"gorm.io/gorm"
)

var methods = map[string]struct{}{
	http.MethodGet:    {},
	http.MethodPut:    {},
	http.MethodPost:   {},
	http.MethodPatch:  {},
	http.MethodDelete: {},
}

var types = map[string]struct{}{
	model.ResourceTypeApi:  {},
	model.ResourceTypePage: {},
}

type Resource struct{}

func (r *Resource) Create(req request.ResourceCreate) int64 {
	if _, ok := types[req.Type]; !ok {
		err2.ParamErr("type", req.Type)
	}

	if req.Method != "" {
		if _, ok := methods[strings.ToUpper(req.Method)]; !ok {
			err2.ParamErr("method", req.Method)
		}
	}

	// pid check
	r.PidCheck(cast.ToInt64(req.Pid))

	m := new(model.Resource)
	m.Name = req.Name
	m.Type = req.Type
	m.Path = req.Path
	m.Code = goutil.Md5(req.Path)
	m.Method = req.Method
	m.CreateTime = time.Now().Unix()
	m.Pid = cast.ToInt64(req.Pid)

	err := global.GetDB().Transaction(func(tx *gorm.DB) error {
		if err := dao.NewResource().Create(m); err != nil {
			return err
		}

		resource, _ := dao.NewResource().Get(m.Pid)
		if resource == nil {
			m.Maps = fmt.Sprintf("/%d", m.ID)
		} else {
			m.Maps = fmt.Sprintf("%s/%d", resource.Maps, m.ID)
		}

		if err := dao.NewResource().Update(m); err != nil {
			return err
		}

		return nil
	})

	if err != nil {
		err2.DbErr(err)
	}

	return m.ID
}

func (r *Resource) PidCheck(pid int64) {
	if pid == 0 {
		return
	}

	resource, err := dao.NewResource().Get(pid)
	if err != nil {
		err2.DbErr(err)
	}

	if resource == nil {
		err2.NotEsxErr()
	}
}

func (r *Resource) Update(req request.ResourceUpdate) {
	m, err := dao.NewResource().Get(cast.ToInt64(req.ID))
	if err != nil {
		err2.DbErr(err)
	}

	if m == nil {
		err2.NotEsxErr()
		return
	}

	if req.Name != "" {
		m.Name = req.Name
	}

	if _, ok := types[req.Type]; !ok {
		err2.ParamErr("type", req.Type)
	}

	if req.Method != "" {
		if _, ok := methods[strings.ToUpper(req.Method)]; !ok {
			err2.ParamErr("method", req.Method)
		}
	}

	if cast.ToInt64(req.Pid) != m.Pid {
		r.PidCheck(m.Pid)
	}

	if req.Path != "" {
		m.Path = req.Path
	}

	pid := cast.ToInt64(req.Pid)
	if pid == m.ID {
		err2.ParamErr("pid not error")
	}

	m.UpdateTime = time.Now().Unix()
	oldMaps := m.Maps
	err = global.GetDB().Transaction(func(tx *gorm.DB) error {

		// 查询上级的maps更新m的maps
		if pid != 0 {
			// 先更新本级
			m.Pid = pid
			c, _ := dao.NewResource().Get(pid)
			m.Maps = fmt.Sprintf("%s/%d", c.Maps, m.ID)
			if err = dao.NewResource().Update(m); err != nil {
				return err
			}

			// 再更新下级
			slavers, _ := dao.NewResource().GetMaps(oldMaps)
			for _, slaver := range slavers {
				master, _ := dao.NewResource().Get(slaver.Pid)
				if master != nil {
					slaver.Maps = fmt.Sprintf("%s/%d", master.Maps, slaver.ID)
					if err = dao.NewResource().Update(slaver); err != nil {
						return err
					}
				}
			}
		}

		return nil
	})

	if err != nil {
		err2.DbErr(err)
	}

	return
}

func (r *Resource) Delete(req request.ResourceDelete) {
	m, err := dao.NewResource().Get(cast.ToInt64(req.ID))
	if err != nil {
		err2.DbErr(err)
	}

	if m == nil {
		err2.NotEsxErr()
		return
	}

	if err = dao.NewResource().Delete(m.ID); err != nil {
		err2.DbErr(err)
	}
	return
}

func (r *Resource) List(req request.ResourceList) (any, int64) {
	req.Pagination()
	lists, count, err := dao.NewResource().List(req.Name, req.Type, req.Code, req.Method, req.Path, req.Page, req.Size, req.Sort)
	if err != nil {
		err2.DbErr(err)
	}

	res := make([]map[string]any, 0)
	for _, list := range lists {
		res = append(res, list.Format())
	}

	return res, count
}