ERP_storage/models/validationtool/validation.go

package validationtool

import (
	"ERP_storage/logs"
	"errors"
	"fmt"
	"github.com/beego/beego/v2/adapter/orm"
	orm2 "github.com/beego/beego/v2/client/orm"
	"gogs.baozhida.cn/zoie/ERP_libs/lib"
	"strconv"
	"time"
)

type ValidationTool struct {
	Id               int       `orm:"column(ID);size(11);auto;pk"`                           // 合同编号
	T_class          int       `orm:"size(20);default(0)"`                                   // 产品分类 T_class=0 冷链验证 	// 产品id
	Validationnumber string    `orm:"size(256);null"`                                        // 验证工具编号
	T_sn             string    `orm:"size(256);null"`                                        // 设备sn
	T_iccid          string    `orm:"size(256);null"`                                        // sim卡号
	T_imei           string    `orm:"size(256);null"`                                        // 模组imei
	History_iccid    string    `orm:"size(256);type(json);null"`                             // 历史sim卡号
	History_imei     string    `orm:"size(256);type(json);null"`                             // 历史模组
	T_state          int       `orm:"size(2);default(2)"`                                    // 1-已出库 2-待使用  3-维修中 4-已报废
	T_remark         string    `orm:"type(text);null"`                                       // 备注
	T_project        string    `orm:"type(text);null"`                                       // 出库项目
	T_project_log    string    `orm:"type(text);null"`                                       // 出库项目
	T_uuid           string    `orm:"size(256);null"`                                        //用户uuid
	LendUser         string    `orm:"size(256);null"`                                        //借出用户
	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 AddValidationTool struct {
	T_sn             string `json:"T_sn"`
	Validationnumber string `json:"Validationnumber"`
	T_remark         string `json:"T_remark"`
	T_class          int    `json:"T_class"`
}
type LendValidationTool struct {
	T_sn             string `json:"T_sn"`
	Validationnumber string `json:"Validationnumber"`
	T_remark         string `json:"T_remark"`
	T_project        string `json:"T_project"`
	LendUser         string `json:"LendUser"`
}

type ValidationStat struct {
	T_project  string // 出库项目
	LendUser   string // 借出用户
	TotalCount int    // 项目数量
	T_state    int
}

func (t *ValidationTool) TableName() string {
	return "ValidationTool"
}

type ValidationImpl struct {
	orm orm.Ormer
}
type ValidationUseRecordImpl struct {
	orm orm.Ormer
}

func NewValidationTool(orm orm.Ormer) *ValidationImpl {
	return &ValidationImpl{orm: orm}
}
func NewValidationToolUseRecord(orm orm.Ormer) *ValidationUseRecordImpl {
	return &ValidationUseRecordImpl{orm: orm}
}

func init() {
	//注册模型
	orm.RegisterModel(new(ValidationTool))
}

// ADDValidationTool 添加
func (dao *ValidationImpl) ADDValidationTool(r ValidationTool) (id int64, err error) {
	_, err = dao.ReadValidationBytSn(r.T_sn)
	if err != nil {
		if errors.Is(err, orm.ErrNoRows) {
			id, err = dao.orm.Insert(&r)
			if err != nil {
				logs.Error(lib.FuncName(), err)
			}
			return id, err
		}
	}
	return id, err
}
func (dao *ValidationImpl) ReadValidationBytSn(T_sn string) (r ValidationTool, err error) {
	qs := dao.orm.QueryTable(new(ValidationTool))
	var list []ValidationTool
	_, err = qs.Limit(1, 0).Filter("T_sn", T_sn).OrderBy("-CreateTime").All(&list)
	if err != nil {
		logs.Error(lib.FuncName(), err)
	}
	if len(list) == 0 {
		return r, orm.ErrNoRows
	}
	if len(list) > 0 {
		r = list[0]
	}
	return
}
func (dao *ValidationImpl) UpdateValidationTool(TSn string, con map[string]string) (err error) {
	qs := dao.orm.QueryTable(new(ValidationTool))
	params := orm.Params{}
	for key, value := range con {
		params[key] = value
	}
	_, err = qs.Filter("T_sn", TSn).Update(orm2.Params(params))
	if err != nil {
		logs.Error(lib.FuncName(), err)
	}
	return err
}
func (dao *ValidationImpl) UpdateValidationToolById(id string, con map[string]string) (err error) {
	qs := dao.orm.QueryTable(new(ValidationTool))
	params := orm.Params{}
	for key, value := range con {
		params[key] = value
	}
	_, err = qs.Filter("id", id).Update(orm2.Params(params))
	if err != nil {
		logs.Error(lib.FuncName(), err)
	}
	return err
}
func (dao *ValidationImpl) ReadValidationById(id string) (r ValidationTool, err error) {
	qs := dao.orm.QueryTable(new(ValidationTool))
	var list []ValidationTool
	_, err = qs.Limit(1, 0).Filter("id", id).OrderBy("-CreateTime").All(&list)
	if err != nil {
		logs.Error(lib.FuncName(), err)
	}
	if len(list) == 0 {
		return r, orm.ErrNoRows
	}
	if len(list) > 0 {
		r = list[0]
	}
	return
}

func (dao *ValidationImpl) Read_Validation_List(Validationnumber, T_sn, T_iccid, T_imei, T_State, LendUser, T_project, T_class string, page, page_z int) (r []ValidationTool, cnt int64) {
	var offset int
	if page <= 1 {
		offset = 0
	} else {
		offset = (page - 1) * page_z
	}

	// 过滤
	sqlWhere := " WHERE id > 0"
	if len(Validationnumber) > 0 {
		sqlWhere += " AND validationnumber like \"%" + Validationnumber + "%\""
	}
	if len(T_State) > 0 {
		sqlWhere += " AND t_state like \"%" + T_State + "%\""
	}
	if len(T_sn) > 0 {
		sqlWhere += " AND t_sn like \"%" + T_sn + "%\""
	}
	if len(T_iccid) > 0 {
		sqlWhere += " AND t_iccid like \"%" + T_iccid + "%\""
	}
	if len(T_imei) > 0 {
		sqlWhere += " AND t_imei like \"%" + T_imei + "%\""
	}
	if len(LendUser) > 0 {
		sqlWhere += " AND lend_user like \"%" + LendUser + "%\""
	}
	if len(T_project) > 0 {
		sqlWhere += " AND t_project like \"%" + T_project + "%\""
	}
	if len(T_class) > 0 {
		sqlWhere += " AND t_class like \"%" + T_class + "%\""
	}
	var maps_z []orm2.ParamsList
	// 获取总条数
	sql := "SELECT COUNT(*) FROM ValidationTool"
	sql = sql + sqlWhere
	fmt.Println(sql)
	_, err := dao.orm.Raw(sql).ValuesList(&maps_z)
	if err != nil {
		return r, 0
	}
	if len(maps_z) == 0 {
		return r, 0
	}
	sql = "SELECT * FROM ValidationTool"

	sql = sql + sqlWhere

	sql += " ORDER BY create_time DESC"

	sql += " LIMIT " + strconv.Itoa(offset) + "," + strconv.Itoa(page_z)

	fmt.Println(sql)
	var maps []ValidationTool
	_, err = dao.orm.Raw(sql).QueryRows(&maps)
	if err != nil {
		return r, 0
	}
	count, _ := strconv.Atoi(maps_z[0][0].(string))
	return maps, int64(count)
}
func (dao *ValidationImpl) DeleteValidationTool(sn string) (err error) {
	qs := dao.orm.QueryTable(new(ValidationTool))
	_, err = qs.Filter("t_sn", sn).Delete()
	return err
}

func (dao *ValidationImpl) Validation_stat(LendUser, T_project string, page, page_z int) (maps []ValidationStat, count int64) {
	var offset int
	if page <= 1 {
		offset = 0
	} else {
		offset = (page - 1) * page_z
	}

	// 过滤
	sqlWhere := " WHERE id > 0"
	if len(LendUser) > 0 {
		if LendUser == "未出库" {
			sqlWhere += " AND lend_user = ''"
		} else {
			sqlWhere += " AND lend_user like \"%" + LendUser + "%\""
		}
	}
	if len(T_project) > 0 {
		sqlWhere += " AND t_project like \"%" + T_project + "%\""
	}

	sql := "SELECT t_project,lend_user,t_state,COUNT(*) as total_count FROM ValidationTool"

	sql = sql + sqlWhere

	sql += " GROUP BY lend_user,t_project ORDER BY lend_user"

	var maps_z []orm2.ParamsList
	// 获取总条数
	countSql := "SELECT COUNT(*) FROM (" + sql + ") as subquery"
	fmt.Println(sql)
	_, err := dao.orm.Raw(countSql).ValuesList(&maps_z)
	if err != nil {
		return maps, 0
	}
	if len(maps_z) == 0 {
		return maps, 0
	}

	if page_z != 9999 {
		sql += " LIMIT " + strconv.Itoa(offset) + "," + strconv.Itoa(page_z)
	}

	fmt.Println(sql)
	_, err = dao.orm.Raw(sql).QueryRows(&maps)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return maps, 0
	}
	cnt, _ := strconv.Atoi(maps_z[0][0].(string))
	return maps, int64(cnt)
}

func (dao *ValidationImpl) Read_lend_user_List(T_name string, page, page_z int) (lists []ValidationStat, count int64) {

	var offset int
	if page <= 1 {
		offset = 0
	} else {
		offset = (page - 1) * page_z
	}

	o := orm.NewOrm()
	sql := "SELECT lend_user,count(*) as total_count FROM ValidationTool"
	if len(T_name) > 0 {
		sql += " WHERE lend_user like \"%" + T_name + "%\""
	}
	sql += " GROUP BY lend_user ORDER BY lend_user"
	var maps_z []orm2.ParamsList
	// 获取总条数
	countSql := "SELECT COUNT(*) FROM (" + sql + ") as subquery"
	fmt.Println(sql)
	_, err := dao.orm.Raw(countSql).ValuesList(&maps_z)
	if err != nil {
		return lists, 0
	}
	if len(maps_z) == 0 {
		return lists, 0
	}

	if page_z != 9999 {
		sql += " LIMIT " + strconv.Itoa(offset) + "," + strconv.Itoa(page_z)
	}

	_, err = o.Raw(sql).QueryRows(&lists)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return
	}
	cnt, _ := strconv.Atoi(maps_z[0][0].(string))
	return lists, int64(cnt)

}