opms_backend/opms_parent/app/handler/dingtalk/ding_event.go

package dingtalk

import (
	"context"
	model "dashoo.cn/micro/app/model/workflow"
	contractSrv "dashoo.cn/micro/app/service/contract"
	custServer "dashoo.cn/micro/app/service/cust"
	"dashoo.cn/micro/app/service/dingtalk_log"
	platServer "dashoo.cn/micro/app/service/plat"
	projService "dashoo.cn/micro/app/service/proj"
	workflowServer "dashoo.cn/micro/app/service/workflow"
	"dashoo.cn/opms_libary/plugin/dingtalk"
	dingContext "dashoo.cn/opms_libary/plugin/dingtalk/context"
	"dashoo.cn/opms_libary/plugin/dingtalk/message"
	"database/sql"
	"fmt"
	"github.com/gogf/gf/os/glog"
	"github.com/gogf/gf/util/gconv"
)

type DingHandler struct{}

// CallBack 钉钉事件回调
// 日程相关详情参照文档：https://open.dingtalk.com/document/orgapp/schedule-event
// 审批相关详情参照文档：https://open.dingtalk.com/document/orgapp/approval-events
func (h *DingHandler) CallBack(ctx context.Context, req *message.SubsMessage, rsp *message.Reply) error {
	req.Ctx = ctx
	handler := dingtalk.Client.GetDingTalkHandler(req)
	//设置接收消息的处理方法
	handler.SetHandleMessageFunc(func(msg *message.MixMessage) string {
		// 记录日志
		dingtalk_log.Create(handler.Context.SubsMessage.Ctx, "20", gconv.String(msg))

		switch msg.EventType {
		case message.EventCheckUrl:
			return h.handleCheckUrl(msg)
		case message.EventCalendarChange:
			return h.handleCalendarChange(msg, handler.Context)
		case message.BpmsInstanceChange:
			return h.handleBpmsInstanceChange(msg, handler.Context)
		case message.BpmsTaskChange:
			return h.handleBpmsTaskChange(msg, handler.Context)
		}
		return ""
	})
	result, _ := handler.Handle()
	*rsp = result
	return nil
}

// 验证回调参数
func (h *DingHandler) handleCheckUrl(msg *message.MixMessage) string {
	fmt.Println(msg)
	return "success"
}

// 处理日程回调
func (h *DingHandler) handleCalendarChange(msg *message.MixMessage, ctx *dingContext.Context) string {
	fmt.Println(msg)

	// 本系统数据库操作
	s, err := platServer.NewScheduleService(ctx.SubsMessage.Ctx)
	if err != nil {
		glog.Error(err)
		return err.Error()
	}
	// 回填数据
	err = s.SaveByDingEvent(msg)
	if err != nil {
		glog.Error(err)
		return err.Error()
	}
	return "success"
}

// 处理审批实例回调
func (h *DingHandler) handleBpmsInstanceChange(msg *message.MixMessage, ctx *dingContext.Context) string {
	fmt.Println(msg)

	// 构造访问服务
	s, err := workflowServer.NewFlowService(ctx.SubsMessage.Ctx)
	if err != nil {
		glog.Error(err)
		return err.Error()
	}
	// 获取审批实例数据
	instance, err := s.GetWorkflowInstance(msg.ProcessInstanceId)
	if err != nil {
		if err == sql.ErrNoRows {
			glog.Error("无匹配的审批实例")
			return "无匹配的审批实例"
		}
		glog.Error(err)
		return err.Error()
	}
	if instance == nil {
		return "无匹配的审批实例"
	}
	// 处理实例数据（不需要钉钉审批实例参数）
	switch instance.BizType {
	case model.CustomerReceive:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := custServer.NewCustomerService(ctx.SubsMessage.Ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.AssignCustomerRequestApproval(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.CustomerPublic:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := custServer.NewCustomerService(ctx.SubsMessage.Ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.MoveToPublicApproval(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.CustomerTrans:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := custServer.NewCustomerService(ctx.SubsMessage.Ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.TransCustomerApproval(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.ContractInvoice:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			err = contractSrv.InvoiceApplyApproval(ctx.SubsMessage.Ctx, instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.ContractCreate:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			err = contractSrv.ContractApplyApproval(ctx.SubsMessage.Ctx, instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.ProjectUpGrade:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := projService.NewBusinessService(ctx.SubsMessage.Ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.BusinessUpgradeNotify(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.ProjectDownGrade:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := projService.NewBusinessService(ctx.SubsMessage.Ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.BusinessDowngradeNotify(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.ProjectTransfer:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := projService.NewBusinessService(ctx.SubsMessage.Ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.BusinessTransferNotify(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.ProjectToReserve:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := projService.NewBusinessService(ctx.SubsMessage.Ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.ConvertToReserveNotify(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	case model.PlatTaskApproval:
		if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
			srv, err := platServer.NewTaskService(ctx.SubsMessage.Ctx)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
			err = srv.AddTaskApproval(instance, msg)
			if err != nil {
				glog.Error(err)
				return err.Error()
			}
		}
		err = s.Update(instance, msg)
		if err != nil {
			glog.Error(err)
			return err.Error()
		}
		return "success"
	}

	// 以下的代码需要调用钉钉接口查询数据，并且以下接口需要审批实例的数据
	//// 获取钉钉数据
	//resp, err := s.GetProcessInstanceDetail(msg.ProcessInstanceId)
	//if err != nil {
	//	glog.Error(err)
	//	return err.Error()
	//}
	//if resp.Success == "false" {
	//	return "fail"
	//}
	////按照类型处理数据（不需要钉钉审批实例参数）
	//switch instance.BizType {
	//case model.CustomerReceive:
	//	if msg.ProcessType == "finish" || msg.ProcessType == "terminate" {
	//		//srv.Handle(instance, msg, resp)
	//	}

	return "success"
}

// 处理审批任务回调
func (h *DingHandler) handleBpmsTaskChange(msg *message.MixMessage, ctx *dingContext.Context) string {
	fmt.Println(msg)

	// TODO 目前审批任务无处理逻辑
	//// 本系统数据库操作
	//s, err := platServer.NewScheduleService(ctx.SubsMessage.Ctx)
	//if err != nil {
	//	glog.Error(err)
	//	return err.Error()
	//}
	//// 回填数据
	//err = s.SaveByDingEvent(msg)
	//if err != nil {
	//	glog.Error(err)
	//	return err.Error()
	//}
	return "success"
}