feat: murder项目整体迁移

app/brahma/api/murder/internal/config/config.go

@@ -0,0 +1,103 @@
+package config
+
+import (
+	"context"
+	"fmt"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/error_process"
+	ctxLogger "github.com/luizsuper/ctxLoggers"
+	clientV3 "go.etcd.io/etcd/client/v3"
+	"go.uber.org/zap"
+	"os"
+	"strings"
+	"time"
+)
+
+const (
+	DsnPre         = "dsn"
+	Local          = "local"
+	Env            = "env"
+	Configs        = "config"
+	Etcd           = "etcd"
+	EtcdEnd        = "endpoints"
+	EtcdEndDefault = "127.0.0.1:2379"
+	Port
+	PortDefault = "8080"
+)
+
+const (
+	TestDB = "taihe"
+)
+
+type Config map[string]string
+
+var (
+	client    *clientV3.Client
+	configMap = make(Config, 0)
+	config    clientV3.Config
+	err       error
+)
+
+func GetConfig() {
+	env := GetEnvDefault(Env, Local)
+	host := GetEnvDefault(Configs, Etcd)
+	switch host {
+	case Etcd:
+		etcdReader(env)
+	}
+}
+
+func etcdReader(env string) {
+	kv := clientV3.NewKV(client)
+	defer client.Close()
+	ctx, cancel := context.WithTimeout(context.TODO(), time.Second*3)
+	defer cancel()
+	if getResp, err := kv.Get(ctx, fmt.Sprintf("/config/%v/", env), clientV3.WithPrefix()); err == nil {
+		for _, v := range getResp.Kvs {
+			configMap[string(v.Key)] = string(v.Value)
+		}
+	} else {
+		ctxLogger.Error(nil, error_process.EtcReadError, zap.String("", err.Error()))
+		os.Exit(-1)
+	}
+}
+
+func GetConfigMap() Config {
+	return configMap
+}
+
+func GetConfigKey(key string) string {
+	configs := GetEnvDefault(Configs, "")
+	env := GetEnvDefault(Env, "")
+	switch configs {
+	case Etcd:
+		fmt.Printf("/config/%v/%v", env, key)
+		return fmt.Sprintf("/config/%v/%v", env, key)
+	default:
+		return ""
+	}
+}
+func init() {
+	connect()
+}
+
+func connect() {
+	envDefault := GetEnvDefault(EtcdEnd, EtcdEndDefault)
+	ends := strings.Split(envDefault, ",")
+	config = clientV3.Config{
+		Endpoints:   ends,
+		DialTimeout: 5 * time.Second,
+	}
+	if client, err = clientV3.New(config); err != nil {
+		ctxLogger.FError(nil, error_process.EtcConnError, zap.String("", err.Error()))
+		os.Exit(-1)
+	}
+}
+
+func GetEnvDefault(key, defVal string) string {
+	val, ex := os.LookupEnv(key)
+	if !ex {
+		os.Setenv(key, defVal)
+		return defVal
+	}
+	return val
+}

app/brahma/api/murder/internal/error_process/error.go

@@ -0,0 +1,52 @@
+package error_process
+
+import (
+	"fmt"
+	"github.com/pkg/errors"
+)
+
+var (
+	dbNotFoundErr  = errors.New("db初始化失败，未从map中获取相应db")
+	numNotMatchErr = errors.New("数量匹配失败")
+	emptyValueErr  = errors.New("空值错误")
+	extraValueErr  = errors.New("额外值错误")
+)
+
+const (
+	// BodyParserErr body 解析错误
+	BodyParserErr     = "BodyParserErr"
+	ServiceErr        = "调用service时错误"
+	EtcReadError      = "etcdReaderErr"
+	EtcConnError      = "etcConnectError"
+	PanicError        = "panicError"
+	GormError         = "gormErr"
+	NoPointError      = "不是指针类型"
+	NilPointError     = "解析失败"
+	IllegalValueError = "非法值错误"
+	GrammerError      = "语法错误"
+)
+
+func DbNotFoundErr(dbKey string) error {
+	return errors.Wrap(dbNotFoundErr, fmt.Sprintf("根据dbKey:%v没有找到db记录", dbKey))
+}
+func UpdateErr(body interface{}, condition interface{}) error {
+	return errors.Wrap(numNotMatchErr, fmt.Sprintf("update操作失败，条件为：%v，updateBody:%v", condition, body))
+}
+func CreateErr(err error, body interface{}) error {
+	return errors.Wrap(err, fmt.Sprintf("新增失败，createBody:%v", body))
+}
+func GetErr(err error, condition interface{}) error {
+	return errors.Wrap(err, fmt.Sprintf("查询失败，queryMap:%v", condition))
+}
+func RecordNotMatchWithUniqueErr(condition interface{}, expected, actual int) error {
+	return errors.WithMessage(numNotMatchErr, fmt.Sprintf("查询条件:%v，期望数量:%v,实际数量:%v", condition, expected, actual))
+}
+func EmptyValueErr(key string) error {
+	return errors.WithMessage(emptyValueErr, fmt.Sprintf("空值key:%v", key))
+}
+func CommonErr(err error) error {
+	return errors.Wrap(err, "")
+}
+func ExtraValueErr(key string) error {
+	return errors.WithMessage(extraValueErr, fmt.Sprintf("key:%v只能为空值", key))
+}

app/brahma/api/murder/internal/gorm_helper/connect.go

@@ -0,0 +1,46 @@
+package gorm_helper
+
+import (
+	"fmt"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/config"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/error_process"
+	"github.com/gofiber/fiber/v2"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+)
+
+type MysqlMapType map[string]*gorm.DB
+
+var mysqlMap = make(MysqlMapType, 0)
+
+func GormMap(dsnPre string) error {
+	dsn := fmt.Sprintf("%v/%v?charset=utf8mb4&parseTime=True&loc=Local", dsnPre, config.TestDB)
+	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
+	if err != nil {
+		return err
+	}
+	err = db.Use(&TracePlugin{})
+	if err != nil {
+		return err
+	}
+	mysqlMap[config.TestDB] = db
+	return nil
+}
+
+func GetMap() MysqlMapType {
+	return mysqlMap
+}
+
+func GetContextDB(ctx *fiber.Ctx, name ...string) (*gorm.DB, error) {
+	//自定义插件接收ctx 里面的 自定义context，打印日志
+	_ctx := ctx.UserContext()
+	db := GetMap()
+	dbName := config.TestDB
+	if len(name) != 0 {
+		dbName = name[0]
+	}
+	if v, ok := db[dbName]; ok {
+		return v.WithContext(_ctx), nil
+	}
+	return nil, error_process.DbNotFoundErr(dbName)
+}

app/brahma/api/murder/internal/gorm_helper/trace_plugin.go

@@ -0,0 +1,87 @@
+package gorm_helper
+
+import (
+	"context"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/util"
+	"github.com/gofiber/fiber/v2"
+	ctxLogger "github.com/luizsuper/ctxLoggers"
+	"github.com/spf13/cast"
+	"go.uber.org/zap"
+	"gorm.io/gorm"
+	"gorm.io/gorm/utils"
+	"time"
+)
+
+type SQL struct {
+	Timestamp   string  `json:"timestamp"`     // 时间，格式：2006-01-02 15:04:05
+	Stack       string  `json:"stack"`         // 文件地址和行号
+	SQL         string  `json:"sql"`           // SQL 语句
+	Rows        int64   `json:"rows_affected"` // 影响行数
+	CostSeconds float64 `json:"cost_seconds"`  // 执行时长(单位秒)
+}
+
+const (
+	callBackBeforeName = "core:before"
+	callBackAfterName  = "core:after"
+	startTime          = "_start_time"
+)
+
+type TracePlugin struct{}
+
+func (op *TracePlugin) Name() string {
+	return "tracePlugin"
+}
+
+func (op *TracePlugin) Initialize(db *gorm.DB) (err error) {
+	// 开始前
+	_ = db.Callback().Create().Before("gorm:before_create").Register(callBackBeforeName, before)
+	_ = db.Callback().Query().Before("gorm:query").Register(callBackBeforeName, before)
+	_ = db.Callback().Delete().Before("gorm:before_delete").Register(callBackBeforeName, before)
+	_ = db.Callback().Update().Before("gorm:setup_reflect_value").Register(callBackBeforeName, before)
+	_ = db.Callback().Row().Before("gorm:row").Register(callBackBeforeName, before)
+	_ = db.Callback().Raw().Before("gorm:raw").Register(callBackBeforeName, before)
+
+	// 结束后
+	_ = db.Callback().Create().After("gorm:after_create").Register(callBackAfterName, after)
+	_ = db.Callback().Query().After("gorm:after_query").Register(callBackAfterName, after)
+	_ = db.Callback().Delete().After("gorm:after_delete").Register(callBackAfterName, after)
+	_ = db.Callback().Update().After("gorm:after_update").Register(callBackAfterName, after)
+	_ = db.Callback().Row().After("gorm:row").Register(callBackAfterName, after)
+	_ = db.Callback().Raw().After("gorm:raw").Register(callBackAfterName, after)
+	return
+}
+
+//记录db开始时间
+func before(db *gorm.DB) {
+	db.InstanceSet(startTime, time.Now())
+	return
+}
+
+func after(db *gorm.DB) {
+	_ctx := db.Statement.Context
+	ctx, ok := _ctx.(context.Context)
+	if !ok {
+		return
+	}
+	defer ctx.Done()
+	_ts, isExist := db.InstanceGet(startTime)
+	if !isExist {
+		return
+	}
+	ts, ok := _ts.(time.Time)
+	if !ok {
+		return
+	}
+
+	sql := db.Dialector.Explain(db.Statement.SQL.String(), db.Statement.Vars...)
+	sqlInfo := new(SQL)
+	sqlInfo.Timestamp = util.CSTLayoutString()
+	sqlInfo.SQL = sql
+	sqlInfo.Stack = utils.FileWithLineNum()
+	sqlInfo.Rows = db.Statement.RowsAffected
+	sqlInfo.CostSeconds = time.Since(ts).Seconds()
+
+	ctxLogger.FInfo(nil, "sql", zap.Any("info", sqlInfo), zap.String("trace_id", cast.ToString(ctx.Value(fiber.HeaderXRequestID))))
+
+	return
+}

app/brahma/api/murder/internal/handler/category_h.go

@@ -0,0 +1,113 @@
+package handler
+
+import (
+	"fmt"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/error_process"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/model"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/service"
+	bgm "git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/util"
+	"github.com/gofiber/fiber/v2"
+	ctxLogger "github.com/luizsuper/ctxLoggers"
+	"go.uber.org/zap"
+	"strconv"
+)
+
+type (
+	CategoryReq struct {
+		Category *model.Category `json:"category" `
+	}
+	CategoriesTagReq struct {
+		Relation *model.CategoriesTagDto `json:"relation" `
+	}
+)
+
+func GetCategoryH(ctx *fiber.Ctx) error {
+	page := ctx.Query("page", "1")
+	limit := ctx.Query("size", "10")
+	iPage, _ := strconv.Atoi(page)
+	iLimit, _ := strconv.Atoi(limit)
+	s := ctx.Query("query", "")
+	queryMap := bgm.GetQueryMap(s)
+	m, num, err := service.GetCategory(iPage, iLimit, queryMap, ctx)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(&Data{
+		Elements: m,
+		Total:    num,
+	}))
+}
+
+//CreateCategoryH 创建类别
+func CreateCategoryH(ctx *fiber.Ctx) error {
+	m := new(CategoryReq)
+	if err := createCategoryParamCheck(m, ctx); err != nil {
+		ctxLogger.FError(ctx, error_process.BodyParserErr, zap.String("", fmt.Sprintf("%v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	err := service.CreateCategory(m.Category, ctx)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(nil))
+}
+
+func UpdateCategoryH(ctx *fiber.Ctx) error {
+	m := new(CategoryReq)
+	if err := checkParam(m, ctx); err != nil {
+		ctxLogger.FError(ctx, error_process.BodyParserErr, zap.String("", fmt.Sprintf("%v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	err := service.UpdateCategory(m.Category, ctx)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(nil))
+}
+
+func DeleteCategoryH(ctx *fiber.Ctx) error {
+	m := new(CategoryReq)
+	if err := checkParam(m, ctx); err != nil {
+		ctxLogger.FError(ctx, error_process.BodyParserErr, zap.String("", fmt.Sprintf("%v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	err := service.DeleteCategory(m.Category, ctx)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(nil))
+}
+
+// CreateTagForCategory 为Category 新增tag
+func CreateTagForCategory(ctx *fiber.Ctx) error {
+	m := new(CategoriesTagReq)
+	if err := checkParam(m, ctx); err != nil {
+		ctxLogger.FError(ctx, error_process.BodyParserErr, zap.String("", fmt.Sprintf("%v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	err := service.CreateTagForCategory(m.Relation, ctx)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(nil))
+}
+
+// DeleteTagForCategory 为Category 删除tag
+func DeleteTagForCategory(ctx *fiber.Ctx) error {
+	m := new(CategoriesTagReq)
+	if err := ctx.BodyParser(m); err != nil {
+		ctxLogger.FError(ctx, error_process.BodyParserErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	err := service.DeleteTagForCategory(m.Relation, ctx)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(nil))
+}

app/brahma/api/murder/internal/handler/check.go

@@ -0,0 +1,146 @@
+package handler
+
+import (
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/error_process"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/model"
+	"github.com/gofiber/fiber/v2"
+	"github.com/google/uuid"
+	"github.com/pkg/errors"
+	"github.com/spf13/cast"
+	"reflect"
+	"strings"
+)
+
+type pluginFunc func(interface{}) error
+
+func checkParam(body interface{}, ctx *fiber.Ctx, plugins ...pluginFunc) error {
+	//第一次执行解析body，并且调用插件方法
+	if ctx != nil {
+		err := ctx.BodyParser(body)
+		if err != nil {
+			return error_process.CommonErr(err)
+		}
+		for _, plugin := range plugins {
+			if err = plugin(body); err != nil {
+				return err
+			}
+		}
+	}
+	//step1 校验是否是指针
+	typ := reflect.TypeOf(body)
+	val := reflect.ValueOf(body)
+	if val.Kind().String() != reflect.Ptr.String() {
+		return errors.New(error_process.NoPointError)
+	}
+	if val.IsNil() {
+		return errors.New(error_process.NilPointError)
+	}
+	num := val.Elem().NumField()
+	for i := 0; i < num; i++ {
+		kind := val.Elem().Field(i).Kind().String()
+		switch kind {
+		case reflect.Ptr.String():
+			//显示指定某些指针跳过校验
+			if tag := typ.Elem().Field(i).Tag.Get("valid"); tag == "omitempty" {
+				continue
+			}
+			//递归调用
+			if err := checkParam(val.Elem().Field(i).Interface(), nil); err != nil {
+				return err
+			}
+		default:
+			//非空值验证
+			if tag := typ.Elem().Field(i).Tag.Get("valid"); tag == "no_empty" {
+				switch kind {
+				case reflect.Ptr.String():
+					if val.Elem().Field(i).IsNil() == true {
+						return error_process.EmptyValueErr(typ.Elem().Field(i).Tag.Get("json"))
+					}
+				case reflect.Slice.String():
+					if val.Elem().Field(i).IsNil() == true || val.Elem().Field(i).Len() == 0 {
+						return error_process.EmptyValueErr(typ.Elem().Field(i).Tag.Get("json"))
+					}
+				default:
+					if val.Elem().Field(i).IsZero() {
+						return error_process.EmptyValueErr(typ.Elem().Field(i).Tag.Get("json"))
+					}
+				}
+			}
+		}
+		//指定制验证
+		if values := typ.Elem().Field(i).Tag.Get("value"); values != "" {
+			eles := make([]string, 0)
+			if eles = strings.Split(values, "|"); len(eles) == 0 {
+				continue
+			}
+			switch kind {
+			case reflect.Int.String():
+				for _, v := range eles {
+					if b := val.Elem().Field(i).Int(); b == cast.ToInt64(v) {
+						//匹配到值定制跳出此次tag处理方法
+						goto LOOP
+					}
+				}
+				return errors.New(error_process.IllegalValueError)
+			default:
+				return errors.New(error_process.BodyParserErr)
+			}
+		}
+	LOOP:
+	}
+	return nil
+}
+
+//tag uuid 覆盖写
+func tagUuidPlugin(body interface{}) error {
+	if req, ok := body.(*TagReq); ok {
+		if req.Tag == nil {
+			return errors.New(error_process.BodyParserErr)
+		}
+		//if req.Tag.Uuid == "" {
+		//	req.Tag.Uuid = xid.New().String()
+		//}
+		return nil
+	}
+	return errors.New(error_process.BodyParserErr)
+}
+
+//category uuid 覆盖写
+func categoryUuidPlugin(body interface{}) error {
+	if req, ok := body.(*CategoryReq); ok {
+		if req.Category == nil {
+			return errors.New(error_process.BodyParserErr)
+		}
+		if req.Category.Uuid == "" {
+			req.Category.Uuid = uuid.New().String()
+		}
+		return nil
+	}
+	return errors.New(error_process.BodyParserErr)
+}
+
+//script uuid 覆盖写
+func scriptUuidPlugin(body interface{}) error {
+	if req, ok := body.(*model.Scripts); ok {
+		if req == nil {
+			return errors.New(error_process.BodyParserErr)
+		}
+		if req.Uuid == "" {
+			req.Uuid = uuid.New().String()
+		}
+		return nil
+	}
+	return errors.New(error_process.BodyParserErr)
+}
+
+func createTagParamCheck(body interface{}, ctx *fiber.Ctx) error {
+	return checkParam(body, ctx, tagUuidPlugin)
+}
+
+func createCategoryParamCheck(body interface{}, ctx *fiber.Ctx) error {
+	return checkParam(body, ctx, categoryUuidPlugin)
+}
+
+func createScriptParamCheck(body interface{}, ctx *fiber.Ctx) error {
+	return checkParam(body, ctx, scriptUuidPlugin)
+}

app/brahma/api/murder/internal/handler/dto.go

@@ -0,0 +1,36 @@
+package handler
+
+const (
+	ResponseCodeSuccess = 0
+	ResponseCodeFail    = -1
+	ResponseSuccess     = "success"
+	ResponseFail        = "fail"
+)
+
+type (
+	Response struct {
+		Code    int    `json:"code"`
+		Message string `json:"message"`
+		Data    *Data  `json:"data,omitempty"`
+	}
+	Data struct {
+		Elements interface{} `json:"elements"`
+		Total    int64       `json:"total"`
+	}
+)
+
+func fail(data *Data) Response {
+	return Response{
+		Code:    ResponseCodeFail,
+		Message: ResponseFail,
+		Data:    data,
+	}
+}
+
+func success(data *Data) Response {
+	return Response{
+		Code:    ResponseCodeSuccess,
+		Message: ResponseSuccess,
+		Data:    data,
+	}
+}

app/brahma/api/murder/internal/handler/scripts_h.go

@@ -0,0 +1,77 @@
+package handler
+
+import (
+	"fmt"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/error_process"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/model"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/service"
+	"github.com/gofiber/fiber/v2"
+	ctxLogger "github.com/luizsuper/ctxLoggers"
+	"go.uber.org/zap"
+	"strconv"
+)
+
+func GetScriptsH(ctx *fiber.Ctx) error {
+	page := ctx.Query("page", "1")
+	limit := ctx.Query("size", "10")
+	iPage, _ := strconv.Atoi(page)
+	iLimit, _ := strconv.Atoi(limit)
+	s := ctx.Query("query", "")
+	query := model.GetQuery{Query: s}
+	processMap, err := query.ProcessMap()
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.GrammerError, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	m, num, err := service.GetScripts(iPage, iLimit, processMap, ctx)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(&Data{
+		Elements: m,
+		Total:    num,
+	}))
+}
+
+func UpdateScriptsH(ctx *fiber.Ctx) error {
+	m := new(model.Scripts)
+	if err := checkParam(m, ctx); err != nil {
+		ctxLogger.FError(ctx, error_process.BodyParserErr, zap.String("", fmt.Sprintf("%v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	err := service.UpdateScripts(m, ctx)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(nil))
+}
+
+func CreateScriptsH(ctx *fiber.Ctx) error {
+	m := new(model.Scripts)
+	if err := createScriptParamCheck(m, ctx); err != nil {
+		ctxLogger.FError(ctx, error_process.BodyParserErr, zap.String("", fmt.Sprintf("%v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	err := service.CreateScripts(m, ctx)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(nil))
+}
+
+func DeleteScriptsH(ctx *fiber.Ctx) error {
+	m := new(model.Scripts)
+	if err := checkParam(m, ctx); err != nil {
+		ctxLogger.FError(ctx, error_process.BodyParserErr, zap.String("", fmt.Sprintf("%v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	err := service.DeleteScripts(m, ctx)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(nil))
+}

app/brahma/api/murder/internal/handler/tag_h.go

@@ -0,0 +1,112 @@
+package handler
+
+import (
+	"fmt"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/error_process"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/model"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/service"
+	bgm "git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/util"
+	"github.com/gofiber/fiber/v2"
+	ctxLogger "github.com/luizsuper/ctxLoggers"
+	"go.uber.org/zap"
+	"strconv"
+)
+
+type (
+	TagReq struct {
+		Tag *model.Tag `json:"tag" `
+	}
+	TagCategoriesReq struct {
+		Relation *model.TagCategoriesDto `json:"relation" `
+	}
+)
+
+func CreateTagH(ctx *fiber.Ctx) error {
+	m := new(TagReq)
+	if err := createTagParamCheck(m, ctx); err != nil {
+		ctxLogger.FError(ctx, error_process.BodyParserErr, zap.String("", fmt.Sprintf("%v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	err := service.CreateTag(m.Tag, ctx)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(nil))
+}
+
+func UpdateTagH(ctx *fiber.Ctx) error {
+	m := new(TagReq)
+	if err := checkParam(m, ctx); err != nil {
+		ctxLogger.FError(ctx, error_process.BodyParserErr, zap.String("", fmt.Sprintf("%v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	err := service.UpdateTag(m.Tag, ctx)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(nil))
+}
+
+func GetTagH(ctx *fiber.Ctx) error {
+	page := ctx.Query("page", "1")
+	limit := ctx.Query("size", "10")
+	iPage, _ := strconv.Atoi(page)
+	iLimit, _ := strconv.Atoi(limit)
+	s := ctx.Query("query", "")
+	queryMap := bgm.GetQueryMap(s)
+	m, num, err := service.GetTag(iPage, iLimit, ctx, queryMap)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(&Data{
+		Elements: m,
+		Total:    num,
+	}))
+}
+
+func DeleteTagH(ctx *fiber.Ctx) error {
+	m := new(TagReq)
+	if err := checkParam(m, ctx); err != nil {
+		ctxLogger.FError(ctx, error_process.BodyParserErr, zap.String("", fmt.Sprintf("%v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	err := service.DeleteTag(m.Tag, ctx)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(nil))
+}
+
+// CreateCategoryForTag 为Tag 新增分组
+func CreateCategoryForTag(ctx *fiber.Ctx) error {
+	m := new(TagCategoriesReq)
+	if err := checkParam(m, ctx); err != nil {
+		ctxLogger.FError(ctx, error_process.BodyParserErr, zap.String("", fmt.Sprintf("%v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	err := service.CreateCategoryForTag(m.Relation, ctx)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(nil))
+}
+
+// DeleteCategoryForTag 为Tag 删除分组
+func DeleteCategoryForTag(ctx *fiber.Ctx) error {
+	m := new(TagCategoriesReq)
+	if err := ctx.BodyParser(m); err != nil {
+		ctxLogger.FError(ctx, error_process.BodyParserErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	err := service.DelCategoryForTag(m.Relation, ctx)
+	if err != nil {
+		ctxLogger.FError(ctx, error_process.ServiceErr, zap.String("", fmt.Sprintf("%+v", err)))
+		return ctx.JSON(fail(nil))
+	}
+	return ctx.JSON(success(nil))
+}

app/brahma/api/murder/internal/model/category.go

@@ -0,0 +1,99 @@
+package model
+
+import (
+	"fmt"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/error_process"
+	bgm "git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/util"
+	"github.com/pkg/errors"
+	"github.com/spf13/cast"
+	"gorm.io/gorm"
+)
+
+type (
+	Category struct {
+		Value string `json:"value" gorm:"column:value"`
+		Uuid  string `json:"uuid" gorm:"primary_key" valid:"no_empty"`
+		IsDel int    `json:"-" gorm:"column:is_del"`
+		Tags  *[]Tag `json:"tags,omitempty" gorm:"many2many:c_tag;foreignKey:Uuid;joinForeignKey:CategoryUid;References:Uuid;JoinReferences:TagUid" valid:"no_empty"`
+	}
+	CategoriesTagDto struct {
+		TIds []string `json:"tag_ids" valid:"no_empty"`
+		Cid  string   `json:"category_id" valid:"no_empty"`
+	}
+)
+
+func (m *Category) TableName() string {
+	return "category"
+}
+
+func GetCategoryM(page, size int, query bgm.QueryMap, db *gorm.DB) ([]Category, int64, error) {
+	i := new([]Category)
+	num := int64(0)
+	for k, v := range query {
+		db = db.Where(fmt.Sprintf("%v = ?", k), v)
+	}
+	if num = db.Find(i).RowsAffected; num <= 0 {
+		return nil, 0, error_process.GetErr(errors.New(error_process.GormError), query)
+	}
+	if size > 0 {
+		db = db.Limit(size).Offset((page - 1) * size)
+	}
+	if err := db.Preload("Tags").Find(i).Error; err != nil {
+		return nil, 0, err
+	}
+	return *i, num, nil
+}
+
+func CreateCategoryM(category *Category, db *gorm.DB) error {
+	if err := db.Create(category).Error; err != nil {
+		return error_process.CreateErr(err, category)
+	}
+	return nil
+}
+
+func UpdateCategoryM(category *Category, db *gorm.DB) error {
+	if num := db.Model(Category{}).Where("uuid = ?", category.Uuid).Updates(*category).RowsAffected; num != 1 {
+		return error_process.UpdateErr(category, category.Uuid)
+	}
+	return nil
+}
+
+func CreateTagForCategoryM(cid string, tIds []string, db *gorm.DB) error {
+	c := new(Category)
+	//step1 getCategory
+	if err := db.Where(&Category{
+		Uuid: cid,
+	}).Find(c).Error; err != nil {
+		return error_process.GetErr(err, c)
+	}
+	//step2 get tags and check num is expected
+	var ts []Tag
+	if num := db.Where(tIds).Find(&ts).RowsAffected; num != cast.ToInt64(len(tIds)) {
+		return error_process.RecordNotMatchWithUniqueErr(tIds, len(tIds), cast.ToInt(num))
+	}
+	//step3 add association
+	if err := db.Model(c).Association("Tags").Append(ts); err != nil {
+		return error_process.CommonErr(err)
+	}
+	return nil
+}
+
+func DelTagForCategoryM(cid string, tIds []string, db *gorm.DB) error {
+	c := new(Category)
+	//step1 getCategory
+	if err := db.Where(&Category{
+		Uuid: cid,
+	}).Find(c).Error; err != nil {
+		return error_process.GetErr(err, c)
+	}
+	//step2 get tags and check num is expected
+	var ts []Tag
+	if num := db.Where(tIds).Find(&ts).RowsAffected; num != cast.ToInt64(len(tIds)) {
+		return error_process.RecordNotMatchWithUniqueErr(tIds, len(tIds), cast.ToInt(num))
+	}
+	//step3 add association
+	if err := db.Model(c).Association("Tags").Delete(ts); err != nil {
+		return error_process.CommonErr(err)
+	}
+	return nil
+}

app/brahma/api/murder/internal/model/dto.go

@@ -0,0 +1,124 @@
+package model
+
+import (
+	"fmt"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/error_process"
+	"github.com/pkg/errors"
+	"strings"
+)
+
+const (
+	jsonArray = "jsonArr"
+	normal    = "normal"
+)
+
+type (
+	//区分query中不同规则
+	ruleType struct {
+		rule  string
+		value string
+	}
+	QueryMap map[string]ruleType
+)
+
+type GetSqlMapFromQuery interface {
+	// ProcessMap 生成queryMap
+	ProcessMap() (QueryMap, error)
+}
+
+type GetQuery struct {
+	Query string
+}
+
+type ScriptsDto struct {
+	ScriptName            string  `json:"script_name" gorm:"column:script_name"`
+	ScriptIntro           string  `json:"script_intro" gorm:"column:script_intro"`
+	ScriptTag             strs    `json:"script_tag" gorm:"column:script_tag"`
+	ScriptScore           float64 `json:"script_score" gorm:"column:script_score"`
+	GroupDuration         int     `json:"group_duration" gorm:"column:group_duration"`
+	ScriptCoverUrl        string  `json:"script_cover_url" gorm:"column:script_cover_url"`
+	ScriptTextContext     string  `json:"script_text_context" gorm:"column:script_text_context"`
+	ScriptPlotScore       float64 `json:"script_plot_score" gorm:"column:script_plot_score"`
+	ScriptImageContent    strs    `json:"script_image_content" gorm:"column:script_image_content"`
+	ScriptMalePlayer      int     `json:"script_male_player" gorm:"column:script_male_player"`
+	ScriptFemalePlayer    int     `json:"script_female_player" gorm:"column:script_female_player"`
+	ScriptDifficultDegree string  `json:"script_difficult_degree" gorm:"column:script_difficult_degree"`
+	ScriptPlayerLimit     int     `json:"script_player_limit" gorm:"column:script_player_limit"`
+	Uuid                  string  `json:"uuid" gorm:"column:uuid" valid:"no_empty"`
+	ScriptComplexScore    float64 `json:"script_complex_score" gorm:"column:script_complex_score"`
+}
+
+//检查语法
+func checkGrammar(value string) bool {
+	//如果 = 左右两侧 不是完整的key、value返回错误
+	var pairs []string
+	if pairs = strings.Split(value, "="); len(pairs) != 2 {
+		return false
+	}
+	//如果 value 没有完整闭合括号则返回错误
+	bytes := []byte(pairs[1])
+	if (bytes[0] == '(' && bytes[len(bytes)-1] != ')') || (bytes[len(bytes)-1] == ')' && bytes[0] != '(') {
+		return false
+	}
+	return true
+}
+
+//处理json数组
+func processJsonArr(pair []string) (string, bool) {
+	value := fmt.Sprintf("JSON_CONTAINS(%v,JSON_ARRAY(", pair[0])
+	//处理括号，遍历元素
+	arrs := strings.Split(string([]byte(pair[1])[1:len([]byte(pair[1]))-1]), "|")
+	for _, v := range arrs {
+		//如果大括号里面没有元素
+		if v == "" {
+			return "", false
+		}
+		value = fmt.Sprintf("%v%v,", value, v)
+	}
+	s := []byte(value)
+	value = string(s[0:len(s)-1]) + "))"
+	return value, true
+
+}
+
+// ProcessMap 生成查询map
+func (g GetQuery) ProcessMap() (QueryMap, error) {
+	m := make(QueryMap)
+	//寻找没有软删掉的数据
+	m["is_del"] = ruleType{rule: normal, value: `0`}
+	//不满足最小查询条件直接返回
+	if len([]byte(g.Query)) < 5 {
+		return m, nil
+	}
+	//括号不匹配直接返回
+	if bytes := []byte(g.Query); bytes[0] != '(' || bytes[len(bytes)-1] != ')' {
+		return nil, errors.New(error_process.GrammerError)
+	}
+	//处理query字符串、掐头去尾
+	g.Query = string([]byte(g.Query)[1 : len([]byte(g.Query))-1])
+	//遍历处理过的字符串，根据query规则生成queryMap
+	for _, v := range strings.Split(g.Query, ",") {
+		if !checkGrammar(v) {
+			return nil, errors.New(error_process.GrammerError)
+		}
+		pairs := strings.Split(v, "=")
+		bytes := []byte(pairs[1])
+		//是否是json数组
+		if bytes[0] == '(' && bytes[len(bytes)-1] == ')' {
+			if value, usable := processJsonArr(pairs); usable {
+				m[pairs[0]] = ruleType{
+					rule:  jsonArray,
+					value: value,
+				}
+				continue
+			}
+			return nil, errors.New(error_process.GrammerError)
+		}
+		//普通字段
+		m[pairs[0]] = ruleType{
+			rule:  normal,
+			value: pairs[1],
+		}
+	}
+	return m, nil
+}

app/brahma/api/murder/internal/model/scripts.go

@@ -0,0 +1,90 @@
+package model
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+	"fmt"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/error_process"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+)
+
+type (
+	ints []int
+	strs []string
+)
+
+type Scripts struct {
+	ScriptName            string  `json:"script_name" gorm:"column:script_name"`
+	ScriptIntro           string  `json:"script_intro" gorm:"column:script_intro"`
+	ScriptTag             ints    `json:"script_tag" gorm:"column:script_tag"`
+	ScriptScore           float64 `json:"script_score" gorm:"column:script_score"`
+	GroupDuration         int     `json:"group_duration" gorm:"column:group_duration"`
+	ScriptCoverUrl        string  `json:"script_cover_url" gorm:"column:script_cover_url"`
+	ScriptTextContext     string  `json:"script_text_context" gorm:"column:script_text_context"`
+	ScriptPlotScore       float64 `json:"script_plot_score" gorm:"column:script_plot_score"`
+	ScriptImageContent    strs    `json:"script_image_content" gorm:"column:script_image_content"`
+	ScriptMalePlayer      int     `json:"script_male_player" gorm:"column:script_male_player"`
+	ScriptFemalePlayer    int     `json:"script_female_player" gorm:"column:script_female_player"`
+	ScriptDifficultDegree string  `json:"script_difficult_degree" gorm:"column:script_difficult_degree"`
+	ScriptPlayerLimit     int     `json:"script_player_limit" gorm:"column:script_player_limit"`
+	Uuid                  string  `json:"uuid" gorm:"column:uuid" valid:"no_empty"`
+	ScriptComplexScore    float64 `json:"script_complex_score" gorm:"column:script_complex_score"`
+	Qid                   string  `json:"qid" gorm:"column:qid"`
+	IsDel                 int     `json:"-" gorm:"column:is_del"`
+}
+
+func (m *Scripts) TableName() string {
+	return "scripts"
+}
+
+func (p ints) Value() (driver.Value, error) {
+	return json.Marshal(p)
+}
+
+func (p *ints) Scan(input interface{}) error {
+	return json.Unmarshal(input.([]byte), &p)
+}
+
+func (p strs) Value() (driver.Value, error) {
+	return json.Marshal(p)
+}
+
+func (p *strs) Scan(input interface{}) error {
+	return json.Unmarshal(input.([]byte), &p)
+}
+
+func GetScriptsM(page, size int, query QueryMap, db *gorm.DB) ([]Scripts, int64, error) {
+	i := new([]Scripts)
+	num := int64(0)
+	for k, v := range query {
+		if v.rule == normal {
+			db = db.Where(fmt.Sprintf("%v = ?", k), v.value)
+		}
+		if v.rule == jsonArray {
+			db = db.Where(v.value)
+		}
+	}
+	if num = db.Find(i).RowsAffected; num < 0 {
+		return nil, 0, error_process.GetErr(errors.New(error_process.GormError), query)
+	}
+	if size > 0 {
+		db = db.Limit(size).Offset((page - 1) * size)
+	}
+	db.Find(i)
+	return *i, num, nil
+}
+
+func UpdateScriptsM(scripts *Scripts, db *gorm.DB) error {
+	if num := db.Model(Scripts{}).Where("uuid = ?", scripts.Uuid).Updates(scripts).RowsAffected; num != 1 {
+		return error_process.UpdateErr(scripts, scripts.Uuid)
+	}
+	return nil
+}
+
+func CreateScriptsM(script *Scripts, db *gorm.DB) error {
+	if err := db.Create(script).Error; err != nil {
+		return error_process.CreateErr(err, script)
+	}
+	return nil
+}

app/brahma/api/murder/internal/model/tag.go

@@ -0,0 +1,101 @@
+package model
+
+import (
+	"fmt"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/error_process"
+	bgm "git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/util"
+	"github.com/pkg/errors"
+	"github.com/spf13/cast"
+	"gorm.io/gorm"
+)
+
+type (
+	Tag struct {
+		Value string      `json:"value" gorm:"column:value"`
+		Uuid  int         `json:"uuid" gorm:"primary_key" valid:"no_empty"`
+		IsDel int         `json:"-" gorm:"column:is_del" value:"1|0"`
+		Cs    *[]Category `json:"categories,omitempty" gorm:"many2many:c_tag;foreignKey:Uuid;joinForeignKey:TagUid;References:Uuid;JoinReferences:CategoryUid" valid:"no_empty"`
+	}
+	// TagCategoriesDto 为标签新增分组
+	TagCategoriesDto struct {
+		CIds []string `json:"category_ids" valid:"no_empty"`
+		Tid  int      `json:"tag_id" valid:"no_empty"`
+	}
+)
+
+func (m *Tag) TableName() string {
+	return "tag"
+}
+
+func CreateTagM(tag *Tag, db *gorm.DB) error {
+	if err := db.Create(tag).Error; err != nil {
+		return error_process.CreateErr(err, tag)
+	}
+	return nil
+}
+
+func UpdateTagM(tag *Tag, db *gorm.DB) error {
+	if num := db.Model(Tag{}).Where("uuid = ?", tag.Uuid).Updates(*tag).RowsAffected; num != 1 {
+		return error_process.UpdateErr(tag, fmt.Sprintf("uuid:%v", tag.Uuid))
+	}
+	return nil
+}
+
+func GetTagM(page, size int, query bgm.QueryMap, db *gorm.DB) ([]Tag, int64, error) {
+	t := new([]Tag)
+	num := int64(0)
+	for k, v := range query {
+		db = db.Where(fmt.Sprintf("%v = ?", k), v)
+	}
+	if num = db.Find(t).RowsAffected; num <= 0 {
+		return nil, 0, error_process.GetErr(errors.New(error_process.GormError), query)
+	}
+	if size > 0 {
+		db = db.Limit(size).Offset((page - 1) * size)
+	}
+	if err := db.Preload("Cs").Find(t).Error; err != nil {
+		return nil, 0, err
+	}
+	return *t, num, nil
+}
+
+func CreateCategoryForTagM(tid int, cIds []string, db *gorm.DB) error {
+	t := new(Tag)
+	//step1 getTag
+	if err := db.Where(&Tag{
+		Uuid: tid,
+	}).Find(t).Error; err != nil {
+		return error_process.GetErr(err, t)
+	}
+	//step2 get categories and check num is expected
+	var cs []Category
+	if num := db.Where(cIds).Find(&cs).RowsAffected; num != cast.ToInt64(len(cIds)) {
+		return error_process.RecordNotMatchWithUniqueErr(cIds, len(cIds), cast.ToInt(num))
+	}
+	//step3 add association
+	if err := db.Model(t).Association("Cs").Append(cs); err != nil {
+		return error_process.CommonErr(err)
+	}
+	return nil
+}
+
+func DelCategoryForTagM(tid int, cIds []string, db *gorm.DB) error {
+	t := new(Tag)
+	//step1 checkTagNum
+	if err := db.Where(&Tag{
+		Uuid: tid,
+	}).Find(t).Error; err != nil {
+		return error_process.GetErr(err, t)
+	}
+	//step2 check cIdsNum
+	var cs []Category
+	if num := db.Where(cIds).Find(&cs).RowsAffected; num != cast.ToInt64(len(cs)) {
+		return error_process.RecordNotMatchWithUniqueErr(cIds, len(cIds), cast.ToInt(num))
+	}
+	//step3 add association
+	err := db.Model(t).Association("Cs").Delete(cs)
+	if err != nil {
+		return error_process.CommonErr(err)
+	}
+	return nil
+}

app/brahma/api/murder/internal/service/category.go

@@ -0,0 +1,83 @@
+package service
+
+import (
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/error_process"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/gorm_helper"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/model"
+	bgm "git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/util"
+	"github.com/gofiber/fiber/v2"
+	"gorm.io/gorm"
+)
+
+func CreateCategory(category *model.Category, ctx *fiber.Ctx) error {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return err
+	}
+	return model.CreateCategoryM(category, db)
+}
+
+func GetCategory(page, limit int, query bgm.QueryMap, ctx *fiber.Ctx) ([]model.Category, int64, error) {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return nil, 0, err
+	}
+	return model.GetCategoryM(page, limit, query, db)
+}
+
+func UpdateCategory(category *model.Category, ctx *fiber.Ctx) error {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return err
+	}
+	return model.UpdateCategoryM(category, db)
+}
+
+func DeleteCategory(category *model.Category, ctx *fiber.Ctx) error {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	category.IsDel = 1
+	//根据uuid对 is_del字段update，其他字段不允许传入
+	if category.Value != "" {
+		return error_process.ExtraValueErr("Value")
+	}
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return err
+	}
+	return model.UpdateCategoryM(category, db)
+}
+
+// CreateTagForCategory 为Category 新增tag
+func CreateTagForCategory(cTags *model.CategoriesTagDto, ctx *fiber.Ctx) error {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return err
+	}
+	return model.CreateTagForCategoryM(cTags.Cid, cTags.TIds, db)
+}
+
+// DeleteTagForCategory 删除Category分组
+func DeleteTagForCategory(cTags *model.CategoriesTagDto, ctx *fiber.Ctx) error {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return err
+	}
+	return model.DelTagForCategoryM(cTags.Cid, cTags.TIds, db)
+}

app/brahma/api/murder/internal/service/scripts.go

@@ -0,0 +1,99 @@
+package service
+
+import (
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/error_process"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/gorm_helper"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/model"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/util"
+	"github.com/gofiber/fiber/v2"
+	"gorm.io/gorm"
+	"strconv"
+)
+
+func GetScripts(page, limit int, query model.QueryMap, ctx *fiber.Ctx) ([]model.ScriptsDto, int64, error) {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return nil, 0, err
+	}
+	queryMap := make(util.QueryMap)
+	m := make(map[int]string)
+	queryMap["type"] = "script"
+	tag, _, err := model.GetTagM(-1, -1, queryMap, db)
+	if err != nil {
+		return nil, 0, err
+	}
+	for _, v := range tag {
+		m[v.Uuid] = v.Value
+	}
+	script, num, err := model.GetScriptsM(page, limit, query, db)
+	if err != nil {
+		return nil, 0, err
+	}
+	dtos := make([]model.ScriptsDto, len(script))
+	for k, v := range script {
+		tags := make([]string, len(v.ScriptTag))
+		for k1, v1 := range v.ScriptTag {
+			if tag1, ok := m[v1]; !ok {
+				return nil, 0, error_process.EmptyValueErr(strconv.Itoa(k1))
+			} else {
+				tags[k1] = tag1
+			}
+
+		}
+		dtos[k] = model.ScriptsDto{
+			ScriptName:            v.ScriptName,
+			ScriptIntro:           v.ScriptIntro,
+			ScriptTag:             tags,
+			ScriptScore:           v.ScriptScore,
+			GroupDuration:         v.GroupDuration,
+			ScriptCoverUrl:        v.ScriptCoverUrl,
+			ScriptTextContext:     v.ScriptTextContext,
+			ScriptPlotScore:       v.ScriptPlotScore,
+			ScriptImageContent:    v.ScriptImageContent,
+			ScriptMalePlayer:      v.ScriptMalePlayer,
+			ScriptFemalePlayer:    v.ScriptFemalePlayer,
+			ScriptDifficultDegree: v.ScriptDifficultDegree,
+			ScriptPlayerLimit:     v.ScriptPlayerLimit,
+			Uuid:                  v.Uuid,
+			ScriptComplexScore:    v.ScriptComplexScore,
+		}
+	}
+	return dtos, num, nil
+}
+
+func UpdateScripts(scripts *model.Scripts, ctx *fiber.Ctx) error {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return err
+	}
+	return model.UpdateScriptsM(scripts, db)
+}
+
+func CreateScripts(scripts *model.Scripts, ctx *fiber.Ctx) error {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return err
+	}
+	return model.CreateScriptsM(scripts, db)
+}
+
+func DeleteScripts(scripts *model.Scripts, ctx *fiber.Ctx) error {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return err
+	}
+	scripts.IsDel = 1
+	return model.UpdateScriptsM(scripts, db)
+}

app/brahma/api/murder/internal/service/tag.go

@@ -0,0 +1,84 @@
+package service
+
+import (
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/error_process"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/gorm_helper"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/model"
+	bgm "git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/util"
+	"github.com/gofiber/fiber/v2"
+	"gorm.io/gorm"
+)
+
+// CreateTag 新建Tag(暂不支持创建连带Category)
+func CreateTag(tag *model.Tag, ctx *fiber.Ctx) error {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return err
+	}
+	return model.CreateTagM(tag, db)
+}
+
+func UpdateTag(tag *model.Tag, ctx *fiber.Ctx) error {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return err
+	}
+	return model.UpdateTagM(tag, db)
+}
+
+func GetTag(page, limit int, ctx *fiber.Ctx, query bgm.QueryMap) ([]model.Tag, int64, error) {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return nil, 0, err
+	}
+	return model.GetTagM(page, limit, query, db)
+}
+
+func DeleteTag(tag *model.Tag, ctx *fiber.Ctx) error {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	tag.IsDel = 1
+	//根据uuid对 is_del字段update，其他字段不允许传入
+	if tag.Value != "" {
+		return error_process.ExtraValueErr("Value")
+	}
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return err
+	}
+	return model.UpdateTagM(tag, db)
+}
+
+// CreateCategoryForTag 新增删除Category分组
+func CreateCategoryForTag(cTags *model.TagCategoriesDto, ctx *fiber.Ctx) error {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return err
+	}
+	return model.CreateCategoryForTagM(cTags.Tid, cTags.CIds, db)
+}
+
+// DelCategoryForTag 删除Category分组
+func DelCategoryForTag(cTags *model.TagCategoriesDto, ctx *fiber.Ctx) error {
+	var (
+		db  *gorm.DB
+		err error
+	)
+	if db, err = gorm_helper.GetContextDB(ctx); err != nil {
+		return err
+	}
+	return model.DelCategoryForTagM(cTags.Tid, cTags.CIds, db)
+}

app/brahma/api/murder/internal/util/sql.go

@@ -0,0 +1,19 @@
+package util
+
+import "strings"
+
+type QueryMap map[string]string
+
+// GetQueryMap 根据查询条件进行sql处理
+func GetQueryMap(s string) QueryMap {
+	m := make(map[string]string)
+	if s != "" {
+		s = string([]byte(s)[1 : len([]byte(s))-1])
+		for _, v := range strings.Split(s, ",") {
+			split := strings.Split(v, "=")
+			m[split[0]] = split[1]
+		}
+	}
+	m["is_del"] = "0"
+	return m
+}

app/brahma/api/murder/internal/util/time.go

@@ -0,0 +1,25 @@
+package util
+
+import "time"
+
+var (
+	cst *time.Location
+)
+
+func init() {
+	var err error
+	if cst, err = time.LoadLocation("Asia/Shanghai"); err != nil {
+		panic(err)
+	}
+
+	// 默认设置为中国时区
+	time.Local = cst
+}
+
+// CSTLayout China Standard Time Layout
+const CSTLayout = "2006-01-02 15:04:05"
+
+func CSTLayoutString() string {
+	ts := time.Now()
+	return ts.In(cst).Format(CSTLayout)
+}

app/brahma/api/murder/main.go

@@ -1,7 +1,146 @@
 package main
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/config"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/error_process"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/gorm_helper"
+	"git.icechen.cn/monorepo/backend/app/brahma/api/murder/internal/handler"
+	"github.com/gofiber/fiber/v2"
+	"github.com/gofiber/fiber/v2/middleware/logger"
+	"github.com/gofiber/fiber/v2/middleware/recover"
+	"github.com/gofiber/fiber/v2/middleware/requestid"
+	ctxLogger "github.com/luizsuper/ctxLoggers"
+	"go.uber.org/zap"
+	"os"
+	"runtime"
+)
+
+const (
+	tag      = "/tag"
+	category = "/category"
+	scripts  = "/scripts"
+)
+
+var (
+	err error
+	//Init App
+	app = fiber.New(fiber.Config{
+		ErrorHandler: func(ctx *fiber.Ctx, err error) error {
+			return ctx.Status(fiber.StatusInternalServerError).JSON(handler.Response{Message: "服务器内部错误"})
+		},
+	})
+)
+
+func init() {
+	ResourceInit()
+	appInit()
+	routerInit()
+}
+
+// ResourceInit 读取配置初始化资源
+func ResourceInit() {
+
+	config.GetConfig()
+
+	err = gorm_helper.GormMap(config.GetConfigMap()[config.GetConfigKey(config.DsnPre)])
+	if err != nil {
+		ctxLogger.FError(nil, error_process.GormError, zap.String("", err.Error()))
+		os.Exit(-1)
+	}
+}
+
+func appInit() {
+	//requestId
+	app.Use(requestid.New())
+	//logger
+	app.Use(logger.New(logger.Config{
+		Format: "${respHeader:X-Request-ID} ${status} - ${method} ${path} ${resBody}\n",
+	}))
+	//recover
+	app.Use(recover.New(recover.Config{
+		EnableStackTrace: true,
+		StackTraceHandler: func(c *fiber.Ctx, e interface{}) {
+			buf := make([]byte, 1024*1024)
+			buf = buf[:runtime.Stack(buf, false)]
+			fmt.Printf("panic: %v\n%s\n", e, buf)
+			ctxLogger.FError(c, error_process.PanicError, zap.String("", fmt.Sprintf("panic: %v\n%s\n", e, buf)))
+		},
+	}))
+	//requestId for gorm
+	app.Use(func(ctx *fiber.Ctx) error {
+		ctx.SetUserContext(context.WithValue(context.Background(), fiber.HeaderXRequestID, ctx.Response().Header.Peek(fiber.HeaderXRequestID)))
+		return ctx.Next()
+	})
+}
+
+func routerInit() {
+	//Tag router
+	tagRoute := app.Group(tag)
+	tagRoute.Get("", func(ctx *fiber.Ctx) error {
+		return handler.GetTagH(ctx)
+	})
+	tagRoute.Post("", func(ctx *fiber.Ctx) error {
+		return handler.CreateTagH(ctx)
+	})
+	tagRoute.Put("", func(ctx *fiber.Ctx) error {
+		return handler.UpdateTagH(ctx)
+	})
+	tagRoute.Delete("", func(ctx *fiber.Ctx) error {
+		return handler.DeleteTagH(ctx)
+	})
+	tagRoute.Post("/categories", func(ctx *fiber.Ctx) error {
+		return handler.CreateCategoryForTag(ctx)
+	})
+	tagRoute.Delete("/categories", func(ctx *fiber.Ctx) error {
+		return handler.DeleteCategoryForTag(ctx)
+	})
+	//Category router
+	categoryRoute := app.Group(category)
+	categoryRoute.Get("", func(ctx *fiber.Ctx) error {
+		return handler.GetCategoryH(ctx)
+	})
+	categoryRoute.Post("", func(ctx *fiber.Ctx) error {
+		return handler.CreateCategoryH(ctx)
+	})
+	categoryRoute.Put("", func(ctx *fiber.Ctx) error {
+		return handler.UpdateCategoryH(ctx)
+	})
+	categoryRoute.Delete("", func(ctx *fiber.Ctx) error {
+		return handler.DeleteCategoryH(ctx)
+	})
+	categoryRoute.Post("/tags", func(ctx *fiber.Ctx) error {
+		return handler.CreateTagForCategory(ctx)
+	})
+	categoryRoute.Delete("/tags", func(ctx *fiber.Ctx) error {
+		return handler.DeleteTagForCategory(ctx)
+	})
+	scriptsGroup := app.Group(scripts)
+	scriptsGroup.Get("", func(ctx *fiber.Ctx) error {
+		return handler.GetScriptsH(ctx)
+	})
+	scriptsGroup.Put("", func(ctx *fiber.Ctx) error {
+		return handler.UpdateScriptsH(ctx)
+	})
+	scriptsGroup.Post("", func(ctx *fiber.Ctx) error {
+		return handler.CreateScriptsH(ctx)
+	})
+	scriptsGroup.Delete("", func(ctx *fiber.Ctx) error {
+		return handler.DeleteScriptsH(ctx)
+	})
+
+}
+
+func serverStart() {
+	port := config.GetEnvDefault(config.Port, config.PortDefault)
+	err = app.Listen(fmt.Sprintf(":%v", port))
+	if err != nil {
+		ctxLogger.Error(nil, "", zap.String("", err.Error()))
+		os.Exit(-1)
+	}
+}
 
 func main() {
-	fmt.Println("我是个示例")
+	serverStart()
 }