LAPP_SJA_APS_BACKEND/seq/Scheduler.go

package seq

import (
	"fmt"
	"leit.com/leit_seat_aps/common"
	"leit.com/leit_seat_aps/db"
	"leit.com/leit_seat_aps/glog"
	"leit.com/leit_seat_aps/service"
	"strings"
	"time"
)

/**
基于产线排序派工下达逻辑
1. 按产线启动 Go Routine
2. 按产线加载未下达已计划的生产订单
3. 对于非混线的产线，按照指定规则对订单队列排序（按SEQ或SWET）
4. 按照产线指定规则下达生产订单并同步更新客户订单状态
**/
func RunScheduler() (err error) {
	var (
		se    service.SchedEngine
		bl_wl service.BL_Workline
		i     int
	)

	se = service.SchedEngine{}
	se.PlanMode = common.LINE_PLAN_IN_SEQ
	se.LineTypes = append(se.LineTypes, "A", "M", "V")

	// 加载排序产线
	if err = se.LoadMasterData(); err != nil {
		return
	}

	// 按产线启动排序派工服务
	for i = 0; i < len(se.Wltablst); i++ {
		fmt.Println("Start line:", bl_wl.WorklineId, " schedule service!")
		bl_wl = service.BL_Workline{}
		bl_wl.PickTmpDict = make(map[string]service.BL_PickingTemplate)
		bl_wl.WorklineId = se.Wltablst[i].Worklineid
		bl_wl.SortMode = se.Wltablst[i].Taskqueuesortway
		if se.Wltablst[i].Multiqueuemixsort == 1 {
			bl_wl.MixSort = true
			bl_wl.MixSortMode = se.Wltablst[i].Taskqueuemixsortway
			bl_wl.MixSortRule = se.Wltablst[i].Mixsortlogic
		} else {
			bl_wl.MixSort = false
		}
		bl_wl.ReleaseMode = se.Wltablst[i].Taskreleaseway
		bl_wl.ReleaseValue = se.Wltablst[i].Releaseparameter
		bl_wl.Worklinetab = se.Wltablst[i]

		go ScheduleTaskToRelease(bl_wl, &se)
	}

	// 循环避免主函数退出
	for {
		time.Sleep(1 * time.Hour)
	}

	return
}

// 产线的排序派工服务
// 1. 读取调度到产线的生产订单，状态 = 20
// 2. 按照 swet 和 Oemseq 排序
// 3. 根据指定规则下达生产订单
func ScheduleTaskToRelease(bl_wl service.BL_Workline, se *service.SchedEngine) {
	var (
		err      error
		workline db.Workline
	)
	// 循环加载产线的待派工的任务，并依次处理
	for {
		//查询产线信息
		if workline, err = bl_wl.SelectWorkline(); err != nil {
			glog.InfoExtln("排序调度", "LoadPlannedTask err: ", err)
			// 报错并返回
			return
		}
		bl_wl.SortMode = workline.Taskqueuesortway
		if workline.Multiqueuemixsort == 1 {
			bl_wl.MixSort = true
			bl_wl.MixSortMode = workline.Taskqueuemixsortway
			bl_wl.MixSortRule = workline.Mixsortlogic
		} else {
			bl_wl.MixSort = false
		}
		bl_wl.ReleaseMode = workline.Taskreleaseway
		bl_wl.ReleaseValue = workline.Releaseparameter
		bl_wl.Worklinetab = workline
		// 基于产线的派工策略获取派工订单
		bl_wolst := make([]service.BL_WorkOrder,0)
		switch bl_wl.ReleaseMode {
		case common.LINE_REL_BY_QTY:
			if bl_wolst,err = bl_wl.GetTaskToReleaseByQty(); err != nil {
				glog.InfoExtln("排序调度", "GetTaskToReleaseByQty1 err: ", err)
				errstr := err.Error()
				if ok := strings.Contains(errstr, "mssql: Transaction (Process ID"); ok {
					glog.InfoExtln("排序调度", "GetTaskToReleaseByQty2 err: ", err)
					time.Sleep(5 * time.Second)
					continue
				}
				// 报错并返回
				return
			}
			// 派工订单
			if err = bl_wl.ReleaseTasks(bl_wolst, se); err != nil {
				glog.InfoExtln("排序调度", "ReleaseTasks err: ", err)
				errstr := err.Error()
				if ok := strings.Contains(errstr, "mssql: Transaction (Process ID"); ok {
					time.Sleep(1 * time.Second)
					continue
				}
				// 报错并返回
				return
			}
		case common.LINE_REL_BY_OEMSEQ:
			if bl_wolst,err = bl_wl.GetTaskToReleaseByTime(); err != nil {
				glog.InfoExtln("排序调度", "GetTaskToReleaseByTime err: ", err)
				// 报错并返回
				return
			}
			// 派工订单
			if err = bl_wl.ReleaseTasks(bl_wolst, se); err != nil {
				glog.InfoExtln("排序调度", "ReleaseTasks err: ", err)
				errstr := err.Error()
				if ok := strings.Contains(errstr, "mssql: Transaction (Process ID"); ok {
					time.Sleep(1 * time.Second)
					continue
				}
				// 报错并返回
				return
			}
		case common.LINE_REL_BY_DURATION:
			if err = bl_wl.GetTaskToReleaseByDuration(&bl_wolst); err != nil {
				glog.InfoExtln("排序调度", "GetTaskToReleaseByDuration err: ", err)
				// 报错并返回
				return
			}
			// 派工订单
			if err = bl_wl.ReleaseTasks(bl_wolst, se); err != nil {
				glog.InfoExtln("排序调度", "ReleaseTasks err: ", err)
				errstr := err.Error()
				if ok := strings.Contains(errstr, "mssql: Transaction (Process ID"); ok {
					time.Sleep(1 * time.Second)
					continue
				}
				// 报错并返回
				return
			}
		}

		time.Sleep(2 * time.Second)
	}
}