feat: 计划调度计划

@@ -39,6 +39,9 @@ func (crontabService *CrontabService) initTask() {
 
 	autoApproveAttendanceRecord := task.NewTask("autoApproveAttendanceRecord", "0 */1 * * * *", AutoApproveProductAttendanceRecord)
 	task.AddTask("autoApproveAttendanceRecord", autoApproveAttendanceRecord)
+
+	autoApproveRecord := task.NewTask("autoApproveRecord", "0 */2 * * * *", AutoApproveProductRecord)
+	task.AddTask("autoApproveRecord", autoApproveRecord)
 }
 
 func (crontabService *CrontabService) StartCrontabTask() {

@@ -283,6 +283,32 @@ func FastPgProductPlan(transactionContext application.TransactionContext, id int
 	return rep, mod, err
 }
 
+// FastPgProductPlan  快速返回生产计划对象
+//
+// transactionContext 事务
+// id  对象唯一标识
+func FastPgProductPlanDispatchRecord(transactionContext application.TransactionContext, id int, options ...option) (domain.ProductPlanDispatchRecordRepository, *domain.ProductPlanDispatchRecord, error) {
+	var rep domain.ProductPlanDispatchRecordRepository
+	var mod *domain.ProductPlanDispatchRecord
+	var err error
+	if value, err := CreateProductPlanDispatchRecordRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	} else {
+		rep = value
+	}
+	if id > 0 {
+		if mod, err = rep.FindOne(map[string]interface{}{"productPlanDispatchRecordId": id}); err != nil {
+			if err == domain.ErrorNotFound {
+				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该生产计划调度记录不存在")
+			}
+			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+		}
+	}
+	return rep, mod, err
+}
+
 // FastPgAttendance  快速返回考勤记录
 //
 // transactionContext 事务

@@ -109,3 +109,11 @@ func CreateWorkshopWorkTimeRecordRepository(options map[string]interface{}) (dom
 	}
 	return repository.NewWorkshopWorkTimeRecordRepository(transactionContext)
 }
+
+func CreateProductPlanDispatchRecordRepository(options map[string]interface{}) (domain.ProductPlanDispatchRecordRepository, error) {
+	var transactionContext *pg.TransactionContext
+	if value, ok := options["transactionContext"]; ok {
+		transactionContext = value.(*pg.TransactionContext)
+	}
+	return repository.NewProductPlanDispatchRecordRepository(transactionContext)
+}

@@ -10,7 +10,7 @@ import (
 
 type SetOfflineCommand struct {
 	// 生产计划ID
-	ProductPlanId int `cname:"生产计划ID" json:"productPlanId" valid:"Required"`
+	ProductPlanId int `cname:"生产计划ID" json:"productPlanDispatchRecordId" valid:"Required"`
 }
 
 func (setOfflineCommand *SetOfflineCommand) Valid(validation *validation.Validation) {

@@ -14,7 +14,7 @@ type SetOnlineCommand struct {
 	// 车间ID
 	WorkshopId int `cname:"车间ID" json:"workshopId" valid:"Required"`
 	// 生产线ID
-	//LineId int `cname:"生产线ID" json:"lineId" valid:"Required"`
+	LineId int `cname:"生产线ID" json:"lineId" valid:"Required"`
 	// 工段ID
 	SectionId int `cname:"工段ID" json:"sectionId" valid:"Required"`
 }

@@ -9,8 +9,8 @@ import (
 )
 
 type SwitchCommand struct {
-	// 下线计划ID
-	FromProductPlanId int `cname:"下线计划ID" json:"fromProductPlanId,omitempty"`
+	// 下线计划调度ID
+	FromProductPlanDispatchRecordId int `cname:"下线计划ID" json:"fromProductPlanId,omitempty"`
 	// 上线计划ID
 	ToProductPlanId int `cname:"上线计划ID" json:"toProductPlanId,omitempty"`
 }

+package dto
+
+import (
+	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/domain"
+	"strings"
+)
+
+type ProductPlanDispatchRecordDto struct {
+	// 生产计划ID
+	ProductPlanId int `json:"productPlanId,omitempty"`
+	// 批号
+	BatchNumber string `json:"batchNumber,omitempty"`
+	// 生产日期
+	ProductDate string `json:"productDate,omitempty"`
+	// 车间
+	//*domain.Workshop
+	*domain.WorkStation
+	// 上班班次 1:全天  2：白班 4：中班  8：夜班
+	WorkOn int `json:"workOn,omitempty"`
+	// 上班班次描述
+	WorkOnDescription string `json:"workOnDescription"`
+	// 机台 （A、B、C、D 区分机器大小）
+	Machine string `json:"machine,omitempty"`
+	// 计划的产品名称
+	PlanProductName string `json:"planProductName,omitempty"`
+	// 计划投入
+	*domain.UnitQuantity
+	// 计划状态 （1：上线 2：下线  默认下线）
+	PlanDispatchStatus int `json:"planDispatchStatus,omitempty"`
+	// 工作位置
+	//WorkStation *WorkStation `json:"workStation,omitempty"`
+	// 总产能
+	//TotalProduct float64 `json:"totalProduct"`
+	// 备注
+	Remark string `json:"remark,omitempty"`
+	// 组织名称
+	OrgName string `json:"orgName"`
+	// 权限标识 （当前登录组织匹配为true,否则false）
+	AuthFlag bool `json:"authFlag"`
+}
+
+func (d *ProductPlanDispatchRecordDto) LoadDto(m *domain.ProductPlanDispatchRecord, orgId int) *ProductPlanDispatchRecordDto {
+	d.ProductPlanId = m.ProductPlanDispatchRecordId
+	d.BatchNumber = m.BatchNumber
+	d.ProductDate = m.ProductDate.Format("2006/01/02")
+	d.WorkStation = m.WorkStation
+	d.WorkOn = m.PlanDispatchRecordExt.WorkOn
+	d.PlanProductName = m.PlanDispatchRecordExt.PlanProductName
+	//d.UnitQuantity = m.PlanDevoted
+	d.PlanDispatchStatus = m.PlanDispatchStatus
+	//d.TotalProduct = 0
+	d.Machine = m.PlanDispatchRecordExt.Machine
+	d.Remark = m.PlanDispatchRecordExt.Remark
+	d.AuthFlag = domain.CheckOrgAuth(orgId, m.OrgId)
+	if m.Ext != nil {
+		d.OrgName = m.Ext.OrgName
+	}
+	workOnDesc := domain.WorkOnDescription(m.PlanDispatchRecordExt.WorkOn)
+	d.WorkOnDescription = strings.Join(workOnDesc, ",")
+	return d
+}

@@ -12,6 +12,7 @@ import (
 	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/domain"
 	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/infrastructure/domainService"
 	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/infrastructure/utils"
+	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/log"
 	"time"
 )
 
@@ -340,9 +341,9 @@ func (productPlanService *ProductPlanService) SetOffline(setOfflineCommand *comm
 		transactionContext.RollbackTransaction()
 	}()
 
-	var productPlanRepository domain.ProductPlanRepository
-	var productPlan *domain.ProductPlan
-	productPlanRepository, productPlan, _ = factory.FastPgProductPlan(transactionContext, setOfflineCommand.ProductPlanId)
+	var productPlanRepository domain.ProductPlanDispatchRecordRepository
+	var productPlan *domain.ProductPlanDispatchRecord
+	productPlanRepository, productPlan, _ = factory.FastPgProductPlanDispatchRecord(transactionContext, setOfflineCommand.ProductPlanId)
 
 	if err = productPlan.ChangeStatus(domain.PlanOffline); err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
@@ -373,45 +374,32 @@ func (productPlanService *ProductPlanService) SetOnline(cmd *command.SetOnlineCo
 	defer func() {
 		transactionContext.RollbackTransaction()
 	}()
-	var productPlanRepository domain.ProductPlanRepository
-	var productPlan *domain.ProductPlan
 
-	productPlanRepository, productPlan, err = factory.FastPgProductPlan(transactionContext, cmd.ProductPlanId)
-	if err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
-
-	if err = productPlan.ChangeStatus(domain.PlanOnline); err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
-
-	var workshop *domain.Workshop
-	_, workshop, err = factory.FastPgWorkshop(transactionContext, cmd.WorkshopId)
-	if err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
+	var productPlan *domain.ProductPlan
 
-	line, section, err := workshop.FindSectionById(cmd.SectionId)
+	_, productPlan, err = factory.FastPgProductPlan(transactionContext, cmd.ProductPlanId)
 	if err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
 
 	var workStation *domain.WorkStation
-	workStation, err = workshop.FindWorkStation(workshop.WorkshopId, line.LineId, section.SectionId)
+	_, workStation, err = factory.FastPgWorkstation(transactionContext, cmd.WorkshopId, cmd.LineId, cmd.SectionId)
 	if err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
 
-	productPlan.WorkStation = workStation
+	var productPlanDispatch *domain.ProductPlanDispatchRecord
+	productPlanDispatch = domain.NewProductPlanDispatchRecord(productPlan, workStation)
 
-	if productPlan, err = productPlanRepository.Save(productPlan); err != nil {
+	var productPlanDispatchRepository, _, _ = factory.FastPgProductPlanDispatchRecord(transactionContext, 0)
+	if productPlanDispatch, err = productPlanDispatchRepository.Save(productPlanDispatch); err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
 
 	if err := transactionContext.CommitTransaction(); err != nil {
 		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
 	}
-	return productPlan, nil
+	return productPlanDispatch, nil
 }
 
 // 换单
@@ -429,9 +417,10 @@ func (productPlanService *ProductPlanService) Exchange(switchCommand *command.Sw
 	defer func() {
 		transactionContext.RollbackTransaction()
 	}()
-	var fromPlan, toPlan *domain.ProductPlan
-	var productPlanRepository domain.ProductPlanRepository
-	productPlanRepository, fromPlan, err = factory.FastPgProductPlan(transactionContext, switchCommand.FromProductPlanId)
+	var fromPlan *domain.ProductPlanDispatchRecord
+	var toPlan *domain.ProductPlan
+	var productPlanDispatchRecordRepository domain.ProductPlanDispatchRecordRepository
+	productPlanDispatchRecordRepository, fromPlan, err = factory.FastPgProductPlanDispatchRecord(transactionContext, switchCommand.FromProductPlanDispatchRecordId)
 	if err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
@@ -444,22 +433,18 @@ func (productPlanService *ProductPlanService) Exchange(switchCommand *command.Sw
 	if err = fromPlan.ChangeStatus(domain.PlanOffline); err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
-	if _, err = productPlanRepository.Save(fromPlan); err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
 
-	var workStation *domain.WorkStation
-	fromWorkStation := fromPlan.WorkStation
-	_, workStation, err = factory.FastPgWorkstation(transactionContext, fromWorkStation.WorkshopId, fromWorkStation.LineId, fromWorkStation.SectionId)
-	if err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	// 新的上线、如果存在一条同一个批次、工段的调度记录 则不做更新
+	if fromPlan.PlanDispatchRecordExt.ProductPlanId == toPlan.ProductPlanId && fromPlan.ProductDate == toPlan.ProductDate {
+		log.Logger.Info("换单的批次与当前批次一致,跳过")
+		return struct{}{}, nil
 	}
-	// 计划上线
-	toPlan.WorkStation = workStation
-	if err = toPlan.ChangeStatus(domain.PlanOnline); err != nil {
+
+	if _, err = productPlanDispatchRecordRepository.Save(fromPlan); err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
-	if _, err = productPlanRepository.Save(toPlan); err != nil {
+	toProductPlanDispatchRecord := domain.NewProductPlanDispatchRecord(toPlan, fromPlan.WorkStation)
+	if _, err = productPlanDispatchRecordRepository.Save(toProductPlanDispatchRecord); err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
 
@@ -554,6 +539,46 @@ func (productPlanService *ProductPlanService) SubmitProductRecord(submitProductR
 	return struct{}{}, nil
 }
 
+// 搜索生产上线计划记录
+func (productPlanService *ProductPlanService) SearchProductPlanOnlineDispatchRecord(operateInfo *domain.OperateInfo, cmd *query.SearchProductPlanQuery) (int64, interface{}, error) {
+	if err := cmd.ValidateQuery(); err != nil {
+		return 0, nil, application.ThrowError(application.ARG_ERROR, err.Error())
+	}
+	transactionContext, err := factory.CreateTransactionContext(nil)
+	if err != nil {
+		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+	}
+	if err := transactionContext.StartTransaction(); err != nil {
+		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var productPlanRepository domain.ProductPlanDispatchRecordRepository
+	if value, err := factory.CreateProductPlanDispatchRecordRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return 0, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	} else {
+		productPlanRepository = value
+	}
+	count, productPlans, err := productPlanRepository.Find(utils.ObjectToMap(cmd))
+	if err != nil {
+		return 0, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if err := transactionContext.CommitTransaction(); err != nil {
+		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+	}
+	var result = make([]*dto.ProductPlanDispatchRecordDto, 0)
+	for i := range productPlans {
+		item := productPlans[i]
+		newItem := &dto.ProductPlanDispatchRecordDto{}
+		newItem.LoadDto(item, operateInfo.OrgId)
+		result = append(result, newItem)
+	}
+	return count, result, nil
+}
+
 func NewProductPlanService(options map[string]interface{}) *ProductPlanService {
 	newProductPlanService := &ProductPlanService{}
 	return newProductPlanService

+package domain
+
+import (
+	"errors"
+	"time"
+)
+
+// 生产计划
+type ProductPlanDispatchRecord struct {
+	// 生产计划调度ID
+	ProductPlanDispatchRecordId int `json:"productPlanDispatchRecordId"`
+	// 企业id
+	CompanyId int `json:"companyId"`
+	// 组织ID
+	OrgId int `json:"orgId"`
+	// 批号
+	BatchNumber string `json:"batchNumber"`
+	// 生产日期
+	ProductDate time.Time `json:"productDate"`
+	// 计划状态 1:上线 2:下线
+	PlanDispatchStatus int `json:"planDispatchStatus"`
+	// 工作位置
+	WorkStation *WorkStation `json:"workStation"`
+	// 创建时间
+	CreatedAt time.Time `json:"createdAt"`
+	// 更新时间
+	UpdatedAt time.Time `json:"updatedAt"`
+	// 删除时间
+	DeletedAt time.Time `json:"deletedAt"`
+	// 计划调度记录扩展数据
+	PlanDispatchRecordExt *PlanDispatchRecordExt `json:"planDispatchRecordExt"`
+	// 其他扩展数据
+	Ext *Ext `json:"ext"`
+}
+
+// 计划调度记录扩展数据
+type PlanDispatchRecordExt struct {
+	// 生产计划ID
+	ProductPlanId int `json:"productPlanId,omitempty"`
+	// 计划的产品名称
+	PlanProductName string `json:"planProductName,omitempty"`
+	// 上班班次 1:全天  2：白班 4：中班  8：夜班
+	WorkOn int `json:"workOn,omitempty"`
+	// 机台 （A、B、C、D 区分机器大小）
+	Machine string `json:"machine,omitempty"`
+	// 备注
+	Remark string `json:"remark,omitempty"`
+}
+
+type ProductPlanDispatchRecordRepository interface {
+	Save(productPlanDispatchRecord *ProductPlanDispatchRecord) (*ProductPlanDispatchRecord, error)
+	Remove(productPlanDispatchRecord *ProductPlanDispatchRecord) (*ProductPlanDispatchRecord, error)
+	FindOne(queryOptions map[string]interface{}) (*ProductPlanDispatchRecord, error)
+	Find(queryOptions map[string]interface{}) (int64, []*ProductPlanDispatchRecord, error)
+}
+
+func (productPlanDispatchRecord *ProductPlanDispatchRecord) Identify() interface{} {
+	if productPlanDispatchRecord.ProductPlanDispatchRecordId == 0 {
+		return nil
+	}
+	return productPlanDispatchRecord.ProductPlanDispatchRecordId
+}
+
+func (productPlanDispatchRecord *ProductPlanDispatchRecord) Update(data map[string]interface{}) error {
+	return nil
+}
+
+func (productPlanDispatchRecord *ProductPlanDispatchRecord) ChangeStatus(status int) error {
+	if productPlanDispatchRecord.PlanDispatchStatus == status && status == PlanOnline {
+		return errors.New("计划已经上线")
+	}
+	if productPlanDispatchRecord.PlanDispatchStatus == status && status == PlanOffline {
+		return errors.New("计划已经下线")
+	}
+	if !(status == PlanOnline || status == PlanOffline) {
+		return errors.New("计划状态有误")
+	}
+	productPlanDispatchRecord.PlanDispatchStatus = status
+	return nil
+}
+
+func NewProductPlanDispatchRecord(productPlan *ProductPlan, workStation *WorkStation) *ProductPlanDispatchRecord {
+	return &ProductPlanDispatchRecord{
+		CompanyId:          productPlan.CompanyId,
+		OrgId:              productPlan.OrgId,
+		BatchNumber:        productPlan.BatchNumber,
+		ProductDate:        productPlan.ProductDate,
+		PlanDispatchStatus: PlanOnline,
+		WorkStation:        workStation,
+		CreatedAt:          time.Now(),
+		UpdatedAt:          time.Now(),
+		PlanDispatchRecordExt: &PlanDispatchRecordExt{
+			ProductPlanId:   productPlan.ProductPlanId,
+			PlanProductName: productPlan.PlanProductName,
+			WorkOn:          productPlan.WorkOn,
+			Machine:         productPlan.Machine,
+			Remark:          productPlan.Remark,
+		},
+		Ext: productPlan.Ext,
+	}
+}

@@ -37,7 +37,7 @@ func (dao *ProductRecordDao) RecentUnApprovedProductRecord(fromLastHour int, rec
 	query.Where("created_at <= ?", endTime)
 	query.Where("created_at >= ?", beginTime)
 	query.Where("product_record_type & ? >0", recordType)
-	query.Where("product_record_info->>approveStatus = '?'", domain.AttendanceNotApprove)
+	query.Where("product_record_info->>'approveStatus' = '?'", domain.AttendanceNotApprove)
 	query.Where("product_record_info->>'weighBefore'<>'0'")
 	query.SetOffsetAndLimit(domain.MaxQueryRow)
 	query.SetOrderDirect("product_record_id", "DESC")

@@ -42,6 +42,7 @@ func init() {
 			(*models.EmployeeProductRecord)(nil),
 			(*models.WorkshopProductRecord)(nil),
 			(*models.WorkshopWorkTimeRecord)(nil),
+			(*models.ProductPlanDispatchRecord)(nil),
 		} {
 			err := DB.Model(model).CreateTable(&orm.CreateTableOptions{
 				Temp:          false,

+package models
+
+import (
+	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/domain"
+	"time"
+)
+
+type ProductPlanDispatchRecord struct {
+	tableName string `comment:"生产计划" pg:"manufacture.product_plan_dispatch_record"`
+	// 生产计划调度ID
+	ProductPlanDispatchRecordId int `comment:"生产计划调度ID" pg:"pk:product_plan_dispatch_record_id"`
+	// 企业id
+	CompanyId int `comment:"企业id"`
+	// 组织ID
+	OrgId int `comment:"组织ID"`
+	// 批号
+	BatchNumber string `comment:"批号"`
+	// 生产日期
+	ProductDate time.Time `comment:"生产日期"`
+	// 计划状态 1:上线 2:下线
+	PlanDispatchStatus int `comment:"计划状态 1:上线 2:下线"`
+	// 工作位置
+	WorkStation *domain.WorkStation `comment:"工作位置"`
+	// 创建时间
+	CreatedAt time.Time `comment:"创建时间"`
+	// 更新时间
+	UpdatedAt time.Time `comment:"更新时间"`
+	// 删除时间
+	DeletedAt time.Time `comment:"删除时间"`
+	// 计划调度记录扩展数据
+	PlanDispatchRecordExt *domain.PlanDispatchRecordExt `comment:"计划调度记录扩展数据"`
+	// 其他扩展数据
+	Ext *domain.Ext `comment:"其他扩展数据"`
+}

+package transform
+
+import (
+	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/domain"
+	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/infrastructure/pg/models"
+)
+
+func TransformToProductPlanDispatchRecordDomainModelFromPgModels(productPlanDispatchRecordModel *models.ProductPlanDispatchRecord) (*domain.ProductPlanDispatchRecord, error) {
+	return &domain.ProductPlanDispatchRecord{
+		ProductPlanDispatchRecordId: productPlanDispatchRecordModel.ProductPlanDispatchRecordId,
+		CompanyId:                   productPlanDispatchRecordModel.CompanyId,
+		OrgId:                       productPlanDispatchRecordModel.OrgId,
+		BatchNumber:                 productPlanDispatchRecordModel.BatchNumber,
+		ProductDate:                 productPlanDispatchRecordModel.ProductDate,
+		PlanDispatchStatus:          productPlanDispatchRecordModel.PlanDispatchStatus,
+		WorkStation:                 productPlanDispatchRecordModel.WorkStation,
+		CreatedAt:                   productPlanDispatchRecordModel.CreatedAt,
+		UpdatedAt:                   productPlanDispatchRecordModel.UpdatedAt,
+		DeletedAt:                   productPlanDispatchRecordModel.DeletedAt,
+		PlanDispatchRecordExt:       productPlanDispatchRecordModel.PlanDispatchRecordExt,
+		Ext:                         productPlanDispatchRecordModel.Ext,
+	}, nil
+}

+package repository
+
+import (
+	"fmt"
+	"github.com/go-pg/pg/v10"
+
+	"github.com/linmadan/egglib-go/persistent/pg/sqlbuilder"
+	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
+	"github.com/linmadan/egglib-go/utils/snowflake"
+	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/domain"
+	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/infrastructure/pg/models"
+	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/infrastructure/pg/transform"
+)
+
+type ProductPlanDispatchRecordRepository struct {
+	transactionContext *pgTransaction.TransactionContext
+}
+
+func (repository *ProductPlanDispatchRecordRepository) nextIdentify() (int64, error) {
+	IdWorker, err := snowflake.NewIdWorker(1)
+	if err != nil {
+		return 0, err
+	}
+	id, err := IdWorker.NextId()
+	return id, err
+}
+func (repository *ProductPlanDispatchRecordRepository) Save(productPlanDispatchRecord *domain.ProductPlanDispatchRecord) (*domain.ProductPlanDispatchRecord, error) {
+	sqlBuildFields := []string{
+		"product_plan_dispatch_record_id",
+		"company_id",
+		"org_id",
+		"batch_number",
+		"product_date",
+		"plan_dispatch_status",
+		"work_station",
+		"created_at",
+		"updated_at",
+		"deleted_at",
+		"plan_dispatch_record_ext",
+		"ext",
+	}
+	insertFieldsSnippet := sqlbuilder.SqlFieldsSnippet(sqlbuilder.RemoveSqlFields(sqlBuildFields, "product_plan_dispatch_record_id", "deleted_at"))
+	insertPlaceHoldersSnippet := sqlbuilder.SqlPlaceHoldersSnippet(sqlbuilder.RemoveSqlFields(sqlBuildFields, "product_plan_dispatch_record_id", "deleted_at"))
+	returningFieldsSnippet := sqlbuilder.SqlFieldsSnippet(sqlBuildFields)
+	updateFields := sqlbuilder.RemoveSqlFields(sqlBuildFields, "product_plan_dispatch_record_id", "deleted_at")
+	updateFieldsSnippet := sqlbuilder.SqlUpdateFieldsSnippet(updateFields)
+	tx := repository.transactionContext.PgTx
+	if productPlanDispatchRecord.Identify() == nil {
+		if _, err := tx.QueryOne(
+			pg.Scan(
+				&productPlanDispatchRecord.ProductPlanDispatchRecordId,
+				&productPlanDispatchRecord.CompanyId,
+				&productPlanDispatchRecord.OrgId,
+				&productPlanDispatchRecord.BatchNumber,
+				&productPlanDispatchRecord.ProductDate,
+				&productPlanDispatchRecord.PlanDispatchStatus,
+				&productPlanDispatchRecord.WorkStation,
+				&productPlanDispatchRecord.CreatedAt,
+				&productPlanDispatchRecord.UpdatedAt,
+				&productPlanDispatchRecord.DeletedAt,
+				&productPlanDispatchRecord.PlanDispatchRecordExt,
+				&productPlanDispatchRecord.Ext,
+			),
+			fmt.Sprintf("INSERT INTO manufacture.product_plan_dispatch_record (%s) VALUES (%s) RETURNING %s", insertFieldsSnippet, insertPlaceHoldersSnippet, returningFieldsSnippet),
+			//productPlanDispatchRecord.ProductPlanDispatchRecordId,
+			productPlanDispatchRecord.CompanyId,
+			productPlanDispatchRecord.OrgId,
+			productPlanDispatchRecord.BatchNumber,
+			productPlanDispatchRecord.ProductDate,
+			productPlanDispatchRecord.PlanDispatchStatus,
+			productPlanDispatchRecord.WorkStation,
+			productPlanDispatchRecord.CreatedAt,
+			productPlanDispatchRecord.UpdatedAt,
+			//productPlanDispatchRecord.DeletedAt,
+			productPlanDispatchRecord.PlanDispatchRecordExt,
+			productPlanDispatchRecord.Ext,
+		); err != nil {
+			return productPlanDispatchRecord, err
+		}
+	} else {
+		if _, err := tx.QueryOne(
+			pg.Scan(
+				&productPlanDispatchRecord.ProductPlanDispatchRecordId,
+				&productPlanDispatchRecord.CompanyId,
+				&productPlanDispatchRecord.OrgId,
+				&productPlanDispatchRecord.BatchNumber,
+				&productPlanDispatchRecord.ProductDate,
+				&productPlanDispatchRecord.PlanDispatchStatus,
+				&productPlanDispatchRecord.WorkStation,
+				&productPlanDispatchRecord.CreatedAt,
+				&productPlanDispatchRecord.UpdatedAt,
+				&productPlanDispatchRecord.DeletedAt,
+				&productPlanDispatchRecord.PlanDispatchRecordExt,
+				&productPlanDispatchRecord.Ext,
+			),
+			fmt.Sprintf("UPDATE manufacture.product_plan_dispatch_record SET %s WHERE product_plan_dispatch_record_id=? RETURNING %s", updateFieldsSnippet, returningFieldsSnippet),
+			//productPlanDispatchRecord.ProductPlanDispatchRecordId,
+			productPlanDispatchRecord.CompanyId,
+			productPlanDispatchRecord.OrgId,
+			productPlanDispatchRecord.BatchNumber,
+			productPlanDispatchRecord.ProductDate,
+			productPlanDispatchRecord.PlanDispatchStatus,
+			productPlanDispatchRecord.WorkStation,
+			productPlanDispatchRecord.CreatedAt,
+			productPlanDispatchRecord.UpdatedAt,
+			//productPlanDispatchRecord.DeletedAt,
+			productPlanDispatchRecord.PlanDispatchRecordExt,
+			productPlanDispatchRecord.Ext,
+			productPlanDispatchRecord.Identify(),
+		); err != nil {
+			return productPlanDispatchRecord, err
+		}
+	}
+	return productPlanDispatchRecord, nil
+}
+func (repository *ProductPlanDispatchRecordRepository) Remove(productPlanDispatchRecord *domain.ProductPlanDispatchRecord) (*domain.ProductPlanDispatchRecord, error) {
+	tx := repository.transactionContext.PgTx
+	productPlanDispatchRecordModel := new(models.ProductPlanDispatchRecord)
+	productPlanDispatchRecordModel.ProductPlanDispatchRecordId = productPlanDispatchRecord.Identify().(int)
+	if _, err := tx.Model(productPlanDispatchRecordModel).WherePK().Delete(); err != nil {
+		return productPlanDispatchRecord, err
+	}
+	return productPlanDispatchRecord, nil
+}
+func (repository *ProductPlanDispatchRecordRepository) FindOne(queryOptions map[string]interface{}) (*domain.ProductPlanDispatchRecord, error) {
+	tx := repository.transactionContext.PgTx
+	productPlanDispatchRecordModel := new(models.ProductPlanDispatchRecord)
+	query := sqlbuilder.BuildQuery(tx.Model(productPlanDispatchRecordModel), queryOptions)
+	query.SetWhereByQueryOption("product_plan_dispatch_record.product_plan_dispatch_record_id = ?", "productPlanDispatchRecordId")
+	query.SetWhereByQueryOption("company_id = ?", "companyId")
+	query.SetWhereByQueryOption("org_id = ?", "orgId")
+	query.SetWhereByQueryOption("product_date = ?", "productDate")
+	query.SetWhereByQueryOption("work_station->>'workStationId'='?'", "workStationId")
+	query.SetWhereByQueryOption("plan_dispatch_record_ext->>'productPlanId'='?'", "productPlanId")
+	if err := query.First(); err != nil {
+		if err.Error() == "pg: no rows in result set" {
+			return nil, domain.ErrorNotFound
+		} else {
+			return nil, err
+		}
+	}
+	if productPlanDispatchRecordModel.ProductPlanDispatchRecordId == 0 {
+		return nil, nil
+	} else {
+		return transform.TransformToProductPlanDispatchRecordDomainModelFromPgModels(productPlanDispatchRecordModel)
+	}
+}
+func (repository *ProductPlanDispatchRecordRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.ProductPlanDispatchRecord, error) {
+	tx := repository.transactionContext.PgTx
+	var productPlanDispatchRecordModels []*models.ProductPlanDispatchRecord
+	productPlanDispatchRecords := make([]*domain.ProductPlanDispatchRecord, 0)
+	query := sqlbuilder.BuildQuery(tx.Model(&productPlanDispatchRecordModels), queryOptions)
+	query.SetOffsetAndLimit(domain.MaxQueryRow)
+	query.SetOrderDirect("product_plan_dispatch_record_id", "DESC")
+	if count, err := query.SelectAndCount(); err != nil {
+		return 0, productPlanDispatchRecords, err
+	} else {
+		for _, productPlanDispatchRecordModel := range productPlanDispatchRecordModels {
+			if productPlanDispatchRecord, err := transform.TransformToProductPlanDispatchRecordDomainModelFromPgModels(productPlanDispatchRecordModel); err != nil {
+				return 0, productPlanDispatchRecords, err
+			} else {
+				productPlanDispatchRecords = append(productPlanDispatchRecords, productPlanDispatchRecord)
+			}
+		}
+		return int64(count), productPlanDispatchRecords, nil
+	}
+}
+func NewProductPlanDispatchRecordRepository(transactionContext *pgTransaction.TransactionContext) (*ProductPlanDispatchRecordRepository, error) {
+	if transactionContext == nil {
+		return nil, fmt.Errorf("transactionContext参数不能为nil")
+	} else {
+		return &ProductPlanDispatchRecordRepository{
+			transactionContext: transactionContext,
+		}, nil
+	}
+}

@@ -130,3 +130,15 @@ func (controller *ProductPlanController) SearchProductPlan() {
 	total, data, err := productPlanService.SearchProductPlan(ParseOperateInfo(controller.BaseController), cmd)
 	ResponseGrid(controller.BaseController, total, data, err)
 }
+
+func (controller *ProductPlanController) SearchProductPlanOnlineDispatchRecord() {
+	productPlanService := service.NewProductPlanService(nil)
+	cmd := &query.SearchProductPlanQuery{}
+	Must(controller.Unmarshal(cmd))
+	operateInfo := ParseOperateInfo(controller.BaseController)
+	//cmd.OrgId = operateInfo.OrgId
+	cmd.CompanyId = operateInfo.CompanyId
+	cmd.InOrgIds = operateInfo.OrgIds
+	total, data, err := productPlanService.SearchProductPlanOnlineDispatchRecord(ParseOperateInfo(controller.BaseController), cmd)
+	ResponseGrid(controller.BaseController, total, data, err)
+}

@@ -18,4 +18,5 @@ func init() {
 	web.Router("/product-plans/exchange", &controllers.ProductPlanController{}, "Post:Switch")
 	web.Router("/product-plans/submit-product-record", &controllers.ProductPlanController{}, "Post:SubmitProductRecord")
 	web.Router("/product-plans/search", &controllers.ProductPlanController{}, "Post:SearchProductPlan")
+	web.Router("/product-plans/online-dispatch-record/search", &controllers.ProductPlanController{}, "Post:SearchProductPlanOnlineDispatchRecord")
 }