package shiyan

import (
	"encoding/json"
	"encoding/xml"
	"fmt"
	"os"
	"strconv"
	"time"

	"github.com/flipped-aurora/gin-vue-admin/server/commonus"
	"github.com/flipped-aurora/gin-vue-admin/server/global"
	"github.com/flipped-aurora/gin-vue-admin/server/model/approvalprocess"
	"github.com/flipped-aurora/gin-vue-admin/server/model/common/response"
	"github.com/flipped-aurora/gin-vue-admin/server/model/testpage"
	"github.com/flipped-aurora/gin-vue-admin/server/model/wechat"
	"github.com/flipped-aurora/gin-vue-admin/server/utils/redishandel"
	"github.com/gin-gonic/gin"
	"github.com/mitchellh/mapstructure"
)

type ShiyanApi struct {
}

func (a *ShiyanApi) AddBaseMenu(c *gin.Context) {
	var answerMap testpage.Answer
	err := global.GVA_DB_Master.First(&answerMap)
	if err != nil {

	}
	fmt.Printf("%v\n", answerMap)
	response.Ok(c)
}

//get请求获参
func (a *ShiyanApi) GetRequestOperation(c *gin.Context) {
	id := c.Query("id")
	fmt.Printf("====>%v\n", id)
	response.Ok(c)
}

//get请求获参
type postGroupCanshu struct {
	Id int `json:"id" from:"id"`
}

func (a *ShiyanApi) PostRequestOperation(c *gin.Context) {
	var ids postGroupCanshu
	_ = c.ShouldBindJSON(&ids)
	// name := c.Query("id")
	fmt.Printf("====>%v\n", ids.Id)
	response.Ok(c)
}

//实验递归
func (s *ShiyanApi) DiGui(c *gin.Context) {
	var group []wechat.GroupForm
	listErr := global.GVA_DB_WatchDate.Find(&group).Error
	if listErr == nil {
	}
	var ids wechat.GroupForm
	_ = c.ShouldBindJSON(&ids)
	var setid int64
	setid = 51
	if ids.Id != 0 {
		setid = ids.Id
	}
	// var parentId []int64
	// var dd Ddigui
	// dd.faherDigui(81, group, parentId)
	// dd.Date = commonus.BubbleSort(dd.Date)
	var dd commonus.ErgodicStruct
	dd.ParentId = 1
	dd.ErgodicParentClassGroup(setid, group)
	dd.Date = append(dd.Date, setid)
	dd.Date = commonus.BubbleSort(dd.Date)
	setidIntString := strconv.FormatInt(setid, 10)
	setidInt, _ := strconv.Atoi(setidIntString)
	depart, isTrue := commonus.GetDepartment(setidInt)
	dateary := commonus.MapOut()
	dateary["data"] = depart
	dateary["istrue"] = isTrue
	dateary["digui"] = dd.Date
	response.Result(0, dateary, "查询失败", c)
}

type Ddigui struct {
	Date []int64
}

//递归递归函数
func (d *Ddigui) faherDigui(id int64, groupStruct []wechat.GroupForm, parentId []int64) []int64 {
	var parentIds []int64
	// parentId = append(parentId, id)
	for _, v := range groupStruct {
		if v.Id == id {
			d.Date = append(d.Date, v.Parentid)

			d.faherDigui(v.Parentid, groupStruct, parentId)
			// parentId = append(parentId, v.Parentid)
			// fmt.Printf("%v==========>%v*******%v\n", id, v.Parentid, parentId)
			// parentIds = parentId
			// parentIds = faherDigui(v.Parentid, groupStruct, parentIds)

			// parentId = append(parentId, v.Parentid)

			// fmt.Printf("%v==========>%v*******%v\n", id, v.Parentid, parentId)

		}
	}
	// parentId = parentIds
	// fmt.Printf("%v==========>*******\n", parentIds)
	return parentIds
}

//实验结果保存到数组
func (s *ShiyanApi) GormToMap(c *gin.Context) {
	// returnData := commonus.MapOut()
	// var returnData []map[string]interface{}
	// tableName := "groupform"
	// global.GVA_DB_WatchDate.Table(tableName).Find(&returnData)
	var pGorm commonus.GormTopMap
	pGorm.Db = global.GVA_DB_WatchDate
	pGorm.TableName = "groupform"
	returnData := commonus.MapOut()
	returnData["ary"] = pGorm.PublicOrmToMap()
	returnData["one"] = pGorm.PublicOrmToMapOne()
	response.Result(0, returnData, "查询成功", c)
}

type PersonInfo struct {
	DefinitIons interface{} `json:"definitions"`
}

//读取json文件解析
func (s *ShiyanApi) ReadJsonFiles(c *gin.Context) {

	filePtr, err := os.Open("conf/forkflow.json")
	defer filePtr.Close()
	if err != nil {
		dfg := fmt.Sprintf("Open file failed [Err:%s]", err.Error())
		// fmt.Println("Open file failed [Err:%s]", err.Error())
		response.Result(0, dfg, "查询成功", c)
		return
	}
	decoder := json.NewDecoder(filePtr)

	var person []PersonInfo

	err = decoder.Decode(&person)
	if err != nil {
		fmt.Println("Decoder failed", err.Error())

	}

	fmt.Println("Open file failed [Err:%s]", person)
	returnData := commonus.MapOut()
	returnData["json"] = person
	response.Result(0, returnData, "查询成功", c)
}

//XML转换处理

/*
*XML结构体
 */
type Definitions struct {
	XMLName         xml.Name          `xml:"definitions" json:"definitions"`
	Text            string            `xml:",chardata" json:"chardata"`
	Bpmn2           string            `xml:"bpmn2,attr" json:"bpmn2"`
	Xsi             string            `xml:"xsi,attr" json:"xsi"`
	Bpmndi          string            `xml:"bpmndi,attr" json:"bpmndi"`
	Dc              string            `xml:"dc,attr" json:"dc"`
	Flowable        string            `xml:"flowable,attr" json:"flowable"`
	Di              string            `xml:"di,attr" json:"di"`
	ID              string            `xml:"id,attr" json:"id"`
	TargetNamespace string            `xml:"targetNamespace,attr" json:"targetNamespace"`
	SchemaLocation  string            `xml:"schemaLocation,attr" json:"schemaLocation"`
	Process         ProcessStruct     `xml:"process" json:"process"`         //工作流过程
	BPMNDiagram     BPMNDiagramStruct `xml:"BPMNDiagram" json:"BPMNDiagram"` //BPMN图结构
}

//工作流过程
type ProcessStruct struct {
	TextAndIdStruct
	NameStruct
	Documentation Documentationstruct  `xml:"documentation" json:"documentation"` //结构描述
	StartEvent    StartEventStruct     `xml:"startEvent" json:"startEvent"`       //开始事件
	UserTask      []UserTaskStruct     `xml:"userTask" json:"userTask"`           //流程主体（用户任务）
	EndEvent      EndEventStruct       `xml:"endEvent" json:"endEvent"`           //结束事件
	SequenceFlow  []SequenceFlowStruct `xml:"sequenceFlow" json:"sequenceFlow"`   //序列流
}

//text结构体
type TextStruct struct {
	Text string `xml:",chardata" json:",text"`
}

//name结构体
type NameStruct struct {
	Name string `xml:"name,attr" json:"name"`
}

//Text与ID 结构
type TextAndIdStruct struct {
	TextStruct
	ID string `xml:"id,attr" json:"id"`
}

type Documentationstruct struct {
	TextStruct
}

//工作流开始事件
type StartEventStruct struct {
	TextAndIdStruct
	NameStruct
	Outgoing []OutgoingStruct `xml:"outgoing" json:"outgoing"` //流程出口
}

//流程出口结构
type OutgoingStruct struct {
	TextStruct
}

//流程主体（用户任务）
type UserTaskStruct struct {
	TextAndIdStruct
	NameStruct
	Assignee        string           `xml:"assignee,attr" json:"assignee"`               //处理人
	CandidateGroups string           `xml:"candidateGroups,attr" json:"candidateGroups"` //处理角色
	CandidateUsers  string           `xml:"candidateUsers,attr" json:"candidateUsers"`   //处理人
	Incoming        []IncomingStruct `xml:"incoming" json:"incoming"`                    //来源
	Outgoing        []OutgoingStruct `xml:"outgoing" json:"outgoing"`                    //流程去向（下一个节点）
}

//本节点来源
type IncomingStruct struct {
	TextStruct
}

//结束事件
type EndEventStruct struct {
	TextAndIdStruct
	NameStruct
	Incoming []IncomingStruct `xml:"incoming" json:"incoming"` //来源
}

//序列流
type SequenceFlowStruct struct {
	TextAndIdStruct
	NameStruct
	SourceRef           string                    `xml:"sourceRef,attr" json:"sourceRef"`                //源
	TargetRef           string                    `xml:"targetRef,attr" json:"targetRef"`                //流向
	ConditionExpression ConditionExpressionStruct `xml:"conditionExpression" json:"conditionExpression"` //条件表达式
}

//条件表达式
type ConditionExpressionStruct struct {
	TextStruct
	Type string `xml:"type,attr" json:"type"`
}

//BPMN图结构
type BPMNDiagramStruct struct {
	TextAndIdStruct
	BPMNPlane BPMNPlaneStruct `xml:"BPMNPlane" json:"BPMNPlane"`
}

//图平面坐标参数
type BPMNPlaneStruct struct {
	TextAndIdStruct
	BpmnElement string            `xml:"bpmnElement,attr" json:"bpmnElement"` //Bpmn元素
	BPMNShape   []BPMNShapeStruct `xml:"BPMNShape" json:"BPMNShape"`          //Bpmn 坐标参数
	BPMNEdge    []BPMNEdgeStruct  `xml:"BPMNEdge" json:"BPMNEdge"`            //Bpmn界限
}

//Bpmn 坐标参数
type BPMNShapeStruct struct {
	TextAndIdStruct
	BpmnElement string          `xml:"bpmnElement,attr" json:"bpmnElement"`
	Bounds      BoundsStruct    `xml:"Bounds" json:"Bounds"`       //图形元素坐标
	BPMNLabel   BPMNLabelStruct `xml:"BPMNLabel" json:"BPMNLabel"` //BPMN标签
}

//图形元素坐标
type BoundsStruct struct {
	TextStruct
	X      string `xml:"x,attr" json:"x"`
	Y      string `xml:"y,attr" json:"y"`
	Width  string `xml:"width,attr" json:"width"`
	Height string `xml:"height,attr" json:"height"`
}

//BPMN标签
type BPMNLabelStruct struct {
	TextStruct
	Bounds BoundsStruct `xml:"Bounds" json:"Bounds"` //图形元素坐标
}

//Bpmn界限
type BPMNEdgeStruct struct {
	TextAndIdStruct
	BpmnElement string           `xml:"bpmnElement,attr" json:"bpmnElement"`
	Waypoint    []WaypointStruct `xml:"waypoint" json:"waypoint"` //线路径坐标
}

//线路径坐标
type WaypointStruct struct {
	TextStruct
	X string `xml:"x,attr" json:"x"`
	Y string `xml:"y,attr" json:"y"`
}

//接收参数
type XmlCanShu struct {
	ProcessKey   string `json:"processKey"`
	ProcessName  string `json:"processName"`
	ResourceName string `json:"resourceName"`
	Xml          string `json:"xml"`
	Svg          string `json:"svg"`
	JsonStr      string `json:"jsonstr"`
}

//工作流XML解析
func (s *ShiyanApi) XmlToJson(c *gin.Context) {
	var xmlToStruct Definitions
	var reportAnswer XmlCanShu
	err := c.ShouldBindJSON(&reportAnswer)
	// if err != nil {
	// 	response.Result(101, err, "参数错误！", c)
	// 	return
	// }
	if reportAnswer.Xml == "" {
		response.Result(102, err, "参数错误！", c)
		return
	}
	errs := xml.Unmarshal([]byte(reportAnswer.Xml), &xmlToStruct)
	if nil != errs {
		fmt.Println("Unmarshal fail")
	} else {
		fmt.Println("struct", xmlToStruct)
	}
	returnData := commonus.MapOut()
	returnData["reportAnswer"] = reportAnswer
	returnData["xmlToStruct"] = xmlToStruct

	var approvalProcess approvalprocess.ApprovalProcess
	processMap := commonus.MapOut()

	processId := commonus.GetFileNumberEs()
	approvalProcess.Id = processId
	processMap["id"] = processId

	approvalProcess.Name = xmlToStruct.Process.Name

	processMap["name"] = xmlToStruct.Process.Name

	result, jsonErr := json.Marshal(xmlToStruct)
	if jsonErr == nil {
		approvalProcess.Flow = string(result)
		processMap["flow"] = string(result)
	} else {
		processMap["flow"] = ""
	}
	approvalProcess.FlowJson = reportAnswer.JsonStr
	processMap["flowjson"] = reportAnswer.JsonStr
	approvalProcess.FlowXml = reportAnswer.Xml
	processMap["flowxml"] = reportAnswer.Xml
	approvalProcess.FlowSvg = reportAnswer.Svg
	processMap["flowsvg"] = reportAnswer.Svg

	resultPro, jsonErrPro := json.Marshal(xmlToStruct.Process)
	if jsonErrPro == nil {
		approvalProcess.GetFlowJson = string(resultPro)
		processMap["getflowjson"] = string(resultPro)
	} else {
		processMap["getflowjson"] = ""
	}
	approvalProcess.Time = time.Now().Unix()
	approvalProcess.EiteTime = time.Now().Unix()
	approvalProcess.Sate = 1
	processMap["sate"] = 1

	batchNum := commonus.GetFileNumberEs()
	approvalProcess.Batch = batchNum
	processMap["batchnum"] = batchNum
	approvalProcess.EditionNum = "V1.0"
	processMap["editionnum"] = "V1.0"

	returnData["approvalProcess"] = approvalProcess

	// writeRedisData := map[string]interface{}{
	// 	"name":        xmlToStruct.Process.Name,
	// 	"flow":        string(result),
	// 	"flowjson":    reportAnswer.JsonStr,
	// 	"flowxml":     reportAnswer.Xml,
	// 	"flowsvg":     reportAnswer.Svg,
	// 	"getflowjson": string(resultPro),
	// 	"sate":        1,
	// 	"batchnum":    batchNum,
	// 	"editionnum":  "V1.0",
	// }
	// addProcess := global.GVA_DB_ApprovalProcess.Create(&approvalProcess)
	// if addProcess.Error != nil {
	// 	response.Result(104, addProcess.Error, "流程创建失败", c)
	// 	return
	// }
	redisClient := redishandel.RunRedis()
	redisClient.SetRedisTime(0)
	kks := redisClient.HashMsetAdd("Process:ApprovalProcess_"+global.GVA_CONFIG.RedisPrefix.Alias+"_"+strconv.FormatInt(batchNum, 10), processMap)

	response.Result(103, kks, "参数错误！", c)
}

type ExamineApprove struct {
	ProcessId        int64  `json:"processId"`        //流程批次
	ExamineApproveId int64  `json:"examineApproveId"` //正在执行的流程
	Type             int    `json:"type"`             //状态（1：同意；2：驳回；3：暂存）
	Condition        string `json:"condition"`        //判断条件
	State            int    `json:"state"`            //状态
}

//审批记录Redis过度
type ApprovalProcessLogRedis struct {
	Id          string `json:"id"`
	Process     string `json:"process" `
	CurrentNode string `json:"currentNode"`
	Title       string `json:"title" `
	Time        string `json:"time"`
	EiteTime    string `json:"eiteTime"`
	ProcessNum  string `json:"processNum"`
	IsEnd       string `json:"isEnd"`
	State       string `json:"state"`
}

//创建及审批
func (s *ShiyanApi) EstablishApprove(c *gin.Context) {
	var examineApprove ExamineApprove
	err := c.ShouldBindJSON(&examineApprove)
	if err != nil {
		response.Result(101, err, "参数错误！", c)
		return
	}
	if examineApprove.ProcessId == 0 || examineApprove.ExamineApproveId == 0 {
		response.Result(102, examineApprove, "参数错误！", c)
		return
	}
	if examineApprove.Type == 0 {
		examineApprove.Type = 2
	}
	//正在执行的流程
	var runApprovalProcess approvalprocess.ApprovalProcessLog
	//缓存设置
	redisClient := redishandel.RunRedis()

	approvalProcessRedis, isTrue := redisClient.HashGetAll("Process:RunApprovalProcess_" + global.GVA_CONFIG.RedisPrefix.Alias + "_" + strconv.FormatInt(examineApprove.ExamineApproveId, 10))
	if isTrue != true { //判断是否存在缓存
		runProcessMap := commonus.MapOut()
		appProLogErr := global.GVA_DB_ApprovalProcess.Where("`apl_id` = ?", examineApprove.ExamineApproveId).First(&runApprovalProcess).Error
		if appProLogErr != nil {
			var getApprovalProcess approvalprocess.ApprovalProcess
			getProLogErr := global.GVA_DB_ApprovalProcess.Where("`ap_batch` = ? AND `ap_state` = 1", examineApprove.ProcessId).First(&getApprovalProcess).Error
			if getProLogErr != nil {
				response.Result(103, getApprovalProcess, "对不起该流程不存在", c)
				return
			}

			runApprovalProcess.Process = getApprovalProcess.GetFlowJson
			runProcessMap["process"] = getApprovalProcess.GetFlowJson
			//流程json转为struct
			var process ProcessStruct
			jsonErrPro := json.Unmarshal([]byte(getApprovalProcess.GetFlowJson), &process)
			if jsonErrPro == nil {
				runApprovalProcess.CurrentNode = process.StartEvent.ID
				runApprovalProcess.Title = process.StartEvent.Name
				runApprovalProcess.ProcessNum = getApprovalProcess.Batch

				runProcessMap["currentNode"] = process.StartEvent.ID
				runProcessMap["title"] = process.StartEvent.Name
				runProcessMap["processNum"] = getApprovalProcess.Batch
			} else {
				runApprovalProcess.CurrentNode = ""
				runApprovalProcess.Title = ""
				runApprovalProcess.ProcessNum = 0

				runProcessMap["currentNode"] = ""
				runProcessMap["title"] = ""
				runProcessMap["processNum"] = 0
			}
			runApprovalProcess.Time = time.Now().Unix()
			runApprovalProcess.EiteTime = time.Now().Unix()

			runApprovalProcess.IsEnd = 1
			runProcessMap["isend"] = 1
			if examineApprove.State == 0 {
				runApprovalProcess.Sate = 1
				runProcessMap["state"] = 1
			} else {
				runApprovalProcess.Sate = examineApprove.State
				runProcessMap["state"] = examineApprove.State
			}

			runProcessMap["time"] = time.Now().Unix()
			runProcessMap["eiteTime"] = time.Now().Unix()

			addProcess := global.GVA_DB_ApprovalProcess.Create(&runApprovalProcess).Error
			if addProcess != nil {
				response.Result(104, getApprovalProcess, "对不起该流程启用失败", c)
				return
			}
			runProcessMap["id"] = runApprovalProcess.Id
			redisClient.SetRedisTime(0)
			redisClient.HashMsetAdd("Process:RunApprovalProcess_"+global.GVA_CONFIG.RedisPrefix.Alias+"_"+strconv.FormatInt(runApprovalProcess.Id, 10), runProcessMap)
		} else {
			runProcessMap["process"] = runApprovalProcess.Process
			runProcessMap["currentNode"] = runApprovalProcess.CurrentNode
			runProcessMap["title"] = runApprovalProcess.Title
			runProcessMap["processNum"] = runApprovalProcess.ProcessNum
			runProcessMap["time"] = runApprovalProcess.Time
			runProcessMap["eiteTime"] = runApprovalProcess.EiteTime
			runProcessMap["id"] = runApprovalProcess.Id
			runProcessMap["isend"] = runApprovalProcess.IsEnd
			runProcessMap["state"] = runApprovalProcess.Sate
			if runApprovalProcess.IsEnd == 1 {
				redisClient.SetRedisTime(0)
			} else {
				redisClient.SetRedisTime(604800)
			}
			redisClient.HashMsetAdd("Process:RunApprovalProcess_"+global.GVA_CONFIG.RedisPrefix.Alias+"_"+strconv.FormatInt(runApprovalProcess.Id, 10), runProcessMap)
			if runApprovalProcess.IsEnd != 1 {
				response.Result(105, runApprovalProcess, "该流程已经结束！请不要重复执行！", c)
				return
			}
		}
	} else {
		// fmt.Printf("Redis====》%v\n", runApprovalProcess)
		var approvalProcessLogRedis ApprovalProcessLogRedis
		err := mapstructure.Decode(approvalProcessRedis, &approvalProcessLogRedis)
		if err != nil {
			response.Result(104, err, "对不起该流程启用失败", c)
			return
			// return departmentlist, false
		}
		appId, appIdErr := strconv.ParseInt(approvalProcessLogRedis.Id, 10, 64)

		if appIdErr == nil {
			runApprovalProcess.Id = appId
		}

		// fmt.Printf("审批ID==Redis==》%v-------------%v\n", approvalProcessLogRedis.Id, appId)

		processNum, processNumErr := strconv.ParseInt(approvalProcessLogRedis.ProcessNum, 10, 64)
		if processNumErr == nil {
			runApprovalProcess.ProcessNum = processNum
		}

		timeVal, timeErr := strconv.ParseInt(approvalProcessLogRedis.Time, 10, 64)
		if timeErr == nil {
			runApprovalProcess.Time = timeVal
		}
		eiteTime, eiteTimeErr := strconv.ParseInt(approvalProcessLogRedis.EiteTime, 10, 64)
		if eiteTimeErr == nil {
			runApprovalProcess.EiteTime = eiteTime
		}

		isEnd, isEndErr := strconv.Atoi(approvalProcessLogRedis.IsEnd)
		if isEndErr == nil {
			runApprovalProcess.IsEnd = isEnd
		} else {
			response.Result(107, runApprovalProcess, "对不起该流程启用失败！", c)
			return
		}
		sateSet, sateErr := strconv.Atoi(approvalProcessLogRedis.State)
		if sateErr == nil {
			runApprovalProcess.Sate = sateSet
		} else {
			response.Result(108, sateErr, "对不起该流程启用失败！", c)
			return
		}

		runApprovalProcess.Process = approvalProcessLogRedis.Process
		runApprovalProcess.CurrentNode = approvalProcessLogRedis.CurrentNode
		runApprovalProcess.Title = approvalProcessLogRedis.Title

		if runApprovalProcess.IsEnd != 1 {
			response.Result(106, runApprovalProcess, "该流程已经结束！请不要重复执行！", c)
			return
		}
	}
	// fmt.Printf("数据结构===========>%v\n", runApprovalProcess)
	switch examineApprove.Type {
	case 1: //批准
		ApproveOperation(runApprovalProcess, examineApprove)
	case 3: //暂存
	default: //驳回
	}
}

//批准操作
func ApproveOperation(runApprovalProcess approvalprocess.ApprovalProcessLog, examineApprove ExamineApprove) (isTrue bool) {
	// fmt.Printf("审批ID==Redis==》%v-------------%v\n", runApprovalProcess.Id, runApprovalProcess)
	isTrue = false
	// fmt.Printf("结果====》%v\n", runApprovalProcess)
	var process ProcessStruct
	jsonErrPro := json.Unmarshal([]byte(runApprovalProcess.Process), &process)
	if jsonErrPro != nil {
		fmt.Printf("转换失败====》%v\n", process)
		return
	}
	if runApprovalProcess.CurrentNode == process.EndEvent.ID {
		fmt.Printf("执行结束节点====》%v\n", process.EndEvent.ID)
		return
	}

	if runApprovalProcess.CurrentNode == process.StartEvent.ID {
		fmt.Printf("执行开始节点====》%v\n", process.StartEvent.ID)

		if len(process.StartEvent.Outgoing) > 1 {
			fmt.Printf("执行开始节点====有条件》%v\n", process.StartEvent.ID)

			currentId := runApprovalProcess.CurrentNode

			appId, appTitle, appIsTrue, isEnd := ApprovalCriteria(1, process, examineApprove, runApprovalProcess.CurrentNode)

			fmt.Printf("执行审批节点==11111==下一个节点》%v----%v-----%v\n", appId, appTitle, appIsTrue)
			if appIsTrue != true {
				return
			}
			isTrue = true
			currentId = appId

			// for _, outGoing := range process.StartEvent.Outgoing {
			// 	for _, seqFlow := range process.SequenceFlow {
			// 		if outGoing.Text == seqFlow.ID {
			// 			// fmt.Printf("条件(%v)====》对比条件-----%v\n", seqFlow.ConditionExpression.Text, examineApprove.Condition)
			// 			if seqFlow.ConditionExpression.Text == examineApprove.Condition {
			// 				isTrue = true
			// 				currentId = seqFlow.TargetRef
			// 				fmt.Printf("执行节点====》%v\n", seqFlow.TargetRef)
			// 			}
			// 		}
			// 	}
			// }

			runApprovalProcess.CurrentNode = currentId
			runApprovalProcess.Title = appTitle
			runApprovalProcess.EiteTime = time.Now().Unix()

			runProcessMap := commonus.MapOut()
			runProcessMap["process"] = runApprovalProcess.Process
			runProcessMap["currentNode"] = currentId

			runProcessMap["processNum"] = runApprovalProcess.ProcessNum
			runProcessMap["time"] = time.Now().Unix()

			runProcessMap["title"] = appTitle
			runProcessMap["eiteTime"] = time.Now().Unix()

			if isEnd == true {
				runApprovalProcess.IsEnd = 2
				runProcessMap["isend"] = 2
			}

			//缓存设置
			redisClient := redishandel.RunRedis()
			redisClient.SetRedisTime(604800)
			redisClient.HashMsetAdd("Process:RunApprovalProcess_"+global.GVA_CONFIG.RedisPrefix.Alias+"_"+strconv.FormatInt(runApprovalProcess.Id, 10), runProcessMap)

			fmt.Printf("审批ID==22222==》%v\n", runApprovalProcess.Id)

			eiteProcess := global.GVA_DB_ApprovalProcess.Where("`apl_id` = ?", runApprovalProcess.Id).Updates(&runApprovalProcess).Error

			if eiteProcess == nil {
				fmt.Printf("更新成功====》%v\n", runApprovalProcess)
			} else {
				fmt.Printf("更新失败====》%v\n", runApprovalProcess)
			}
			return
		} else if len(process.StartEvent.Outgoing) < 1 {
			fmt.Printf("执行开始节点====未知下个节点》%v\n", process.StartEvent.ID)
		} else {
			fmt.Printf("执行开始节点====直接到审批》%v\n", process.StartEvent.ID)
		}

	}

	for _, taskVal := range process.UserTask {
		if runApprovalProcess.CurrentNode == taskVal.ID {
			fmt.Printf("执行审批节点====》%v\n", taskVal.ID)
			appId, appTitle, appIsTrue, isEnd := ApprovalCriteria(3, process, examineApprove, runApprovalProcess.CurrentNode)

			fmt.Printf("执行审批节点====下一个节点》%v----%v-----%v\n", appId, appTitle, appIsTrue)

			currentId := runApprovalProcess.CurrentNode
			if appIsTrue != true {
				return
			}
			isTrue = true
			currentId = appId
			runApprovalProcess.CurrentNode = currentId
			runApprovalProcess.Title = appTitle
			runApprovalProcess.EiteTime = time.Now().Unix()

			runProcessMap := commonus.MapOut()
			runProcessMap["process"] = runApprovalProcess.Process
			runProcessMap["currentNode"] = currentId

			runProcessMap["processNum"] = runApprovalProcess.ProcessNum
			runProcessMap["time"] = time.Now().Unix()

			runProcessMap["title"] = appTitle
			runProcessMap["eiteTime"] = time.Now().Unix()

			if isEnd == true {
				runApprovalProcess.IsEnd = 2
				runProcessMap["isend"] = 2
			}

			//缓存设置
			redisClient := redishandel.RunRedis()
			redisClient.SetRedisTime(604800)
			redisClient.HashMsetAdd("Process:RunApprovalProcess_"+global.GVA_CONFIG.RedisPrefix.Alias+"_"+strconv.FormatInt(runApprovalProcess.Id, 10), runProcessMap)

			fmt.Printf("审批ID====》%v\n", runApprovalProcess.Id)

			eiteProcess := global.GVA_DB_ApprovalProcess.Where("`apl_id` = ?", runApprovalProcess.Id).Updates(&runApprovalProcess).Error

			if eiteProcess == nil {
				fmt.Printf("更新成功uis====》%v\n", runApprovalProcess)
			} else {
				fmt.Printf("更新失败uis====》%v\n", runApprovalProcess)
			}
			return
		}
	}
	return
}

//审批条件解析
/*
@execStatus   执行状态  1：开始；2：结束；3：审批
*/
func ApprovalCriteria(execStatus int, process ProcessStruct, examineApprove ExamineApprove, currentNode string) (currentId, nextTitle string, isTrue, isEnd bool) {
	isTrue = false
	isEnd = false
	//解析条件判断，获取出下个节点的ID
	switch execStatus {
	case 1:
		fmt.Printf("State ----------> %v\n", execStatus)
		for _, outGoing := range process.StartEvent.Outgoing {
			for _, seqFlow := range process.SequenceFlow {
				if outGoing.Text == seqFlow.ID {
					fmt.Printf("条件(%v)====》对比条件-----%v\n", seqFlow.ConditionExpression.Text, examineApprove.Condition)
					if seqFlow.ConditionExpression.Text == examineApprove.Condition {
						isTrue = true
						currentId = seqFlow.TargetRef
						fmt.Printf("执行节点====》%v\n", seqFlow.TargetRef)
					}
				}
			}
		}
	case 2:
		fmt.Printf("State ----------> %v\n", execStatus)
	default:
		fmt.Printf("State ----------> %v\n", execStatus)
		for _, taskVal := range process.UserTask {
			if taskVal.ID == currentNode {
				for _, outGoing := range taskVal.Outgoing {
					for _, seqFlow := range process.SequenceFlow {
						if outGoing.Text == seqFlow.ID {
							fmt.Printf("条件(%v)====》对比条件-----%v\n", seqFlow.ConditionExpression.Text, examineApprove.Condition)
							if seqFlow.ConditionExpression.Text == examineApprove.Condition {
								isTrue = true
								currentId = seqFlow.TargetRef
								fmt.Printf("执行节点====》%v\n", seqFlow.TargetRef)
							}
						}
					}
				}
			}
			// for _, seqFlow := range process.SequenceFlow {

			// 	fmt.Printf("条件(%v)====》对比条件-----%v\n", taskVal.ID, seqFlow.ID)

			// 	if taskVal.ID == seqFlow.ID {

			// 		if seqFlow.ConditionExpression.Text == examineApprove.Condition {
			// 			isTrue = true
			// 			currentId = seqFlow.TargetRef
			// 			fmt.Printf("执行节点====》%v\n", seqFlow.TargetRef)
			// 		}
			// 	}
			// }
		}
	}
	nextNameIsTrue := false
	//获取审批节点名称
	for _, taskVal := range process.UserTask {
		if taskVal.ID == currentId {
			nextTitle = taskVal.Name
			nextNameIsTrue = true
		}
	}
	if nextNameIsTrue != true {
		if currentId == process.EndEvent.ID {
			nextTitle = process.EndEvent.Name
			nextNameIsTrue = true
			isEnd = true
			return
		}
		if currentId == process.StartEvent.ID {
			nextTitle = process.StartEvent.Name
			nextNameIsTrue = true
		}
	}
	return
}