添加派工计划工作台的功能

common/ProjectChannel.go

@@ -1,5 +1,7 @@
 package common
 
-import plnModel "LAPP_ACURA_MOM_BACKEND/models/pln"
+import "LAPP_ACURA_MOM_BACKEND/models/channel"
+
+var	ReleaseTaskChannel map[int]*channel.ReleaseTaskChannel
+
 
-var ReleaseTaskChannel map[int]chan plnModel.CustOrder

dao/pln/CustOrder.dao.go

@@ -475,6 +475,8 @@ type CustOrderDAO interface {
 	SelectRunningCustOrder(workLineId string) ([]model.CustOrder, error)
 	// 查询可生产的客户订单
 	SelectNeedReleaseCustOrder() ([]model.CustOrder, error)
+	// 查询派工中和派工失败的客户订单
+	SelectReleasingOrder() ([]model.CustOrder, error)
 }
 
 /******************************************************************************

dao/pln/implments/CustOrder.dao.impl.go

@@ -904,4 +904,38 @@ func (impl *CustOrderDAOImplement) SelectNeedReleaseCustOrder() ([]model.CustOrd
 		result = append(result, custOrder)
 	}
 	return result, err
+}
+
+func (impl *CustOrderDAOImplement) SelectReleasingOrder() ([]model.CustOrder, error) {
+	parameters := []interface{}{impl.plantNr, common.ORDER_STATUS_LOCKED, common.WO_STATUS_RELEASE_FAILED}
+	where := fmt.Sprintf("%s = ? and ( %s = ? or %s = ?)",
+		meta.CustOrder_PlantNr.ColumnName,
+		meta.CustOrderStatus_Status.ColumnName,
+		meta.CustOrderStatus_Status.ColumnName,
+		)
+	statusCondition := fmt.Sprintf("%s = %s and %s = %s",
+		meta.CustOrder_PlantNr.ColumnName,
+		meta.CustOrderStatus_PlantNr.ColumnName,
+		meta.CustOrder_CustOrderId.ColumnName,
+		meta.CustOrderStatus_CustOrderId.ColumnName)
+	qtyCondition := fmt.Sprintf("%s = %s and %s = %s",
+		meta.CustOrder_PlantNr.ColumnName,
+		meta.CustOrderQty_PlantNr.ColumnName,
+		meta.CustOrder_CustOrderId.ColumnName,
+		meta.CustOrderQty_CustOrderId.ColumnName)
+	session := impl.session.Table(impl.meta.TableName).Join("INNER", meta.CustOrderStatus.TableName, statusCondition).Join("INNER", meta.CustOrderQty.TableName, qtyCondition)
+	data := make([]model.CustOrderData, 0)
+	err := session.Where(where, parameters...).Asc(meta.CustOrder_WorkLineId.SortColumnName).Asc(meta.CustOrder_PlanStartTime.SortColumnName).Find(&data)
+	if err != nil {
+		return nil, err
+	}
+	result := make([]model.CustOrder, 0, len(data))
+	for _, custOrderData := range data {
+		var custOrder model.CustOrder
+		custOrder = custOrderData.CustOrder
+		custOrder.OrderStatus = custOrderData.CustOrderStatus
+		custOrder.OrderQty = custOrderData.CustOrderQty
+		result = append(result, custOrder)
+	}
+	return result, err
 }

models/base/Const.go

@@ -6,6 +6,11 @@ const (
 	PROJECT_ACURA  = "ACURA"
 	PROJECT_NANSHA = "nansha"
 
+	// 跨工厂任务状态
+	CROSS_TASK_STATUS_PLAN = 20
+	CROSS_TASK_STATUS_ACCOMPLISHED = 80
+	CROSS_TASK_STATUS_ERROR = 90
+
 	// 流水号重置规则
 	RESET_RULE_DAYLY = "DAILY"
 	RESET_RULE_WEEKLY = "WEEKLY"
@@ -47,6 +52,7 @@ const (
 	WO_STATUS_UNPLANNED   = 10 // 未计划
 	WO_STATUS_PLANNED     = 20 // 已计划
 	WO_STATUS_LOCKED      = 24 // 已锁定
+	WO_STATUS_RELEASE_FAILED = 25 // 派工失败
 	WO_STATUS_RELEASED    = 26 // 已下达，生成序列订单
 	WO_STATUS_INTERRUPT   = 39 // 中断中 aps不合格 mes跳单
 	WO_STATUS_UNQUALIFIED = 49 // aps不合格

models/channel/ReleaseTask.go

@@ -0,0 +1,70 @@
+package channel
+
+import (
+	plnModel "LAPP_ACURA_MOM_BACKEND/models/pln"
+	"errors"
+	"sync"
+)
+
+type ReleaseTaskChannel struct {
+	c      chan plnModel.CustOrder
+	closed bool
+	mutex  sync.Mutex
+}
+
+func NewReleaseChannel() *ReleaseTaskChannel {
+	return &ReleaseTaskChannel{
+		c: make(chan plnModel.CustOrder, 50),
+	}
+}
+
+// IsClosed 判断channel是否关闭
+func (c *ReleaseTaskChannel) IsClosed() bool {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	return c.closed
+}
+
+// SendData 发送数据
+func (c *ReleaseTaskChannel) SendData(custOrder plnModel.CustOrder) error {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	if c.closed {
+		return errors.New("管道已关闭")
+	}
+	c.c <- custOrder
+	return nil
+}
+
+func (c *ReleaseTaskChannel) Close() {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	if c.closed {
+		return
+	}
+	close(c.c)
+	c.closed = true
+}
+
+func (c *ReleaseTaskChannel) Read() (data plnModel.CustOrder, ok bool, err error) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	if c.closed {
+		err = errors.New("管道已关闭")
+		return
+	}
+	data, ok = <- c.c
+	return
+}
+
+func (c *ReleaseTaskChannel) ResetChannel() (err error) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	if !c.closed {
+		err = errors.New("管道未关闭")
+		return
+	}
+	c.closed = false
+	c.c = make(chan plnModel.CustOrder, 50)
+	return
+}

models/pln/const.go

@@ -22,6 +22,8 @@ const (
 	STATUS_CHANGE_TYPE_REPORT = "REPORT"
 	STATUS__CHANGE_TYPE_SCHUDLER = "SCHUDLER"
 	STATUS_CHANGE_TYPE_OPERATION = "OPERATION"
+	STATUS_CHANGE_TYPE_SPLIT = "SPLIT"
+	STATUS_CHANGE_TYPE_RELEASE = "RELEASE"
 
 	// toyota calloff 解析状态
 	CALLOFF_STATUS_UNPARSED = 0

services/pln/CustOrder.service.go

@@ -425,7 +425,12 @@ type CustOrderService interface {
 	 *
 	 ******************************************************************************/
 	AnalysisPlanFromExcel(user *global.User, filepath string) error
+	// 派工
 	ReleaseTask() error
+	// 查询所有派工未完成和失败的任务
+	SelectReleaseTask(user *global.User) ([]model.CustOrder, error)
+	// 修复派工失败
+	RepairReleaseFailedTask(user *global.User) (err error)
 }
 
 /******************************************************************************

services/pln/implments/CustOrder.service.impl.go

@@ -1352,7 +1352,7 @@ func (impl *CustOrderServiceImplement) SplitOrderQty(user *global.User, custOrde
 		if custOrder.OrderQty.PlanQty == custOrder.OrderQty.CancelQty {
 			custOrderStatusRec := model.CustOrderStatusHistory{
 				CustOrderId:      custOrderId,
-				StatusChangeType: "SPLIT",
+				StatusChangeType: model.STATUS_CHANGE_TYPE_SPLIT,
 				FromStatus:       custOrder.OrderStatus.Status,
 				ToStatus:         baseModel.WO_STATUS_CANCELED,
 				ChangeTime:       grmi.DateTime(time.Now()),
@@ -1371,7 +1371,7 @@ func (impl *CustOrderServiceImplement) SplitOrderQty(user *global.User, custOrde
 		} else if custOrder.OrderQty.PlanQty == custOrder.OrderQty.ActQty+custOrder.OrderQty.CancelQty {
 			custOrderStatusRec := model.CustOrderStatusHistory{
 				CustOrderId:      custOrderId,
-				StatusChangeType: "SPLIT",
+				StatusChangeType: model.STATUS_CHANGE_TYPE_SPLIT,
 				FromStatus:       custOrder.OrderStatus.Status,
 				ToStatus:         baseModel.WO_STATUS_FINISHED,
 				ChangeTime:       grmi.DateTime(time.Now()),
@@ -1507,7 +1507,7 @@ func (impl *CustOrderServiceImplement) SplitOrderQty(user *global.User, custOrde
 	if custOrder.OrderQty.PlanQty == custOrder.OrderQty.CancelQty {
 		custOrderStatusRec := model.CustOrderStatusHistory{
 			CustOrderId:      custOrderId,
-			StatusChangeType: "SPLIT",
+			StatusChangeType: model.STATUS_CHANGE_TYPE_SPLIT,
 			FromStatus:       custOrder.OrderStatus.Status,
 			ToStatus:         baseModel.WO_STATUS_CANCELED,
 			ChangeTime:       grmi.DateTime(time.Now()),
@@ -1526,7 +1526,7 @@ func (impl *CustOrderServiceImplement) SplitOrderQty(user *global.User, custOrde
 	} else if custOrder.OrderQty.PlanQty == custOrder.OrderQty.ActQty+custOrder.OrderQty.CancelQty {
 		custOrderStatusRec := model.CustOrderStatusHistory{
 			CustOrderId:      custOrderId,
-			StatusChangeType: "SPLIT",
+			StatusChangeType: model.STATUS_CHANGE_TYPE_SPLIT,
 			FromStatus:       custOrder.OrderStatus.Status,
 			ToStatus:         baseModel.WO_STATUS_FINISHED,
 			ChangeTime:       grmi.DateTime(time.Now()),
@@ -1730,10 +1730,12 @@ func (impl *CustOrderServiceImplement) AutoScheduler(user *global.User, session
 
 		err error
 	)
+	custOrderIdMap := make(map[string]interface{})
 	returnCustOrderLi := make([]model.CustOrder, 0, len(unplannedCustOrderLi))
 	custOrderMap := make(map[string]*model.CustOrder)
 	for index, custOrder := range unplannedCustOrderLi {
 		custOrderMap[custOrder.CustOrderId] = &unplannedCustOrderLi[index]
+		custOrderIdMap[custOrder.CustOrderId] = nil
 	}
 	endDate = endDate.Add(1 * time.Second)
 	schedEngine = schedule.SchedulerSrv{PlantNr: user.PlantNr, StartDate: startDate, EndDate: endDate}
@@ -1782,10 +1784,15 @@ func (impl *CustOrderServiceImplement) AutoScheduler(user *global.User, session
 	if err != nil {
 		return nil, err
 	}
+
 	// 将已计划的客户订单进行落库 状态设置为26
-	for _, plannedTask := range schedEngine.UnPlannedTaskArray {
+	for _, plannedTask := range schedEngine.WorklineDict[workLineId].SchedTaskArray {
 		//过滤订单状态大于20的订单
-		if plannedTask.CustOrderStatus.Status > baseModel.WO_STATUS_PLANNED {
+		//if plannedTask.CustOrderStatus.Status > baseModel.WO_STATUS_PLANNED {
+		//	continue
+		//}
+		_, exist := custOrderIdMap[plannedTask.TaskId]
+		if !exist {
 			continue
 		}
 		// 保存客户订单数据

services/pln/implments/CustOrderLogic.service.impl.go

@@ -12,13 +12,14 @@ import (
 	"LAPP_ACURA_MOM_BACKEND/infra/logger"
 	meMeta "LAPP_ACURA_MOM_BACKEND/meta/me"
 	omMeta "LAPP_ACURA_MOM_BACKEND/meta/om"
+	meta "LAPP_ACURA_MOM_BACKEND/meta/pln"
 	baseModel "LAPP_ACURA_MOM_BACKEND/models/base"
+	channelModel "LAPP_ACURA_MOM_BACKEND/models/channel"
 	meModel "LAPP_ACURA_MOM_BACKEND/models/me"
 	omModel "LAPP_ACURA_MOM_BACKEND/models/om"
 	model "LAPP_ACURA_MOM_BACKEND/models/pln"
 	omSvr "LAPP_ACURA_MOM_BACKEND/services/om"
 	"LAPP_ACURA_MOM_BACKEND/utils"
-	"fmt"
 	"github.com/360EntSecGroup-Skylar/excelize/v2"
 	uuid "github.com/iris-contrib/go.uuid"
 	"sort"
@@ -84,11 +85,13 @@ func (impl *CustOrderServiceImplement) LockCustOrder(user *global.User, custOrde
 	plantNr := user.PlantNr
 	channel, exist := common.ReleaseTaskChannel[plantNr]
 	if !exist {
-		common.ReleaseTaskChannel[plantNr] = make(chan model.CustOrder, 50)
-		channel = common.ReleaseTaskChannel[plantNr]
+		return nil
 	}
 	for _, custOrder := range custOrderLi {
-		channel <- custOrder
+		err = channel.SendData(custOrder)
+		if err != nil {
+			return nil
+		}
 	}
 	return nil
 }
@@ -262,28 +265,62 @@ func (impl *CustOrderServiceImplement) AnalysisPlanFromExcel(user *global.User,
 	sort.Slice(releaseCustOrderLi, func(i, j int) bool {
 		itemI := releaseCustOrderLi[i]
 		itemJ := releaseCustOrderLi[j]
-		return itemJ.PlanStartTime.Restore().Before(itemI.PlanStartTime.Restore())
+		return itemI.PlanStartTime.Restore().Before(itemJ.PlanStartTime.Restore())
 	})
 	plantNr := user.PlantNr
 	channel, exist := common.ReleaseTaskChannel[plantNr]
 	if !exist {
-		common.ReleaseTaskChannel[plantNr] = make(chan model.CustOrder, 50)
-		channel = common.ReleaseTaskChannel[plantNr]
+		return nil
 	}
 	for _, custOrder := range releaseCustOrderLi {
-		fmt.Println("custORderId:", custOrder.CustOrderId)
-		channel <- custOrder
+		err = channel.SendData(custOrder)
+		if err != nil {
+			return nil
+		}
 	}
 	return nil
 }
 
-// ReleaseCustOrder 对客户订单进行派工
-func (impl *CustOrderServiceImplement) ReleaseCustOrder(user *global.User, custOrderData model.CustOrder) error {
+func (impl *CustOrderServiceImplement) ReleaseSingleOrder(user *global.User, custOrderData model.CustOrder) error {
 	releaseId, err := uuid.NewV4()
 	if err != nil {
 		return grmi.NewBusinessError("生成任务id失败,错误:" + err.Error())
 	}
 	log, _ := logger.NewLogger("客户订单派工,id:"+releaseId.String(), "PLN")
+	err = impl.ReleaseCustOrder(user, custOrderData, log)
+	if err != nil {
+		engine := db.Eloquent.Master()
+		session := engine.NewSession()
+		defer session.Close()
+		statusHistoryDao := dal.NewCustOrderStatusHistoryDAO(session, user.PlantNr, user.UserId)
+		statusDao := dal.NewCustOrderStatusDAO(session, user.PlantNr, user.UserId)
+		statusHistory := model.CustOrderStatusHistory{
+			CustOrderId: custOrderData.CustOrderId,
+			StatusChangeType: model.STATUS_CHANGE_TYPE_RELEASE,
+			FromStatus: custOrderData.OrderStatus.Status,
+			ToStatus: baseModel.WO_STATUS_RELEASE_FAILED,
+			ChangeTime: grmi.DateTime(time.Now()),
+			TriggerPara1: err.Error(),
+		}
+		innerErr := statusHistoryDao.InsertOne(&statusHistory)
+		if innerErr != nil {
+			log.Error("派工失败, 保存客户订单状态变更记录失败, 错误:" + err.Error())
+			return err
+		}
+		custOrderData.OrderStatus.Status = baseModel.WO_STATUS_RELEASE_FAILED
+		innerErr = statusDao.UpdateOne(&custOrderData.OrderStatus)
+		if err != nil {
+			log.Error("派工失败, 更新客户订单状态变更记录失败, 错误:" + err.Error())
+			return err
+		}
+		return err
+	}
+	return nil
+}
+
+// ReleaseCustOrder 对客户订单进行派工
+func (impl *CustOrderServiceImplement) ReleaseCustOrder(user *global.User, custOrderData model.CustOrder, log logger.Log) error {
+
 	engine := db.Eloquent.Master()
 	session := engine.NewSession()
 	defer session.Close()
@@ -887,19 +924,24 @@ func (impl *CustOrderServiceImplement) ReleaseCustOrder(user *global.User, custO
 
 func (impl *CustOrderServiceImplement) ReleasePlantTask(user *global.User) {
 	log, _ := logger.NewLogger("派工任务", "PLN")
-	var err error
 	plantNr := user.PlantNr
 	channel, exist := common.ReleaseTaskChannel[plantNr]
 	if !exist {
-		common.ReleaseTaskChannel[plantNr] = make(chan model.CustOrder, 50)
+		return
 	}
 	for {
-		select {
-		case custOrder := <-channel:
-			err = impl.ReleaseCustOrder(user, custOrder)
-			if err != nil {
-				log.Error("派工异常, 错误:" + err.Error())
-			}
+		custOrder, ok, err := channel.Read()
+		if err != nil {
+			return
+		}
+		if !ok {
+			continue
+		}
+		err = impl.ReleaseSingleOrder(user, custOrder)
+		if err != nil {
+			log.Error("派工异常, 错误:" + err.Error())
+			channel.Close()
+			return
 		}
 	}
 }
@@ -926,11 +968,14 @@ func (impl *CustOrderServiceImplement) ReleaseTask() error {
 		}
 		channel, exist := common.ReleaseTaskChannel[user.PlantNr]
 		if !exist {
-			common.ReleaseTaskChannel[user.PlantNr] = make(chan model.CustOrder, 50)
-			channel = common.ReleaseTaskChannel[user.PlantNr]
+			channel = channelModel.NewReleaseChannel()
+			common.ReleaseTaskChannel[user.PlantNr] = channel
 		}
 		for _, custOrder := range custOrderLi {
-			channel <- custOrder
+			err = channel.SendData(custOrder)
+			if err != nil {
+				return err
+			}
 		}
 		go func(user *global.User) {
 			impl.ReleasePlantTask(user)
@@ -938,3 +983,81 @@ func (impl *CustOrderServiceImplement) ReleaseTask() error {
 	}
 	return nil
 }
+
+// SelectReleaseTask 查询派工任务
+func (impl *CustOrderServiceImplement) SelectReleaseTask(user *global.User) ([]model.CustOrder, error) {
+	engine := db.Eloquent.Master()
+	session := engine.NewSession()
+	defer session.Close()
+	custOrderDao := dal.NewCustOrderDAO(session, user.PlantNr, user.UserId)
+	custOrderLi, err := custOrderDao.SelectReleasingOrder()
+	return custOrderLi, err
+}
+
+// RepairReleaseFailedTask 修复派工失败
+func (impl *CustOrderServiceImplement) RepairReleaseFailedTask(user *global.User) (err error)  {
+	engine := db.Eloquent.Master()
+	session := engine.NewSession()
+	defer session.Close()
+	custOrderStatusDao := dal.NewCustOrderStatusDAO(session, user.PlantNr, user.UserId)
+	statusHistoryDao := dal.NewCustOrderStatusHistoryDAO(session, user.PlantNr, user.UserId)
+	custOrderDao := dal.NewCustOrderDAO(session, user.PlantNr, user.UserId)
+	statusLi, err := custOrderStatusDao.Select([]grmi.Predicate{
+		meta.CustOrderStatus_Status.NewPredicate(grmi.Equal, baseModel.WO_STATUS_RELEASE_FAILED),
+	}, nil)
+	if err != nil {
+		return grmi.NewBusinessError("查询客户订单数据失败, 错误:" + err.Error())
+	}
+	if len(statusLi) == 0 {
+		return grmi.NewBusinessError("不存在派工失败的客户订单, 错误:" + err.Error())
+	}
+	channel, exist := common.ReleaseTaskChannel[user.PlantNr]
+	if !exist {
+		return grmi.NewBusinessError("该工厂任务队列不存在, 请联系软件供应商")
+	}
+	if err = session.Begin(); err != nil {
+		return grmi.NewBusinessError("开启事务失败, 错误:" + err.Error())
+	}
+	for _, status := range statusLi {
+		statusHistory := model.CustOrderStatusHistory{
+			CustOrderId: status.CustOrderId,
+			StatusChangeType: model.STATUS_CHANGE_TYPE_RELEASE,
+			FromStatus: status.Status,
+			ToStatus: baseModel.WO_STATUS_LOCKED,
+			ChangeTime: grmi.DateTime(time.Now()),
+			TriggerPara1: "修复派工任务",
+		}
+		err = statusHistoryDao.InsertOne(&statusHistory)
+		if err != nil {
+			_ = session.Rollback()
+			return grmi.NewBusinessError("保存客户订单状态变更历史失败， 错误:" + err.Error())
+		}
+		status.Status = baseModel.WO_STATUS_LOCKED
+		 err = custOrderStatusDao.UpdateOne(&status)
+		if err != nil {
+			_ = session.Rollback()
+			return grmi.NewBusinessError("更新客户订单状态失败， 错误:" + err.Error())
+		}
+	}
+	err = channel.ResetChannel()
+	if err != nil {
+		_ = session.Rollback()
+		return grmi.NewBusinessError("刷新任务队列失败")
+	}
+	custOrderLi, err := custOrderDao.SelectNeedReleaseCustOrder()
+	if err != nil {
+		_ = session.Rollback()
+		return grmi.NewBusinessError("查询需要派工的客户订单失败, 错误:" + err.Error())
+	}
+	for _, custOrder := range custOrderLi {
+		err = channel.SendData(custOrder)
+		if err != nil {
+			_ = session.Rollback()
+			return grmi.NewBusinessError("向队列发送数据失败, 错误:" + err.Error())
+		}
+	}
+	_ = session.Commit()
+	go impl.ReleasePlantTask(user)
+	return nil
+
+}

task/ApsRelease.go

@@ -2,12 +2,12 @@ package task
 
 import (
 	"LAPP_ACURA_MOM_BACKEND/common"
-	plnModel "LAPP_ACURA_MOM_BACKEND/models/pln"
+	"LAPP_ACURA_MOM_BACKEND/models/channel"
 	"LAPP_ACURA_MOM_BACKEND/services/pln"
 )
 
 func StartApsRelease() error {
-	common.ReleaseTaskChannel = make(map[int]chan plnModel.CustOrder)
+	common.ReleaseTaskChannel = make(map[int]*channel.ReleaseTaskChannel)
 	custSvr := pln.NewCustOrderService()
 	err := custSvr.ReleaseTask()
 	return err

web/controllers/pln/CustOrder.rest.go

@@ -826,4 +826,74 @@ func RegisterAnalysisExcelToCustOrder(party router.Party, path string, method fu
 		}
 		supports.Ok(ctx, supports.OptionSuccess, nil)
 	})
+}
+
+/******************************************************************************
+ *
+ * @Function Name            : RegisterSelectReleaseCustOrder
+ *-----------------------------------------------------------------------------
+ *
+ * @Description              : 查询派工任务
+ *
+ * @Function Parameters      : 路由分组
+ *
+ * @Function Parameters      : 路径
+ *
+ * @Function Parameters      : 实际处理请求的方法
+ *
+ * @Author                   : 代码生成器创建
+ *
+ * @Date                     : 2022-03-08
+ *
+ ******************************************************************************/
+func RegisterSelectReleaseCustOrder(party router.Party, path string, method func(user *global.User) ([]model.CustOrder, error)) {
+
+	party.Get(path, func(ctx iris.Context) {
+		user, ok := jwts.ParseToken(ctx)
+		if !ok {
+			return
+		}
+		data, err := method(user)
+		if err != nil {
+			supports.Error(ctx, iris.StatusBadRequest, err.Error(), nil)
+			return
+		}
+		supports.Ok(ctx, supports.OptionSuccess, data)
+	})
+}
+
+
+
+/******************************************************************************
+ *
+ * @Function Name            : RegisterSelectReleaseCustOrder
+ *-----------------------------------------------------------------------------
+ *
+ * @Description              : 查询派工任务
+ *
+ * @Function Parameters      : 路由分组
+ *
+ * @Function Parameters      : 路径
+ *
+ * @Function Parameters      : 实际处理请求的方法
+ *
+ * @Author                   : 代码生成器创建
+ *
+ * @Date                     : 2022-03-08
+ *
+ ******************************************************************************/
+func RegisterRepairReleaseFailedTask(party router.Party, path string, method func(user *global.User) error) {
+
+	party.Get(path, func(ctx iris.Context) {
+		user, ok := jwts.ParseToken(ctx)
+		if !ok {
+			return
+		}
+		err := method(user)
+		if err != nil {
+			supports.Error(ctx, iris.StatusBadRequest, err.Error(), nil)
+			return
+		}
+		supports.Ok(ctx, supports.OptionSuccess, nil)
+	})
 }

web/controllers/pln/pln.go

@@ -138,6 +138,10 @@ func RegisterRoutes() {
 		RegisterSplitOrderQty(custorder, "/split", serviceOfCustOrder.SplitOrderQty)
 		// 解析excel生成客户订单
 		RegisterAnalysisExcelToCustOrder(custorder, "/analysisexcel", serviceOfCustOrder.AnalysisPlanFromExcel)
+		// 查询所有派工未完成和派工失败的任务
+		RegisterSelectReleaseCustOrder(custorder, "/releasetask", serviceOfCustOrder.SelectReleaseTask)
+		// 修复派工失败
+		RegisterRepairReleaseFailedTask(custorder, "/repairrelease", serviceOfCustOrder.RepairReleaseFailedTask)
 
 		// CustOrderStatus的路由组
 		custorderstatus := party.Party("/custorderstatus")