Cold_GoodsOrder/models/Function/Order.go

package Function

import (
	"Cold_GoodsOrder/Nats/NatsServer"
	"Cold_GoodsOrder/conf"
	"encoding/json"
	"fmt"
	"github.com/astaxie/beego/cache"
	"github.com/beego/beego/v2/adapter/orm"
	orm2 "github.com/beego/beego/v2/client/orm"
	_ "github.com/go-sql-driver/mysql"
	"strconv"
	"time"
)

// Order 模板
type Order struct {
	Id                  int       `orm:"column(ID);size(11);auto;pk"`
	T_pid               int       `orm:"index;size(256);null"`                                  // Account.Company 绑定公司
	ChildPid            string    `orm:"index;size(256);null"`                                  //子公司id
	T_orderid           string    `orm:"size(256);null"`                                        // 订单号
	T_outorderid        string    `orm:"size(256);null"`                                        // 出库订单号
	WaybillNo           string    `orm:"size(256);null"`                                        //运单号
	T_sn                string    `orm:"size(256);null"`                                        // 设备sn
	DeviceType          string    `orm:"size(256);null"`                                        // 设备类型
	T_receiving         string    `orm:"size(256);null"`                                        // 收货单位
	ShippingUnit        string    `orm:"size(256);null"`                                        //发货单位
	T_start_Ut          time.Time `orm:"type(timestamp);null;"`                                 // 起运时间
	T_end_Ut            time.Time `orm:"type(timestamp);null;"`                                 // 到达时间
	EstimateEndTime     time.Time `orm:"type(timestamp);null;"`                                 // 预计到达时间
	EstimateStartTime   time.Time `orm:"type(timestamp);null;"`                                 // 预计开始时间
	PeerList            string    `orm:"size(256);null"`                                        //随货同行单
	T_text              string    `orm:"type(text);null"`                                       // 详情
	T_State             int       `orm:"size(2);default(1)"`                                    //1 正常 2 在途 3 已到达
	IsExpatriate        int       `orm:"size(2);default(1)"`                                    //1 非外派  2外派
	ExpatriateReceiving string    `orm:"size(256);null"`                                        //外派收货单位
	Phone               string    `orm:"size(256);"`                                            //电话
	CreateTime          time.Time `orm:"column(create_time);type(timestamp);null;auto_now_add"` //auto_now_add 第一次保存时才设置时间
	UpdateTime          time.Time `orm:"column(update_time);type(timestamp);null;auto_now"`     //auto_now 每次 model 保存时都会对时间自动更新
}
type OrderR struct {
	Id                int     // ID
	T_orderid         string  // 订单号
	T_outorderid      string  // 出库订单号
	ShippingUnit      string  //发货单位
	T_name            string  // 设备名称
	DeviceType        string  // 设备类型
	T_sn              string  // 设备sn
	T_receiving       string  // 收货单位
	T_start_Ut        string  // 起运时间
	T_start_Ut_T      float32 // 起运温度
	T_end_Ut          string  // 到达时间
	T_end_Ut_T        float32 // 到达时间
	T_text            string  // 详情
	PeerList          string  //随货同行单号
	WaybillNo         string
	T_State           int
	ChildPid          string
	IsExpatriate      int    //1 非外派  2外派
	Phone             string //电话
	EstimateStartTime string
	EstimateEndTime   string
}

func OrderToOrderR(t Order) (r OrderR) {
	r.Id = t.Id
	r.T_orderid = t.T_orderid
	r.T_outorderid = t.T_outorderid
	Device_r, err := NatsServer.ReadDeviceByT_sn(t.T_sn)
	r.T_name = t.T_sn
	if err == nil {
		r.T_name = Device_r.T_devName
	}
	r.WaybillNo = t.WaybillNo
	r.ChildPid = t.ChildPid
	r.IsExpatriate = t.IsExpatriate
	r.Phone = t.Phone
	r.T_sn = t.T_sn
	r.T_receiving = t.T_receiving
	if !t.T_start_Ut.IsZero() {
		r.T_start_Ut = t.T_start_Ut.Format("2006-01-02 15:04:05")
	}
	if !t.T_end_Ut.IsZero() {
		r.T_end_Ut = t.T_end_Ut.Format("2006-01-02 15:04:05")
	}
	if !t.EstimateStartTime.IsZero() {
		r.EstimateStartTime = t.EstimateStartTime.Format("2006-01-02 15:04:05")
	}
	if !t.EstimateEndTime.IsZero() {
		r.EstimateEndTime = t.EstimateEndTime.Format("2006-01-02 15:04:05")
	}
	r.T_text = t.T_text
	r.PeerList = t.PeerList
	r.ShippingUnit = t.ShippingUnit
	r.DeviceType = t.DeviceType
	r.T_State = t.T_State
	return
}

func (t *Order) TableName() string {
	return "order" // 数据库名称   // ************** 替换 FormulaList **************
}

var redisCache_Order cache.Cache

func init() {
	//注册模型
	orm.RegisterModel(new(Order))
	config := fmt.Sprintf(`{"key":"%s","conn":"%s","dbNum":"%s","password":"%s"}`,
		"redis_Order", conf.Redis_address, conf.Redis_dbNum, conf.Redis_password)
	fmt.Println(config)
	var err error
	redisCache_Order, err = cache.NewCache("redis", config)
	if err != nil || redisCache_Order == nil {
		errMsg := "failed to init redis"
		fmt.Println(errMsg, err)
	}

}

// ---------------- Redis -------------------
func Redis_Order_Set(r Order) (err error) {
	//json序列化
	str, err := json.Marshal(r)
	if err != nil {
		fmt.Print(err)
		return
	}

	err = redisCache_Order.Put(strconv.Itoa(r.Id), str, 24*time.Hour)
	if err != nil {
		fmt.Println("set key:", strconv.Itoa(r.Id), ",value:", str, err)
	}
	return
}

func Redis_Order_Get(key string) (r Order, is bool) {
	if redisCache_Order.IsExist(key) {
		//println("找到key:",key)
		v := redisCache_Order.Get(key)

		json.Unmarshal(v.([]byte), &r)
		return r, true
	}
	//println("没有 找到key:",key)
	return Order{}, false
}

func Redis_Order_DelK(key string) (err error) {
	err = redisCache_Order.Delete(key)
	return
}

// ---------------- 特殊方法 -------------------

// 获取 ById
func Read_Order_ById(id int) (r Order) {
	if r, is := Redis_Order_Get(strconv.Itoa(id)); is {
		return r
	}

	o := orm.NewOrm()
	r = Order{Id: id}
	err := o.Read(&r)
	if err != nil {
		fmt.Println(err)
	}
	return r
}
func Read_Order_ByOderid(t_orderid string) (r Order) {

	o := orm.NewOrm()
	r = Order{T_orderid: t_orderid}
	err := o.Raw("SELECT * FROM `order` WHERE t_orderid = ?", t_orderid).QueryRow(&r)
	if err != nil {
		fmt.Println(err)
	}
	return r
}
func Read_Order_ByOrderid(id int) (r Order) {
	o := orm.NewOrm()
	r = Order{Id: id}
	err := o.Read(&r)
	if err != nil {
		fmt.Println(err)
	}
	return r
}

// 添加
func Add_Order(m Order) (id int64, err error) {
	o := orm.NewOrm()

	id, err = o.Insert(&m)
	if err != nil {
		fmt.Println(err)
	}
	Redis_Order_Set(m)
	return id, err
}

// 修改
func Update_Order(r Order, cols ...string) bool {
	o := orm.NewOrm()
	if num, err := o.Update(&r, cols...); err == nil {
		fmt.Println("Number of records updated in database:", num)
		Redis_Order_Set(r)
		return true
	}
	return false
}

// 删除
func Delete_Order(m Order) bool {
	o := orm.NewOrm()
	m.T_State = 0
	if num, err := o.Delete(&m); err == nil {
		fmt.Println("Number of records deleted in database:", num)
		Redis_Order_DelK(strconv.Itoa(m.Id))
		return true
	}
	return false
}

// Read_Order_List 获取列表
func Read_Order_List(T_pid int, page int, page_z int, order, sn, startTime, endTime string) (t []OrderR, cnt int64) {
	o := orm.NewOrm()

	// 也可以直接使用 Model 结构体作为表名
	qs := o.QueryTable(new(Order))
	var offset int64
	if page_z == 0 {
		page_z = conf.Page_size
	}
	var r []Order
	if page <= 1 {
		offset = 0
	} else {
		offset = int64((page - 1) * page_z)
	}

	cond := orm.NewCondition().And("T_pid", T_pid).Or("child_pid", T_pid)
	cond1 := orm.NewCondition().AndCond(cond)
	if len(order) > 0 {
		cond1 = cond1.And("T_orderid__icontains", order)
	}
	if len(sn) > 0 {
		cond1 = cond1.And("T_sn__icontains", sn)
	}
	if len(startTime) > 0 && len(endTime) > 0 {
		cond1 = cond1.And("T_start_Ut__gte", startTime).And("T_start_Ut__lte", endTime)
	}
	qs.Limit(page_z, offset).SetCond((*orm2.Condition)(cond1)).OrderBy("-Id").All(&r)
	cnt, _ = qs.SetCond((*orm2.Condition)(cond1)).Count()

	for _, v := range r {
		t = append(t, OrderToOrderR(v))
	}
	return t, cnt
}