feature: 交付工单

opms_parent/app/dao/work/deliver_order.go

@@ -0,0 +1,36 @@
+// ============================================================================
+// This is auto-generated by gf cli tool only once. Fill this file as you wish.
+// ============================================================================
+
+package work
+
+import (
+	"dashoo.cn/micro/app/dao/work/internal"
+)
+
+// deliverOrderDao is the manager for logic model data accessing
+// and custom defined data operations functions management. You can define
+// methods on it to extend its functionality as you wish.
+type deliverOrderDao struct {
+	internal.DeliverOrderDao
+}
+
+var (
+	// DeliverOrder is globally public accessible object for table deliver_order operations.
+	DeliverOrder = deliverOrderDao{
+		internal.DeliverOrder,
+	}
+)
+
+type DeliverOrderDao struct {
+	internal.DeliverOrderDao
+}
+
+func NewDeliverOrderDao(tenant string) *DeliverOrderDao {
+	dao := internal.NewDeliverOrderDao(tenant)
+	return &DeliverOrderDao{
+		dao,
+	}
+}
+
+// Fill with you ideas below.

opms_parent/app/dao/work/deliver_order_imp_plan.go

@@ -0,0 +1,36 @@
+// ============================================================================
+// This is auto-generated by gf cli tool only once. Fill this file as you wish.
+// ============================================================================
+
+package work
+
+import (
+	"dashoo.cn/micro/app/dao/work/internal"
+)
+
+// deliverOrderImpPlanDao is the manager for logic model data accessing
+// and custom defined data operations functions management. You can define
+// methods on it to extend its functionality as you wish.
+type deliverOrderImpPlanDao struct {
+	internal.DeliverOrderImpPlanDao
+}
+
+var (
+	// DeliverOrderImpPlan is globally public accessible object for table deliver_order_imp_plan operations.
+	DeliverOrderImpPlan = deliverOrderImpPlanDao{
+		internal.DeliverOrderImpPlan,
+	}
+)
+
+type DeliverOrderImpPlanDao struct {
+	internal.DeliverOrderImpPlanDao
+}
+
+func NewDeliverOrderImpPlanDao(tenant string) *DeliverOrderImpPlanDao {
+	dao := internal.NewDeliverOrderImpPlanDao(tenant)
+	return &DeliverOrderImpPlanDao{
+		dao,
+	}
+}
+
+// Fill with you ideas below.

opms_parent/app/dao/work/deliver_order_imp_progress.go

@@ -0,0 +1,36 @@
+// ============================================================================
+// This is auto-generated by gf cli tool only once. Fill this file as you wish.
+// ============================================================================
+
+package work
+
+import (
+	"dashoo.cn/micro/app/dao/work/internal"
+)
+
+// deliverOrderImpProgressDao is the manager for logic model data accessing
+// and custom defined data operations functions management. You can define
+// methods on it to extend its functionality as you wish.
+type deliverOrderImpProgressDao struct {
+	internal.DeliverOrderImpProgressDao
+}
+
+var (
+	// DeliverOrderImpProgress is globally public accessible object for table deliver_order_imp_progress operations.
+	DeliverOrderImpProgress = deliverOrderImpProgressDao{
+		internal.DeliverOrderImpProgress,
+	}
+)
+
+type DeliverOrderImpProgressDao struct {
+	internal.DeliverOrderImpProgressDao
+}
+
+func NewDeliverOrderImpProgressDao(tenant string) *DeliverOrderImpProgressDao {
+	dao := internal.NewDeliverOrderImpProgressDao(tenant)
+	return &DeliverOrderImpProgressDao{
+		dao,
+	}
+}
+
+// Fill with you ideas below.

opms_parent/app/dao/work/deliver_order_product.go

@@ -0,0 +1,36 @@
+// ============================================================================
+// This is auto-generated by gf cli tool only once. Fill this file as you wish.
+// ============================================================================
+
+package work
+
+import (
+	"dashoo.cn/micro/app/dao/work/internal"
+)
+
+// deliverOrderProductDao is the manager for logic model data accessing
+// and custom defined data operations functions management. You can define
+// methods on it to extend its functionality as you wish.
+type deliverOrderProductDao struct {
+	internal.DeliverOrderProductDao
+}
+
+var (
+	// DeliverOrderProduct is globally public accessible object for table deliver_order_product operations.
+	DeliverOrderProduct = deliverOrderProductDao{
+		internal.DeliverOrderProduct,
+	}
+)
+
+type DeliverOrderProductDao struct {
+	internal.DeliverOrderProductDao
+}
+
+func NewDeliverOrderProductDao(tenant string) *DeliverOrderProductDao {
+	dao := internal.NewDeliverOrderProductDao(tenant)
+	return &DeliverOrderProductDao{
+		dao,
+	}
+}
+
+// Fill with you ideas below.

opms_parent/app/dao/work/internal/deliver_order.go

@@ -0,0 +1,866 @@
+// ==========================================================================
+// This is auto-generated by gf cli tool. DO NOT EDIT THIS FILE MANUALLY.
+// ==========================================================================
+
+package internal
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"github.com/gogf/gf/container/garray"
+	"github.com/gogf/gf/database/gdb"
+	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/frame/gmvc"
+	"github.com/gogf/gf/util/gconv"
+	"strings"
+	"time"
+
+	model "dashoo.cn/micro/app/model/work"
+)
+
+// DeliverOrderDao is the manager for logic model data accessing and custom defined data operations functions management.
+type DeliverOrderDao struct {
+	gmvc.M                      // M is the core and embedded struct that inherits all chaining operations from gdb.Model.
+	C       deliverOrderColumns // C is the short type for Columns, which contains all the column names of Table for convenient usage.
+	DB      gdb.DB              // DB is the raw underlying database management object.
+	Table   string              // Table is the underlying table name of the DAO.
+	TableAs string              // TableAs is the underlying table alias name of the DAO.
+}
+
+// DeliverOrderColumns defines and stores column names for table deliver_order.
+type deliverOrderColumns struct {
+	Id             string // 主键
+	OrderCode      string // 交付订单号
+	OrderStatus    string // 交付状态(10项目立项 20 完成)
+	OrderType      string // 交付类型(10 软件 20 硬件)
+	CustId         string // 关联客户ID
+	CustName       string // 关联客户名称
+	ProjectId      string // 关联项目ID
+	ProjectName    string // 关联项目名称
+	ContractId     string // 关联合同ID
+	ContractCode   string // 关联合同编号
+	ProjectManId   string // 项目经理
+	ProjectManName string // 项目经理
+	DeliverManId   string // 交付经理
+	DeliverManName string // 交付经理
+	Product        string // 产品线
+	FinishRemark   string // 完成信息
+	FinishTime     string // 完成时间
+	FinishBy       string // 完成操作人
+	FinishByName   string // 完成操作人
+	Remark         string // 备注
+	CreatedBy      string // 创建者
+	CreatedName    string // 创建人
+	CreatedTime    string // 创建时间
+	UpdatedBy      string // 更新者
+	UpdatedName    string // 更新人
+	UpdatedTime    string // 更新时间
+	DeletedTime    string // 删除时间
+}
+
+var (
+	// DeliverOrder is globally public accessible object for table deliver_order operations.
+	DeliverOrder = DeliverOrderDao{
+		M:     g.DB("default").Model("deliver_order").Safe(),
+		DB:    g.DB("default"),
+		Table: "deliver_order",
+		C: deliverOrderColumns{
+			Id:             "id",
+			OrderCode:      "order_code",
+			OrderStatus:    "order_status",
+			OrderType:      "order_type",
+			CustId:         "cust_id",
+			CustName:       "cust_name",
+			ProjectId:      "project_id",
+			ProjectName:    "project_name",
+			ContractId:     "contract_id",
+			ContractCode:   "contract_code",
+			ProjectManId:   "project_man_id",
+			ProjectManName: "project_man_name",
+			DeliverManId:   "deliver_man_id",
+			DeliverManName: "deliver_man_name",
+			Product:        "product",
+			FinishRemark:   "finish_remark",
+			FinishTime:     "finish_time",
+			FinishBy:       "finish_by",
+			FinishByName:   "finish_by_name",
+			Remark:         "remark",
+			CreatedBy:      "created_by",
+			CreatedName:    "created_name",
+			CreatedTime:    "created_time",
+			UpdatedBy:      "updated_by",
+			UpdatedName:    "updated_name",
+			UpdatedTime:    "updated_time",
+			DeletedTime:    "deleted_time",
+		},
+	}
+)
+
+func NewDeliverOrderDao(tenant string) DeliverOrderDao {
+	var dao DeliverOrderDao
+	dao = DeliverOrderDao{
+		M:     g.DB(tenant).Model("deliver_order").Safe(),
+		DB:    g.DB(tenant),
+		Table: "deliver_order",
+		C: deliverOrderColumns{
+			Id:             "id",
+			OrderCode:      "order_code",
+			OrderStatus:    "order_status",
+			OrderType:      "order_type",
+			CustId:         "cust_id",
+			CustName:       "cust_name",
+			ProjectId:      "project_id",
+			ProjectName:    "project_name",
+			ContractId:     "contract_id",
+			ContractCode:   "contract_code",
+			ProjectManId:   "project_man_id",
+			ProjectManName: "project_man_name",
+			DeliverManId:   "deliver_man_id",
+			DeliverManName: "deliver_man_name",
+			Product:        "product",
+			FinishRemark:   "finish_remark",
+			FinishTime:     "finish_time",
+			FinishBy:       "finish_by",
+			FinishByName:   "finish_by_name",
+			Remark:         "remark",
+			CreatedBy:      "created_by",
+			CreatedName:    "created_name",
+			CreatedTime:    "created_time",
+			UpdatedBy:      "updated_by",
+			UpdatedName:    "updated_name",
+			UpdatedTime:    "updated_time",
+			DeletedTime:    "deleted_time",
+		},
+	}
+	return dao
+}
+
+// Ctx is a chaining function, which creates and returns a new DB that is a shallow copy
+// of current DB object and with given context in it.
+// Note that this returned DB object can be used only once, so do not assign it to
+// a global or package variable for long using.
+func (d *DeliverOrderDao) Ctx(ctx context.Context) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
+}
+
+// GetCtx returns the context for current Model.
+// It returns "context.Background() i"s there's no context previously set.
+func (d *DeliverOrderDao) GetCtx() context.Context {
+	return d.M.GetCtx()
+}
+
+// As sets an alias name for current table.
+func (d *DeliverOrderDao) As(as string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.As(as), Table: d.Table, TableAs: as}
+}
+
+// TX sets the transaction for current operation.
+func (d *DeliverOrderDao) TX(tx *gdb.TX) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.TX(tx), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Master marks the following operation on master node.
+func (d *DeliverOrderDao) Master() *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Master(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Slave marks the following operation on slave node.
+// Note that it makes sense only if there's any slave node configured.
+func (d *DeliverOrderDao) Slave() *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Slave(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Args sets custom arguments for model operation.
+func (d *DeliverOrderDao) Args(args ...interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Args(args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Handler calls each of "handlers" on current Model and returns a new Model.
+// ModelHandler is a function that handles given Model and returns a new Model that is custom modified.
+func (d *DeliverOrderDao) Handler(handlers ...gdb.ModelHandler) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Handler(handlers...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// LeftJoin does "LEFT JOIN ... ON ..." statement on the model.
+// The parameter <table> can be joined table and its joined condition,
+// and also with its alias name, like:
+// Table("user").LeftJoin("user_detail", "user_detail.uid=user.uid")
+// Table("user", "u").LeftJoin("user_detail", "ud", "ud.uid=u.uid")
+func (d *DeliverOrderDao) LeftJoin(table ...string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.LeftJoin(table...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// RightJoin does "RIGHT JOIN ... ON ..." statement on the model.
+// The parameter <table> can be joined table and its joined condition,
+// and also with its alias name, like:
+// Table("user").RightJoin("user_detail", "user_detail.uid=user.uid")
+// Table("user", "u").RightJoin("user_detail", "ud", "ud.uid=u.uid")
+func (d *DeliverOrderDao) RightJoin(table ...string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.RightJoin(table...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// InnerJoin does "INNER JOIN ... ON ..." statement on the model.
+// The parameter <table> can be joined table and its joined condition,
+// and also with its alias name, like:
+// Table("user").InnerJoin("user_detail", "user_detail.uid=user.uid")
+// Table("user", "u").InnerJoin("user_detail", "ud", "ud.uid=u.uid")
+func (d *DeliverOrderDao) InnerJoin(table ...string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.InnerJoin(table...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Fields sets the operation fields of the model, multiple fields joined using char ','.
+// The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
+func (d *DeliverOrderDao) Fields(fieldNamesOrMapStruct ...interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Fields(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldsEx sets the excluded operation fields of the model, multiple fields joined using char ','.
+// The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
+func (d *DeliverOrderDao) FieldsEx(fieldNamesOrMapStruct ...interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.FieldsEx(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldCount formats and appends commonly used field "COUNT(column)" to the select fields of model.
+func (d *DeliverOrderDao) FieldCount(column string, as ...string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.FieldCount(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldSum formats and appends commonly used field "SUM(column)" to the select fields of model.
+func (d *DeliverOrderDao) FieldSum(column string, as ...string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.FieldSum(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldMin formats and appends commonly used field "MIN(column)" to the select fields of model.
+func (d *DeliverOrderDao) FieldMin(column string, as ...string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.FieldMin(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldMax formats and appends commonly used field "MAX(column)" to the select fields of model.
+func (d *DeliverOrderDao) FieldMax(column string, as ...string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.FieldMax(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldAvg formats and appends commonly used field "AVG(column)" to the select fields of model.
+func (d *DeliverOrderDao) FieldAvg(column string, as ...string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.FieldAvg(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Option adds extra operation option for the model.
+// Deprecated, use separate operations instead.
+func (d *DeliverOrderDao) Option(option int) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Option(option), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitEmpty sets OPTION_OMITEMPTY option for the model, which automatically filers
+// the data and where attributes for empty values.
+func (d *DeliverOrderDao) OmitEmpty() *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.OmitEmpty(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitEmptyWhere sets optionOmitEmptyWhere option for the model, which automatically filers
+// the Where/Having parameters for "empty" values.
+func (d *DeliverOrderDao) OmitEmptyWhere() *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.OmitEmptyWhere(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitEmptyData sets optionOmitEmptyData option for the model, which automatically filers
+// the Data parameters for "empty" values.
+func (d *DeliverOrderDao) OmitEmptyData() *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.OmitEmptyData(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitNil sets optionOmitNil option for the model, which automatically filers
+// the data and where parameters for "nil" values.
+func (d *DeliverOrderDao) OmitNil() *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.OmitNil(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitNilWhere sets optionOmitNilWhere option for the model, which automatically filers
+// the Where/Having parameters for "nil" values.
+func (d *DeliverOrderDao) OmitNilWhere() *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.OmitNilWhere(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitNilData sets optionOmitNilData option for the model, which automatically filers
+// the Data parameters for "nil" values.
+func (d *DeliverOrderDao) OmitNilData() *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.OmitNilData(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Filter marks filtering the fields which does not exist in the fields of the operated table.
+// Note that this function supports only single table operations.
+// Deprecated, filter feature is automatically enabled from GoFrame v1.16.0, it is so no longer used.
+func (d *DeliverOrderDao) Filter() *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Filter(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Where sets the condition statement for the model. The parameter <where> can be type of
+// string/map/gmap/slice/struct/*struct, etc. Note that, if it's called more than one times,
+// multiple conditions will be joined into where statement using "AND".
+// Eg:
+// Where("uid=10000")
+// Where("uid", 10000)
+// Where("money>? AND name like ?", 99999, "vip_%")
+// Where("uid", 1).Where("name", "john")
+// Where("status IN (?)", g.Slice{1,2,3})
+// Where("age IN(?,?)", 18, 50)
+// Where(User{ Id : 1, UserName : "john"})
+func (d *DeliverOrderDao) Where(where interface{}, args ...interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Where(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WherePri does the same logic as M.Where except that if the parameter <where>
+// is a single condition like int/string/float/slice, it treats the condition as the primary
+// key value. That is, if primary key is "id" and given <where> parameter as "123", the
+// WherePri function treats the condition as "id=123", but M.Where treats the condition
+// as string "123".
+func (d *DeliverOrderDao) WherePri(where interface{}, args ...interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WherePri(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Having sets the having statement for the model.
+// The parameters of this function usage are as the same as function Where.
+// See Where.
+func (d *DeliverOrderDao) Having(having interface{}, args ...interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Having(having, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Wheref builds condition string using fmt.Sprintf and arguments.
+// Note that if the number of "args" is more than the place holder in "format",
+// the extra "args" will be used as the where condition arguments of the Model.
+func (d *DeliverOrderDao) Wheref(format string, args ...interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Wheref(format, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereLT builds "column < value" statement.
+func (d *DeliverOrderDao) WhereLT(column string, value interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereLT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereLTE builds "column <= value" statement.
+func (d *DeliverOrderDao) WhereLTE(column string, value interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereLTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereGT builds "column > value" statement.
+func (d *DeliverOrderDao) WhereGT(column string, value interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereGT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereGTE builds "column >= value" statement.
+func (d *DeliverOrderDao) WhereGTE(column string, value interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereGTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereBetween builds "column BETWEEN min AND max" statement.
+func (d *DeliverOrderDao) WhereBetween(column string, min, max interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereLike builds "column LIKE like" statement.
+func (d *DeliverOrderDao) WhereLike(column string, like interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereIn builds "column IN (in)" statement.
+func (d *DeliverOrderDao) WhereIn(column string, in interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNull builds "columns[0] IS NULL AND columns[1] IS NULL ..." statement.
+func (d *DeliverOrderDao) WhereNull(columns ...string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotBetween builds "column NOT BETWEEN min AND max" statement.
+func (d *DeliverOrderDao) WhereNotBetween(column string, min, max interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotLike builds "column NOT LIKE like" statement.
+func (d *DeliverOrderDao) WhereNotLike(column string, like interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNot builds "column != value" statement.
+func (d *DeliverOrderDao) WhereNot(column string, value interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereNot(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotIn builds "column NOT IN (in)" statement.
+func (d *DeliverOrderDao) WhereNotIn(column string, in interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotNull builds "columns[0] IS NOT NULL AND columns[1] IS NOT NULL ..." statement.
+func (d *DeliverOrderDao) WhereNotNull(columns ...string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOr adds "OR" condition to the where statement.
+func (d *DeliverOrderDao) WhereOr(where interface{}, args ...interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereOr(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrf builds "OR" condition string using fmt.Sprintf and arguments.
+func (d *DeliverOrderDao) WhereOrf(format string, args ...interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereOrf(format, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrLT builds "column < value" statement in "OR" conditions..
+func (d *DeliverOrderDao) WhereOrLT(column string, value interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereOrLT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrLTE builds "column <= value" statement in "OR" conditions..
+func (d *DeliverOrderDao) WhereOrLTE(column string, value interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereOrLTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrGT builds "column > value" statement in "OR" conditions..
+func (d *DeliverOrderDao) WhereOrGT(column string, value interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereOrGT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrGTE builds "column >= value" statement in "OR" conditions..
+func (d *DeliverOrderDao) WhereOrGTE(column string, value interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereOrGTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrBetween builds "column BETWEEN min AND max" statement in "OR" conditions.
+func (d *DeliverOrderDao) WhereOrBetween(column string, min, max interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereOrBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrLike builds "column LIKE like" statement in "OR" conditions.
+func (d *DeliverOrderDao) WhereOrLike(column string, like interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereOrLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrIn builds "column IN (in)" statement in "OR" conditions.
+func (d *DeliverOrderDao) WhereOrIn(column string, in interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereOrIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNull builds "columns[0] IS NULL OR columns[1] IS NULL ..." statement in "OR" conditions.
+func (d *DeliverOrderDao) WhereOrNull(columns ...string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereOrNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotBetween builds "column NOT BETWEEN min AND max" statement in "OR" conditions.
+func (d *DeliverOrderDao) WhereOrNotBetween(column string, min, max interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereOrNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotLike builds "column NOT LIKE like" statement in "OR" conditions.
+func (d *DeliverOrderDao) WhereOrNotLike(column string, like interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereOrNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotIn builds "column NOT IN (in)" statement.
+func (d *DeliverOrderDao) WhereOrNotIn(column string, in interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereOrNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotNull builds "columns[0] IS NOT NULL OR columns[1] IS NOT NULL ..." statement in "OR" conditions.
+func (d *DeliverOrderDao) WhereOrNotNull(columns ...string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.WhereOrNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Group sets the "GROUP BY" statement for the model.
+func (d *DeliverOrderDao) Group(groupBy ...string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Group(groupBy...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// And adds "AND" condition to the where statement.
+// Deprecated, use Where instead.
+func (d *DeliverOrderDao) And(where interface{}, args ...interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.And(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Or adds "OR" condition to the where statement.
+// Deprecated, use WhereOr instead.
+func (d *DeliverOrderDao) Or(where interface{}, args ...interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Or(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// GroupBy sets the "GROUP BY" statement for the model.
+func (d *DeliverOrderDao) GroupBy(groupBy string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Group(groupBy), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Order sets the "ORDER BY" statement for the model.
+func (d *DeliverOrderDao) Order(orderBy ...string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Order(orderBy...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderAsc sets the "ORDER BY xxx ASC" statement for the model.
+func (d *DeliverOrderDao) OrderAsc(column string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.OrderAsc(column), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderDesc sets the "ORDER BY xxx DESC" statement for the model.
+func (d *DeliverOrderDao) OrderDesc(column string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.OrderDesc(column), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderRandom sets the "ORDER BY RANDOM()" statement for the model.
+func (d *DeliverOrderDao) OrderRandom() *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.OrderRandom(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderBy is alias of Model.Order.
+// See Model.Order.
+// Deprecated, use Order instead.
+func (d *DeliverOrderDao) OrderBy(orderBy string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Order(orderBy), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Limit sets the "LIMIT" statement for the model.
+// The parameter <limit> can be either one or two number, if passed two number is passed,
+// it then sets "LIMIT limit[0],limit[1]" statement for the model, or else it sets "LIMIT limit[0]"
+// statement.
+func (d *DeliverOrderDao) Limit(limit ...int) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Limit(limit...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Offset sets the "OFFSET" statement for the model.
+// It only makes sense for some databases like SQLServer, PostgreSQL, etc.
+func (d *DeliverOrderDao) Offset(offset int) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Offset(offset), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Distinct forces the query to only return distinct results.
+func (d *DeliverOrderDao) Distinct() *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Distinct(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Page sets the paging number for the model.
+// The parameter <page> is started from 1 for paging.
+// Note that, it differs that the Limit function start from 0 for "LIMIT" statement.
+func (d *DeliverOrderDao) Page(page, limit int) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Page(page, limit), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Batch sets the batch operation number for the model.
+func (d *DeliverOrderDao) Batch(batch int) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Batch(batch), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Cache sets the cache feature for the model. It caches the result of the sql, which means
+// if there's another same sql request, it just reads and returns the result from cache, it
+// but not committed and executed into the database.
+//
+// If the parameter <duration> < 0, which means it clear the cache with given <name>.
+// If the parameter <duration> = 0, which means it never expires.
+// If the parameter <duration> > 0, which means it expires after <duration>.
+//
+// The optional parameter <name> is used to bind a name to the cache, which means you can later
+// control the cache like changing the <duration> or clearing the cache with specified <name>.
+//
+// Note that, the cache feature is disabled if the model is operating on a transaction.
+func (d *DeliverOrderDao) Cache(duration time.Duration, name ...string) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Cache(duration, name...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Data sets the operation data for the model.
+// The parameter <data> can be type of string/map/gmap/slice/struct/*struct, etc.
+// Eg:
+// Data("uid=10000")
+// Data("uid", 10000)
+// Data(g.Map{"uid": 10000, "name":"john"})
+// Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
+func (d *DeliverOrderDao) Data(data ...interface{}) *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Data(data...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// All does "SELECT FROM ..." statement for the model.
+// It retrieves the records from table and returns the result as []*model.DeliverOrder.
+// It returns nil if there's no record retrieved with the given conditions from table.
+//
+// The optional parameter <where> is the same as the parameter of M.Where function,
+// see M.Where.
+func (d *DeliverOrderDao) All(where ...interface{}) ([]*model.DeliverOrder, error) {
+	all, err := d.M.All(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entities []*model.DeliverOrder
+	if err = all.Structs(&entities); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entities, nil
+}
+
+// One retrieves one record from table and returns the result as *model.DeliverOrder.
+// It returns nil if there's no record retrieved with the given conditions from table.
+//
+// The optional parameter <where> is the same as the parameter of M.Where function,
+// see M.Where.
+func (d *DeliverOrderDao) One(where ...interface{}) (*model.DeliverOrder, error) {
+	one, err := d.M.One(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entity *model.DeliverOrder
+	if err = one.Struct(&entity); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entity, nil
+}
+
+// FindOne retrieves and returns a single Record by M.WherePri and M.One.
+// Also see M.WherePri and M.One.
+func (d *DeliverOrderDao) FindOne(where ...interface{}) (*model.DeliverOrder, error) {
+	one, err := d.M.FindOne(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entity *model.DeliverOrder
+	if err = one.Struct(&entity); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entity, nil
+}
+
+// FindAll retrieves and returns Result by by M.WherePri and M.All.
+// Also see M.WherePri and M.All.
+func (d *DeliverOrderDao) FindAll(where ...interface{}) ([]*model.DeliverOrder, error) {
+	all, err := d.M.FindAll(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entities []*model.DeliverOrder
+	if err = all.Structs(&entities); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entities, nil
+}
+
+// Struct retrieves one record from table and converts it into given struct.
+// The parameter <pointer> should be type of *struct/**struct. If type **struct is given,
+// it can create the struct internally during converting.
+//
+// The optional parameter <where> is the same as the parameter of Model.Where function,
+// see Model.Where.
+//
+// Note that it returns sql.ErrNoRows if there's no record retrieved with the given conditions
+// from table and <pointer> is not nil.
+//
+// Eg:
+// user := new(User)
+// err  := dao.User.Where("id", 1).Struct(user)
+//
+// user := (*User)(nil)
+// err  := dao.User.Where("id", 1).Struct(&user)
+func (d *DeliverOrderDao) Struct(pointer interface{}, where ...interface{}) error {
+	return d.M.Struct(pointer, where...)
+}
+
+// Structs retrieves records from table and converts them into given struct slice.
+// The parameter <pointer> should be type of *[]struct/*[]*struct. It can create and fill the struct
+// slice internally during converting.
+//
+// The optional parameter <where> is the same as the parameter of Model.Where function,
+// see Model.Where.
+//
+// Note that it returns sql.ErrNoRows if there's no record retrieved with the given conditions
+// from table and <pointer> is not empty.
+//
+// Eg:
+// users := ([]User)(nil)
+// err   := dao.User.Structs(&users)
+//
+// users := ([]*User)(nil)
+// err   := dao.User.Structs(&users)
+func (d *DeliverOrderDao) Structs(pointer interface{}, where ...interface{}) error {
+	return d.M.Structs(pointer, where...)
+}
+
+// Scan automatically calls Struct or Structs function according to the type of parameter <pointer>.
+// It calls function Struct if <pointer> is type of *struct/**struct.
+// It calls function Structs if <pointer> is type of *[]struct/*[]*struct.
+//
+// The optional parameter <where> is the same as the parameter of Model.Where function,
+// see Model.Where.
+//
+// Note that it returns sql.ErrNoRows if there's no record retrieved and given pointer is not empty or nil.
+//
+// Eg:
+// user  := new(User)
+// err   := dao.User.Where("id", 1).Scan(user)
+//
+// user  := (*User)(nil)
+// err   := dao.User.Where("id", 1).Scan(&user)
+//
+// users := ([]User)(nil)
+// err   := dao.User.Scan(&users)
+//
+// users := ([]*User)(nil)
+// err   := dao.User.Scan(&users)
+func (d *DeliverOrderDao) Scan(pointer interface{}, where ...interface{}) error {
+	return d.M.Scan(pointer, where...)
+}
+
+// Chunk iterates the table with given size and callback function.
+func (d *DeliverOrderDao) Chunk(limit int, callback func(entities []*model.DeliverOrder, err error) bool) {
+	d.M.Chunk(limit, func(result gdb.Result, err error) bool {
+		var entities []*model.DeliverOrder
+		err = result.Structs(&entities)
+		if err == sql.ErrNoRows {
+			return false
+		}
+		return callback(entities, err)
+	})
+}
+
+// LockUpdate sets the lock for update for current operation.
+func (d *DeliverOrderDao) LockUpdate() *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.LockUpdate(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// LockShared sets the lock in share mode for current operation.
+func (d *DeliverOrderDao) LockShared() *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.LockShared(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Unscoped enables/disables the soft deleting feature.
+func (d *DeliverOrderDao) Unscoped() *DeliverOrderDao {
+	return &DeliverOrderDao{M: d.M.Unscoped(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// DataScope enables the DataScope feature.
+func (d *DeliverOrderDao) DataScope(ctx context.Context, args ...interface{}) *DeliverOrderDao {
+	cs := ctx.Value("contextService")
+	dataScope := gconv.Map(gconv.String(gconv.Map(cs)["dataScope"]))
+	if dataScope != nil {
+		// 销售工程师判断
+		var salesEngineerFlag bool
+		if roles, ok := dataScope["roles"]; ok {
+			arr := garray.NewArrayFrom(roles.([]interface{}), true)
+			if arr.Len() == 1 && arr.Contains("SalesEngineer") {
+				salesEngineerFlag = true
+			}
+		}
+		userIds, ok := dataScope["userIds"]
+		specialFlag, userCols, orColsMap := d.checkColumnsName(dataScope, args...)
+
+		var orColumns []string
+		var orValues []interface{}
+		if ok && userIds != "-1" {
+			for _, column := range userCols {
+				if ok, _ := d.M.HasField(column); ok || specialFlag {
+					orColumns = append(orColumns, column+" IN (?) ")
+					orValues = append(orValues, userIds)
+				}
+			}
+		}
+		for col, params := range orColsMap {
+			if ok, _ := d.M.HasField(col); ok || specialFlag {
+				orColumns = append(orColumns, fmt.Sprintf(" ( %s IN (?) )", col))
+				orValues = append(orValues, params)
+			}
+		}
+
+		// 销售工程师权限加成
+		if !salesEngineerFlag {
+			var andColumns []string
+			var andValues []interface{}
+			for col, params := range dataScope {
+				if ok, _ := d.M.HasField(col); ok || specialFlag {
+					andColumns = append(andColumns, fmt.Sprintf(" ( %s IN (?) )", col))
+					andValues = append(andValues, params)
+				}
+			}
+			if len(andColumns) > 0 {
+				andWhereSql := strings.Join(andColumns, " AND ")
+				orColumns = append(orColumns, "("+andWhereSql+")")
+				orValues = append(orValues, andValues...)
+			}
+		}
+
+		whereSql := strings.Join(orColumns, " OR ")
+		return &DeliverOrderDao{M: d.M.Where(whereSql, orValues...).Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
+	}
+	return d
+}
+
+// args 1、字段
+// args 2、字段、表名
+// args 3、字段对应关系
+func (d *DeliverOrderDao) checkColumnsName(dataScope map[string]interface{}, args ...interface{}) (bool, []string, map[string]interface{}) {
+	var userCols []string
+	tableAs, specialFlag := "", false
+	orColsMap, colsContrast := map[string]interface{}{}, map[string]interface{}{}
+
+	if d.TableAs != "" && len(args) <= 1 {
+		tableAs = d.TableAs + "."
+	}
+	if len(args) > 1 {
+		specialFlag = true
+		if val, ok := args[1].(string); ok {
+			tableAs = val + "."
+		}
+	}
+	if len(args) > 0 {
+		userCols = []string{"created_by"}
+		if column, ok := args[0].(string); ok {
+			userCols = []string{tableAs + column}
+		}
+		if cols, ok := args[0].([]string); ok {
+			for _, v := range cols {
+				userCols = append(userCols, tableAs+v)
+			}
+		}
+		if val, ok := args[0].(map[string]interface{}); ok {
+			specialFlag = true
+			colsContrast = val
+			if orcols, ok := val["orcols"]; ok {
+				if col, ok := orcols.(string); ok && gconv.String(val[col]) != "" {
+					orColsMap[col] = val[col]
+					delete(colsContrast, col)
+				}
+				if cols, ok := orcols.([]string); ok {
+					for _, col := range cols {
+						if gconv.String(val[col]) == "" {
+							continue
+						}
+						orColsMap[col] = val[col]
+						delete(colsContrast, col)
+					}
+				}
+			}
+			delete(colsContrast, "orcols")
+		}
+	}
+	bigColumns := "is_big"
+	if isBig, ok := dataScope[bigColumns]; ok {
+		if bigCol, ok := colsContrast[bigColumns]; ok {
+			orColsMap[bigCol.(string)] = isBig
+			delete(colsContrast, bigCol.(string))
+		} else {
+			if ok, _ := d.M.HasField(bigColumns); ok && specialFlag {
+				orColsMap[tableAs+bigColumns] = isBig
+			}
+		}
+	}
+
+	delete(dataScope, "userIds")
+	delete(dataScope, "roles")
+	delete(dataScope, "posts")
+	delete(dataScope, bigColumns)
+	if len(colsContrast) > 0 {
+		for k, v := range dataScope {
+			if data, ok := colsContrast[k]; ok {
+				dataScope[data.(string)] = v
+			}
+			delete(dataScope, k)
+			delete(colsContrast, k)
+		}
+		for k, v := range colsContrast {
+			dataScope[k] = v
+		}
+	}
+	return specialFlag, userCols, orColsMap
+}

opms_parent/app/dao/work/internal/deliver_order_imp_plan.go

@@ -0,0 +1,833 @@
+// ==========================================================================
+// This is auto-generated by gf cli tool. DO NOT EDIT THIS FILE MANUALLY.
+// ==========================================================================
+
+package internal
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"github.com/gogf/gf/container/garray"
+	"github.com/gogf/gf/database/gdb"
+	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/frame/gmvc"
+	"github.com/gogf/gf/util/gconv"
+	"strings"
+	"time"
+
+	model "dashoo.cn/micro/app/model/work"
+)
+
+// DeliverOrderImpPlanDao is the manager for logic model data accessing and custom defined data operations functions management.
+type DeliverOrderImpPlanDao struct {
+	gmvc.M                             // M is the core and embedded struct that inherits all chaining operations from gdb.Model.
+	C       deliverOrderImpPlanColumns // C is the short type for Columns, which contains all the column names of Table for convenient usage.
+	DB      gdb.DB                     // DB is the raw underlying database management object.
+	Table   string                     // Table is the underlying table name of the DAO.
+	TableAs string                     // TableAs is the underlying table alias name of the DAO.
+}
+
+// DeliverOrderImpPlanColumns defines and stores column names for table deliver_order_imp_plan.
+type deliverOrderImpPlanColumns struct {
+	Id             string // 主键
+	DeliverOrderId string // 关联交付订单ID
+	PlanTitle      string // 计划标题
+	PlanStatus     string // 计划状态（10 未开始 20 已开始 30已关闭）
+	PlanStartDate  string // 开始时间
+	PlanEndDate    string // 结束时间
+	ReaStartDate   string // 实际开始时间
+	ReaEndDate     string // 实际结束时间
+	Remark         string // 备注
+	CreatedBy      string // 创建者
+	CreatedName    string // 创建人
+	CreatedTime    string // 创建时间
+	UpdatedBy      string // 更新者
+	UpdatedName    string // 更新人
+	UpdatedTime    string // 更新时间
+	DeletedTime    string // 删除时间
+}
+
+var (
+	// DeliverOrderImpPlan is globally public accessible object for table deliver_order_imp_plan operations.
+	DeliverOrderImpPlan = DeliverOrderImpPlanDao{
+		M:     g.DB("default").Model("deliver_order_imp_plan").Safe(),
+		DB:    g.DB("default"),
+		Table: "deliver_order_imp_plan",
+		C: deliverOrderImpPlanColumns{
+			Id:             "id",
+			DeliverOrderId: "deliver_order_id",
+			PlanTitle:      "plan_title",
+			PlanStatus:     "plan_status",
+			PlanStartDate:  "plan_start_date",
+			PlanEndDate:    "plan_end_date",
+			ReaStartDate:   "rea_start_date",
+			ReaEndDate:     "rea_end_date",
+			Remark:         "remark",
+			CreatedBy:      "created_by",
+			CreatedName:    "created_name",
+			CreatedTime:    "created_time",
+			UpdatedBy:      "updated_by",
+			UpdatedName:    "updated_name",
+			UpdatedTime:    "updated_time",
+			DeletedTime:    "deleted_time",
+		},
+	}
+)
+
+func NewDeliverOrderImpPlanDao(tenant string) DeliverOrderImpPlanDao {
+	var dao DeliverOrderImpPlanDao
+	dao = DeliverOrderImpPlanDao{
+		M:     g.DB(tenant).Model("deliver_order_imp_plan").Safe(),
+		DB:    g.DB(tenant),
+		Table: "deliver_order_imp_plan",
+		C: deliverOrderImpPlanColumns{
+			Id:             "id",
+			DeliverOrderId: "deliver_order_id",
+			PlanTitle:      "plan_title",
+			PlanStatus:     "plan_status",
+			PlanStartDate:  "plan_start_date",
+			PlanEndDate:    "plan_end_date",
+			ReaStartDate:   "rea_start_date",
+			ReaEndDate:     "rea_end_date",
+			Remark:         "remark",
+			CreatedBy:      "created_by",
+			CreatedName:    "created_name",
+			CreatedTime:    "created_time",
+			UpdatedBy:      "updated_by",
+			UpdatedName:    "updated_name",
+			UpdatedTime:    "updated_time",
+			DeletedTime:    "deleted_time",
+		},
+	}
+	return dao
+}
+
+// Ctx is a chaining function, which creates and returns a new DB that is a shallow copy
+// of current DB object and with given context in it.
+// Note that this returned DB object can be used only once, so do not assign it to
+// a global or package variable for long using.
+func (d *DeliverOrderImpPlanDao) Ctx(ctx context.Context) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
+}
+
+// GetCtx returns the context for current Model.
+// It returns "context.Background() i"s there's no context previously set.
+func (d *DeliverOrderImpPlanDao) GetCtx() context.Context {
+	return d.M.GetCtx()
+}
+
+// As sets an alias name for current table.
+func (d *DeliverOrderImpPlanDao) As(as string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.As(as), Table: d.Table, TableAs: as}
+}
+
+// TX sets the transaction for current operation.
+func (d *DeliverOrderImpPlanDao) TX(tx *gdb.TX) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.TX(tx), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Master marks the following operation on master node.
+func (d *DeliverOrderImpPlanDao) Master() *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Master(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Slave marks the following operation on slave node.
+// Note that it makes sense only if there's any slave node configured.
+func (d *DeliverOrderImpPlanDao) Slave() *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Slave(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Args sets custom arguments for model operation.
+func (d *DeliverOrderImpPlanDao) Args(args ...interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Args(args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Handler calls each of "handlers" on current Model and returns a new Model.
+// ModelHandler is a function that handles given Model and returns a new Model that is custom modified.
+func (d *DeliverOrderImpPlanDao) Handler(handlers ...gdb.ModelHandler) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Handler(handlers...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// LeftJoin does "LEFT JOIN ... ON ..." statement on the model.
+// The parameter <table> can be joined table and its joined condition,
+// and also with its alias name, like:
+// Table("user").LeftJoin("user_detail", "user_detail.uid=user.uid")
+// Table("user", "u").LeftJoin("user_detail", "ud", "ud.uid=u.uid")
+func (d *DeliverOrderImpPlanDao) LeftJoin(table ...string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.LeftJoin(table...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// RightJoin does "RIGHT JOIN ... ON ..." statement on the model.
+// The parameter <table> can be joined table and its joined condition,
+// and also with its alias name, like:
+// Table("user").RightJoin("user_detail", "user_detail.uid=user.uid")
+// Table("user", "u").RightJoin("user_detail", "ud", "ud.uid=u.uid")
+func (d *DeliverOrderImpPlanDao) RightJoin(table ...string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.RightJoin(table...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// InnerJoin does "INNER JOIN ... ON ..." statement on the model.
+// The parameter <table> can be joined table and its joined condition,
+// and also with its alias name, like:
+// Table("user").InnerJoin("user_detail", "user_detail.uid=user.uid")
+// Table("user", "u").InnerJoin("user_detail", "ud", "ud.uid=u.uid")
+func (d *DeliverOrderImpPlanDao) InnerJoin(table ...string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.InnerJoin(table...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Fields sets the operation fields of the model, multiple fields joined using char ','.
+// The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
+func (d *DeliverOrderImpPlanDao) Fields(fieldNamesOrMapStruct ...interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Fields(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldsEx sets the excluded operation fields of the model, multiple fields joined using char ','.
+// The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
+func (d *DeliverOrderImpPlanDao) FieldsEx(fieldNamesOrMapStruct ...interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.FieldsEx(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldCount formats and appends commonly used field "COUNT(column)" to the select fields of model.
+func (d *DeliverOrderImpPlanDao) FieldCount(column string, as ...string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.FieldCount(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldSum formats and appends commonly used field "SUM(column)" to the select fields of model.
+func (d *DeliverOrderImpPlanDao) FieldSum(column string, as ...string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.FieldSum(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldMin formats and appends commonly used field "MIN(column)" to the select fields of model.
+func (d *DeliverOrderImpPlanDao) FieldMin(column string, as ...string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.FieldMin(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldMax formats and appends commonly used field "MAX(column)" to the select fields of model.
+func (d *DeliverOrderImpPlanDao) FieldMax(column string, as ...string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.FieldMax(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldAvg formats and appends commonly used field "AVG(column)" to the select fields of model.
+func (d *DeliverOrderImpPlanDao) FieldAvg(column string, as ...string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.FieldAvg(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Option adds extra operation option for the model.
+// Deprecated, use separate operations instead.
+func (d *DeliverOrderImpPlanDao) Option(option int) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Option(option), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitEmpty sets OPTION_OMITEMPTY option for the model, which automatically filers
+// the data and where attributes for empty values.
+func (d *DeliverOrderImpPlanDao) OmitEmpty() *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.OmitEmpty(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitEmptyWhere sets optionOmitEmptyWhere option for the model, which automatically filers
+// the Where/Having parameters for "empty" values.
+func (d *DeliverOrderImpPlanDao) OmitEmptyWhere() *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.OmitEmptyWhere(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitEmptyData sets optionOmitEmptyData option for the model, which automatically filers
+// the Data parameters for "empty" values.
+func (d *DeliverOrderImpPlanDao) OmitEmptyData() *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.OmitEmptyData(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitNil sets optionOmitNil option for the model, which automatically filers
+// the data and where parameters for "nil" values.
+func (d *DeliverOrderImpPlanDao) OmitNil() *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.OmitNil(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitNilWhere sets optionOmitNilWhere option for the model, which automatically filers
+// the Where/Having parameters for "nil" values.
+func (d *DeliverOrderImpPlanDao) OmitNilWhere() *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.OmitNilWhere(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitNilData sets optionOmitNilData option for the model, which automatically filers
+// the Data parameters for "nil" values.
+func (d *DeliverOrderImpPlanDao) OmitNilData() *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.OmitNilData(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Filter marks filtering the fields which does not exist in the fields of the operated table.
+// Note that this function supports only single table operations.
+// Deprecated, filter feature is automatically enabled from GoFrame v1.16.0, it is so no longer used.
+func (d *DeliverOrderImpPlanDao) Filter() *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Filter(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Where sets the condition statement for the model. The parameter <where> can be type of
+// string/map/gmap/slice/struct/*struct, etc. Note that, if it's called more than one times,
+// multiple conditions will be joined into where statement using "AND".
+// Eg:
+// Where("uid=10000")
+// Where("uid", 10000)
+// Where("money>? AND name like ?", 99999, "vip_%")
+// Where("uid", 1).Where("name", "john")
+// Where("status IN (?)", g.Slice{1,2,3})
+// Where("age IN(?,?)", 18, 50)
+// Where(User{ Id : 1, UserName : "john"})
+func (d *DeliverOrderImpPlanDao) Where(where interface{}, args ...interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Where(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WherePri does the same logic as M.Where except that if the parameter <where>
+// is a single condition like int/string/float/slice, it treats the condition as the primary
+// key value. That is, if primary key is "id" and given <where> parameter as "123", the
+// WherePri function treats the condition as "id=123", but M.Where treats the condition
+// as string "123".
+func (d *DeliverOrderImpPlanDao) WherePri(where interface{}, args ...interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WherePri(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Having sets the having statement for the model.
+// The parameters of this function usage are as the same as function Where.
+// See Where.
+func (d *DeliverOrderImpPlanDao) Having(having interface{}, args ...interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Having(having, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Wheref builds condition string using fmt.Sprintf and arguments.
+// Note that if the number of "args" is more than the place holder in "format",
+// the extra "args" will be used as the where condition arguments of the Model.
+func (d *DeliverOrderImpPlanDao) Wheref(format string, args ...interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Wheref(format, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereLT builds "column < value" statement.
+func (d *DeliverOrderImpPlanDao) WhereLT(column string, value interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereLT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereLTE builds "column <= value" statement.
+func (d *DeliverOrderImpPlanDao) WhereLTE(column string, value interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereLTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereGT builds "column > value" statement.
+func (d *DeliverOrderImpPlanDao) WhereGT(column string, value interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereGT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereGTE builds "column >= value" statement.
+func (d *DeliverOrderImpPlanDao) WhereGTE(column string, value interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereGTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereBetween builds "column BETWEEN min AND max" statement.
+func (d *DeliverOrderImpPlanDao) WhereBetween(column string, min, max interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereLike builds "column LIKE like" statement.
+func (d *DeliverOrderImpPlanDao) WhereLike(column string, like interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereIn builds "column IN (in)" statement.
+func (d *DeliverOrderImpPlanDao) WhereIn(column string, in interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNull builds "columns[0] IS NULL AND columns[1] IS NULL ..." statement.
+func (d *DeliverOrderImpPlanDao) WhereNull(columns ...string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotBetween builds "column NOT BETWEEN min AND max" statement.
+func (d *DeliverOrderImpPlanDao) WhereNotBetween(column string, min, max interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotLike builds "column NOT LIKE like" statement.
+func (d *DeliverOrderImpPlanDao) WhereNotLike(column string, like interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNot builds "column != value" statement.
+func (d *DeliverOrderImpPlanDao) WhereNot(column string, value interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereNot(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotIn builds "column NOT IN (in)" statement.
+func (d *DeliverOrderImpPlanDao) WhereNotIn(column string, in interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotNull builds "columns[0] IS NOT NULL AND columns[1] IS NOT NULL ..." statement.
+func (d *DeliverOrderImpPlanDao) WhereNotNull(columns ...string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOr adds "OR" condition to the where statement.
+func (d *DeliverOrderImpPlanDao) WhereOr(where interface{}, args ...interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereOr(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrf builds "OR" condition string using fmt.Sprintf and arguments.
+func (d *DeliverOrderImpPlanDao) WhereOrf(format string, args ...interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereOrf(format, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrLT builds "column < value" statement in "OR" conditions..
+func (d *DeliverOrderImpPlanDao) WhereOrLT(column string, value interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereOrLT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrLTE builds "column <= value" statement in "OR" conditions..
+func (d *DeliverOrderImpPlanDao) WhereOrLTE(column string, value interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereOrLTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrGT builds "column > value" statement in "OR" conditions..
+func (d *DeliverOrderImpPlanDao) WhereOrGT(column string, value interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereOrGT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrGTE builds "column >= value" statement in "OR" conditions..
+func (d *DeliverOrderImpPlanDao) WhereOrGTE(column string, value interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereOrGTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrBetween builds "column BETWEEN min AND max" statement in "OR" conditions.
+func (d *DeliverOrderImpPlanDao) WhereOrBetween(column string, min, max interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereOrBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrLike builds "column LIKE like" statement in "OR" conditions.
+func (d *DeliverOrderImpPlanDao) WhereOrLike(column string, like interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereOrLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrIn builds "column IN (in)" statement in "OR" conditions.
+func (d *DeliverOrderImpPlanDao) WhereOrIn(column string, in interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereOrIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNull builds "columns[0] IS NULL OR columns[1] IS NULL ..." statement in "OR" conditions.
+func (d *DeliverOrderImpPlanDao) WhereOrNull(columns ...string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereOrNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotBetween builds "column NOT BETWEEN min AND max" statement in "OR" conditions.
+func (d *DeliverOrderImpPlanDao) WhereOrNotBetween(column string, min, max interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereOrNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotLike builds "column NOT LIKE like" statement in "OR" conditions.
+func (d *DeliverOrderImpPlanDao) WhereOrNotLike(column string, like interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereOrNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotIn builds "column NOT IN (in)" statement.
+func (d *DeliverOrderImpPlanDao) WhereOrNotIn(column string, in interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereOrNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotNull builds "columns[0] IS NOT NULL OR columns[1] IS NOT NULL ..." statement in "OR" conditions.
+func (d *DeliverOrderImpPlanDao) WhereOrNotNull(columns ...string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.WhereOrNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Group sets the "GROUP BY" statement for the model.
+func (d *DeliverOrderImpPlanDao) Group(groupBy ...string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Group(groupBy...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// And adds "AND" condition to the where statement.
+// Deprecated, use Where instead.
+func (d *DeliverOrderImpPlanDao) And(where interface{}, args ...interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.And(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Or adds "OR" condition to the where statement.
+// Deprecated, use WhereOr instead.
+func (d *DeliverOrderImpPlanDao) Or(where interface{}, args ...interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Or(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// GroupBy sets the "GROUP BY" statement for the model.
+func (d *DeliverOrderImpPlanDao) GroupBy(groupBy string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Group(groupBy), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Order sets the "ORDER BY" statement for the model.
+func (d *DeliverOrderImpPlanDao) Order(orderBy ...string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Order(orderBy...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderAsc sets the "ORDER BY xxx ASC" statement for the model.
+func (d *DeliverOrderImpPlanDao) OrderAsc(column string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.OrderAsc(column), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderDesc sets the "ORDER BY xxx DESC" statement for the model.
+func (d *DeliverOrderImpPlanDao) OrderDesc(column string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.OrderDesc(column), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderRandom sets the "ORDER BY RANDOM()" statement for the model.
+func (d *DeliverOrderImpPlanDao) OrderRandom() *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.OrderRandom(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderBy is alias of Model.Order.
+// See Model.Order.
+// Deprecated, use Order instead.
+func (d *DeliverOrderImpPlanDao) OrderBy(orderBy string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Order(orderBy), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Limit sets the "LIMIT" statement for the model.
+// The parameter <limit> can be either one or two number, if passed two number is passed,
+// it then sets "LIMIT limit[0],limit[1]" statement for the model, or else it sets "LIMIT limit[0]"
+// statement.
+func (d *DeliverOrderImpPlanDao) Limit(limit ...int) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Limit(limit...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Offset sets the "OFFSET" statement for the model.
+// It only makes sense for some databases like SQLServer, PostgreSQL, etc.
+func (d *DeliverOrderImpPlanDao) Offset(offset int) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Offset(offset), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Distinct forces the query to only return distinct results.
+func (d *DeliverOrderImpPlanDao) Distinct() *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Distinct(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Page sets the paging number for the model.
+// The parameter <page> is started from 1 for paging.
+// Note that, it differs that the Limit function start from 0 for "LIMIT" statement.
+func (d *DeliverOrderImpPlanDao) Page(page, limit int) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Page(page, limit), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Batch sets the batch operation number for the model.
+func (d *DeliverOrderImpPlanDao) Batch(batch int) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Batch(batch), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Cache sets the cache feature for the model. It caches the result of the sql, which means
+// if there's another same sql request, it just reads and returns the result from cache, it
+// but not committed and executed into the database.
+//
+// If the parameter <duration> < 0, which means it clear the cache with given <name>.
+// If the parameter <duration> = 0, which means it never expires.
+// If the parameter <duration> > 0, which means it expires after <duration>.
+//
+// The optional parameter <name> is used to bind a name to the cache, which means you can later
+// control the cache like changing the <duration> or clearing the cache with specified <name>.
+//
+// Note that, the cache feature is disabled if the model is operating on a transaction.
+func (d *DeliverOrderImpPlanDao) Cache(duration time.Duration, name ...string) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Cache(duration, name...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Data sets the operation data for the model.
+// The parameter <data> can be type of string/map/gmap/slice/struct/*struct, etc.
+// Eg:
+// Data("uid=10000")
+// Data("uid", 10000)
+// Data(g.Map{"uid": 10000, "name":"john"})
+// Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
+func (d *DeliverOrderImpPlanDao) Data(data ...interface{}) *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Data(data...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// All does "SELECT FROM ..." statement for the model.
+// It retrieves the records from table and returns the result as []*model.DeliverOrderImpPlan.
+// It returns nil if there's no record retrieved with the given conditions from table.
+//
+// The optional parameter <where> is the same as the parameter of M.Where function,
+// see M.Where.
+func (d *DeliverOrderImpPlanDao) All(where ...interface{}) ([]*model.DeliverOrderImpPlan, error) {
+	all, err := d.M.All(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entities []*model.DeliverOrderImpPlan
+	if err = all.Structs(&entities); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entities, nil
+}
+
+// One retrieves one record from table and returns the result as *model.DeliverOrderImpPlan.
+// It returns nil if there's no record retrieved with the given conditions from table.
+//
+// The optional parameter <where> is the same as the parameter of M.Where function,
+// see M.Where.
+func (d *DeliverOrderImpPlanDao) One(where ...interface{}) (*model.DeliverOrderImpPlan, error) {
+	one, err := d.M.One(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entity *model.DeliverOrderImpPlan
+	if err = one.Struct(&entity); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entity, nil
+}
+
+// FindOne retrieves and returns a single Record by M.WherePri and M.One.
+// Also see M.WherePri and M.One.
+func (d *DeliverOrderImpPlanDao) FindOne(where ...interface{}) (*model.DeliverOrderImpPlan, error) {
+	one, err := d.M.FindOne(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entity *model.DeliverOrderImpPlan
+	if err = one.Struct(&entity); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entity, nil
+}
+
+// FindAll retrieves and returns Result by by M.WherePri and M.All.
+// Also see M.WherePri and M.All.
+func (d *DeliverOrderImpPlanDao) FindAll(where ...interface{}) ([]*model.DeliverOrderImpPlan, error) {
+	all, err := d.M.FindAll(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entities []*model.DeliverOrderImpPlan
+	if err = all.Structs(&entities); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entities, nil
+}
+
+// Struct retrieves one record from table and converts it into given struct.
+// The parameter <pointer> should be type of *struct/**struct. If type **struct is given,
+// it can create the struct internally during converting.
+//
+// The optional parameter <where> is the same as the parameter of Model.Where function,
+// see Model.Where.
+//
+// Note that it returns sql.ErrNoRows if there's no record retrieved with the given conditions
+// from table and <pointer> is not nil.
+//
+// Eg:
+// user := new(User)
+// err  := dao.User.Where("id", 1).Struct(user)
+//
+// user := (*User)(nil)
+// err  := dao.User.Where("id", 1).Struct(&user)
+func (d *DeliverOrderImpPlanDao) Struct(pointer interface{}, where ...interface{}) error {
+	return d.M.Struct(pointer, where...)
+}
+
+// Structs retrieves records from table and converts them into given struct slice.
+// The parameter <pointer> should be type of *[]struct/*[]*struct. It can create and fill the struct
+// slice internally during converting.
+//
+// The optional parameter <where> is the same as the parameter of Model.Where function,
+// see Model.Where.
+//
+// Note that it returns sql.ErrNoRows if there's no record retrieved with the given conditions
+// from table and <pointer> is not empty.
+//
+// Eg:
+// users := ([]User)(nil)
+// err   := dao.User.Structs(&users)
+//
+// users := ([]*User)(nil)
+// err   := dao.User.Structs(&users)
+func (d *DeliverOrderImpPlanDao) Structs(pointer interface{}, where ...interface{}) error {
+	return d.M.Structs(pointer, where...)
+}
+
+// Scan automatically calls Struct or Structs function according to the type of parameter <pointer>.
+// It calls function Struct if <pointer> is type of *struct/**struct.
+// It calls function Structs if <pointer> is type of *[]struct/*[]*struct.
+//
+// The optional parameter <where> is the same as the parameter of Model.Where function,
+// see Model.Where.
+//
+// Note that it returns sql.ErrNoRows if there's no record retrieved and given pointer is not empty or nil.
+//
+// Eg:
+// user  := new(User)
+// err   := dao.User.Where("id", 1).Scan(user)
+//
+// user  := (*User)(nil)
+// err   := dao.User.Where("id", 1).Scan(&user)
+//
+// users := ([]User)(nil)
+// err   := dao.User.Scan(&users)
+//
+// users := ([]*User)(nil)
+// err   := dao.User.Scan(&users)
+func (d *DeliverOrderImpPlanDao) Scan(pointer interface{}, where ...interface{}) error {
+	return d.M.Scan(pointer, where...)
+}
+
+// Chunk iterates the table with given size and callback function.
+func (d *DeliverOrderImpPlanDao) Chunk(limit int, callback func(entities []*model.DeliverOrderImpPlan, err error) bool) {
+	d.M.Chunk(limit, func(result gdb.Result, err error) bool {
+		var entities []*model.DeliverOrderImpPlan
+		err = result.Structs(&entities)
+		if err == sql.ErrNoRows {
+			return false
+		}
+		return callback(entities, err)
+	})
+}
+
+// LockUpdate sets the lock for update for current operation.
+func (d *DeliverOrderImpPlanDao) LockUpdate() *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.LockUpdate(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// LockShared sets the lock in share mode for current operation.
+func (d *DeliverOrderImpPlanDao) LockShared() *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.LockShared(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Unscoped enables/disables the soft deleting feature.
+func (d *DeliverOrderImpPlanDao) Unscoped() *DeliverOrderImpPlanDao {
+	return &DeliverOrderImpPlanDao{M: d.M.Unscoped(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// DataScope enables the DataScope feature.
+func (d *DeliverOrderImpPlanDao) DataScope(ctx context.Context, args ...interface{}) *DeliverOrderImpPlanDao {
+	cs := ctx.Value("contextService")
+	dataScope := gconv.Map(gconv.String(gconv.Map(cs)["dataScope"]))
+	if dataScope != nil {
+		// 销售工程师判断
+		var salesEngineerFlag bool
+		if roles, ok := dataScope["roles"]; ok {
+			arr := garray.NewArrayFrom(roles.([]interface{}), true)
+			if arr.Len() == 1 && arr.Contains("SalesEngineer") {
+				salesEngineerFlag = true
+			}
+		}
+		userIds, ok := dataScope["userIds"]
+		specialFlag, userCols, orColsMap := d.checkColumnsName(dataScope, args...)
+
+		var orColumns []string
+		var orValues []interface{}
+		if ok && userIds != "-1" {
+			for _, column := range userCols {
+				if ok, _ := d.M.HasField(column); ok || specialFlag {
+					orColumns = append(orColumns, column+" IN (?) ")
+					orValues = append(orValues, userIds)
+				}
+			}
+		}
+		for col, params := range orColsMap {
+			if ok, _ := d.M.HasField(col); ok || specialFlag {
+				orColumns = append(orColumns, fmt.Sprintf(" ( %s IN (?) )", col))
+				orValues = append(orValues, params)
+			}
+		}
+
+		// 销售工程师权限加成
+		if !salesEngineerFlag {
+			var andColumns []string
+			var andValues []interface{}
+			for col, params := range dataScope {
+				if ok, _ := d.M.HasField(col); ok || specialFlag {
+					andColumns = append(andColumns, fmt.Sprintf(" ( %s IN (?) )", col))
+					andValues = append(andValues, params)
+				}
+			}
+			if len(andColumns) > 0 {
+				andWhereSql := strings.Join(andColumns, " AND ")
+				orColumns = append(orColumns, "("+andWhereSql+")")
+				orValues = append(orValues, andValues...)
+			}
+		}
+
+		whereSql := strings.Join(orColumns, " OR ")
+		return &DeliverOrderImpPlanDao{M: d.M.Where(whereSql, orValues...).Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
+	}
+	return d
+}
+
+// args 1、字段
+// args 2、字段、表名
+// args 3、字段对应关系
+func (d *DeliverOrderImpPlanDao) checkColumnsName(dataScope map[string]interface{}, args ...interface{}) (bool, []string, map[string]interface{}) {
+	var userCols []string
+	tableAs, specialFlag := "", false
+	orColsMap, colsContrast := map[string]interface{}{}, map[string]interface{}{}
+
+	if d.TableAs != "" && len(args) <= 1 {
+		tableAs = d.TableAs + "."
+	}
+	if len(args) > 1 {
+		specialFlag = true
+		if val, ok := args[1].(string); ok {
+			tableAs = val + "."
+		}
+	}
+	if len(args) > 0 {
+		userCols = []string{"created_by"}
+		if column, ok := args[0].(string); ok {
+			userCols = []string{tableAs + column}
+		}
+		if cols, ok := args[0].([]string); ok {
+			for _, v := range cols {
+				userCols = append(userCols, tableAs+v)
+			}
+		}
+		if val, ok := args[0].(map[string]interface{}); ok {
+			specialFlag = true
+			colsContrast = val
+			if orcols, ok := val["orcols"]; ok {
+				if col, ok := orcols.(string); ok && gconv.String(val[col]) != "" {
+					orColsMap[col] = val[col]
+					delete(colsContrast, col)
+				}
+				if cols, ok := orcols.([]string); ok {
+					for _, col := range cols {
+						if gconv.String(val[col]) == "" {
+							continue
+						}
+						orColsMap[col] = val[col]
+						delete(colsContrast, col)
+					}
+				}
+			}
+			delete(colsContrast, "orcols")
+		}
+	}
+	bigColumns := "is_big"
+	if isBig, ok := dataScope[bigColumns]; ok {
+		if bigCol, ok := colsContrast[bigColumns]; ok {
+			orColsMap[bigCol.(string)] = isBig
+			delete(colsContrast, bigCol.(string))
+		} else {
+			if ok, _ := d.M.HasField(bigColumns); ok && specialFlag {
+				orColsMap[tableAs+bigColumns] = isBig
+			}
+		}
+	}
+
+	delete(dataScope, "userIds")
+	delete(dataScope, "roles")
+	delete(dataScope, "posts")
+	delete(dataScope, bigColumns)
+	if len(colsContrast) > 0 {
+		for k, v := range dataScope {
+			if data, ok := colsContrast[k]; ok {
+				dataScope[data.(string)] = v
+			}
+			delete(dataScope, k)
+			delete(colsContrast, k)
+		}
+		for k, v := range colsContrast {
+			dataScope[k] = v
+		}
+	}
+	return specialFlag, userCols, orColsMap
+}

opms_parent/app/dao/work/internal/deliver_order_imp_progress.go

@@ -0,0 +1,839 @@
+// ==========================================================================
+// This is auto-generated by gf cli tool. DO NOT EDIT THIS FILE MANUALLY.
+// ==========================================================================
+
+package internal
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"github.com/gogf/gf/container/garray"
+	"github.com/gogf/gf/database/gdb"
+	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/frame/gmvc"
+	"github.com/gogf/gf/util/gconv"
+	"strings"
+	"time"
+
+	model "dashoo.cn/micro/app/model/work"
+)
+
+// DeliverOrderImpProgressDao is the manager for logic model data accessing and custom defined data operations functions management.
+type DeliverOrderImpProgressDao struct {
+	gmvc.M                                 // M is the core and embedded struct that inherits all chaining operations from gdb.Model.
+	C       deliverOrderImpProgressColumns // C is the short type for Columns, which contains all the column names of Table for convenient usage.
+	DB      gdb.DB                         // DB is the raw underlying database management object.
+	Table   string                         // Table is the underlying table name of the DAO.
+	TableAs string                         // TableAs is the underlying table alias name of the DAO.
+}
+
+// DeliverOrderImpProgressColumns defines and stores column names for table deliver_order_imp_progress.
+type deliverOrderImpProgressColumns struct {
+	Id              string // 主键
+	PlanId          string // 关联实施计划
+	ProgressTitle   string // 任务标题
+	ProgressContext string // 任务内容
+	StartDate       string // 开始时间
+	EndDate         string // 结束时间
+	ReaStartDate    string // 实际开始时间
+	ReaEndDate      string // 实际结束时间
+	ProgressStatus  string // 状态(10未开始20已开始30已完成)
+	ProgressLevel   string // 优先级（10最高 20普通 30较低 ）
+	Remark          string // 备注
+	CreatedBy       string // 创建者
+	CreatedName     string // 创建人
+	CreatedTime     string // 创建时间
+	UpdatedBy       string // 更新者
+	UpdatedName     string // 更新人
+	UpdatedTime     string // 更新时间
+	DeletedTime     string // 删除时间
+}
+
+var (
+	// DeliverOrderImpProgress is globally public accessible object for table deliver_order_imp_progress operations.
+	DeliverOrderImpProgress = DeliverOrderImpProgressDao{
+		M:     g.DB("default").Model("deliver_order_imp_progress").Safe(),
+		DB:    g.DB("default"),
+		Table: "deliver_order_imp_progress",
+		C: deliverOrderImpProgressColumns{
+			Id:              "id",
+			PlanId:          "plan_id",
+			ProgressTitle:   "progress_title",
+			ProgressContext: "progress_context",
+			StartDate:       "start_date",
+			EndDate:         "end_date",
+			ReaStartDate:    "rea_start_date",
+			ReaEndDate:      "rea_end_date",
+			ProgressStatus:  "progress_status",
+			ProgressLevel:   "progress_level",
+			Remark:          "remark",
+			CreatedBy:       "created_by",
+			CreatedName:     "created_name",
+			CreatedTime:     "created_time",
+			UpdatedBy:       "updated_by",
+			UpdatedName:     "updated_name",
+			UpdatedTime:     "updated_time",
+			DeletedTime:     "deleted_time",
+		},
+	}
+)
+
+func NewDeliverOrderImpProgressDao(tenant string) DeliverOrderImpProgressDao {
+	var dao DeliverOrderImpProgressDao
+	dao = DeliverOrderImpProgressDao{
+		M:     g.DB(tenant).Model("deliver_order_imp_progress").Safe(),
+		DB:    g.DB(tenant),
+		Table: "deliver_order_imp_progress",
+		C: deliverOrderImpProgressColumns{
+			Id:              "id",
+			PlanId:          "plan_id",
+			ProgressTitle:   "progress_title",
+			ProgressContext: "progress_context",
+			StartDate:       "start_date",
+			EndDate:         "end_date",
+			ReaStartDate:    "rea_start_date",
+			ReaEndDate:      "rea_end_date",
+			ProgressStatus:  "progress_status",
+			ProgressLevel:   "progress_level",
+			Remark:          "remark",
+			CreatedBy:       "created_by",
+			CreatedName:     "created_name",
+			CreatedTime:     "created_time",
+			UpdatedBy:       "updated_by",
+			UpdatedName:     "updated_name",
+			UpdatedTime:     "updated_time",
+			DeletedTime:     "deleted_time",
+		},
+	}
+	return dao
+}
+
+// Ctx is a chaining function, which creates and returns a new DB that is a shallow copy
+// of current DB object and with given context in it.
+// Note that this returned DB object can be used only once, so do not assign it to
+// a global or package variable for long using.
+func (d *DeliverOrderImpProgressDao) Ctx(ctx context.Context) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
+}
+
+// GetCtx returns the context for current Model.
+// It returns "context.Background() i"s there's no context previously set.
+func (d *DeliverOrderImpProgressDao) GetCtx() context.Context {
+	return d.M.GetCtx()
+}
+
+// As sets an alias name for current table.
+func (d *DeliverOrderImpProgressDao) As(as string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.As(as), Table: d.Table, TableAs: as}
+}
+
+// TX sets the transaction for current operation.
+func (d *DeliverOrderImpProgressDao) TX(tx *gdb.TX) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.TX(tx), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Master marks the following operation on master node.
+func (d *DeliverOrderImpProgressDao) Master() *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Master(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Slave marks the following operation on slave node.
+// Note that it makes sense only if there's any slave node configured.
+func (d *DeliverOrderImpProgressDao) Slave() *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Slave(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Args sets custom arguments for model operation.
+func (d *DeliverOrderImpProgressDao) Args(args ...interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Args(args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Handler calls each of "handlers" on current Model and returns a new Model.
+// ModelHandler is a function that handles given Model and returns a new Model that is custom modified.
+func (d *DeliverOrderImpProgressDao) Handler(handlers ...gdb.ModelHandler) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Handler(handlers...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// LeftJoin does "LEFT JOIN ... ON ..." statement on the model.
+// The parameter <table> can be joined table and its joined condition,
+// and also with its alias name, like:
+// Table("user").LeftJoin("user_detail", "user_detail.uid=user.uid")
+// Table("user", "u").LeftJoin("user_detail", "ud", "ud.uid=u.uid")
+func (d *DeliverOrderImpProgressDao) LeftJoin(table ...string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.LeftJoin(table...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// RightJoin does "RIGHT JOIN ... ON ..." statement on the model.
+// The parameter <table> can be joined table and its joined condition,
+// and also with its alias name, like:
+// Table("user").RightJoin("user_detail", "user_detail.uid=user.uid")
+// Table("user", "u").RightJoin("user_detail", "ud", "ud.uid=u.uid")
+func (d *DeliverOrderImpProgressDao) RightJoin(table ...string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.RightJoin(table...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// InnerJoin does "INNER JOIN ... ON ..." statement on the model.
+// The parameter <table> can be joined table and its joined condition,
+// and also with its alias name, like:
+// Table("user").InnerJoin("user_detail", "user_detail.uid=user.uid")
+// Table("user", "u").InnerJoin("user_detail", "ud", "ud.uid=u.uid")
+func (d *DeliverOrderImpProgressDao) InnerJoin(table ...string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.InnerJoin(table...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Fields sets the operation fields of the model, multiple fields joined using char ','.
+// The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
+func (d *DeliverOrderImpProgressDao) Fields(fieldNamesOrMapStruct ...interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Fields(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldsEx sets the excluded operation fields of the model, multiple fields joined using char ','.
+// The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
+func (d *DeliverOrderImpProgressDao) FieldsEx(fieldNamesOrMapStruct ...interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.FieldsEx(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldCount formats and appends commonly used field "COUNT(column)" to the select fields of model.
+func (d *DeliverOrderImpProgressDao) FieldCount(column string, as ...string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.FieldCount(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldSum formats and appends commonly used field "SUM(column)" to the select fields of model.
+func (d *DeliverOrderImpProgressDao) FieldSum(column string, as ...string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.FieldSum(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldMin formats and appends commonly used field "MIN(column)" to the select fields of model.
+func (d *DeliverOrderImpProgressDao) FieldMin(column string, as ...string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.FieldMin(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldMax formats and appends commonly used field "MAX(column)" to the select fields of model.
+func (d *DeliverOrderImpProgressDao) FieldMax(column string, as ...string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.FieldMax(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldAvg formats and appends commonly used field "AVG(column)" to the select fields of model.
+func (d *DeliverOrderImpProgressDao) FieldAvg(column string, as ...string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.FieldAvg(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Option adds extra operation option for the model.
+// Deprecated, use separate operations instead.
+func (d *DeliverOrderImpProgressDao) Option(option int) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Option(option), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitEmpty sets OPTION_OMITEMPTY option for the model, which automatically filers
+// the data and where attributes for empty values.
+func (d *DeliverOrderImpProgressDao) OmitEmpty() *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.OmitEmpty(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitEmptyWhere sets optionOmitEmptyWhere option for the model, which automatically filers
+// the Where/Having parameters for "empty" values.
+func (d *DeliverOrderImpProgressDao) OmitEmptyWhere() *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.OmitEmptyWhere(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitEmptyData sets optionOmitEmptyData option for the model, which automatically filers
+// the Data parameters for "empty" values.
+func (d *DeliverOrderImpProgressDao) OmitEmptyData() *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.OmitEmptyData(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitNil sets optionOmitNil option for the model, which automatically filers
+// the data and where parameters for "nil" values.
+func (d *DeliverOrderImpProgressDao) OmitNil() *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.OmitNil(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitNilWhere sets optionOmitNilWhere option for the model, which automatically filers
+// the Where/Having parameters for "nil" values.
+func (d *DeliverOrderImpProgressDao) OmitNilWhere() *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.OmitNilWhere(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitNilData sets optionOmitNilData option for the model, which automatically filers
+// the Data parameters for "nil" values.
+func (d *DeliverOrderImpProgressDao) OmitNilData() *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.OmitNilData(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Filter marks filtering the fields which does not exist in the fields of the operated table.
+// Note that this function supports only single table operations.
+// Deprecated, filter feature is automatically enabled from GoFrame v1.16.0, it is so no longer used.
+func (d *DeliverOrderImpProgressDao) Filter() *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Filter(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Where sets the condition statement for the model. The parameter <where> can be type of
+// string/map/gmap/slice/struct/*struct, etc. Note that, if it's called more than one times,
+// multiple conditions will be joined into where statement using "AND".
+// Eg:
+// Where("uid=10000")
+// Where("uid", 10000)
+// Where("money>? AND name like ?", 99999, "vip_%")
+// Where("uid", 1).Where("name", "john")
+// Where("status IN (?)", g.Slice{1,2,3})
+// Where("age IN(?,?)", 18, 50)
+// Where(User{ Id : 1, UserName : "john"})
+func (d *DeliverOrderImpProgressDao) Where(where interface{}, args ...interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Where(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WherePri does the same logic as M.Where except that if the parameter <where>
+// is a single condition like int/string/float/slice, it treats the condition as the primary
+// key value. That is, if primary key is "id" and given <where> parameter as "123", the
+// WherePri function treats the condition as "id=123", but M.Where treats the condition
+// as string "123".
+func (d *DeliverOrderImpProgressDao) WherePri(where interface{}, args ...interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WherePri(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Having sets the having statement for the model.
+// The parameters of this function usage are as the same as function Where.
+// See Where.
+func (d *DeliverOrderImpProgressDao) Having(having interface{}, args ...interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Having(having, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Wheref builds condition string using fmt.Sprintf and arguments.
+// Note that if the number of "args" is more than the place holder in "format",
+// the extra "args" will be used as the where condition arguments of the Model.
+func (d *DeliverOrderImpProgressDao) Wheref(format string, args ...interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Wheref(format, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereLT builds "column < value" statement.
+func (d *DeliverOrderImpProgressDao) WhereLT(column string, value interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereLT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereLTE builds "column <= value" statement.
+func (d *DeliverOrderImpProgressDao) WhereLTE(column string, value interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereLTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereGT builds "column > value" statement.
+func (d *DeliverOrderImpProgressDao) WhereGT(column string, value interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereGT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereGTE builds "column >= value" statement.
+func (d *DeliverOrderImpProgressDao) WhereGTE(column string, value interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereGTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereBetween builds "column BETWEEN min AND max" statement.
+func (d *DeliverOrderImpProgressDao) WhereBetween(column string, min, max interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereLike builds "column LIKE like" statement.
+func (d *DeliverOrderImpProgressDao) WhereLike(column string, like interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereIn builds "column IN (in)" statement.
+func (d *DeliverOrderImpProgressDao) WhereIn(column string, in interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNull builds "columns[0] IS NULL AND columns[1] IS NULL ..." statement.
+func (d *DeliverOrderImpProgressDao) WhereNull(columns ...string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotBetween builds "column NOT BETWEEN min AND max" statement.
+func (d *DeliverOrderImpProgressDao) WhereNotBetween(column string, min, max interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotLike builds "column NOT LIKE like" statement.
+func (d *DeliverOrderImpProgressDao) WhereNotLike(column string, like interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNot builds "column != value" statement.
+func (d *DeliverOrderImpProgressDao) WhereNot(column string, value interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereNot(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotIn builds "column NOT IN (in)" statement.
+func (d *DeliverOrderImpProgressDao) WhereNotIn(column string, in interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotNull builds "columns[0] IS NOT NULL AND columns[1] IS NOT NULL ..." statement.
+func (d *DeliverOrderImpProgressDao) WhereNotNull(columns ...string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOr adds "OR" condition to the where statement.
+func (d *DeliverOrderImpProgressDao) WhereOr(where interface{}, args ...interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereOr(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrf builds "OR" condition string using fmt.Sprintf and arguments.
+func (d *DeliverOrderImpProgressDao) WhereOrf(format string, args ...interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereOrf(format, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrLT builds "column < value" statement in "OR" conditions..
+func (d *DeliverOrderImpProgressDao) WhereOrLT(column string, value interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereOrLT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrLTE builds "column <= value" statement in "OR" conditions..
+func (d *DeliverOrderImpProgressDao) WhereOrLTE(column string, value interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereOrLTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrGT builds "column > value" statement in "OR" conditions..
+func (d *DeliverOrderImpProgressDao) WhereOrGT(column string, value interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereOrGT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrGTE builds "column >= value" statement in "OR" conditions..
+func (d *DeliverOrderImpProgressDao) WhereOrGTE(column string, value interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereOrGTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrBetween builds "column BETWEEN min AND max" statement in "OR" conditions.
+func (d *DeliverOrderImpProgressDao) WhereOrBetween(column string, min, max interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereOrBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrLike builds "column LIKE like" statement in "OR" conditions.
+func (d *DeliverOrderImpProgressDao) WhereOrLike(column string, like interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereOrLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrIn builds "column IN (in)" statement in "OR" conditions.
+func (d *DeliverOrderImpProgressDao) WhereOrIn(column string, in interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereOrIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNull builds "columns[0] IS NULL OR columns[1] IS NULL ..." statement in "OR" conditions.
+func (d *DeliverOrderImpProgressDao) WhereOrNull(columns ...string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereOrNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotBetween builds "column NOT BETWEEN min AND max" statement in "OR" conditions.
+func (d *DeliverOrderImpProgressDao) WhereOrNotBetween(column string, min, max interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereOrNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotLike builds "column NOT LIKE like" statement in "OR" conditions.
+func (d *DeliverOrderImpProgressDao) WhereOrNotLike(column string, like interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereOrNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotIn builds "column NOT IN (in)" statement.
+func (d *DeliverOrderImpProgressDao) WhereOrNotIn(column string, in interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereOrNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotNull builds "columns[0] IS NOT NULL OR columns[1] IS NOT NULL ..." statement in "OR" conditions.
+func (d *DeliverOrderImpProgressDao) WhereOrNotNull(columns ...string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.WhereOrNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Group sets the "GROUP BY" statement for the model.
+func (d *DeliverOrderImpProgressDao) Group(groupBy ...string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Group(groupBy...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// And adds "AND" condition to the where statement.
+// Deprecated, use Where instead.
+func (d *DeliverOrderImpProgressDao) And(where interface{}, args ...interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.And(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Or adds "OR" condition to the where statement.
+// Deprecated, use WhereOr instead.
+func (d *DeliverOrderImpProgressDao) Or(where interface{}, args ...interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Or(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// GroupBy sets the "GROUP BY" statement for the model.
+func (d *DeliverOrderImpProgressDao) GroupBy(groupBy string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Group(groupBy), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Order sets the "ORDER BY" statement for the model.
+func (d *DeliverOrderImpProgressDao) Order(orderBy ...string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Order(orderBy...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderAsc sets the "ORDER BY xxx ASC" statement for the model.
+func (d *DeliverOrderImpProgressDao) OrderAsc(column string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.OrderAsc(column), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderDesc sets the "ORDER BY xxx DESC" statement for the model.
+func (d *DeliverOrderImpProgressDao) OrderDesc(column string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.OrderDesc(column), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderRandom sets the "ORDER BY RANDOM()" statement for the model.
+func (d *DeliverOrderImpProgressDao) OrderRandom() *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.OrderRandom(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderBy is alias of Model.Order.
+// See Model.Order.
+// Deprecated, use Order instead.
+func (d *DeliverOrderImpProgressDao) OrderBy(orderBy string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Order(orderBy), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Limit sets the "LIMIT" statement for the model.
+// The parameter <limit> can be either one or two number, if passed two number is passed,
+// it then sets "LIMIT limit[0],limit[1]" statement for the model, or else it sets "LIMIT limit[0]"
+// statement.
+func (d *DeliverOrderImpProgressDao) Limit(limit ...int) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Limit(limit...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Offset sets the "OFFSET" statement for the model.
+// It only makes sense for some databases like SQLServer, PostgreSQL, etc.
+func (d *DeliverOrderImpProgressDao) Offset(offset int) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Offset(offset), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Distinct forces the query to only return distinct results.
+func (d *DeliverOrderImpProgressDao) Distinct() *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Distinct(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Page sets the paging number for the model.
+// The parameter <page> is started from 1 for paging.
+// Note that, it differs that the Limit function start from 0 for "LIMIT" statement.
+func (d *DeliverOrderImpProgressDao) Page(page, limit int) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Page(page, limit), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Batch sets the batch operation number for the model.
+func (d *DeliverOrderImpProgressDao) Batch(batch int) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Batch(batch), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Cache sets the cache feature for the model. It caches the result of the sql, which means
+// if there's another same sql request, it just reads and returns the result from cache, it
+// but not committed and executed into the database.
+//
+// If the parameter <duration> < 0, which means it clear the cache with given <name>.
+// If the parameter <duration> = 0, which means it never expires.
+// If the parameter <duration> > 0, which means it expires after <duration>.
+//
+// The optional parameter <name> is used to bind a name to the cache, which means you can later
+// control the cache like changing the <duration> or clearing the cache with specified <name>.
+//
+// Note that, the cache feature is disabled if the model is operating on a transaction.
+func (d *DeliverOrderImpProgressDao) Cache(duration time.Duration, name ...string) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Cache(duration, name...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Data sets the operation data for the model.
+// The parameter <data> can be type of string/map/gmap/slice/struct/*struct, etc.
+// Eg:
+// Data("uid=10000")
+// Data("uid", 10000)
+// Data(g.Map{"uid": 10000, "name":"john"})
+// Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
+func (d *DeliverOrderImpProgressDao) Data(data ...interface{}) *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Data(data...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// All does "SELECT FROM ..." statement for the model.
+// It retrieves the records from table and returns the result as []*model.DeliverOrderImpProgress.
+// It returns nil if there's no record retrieved with the given conditions from table.
+//
+// The optional parameter <where> is the same as the parameter of M.Where function,
+// see M.Where.
+func (d *DeliverOrderImpProgressDao) All(where ...interface{}) ([]*model.DeliverOrderImpProgress, error) {
+	all, err := d.M.All(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entities []*model.DeliverOrderImpProgress
+	if err = all.Structs(&entities); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entities, nil
+}
+
+// One retrieves one record from table and returns the result as *model.DeliverOrderImpProgress.
+// It returns nil if there's no record retrieved with the given conditions from table.
+//
+// The optional parameter <where> is the same as the parameter of M.Where function,
+// see M.Where.
+func (d *DeliverOrderImpProgressDao) One(where ...interface{}) (*model.DeliverOrderImpProgress, error) {
+	one, err := d.M.One(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entity *model.DeliverOrderImpProgress
+	if err = one.Struct(&entity); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entity, nil
+}
+
+// FindOne retrieves and returns a single Record by M.WherePri and M.One.
+// Also see M.WherePri and M.One.
+func (d *DeliverOrderImpProgressDao) FindOne(where ...interface{}) (*model.DeliverOrderImpProgress, error) {
+	one, err := d.M.FindOne(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entity *model.DeliverOrderImpProgress
+	if err = one.Struct(&entity); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entity, nil
+}
+
+// FindAll retrieves and returns Result by by M.WherePri and M.All.
+// Also see M.WherePri and M.All.
+func (d *DeliverOrderImpProgressDao) FindAll(where ...interface{}) ([]*model.DeliverOrderImpProgress, error) {
+	all, err := d.M.FindAll(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entities []*model.DeliverOrderImpProgress
+	if err = all.Structs(&entities); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entities, nil
+}
+
+// Struct retrieves one record from table and converts it into given struct.
+// The parameter <pointer> should be type of *struct/**struct. If type **struct is given,
+// it can create the struct internally during converting.
+//
+// The optional parameter <where> is the same as the parameter of Model.Where function,
+// see Model.Where.
+//
+// Note that it returns sql.ErrNoRows if there's no record retrieved with the given conditions
+// from table and <pointer> is not nil.
+//
+// Eg:
+// user := new(User)
+// err  := dao.User.Where("id", 1).Struct(user)
+//
+// user := (*User)(nil)
+// err  := dao.User.Where("id", 1).Struct(&user)
+func (d *DeliverOrderImpProgressDao) Struct(pointer interface{}, where ...interface{}) error {
+	return d.M.Struct(pointer, where...)
+}
+
+// Structs retrieves records from table and converts them into given struct slice.
+// The parameter <pointer> should be type of *[]struct/*[]*struct. It can create and fill the struct
+// slice internally during converting.
+//
+// The optional parameter <where> is the same as the parameter of Model.Where function,
+// see Model.Where.
+//
+// Note that it returns sql.ErrNoRows if there's no record retrieved with the given conditions
+// from table and <pointer> is not empty.
+//
+// Eg:
+// users := ([]User)(nil)
+// err   := dao.User.Structs(&users)
+//
+// users := ([]*User)(nil)
+// err   := dao.User.Structs(&users)
+func (d *DeliverOrderImpProgressDao) Structs(pointer interface{}, where ...interface{}) error {
+	return d.M.Structs(pointer, where...)
+}
+
+// Scan automatically calls Struct or Structs function according to the type of parameter <pointer>.
+// It calls function Struct if <pointer> is type of *struct/**struct.
+// It calls function Structs if <pointer> is type of *[]struct/*[]*struct.
+//
+// The optional parameter <where> is the same as the parameter of Model.Where function,
+// see Model.Where.
+//
+// Note that it returns sql.ErrNoRows if there's no record retrieved and given pointer is not empty or nil.
+//
+// Eg:
+// user  := new(User)
+// err   := dao.User.Where("id", 1).Scan(user)
+//
+// user  := (*User)(nil)
+// err   := dao.User.Where("id", 1).Scan(&user)
+//
+// users := ([]User)(nil)
+// err   := dao.User.Scan(&users)
+//
+// users := ([]*User)(nil)
+// err   := dao.User.Scan(&users)
+func (d *DeliverOrderImpProgressDao) Scan(pointer interface{}, where ...interface{}) error {
+	return d.M.Scan(pointer, where...)
+}
+
+// Chunk iterates the table with given size and callback function.
+func (d *DeliverOrderImpProgressDao) Chunk(limit int, callback func(entities []*model.DeliverOrderImpProgress, err error) bool) {
+	d.M.Chunk(limit, func(result gdb.Result, err error) bool {
+		var entities []*model.DeliverOrderImpProgress
+		err = result.Structs(&entities)
+		if err == sql.ErrNoRows {
+			return false
+		}
+		return callback(entities, err)
+	})
+}
+
+// LockUpdate sets the lock for update for current operation.
+func (d *DeliverOrderImpProgressDao) LockUpdate() *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.LockUpdate(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// LockShared sets the lock in share mode for current operation.
+func (d *DeliverOrderImpProgressDao) LockShared() *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.LockShared(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Unscoped enables/disables the soft deleting feature.
+func (d *DeliverOrderImpProgressDao) Unscoped() *DeliverOrderImpProgressDao {
+	return &DeliverOrderImpProgressDao{M: d.M.Unscoped(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// DataScope enables the DataScope feature.
+func (d *DeliverOrderImpProgressDao) DataScope(ctx context.Context, args ...interface{}) *DeliverOrderImpProgressDao {
+	cs := ctx.Value("contextService")
+	dataScope := gconv.Map(gconv.String(gconv.Map(cs)["dataScope"]))
+	if dataScope != nil {
+		// 销售工程师判断
+		var salesEngineerFlag bool
+		if roles, ok := dataScope["roles"]; ok {
+			arr := garray.NewArrayFrom(roles.([]interface{}), true)
+			if arr.Len() == 1 && arr.Contains("SalesEngineer") {
+				salesEngineerFlag = true
+			}
+		}
+		userIds, ok := dataScope["userIds"]
+		specialFlag, userCols, orColsMap := d.checkColumnsName(dataScope, args...)
+
+		var orColumns []string
+		var orValues []interface{}
+		if ok && userIds != "-1" {
+			for _, column := range userCols {
+				if ok, _ := d.M.HasField(column); ok || specialFlag {
+					orColumns = append(orColumns, column+" IN (?) ")
+					orValues = append(orValues, userIds)
+				}
+			}
+		}
+		for col, params := range orColsMap {
+			if ok, _ := d.M.HasField(col); ok || specialFlag {
+				orColumns = append(orColumns, fmt.Sprintf(" ( %s IN (?) )", col))
+				orValues = append(orValues, params)
+			}
+		}
+
+		// 销售工程师权限加成
+		if !salesEngineerFlag {
+			var andColumns []string
+			var andValues []interface{}
+			for col, params := range dataScope {
+				if ok, _ := d.M.HasField(col); ok || specialFlag {
+					andColumns = append(andColumns, fmt.Sprintf(" ( %s IN (?) )", col))
+					andValues = append(andValues, params)
+				}
+			}
+			if len(andColumns) > 0 {
+				andWhereSql := strings.Join(andColumns, " AND ")
+				orColumns = append(orColumns, "("+andWhereSql+")")
+				orValues = append(orValues, andValues...)
+			}
+		}
+
+		whereSql := strings.Join(orColumns, " OR ")
+		return &DeliverOrderImpProgressDao{M: d.M.Where(whereSql, orValues...).Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
+	}
+	return d
+}
+
+// args 1、字段
+// args 2、字段、表名
+// args 3、字段对应关系
+func (d *DeliverOrderImpProgressDao) checkColumnsName(dataScope map[string]interface{}, args ...interface{}) (bool, []string, map[string]interface{}) {
+	var userCols []string
+	tableAs, specialFlag := "", false
+	orColsMap, colsContrast := map[string]interface{}{}, map[string]interface{}{}
+
+	if d.TableAs != "" && len(args) <= 1 {
+		tableAs = d.TableAs + "."
+	}
+	if len(args) > 1 {
+		specialFlag = true
+		if val, ok := args[1].(string); ok {
+			tableAs = val + "."
+		}
+	}
+	if len(args) > 0 {
+		userCols = []string{"created_by"}
+		if column, ok := args[0].(string); ok {
+			userCols = []string{tableAs + column}
+		}
+		if cols, ok := args[0].([]string); ok {
+			for _, v := range cols {
+				userCols = append(userCols, tableAs+v)
+			}
+		}
+		if val, ok := args[0].(map[string]interface{}); ok {
+			specialFlag = true
+			colsContrast = val
+			if orcols, ok := val["orcols"]; ok {
+				if col, ok := orcols.(string); ok && gconv.String(val[col]) != "" {
+					orColsMap[col] = val[col]
+					delete(colsContrast, col)
+				}
+				if cols, ok := orcols.([]string); ok {
+					for _, col := range cols {
+						if gconv.String(val[col]) == "" {
+							continue
+						}
+						orColsMap[col] = val[col]
+						delete(colsContrast, col)
+					}
+				}
+			}
+			delete(colsContrast, "orcols")
+		}
+	}
+	bigColumns := "is_big"
+	if isBig, ok := dataScope[bigColumns]; ok {
+		if bigCol, ok := colsContrast[bigColumns]; ok {
+			orColsMap[bigCol.(string)] = isBig
+			delete(colsContrast, bigCol.(string))
+		} else {
+			if ok, _ := d.M.HasField(bigColumns); ok && specialFlag {
+				orColsMap[tableAs+bigColumns] = isBig
+			}
+		}
+	}
+
+	delete(dataScope, "userIds")
+	delete(dataScope, "roles")
+	delete(dataScope, "posts")
+	delete(dataScope, bigColumns)
+	if len(colsContrast) > 0 {
+		for k, v := range dataScope {
+			if data, ok := colsContrast[k]; ok {
+				dataScope[data.(string)] = v
+			}
+			delete(dataScope, k)
+			delete(colsContrast, k)
+		}
+		for k, v := range colsContrast {
+			dataScope[k] = v
+		}
+	}
+	return specialFlag, userCols, orColsMap
+}

opms_parent/app/dao/work/internal/deliver_order_product.go

@@ -0,0 +1,827 @@
+// ==========================================================================
+// This is auto-generated by gf cli tool. DO NOT EDIT THIS FILE MANUALLY.
+// ==========================================================================
+
+package internal
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"github.com/gogf/gf/container/garray"
+	"github.com/gogf/gf/database/gdb"
+	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/frame/gmvc"
+	"github.com/gogf/gf/util/gconv"
+	"strings"
+	"time"
+
+	model "dashoo.cn/micro/app/model/work"
+)
+
+// DeliverOrderProductDao is the manager for logic model data accessing and custom defined data operations functions management.
+type DeliverOrderProductDao struct {
+	gmvc.M                             // M is the core and embedded struct that inherits all chaining operations from gdb.Model.
+	C       deliverOrderProductColumns // C is the short type for Columns, which contains all the column names of Table for convenient usage.
+	DB      gdb.DB                     // DB is the raw underlying database management object.
+	Table   string                     // Table is the underlying table name of the DAO.
+	TableAs string                     // TableAs is the underlying table alias name of the DAO.
+}
+
+// DeliverOrderProductColumns defines and stores column names for table deliver_order_product.
+type deliverOrderProductColumns struct {
+	Id             string // 主键
+	DeliverOrderId string // 关联交付订单ID
+	ProductCode    string // 产品编码
+	ProductName    string // 产品名称
+	ProductType    string // 产品类型
+	ProductNum     string // 产品数量
+	Remark         string // 备注
+	CreatedBy      string // 创建者
+	CreatedName    string // 创建人
+	CreatedTime    string // 创建时间
+	UpdatedBy      string // 更新者
+	UpdatedName    string // 更新人
+	UpdatedTime    string // 更新时间
+	DeletedTime    string // 删除时间
+}
+
+var (
+	// DeliverOrderProduct is globally public accessible object for table deliver_order_product operations.
+	DeliverOrderProduct = DeliverOrderProductDao{
+		M:     g.DB("default").Model("deliver_order_product").Safe(),
+		DB:    g.DB("default"),
+		Table: "deliver_order_product",
+		C: deliverOrderProductColumns{
+			Id:             "id",
+			DeliverOrderId: "deliver_order_id",
+			ProductCode:    "product_code",
+			ProductName:    "product_name",
+			ProductType:    "product_type",
+			ProductNum:     "product_num",
+			Remark:         "remark",
+			CreatedBy:      "created_by",
+			CreatedName:    "created_name",
+			CreatedTime:    "created_time",
+			UpdatedBy:      "updated_by",
+			UpdatedName:    "updated_name",
+			UpdatedTime:    "updated_time",
+			DeletedTime:    "deleted_time",
+		},
+	}
+)
+
+func NewDeliverOrderProductDao(tenant string) DeliverOrderProductDao {
+	var dao DeliverOrderProductDao
+	dao = DeliverOrderProductDao{
+		M:     g.DB(tenant).Model("deliver_order_product").Safe(),
+		DB:    g.DB(tenant),
+		Table: "deliver_order_product",
+		C: deliverOrderProductColumns{
+			Id:             "id",
+			DeliverOrderId: "deliver_order_id",
+			ProductCode:    "product_code",
+			ProductName:    "product_name",
+			ProductType:    "product_type",
+			ProductNum:     "product_num",
+			Remark:         "remark",
+			CreatedBy:      "created_by",
+			CreatedName:    "created_name",
+			CreatedTime:    "created_time",
+			UpdatedBy:      "updated_by",
+			UpdatedName:    "updated_name",
+			UpdatedTime:    "updated_time",
+			DeletedTime:    "deleted_time",
+		},
+	}
+	return dao
+}
+
+// Ctx is a chaining function, which creates and returns a new DB that is a shallow copy
+// of current DB object and with given context in it.
+// Note that this returned DB object can be used only once, so do not assign it to
+// a global or package variable for long using.
+func (d *DeliverOrderProductDao) Ctx(ctx context.Context) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
+}
+
+// GetCtx returns the context for current Model.
+// It returns "context.Background() i"s there's no context previously set.
+func (d *DeliverOrderProductDao) GetCtx() context.Context {
+	return d.M.GetCtx()
+}
+
+// As sets an alias name for current table.
+func (d *DeliverOrderProductDao) As(as string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.As(as), Table: d.Table, TableAs: as}
+}
+
+// TX sets the transaction for current operation.
+func (d *DeliverOrderProductDao) TX(tx *gdb.TX) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.TX(tx), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Master marks the following operation on master node.
+func (d *DeliverOrderProductDao) Master() *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Master(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Slave marks the following operation on slave node.
+// Note that it makes sense only if there's any slave node configured.
+func (d *DeliverOrderProductDao) Slave() *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Slave(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Args sets custom arguments for model operation.
+func (d *DeliverOrderProductDao) Args(args ...interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Args(args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Handler calls each of "handlers" on current Model and returns a new Model.
+// ModelHandler is a function that handles given Model and returns a new Model that is custom modified.
+func (d *DeliverOrderProductDao) Handler(handlers ...gdb.ModelHandler) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Handler(handlers...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// LeftJoin does "LEFT JOIN ... ON ..." statement on the model.
+// The parameter <table> can be joined table and its joined condition,
+// and also with its alias name, like:
+// Table("user").LeftJoin("user_detail", "user_detail.uid=user.uid")
+// Table("user", "u").LeftJoin("user_detail", "ud", "ud.uid=u.uid")
+func (d *DeliverOrderProductDao) LeftJoin(table ...string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.LeftJoin(table...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// RightJoin does "RIGHT JOIN ... ON ..." statement on the model.
+// The parameter <table> can be joined table and its joined condition,
+// and also with its alias name, like:
+// Table("user").RightJoin("user_detail", "user_detail.uid=user.uid")
+// Table("user", "u").RightJoin("user_detail", "ud", "ud.uid=u.uid")
+func (d *DeliverOrderProductDao) RightJoin(table ...string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.RightJoin(table...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// InnerJoin does "INNER JOIN ... ON ..." statement on the model.
+// The parameter <table> can be joined table and its joined condition,
+// and also with its alias name, like:
+// Table("user").InnerJoin("user_detail", "user_detail.uid=user.uid")
+// Table("user", "u").InnerJoin("user_detail", "ud", "ud.uid=u.uid")
+func (d *DeliverOrderProductDao) InnerJoin(table ...string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.InnerJoin(table...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Fields sets the operation fields of the model, multiple fields joined using char ','.
+// The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
+func (d *DeliverOrderProductDao) Fields(fieldNamesOrMapStruct ...interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Fields(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldsEx sets the excluded operation fields of the model, multiple fields joined using char ','.
+// The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
+func (d *DeliverOrderProductDao) FieldsEx(fieldNamesOrMapStruct ...interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.FieldsEx(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldCount formats and appends commonly used field "COUNT(column)" to the select fields of model.
+func (d *DeliverOrderProductDao) FieldCount(column string, as ...string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.FieldCount(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldSum formats and appends commonly used field "SUM(column)" to the select fields of model.
+func (d *DeliverOrderProductDao) FieldSum(column string, as ...string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.FieldSum(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldMin formats and appends commonly used field "MIN(column)" to the select fields of model.
+func (d *DeliverOrderProductDao) FieldMin(column string, as ...string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.FieldMin(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldMax formats and appends commonly used field "MAX(column)" to the select fields of model.
+func (d *DeliverOrderProductDao) FieldMax(column string, as ...string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.FieldMax(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// FieldAvg formats and appends commonly used field "AVG(column)" to the select fields of model.
+func (d *DeliverOrderProductDao) FieldAvg(column string, as ...string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.FieldAvg(column, as...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Option adds extra operation option for the model.
+// Deprecated, use separate operations instead.
+func (d *DeliverOrderProductDao) Option(option int) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Option(option), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitEmpty sets OPTION_OMITEMPTY option for the model, which automatically filers
+// the data and where attributes for empty values.
+func (d *DeliverOrderProductDao) OmitEmpty() *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.OmitEmpty(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitEmptyWhere sets optionOmitEmptyWhere option for the model, which automatically filers
+// the Where/Having parameters for "empty" values.
+func (d *DeliverOrderProductDao) OmitEmptyWhere() *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.OmitEmptyWhere(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitEmptyData sets optionOmitEmptyData option for the model, which automatically filers
+// the Data parameters for "empty" values.
+func (d *DeliverOrderProductDao) OmitEmptyData() *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.OmitEmptyData(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitNil sets optionOmitNil option for the model, which automatically filers
+// the data and where parameters for "nil" values.
+func (d *DeliverOrderProductDao) OmitNil() *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.OmitNil(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitNilWhere sets optionOmitNilWhere option for the model, which automatically filers
+// the Where/Having parameters for "nil" values.
+func (d *DeliverOrderProductDao) OmitNilWhere() *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.OmitNilWhere(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OmitNilData sets optionOmitNilData option for the model, which automatically filers
+// the Data parameters for "nil" values.
+func (d *DeliverOrderProductDao) OmitNilData() *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.OmitNilData(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Filter marks filtering the fields which does not exist in the fields of the operated table.
+// Note that this function supports only single table operations.
+// Deprecated, filter feature is automatically enabled from GoFrame v1.16.0, it is so no longer used.
+func (d *DeliverOrderProductDao) Filter() *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Filter(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Where sets the condition statement for the model. The parameter <where> can be type of
+// string/map/gmap/slice/struct/*struct, etc. Note that, if it's called more than one times,
+// multiple conditions will be joined into where statement using "AND".
+// Eg:
+// Where("uid=10000")
+// Where("uid", 10000)
+// Where("money>? AND name like ?", 99999, "vip_%")
+// Where("uid", 1).Where("name", "john")
+// Where("status IN (?)", g.Slice{1,2,3})
+// Where("age IN(?,?)", 18, 50)
+// Where(User{ Id : 1, UserName : "john"})
+func (d *DeliverOrderProductDao) Where(where interface{}, args ...interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Where(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WherePri does the same logic as M.Where except that if the parameter <where>
+// is a single condition like int/string/float/slice, it treats the condition as the primary
+// key value. That is, if primary key is "id" and given <where> parameter as "123", the
+// WherePri function treats the condition as "id=123", but M.Where treats the condition
+// as string "123".
+func (d *DeliverOrderProductDao) WherePri(where interface{}, args ...interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WherePri(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Having sets the having statement for the model.
+// The parameters of this function usage are as the same as function Where.
+// See Where.
+func (d *DeliverOrderProductDao) Having(having interface{}, args ...interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Having(having, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Wheref builds condition string using fmt.Sprintf and arguments.
+// Note that if the number of "args" is more than the place holder in "format",
+// the extra "args" will be used as the where condition arguments of the Model.
+func (d *DeliverOrderProductDao) Wheref(format string, args ...interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Wheref(format, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereLT builds "column < value" statement.
+func (d *DeliverOrderProductDao) WhereLT(column string, value interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereLT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereLTE builds "column <= value" statement.
+func (d *DeliverOrderProductDao) WhereLTE(column string, value interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereLTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereGT builds "column > value" statement.
+func (d *DeliverOrderProductDao) WhereGT(column string, value interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereGT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereGTE builds "column >= value" statement.
+func (d *DeliverOrderProductDao) WhereGTE(column string, value interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereGTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereBetween builds "column BETWEEN min AND max" statement.
+func (d *DeliverOrderProductDao) WhereBetween(column string, min, max interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereLike builds "column LIKE like" statement.
+func (d *DeliverOrderProductDao) WhereLike(column string, like interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereIn builds "column IN (in)" statement.
+func (d *DeliverOrderProductDao) WhereIn(column string, in interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNull builds "columns[0] IS NULL AND columns[1] IS NULL ..." statement.
+func (d *DeliverOrderProductDao) WhereNull(columns ...string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotBetween builds "column NOT BETWEEN min AND max" statement.
+func (d *DeliverOrderProductDao) WhereNotBetween(column string, min, max interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotLike builds "column NOT LIKE like" statement.
+func (d *DeliverOrderProductDao) WhereNotLike(column string, like interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNot builds "column != value" statement.
+func (d *DeliverOrderProductDao) WhereNot(column string, value interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereNot(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotIn builds "column NOT IN (in)" statement.
+func (d *DeliverOrderProductDao) WhereNotIn(column string, in interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereNotNull builds "columns[0] IS NOT NULL AND columns[1] IS NOT NULL ..." statement.
+func (d *DeliverOrderProductDao) WhereNotNull(columns ...string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOr adds "OR" condition to the where statement.
+func (d *DeliverOrderProductDao) WhereOr(where interface{}, args ...interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereOr(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrf builds "OR" condition string using fmt.Sprintf and arguments.
+func (d *DeliverOrderProductDao) WhereOrf(format string, args ...interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereOrf(format, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrLT builds "column < value" statement in "OR" conditions..
+func (d *DeliverOrderProductDao) WhereOrLT(column string, value interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereOrLT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrLTE builds "column <= value" statement in "OR" conditions..
+func (d *DeliverOrderProductDao) WhereOrLTE(column string, value interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereOrLTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrGT builds "column > value" statement in "OR" conditions..
+func (d *DeliverOrderProductDao) WhereOrGT(column string, value interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereOrGT(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrGTE builds "column >= value" statement in "OR" conditions..
+func (d *DeliverOrderProductDao) WhereOrGTE(column string, value interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereOrGTE(column, value), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrBetween builds "column BETWEEN min AND max" statement in "OR" conditions.
+func (d *DeliverOrderProductDao) WhereOrBetween(column string, min, max interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereOrBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrLike builds "column LIKE like" statement in "OR" conditions.
+func (d *DeliverOrderProductDao) WhereOrLike(column string, like interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereOrLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrIn builds "column IN (in)" statement in "OR" conditions.
+func (d *DeliverOrderProductDao) WhereOrIn(column string, in interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereOrIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNull builds "columns[0] IS NULL OR columns[1] IS NULL ..." statement in "OR" conditions.
+func (d *DeliverOrderProductDao) WhereOrNull(columns ...string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereOrNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotBetween builds "column NOT BETWEEN min AND max" statement in "OR" conditions.
+func (d *DeliverOrderProductDao) WhereOrNotBetween(column string, min, max interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereOrNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotLike builds "column NOT LIKE like" statement in "OR" conditions.
+func (d *DeliverOrderProductDao) WhereOrNotLike(column string, like interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereOrNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotIn builds "column NOT IN (in)" statement.
+func (d *DeliverOrderProductDao) WhereOrNotIn(column string, in interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereOrNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
+}
+
+// WhereOrNotNull builds "columns[0] IS NOT NULL OR columns[1] IS NOT NULL ..." statement in "OR" conditions.
+func (d *DeliverOrderProductDao) WhereOrNotNull(columns ...string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.WhereOrNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Group sets the "GROUP BY" statement for the model.
+func (d *DeliverOrderProductDao) Group(groupBy ...string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Group(groupBy...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// And adds "AND" condition to the where statement.
+// Deprecated, use Where instead.
+func (d *DeliverOrderProductDao) And(where interface{}, args ...interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.And(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Or adds "OR" condition to the where statement.
+// Deprecated, use WhereOr instead.
+func (d *DeliverOrderProductDao) Or(where interface{}, args ...interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Or(where, args...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// GroupBy sets the "GROUP BY" statement for the model.
+func (d *DeliverOrderProductDao) GroupBy(groupBy string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Group(groupBy), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Order sets the "ORDER BY" statement for the model.
+func (d *DeliverOrderProductDao) Order(orderBy ...string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Order(orderBy...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderAsc sets the "ORDER BY xxx ASC" statement for the model.
+func (d *DeliverOrderProductDao) OrderAsc(column string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.OrderAsc(column), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderDesc sets the "ORDER BY xxx DESC" statement for the model.
+func (d *DeliverOrderProductDao) OrderDesc(column string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.OrderDesc(column), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderRandom sets the "ORDER BY RANDOM()" statement for the model.
+func (d *DeliverOrderProductDao) OrderRandom() *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.OrderRandom(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// OrderBy is alias of Model.Order.
+// See Model.Order.
+// Deprecated, use Order instead.
+func (d *DeliverOrderProductDao) OrderBy(orderBy string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Order(orderBy), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Limit sets the "LIMIT" statement for the model.
+// The parameter <limit> can be either one or two number, if passed two number is passed,
+// it then sets "LIMIT limit[0],limit[1]" statement for the model, or else it sets "LIMIT limit[0]"
+// statement.
+func (d *DeliverOrderProductDao) Limit(limit ...int) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Limit(limit...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Offset sets the "OFFSET" statement for the model.
+// It only makes sense for some databases like SQLServer, PostgreSQL, etc.
+func (d *DeliverOrderProductDao) Offset(offset int) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Offset(offset), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Distinct forces the query to only return distinct results.
+func (d *DeliverOrderProductDao) Distinct() *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Distinct(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Page sets the paging number for the model.
+// The parameter <page> is started from 1 for paging.
+// Note that, it differs that the Limit function start from 0 for "LIMIT" statement.
+func (d *DeliverOrderProductDao) Page(page, limit int) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Page(page, limit), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Batch sets the batch operation number for the model.
+func (d *DeliverOrderProductDao) Batch(batch int) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Batch(batch), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Cache sets the cache feature for the model. It caches the result of the sql, which means
+// if there's another same sql request, it just reads and returns the result from cache, it
+// but not committed and executed into the database.
+//
+// If the parameter <duration> < 0, which means it clear the cache with given <name>.
+// If the parameter <duration> = 0, which means it never expires.
+// If the parameter <duration> > 0, which means it expires after <duration>.
+//
+// The optional parameter <name> is used to bind a name to the cache, which means you can later
+// control the cache like changing the <duration> or clearing the cache with specified <name>.
+//
+// Note that, the cache feature is disabled if the model is operating on a transaction.
+func (d *DeliverOrderProductDao) Cache(duration time.Duration, name ...string) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Cache(duration, name...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Data sets the operation data for the model.
+// The parameter <data> can be type of string/map/gmap/slice/struct/*struct, etc.
+// Eg:
+// Data("uid=10000")
+// Data("uid", 10000)
+// Data(g.Map{"uid": 10000, "name":"john"})
+// Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
+func (d *DeliverOrderProductDao) Data(data ...interface{}) *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Data(data...), Table: d.Table, TableAs: d.TableAs}
+}
+
+// All does "SELECT FROM ..." statement for the model.
+// It retrieves the records from table and returns the result as []*model.DeliverOrderProduct.
+// It returns nil if there's no record retrieved with the given conditions from table.
+//
+// The optional parameter <where> is the same as the parameter of M.Where function,
+// see M.Where.
+func (d *DeliverOrderProductDao) All(where ...interface{}) ([]*model.DeliverOrderProduct, error) {
+	all, err := d.M.All(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entities []*model.DeliverOrderProduct
+	if err = all.Structs(&entities); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entities, nil
+}
+
+// One retrieves one record from table and returns the result as *model.DeliverOrderProduct.
+// It returns nil if there's no record retrieved with the given conditions from table.
+//
+// The optional parameter <where> is the same as the parameter of M.Where function,
+// see M.Where.
+func (d *DeliverOrderProductDao) One(where ...interface{}) (*model.DeliverOrderProduct, error) {
+	one, err := d.M.One(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entity *model.DeliverOrderProduct
+	if err = one.Struct(&entity); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entity, nil
+}
+
+// FindOne retrieves and returns a single Record by M.WherePri and M.One.
+// Also see M.WherePri and M.One.
+func (d *DeliverOrderProductDao) FindOne(where ...interface{}) (*model.DeliverOrderProduct, error) {
+	one, err := d.M.FindOne(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entity *model.DeliverOrderProduct
+	if err = one.Struct(&entity); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entity, nil
+}
+
+// FindAll retrieves and returns Result by by M.WherePri and M.All.
+// Also see M.WherePri and M.All.
+func (d *DeliverOrderProductDao) FindAll(where ...interface{}) ([]*model.DeliverOrderProduct, error) {
+	all, err := d.M.FindAll(where...)
+	if err != nil {
+		return nil, err
+	}
+	var entities []*model.DeliverOrderProduct
+	if err = all.Structs(&entities); err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	return entities, nil
+}
+
+// Struct retrieves one record from table and converts it into given struct.
+// The parameter <pointer> should be type of *struct/**struct. If type **struct is given,
+// it can create the struct internally during converting.
+//
+// The optional parameter <where> is the same as the parameter of Model.Where function,
+// see Model.Where.
+//
+// Note that it returns sql.ErrNoRows if there's no record retrieved with the given conditions
+// from table and <pointer> is not nil.
+//
+// Eg:
+// user := new(User)
+// err  := dao.User.Where("id", 1).Struct(user)
+//
+// user := (*User)(nil)
+// err  := dao.User.Where("id", 1).Struct(&user)
+func (d *DeliverOrderProductDao) Struct(pointer interface{}, where ...interface{}) error {
+	return d.M.Struct(pointer, where...)
+}
+
+// Structs retrieves records from table and converts them into given struct slice.
+// The parameter <pointer> should be type of *[]struct/*[]*struct. It can create and fill the struct
+// slice internally during converting.
+//
+// The optional parameter <where> is the same as the parameter of Model.Where function,
+// see Model.Where.
+//
+// Note that it returns sql.ErrNoRows if there's no record retrieved with the given conditions
+// from table and <pointer> is not empty.
+//
+// Eg:
+// users := ([]User)(nil)
+// err   := dao.User.Structs(&users)
+//
+// users := ([]*User)(nil)
+// err   := dao.User.Structs(&users)
+func (d *DeliverOrderProductDao) Structs(pointer interface{}, where ...interface{}) error {
+	return d.M.Structs(pointer, where...)
+}
+
+// Scan automatically calls Struct or Structs function according to the type of parameter <pointer>.
+// It calls function Struct if <pointer> is type of *struct/**struct.
+// It calls function Structs if <pointer> is type of *[]struct/*[]*struct.
+//
+// The optional parameter <where> is the same as the parameter of Model.Where function,
+// see Model.Where.
+//
+// Note that it returns sql.ErrNoRows if there's no record retrieved and given pointer is not empty or nil.
+//
+// Eg:
+// user  := new(User)
+// err   := dao.User.Where("id", 1).Scan(user)
+//
+// user  := (*User)(nil)
+// err   := dao.User.Where("id", 1).Scan(&user)
+//
+// users := ([]User)(nil)
+// err   := dao.User.Scan(&users)
+//
+// users := ([]*User)(nil)
+// err   := dao.User.Scan(&users)
+func (d *DeliverOrderProductDao) Scan(pointer interface{}, where ...interface{}) error {
+	return d.M.Scan(pointer, where...)
+}
+
+// Chunk iterates the table with given size and callback function.
+func (d *DeliverOrderProductDao) Chunk(limit int, callback func(entities []*model.DeliverOrderProduct, err error) bool) {
+	d.M.Chunk(limit, func(result gdb.Result, err error) bool {
+		var entities []*model.DeliverOrderProduct
+		err = result.Structs(&entities)
+		if err == sql.ErrNoRows {
+			return false
+		}
+		return callback(entities, err)
+	})
+}
+
+// LockUpdate sets the lock for update for current operation.
+func (d *DeliverOrderProductDao) LockUpdate() *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.LockUpdate(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// LockShared sets the lock in share mode for current operation.
+func (d *DeliverOrderProductDao) LockShared() *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.LockShared(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// Unscoped enables/disables the soft deleting feature.
+func (d *DeliverOrderProductDao) Unscoped() *DeliverOrderProductDao {
+	return &DeliverOrderProductDao{M: d.M.Unscoped(), Table: d.Table, TableAs: d.TableAs}
+}
+
+// DataScope enables the DataScope feature.
+func (d *DeliverOrderProductDao) DataScope(ctx context.Context, args ...interface{}) *DeliverOrderProductDao {
+	cs := ctx.Value("contextService")
+	dataScope := gconv.Map(gconv.String(gconv.Map(cs)["dataScope"]))
+	if dataScope != nil {
+		// 销售工程师判断
+		var salesEngineerFlag bool
+		if roles, ok := dataScope["roles"]; ok {
+			arr := garray.NewArrayFrom(roles.([]interface{}), true)
+			if arr.Len() == 1 && arr.Contains("SalesEngineer") {
+				salesEngineerFlag = true
+			}
+		}
+		userIds, ok := dataScope["userIds"]
+		specialFlag, userCols, orColsMap := d.checkColumnsName(dataScope, args...)
+
+		var orColumns []string
+		var orValues []interface{}
+		if ok && userIds != "-1" {
+			for _, column := range userCols {
+				if ok, _ := d.M.HasField(column); ok || specialFlag {
+					orColumns = append(orColumns, column+" IN (?) ")
+					orValues = append(orValues, userIds)
+				}
+			}
+		}
+		for col, params := range orColsMap {
+			if ok, _ := d.M.HasField(col); ok || specialFlag {
+				orColumns = append(orColumns, fmt.Sprintf(" ( %s IN (?) )", col))
+				orValues = append(orValues, params)
+			}
+		}
+
+		// 销售工程师权限加成
+		if !salesEngineerFlag {
+			var andColumns []string
+			var andValues []interface{}
+			for col, params := range dataScope {
+				if ok, _ := d.M.HasField(col); ok || specialFlag {
+					andColumns = append(andColumns, fmt.Sprintf(" ( %s IN (?) )", col))
+					andValues = append(andValues, params)
+				}
+			}
+			if len(andColumns) > 0 {
+				andWhereSql := strings.Join(andColumns, " AND ")
+				orColumns = append(orColumns, "("+andWhereSql+")")
+				orValues = append(orValues, andValues...)
+			}
+		}
+
+		whereSql := strings.Join(orColumns, " OR ")
+		return &DeliverOrderProductDao{M: d.M.Where(whereSql, orValues...).Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
+	}
+	return d
+}
+
+// args 1、字段
+// args 2、字段、表名
+// args 3、字段对应关系
+func (d *DeliverOrderProductDao) checkColumnsName(dataScope map[string]interface{}, args ...interface{}) (bool, []string, map[string]interface{}) {
+	var userCols []string
+	tableAs, specialFlag := "", false
+	orColsMap, colsContrast := map[string]interface{}{}, map[string]interface{}{}
+
+	if d.TableAs != "" && len(args) <= 1 {
+		tableAs = d.TableAs + "."
+	}
+	if len(args) > 1 {
+		specialFlag = true
+		if val, ok := args[1].(string); ok {
+			tableAs = val + "."
+		}
+	}
+	if len(args) > 0 {
+		userCols = []string{"created_by"}
+		if column, ok := args[0].(string); ok {
+			userCols = []string{tableAs + column}
+		}
+		if cols, ok := args[0].([]string); ok {
+			for _, v := range cols {
+				userCols = append(userCols, tableAs+v)
+			}
+		}
+		if val, ok := args[0].(map[string]interface{}); ok {
+			specialFlag = true
+			colsContrast = val
+			if orcols, ok := val["orcols"]; ok {
+				if col, ok := orcols.(string); ok && gconv.String(val[col]) != "" {
+					orColsMap[col] = val[col]
+					delete(colsContrast, col)
+				}
+				if cols, ok := orcols.([]string); ok {
+					for _, col := range cols {
+						if gconv.String(val[col]) == "" {
+							continue
+						}
+						orColsMap[col] = val[col]
+						delete(colsContrast, col)
+					}
+				}
+			}
+			delete(colsContrast, "orcols")
+		}
+	}
+	bigColumns := "is_big"
+	if isBig, ok := dataScope[bigColumns]; ok {
+		if bigCol, ok := colsContrast[bigColumns]; ok {
+			orColsMap[bigCol.(string)] = isBig
+			delete(colsContrast, bigCol.(string))
+		} else {
+			if ok, _ := d.M.HasField(bigColumns); ok && specialFlag {
+				orColsMap[tableAs+bigColumns] = isBig
+			}
+		}
+	}
+
+	delete(dataScope, "userIds")
+	delete(dataScope, "roles")
+	delete(dataScope, "posts")
+	delete(dataScope, bigColumns)
+	if len(colsContrast) > 0 {
+		for k, v := range dataScope {
+			if data, ok := colsContrast[k]; ok {
+				dataScope[data.(string)] = v
+			}
+			delete(dataScope, k)
+			delete(colsContrast, k)
+		}
+		for k, v := range colsContrast {
+			dataScope[k] = v
+		}
+	}
+	return specialFlag, userCols, orColsMap
+}

opms_parent/app/handler/work/deliver_order.go

@@ -0,0 +1,96 @@
+package work
+
+import (
+	"context"
+
+	"dashoo.cn/common_definition/comm_def"
+	"github.com/gogf/gf/frame/g"
+
+	contractmodel "dashoo.cn/micro/app/model/contract"
+	model "dashoo.cn/micro/app/model/work"
+	workSrv "dashoo.cn/micro/app/service/work"
+)
+
+type DeliverOrder struct{}
+
+// Swagger:DeliverOrder 交付工单 工单列表
+func (w *DeliverOrder) List(ctx context.Context, req *model.DeliverOrderListReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderService(ctx)
+	if err != nil {
+		return err
+	}
+	total, list, err := s.List(ctx, req)
+	if err != nil {
+		return err
+	}
+	rsp.Data = g.Map{"list": list, "total": total}
+	return nil
+
+}
+
+// Swagger:DeliverOrder 交付工单 工单详情
+func (w *DeliverOrder) Get(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderService(ctx)
+	if err != nil {
+		return err
+	}
+	detail, err := s.Get(ctx, int(req.Id))
+	if err != nil {
+		return err
+	}
+	rsp.Data = detail
+	return nil
+}
+
+// Swagger:DeliverOrder 交付工单 更新工单
+func (w *DeliverOrder) Update(ctx context.Context, req *model.DeliverOrderUpdateReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderService(ctx)
+	if err != nil {
+		return err
+	}
+	err = s.Update(ctx, req)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Swagger:DeliverOrder 交付工单 创建工单
+func (w *DeliverOrder) Add(ctx context.Context, req *model.DeliverOrderAddReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderService(ctx)
+	if err != nil {
+		return err
+	}
+	id, err := s.Add(ctx, req)
+	if err != nil {
+		return err
+	}
+	rsp.Data = id
+	return nil
+}
+
+// Swagger:DeliverOrder 交付工单 完成工单
+func (w *DeliverOrder) Finish(ctx context.Context, req *model.DeliverOrderFinishReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderService(ctx)
+	if err != nil {
+		return err
+	}
+	err = s.Finish(ctx, req)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Swagger:DeliverOrder 交付工单 删除工单
+func (w *DeliverOrder) Delete(ctx context.Context, req *contractmodel.IdsReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderService(ctx)
+	if err != nil {
+		return err
+	}
+	err = s.Delete(ctx, req.Id)
+	if err != nil {
+		return err
+	}
+	return nil
+}

opms_parent/app/handler/work/deliver_order_plan.go

@@ -0,0 +1,109 @@
+package work
+
+import (
+	"context"
+
+	"dashoo.cn/common_definition/comm_def"
+	"github.com/gogf/gf/frame/g"
+
+	contractmodel "dashoo.cn/micro/app/model/contract"
+	model "dashoo.cn/micro/app/model/work"
+	workSrv "dashoo.cn/micro/app/service/work"
+)
+
+type DeliverOrderPlan struct{}
+
+// Swagger:DeliverOrderPlan 交付工单计划 工单列表
+func (w *DeliverOrderPlan) List(ctx context.Context, req *model.DeliverOrderPlanListReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderPlanService(ctx)
+	if err != nil {
+		return err
+	}
+	total, list, err := s.List(ctx, req)
+	if err != nil {
+		return err
+	}
+	rsp.Data = g.Map{"list": list, "total": total}
+	return nil
+
+}
+
+// Swagger:DeliverOrderPlan 交付工单计划 工单详情
+func (w *DeliverOrderPlan) Get(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderPlanService(ctx)
+	if err != nil {
+		return err
+	}
+	detail, err := s.Get(ctx, int(req.Id))
+	if err != nil {
+		return err
+	}
+	rsp.Data = detail
+	return nil
+}
+
+// Swagger:DeliverOrderPlan 交付工单计划 更新工单
+func (w *DeliverOrderPlan) Update(ctx context.Context, req *model.DeliverOrderImpPlanUpdateReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderPlanService(ctx)
+	if err != nil {
+		return err
+	}
+	err = s.Update(ctx, req)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Swagger:DeliverOrderPlan 交付工单计划 创建工单
+func (w *DeliverOrderPlan) Add(ctx context.Context, req *model.DeliverOrderImpPlanAddReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderPlanService(ctx)
+	if err != nil {
+		return err
+	}
+	id, err := s.Add(ctx, req)
+	if err != nil {
+		return err
+	}
+	rsp.Data = id
+	return nil
+}
+
+// Swagger:DeliverOrderPlan 交付工单计划 开始计划
+func (w *DeliverOrderPlan) Start(ctx context.Context, req *model.DeliverOrderImpPlanStartReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderPlanService(ctx)
+	if err != nil {
+		return err
+	}
+	err = s.Start(ctx, req)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Swagger:DeliverOrderPlan 交付工单计划 结束计划
+func (w *DeliverOrderPlan) Finish(ctx context.Context, req *model.DeliverOrderImpPlanFinishReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderPlanService(ctx)
+	if err != nil {
+		return err
+	}
+	err = s.Finish(ctx, req)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Swagger:DeliverOrderPlan 交付工单计划 删除工单
+func (w *DeliverOrderPlan) Delete(ctx context.Context, req *contractmodel.IdsReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderPlanService(ctx)
+	if err != nil {
+		return err
+	}
+	err = s.Delete(ctx, req.Id)
+	if err != nil {
+		return err
+	}
+	return nil
+}

opms_parent/app/handler/work/deliver_order_progress.go

@@ -0,0 +1,95 @@
+package work
+
+import (
+	"context"
+
+	"dashoo.cn/common_definition/comm_def"
+	"github.com/gogf/gf/frame/g"
+
+	contractmodel "dashoo.cn/micro/app/model/contract"
+	model "dashoo.cn/micro/app/model/work"
+	workSrv "dashoo.cn/micro/app/service/work"
+)
+
+type DeliverOrderProgress struct{}
+
+// Swagger:DeliverOrderProgress 交付工单任务 工单列表
+func (w *DeliverOrderProgress) List(ctx context.Context, req *model.DeliverOrderProgressListReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderProgressService(ctx)
+	if err != nil {
+		return err
+	}
+	total, list, err := s.List(ctx, req)
+	if err != nil {
+		return err
+	}
+	rsp.Data = g.Map{"list": list, "total": total}
+	return nil
+
+}
+
+// Swagger:DeliverOrderProgress 交付工单任务 更新工单
+func (w *DeliverOrderProgress) Update(ctx context.Context, req *model.DeliverOrderProgressUpdateReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderProgressService(ctx)
+	if err != nil {
+		return err
+	}
+	err = s.Update(ctx, req)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Swagger:DeliverOrderProgress 交付工单任务 创建工单
+func (w *DeliverOrderProgress) Add(ctx context.Context, req *model.DeliverOrderProgressAddReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderProgressService(ctx)
+	if err != nil {
+		return err
+	}
+	id, err := s.Add(ctx, req)
+	if err != nil {
+		return err
+	}
+	rsp.Data = id
+	return nil
+}
+
+// Swagger:DeliverOrderProgress 交付工单任务 开始任务
+func (w *DeliverOrderProgress) Start(ctx context.Context, req *model.DeliverOrderImpProgressStartReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderProgressService(ctx)
+	if err != nil {
+		return err
+	}
+	err = s.Start(ctx, req)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Swagger:DeliverOrderProgress 交付工单任务 结束任务
+func (w *DeliverOrderProgress) Finish(ctx context.Context, req *model.DeliverOrderImpProgressFinishReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderProgressService(ctx)
+	if err != nil {
+		return err
+	}
+	err = s.Finish(ctx, req)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Swagger:DeliverOrderProgress 交付工单任务 删除工单
+func (w *DeliverOrderProgress) Delete(ctx context.Context, req *contractmodel.IdsReq, rsp *comm_def.CommonMsg) error {
+	s, err := workSrv.NewDeliverOrderProgressService(ctx)
+	if err != nil {
+		return err
+	}
+	err = s.Delete(ctx, req.Id)
+	if err != nil {
+		return err
+	}
+	return nil
+}

opms_parent/app/model/work/deliver_order.go

@@ -0,0 +1,56 @@
+// ==========================================================================
+// This is auto-generated by gf cli tool. Fill this file as you wish.
+// ==========================================================================
+
+package work
+
+import (
+	"dashoo.cn/micro/app/model/work/internal"
+	"dashoo.cn/opms_libary/request"
+)
+
+// DeliverOrder is the golang structure for table deliver_order.
+type DeliverOrder internal.DeliverOrder
+
+// Fill with you ideas below.
+type DeliverOrderGetRsp struct {
+	DeliverOrder
+	Plan    []*DeliverOrderImpPlan `json:"plan"`
+	Product []*DeliverOrderProduct `json:"product"`
+}
+
+type DeliverOrderListReq struct {
+	request.PageReq
+	OrderCode      string `json:"orderCode"`      // 交付订单号
+	OrderStatus    string `json:"orderStatus"`    // 交付状态(10项目立项 )
+	OrderType      string `json:"orderType"`      // 交付类型(10 软件 20 硬件)
+	CustId         int    `json:"custId"`         // 关联客户ID
+	CustName       string `json:"custName"`       // 关联客户名称
+	ProjectId      int    `json:"projectId"`      // 关联项目ID
+	ProjectName    string `json:"projectName"`    // 关联项目名称
+	ContractId     int    `json:"contractId"`     // 关联合同ID
+	ContractCode   string `json:"contractCode"`   // 关联合同编号
+	ProjectManId   int    `json:"projectManId"`   // 项目经理
+	ProjectManName string `json:"projectManName"` // 项目经理
+	DeliverManId   int    `json:"deliverManId"`   // 交付经理
+	DeliverManName string `json:"deliverManName"` // 交付经理
+	Product        string `json:"product"`        // 产品线
+}
+
+type DeliverOrderAddReq struct {
+	ContractId int `json:"contractId" v:"required#请输入合同ID"` // 关联合同ID
+}
+
+type DeliverOrderUpdateReq struct {
+	Id             int    `json:"id" v:"required#请输入Id"`
+	OrderStatus    string `json:"orderStatus"`    // 交付状态(10项目立项 )
+	ProjectManId   int    `json:"projectManId"`   // 项目经理
+	ProjectManName string `json:"projectManName"` // 项目经理
+	DeliverManId   int    `json:"deliverManId"`   // 交付经理
+	DeliverManName string `json:"deliverManName"` // 交付经理
+}
+
+type DeliverOrderFinishReq struct {
+	OrderId      int    `json:"orderId"     v:"min:1#工单不能为空"` //
+	FinishRemark string `json:"finishRemark"`                 // 完成信息
+}

opms_parent/app/model/work/deliver_order_imp_plan.go

@@ -0,0 +1,57 @@
+// ==========================================================================
+// This is auto-generated by gf cli tool. Fill this file as you wish.
+// ==========================================================================
+
+package work
+
+import (
+	"dashoo.cn/micro/app/model/work/internal"
+	"dashoo.cn/opms_libary/request"
+	"github.com/gogf/gf/os/gtime"
+)
+
+// DeliverOrderImpPlan is the golang structure for table deliver_order_imp_plan.
+type DeliverOrderImpPlan internal.DeliverOrderImpPlan
+
+// Fill with you ideas below.
+type DeliverOrderPlanGetRsp struct {
+	DeliverOrderImpPlan
+	Progress []*DeliverOrderImpProgress `json:"progress"`
+}
+
+type DeliverOrderPlanListReq struct {
+	request.PageReq
+	DeliverOrderId int    `json:"deliverOrderId"` // 关联交付订单ID
+	PlanTitle      string `json:"planTitle"`      // 计划标题
+	PlanStatus     string `json:"planStatus"`     // 计划状态（10 未开始 20 已开始 30已关闭）
+}
+
+type DeliverOrderPlanListRsp struct {
+	DeliverOrderImpPlan
+	OrderStatus string `json:"orderStatus"` // 交付状态(10项目立项 20 完成)
+}
+
+type DeliverOrderImpPlanAddReq struct {
+	DeliverOrderId int         `json:"deliverOrderId" v:"required#请输入工单ID"`  // 关联交付订单ID
+	PlanTitle      string      `json:"planTitle" v:"required#请输入工单计划标题"`     // 计划标题
+	PlanStartDate  *gtime.Time `json:"planStartDate" v:"required#请输入工单开始时间"` // 开始时间
+	PlanEndDate    *gtime.Time `json:"planEndDate" v:"required#请输入工单结束时间"`   // 结束时间
+}
+
+type DeliverOrderImpPlanUpdateReq struct {
+	Id            int         `json:"id" v:"required#请输入Id"`
+	PlanTitle     string      `json:"planTitle"`     // 计划标题
+	PlanStatus    string      `json:"planStatus"`    // 计划状态（10 未开始 20 已开始 30已关闭）
+	PlanStartDate *gtime.Time `json:"planStartDate"` // 开始时间
+	PlanEndDate   *gtime.Time `json:"planEndDate"`   // 结束时间
+}
+
+type DeliverOrderImpPlanStartReq struct {
+	Id     int    `json:"id" v:"required#请输入Id"`
+	Remark string `json:"remark"` // 备注
+}
+
+type DeliverOrderImpPlanFinishReq struct {
+	Id     int    `json:"id" v:"required#请输入Id"`
+	Remark string `json:"remark"` // 备注
+}

opms_parent/app/model/work/deliver_order_imp_progress.go

@@ -0,0 +1,60 @@
+// ==========================================================================
+// This is auto-generated by gf cli tool. Fill this file as you wish.
+// ==========================================================================
+
+package work
+
+import (
+	"dashoo.cn/micro/app/model/work/internal"
+	"dashoo.cn/opms_libary/request"
+	"github.com/gogf/gf/os/gtime"
+)
+
+// DeliverOrderImpProgress is the golang structure for table deliver_order_imp_progress.
+type DeliverOrderImpProgress internal.DeliverOrderImpProgress
+
+// Fill with you ideas below.
+type DeliverOrderProgressListReq struct {
+	request.PageReq
+	DeliverOrderId int    `json:"deliverOrderId"` // 关联交付订单ID
+	PlanId         int    `json:"planId"`         // 关联实施计划
+	ProgressTitle  string `json:"progressTitle"`  // 任务标题
+	ProgressStatus string `json:"progressStatus"` // 状态(10未开始20已开始30已完成)
+	ProgressLevel  string `json:"progressLevel"`  // 优先级（10最高 20普通 30较低 ）
+}
+
+type DeliverOrderProgressAddReq struct {
+	PlanId          int         `json:"planId" v:"required#请输入工单计划ID"`        // 关联实施计划
+	ProgressTitle   string      `json:"progressTitle" v:"required#请输入任务标题"`   // 任务标题
+	ProgressContext string      `json:"progressContext" v:"required#请输入任务内容"` // 任务内容
+	StartDate       *gtime.Time `json:"startDate" v:"required#请输入开始时间"`       // 开始时间
+	EndDate         *gtime.Time `json:"endDate" v:"required#请输入结束时间"`         // 结束时间
+	ReaStartDate    *gtime.Time `json:"reaStartDate"`                         // 实际开始时间
+	ReaEndDate      *gtime.Time `json:"reaEndDate"`                           // 实际结束时间
+	ProgressLevel   string      `json:"progressLevel"`                        // 优先级（10最高 20普通 30较低 ）
+	Remark          string      `json:"remark"`                               // 备注
+
+}
+
+type DeliverOrderProgressUpdateReq struct {
+	Id              int         `json:"id" v:"required#请输入Id"`
+	ProgressTitle   string      `json:"progressTitle"`   // 任务标题
+	ProgressContext string      `json:"progressContext"` // 任务内容
+	StartDate       *gtime.Time `json:"startDate"`       // 开始时间
+	EndDate         *gtime.Time `json:"endDate"`         // 结束时间
+	ReaStartDate    *gtime.Time `json:"reaStartDate"`    // 实际开始时间
+	ReaEndDate      *gtime.Time `json:"reaEndDate"`      // 实际结束时间
+	ProgressStatus  string      `json:"progressStatus"`  // 状态(10未开始20已开始30已完成)
+	ProgressLevel   string      `json:"progressLevel"`   // 优先级（10最高 20普通 30较低 ）
+	Remark          *string     `json:"remark"`          // 备注
+}
+
+type DeliverOrderImpProgressStartReq struct {
+	Id     int    `json:"id" v:"required#请输入Id"`
+	Remark string `json:"remark"` // 备注
+}
+
+type DeliverOrderImpProgressFinishReq struct {
+	Id     int    `json:"id" v:"required#请输入Id"`
+	Remark string `json:"remark"` // 备注
+}

opms_parent/app/model/work/deliver_order_product.go

@@ -0,0 +1,14 @@
+// ==========================================================================
+// This is auto-generated by gf cli tool. Fill this file as you wish.
+// ==========================================================================
+
+package work
+
+import (
+	"dashoo.cn/micro/app/model/work/internal"
+)
+
+// DeliverOrderProduct is the golang structure for table deliver_order_product.
+type DeliverOrderProduct internal.DeliverOrderProduct
+
+// Fill with you ideas below.

opms_parent/app/model/work/internal/deliver_order.go

@@ -0,0 +1,40 @@
+// ==========================================================================
+// This is auto-generated by gf cli tool. DO NOT EDIT THIS FILE MANUALLY.
+// ==========================================================================
+
+package internal
+
+import (
+	"github.com/gogf/gf/os/gtime"
+)
+
+// DeliverOrder is the golang structure for table deliver_order.
+type DeliverOrder struct {
+	Id             int         `orm:"id,primary"       json:"id"`             // 主键
+	OrderCode      string      `orm:"order_code"       json:"orderCode"`      // 交付订单号
+	OrderStatus    string      `orm:"order_status"     json:"orderStatus"`    // 交付状态(10项目立项 20 完成)
+	OrderType      string      `orm:"order_type"       json:"orderType"`      // 交付类型(10 软件 20 硬件)
+	CustId         int         `orm:"cust_id"          json:"custId"`         // 关联客户ID
+	CustName       string      `orm:"cust_name"        json:"custName"`       // 关联客户名称
+	ProjectId      int         `orm:"project_id"       json:"projectId"`      // 关联项目ID
+	ProjectName    string      `orm:"project_name"     json:"projectName"`    // 关联项目名称
+	ContractId     int         `orm:"contract_id"      json:"contractId"`     // 关联合同ID
+	ContractCode   string      `orm:"contract_code"    json:"contractCode"`   // 关联合同编号
+	ProjectManId   int         `orm:"project_man_id"   json:"projectManId"`   // 项目经理
+	ProjectManName string      `orm:"project_man_name" json:"projectManName"` // 项目经理
+	DeliverManId   int         `orm:"deliver_man_id"   json:"deliverManId"`   // 交付经理
+	DeliverManName string      `orm:"deliver_man_name" json:"deliverManName"` // 交付经理
+	Product        string      `orm:"product"          json:"product"`        // 产品线
+	FinishRemark   string      `orm:"finish_remark"    json:"finishRemark"`   // 完成信息
+	FinishTime     *gtime.Time `orm:"finish_time"      json:"finishTime"`     // 完成时间
+	FinishBy       int         `orm:"finish_by"        json:"finishBy"`       // 完成操作人
+	FinishByName   string      `orm:"finish_by_name"   json:"finishByName"`   // 完成操作人
+	Remark         string      `orm:"remark"           json:"remark"`         // 备注
+	CreatedBy      int         `orm:"created_by"       json:"createdBy"`      // 创建者
+	CreatedName    string      `orm:"created_name"     json:"createdName"`    // 创建人
+	CreatedTime    *gtime.Time `orm:"created_time"     json:"createdTime"`    // 创建时间
+	UpdatedBy      int         `orm:"updated_by"       json:"updatedBy"`      // 更新者
+	UpdatedName    string      `orm:"updated_name"     json:"updatedName"`    // 更新人
+	UpdatedTime    *gtime.Time `orm:"updated_time"     json:"updatedTime"`    // 更新时间
+	DeletedTime    *gtime.Time `orm:"deleted_time"     json:"deletedTime"`    // 删除时间
+}

opms_parent/app/model/work/internal/deliver_order_imp_plan.go

@@ -0,0 +1,29 @@
+// ==========================================================================
+// This is auto-generated by gf cli tool. DO NOT EDIT THIS FILE MANUALLY.
+// ==========================================================================
+
+package internal
+
+import (
+	"github.com/gogf/gf/os/gtime"
+)
+
+// DeliverOrderImpPlan is the golang structure for table deliver_order_imp_plan.
+type DeliverOrderImpPlan struct {
+	Id             int         `orm:"id,primary"       json:"id"`             // 主键
+	DeliverOrderId int         `orm:"deliver_order_id" json:"deliverOrderId"` // 关联交付订单ID
+	PlanTitle      string      `orm:"plan_title"       json:"planTitle"`      // 计划标题
+	PlanStatus     string      `orm:"plan_status"      json:"planStatus"`     // 计划状态（10 未开始 20 已开始 30已关闭）
+	PlanStartDate  *gtime.Time `orm:"plan_start_date"  json:"planStartDate"`  // 开始时间
+	PlanEndDate    *gtime.Time `orm:"plan_end_date"    json:"planEndDate"`    // 结束时间
+	ReaStartDate   *gtime.Time `orm:"rea_start_date"   json:"reaStartDate"`   // 实际开始时间
+	ReaEndDate     *gtime.Time `orm:"rea_end_date"     json:"reaEndDate"`     // 实际结束时间
+	Remark         string      `orm:"remark"           json:"remark"`         // 备注
+	CreatedBy      int         `orm:"created_by"       json:"createdBy"`      // 创建者
+	CreatedName    string      `orm:"created_name"     json:"createdName"`    // 创建人
+	CreatedTime    *gtime.Time `orm:"created_time"     json:"createdTime"`    // 创建时间
+	UpdatedBy      int         `orm:"updated_by"       json:"updatedBy"`      // 更新者
+	UpdatedName    string      `orm:"updated_name"     json:"updatedName"`    // 更新人
+	UpdatedTime    *gtime.Time `orm:"updated_time"     json:"updatedTime"`    // 更新时间
+	DeletedTime    *gtime.Time `orm:"deleted_time"     json:"deletedTime"`    // 删除时间
+}

opms_parent/app/model/work/internal/deliver_order_imp_progress.go

@@ -0,0 +1,31 @@
+// ==========================================================================
+// This is auto-generated by gf cli tool. DO NOT EDIT THIS FILE MANUALLY.
+// ==========================================================================
+
+package internal
+
+import (
+	"github.com/gogf/gf/os/gtime"
+)
+
+// DeliverOrderImpProgress is the golang structure for table deliver_order_imp_progress.
+type DeliverOrderImpProgress struct {
+	Id              int         `orm:"id,primary"       json:"id"`              // 主键
+	PlanId          int         `orm:"plan_id"          json:"planId"`          // 关联实施计划
+	ProgressTitle   string      `orm:"progress_title"   json:"progressTitle"`   // 任务标题
+	ProgressContext string      `orm:"progress_context" json:"progressContext"` // 任务内容
+	StartDate       *gtime.Time `orm:"start_date"       json:"startDate"`       // 开始时间
+	EndDate         *gtime.Time `orm:"end_date"         json:"endDate"`         // 结束时间
+	ReaStartDate    *gtime.Time `orm:"rea_start_date"   json:"reaStartDate"`    // 实际开始时间
+	ReaEndDate      *gtime.Time `orm:"rea_end_date"     json:"reaEndDate"`      // 实际结束时间
+	ProgressStatus  string      `orm:"progress_status"  json:"progressStatus"`  // 状态(10未开始20已开始30已完成)
+	ProgressLevel   string      `orm:"progress_level"   json:"progressLevel"`   // 优先级（10最高 20普通 30较低 ）
+	Remark          string      `orm:"remark"           json:"remark"`          // 备注
+	CreatedBy       int         `orm:"created_by"       json:"createdBy"`       // 创建者
+	CreatedName     string      `orm:"created_name"     json:"createdName"`     // 创建人
+	CreatedTime     *gtime.Time `orm:"created_time"     json:"createdTime"`     // 创建时间
+	UpdatedBy       int         `orm:"updated_by"       json:"updatedBy"`       // 更新者
+	UpdatedName     string      `orm:"updated_name"     json:"updatedName"`     // 更新人
+	UpdatedTime     *gtime.Time `orm:"updated_time"     json:"updatedTime"`     // 更新时间
+	DeletedTime     *gtime.Time `orm:"deleted_time"     json:"deletedTime"`     // 删除时间
+}

opms_parent/app/model/work/internal/deliver_order_product.go

@@ -0,0 +1,27 @@
+// ==========================================================================
+// This is auto-generated by gf cli tool. DO NOT EDIT THIS FILE MANUALLY.
+// ==========================================================================
+
+package internal
+
+import (
+	"github.com/gogf/gf/os/gtime"
+)
+
+// DeliverOrderProduct is the golang structure for table deliver_order_product.
+type DeliverOrderProduct struct {
+	Id             int         `orm:"id,primary"       json:"id"`             // 主键
+	DeliverOrderId int         `orm:"deliver_order_id" json:"deliverOrderId"` // 关联交付订单ID
+	ProductCode    string      `orm:"product_code"     json:"productCode"`    // 产品编码
+	ProductName    string      `orm:"product_name"     json:"productName"`    // 产品名称
+	ProductType    string      `orm:"product_type"     json:"productType"`    // 产品类型
+	ProductNum     int         `orm:"product_num"      json:"productNum"`     // 产品数量
+	Remark         string      `orm:"remark"           json:"remark"`         // 备注
+	CreatedBy      int         `orm:"created_by"       json:"createdBy"`      // 创建者
+	CreatedName    string      `orm:"created_name"     json:"createdName"`    // 创建人
+	CreatedTime    *gtime.Time `orm:"created_time"     json:"createdTime"`    // 创建时间
+	UpdatedBy      int         `orm:"updated_by"       json:"updatedBy"`      // 更新者
+	UpdatedName    string      `orm:"updated_name"     json:"updatedName"`    // 更新人
+	UpdatedTime    *gtime.Time `orm:"updated_time"     json:"updatedTime"`    // 更新时间
+	DeletedTime    *gtime.Time `orm:"deleted_time"     json:"deletedTime"`    // 删除时间
+}

opms_parent/app/service/base.go

@@ -341,3 +341,36 @@ func GSendMail(msg g.MapStrStr) error {
 	fmt.Println(resp.Data)
 	return nil
 }
+
+func ColumnInt(m *gdb.Model, name string) ([]int, error) {
+	v, err := m.Fields(name).Array()
+	if err != nil {
+		return nil, err
+	}
+	res := []int{}
+	for _, i := range v {
+		res = append(res, i.Int())
+	}
+	return res, nil
+}
+
+func ColumnString(m *gdb.Model, name string) ([]string, error) {
+	v, err := m.Fields(name).Array()
+	if err != nil {
+		return nil, err
+	}
+	res := []string{}
+	for _, i := range v {
+		res = append(res, i.String())
+	}
+	return res, nil
+}
+
+func StringsContains(s []string, ele string) bool {
+	for _, i := range s {
+		if i == ele {
+			return true
+		}
+	}
+	return false
+}

opms_parent/app/service/contract/ctr_contract.go

@@ -22,6 +22,7 @@ import (
 	workflowModel "dashoo.cn/micro/app/model/workflow"
 	"dashoo.cn/micro/app/service"
 	projsrv "dashoo.cn/micro/app/service/proj"
+	worksrv "dashoo.cn/micro/app/service/work"
 	workflowService "dashoo.cn/micro/app/service/workflow"
 
 	"dashoo.cn/opms_libary/micro_srv"
@@ -720,25 +721,32 @@ func ContractApplyApproval(ctx context.Context, flow *workflowModel.PlatWorkflow
 		return fmt.Errorf("无法识别的 Result ：%s", msg.Result)
 	}
 
+	var status string
 	if msg.ProcessType == "terminate" {
-		_, err = contractDao.Where("id = ?", contractId).Data(map[string]interface{}{
-			"appro_status": "50",
-		}).Update()
-		return err
+		status = "50"
+	} else {
+		pass := msg.Result == "agree"
+		if !pass {
+			status = "40"
+		} else {
+			status = "30"
+		}
 	}
 
-	pass := msg.Result == "agree"
-	if !pass {
-		_, err = contractDao.Where("id = ?", contractId).Data(map[string]interface{}{
-			"appro_status": "40",
-		}).Update()
+	_, err = contractDao.Where("id = ?", contractId).Data(map[string]interface{}{
+		"appro_status": status,
+	}).Update()
+	if err != nil {
 		return err
 	}
+	if status != "30" {
+		return nil
+	}
 
-	_, err = contractDao.Where("id = ?", contractId).Data(map[string]interface{}{
-		"appro_status": "30",
-	}).Update()
-	return err
+	return contractDao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
+		_, err = worksrv.DeliverOrderAdd(tx, contractId, request.UserInfo{})
+		return err
+	})
 }
 
 func (s CtrContractService) Update(ctx context.Context, req *model.CtrContractUpdateReq) error {

opms_parent/app/service/work/deliver_order.go

@@ -0,0 +1,399 @@
+package work
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+
+	basedao "dashoo.cn/micro/app/dao/base"
+	contractdao "dashoo.cn/micro/app/dao/contract"
+	custdao "dashoo.cn/micro/app/dao/cust"
+	projdao "dashoo.cn/micro/app/dao/proj"
+	workdao "dashoo.cn/micro/app/dao/work"
+	contractmodel "dashoo.cn/micro/app/model/contract"
+	work "dashoo.cn/micro/app/model/work"
+	"dashoo.cn/micro/app/service"
+
+	"dashoo.cn/opms_libary/micro_srv"
+	"dashoo.cn/opms_libary/myerrors"
+	"dashoo.cn/opms_libary/request"
+	"github.com/gogf/gf/database/gdb"
+	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/gtime"
+	"github.com/gogf/gf/util/gvalid"
+)
+
+type DeliverOrderService struct {
+	Dao             *workdao.DeliverOrderDao
+	PlanDao         *workdao.DeliverOrderImpPlanDao
+	ProductDao      *workdao.DeliverOrderProductDao
+	ContractDao     *contractdao.CtrContractDao
+	ProjBusinessDao *projdao.ProjBusinessDao
+	CustomerDao     *custdao.CustCustomerDao
+	CtrProductDao   *contractdao.CtrContractProductDao
+	BaseProductDao  *basedao.BaseProductDao
+
+	Tenant    string
+	userInfo  request.UserInfo
+	DataScope g.Map `json:"dataScope"`
+}
+
+func NewDeliverOrderService(ctx context.Context) (*DeliverOrderService, error) {
+	tenant, err := micro_srv.GetTenant(ctx)
+	if err != nil {
+		err = myerrors.TipsError(fmt.Sprintf("获取租户码异常：%s", err.Error()))
+		return nil, err
+	}
+	// 获取用户信息
+	userInfo, err := micro_srv.GetUserInfo(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("获取用户信息异常：%s", err.Error())
+	}
+	return &DeliverOrderService{
+		Dao:             workdao.NewDeliverOrderDao(tenant),
+		PlanDao:         workdao.NewDeliverOrderImpPlanDao(tenant),
+		ContractDao:     contractdao.NewCtrContractDao(tenant),
+		ProjBusinessDao: projdao.NewProjBusinessDao(tenant),
+		CustomerDao:     custdao.NewCustCustomerDao(tenant),
+		CtrProductDao:   contractdao.NewCtrContractProductDao(tenant),
+		ProductDao:      workdao.NewDeliverOrderProductDao(tenant),
+		BaseProductDao:  basedao.NewBaseProductDao(tenant),
+		Tenant:          tenant,
+		userInfo:        userInfo,
+		DataScope:       userInfo.DataScope,
+	}, nil
+}
+
+func (s DeliverOrderService) Get(ctx context.Context, id int) (*work.DeliverOrderGetRsp, error) {
+	ent, err := s.Dao.Where("Id = ?", id).One()
+	if err != nil {
+		return nil, err
+	}
+	if ent == nil {
+		return nil, myerrors.TipsError("工单不存在")
+	}
+	plan, err := s.PlanDao.Where("deliver_order_id = ?", id).All()
+	if err != nil {
+		return nil, err
+	}
+	if plan == nil {
+		plan = []*work.DeliverOrderImpPlan{}
+	}
+	product, err := s.ProductDao.Where("deliver_order_id = ?", id).All()
+	if err != nil {
+		return nil, err
+	}
+	if product == nil {
+		product = []*work.DeliverOrderProduct{}
+	}
+	return &work.DeliverOrderGetRsp{
+		DeliverOrder: *ent,
+		Plan:         plan,
+		Product:      product,
+	}, nil
+}
+
+func (s DeliverOrderService) List(ctx context.Context, req *work.DeliverOrderListReq) (int, []*work.DeliverOrder, error) {
+	g.Log().Infof("DeliverOrderService List roles %v", s.userInfo.Roles)
+	dao := s.Dao.DeliverOrderDao.As("a").LeftJoin("ctr_contract b", "a.contract_id=b.id").Unscoped().Where("a.deleted_time is null")
+	// 销售和交付经理只能看自己所属的,其他人只能看自己所属产品线的
+	if service.StringsContains(s.userInfo.Roles, "SalesEngineer") {
+		dao = dao.Where("b.incharge_id = ?", s.userInfo.Id)
+	} else if service.StringsContains(s.userInfo.Roles, "ProjectDeliveryManager") {
+		dao = dao.Where("a.deliver_man_id = ?", s.userInfo.Id)
+	} else {
+		productCode, err := service.ColumnString(s.Dao.DB.Table("base_product_auth").Wheref("user_id = ?", s.userInfo.Id), "product_code")
+		if err != nil {
+			return 0, nil, err
+		}
+		g.Log().Infof("DeliverOrderService List product_code %v", productCode)
+		dao = dao.Where("a.product in (?)", productCode)
+	}
+
+	if req.OrderCode != "" {
+		dao = dao.Where("a.order_code = ?", req.OrderCode)
+	}
+	if req.OrderStatus != "" {
+		dao = dao.Where("a.order_status = ?", req.OrderStatus)
+	}
+	if req.OrderType != "" {
+		dao = dao.Where("a.order_type = ?", req.OrderType)
+	}
+	if req.CustId != 0 {
+		dao = dao.Where("a.cust_id = ?", req.CustId)
+	}
+	if req.CustName != "" {
+		likestr := fmt.Sprintf("%%%s%%", req.CustName)
+		dao = dao.Where("a.cust_name like ?", likestr)
+	}
+	if req.ProjectId != 0 {
+		dao = dao.Where("a.project_id = ?", req.ProjectId)
+	}
+	if req.ProjectName != "" {
+		likestr := fmt.Sprintf("%%%s%%", req.ProjectName)
+		dao = dao.Where("a.project_name like ?", likestr)
+	}
+	if req.ContractId != 0 {
+		dao = dao.Where("a.contract_id = ?", req.ContractId)
+	}
+	if req.ContractCode != "" {
+		dao = dao.Where("a.contract_code = ?", req.ContractCode)
+	}
+	if req.ProjectManId != 0 {
+		dao = dao.Where("a.project_man_id = ?", req.ProjectManId)
+	}
+	if req.ProjectManName != "" {
+		likestr := fmt.Sprintf("%%%s%%", req.ProjectManName)
+		dao = dao.Where("a.project_man_name like ?", likestr)
+	}
+	if req.DeliverManId != 0 {
+		dao = dao.Where("a.deliver_man_id = ?", req.DeliverManId)
+	}
+	if req.DeliverManName != "" {
+		likestr := fmt.Sprintf("%%%s%%", req.DeliverManName)
+		dao = dao.Where("a.deliver_man_name like ?", likestr)
+	}
+	if req.Product != "" {
+		dao = dao.Where("a.product = ?", req.Product)
+	}
+
+	total, err := dao.Count()
+	if err != nil {
+		return 0, nil, err
+	}
+	if req.PageNum != 0 {
+		dao = dao.Page(req.GetPage())
+	}
+	orderby := "a.created_time desc"
+	if req.OrderBy != "" {
+		orderby = req.OrderBy
+	}
+	dao = dao.Order(orderby)
+
+	ents := []*work.DeliverOrder{}
+	err = dao.Fields("a.*").Structs(&ents)
+	if err != nil && err != sql.ErrNoRows {
+		return 0, nil, err
+	}
+	return total, ents, err
+}
+
+func (s DeliverOrderService) Add(ctx context.Context, req *work.DeliverOrderAddReq) ([]int, error) {
+	validErr := gvalid.CheckStruct(ctx, req, nil)
+	if validErr != nil {
+		return nil, myerrors.TipsError(validErr.Current().Error())
+	}
+
+	var id = []int{}
+	txerr := s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
+		var err error
+		id, err = DeliverOrderAdd(tx, req.ContractId, s.userInfo)
+		return err
+	})
+	return id, txerr
+}
+
+func DeliverOrderAdd(tx *gdb.TX, contractId int, userInfo request.UserInfo) ([]int, error) {
+	var c contractmodel.CtrContract
+	err := tx.GetStruct(&c, "select * from ctr_contract where id = ?", contractId)
+	if err == sql.ErrNoRows {
+		return nil, myerrors.TipsError(fmt.Sprintf("合同：%d 不存在", contractId))
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	var product []*contractmodel.CtrContractProduct
+	err = tx.GetStructs(&product, "select * from ctr_contract_product where contract_id = ?", contractId)
+	if err == sql.ErrNoRows {
+		return nil, myerrors.TipsError(fmt.Sprintf("合同产品为空: %d", contractId))
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	var deliverSoft *work.DeliverOrder
+	var deliverHard *work.DeliverOrder
+	deliverProductSoft := []work.DeliverOrderProduct{}
+	deliverProductHard := []work.DeliverOrderProduct{}
+
+	for _, p := range product {
+		var orderType string
+		if p.ProdClass == "10" || p.ProdClass == "20" || p.ProdClass == "30" {
+			orderType = "10"
+		}
+		if p.ProdClass == "40" || p.ProdClass == "60" {
+			orderType = "20"
+		}
+		o := work.DeliverOrder{
+			OrderCode:      fmt.Sprintf("%s%s", c.ContractCode, orderType),
+			OrderStatus:    "10",
+			OrderType:      orderType,
+			CustId:         c.CustId,
+			CustName:       c.CustName,
+			ProjectId:      c.NboId,
+			ProjectName:    c.NboName,
+			ContractId:     c.Id,
+			ContractCode:   c.ContractCode,
+			ProjectManId:   0,
+			ProjectManName: "",
+			DeliverManId:   0,
+			DeliverManName: "",
+			Product:        c.ProductLine,
+			Remark:         "",
+			CreatedBy:      int(userInfo.Id),
+			CreatedName:    userInfo.NickName,
+			CreatedTime:    gtime.Now(),
+			UpdatedBy:      int(userInfo.Id),
+			UpdatedName:    userInfo.NickName,
+			UpdatedTime:    gtime.Now(),
+		}
+		op := work.DeliverOrderProduct{
+			DeliverOrderId: 0,
+			ProductCode:    p.ProdCode,
+			ProductName:    p.ProdName,
+			ProductType:    p.ProdClass,
+			ProductNum:     p.ProdNum,
+			Remark:         "",
+			CreatedBy:      int(userInfo.Id),
+			CreatedName:    userInfo.NickName,
+			CreatedTime:    gtime.Now(),
+			UpdatedBy:      int(userInfo.Id),
+			UpdatedName:    userInfo.NickName,
+			UpdatedTime:    gtime.Now(),
+		}
+		if orderType == "10" {
+			deliverSoft = &o
+			deliverProductSoft = append(deliverProductSoft, op)
+		}
+		if orderType == "20" {
+			deliverHard = &o
+			deliverProductHard = append(deliverProductHard, op)
+		}
+	}
+
+	var id = []int{}
+	if deliverHard != nil {
+		oid, err := tx.InsertAndGetId("deliver_order", *deliverHard)
+		if err != nil {
+			return nil, err
+		}
+		err = DeliverOrderBindProduct(tx, int(oid), deliverProductHard)
+		if err != nil {
+			return nil, err
+		}
+		id = append(id, int(oid))
+	}
+	if deliverSoft != nil {
+		oid, err := tx.InsertAndGetId("deliver_order", *deliverSoft)
+		if err != nil {
+			return nil, err
+		}
+		err = DeliverOrderBindProduct(tx, int(oid), deliverProductSoft)
+		if err != nil {
+			return nil, err
+		}
+		id = append(id, int(oid))
+	}
+	return id, nil
+}
+
+func DeliverOrderBindProduct(tx *gdb.TX, id int, product []work.DeliverOrderProduct) error {
+	_, err := tx.Delete("deliver_order_product", "deliver_order_id = ?", id)
+	if err != nil {
+		return err
+	}
+	for i := range product {
+		product[i].DeliverOrderId = id
+	}
+	if len(product) != 0 {
+		_, err = tx.Insert("deliver_order_product", product)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s DeliverOrderService) Update(ctx context.Context, req *work.DeliverOrderUpdateReq) error {
+	validErr := gvalid.CheckStruct(ctx, req, nil)
+	if validErr != nil {
+		return myerrors.TipsError(validErr.Current().Error())
+	}
+
+	ent, err := s.Dao.Where("id = ?", req.Id).One()
+	if err != nil {
+		return err
+	}
+	if ent == nil {
+		return myerrors.TipsError(fmt.Sprintf("工单不存在: %d", req.Id))
+	}
+
+	toupdate := map[string]interface{}{}
+	if req.OrderStatus != "" {
+		toupdate["order_status"] = req.OrderStatus
+	}
+	if req.ProjectManId != 0 {
+		toupdate["project_man_id"] = req.ProjectManId
+	}
+	if req.ProjectManName != "" {
+		toupdate["project_man_name"] = req.ProjectManName
+	}
+	if req.DeliverManId != 0 {
+		toupdate["deliver_man_id"] = req.DeliverManId
+	}
+	if req.DeliverManName != "" {
+		toupdate["deliver_man_name"] = req.DeliverManName
+	}
+	if len(toupdate) != 0 {
+		toupdate["updated_by"] = int(s.userInfo.Id)
+		toupdate["updated_name"] = s.userInfo.NickName
+		toupdate["updated_time"] = gtime.Now()
+		txerr := s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
+			_, err = tx.Update("deliver_order", toupdate, "id = ?", req.Id)
+			if err != nil {
+				return err
+			}
+			return nil
+		})
+		if txerr != nil {
+			return txerr
+		}
+	}
+	return nil
+}
+
+func (s *DeliverOrderService) Finish(ctx context.Context, req *work.DeliverOrderFinishReq) error {
+	ent, err := s.Dao.Where("id = ?", req.OrderId).One()
+	if err != nil {
+		return err
+	}
+	if ent == nil {
+		return myerrors.TipsError("工单不存在")
+	}
+	// if ent.OrderStatus != "30" {
+	// 	return myerrors.TipsError("当前工单不可完成")
+	// }
+
+	return s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
+		_, err = tx.Update("deliver_order", map[string]interface{}{
+			"order_status":   "20",
+			"finish_remark":  req.FinishRemark,
+			"finish_time":    gtime.Now(),
+			"finish_by":      int(s.userInfo.Id),
+			"finish_by_name": s.userInfo.NickName,
+			"updated_by":     int(s.userInfo.Id),
+			"updated_name":   s.userInfo.NickName,
+			"updated_time":   gtime.Now(),
+		}, "id = ?", req.OrderId)
+		return err
+	})
+}
+
+func (s DeliverOrderService) Delete(ctx context.Context, id []int) error {
+	if len(id) == 0 {
+		return nil
+	}
+	_, err := s.Dao.Where("Id  IN (?)", id).Delete()
+	return err
+}

opms_parent/app/service/work/deliver_order_plan.go

@@ -0,0 +1,266 @@
+package work
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+
+	contractdao "dashoo.cn/micro/app/dao/contract"
+	workdao "dashoo.cn/micro/app/dao/work"
+	work "dashoo.cn/micro/app/model/work"
+
+	"dashoo.cn/opms_libary/micro_srv"
+	"dashoo.cn/opms_libary/myerrors"
+	"dashoo.cn/opms_libary/request"
+	"github.com/gogf/gf/database/gdb"
+	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/gtime"
+	"github.com/gogf/gf/util/gvalid"
+)
+
+type DeliverOrderPlanService struct {
+	Dao         *workdao.DeliverOrderImpPlanDao
+	OrderDao    *workdao.DeliverOrderDao
+	ProgressDao *workdao.DeliverOrderImpProgressDao
+	ProductDao  *workdao.DeliverOrderProductDao
+	ContractDao *contractdao.CtrContractDao
+
+	Tenant    string
+	userInfo  request.UserInfo
+	DataScope g.Map `json:"dataScope"`
+}
+
+func NewDeliverOrderPlanService(ctx context.Context) (*DeliverOrderPlanService, error) {
+	tenant, err := micro_srv.GetTenant(ctx)
+	if err != nil {
+		err = myerrors.TipsError(fmt.Sprintf("获取租户码异常：%s", err.Error()))
+		return nil, err
+	}
+	// 获取用户信息
+	userInfo, err := micro_srv.GetUserInfo(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("获取用户信息异常：%s", err.Error())
+	}
+	return &DeliverOrderPlanService{
+		Dao:         workdao.NewDeliverOrderImpPlanDao(tenant),
+		OrderDao:    workdao.NewDeliverOrderDao(tenant),
+		ProgressDao: workdao.NewDeliverOrderImpProgressDao(tenant),
+		ContractDao: contractdao.NewCtrContractDao(tenant),
+		ProductDao:  workdao.NewDeliverOrderProductDao(tenant),
+		Tenant:      tenant,
+		userInfo:    userInfo,
+		DataScope:   userInfo.DataScope,
+	}, nil
+}
+
+func (s DeliverOrderPlanService) Get(ctx context.Context, id int) (*work.DeliverOrderPlanGetRsp, error) {
+	ent, err := s.Dao.Where("Id = ?", id).One()
+	if err != nil {
+		return nil, err
+	}
+	if ent == nil {
+		return nil, myerrors.TipsError("工单不存在")
+	}
+	process, err := s.ProgressDao.Where("plan_id = ?", id).All()
+	if err != nil {
+		return nil, err
+	}
+	if process == nil {
+		process = []*work.DeliverOrderImpProgress{}
+	}
+	return &work.DeliverOrderPlanGetRsp{
+		DeliverOrderImpPlan: *ent,
+		Progress:            process,
+	}, nil
+}
+
+func (s DeliverOrderPlanService) List(ctx context.Context, req *work.DeliverOrderPlanListReq) (int, []*work.DeliverOrderPlanListRsp, error) {
+	dao := s.Dao.DB.Table("deliver_order_imp_plan a").LeftJoin("deliver_order b", "a.deliver_order_id=b.id")
+	if req.DeliverOrderId != 0 {
+		dao = dao.Where("a.deliver_order_id = ?", req.DeliverOrderId)
+	}
+	if req.PlanTitle != "" {
+		likestr := fmt.Sprintf("%%%s%%", req.PlanTitle)
+		dao = dao.Where("a.plan_title like ?", likestr)
+	}
+	if req.PlanStatus != "" {
+		dao = dao.Where("a.plan_status = ?", req.PlanStatus)
+	}
+
+	total, err := dao.Count()
+	if err != nil {
+		return 0, nil, err
+	}
+	if req.PageNum != 0 {
+		dao = dao.Page(req.GetPage())
+	}
+	orderby := "a.created_time desc"
+	if req.OrderBy != "" {
+		orderby = req.OrderBy
+	}
+	dao = dao.Order(orderby)
+
+	ents := []*work.DeliverOrderPlanListRsp{}
+	err = dao.Fields("a.*, b.order_status as OrderStatus").Structs(&ents)
+	if err != nil && err != sql.ErrNoRows {
+		return 0, nil, err
+	}
+	return total, ents, err
+}
+
+func (s DeliverOrderPlanService) Add(ctx context.Context, req *work.DeliverOrderImpPlanAddReq) (int, error) {
+	validErr := gvalid.CheckStruct(ctx, req, nil)
+	if validErr != nil {
+		return 0, myerrors.TipsError(validErr.Current().Error())
+	}
+
+	o, err := s.OrderDao.Where("id = ?", req.DeliverOrderId).One()
+	if err != nil {
+		return 0, err
+	}
+	if o == nil {
+		return 0, myerrors.TipsError(fmt.Sprintf("工单：%d 不存在", req.DeliverOrderId))
+	}
+	if o.OrderStatus == "20" {
+		return 0, myerrors.TipsError("工单已完成")
+	}
+
+	var id int
+	txerr := s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
+		pid, err := tx.InsertAndGetId("deliver_order_imp_plan", work.DeliverOrderImpPlan{
+			DeliverOrderId: req.DeliverOrderId,
+			PlanTitle:      req.PlanTitle,
+			PlanStatus:     "10",
+			PlanStartDate:  req.PlanStartDate,
+			PlanEndDate:    req.PlanEndDate,
+			Remark:         "",
+			CreatedBy:      int(s.userInfo.Id),
+			CreatedName:    s.userInfo.NickName,
+			CreatedTime:    gtime.Now(),
+			UpdatedBy:      int(s.userInfo.Id),
+			UpdatedName:    s.userInfo.NickName,
+			UpdatedTime:    gtime.Now(),
+		})
+		if err != nil {
+			return err
+		}
+		id = int(pid)
+		return nil
+	})
+	return id, txerr
+}
+
+func (s DeliverOrderPlanService) Update(ctx context.Context, req *work.DeliverOrderImpPlanUpdateReq) error {
+	validErr := gvalid.CheckStruct(ctx, req, nil)
+	if validErr != nil {
+		return myerrors.TipsError(validErr.Current().Error())
+	}
+
+	ent, err := s.Dao.Where("id = ?", req.Id).One()
+	if err != nil {
+		return err
+	}
+	if ent == nil {
+		return myerrors.TipsError(fmt.Sprintf("工单计划不存在: %d", req.Id))
+	}
+
+	toupdate := map[string]interface{}{}
+	if req.PlanTitle != "" {
+		toupdate["plan_title"] = req.PlanTitle
+	}
+	if req.PlanStatus != "" {
+		toupdate["plan_status"] = req.PlanStatus
+	}
+	if req.PlanStartDate != nil {
+		toupdate["plan_start_date"] = req.PlanStartDate
+	}
+	if req.PlanEndDate != nil {
+		toupdate["plan_end_date"] = req.PlanEndDate
+	}
+	if len(toupdate) != 0 {
+		toupdate["updated_by"] = int(s.userInfo.Id)
+		toupdate["updated_name"] = s.userInfo.NickName
+		toupdate["updated_time"] = gtime.Now()
+		txerr := s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
+			_, err = tx.Update("deliver_order_imp_plan", toupdate, "id = ?", req.Id)
+			if err != nil {
+				return err
+			}
+			return nil
+		})
+		if txerr != nil {
+			return txerr
+		}
+	}
+	return nil
+}
+
+func (s DeliverOrderPlanService) Start(ctx context.Context, req *work.DeliverOrderImpPlanStartReq) error {
+	validErr := gvalid.CheckStruct(ctx, req, nil)
+	if validErr != nil {
+		return myerrors.TipsError(validErr.Current().Error())
+	}
+
+	ent, err := s.Dao.Where("id = ?", req.Id).One()
+	if err != nil {
+		return err
+	}
+	if ent == nil {
+		return myerrors.TipsError(fmt.Sprintf("工单计划不存在: %d", req.Id))
+	}
+
+	txerr := s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
+		_, err = tx.Update("deliver_order_imp_plan", map[string]interface{}{
+			"plan_status":    "20",
+			"rea_start_date": gtime.Now(),
+			"remark":         req.Remark,
+		}, "id = ?", req.Id)
+		if err != nil {
+			return err
+		}
+		return nil
+	})
+	if txerr != nil {
+		return txerr
+	}
+	return nil
+}
+
+func (s DeliverOrderPlanService) Finish(ctx context.Context, req *work.DeliverOrderImpPlanFinishReq) error {
+	validErr := gvalid.CheckStruct(ctx, req, nil)
+	if validErr != nil {
+		return myerrors.TipsError(validErr.Current().Error())
+	}
+
+	ent, err := s.Dao.Where("id = ?", req.Id).One()
+	if err != nil {
+		return err
+	}
+	if ent == nil {
+		return myerrors.TipsError(fmt.Sprintf("工单计划不存在: %d", req.Id))
+	}
+
+	txerr := s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
+		_, err = tx.Update("deliver_order_imp_plan", map[string]interface{}{
+			"plan_status":  "30",
+			"rea_end_date": gtime.Now(),
+			"remark":       req.Remark,
+		}, "id = ?", req.Id)
+		if err != nil {
+			return err
+		}
+		return nil
+	})
+	if txerr != nil {
+		return txerr
+	}
+	return nil
+}
+
+func (s DeliverOrderPlanService) Delete(ctx context.Context, id []int) error {
+	if len(id) == 0 {
+		return nil
+	}
+	_, err := s.Dao.Where("Id  IN (?)", id).Delete()
+	return err
+}

opms_parent/app/service/work/deliver_order_progress.go

@@ -0,0 +1,268 @@
+package work
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+
+	contractdao "dashoo.cn/micro/app/dao/contract"
+	workdao "dashoo.cn/micro/app/dao/work"
+	work "dashoo.cn/micro/app/model/work"
+
+	"dashoo.cn/opms_libary/micro_srv"
+	"dashoo.cn/opms_libary/myerrors"
+	"dashoo.cn/opms_libary/request"
+	"github.com/gogf/gf/database/gdb"
+	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/gtime"
+	"github.com/gogf/gf/util/gvalid"
+)
+
+type DeliverOrderProgressService struct {
+	Dao         *workdao.DeliverOrderImpProgressDao
+	PlanDao     *workdao.DeliverOrderImpPlanDao
+	OrderDao    *workdao.DeliverOrderDao
+	ProductDao  *workdao.DeliverOrderProductDao
+	ContractDao *contractdao.CtrContractDao
+
+	Tenant    string
+	userInfo  request.UserInfo
+	DataScope g.Map `json:"dataScope"`
+}
+
+func NewDeliverOrderProgressService(ctx context.Context) (*DeliverOrderProgressService, error) {
+	tenant, err := micro_srv.GetTenant(ctx)
+	if err != nil {
+		err = myerrors.TipsError(fmt.Sprintf("获取租户码异常：%s", err.Error()))
+		return nil, err
+	}
+	// 获取用户信息
+	userInfo, err := micro_srv.GetUserInfo(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("获取用户信息异常：%s", err.Error())
+	}
+	return &DeliverOrderProgressService{
+		Dao:         workdao.NewDeliverOrderImpProgressDao(tenant),
+		PlanDao:     workdao.NewDeliverOrderImpPlanDao(tenant),
+		OrderDao:    workdao.NewDeliverOrderDao(tenant),
+		ContractDao: contractdao.NewCtrContractDao(tenant),
+		ProductDao:  workdao.NewDeliverOrderProductDao(tenant),
+		Tenant:      tenant,
+		userInfo:    userInfo,
+		DataScope:   userInfo.DataScope,
+	}, nil
+}
+
+func (s DeliverOrderProgressService) List(ctx context.Context, req *work.DeliverOrderProgressListReq) (int, []*work.DeliverOrderImpProgress, error) {
+	dao := &s.Dao.DeliverOrderImpProgressDao
+	if req.DeliverOrderId != 0 {
+		dao = dao.Where("deliver_order_id = ?", req.DeliverOrderId)
+	}
+	if req.PlanId != 0 {
+		dao = dao.Where("plan_id = ?", req.PlanId)
+	}
+	if req.ProgressTitle != "" {
+		likestr := fmt.Sprintf("%%%s%%", req.ProgressTitle)
+		dao = dao.Where("progress_title like ?", likestr)
+	}
+	if req.ProgressStatus != "" {
+		dao = dao.Where("progress_status = ?", req.ProgressStatus)
+	}
+	if req.ProgressLevel != "" {
+		dao = dao.Where("progress_level = ?", req.ProgressLevel)
+	}
+
+	total, err := dao.Count()
+	if err != nil {
+		return 0, nil, err
+	}
+	if req.PageNum != 0 {
+		dao = dao.Page(req.GetPage())
+	}
+	orderby := "created_time desc"
+	if req.OrderBy != "" {
+		orderby = req.OrderBy
+	}
+	dao = dao.Order(orderby)
+
+	ents := []*work.DeliverOrderImpProgress{}
+	err = dao.Structs(&ents)
+	if err != nil && err != sql.ErrNoRows {
+		return 0, nil, err
+	}
+	return total, ents, err
+}
+
+func (s DeliverOrderProgressService) Add(ctx context.Context, req *work.DeliverOrderProgressAddReq) (int, error) {
+	validErr := gvalid.CheckStruct(ctx, req, nil)
+	if validErr != nil {
+		return 0, myerrors.TipsError(validErr.Current().Error())
+	}
+
+	p, err := s.PlanDao.Where("id = ?", req.PlanId).One()
+	if err != nil {
+		return 0, err
+	}
+	if p == nil {
+		return 0, myerrors.TipsError(fmt.Sprintf("工单计划：%d 不存在", req.PlanId))
+	}
+
+	var id int
+	txerr := s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
+		pid, err := tx.InsertAndGetId("deliver_order_imp_progress", work.DeliverOrderImpProgress{
+			PlanId:          req.PlanId,
+			ProgressTitle:   req.ProgressTitle,
+			ProgressContext: req.ProgressContext,
+			StartDate:       req.StartDate,
+			EndDate:         req.EndDate,
+			ReaStartDate:    req.ReaStartDate,
+			ReaEndDate:      req.ReaEndDate,
+			ProgressStatus:  "10",
+			ProgressLevel:   req.ProgressLevel,
+			Remark:          req.Remark,
+			CreatedBy:       int(s.userInfo.Id),
+			CreatedName:     s.userInfo.NickName,
+			CreatedTime:     gtime.Now(),
+			UpdatedBy:       int(s.userInfo.Id),
+			UpdatedName:     s.userInfo.NickName,
+			UpdatedTime:     gtime.Now(),
+		})
+		if err != nil {
+			return err
+		}
+		id = int(pid)
+		return nil
+	})
+	return id, txerr
+}
+
+func (s DeliverOrderProgressService) Update(ctx context.Context, req *work.DeliverOrderProgressUpdateReq) error {
+	validErr := gvalid.CheckStruct(ctx, req, nil)
+	if validErr != nil {
+		return myerrors.TipsError(validErr.Current().Error())
+	}
+
+	ent, err := s.Dao.Where("id = ?", req.Id).One()
+	if err != nil {
+		return err
+	}
+	if ent == nil {
+		return myerrors.TipsError(fmt.Sprintf("工单任务不存在: %d", req.Id))
+	}
+
+	toupdate := map[string]interface{}{}
+	if req.ProgressTitle != "" {
+		toupdate["progress_title"] = req.ProgressTitle
+	}
+	if req.ProgressContext != "" {
+		toupdate["progress_context"] = req.ProgressContext
+	}
+	if req.StartDate != nil {
+		toupdate["start_date"] = req.StartDate
+	}
+	if req.EndDate != nil {
+		toupdate["end_date"] = req.EndDate
+	}
+	if req.ReaStartDate != nil {
+		toupdate["rea_start_date"] = req.ReaStartDate
+	}
+	if req.ReaEndDate != nil {
+		toupdate["rea_end_date"] = req.ReaEndDate
+	}
+	if req.ProgressStatus != "" {
+		toupdate["progress_status"] = req.ProgressStatus
+	}
+	if req.ProgressLevel != "" {
+		toupdate["progress_level"] = req.ProgressLevel
+	}
+	if req.Remark != nil {
+		toupdate["remark"] = req.Remark
+	}
+	if len(toupdate) != 0 {
+		toupdate["updated_by"] = int(s.userInfo.Id)
+		toupdate["updated_name"] = s.userInfo.NickName
+		toupdate["updated_time"] = gtime.Now()
+		txerr := s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
+			_, err = tx.Update("deliver_order_imp_progress", toupdate, "id = ?", req.Id)
+			if err != nil {
+				return err
+			}
+			return nil
+		})
+		if txerr != nil {
+			return txerr
+		}
+	}
+	return nil
+}
+
+
+func (s DeliverOrderProgressService) Start(ctx context.Context, req *work.DeliverOrderImpProgressStartReq) error {
+	validErr := gvalid.CheckStruct(ctx, req, nil)
+	if validErr != nil {
+		return myerrors.TipsError(validErr.Current().Error())
+	}
+
+	ent, err := s.Dao.Where("id = ?", req.Id).One()
+	if err != nil {
+		return err
+	}
+	if ent == nil {
+		return myerrors.TipsError(fmt.Sprintf("工单任务不存在: %d", req.Id))
+	}
+
+	txerr := s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
+		_, err = tx.Update("deliver_order_imp_progress", map[string]interface{}{
+			"progress_status":    "20",
+			"rea_start_date": gtime.Now(),
+			"remark":         req.Remark,
+		}, "id = ?", req.Id)
+		if err != nil {
+			return err
+		}
+		return nil
+	})
+	if txerr != nil {
+		return txerr
+	}
+	return nil
+}
+
+func (s DeliverOrderProgressService) Finish(ctx context.Context, req *work.DeliverOrderImpProgressFinishReq) error {
+	validErr := gvalid.CheckStruct(ctx, req, nil)
+	if validErr != nil {
+		return myerrors.TipsError(validErr.Current().Error())
+	}
+
+	ent, err := s.Dao.Where("id = ?", req.Id).One()
+	if err != nil {
+		return err
+	}
+	if ent == nil {
+		return myerrors.TipsError(fmt.Sprintf("工单任务不存在: %d", req.Id))
+	}
+
+	txerr := s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
+		_, err = tx.Update("deliver_order_imp_progress", map[string]interface{}{
+			"progress_status":  "30",
+			"rea_end_date": gtime.Now(),
+			"remark":       req.Remark,
+		}, "id = ?", req.Id)
+		if err != nil {
+			return err
+		}
+		return nil
+	})
+	if txerr != nil {
+		return txerr
+	}
+	return nil
+}
+
+func (s DeliverOrderProgressService) Delete(ctx context.Context, id []int) error {
+	if len(id) == 0 {
+		return nil
+	}
+	_, err := s.Dao.Where("Id  IN (?)", id).Delete()
+	return err
+}

opms_parent/main.go

@@ -57,6 +57,9 @@ func main() {
 	s.RegisterName("CtrContractInvoice", new(contract.CtrContractInvoice), "")
 	s.RegisterName("WorkOrder", new(work.WorkOrderHandler), "")
 	s.RegisterName("WorkOrderType", new(work.WorkOrderTypeHandler), "")
+	s.RegisterName("DeliverOrder", new(work.DeliverOrder), "")
+	s.RegisterName("DeliverOrderPlan", new(work.DeliverOrderPlan), "")
+	s.RegisterName("DeliverOrderProgress", new(work.DeliverOrderProgress), "")
 	s.RegisterName("Schedule", new(plat.ScheduleHeader), "")
 	s.RegisterName("PlatWorkflow", new(workflow.PlatWorkflowHandler), "")
 	s.RegisterName("DingUpload", new(dingtalk.DingUploadHandler), "")

opms_parent/schema/work_order.sql

@@ -29,8 +29,100 @@ work_order CREATE TABLE `work_order` (
 alter table work_order add `product_line` varchar(4) NOT NULL COMMENT '产品线' after nbo_name;
 alter table work_order add `end_time` datetime DEFAULT NULL COMMENT '结束时间' after order_status;
 alter table work_order add `finish_remark` text DEFAULT NULL COMMENT '完成信息' after `file`;
-alter table work_order add `finish_time` datetime DEFAULT NULL COMMENT '完成信息' after `finish_remark`;
+alter table work_order add `finish_time` datetime DEFAULT NULL COMMENT '完成时间' after `finish_remark`;
 alter table work_order add `finish_by` int(11) DEFAULT NULL COMMENT '完成操作人' after `finish_time`;
 alter table work_order add `finish_by_name`  varchar(90) DEFAULT NULL COMMENT '完成操作人' after `finish_by`;
 alter table work_order modify `order_status` varchar(4) NOT NULL COMMENT '工单状态（10发起20审批中30审批通过40审批拒绝50关闭60已完成）';
 
+
+DROP TABLE IF EXISTS deliver_order;
+CREATE TABLE deliver_order(
+    `id` INT(11) NOT NULL AUTO_INCREMENT  COMMENT '主键' ,
+    `order_code` VARCHAR(32) NOT NULL   COMMENT '交付订单号' ,
+    `order_status` VARCHAR(4) NOT NULL   COMMENT '交付状态(10项目立项 20 完成)' ,
+    `order_type` VARCHAR(4) NOT NULL   COMMENT '交付类型(10 软件 20 硬件)' ,
+    `cust_id` INT(11) NOT NULL   COMMENT '关联客户ID' ,
+    `cust_name` VARCHAR(90) NOT NULL   COMMENT '关联客户名称' ,
+    `project_id` INT(11) NOT NULL   COMMENT '关联项目ID' ,
+    `project_name` VARCHAR(90) NOT NULL   COMMENT '关联项目名称' ,
+    `contract_id` INT(11) NOT NULL   COMMENT '关联合同ID' ,
+    `contract_code` VARCHAR(32) NOT NULL   COMMENT '关联合同编号' ,
+    `project_man_id` INT(11)    COMMENT '项目经理' ,
+    `project_man_name` VARCHAR(90)    COMMENT '项目经理' ,
+    `deliver_man_id` INT(11)    COMMENT '交付经理' ,
+    `deliver_man_name` VARCHAR(90)    COMMENT '交付经理' ,
+    `product` VARCHAR(4)    COMMENT '产品线' ,
+    `finish_remark` text DEFAULT NULL COMMENT '完成信息',
+    `finish_time` datetime DEFAULT NULL COMMENT '完成时间',
+    `finish_by` int(11) DEFAULT NULL COMMENT '完成操作人',
+    `finish_by_name`  varchar(90) DEFAULT NULL COMMENT '完成操作人',
+    `remark` TEXT    COMMENT '备注' ,
+    `created_by` INT(11) NOT NULL   COMMENT '创建者' ,
+    `created_name` VARCHAR(90) NOT NULL   COMMENT '创建人' ,
+    `created_time` DATETIME NOT NULL   COMMENT '创建时间' ,
+    `updated_by` INT(11)    COMMENT '更新者' ,
+    `updated_name` VARCHAR(90)    COMMENT '更新人' ,
+    `updated_time` DATETIME    COMMENT '更新时间' ,
+    `deleted_time` DATETIME    COMMENT '删除时间' ,
+    PRIMARY KEY (id)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COMMENT = '交付订单';
+DROP TABLE IF EXISTS deliver_order_product;
+CREATE TABLE deliver_order_product(
+    `id` INT(11) NOT NULL AUTO_INCREMENT  COMMENT '主键' ,
+    `deliver_order_id` INT(11) NOT NULL   COMMENT '关联交付订单ID' ,
+    `product_code` VARCHAR(32) NOT NULL   COMMENT '产品编码' ,
+    `product_name` VARCHAR(90) NOT NULL   COMMENT '产品名称' ,
+    `product_type` VARCHAR(4) NOT NULL   COMMENT '产品类型' ,
+    `product_num` INT NOT NULL   COMMENT '产品数量' ,
+    `remark` TEXT    COMMENT '备注' ,
+    `created_by` INT(11) NOT NULL   COMMENT '创建者' ,
+    `created_name` VARCHAR(90) NOT NULL   COMMENT '创建人' ,
+    `created_time` DATETIME NOT NULL   COMMENT '创建时间' ,
+    `updated_by` INT(11)    COMMENT '更新者' ,
+    `updated_name` VARCHAR(90)    COMMENT '更新人' ,
+    `updated_time` DATETIME    COMMENT '更新时间' ,
+    `deleted_time` DATETIME    COMMENT '删除时间' ,
+    PRIMARY KEY (id)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COMMENT = '交付订单产品明细';
+DROP TABLE IF EXISTS deliver_order_imp_plan;
+CREATE TABLE deliver_order_imp_plan(
+    `id` INT(11) NOT NULL AUTO_INCREMENT  COMMENT '主键' ,
+    `deliver_order_id` INT(11) NOT NULL   COMMENT '关联交付订单ID' ,
+    `plan_title` VARCHAR(90) NOT NULL   COMMENT '计划标题' ,
+    `plan_status` VARCHAR(4) NOT NULL   COMMENT '计划状态（10 未开始 20 已开始 30已关闭）' ,
+    `plan_start_date` DATETIME NOT NULL   COMMENT '开始时间' ,
+    `plan_end_date` DATETIME NOT NULL   COMMENT '结束时间' ,
+    `rea_start_date` DATETIME    COMMENT '实际开始时间' ,
+    `rea_end_date` DATETIME    COMMENT '实际结束时间' ,
+    `remark` TEXT    COMMENT '备注' ,
+    `created_by` INT(11) NOT NULL   COMMENT '创建者' ,
+    `created_name` VARCHAR(90) NOT NULL   COMMENT '创建人' ,
+    `created_time` DATETIME NOT NULL   COMMENT '创建时间' ,
+    `updated_by` INT(11)    COMMENT '更新者' ,
+    `updated_name` VARCHAR(90)    COMMENT '更新人' ,
+    `updated_time` DATETIME    COMMENT '更新时间' ,
+    `deleted_time` DATETIME    COMMENT '删除时间' ,
+    PRIMARY KEY (id)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COMMENT = '交付订单实施计划';
+DROP TABLE IF EXISTS deliver_order_imp_progress;
+CREATE TABLE deliver_order_imp_progress(
+    `id` INT(11) NOT NULL AUTO_INCREMENT  COMMENT '主键' ,
+    `plan_id` INT(11) NOT NULL   COMMENT '关联实施计划' ,
+    `progress_title` VARCHAR(90) NOT NULL   COMMENT '任务标题' ,
+    `progress_context` TEXT    COMMENT '任务内容' ,
+    `start_date` DATETIME NOT NULL   COMMENT '开始时间' ,
+    `end_date` DATETIME NOT NULL   COMMENT '结束时间' ,
+    `rea_start_date` DATETIME    COMMENT '实际开始时间' ,
+    `rea_end_date` DATETIME    COMMENT '实际结束时间' ,
+    `progress_status` VARCHAR(255) NOT NULL   COMMENT '状态(10未开始20已开始30已完成)' ,
+    `progress_level` VARCHAR(255) NOT NULL   COMMENT '优先级（10最高 20普通 30较低 ）' ,
+    `remark` TEXT    COMMENT '备注' ,
+    `created_by` INT(11) NOT NULL   COMMENT '创建者' ,
+    `created_name` VARCHAR(90) NOT NULL   COMMENT '创建人' ,
+    `created_time` DATETIME NOT NULL   COMMENT '创建时间' ,
+    `updated_by` INT(11)    COMMENT '更新者' ,
+    `updated_name` VARCHAR(90)    COMMENT '更新人' ,
+    `updated_time` DATETIME    COMMENT '更新时间' ,
+    `deleted_time` DATETIME    COMMENT '删除时间' ,
+    PRIMARY KEY (id)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COMMENT = '交付订单实施进展';