go-common/app/admin/main/aegis/service/engine.go

package service

import (
	"context"
	"encoding/json"
	"fmt"
	"reflect"
	"sort"
	"strconv"
	"strings"
	"time"

	"go-common/app/admin/main/aegis/model"
	"go-common/app/admin/main/aegis/model/business"
	"go-common/app/admin/main/aegis/model/common"
	"go-common/app/admin/main/aegis/model/net"
	"go-common/app/admin/main/aegis/model/resource"
	taskmod "go-common/app/admin/main/aegis/model/task"
	uprpc "go-common/app/service/main/up/api/v1"
	"go-common/library/ecode"
	"go-common/library/log"
	"go-common/library/sync/errgroup"
	"go-common/library/xstr"
)

// ListBizFlow .
func (s *Service) ListBizFlow(c context.Context, tp int8, bizID []int64, flowID []int64) (list []*business.BizItem, err error) {
	// 1. 获取每个类型的业务
	list = []*business.BizItem{}
	res, err := s.gorm.BusinessList(c, tp, bizID, true)
	if err != nil {
		err = ecode.AegisBusinessCfgErr
		return
	}
	if len(res) == 0 {
		return
	}
	bizMap := map[int64]*business.Business{}
	accessBiz := []int64{}
	for _, item := range res {
		bizMap[item.ID] = item
		accessBiz = append(accessBiz, item.ID)
	}

	//获取指定业务下的可分发流程节点
	var bizFlow map[int64]map[int64]string
	if bizFlow, err = s.dispatchFlow(c, accessBiz, flowID); err != nil {
		return
	}
	for bizID, item := range bizFlow {
		if bizMap[bizID] == nil {
			continue
		}

		bizItem := &business.BizItem{
			BizID:   bizID,
			BizName: bizMap[bizID].Name,
			BizType: bizMap[bizID].TP,
			Flows:   item,
		}
		list = append(list, bizItem)
	}

	sort.Sort(business.BizItemArr(list))
	return
}

// Next reveive next auditing task
func (s *Service) Next(c context.Context, opt *taskmod.NextOptions) (infos []*model.AuditInfo, err error) {
	log.Info("Next opt(%+v)", opt)
	if opt.Debug == 1 {
		info := model.GetEmptyInfo()
		infos = append(infos, info)
		return
	}
	// 1. TODO: 根据业务 动态判定dispatch_count和seize_count
	/*
		获取任务后，要根据资源状态判断释放需要审核，不用审核的直接关任务。 再次循环获取
	*/
	var (
		tasks []*taskmod.Task
	)
	for i := 0; i < 3; i++ {
		tasks, _, err = s.NextTask(c, opt)
		if err != nil {
			log.Error("NextTask err(%v)", err)
			err = ecode.AegisTaskErr
			return
		}
		if len(tasks) == 0 {
			log.Info("NextTask empty task")
			return
		}

		for _, task := range tasks {
			log.Info("Next task(%+v)", task)
			info, err := s.auditInfoByTask(c, task, &opt.BaseOptions)
			if err != nil {
				err = nil
				continue
			}
			infos = append(infos, info)
		}
		if len(infos) > 0 {
			break
		}
	}

	return
}

// InfoTask .
func (s *Service) InfoTask(c context.Context, opt *common.BaseOptions, taskid int64) (info *model.AuditInfo, err error) {
	task, err := s.Task(c, taskid)
	if err != nil || task == nil {
		err = ecode.AegisTaskErr
		return
	}

	return s.auditInfoByTask(c, task, opt)
}

// ListByTask 任务列表
func (s *Service) ListByTask(c context.Context, opt *taskmod.ListOptions) (list []*model.ListTaskItem, err error) {
	log.Info("ListByTask opt(%+v)", opt)
	var (
		tasks []*taskmod.Task
		count int64
	)

	if opt.Debug == 1 {
		list = []*model.ListTaskItem{{}}
		opt.Total = 1
	} else {
		tasks, count, err = s.ListTasks(c, opt)
		if err != nil {
			log.Error("ListTasks err(%v)", err)
			err = ecode.AegisTaskErr
			return
		}
		if len(tasks) == 0 {
			return
		}
		opt.Total = int(count)
	}

	for _, task := range tasks {
		item := &model.ListTaskItem{}

		item.Task = task
		if int(time.Since(task.Gtime.Time()).Minutes()) < 10 {
			item.GTstr = common.WaitTime(task.Gtime.Time())
		}
		item.CTstr = task.Ctime.Time().Format("2006-01-02 15:04:05")
		item.MTstr = task.Mtime.Time().Format("2006-01-02 15:04:05")
		item.WaitTime = common.WaitTime(task.Ctime.Time())
		ids, _ := xstr.SplitInts(task.Group)
		item.UserGroup = s.getUserGroup(c, ids)
		list = append(list, item)
	}

	// 补充oid,content
	s.mulIDtoName(c, list, s.gorm.ListHelperForTask, "RID", "OID", "Content", "Metas")
	// 补充user_info,user_group
	s.mulIDtoName(c, list, s.listHelpUser, "MID", "UserGroup", "UserInfo")
	// 补充uname
	s.mulIDtoName(c, list, s.transUnames, "UID", "UserName")
	// 将mid替换为昵称 或者 cuser
	for _, item := range list {
		if item.MID != 0 && item.UserInfo != nil {
			item.MidStr = item.UserInfo.Name
		} else if item.Metas != nil {
			if val, ok := item.Metas["cuser"]; ok {
				item.MidStr = fmt.Sprint(val)
			}
		}
	}
	return
}

// InfoResource .
func (s *Service) InfoResource(c context.Context, opt *common.BaseOptions) (info *model.AuditInfo, err error) {
	if opt.Debug == 1 {
		return model.GetEmptyInfo(), nil
	}
	// 根据oid查资源
	rsc, err := s.gorm.ResByOID(c, opt.BusinessID, opt.OID)
	if err != nil || rsc == nil {
		err = ecode.AegisResourceErr
		return
	}

	return s.auditInfoByRsc(c, rsc, opt.NetID)
}

// ListByResource 资源列表
func (s *Service) ListByResource(c context.Context, arg *model.SearchParams) (columns []*model.Column, list []*model.ListRscItem, op []*net.TranOperation, err error) {
	if arg.Debug == 1 {
		arg.Total = 1
		return []*model.Column{}, []*model.ListRscItem{model.EmptyListItem()}, []*net.TranOperation{{}}, nil
	}
	// 搜索返回资源信息
	var sres *model.SearchRes
	if sres, err = s.http.ResourceES(c, arg); err != nil || sres == nil {
		err = ecode.AegisSearchErr
		return
	}
	arg.Total = sres.Page.Total
	if arg.FilterOff {
		list = sres.Resources
	} else {
		list = s.listParseState(c, arg.State, sres.Resources)
	}

	// 补充粉丝数和分组
	if len(list) > 0 {
		g, _ := errgroup.WithContext(c)
		g.Go(func() error {
			s.mulIDtoName(c, list, s.listHelpUser, "MID", "UserGroup", "UserInfo")
			return nil
		})
		g.Go(func() error {
			s.listHightLight(c, arg.BusinessID, list)
			return nil
		})
		g.Go(func() error {
			s.mulIDtoName(c, list, s.listMetas, "ID", "MetaData", "Metas")
			return nil
		})
		g.Wait()
	}
	columns = s.getColumns(c, arg.BusinessID)

	// 批量操作项
	op, err = s.fetchBatchOperations(c, arg.BusinessID, 0)
	return
}

// listMetas 补充列表里面的 metadata metas
func (s *Service) listMetas(c context.Context, ids []int64) (res map[int64][]interface{}, err error) {
	res = make(map[int64][]interface{})
	var metas map[int64]string

	if metas, err = s.gorm.MetaByRID(c, ids); err != nil {
		return
	}
	for id, meta := range metas {
		mmeta := make(map[string]interface{})
		if len(meta) > 0 {
			if err = json.Unmarshal([]byte(meta), &mmeta); err != nil {
				log.Error("listMetas json.Unmarshal error(%v)", err)
				err = nil
			}
		}
		res[id] = []interface{}{meta, mmeta}
	}
	return
}

//状态筛选，防止搜索列表更新不及时
func (s *Service) listParseState(c context.Context, state int64, list []*model.ListRscItem) (hitlist []*model.ListRscItem) {
	var arrids []int64
	for _, item := range list {
		arrids = append(arrids, item.ID)
	}
	hitids, err := s.gorm.ResourceHit(c, arrids)
	if err != nil {
		return list
	}

	//搜索待审列表时,过滤掉已被领取的任务，避免提交冲突
	taskhitids, _ := s.gorm.TaskHitAuditing(c, arrids)
	for _, item := range list {
		if _, ok := taskhitids[item.ID]; ok {
			continue
		}
		if st, ok := hitids[item.ID]; ok {
			if state == -12345 || (state == st) {
				item.State = st
				hitlist = append(hitlist, item)
			}
		}
	}
	return
}

// listHelpUser 补充列表里面的 user_info user_group
func (s *Service) listHelpUser(c context.Context, mids []int64) (res map[int64][]interface{}, err error) {
	res = make(map[int64][]interface{})
	//mids去零
	for i, v := range mids {
		if v > 0 {
			continue
		}

		if i == len(mids)-1 {
			mids = mids[:i]
		} else {
			mids = append(mids[:i], mids[i+1:]...)
		}
	}
	if len(mids) == 0 {
		return
	}

	infos, err := s.rpc.UserInfos(c, mids)
	if err != nil {
		infos = make(map[int64]*model.UserInfo)
	}

	upspecials, err := s.rpc.UpsSpecial(c, mids)
	if err != nil {
		upspecials = make(map[int64]*uprpc.UpSpecial)
	}

	for _, mid := range mids {
		gids := []int64{}
		if gs, ok := upspecials[mid]; ok {
			gids = gs.GroupIDs
		}
		res[mid] = []interface{}{s.getUserGroup(c, gids), infos[mid]}
	}
	log.Info("listRscHelper res(%+v)", res)
	return
}

/*
避免超时，控制文本长度小于3000
过滤相同的文本，减少不必要请求
*/
func (s *Service) listHightLight(c context.Context, bizid int64, list []*model.ListRscItem) {

	var (
		area string
		err  error
	)

	if area = s.getConfig(c, bizid, business.TypeFiler); len(area) == 0 {
		log.Warn("sigleHightLight(%d) 没有文本高亮配置(%v)", bizid, err)
		return
	}

	arrcontent := []string{}
	for _, item := range list {
		arrcontent = append(arrcontent, item.Content)
	}
	arrset := stringset(arrcontent)
	hits, err := s.concurrentHightList(c, area, arrset)
	if err != nil {
		log.Error("listHightLight error(%v)", err)
		return
	}

	hitset := stringset(hits)
	for _, item := range list {
		item.Hit = hitset
	}
}

func (s *Service) concurrentHightList(c context.Context, area string, mapset []string) (hits []string, err error) {
	var eg errgroup.Group
	msgs := joinstr(mapset, "msg=", 3000)
	for _, msg := range msgs {
		var m = msg
		eg.Go(func() error {
			var (
				e   error
				hit []string
			)
			hit, e = s.http.FilterMulti(context.Background(), area, m)
			hits = append(hits, hit...)
			return e
		})
	}
	err = eg.Wait()
	return
}

func (s *Service) sigleHightLight(c context.Context, bizid int64, content string) (hit []string) {
	var (
		area string
		err  error
	)

	if area = s.getConfig(c, bizid, business.TypeFiler); len(area) == 0 {
		log.Warn("sigleHightLight(%d) 没有文本高亮配置(%v)", bizid, err)
		return
	}

	hits, err := s.http.FilterMulti(c, area, "msg="+content)
	if err != nil {
		log.Error("sigleHightLight error(%v)", err)
		return
	}
	return hits
}

func (s *Service) getColumns(c context.Context, bizid int64) (columns []*model.Column) {
	cfg := s.getConfig(c, bizid, business.TypeRscListAdapter)
	if len(cfg) == 0 {
		log.Warn("getColumns empty config")
		return
	}
	if err := json.Unmarshal([]byte(cfg), &columns); err != nil {
		log.Error("getColumns err(%v)", err)
	}
	return
}

//Submit .
func (s *Service) Submit(c context.Context, opt *model.SubmitOptions) (err error) {
	log.Info("Pre submit(%+v)", opt)

	// 1. 获取flow流转结果
	result, err := s.computeTriggerResult(c, opt.RID, opt.FlowID, opt.Binds)
	if err != nil {
		return err
	}

	esupsert, err := s.submit(c, "submit", opt, result)
	if err != nil {
		return err
	}

	//更新es
	s.http.UpsertES(c, []*model.UpsertItem{esupsert})
	return
}

func (s *Service) submit(c context.Context, action string, opt *model.SubmitOptions, result *net.TriggerResult) (esupsert *model.UpsertItem, err error) {
	ormTx, err := s.gorm.BeginTx(c)
	if err != nil {
		log.Error("tx error(%v)", err)
		return nil, ecode.ServerErr
	}

	var (
		rsc                *resource.Resource
		mid, ouid, otaskid int64
		ostate             int8
		taskstate          int8
	)

	if rsc, err = s.gorm.ResourceByOID(c, opt.OID, opt.BusinessID); err != nil || rsc == nil {
		ormTx.Rollback()
		err = ecode.AegisResourceErr
		return
	}

	if rsc.ID != opt.RID {
		ormTx.Rollback()
		err = ecode.AegisResourceErr
		return
	}
	mid = rsc.MID

	// 2. 更新resource 和 resource_result
	if err = s.TxUpdateResource(ormTx, opt.RID, result.ResultToken.Values, opt.Result); err != nil {
		log.Error("submit TxUpdateResource(%v)", err)
		ormTx.Rollback()
		err = ecode.AegisResourceErr
		return
	}
	log.Info("submit TxUpdateResource success")

	// 3. 更新task
	if result.ResultToken.HitAudit && opt.TaskID > 0 {
		taskstate = taskmod.TaskStateSubmit
		if action == "batch" { // 目前的接口我们区分不了 资源提交还是任务提交
			taskstate = taskmod.TaskStateRscSb
		}

		// TODO 看来还是要把资源提交和任务提交分开。 资源提交不能确定要关的是哪个任务
		if ostate, otaskid, ouid, err = s.TxSubmitTask(c, ormTx, &opt.BaseOptions, taskstate); err != nil {
			log.Error("submit TxSubmitTask(%v)", err)
			ormTx.Rollback()
			err = ecode.AegisTaskErr
			return
		}
		log.Info("submit TxSubmitTask success")
		if otaskid != opt.TaskID {
			log.Warn("submit different taskid(%d-->%d)", opt.TaskID, otaskid)
			opt.TaskID = otaskid
		}
	}

	if result.ResultToken.HitAudit {
		// 4. 更新flow
		if err = s.reachNewFlowDB(c, ormTx, result); err != nil {
			log.Error("submit reachNewFlowDB(%v)", err)
			ormTx.Rollback()
			return
		}
		log.Info("submit reachNewFlowDB success")

		opt.Result.State, _ = strconv.Atoi(fmt.Sprint(result.ResultToken.Values["state"]))
	}

	// 5. 更新业务
	if err = s.syncResource(c, opt, mid, result.ResultToken); err != nil {
		log.Error("submit syncResource(%v)", err)
		ormTx.Rollback()
		return
	}
	log.Info("submit syncResource success")

	if err = ormTx.Commit().Error; err != nil {
		ormTx.Rollback()
		return
	}

	// 6. 任务缓存更新
	if result.ResultToken.HitAudit && opt.TaskID > 0 {
		s.submitTaskCache(c, &opt.BaseOptions, ostate, otaskid, ouid)
	}

	// 7. 任务流转
	if err = s.afterReachNewFlow(c, result, opt.BusinessID); err != nil {
		log.Error("submit afterReachNewFlow(%v)", err)
		return
	}
	log.Info("submit afterReachNewFlow success")

	// 8. 查询下最终数据库的结果,记录
	res, err := s.gorm.ResourceRes(c, opt.RID)
	if err != nil || res == nil {
		return
	}

	//8. 记录日志
	if opt.Result != nil {
		opt.Result.State = int(res.State)
	}
	s.logSubmit(c, action, opt, result)

	//9.更新es
	esupsert = &model.UpsertItem{
		ID:     res.ID,
		State:  int(res.State),
		Extra1: res.Extra1,
		Extra2: res.Extra2,
		Extra3: res.Extra3,
		Extra4: res.Extra4,
	}
	return
}

func (s *Service) logSubmit(c context.Context, action string, opt *model.SubmitOptions, res interface{}) {
	s.async.Do(c, func(ctx context.Context) {
		// 1. 操作日志
		s.sendAuditLog(ctx, action, opt, res, model.LogTypeAuditSubmit)
		// 2. resource日志
		s.sendRscSubmitLog(ctx, action, opt, res)
	})
}

// JumpFlow 跳流程提交
func (s *Service) JumpFlow(c context.Context, opt *model.SubmitOptions) (err error) {
	var (
		ostate        int8
		ouid, otaskid int64
		esupsert      *model.UpsertItem
	)

	ormTx, err := s.gorm.BeginTx(c)
	if err != nil {
		log.Error("tx error(%v)", err)
		return ecode.ServerErr
	}

	// 1. 提交结果到flow
	result, err := s.jumpFlow(c, ormTx, opt.RID, opt.FlowID, opt.NewFlowID, opt.Binds)
	if err != nil {
		ormTx.Rollback()
		return
	}

	// 2. 更新task
	if result.ResultToken.HitAudit && opt.TaskID > 0 { //资源列表直接提交可能没有任务信息
		if ostate, otaskid, ouid, err = s.TxSubmitTask(c, ormTx, &opt.BaseOptions, taskmod.TaskStateClosed); err != nil {
			ormTx.Rollback()
			err = ecode.AegisTaskErr
			return
		}
		if otaskid != opt.TaskID {
			log.Warn("submit different taskid(%d-->%d)", opt.TaskID, otaskid)
			opt.TaskID = otaskid
		}
	}

	if result.SubmitToken != nil {
		var (
			rsc *resource.Resource
			mid int64
		)
		if rsc, err = s.gorm.ResourceByOID(c, opt.OID, opt.BusinessID); err != nil || rsc == nil {
			ormTx.Rollback()
			err = ecode.AegisResourceErr
			return
		}

		if rsc.ID != opt.RID {
			ormTx.Rollback()
			err = ecode.AegisResourceErr
			return
		}
		mid = rsc.MID

		// 3. 更新resource 和 resource_result
		if err = s.TxUpdateResource(ormTx, opt.RID, result.ResultToken.Values, opt.Result); err != nil {
			ormTx.Rollback()
			err = ecode.AegisResourceErr
			return
		}

		// 4. 更新业务
		if err = s.syncResource(c, opt, mid, result.ResultToken); err != nil {
			ormTx.Rollback()
			err = ecode.AegisBusinessSyncErr
			return
		}

	}

	if err = ormTx.Commit().Error; err != nil {
		return
	}

	// 5. 任务缓存更新
	if result.ResultToken.HitAudit && opt.TaskID > 0 {
		s.submitTaskCache(c, &opt.BaseOptions, ostate, otaskid, ouid)
	}

	// 6. 任务流转
	if result.ResultToken.HitAudit {
		s.afterJumpFlow(c, result, opt.BusinessID)
	}

	rscr, err := s.gorm.ResourceRes(c, opt.RID)
	if err != nil || rscr != nil {
		return
	}
	//7. 记录日志
	if opt.Result != nil {
		opt.Result.State = int(rscr.State)
	}
	s.logSubmit(c, "jump", opt, result)

	//8.更新es
	esupsert = &model.UpsertItem{
		ID:     rscr.ID,
		State:  int(rscr.State),
		Extra1: rscr.Extra1,
		Extra2: rscr.Extra2,
		Extra3: rscr.Extra3,
		Extra4: rscr.Extra4,
	}
	s.http.UpsertES(c, []*model.UpsertItem{esupsert})

	return
}

// BatchSubmit 批量提交, 超过10个的做异步
func (s *Service) BatchSubmit(c context.Context, opt *model.BatchOption) (tip *model.Tip, err error) {
	tip = &model.Tip{Fail: make(map[int64]string)}

	if len(opt.RIDs) > 10 {
		go s.processBatch(context.Background(), opt.RIDs[10:], opt, nil)
		rids := opt.RIDs[:10]
		s.processBatch(c, rids, opt, tip)
		tip.Async = append(tip.Async, opt.RIDs[10:]...)
	} else {
		s.processBatch(c, opt.RIDs, opt, tip)
	}

	return
}

func (s *Service) processBatch(c context.Context, rids []int64, opt *model.BatchOption, tip *model.Tip) {
	var (
		err       error
		esupdate  *model.UpsertItem
		esupdates = []*model.UpsertItem{}
	)
	for _, rid := range rids {
		var (
			taskid int64
			oid    string
		)
		if oid, err = s.gorm.OidByRID(c, rid); err != nil {
			if tip != nil {
				tip.Fail[rid] = err.Error()
			}
			continue
		}

		res, err := s.computeBatchTriggerResult(c, opt.BusinessID, rid, opt.Binds)
		if err != nil {
			if tip != nil {
				tip.Fail[rid] = ecode.Cause(err).Message()
			}
			continue
		}
		if task, _ := s.gorm.TaskByRID(c, rid, 0); task != nil {
			taskid = task.ID
		}

		smtOpt := &model.SubmitOptions{
			EngineOption: model.EngineOption{
				BaseOptions: common.BaseOptions{
					BusinessID: opt.BusinessID,
					OID:        oid,
					UID:        opt.UID,
					RID:        rid,
					Uname:      opt.Uname,
				},
				Result: &resource.Result{
					Attribute:    -1, // -1表示不更新
					ReasonID:     opt.ReasonID,
					RejectReason: opt.RejectReason,
				},
				TaskID: taskid,
				ExtraData: map[string]interface{}{
					"notify": opt.Notify,
				},
			},
			Binds: opt.Binds,
		}
		if esupdate, err = s.submit(c, "batch", smtOpt, res); err != nil {
			if tip != nil {
				tip.Fail[rid] = ecode.Cause(err).Message()
			}
		} else {
			if tip != nil {
				tip.Success = append(tip.Success, rid)
			}
			esupdates = append(esupdates, esupdate)
		}
	}

	//更新es
	s.http.UpsertES(c, esupdates)
}

// Add 业务方添加资源
func (s *Service) Add(c context.Context, opt *model.AddOption) (err error) {
	var res *net.TriggerResult
	defer func() {
		// 5. 记录资源添加日志
		s.sendRscLog(c, "add", opt, res, nil, err)
	}()

	business.AdaptAddOpt(opt, s.getAdapter(c, opt.BusinessID))
	if b, _ := s.gorm.Business(c, opt.BusinessID); b == nil || b.State != 0 {
		err = ecode.AegisBusinessSyncErr
		return
	}

	var rid int64
	ormTx, err := s.gorm.BeginTx(c)
	if err != nil {
		log.Error("tx error(%v)", err)
		return ecode.ServerErr
	}

	// 2. 根据net_id,计算是否可添加
	res, err = s.startNet(c, opt.BusinessID, opt.NetID)
	if err != nil {
		ormTx.Rollback()
		return
	}

	// 3. 事务新增资源
	rsc := &resource.Result{State: opt.State}
	if res.ResultToken != nil {
		if state, ok := res.ResultToken.Values["state"]; ok {
			rsc.State, _ = strconv.Atoi(fmt.Sprint(state))
		}
	}

	rid, err = s.TxAddResource(ormTx, &opt.Resource, rsc)
	if err != nil {
		ormTx.Rollback()
		err = ecode.AegisResourceErr
		return
	}
	res.RID = rid

	// 4. 事务新增flow,根据创建rid
	if err = s.reachNewFlowDB(c, ormTx, res); err != nil {
		ormTx.Rollback()
		return
	}

	if err = ormTx.Commit().Error; err != nil {
		log.Error("Commit opt(%+v) error(%v)", opt, err)
		return
	}

	go func() {
		s.afterReachNewFlow(context.TODO(), res, opt.BusinessID)

		// 1. 操作日志
		s.sendAuditLog(context.TODO(), "add", &model.SubmitOptions{
			EngineOption: model.EngineOption{
				BaseOptions: common.BaseOptions{
					BusinessID: opt.BusinessID,
					FlowID:     res.NewFlowID,
					RID:        rid,
					UID:        399,
					Uname:      "业务方",
				},
				Result: rsc,
			},
		}, res, model.LogTypeAuditAdd)
	}()
	return
}

// Update 业务方修改资源参数
func (s *Service) Update(c context.Context, opt *model.UpdateOption) (err error) {
	var rows int64
	business.AdaptUpdateOpt(opt, s.getAdapter(c, opt.BusinessID))
	for key, val := range opt.Update {
		if _, ok := model.UpdateKeys[key]; !ok {
			delete(opt.Update, key)
			continue
		}
		switch key {
		case "extra1", "extra2", "extra3", "extra4", "extra5", "extra6":
			if reflect.TypeOf(val).Kind() != reflect.Float64 && reflect.TypeOf(val).Kind() != reflect.Int {
				return ecode.RequestErr
			}
		case "extra1s", "extra2s", "extra3s", "extra4s":
			if reflect.TypeOf(val).Kind() != reflect.String {
				return ecode.RequestErr
			}
		case "extratime1", "octime", "ptime": //时间类型不校验了
		case "metadata": //如果是map，json转化为字符串
			if reflect.TypeOf(val).Kind() == reflect.Map {
				var bs []byte
				if bs, err = json.Marshal(val); err != nil {
					return ecode.RequestErr
				}
				opt.Update["metadata"] = string(bs)
			}
		}
	}
	if len(opt.Update) == 0 {
		err = ecode.RequestErr
	} else {
		rows, err = s.gorm.UpdateResource(c, opt.BusinessID, opt.OID, opt.Update)
	}
	if rows > 0 || err != nil {
		s.sendRscLog(c, "update", &model.AddOption{
			Resource: resource.Resource{
				BusinessID: opt.BusinessID,
				OID:        opt.OID,
			}, NetID: opt.NetID,
		}, nil, opt.Update, err)
	}
	return
}

//CancelByOper 手动删除任务
func (s *Service) CancelByOper(c context.Context, businessID int64, oids []string, uid int64, username string) (err error) {
	if err = s.Cancel(c, businessID, oids, uid, username); err != nil {
		return
	}

	//upsert es
	go func(businessID int64, oids []string) {
		var (
			esupserts []*model.UpsertItem
			ctx       = context.TODO()
		)
		if esupserts, err = s.gorm.UpsertByOIDs(ctx, businessID, oids); err != nil || len(esupserts) == 0 {
			return
		}
		s.http.UpsertES(ctx, esupserts)
	}(businessID, oids)
	return
}

// Cancel 取消相关资源的所有流程
func (s *Service) Cancel(c context.Context, businessID int64, oids []string, uid int64, username string) (err error) {
	var (
		dstate  int
		ridFlow map[int64]string
	)
	defer func() {
		// 5. 记录资源注销日志
		s.sendRscCancleLog(c, businessID, oids, uid, username, err)
	}()

	ridstr, err := s.gorm.RidsByOids(c, businessID, oids)
	if err != nil {
		err = nil
		return
	}
	rids, err := xstr.SplitInts(ridstr)
	if err != nil || len(rids) == 0 {
		err = nil
		return
	}

	ormTx, err := s.gorm.BeginTx(c)
	if err != nil {
		log.Error("tx error(%v)", err)
		return ecode.ServerErr
	}
	defer ormTx.Commit()

	// 1. 资源修改为已删除状态
	if dstate, err = s.TxDelResource(c, ormTx, businessID, rids); err != nil {
		ormTx.Rollback()
		err = ecode.AegisResourceErr
		return
	}

	// 2. 取消相关flow流程
	if ridFlow, err = s.cancelNet(c, ormTx, rids); err != nil {
		ormTx.Rollback()
		return
	}

	// 3. 取消相关task
	if err = s.gorm.TxCloseTasks(ormTx, rids, uid); err != nil {
		ormTx.Rollback()
		err = ecode.AegisTaskErr
		return
	}

	// 操作日志
	for _, rid := range rids {
		s.sendAuditLog(c, "cancel", &model.SubmitOptions{
			EngineOption: model.EngineOption{
				BaseOptions: common.BaseOptions{
					BusinessID: businessID,
					RID:        rid,
					UID:        uid,
					Uname:      username,
				},
				Result: &resource.Result{
					State: dstate,
				},
			},
		}, &net.TriggerResult{
			OldFlowID: ridFlow[rid],
		}, model.LogTypeAuditCancel)
	}
	return
}

func (s *Service) closeTask(c context.Context, task *taskmod.Task) (err error) {
	if err = s.gorm.CloseTask(c, task.ID); err != nil {
		return
	}
	if task.UID > 0 {
		s.submitTaskCache(c, &common.BaseOptions{
			BusinessID: task.BusinessID,
			FlowID:     task.FlowID,
		}, task.State, task.ID, task.UID)
	}
	return
}

// Upload to bfs
func (s *Service) Upload(c context.Context, fileName string, fileType string, timing int64, body []byte) (location string, err error) {
	if len(body) == 0 {
		err = ecode.FileNotExists
		return
	}
	if location, err = s.http.Upload(c, fileName, fileType, timing, body); err != nil {
		log.Error("s.upload.Upload() error(%v)", err)
	}
	return
}

func (s *Service) auditInfoByTask(c context.Context, task *taskmod.Task, opt *common.BaseOptions) (info *model.AuditInfo, err error) {
	var (
		userinfo          *model.UserInfo
		operhistorys, hit []string
		iframeurl         string
		actions           []*model.Action
	)
	// 1. 未完成的任务信息
	undoStat, _ := s.UnDoStat(c, opt)

	// 2. 获取业务信息 resource
	resource, err := s.ResourceRes(c, &resource.Args{RID: task.RID})
	if err != nil || resource == nil || !s.checkaudit(task.FlowID, resource.State) {
		log.Error("资源查找失败,删除任务 ResourceRes err(%v)", err)
		s.closeTask(c, task)
		err = ecode.AegisResourceErr
		return
	}

	// 3. 获取操作项 flow
	flow, err := s.fetchTaskTranInfo(c, task.RID, task.FlowID, opt.NetID)
	if err != nil {
		log.Error("fetchTransitionInfo(%d,%d) err(%v)", task.RID, task.FlowID, err)
		return
	}

	g, _ := errgroup.WithContext(c)

	// 4. 获取用户信息 account
	g.Go(func() error {
		userinfo, err = s.rpc.Profile(c, task.MID)
		if err != nil {
			log.Error("Profile(%d) err(%v)", task.MID, err)
		}
		return nil
	})

	// 5. 审核历史
	g.Go(func() error {
		operhistorys, err = s.auditLogByRID(c, task.RID)
		if err != nil {
			log.Error("AuditLog err(%v)", err)
		}
		return nil
	})

	// 6. iframe url
	g.Go(func() error {
		iframeurl = s.getConfig(c, task.BusinessID, business.TypeIframe)
		actions = s.getActions(c, task.BusinessID)

		var attrcfg map[string]uint
		if attrcfg, err = s.AttributeCFG(c, task.BusinessID); len(attrcfg) > 0 {
			resource.AttrParse(attrcfg)
		}
		resource.MetaParse()
		return nil
	})

	// 7. filter
	g.Go(func() error {
		hit = s.sigleHightLight(c, task.BusinessID, resource.Content)
		return nil
	})
	g.Wait()

	info = &model.AuditInfo{
		UnDoStat:     undoStat,
		Task:         task,
		Resource:     resource,
		UserInfo:     userinfo,
		Flow:         flow,
		OperHistorys: operhistorys,
		IFrame:       iframeurl,
		Actions:      actions,
		Hit:          hit,
	}
	if task.MID > 0 {
		s.getUserGroup(c, []int64{task.MID})
	}

	return
}

func (s *Service) auditInfoByRsc(c context.Context, rsc *resource.Res, netid int64) (info *model.AuditInfo, err error) {
	var (
		task              *taskmod.Task
		userinfo          *model.UserInfo
		flow              *net.TransitionInfo
		iframeurl         string
		attrcfg           map[string]uint
		operhistorys, hit []string
		actions           []*model.Action
	)

	g, _ := errgroup.WithContext(c)

	// 搜索未指定flow, 则检索task
	g.Go(func() error {
		task, err = s.gorm.TaskByRID(c, rsc.ID, 0)
		if err != nil {
			err = nil
			task = nil
		}
		return nil
	})

	// 1. 获取用户信息 account
	g.Go(func() error {
		if userinfo, err = s.rpc.Profile(c, rsc.MID); err != nil {
			log.Error("Profile(%d) err(%v)", rsc.MID, err)
		}
		return nil
	})

	// 2. 获取操作项 flow
	g.Go(func() error {
		flow, err = s.fetchResourceTranInfo(c, rsc.ID, rsc.BusinessID, netid)
		if err != nil {
			log.Error("fetchTransitionInfo(%d,%d,%d) err(%v)", rsc.ID, rsc.BusinessID, netid, err)
		}
		return nil
	})

	// 3. 审核历史
	g.Go(func() error {
		operhistorys, err = s.auditLogByRID(c, rsc.ID)
		if err != nil {
			log.Error("AuditLog(%d) err(%v)", rsc.ID, err)
		}
		return nil
	})

	// 4. iframe url
	g.Go(func() error {
		iframeurl = s.getConfig(c, rsc.BusinessID, business.TypeIframe)
		actions = s.getActions(c, rsc.BusinessID)

		if attrcfg, err = s.AttributeCFG(c, rsc.BusinessID); len(attrcfg) > 0 {
			rsc.AttrParse(attrcfg)
		}
		rsc.MetaParse()
		return nil
	})

	// 5. filter
	g.Go(func() error {
		hit = s.sigleHightLight(c, rsc.BusinessID, rsc.Content)
		return nil
	})
	g.Wait()

	info = &model.AuditInfo{
		Task:         task,
		Resource:     rsc,
		UserInfo:     userinfo,
		Flow:         flow,
		OperHistorys: operhistorys,
		IFrame:       iframeurl,
		Actions:      actions,
		Hit:          hit,
	}

	if rsc.MID > 0 {
		if upspecial, _ := s.rpc.UpSpecial(c, rsc.MID); upspecial != nil {
			info.UserGroup = s.getUserGroup(c, upspecial.GroupIDs)
		}
	}
	return
}

func (s *Service) getActions(c context.Context, bizid int64) (actions []*model.Action) {
	cfg := s.getConfig(c, bizid, business.TypeAction)
	if len(cfg) == 0 {
		log.Error("getActions(%d) empty", bizid)
		return
	}
	if err := json.Unmarshal([]byte(cfg), &actions); err != nil {
		log.Error("getActions(%d) error(%v)", bizid, err)
	}
	return
}

func (s *Service) getAdapter(c context.Context, bizid int64) (adps []*business.Adapter) {
	cfg := s.getConfig(c, bizid, business.TypeAdapter)
	if len(cfg) == 0 {
		return
	}

	if err := json.Unmarshal([]byte(cfg), &adps); err != nil {
		log.Error("getAdapter cfg(%s) err(%v)", cfg, err)
	}
	return
}

// Gray 灰度
func (s *Service) Gray(opt *model.AddOption) (next bool) {
	if opt == nil {
		return
	}
	//未配置，则默认全量
	if len(s.gray[opt.BusinessID]) == 0 {
		next = true
		return
	}

	optval := reflect.ValueOf(opt).Elem()
	opttp := optval.Type()
	for _, opts := range s.gray[opt.BusinessID] {
		//策略与策略之间or, 策略的fields之间and
		okcnt := 0

		for _, item := range opts {
			f, exist := opttp.FieldByName(item.Name)
			if !exist {
				break
			}

			v := optval.FieldByIndex(f.Index)
			if strings.Contains(item.Value, fmt.Sprintf(",%v,", v.Interface())) {
				okcnt++
				continue
			}
		}
		if okcnt > 0 && okcnt == len(opts) {
			next = true
			return
		}
	}

	return
}

//checkaudit 检查任务对应的资源是否需要审核，不需要的不下发
func (s *Service) checkaudit(flowid int64, state int64) bool {
	if len(s.c.Auditstate) > 0 {
		if states, ok := s.c.Auditstate[fmt.Sprint(flowid)]; ok {
			if !strings.Contains(","+states+",", fmt.Sprint(state)) {
				return false
			}
		}
	}
	return true
}

//Auth 用户权限查询
func (s *Service) Auth(c context.Context, uid int64) (a *model.Auth, err error) {
	var (
		roles []*taskmod.Role
	)
	a = &model.Auth{}
	if s.Debug() == "local" {
		a.OK = true
		return
	}
	if s.IsAdmin(uid) {
		a.OK = true
		a.Admin = true
		return
	}

	//查看业务级别&任务级别的绑定权限
	bidBiz := map[int64]int64{}
	//任务级别权限
	for biz, bidFlows := range s.taskRoleCache {
		for bid := range bidFlows {
			bidBiz[bid] = biz
		}
	}
	//业务级别权限
	for biz, cfgs := range s.bizRoleCache {
		if bid, exist := cfgs[business.BizBIDMngID]; exist && bid > 0 {
			bidBiz[bid] = biz
		}
	}
	log.Info("Auth bidbiz(%+v) \r\n   taskrole(%+v) \r\n bizrole(%+v)", bidBiz, s.taskRoleCache, s.bizRoleCache)

	//用户角色
	if roles, err = s.http.GetUserRoles(c, uid); err != nil {
		log.Error("Auth s.http.GetUserRoles(%d) error(%v)", uid, err)
		return
	}

	a.Business = map[int64]int64{}
	for _, item := range roles {
		if bidBiz[item.BID] > 0 {
			a.Business[item.BID] = bidBiz[item.BID]
		}
	}
	a.OK = len(a.Business) > 0
	return
}