提交订单解析代码

main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"LAPP_GAAS_GFrame_BACKEND/conf"
 	"LAPP_GAAS_GFrame_BACKEND/db"
+	"LAPP_GAAS_GFrame_BACKEND/scheduler"
 	"LAPP_GAAS_GFrame_BACKEND/task"
 	"LAPP_GAAS_GFrame_BACKEND/utils"
 	"LAPP_GAAS_GFrame_BACKEND/web/middleware/glog"
@@ -117,6 +118,10 @@ func imain() {
 	//注册服务
 	//go etcd.Etcdrun()
 
+	err = scheduler.Start()
+	if err != nil {
+		log.Fatal("scheduler start failed, error: " + err.Error())
+	}
 	//开启定时任务,生产维护工单
 	go task.CreateTask()
 
@@ -124,4 +129,3 @@ func imain() {
 	app.Run(iris.Addr(":8093"), iris.WithConfiguration(conf.C))
 
 }
-

models/om/DemendHead.go

@@ -0,0 +1,10 @@
+package om
+
+const (
+	WO_STATUS_PLANNED    = 0 // 未上线
+	WO_STATUS_RUNNING1   = 1 // 已上线
+	WO_STATUS_RUNNING2   = 2 // 已目视
+	WO_STATUS_FINISHED1  = 3 // 打包
+	WO_STATUS_FINISHED2  = 4 // 总打包
+	WO_STATUS_DISPATCHED = 5 // 已发运
+)

scheduler/ParseDemand.go

@@ -0,0 +1,5 @@
+package scheduler
+
+func ParseDemandFile() {
+	demandHeadDao :=
+}

scheduler/scheduler.go

@@ -0,0 +1,16 @@
+package scheduler
+
+import (
+	"github.com/robfig/cron"
+)
+
+func Start() error {
+		c := cron.New()
+		err := c.AddFunc("*/10 * * * * ?", ParseDemandFile)
+		if err != nil {
+			return err
+		}
+		c.Start()
+		select {}
+}
+

services/om/implments/DemandHead.service.impl.go

@@ -3,12 +3,20 @@
 package implments
 
 import (
+	logDal "LAPP_GAAS_GFrame_BACKEND/dao/log"
 	dal "LAPP_GAAS_GFrame_BACKEND/dao/om"
 	"LAPP_GAAS_GFrame_BACKEND/db"
 	"LAPP_GAAS_GFrame_BACKEND/grmi"
+	logMeta "LAPP_GAAS_GFrame_BACKEND/meta/log"
 	meta "LAPP_GAAS_GFrame_BACKEND/meta/om"
+	baseModel "LAPP_GAAS_GFrame_BACKEND/models/base"
+	logModel "LAPP_GAAS_GFrame_BACKEND/models/log"
 	model "LAPP_GAAS_GFrame_BACKEND/models/om"
+	"LAPP_GAAS_GFrame_BACKEND/utils"
 	"LAPP_GAAS_GFrame_BACKEND/web/models"
+	"github.com/360EntSecGroup-Skylar/excelize"
+	"strconv"
+	"time"
 )
 
 /******************************************************************************
@@ -323,3 +331,393 @@ func (impl *DemandHeadServiceImplement) Update(user *models.Usertab, entities *[
 	}
 	return nil
 }
+
+func (impl *DemandHeadServiceImplement) UploadExcel(user *models.Usertab, filepath string) error {
+	engine := db.Eloquent.Master()
+	session := engine.NewSession()
+	defer session.Close()
+	err := session.Begin()
+	if err != nil {
+		return err
+	}
+	demandHeadDao := dal.NewDemandHeadDAO(session, user.Pid, user.Userid)
+
+	file, err := excelize.OpenFile(filepath)
+	if err != nil {
+		return err
+	}
+	rowsIterator, err := file.Rows("sheet1")
+	if err != nil {
+		return err
+	}
+	demandLi := make([]model.DemandHead, 0, 100)
+	for rowsIterator.Next() {
+		var demandHead model.DemandHead
+		demandHead.PlantNr = user.Pid
+		row := rowsIterator.Columns()
+		for index, colCell := range row {
+			switch index {
+			case 0:
+				demandHead.DemandId = colCell
+			case 1:
+				demandHead.BarCode = colCell
+			case 2:
+				demandHead.BarCodeDesc = colCell
+			case 3:
+				demandHead.PartCode = colCell
+			case 4:
+				demandTime, err := time.Parse("2006-01-02 15:04:05.000", colCell)
+				if err != nil {
+					return grmi.NewBusinessError("plan_dttm时间解析错误: " + err.Error())
+				}
+				demandHead.PlanDttm = grmi.DateTime(demandTime)
+			case 5:
+				demandHead.Class1 = colCell
+			case 6:
+				demandHead.ConfigKey = colCell
+			case 7:
+				seq, err := strconv.Atoi(colCell)
+				if err != nil {
+					return grmi.NewBusinessError("seq value type error: " + err.Error())
+				}
+				demandHead.Seq = seq
+			case 8:
+				state, err := strconv.Atoi(colCell)
+				if err != nil {
+					return grmi.NewBusinessError("state value type error: " + err.Error())
+				}
+				demandHead.State = state
+			case 9:
+				demandHead.StateName = colCell
+			case 10:
+				demandHead.StationCode = colCell
+			case 11:
+				demandHead.StationDesc = colCell
+			case 12:
+				creatTime, err := time.Parse("2006-01-02 15:04:05.000", colCell)
+				if err != nil {
+					return grmi.NewBusinessError("create_time解析错误: " + err.Error())
+				}
+				demandHead.DemandCreateTime = grmi.DateTime(creatTime)
+			case 13:
+				if colCell == "" {
+					demandHead.IsRefreshToggle = false
+				} else {
+					demandHead.IsRefreshToggle = true
+				}
+			case 14:
+				serial, err := strconv.Atoi(colCell)
+				if err != nil {
+					return grmi.NewBusinessError("serial value type error: " + err.Error())
+				}
+				demandHead.Serial = serial
+			case 15:
+				demandHead.CustomId = colCell
+			case 16:
+				if colCell != "" {
+					logTime, err := time.Parse("2006-01-02 15:04:05.000", colCell)
+					if err != nil {
+						return grmi.NewBusinessError("log_time解析错误: " + err.Error())
+					}
+					demandHead.LogTime = grmi.DateTime(logTime)
+				}
+			case 17:
+				demandHead.CodeBar = colCell
+			case 18:
+				demandHead.Memo = colCell
+			}
+		}
+		demandLi = append(demandLi, demandHead)
+	}
+	session.Commit()
+	return nil
+}
+
+func (impl *DemandHeadServiceImplement) dealDemandDateLi() error {
+	engine := db.Eloquent.Master()
+	session := engine.NewSession()
+	defer session.Close()
+	err := session.Begin()
+	if err != nil {
+		return err
+	}
+	var pid int
+	var userId string
+	var demandHeadLi []model.DemandHead
+	demandHeadDao := dal.NewDemandHeadDAO(session, pid, userId)
+	workOrderDao := dal.NewWorkOrderDAO(session, pid, userId)
+	workOrderStatusDao := dal.NewWorkOrderStatusDAO(session, pid, userId)
+	workOrderStatusRecDao := dal.NewWorkOrderStatusRecLstDAO(session, pid, userId)
+	workOrderQtyDao := dal.NewWorkOrderQtyDAO(session, pid, userId)
+	workOrderQtyRecDao := dal.NewWorkOrderQtyRecLstDAO(session, pid, userId)
+	logDemandHeadDao := logDal.NewArtDemandHeadDAO(session, pid, userId)
+	logDemandLstDao := logDal.NewArtDemandLstDAO(session, pid, userId)
+	var workOrderStatus model.WorkOrderStatus
+	var workOrderQty model.WorkOrderQty
+
+	var qty int
+	var partCode string
+	var planDttm = grmi.DateTime(time.Time{})
+	for _, demandHead := range demandHeadLi {
+
+		if partCode == "" {
+			partCode = demandHead.PartCode
+		}
+		if planDttm == grmi.DateTime(time.Time{}) {
+
+		} else {
+			if partCode != demandHead.PartCode {
+				partCode = ""
+				qty = 0
+				demandHead.PlanDttm = grmi.DateTime(time.Time{})
+				err := impl.CreateWorkOrder(user, &demandHead, qty)
+				if err != nil {
+					return err
+				}
+				continue
+			}
+		}
+		if planDttm == grmi.DateTime(time.Time{}) {
+			planDttm = demandHead.PlanDttm
+		} else {
+			if planDttm != demandHead.PlanDttm {
+				partCode = ""
+				demandHead.PlanDttm = grmi.DateTime(time.Time{})
+				qty = 0
+				workOrder, workOrderStatus, workOrderQty, err := impl.CreateWorkOrder(user, &demandHead, qty)
+				if err != nil {
+					return err
+				}
+				workOrderLi = append(workOrderLi, workOrder)
+				workOrderStatusLi = append(workOrderStatusLi, workOrderStatus)
+				workOrderQtyLi = append(workOrderQtyLi, workOrderQty)
+				continue
+			}
+		}
+		qty += 1
+
+	}
+
+	err = dao.Insert(&demandData)
+	if err != nil {
+		session.Rollback()
+		return err
+	}
+	err = workOrderDao.Insert(&workOrderLi)
+	if err != nil {
+		session.Rollback()
+		return err
+	}
+	err = workOrderStatusDao.Insert(&workOrderStatusLi)
+	if err != nil {
+		session.Rollback()
+		return err
+	}
+
+	workOrderLi
+
+}
+
+func (impl *DemandHeadServiceImplement) DealWorkOrder(user *models.Usertab,
+	demandData *model.DemandHead,
+	qty float64,
+	workOrderDao dal.WorkOrderDAO,
+	workOrderStatusDao dal.WorkOrderStatusDAO,
+	workOrderStatusRecDao dal.WorkOrderStatusRecLstDAO,
+	workOrderQtyDao dal.WorkOrderQtyDAO,
+	workOrderQtyRecDao dal.WorkOrderQtyRecLstDAO,
+	stateCode int) (workOrder model.WorkOrder, workOrderStatus model.WorkOrderStatus, workOrderQty model.WorkOrderQty, err error) {
+	workOrderLi, err := workOrderDao.Select([]grmi.Predicate{meta.WorkOrder_PlanResourceId.NewPredicate(grmi.Equal, demandData.PartCode), meta.WorkOrder_PlanEndTime.NewPredicate(grmi.Equal, demandData.PlanDttm)}, []grmi.Field{meta.WorkOrder_PlantNr})
+
+	if err != nil {
+		return workOrder, workOrderStatus, workOrderQty, err
+	}
+	var localStateCode int
+	if len(workOrderLi) != 0 {
+		workOrder = workOrderLi[0]
+		workOrderStatusPoint, err := workOrderStatusDao.SelectOne(workOrder.WorkOrderId)
+		if err != nil {
+			return workOrder, workOrderStatus, workOrderQty, err
+		}
+		if workOrderStatusPoint == nil {
+			return workOrder, workOrderStatus, workOrderQty, grmi.NewBusinessError("存在workOrder,不存在对应的workOrderStatus, workOrderId: " + workOrder.WorkOrderId)
+		}
+		workOrderStatus = *workOrderStatusPoint
+		workOrderQtyPoint, err := workOrderQtyDao.SelectOne(workOrder.WorkOrderId)
+		if err != nil {
+			return workOrder, workOrderStatus, workOrderQty, err
+		}
+		if workOrderQtyPoint == nil {
+			return workOrder, workOrderStatus, workOrderQty, grmi.NewBusinessError("存在workOrder,不存在对应的workOrderQty, workOrderId: " + workOrder.WorkOrderId)
+		}
+		workOrderQty = *workOrderQtyPoint
+		if stateCode == model.WO_STATUS_PLANNED {
+			localStateCode = baseModel.WO_STATUS_PLANNED
+		} else if stateCode == model.WO_STATUS_RUNNING1 || stateCode == model.WO_STATUS_RUNNING2 {
+			localStateCode = baseModel.WO_STATUS_RUNNING
+		} else if stateCode == model.WO_STATUS_FINISHED1 || stateCode == model.WO_STATUS_FINISHED2 {
+			localStateCode = baseModel.WO_STATUS_FINISHED
+		} else if stateCode == model.WO_STATUS_DISPATCHED {
+			localStateCode = baseModel.WO_STATUS_DISPATCHED
+		} else {
+			return workOrder, workOrderStatus, workOrderQty, grmi.NewBusinessError("需求订单状态不支持, state: " + strconv.Itoa(stateCode))
+		}
+		if workOrderStatus.Status != localStateCode {
+
+			var workOrderStatusRec model.WorkOrderStatusRecLst
+			workOrderStatusRec.WorkOrderId = workOrder.WorkOrderId
+			workOrderStatusRec.PrevStatus = workOrderStatus.Status
+			workOrderStatusRec.Status = localStateCode
+			err = workOrderStatusRecDao.InsertOne(&workOrderStatusRec)
+			if err != nil {
+				return
+			}
+			workOrderStatus.Status = localStateCode
+			err = workOrderStatusDao.UpdateOne(&workOrderStatus)
+			if err != nil {
+				return
+			}
+		}
+		if workOrderQty.ActQty != qty {
+			var workOrderQtyRec model.WorkOrderQtyRecLst
+			workOrderQtyRec.WorkOrderId = workOrder.WorkOrderId
+			workOrderQtyRec.ActQty = qty
+			err = workOrderQtyRecDao.InsertOne(&workOrderQtyRec)
+			if err != nil {
+				return
+			}
+			workOrderQty.ActQty = qty
+			err = workOrderQtyDao.UpdateOne(&workOrderQty)
+			if err != nil {
+				return
+			}
+		}
+	} else {
+		snr := new(models.Snrtab)
+		snr.Finr = user.Pid
+		workOrderId, err := snr.GetNextSnr("WorkOrder")
+		if err != nil {
+			return workOrder, workOrderStatus, workOrderQty, err
+		}
+		endTime := demandData.PlanDttm.Restore()
+		endDate := endTime.Format("2006-01-02")
+		planStartTimeStr := endDate + " 00:00:00"
+		planEndTimeStr := endDate + " 23:59:59"
+		planStartTime, _ := time.ParseInLocation("2006-01-02 15:04:05", planStartTimeStr, utils.TimezoneLocation)
+		planEndTime, _ := time.ParseInLocation("2006-01-02 15:04:05", planEndTimeStr, utils.TimezoneLocation)
+		workOrder = model.WorkOrder{
+			WorkOrderId:       workOrderId,
+			ArtId:             demandData.PartCode,
+			OrderType:         "SEQ",
+			PlanQty:           qty,
+			QtyUomId:          "",
+			RatePerHourToggle: true,
+			PlanStartDate:     grmi.Date(demandData.PlanDttm),
+			PlanEndDate:       grmi.Date(demandData.PlanDttm),
+			PlanStartTime:     grmi.DateTime(planStartTime),
+			PlanEndTime:       grmi.DateTime(planEndTime),
+		}
+		workOrderStatus = model.WorkOrderStatus{
+			WorkOrderId: workOrderId,
+			Status:      localStateCode,
+		}
+		workOrderQty = model.WorkOrderQty{
+			WorkOrderId: workOrderId,
+			PlanQty:     qty,
+		}
+		err = workOrderDao.InsertOne(&workOrder)
+		if err != nil {
+			return
+		}
+		err = workOrderStatusDao.InsertOne(&workOrderStatus)
+		if err != nil {
+			return
+		}
+		err = workOrderQtyDao.InsertOne(&workOrderQty)
+		if err != nil {
+			return
+		}
+	}
+	return workOrder, workOrderStatus, workOrderQty, nil
+}
+
+func (impl *DemandHeadServiceImplement) DealArtDemand(user models.Usertab,
+	demandHeadLi []model.DemandHead,
+	workOrder model.WorkOrder,
+	workOrderStatus model.WorkOrderStatus,
+	workOrderQty model.WorkOrderQty,
+	artDemandHeadDao logDal.ArtDemandHeadDAO,
+	artDemandLstDao logDal.ArtDemandLstDAO) (err error) {
+	status := workOrderStatus.Status
+	if status == baseModel.WO_STATUS_PLANNED || status == baseModel.WO_STATUS_LOCKED || status == baseModel.WO_STATUS_RELEASED || status == baseModel.WO_STATUS_INTERRUPT || status == baseModel.WO_STATUS_RUNNING {
+		predicates := []grmi.Predicate{logMeta.ArtDemandHead_ArtId.NewPredicate(grmi.Equal, workOrder.ArtId), logMeta.ArtDemandHead_DemandTime.NewPredicate(grmi.Equal, workOrder.PlanEndTime)}
+		fields := []grmi.Field{logMeta.ArtDemandHead_PlantNr}
+		artDemandHead, err := artDemandHeadDao.Select(predicates, fields)
+		if err != nil {
+			return err
+		}
+		var demandId string
+		demandTime := workOrder.PlanEndTime.Restore()
+		weekIndex := utils.ParseWeekIndex(demandTime)
+		if len(artDemandHead) == 0 {
+			snr := new(models.Snrtab)
+			snr.Finr = user.Pid
+			demandId, err = snr.GetNextSnr("ArtDemandHead")
+			if err != nil {
+				return err
+			}
+			artDemandHead := logModel.ArtDemandHead{
+				DemandId:    demandId,
+				ArtId:       workOrder.ArtId,
+				DemandType:  "byDay",
+				DemandYear:  demandTime.Year(),
+				DemandMonth: int(demandTime.Month()),
+				DemandWeek:  weekIndex,
+				DemandTime:  workOrder.PlanEndTime,
+				DemandDate:  grmi.Date(demandTime),
+				DemandQty:   workOrderQty.PlanQty,
+				Status:      workOrderStatus.Status,
+				QtyUomId:    "",
+			}
+			err = artDemandHeadDao.InsertOne(&artDemandHead)
+			if err != nil {
+				return err
+			}
+
+		} else {
+			artDemandHead := artDemandHead[0]
+			artDemandHead.Status = workOrderStatus.Status
+			artDemandHead.DemandQty = workOrderQty.PlanQty
+			err = artDemandHeadDao.UpdateOne(&artDemandHead)
+			if err != nil {
+				return err
+			}
+			err = artDemandLstDao.DeleteWhere([]grmi.Predicate{logMeta.ArtDemandLst_DemandId.NewPredicate(grmi.Equal, demandId)})
+			if err != nil {
+				return err
+			}
+		}
+		artDemandLstLi := make([]logModel.ArtDemandLst, 0, len(demandHeadLi))
+		for range demandHeadLi {
+			artDemandLst := logModel.ArtDemandLst{
+				DemandId:    demandId,
+				ArtId:       workOrder.ArtId,
+				DemandType:  "byDay",
+				DemandYear:  demandTime.Year(),
+				DemandMonth: int(demandTime.Month()),
+				DemandWeek:  weekIndex,
+				DemandTime:  workOrder.PlanEndTime,
+				DemandDate:  grmi.Date(demandTime),
+				DemandQty:   workOrderQty.PlanQty,
+				Status:      workOrderStatus.Status,
+				QtyUomId:    "",
+			}
+			artDemandLstLi = append(artDemandLstLi, artDemandLst)
+		}
+		err = artDemandLstDao.Insert(&artDemandLstLi)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

utils/time.go

@@ -2,6 +2,7 @@ package utils
 
 import (
 	"errors"
+	"fmt"
 	"log"
 	"math"
 	"strconv"
@@ -299,4 +300,25 @@ func TimeReturnMonth(now time.Time) (firstMonth string, lastMonth string) {
 	firstOfMonth := time.Date(currentYear, currentMonth, 1, 0, 0, 0, 0, currentLocation)
 	lastOfMonth := firstOfMonth.AddDate(0, 1, 0).Add(time.Second * -1)
 	return TimeFormat(firstOfMonth,"yyyyMMdd"), TimeFormat(lastOfMonth,"yyyyMMdd")
+}
+
+func ParseWeekIndex(date time.Time) int {
+	dateStr := date.Format("2006-01-02")
+	dateStr = dateStr[:8] + "01"
+	firstDay, _ := time.Parse("2006-01-02", dateStr)
+	firstWeekDay := firstDay.Weekday()
+	weekDay := date.Weekday()
+	fmt.Println("first day:", firstDay)
+	for i:=1; i < 6; i++ {
+		fmt.Println("i:", i)
+		date = date.AddDate(0, 0, -7)
+		fmt.Println("date:", date)
+		if date.Before(firstDay) {
+			if weekDay >= firstWeekDay {
+				return i
+			}
+			return i + 1
+		}
+	}
+	return 0
 }