gobackend-qingma/service/productivity_service.go

package service

import (
	"errors"
	"fmt"
	"time"

	"gopkg.in/guregu/null.v3"

	"xiaoniaokuaiyan.com/xiaoniao/entity"
	"xiaoniaokuaiyan.com/xiaoniao/util"
)

type ProductivityService struct {
}

func (srv *ProductivityService) Add(pitem *entity.ProductivityInfo) (interface{}, error) {
	if pitem.Id != 0 {
		return nil, errors.New("productivity info already exists")
	}
	strSql, kv := util.GenerateInsertSqlFromStruct("t_producer_info", pitem)
	db := util.GetWriteSqlDB()
	sqlResult, err := db.NamedExec(strSql, kv)
	if err != nil {
		return nil, err
	}
	if pid, err := sqlResult.LastInsertId(); err != nil {
		return nil, err
	} else {
		pitem.Id = int(pid)
		return pitem, nil
	}
}

func (srv *ProductivityService) Update(pitem *entity.ProductivityInfo) (interface{}, error) {
	if pitem.Id <= 0 {
		return nil, errors.New("can not find record")
	}
	strSql, kv := util.GenerateUpdateSqlFromStruct("t_producer_info", pitem, fmt.Sprintf("where id =%d", pitem.Id))
	db := util.GetWriteSqlDB()
	sqlResult, err := db.NamedExec(strSql, kv)
	if err != nil {
		return nil, err
	}
	if ra, err := sqlResult.RowsAffected(); err != nil {
		return nil, err
	} else if ra <= 0 {
		return nil, errors.New("update failed, can not find record ")
	}
	return pitem, nil
}

type producerInfo struct {
	GId       int         `db:"id"`
	GNum      int         `db:"gnum"`
	RemainNum null.Int    `db:"remain_num"`
	PDate     null.String `db:"pdate"`
	TimeRange null.String `db:"time_range"`
}

const QUERY_DAYS = 30 //todo config

//var TIME_RANGES = []string{
//	"08:30-09:30",
//	"09:30-10:30",
//	"10:30-11:30",
//	//	"11:30-12:30",
//	"12:30-13:30",
//	"13:30-14:30",
//	"14:30-15:30",
//	"15:30-16:30",
//}

//20210123 永久修改产能为上午下午
//20210913 改为早8点
//var TIME_RANGES = []string{
//	"08:00-12:00",
//	"13:00-16:00",
//}
//20220120 万万没想到，又改了
var TIME_RANGES = []string{
	"08:00-10:00",
	"10:00-15:00",
}
//20230420 是啊，再一次修改
var TIME_RANGES_KONGFU = map[int][]string{
	100:{"08:00-09:00","09:00-10:00",},
	200:{"08:00-09:00","09:00-10:00","10:00-11:00","11:00-12:00",},
	300:{"08:00-12:00","13:00-15:00",},
}

var TIME_RANGES_ALIAS = []string{
	"上午",
	"下午",
}

type ptValue struct {
	TimeRange string `json:"timeRange"`
	RemainNum int64  `json:"remainNum"`
}
type ptValues []*ptValue

func (srv *ProductivityService) PtList(cityId int, fromDay string, ptType int, kongFuType int ) (interface{}, error) {
	var qDays = QUERY_DAYS
	now, err := time.Parse("2006-01-02", fromDay)
	if err != nil {
		now = time.Now()
		if now.Hour() > 15 {
			now = now.Add(time.Hour * 48)
		} else {
			now = now.Add(time.Hour * 24)
		}
	}

	today := now.Format("2006-01-02")
	var timeRanges []string 
	var bl bool
	timeRanges, bl = TIME_RANGES_KONGFU[kongFuType]
	if !bl {
		timeRanges = TIME_RANGES_KONGFU[100]
	}
	if ptType == 1 {
		timeRanges = TIME_RANGES_ALIAS
	} else if ptType == 2 {
		//timeRanges = []string{
		//	//"9:00-12:00",
		//	//"14:00-17:00",
		//	"09:00-12:00",
		//	"13:00-16:00",
		//}
		
		qDays = 6
	}

	strSql := "select t1.id, t1.gnum, t2.remain_num, t2.pdate, t2.time_range from (select id, num as gnum from t_producer_config where city_id = ? and type = ?) t1 left join (select * from t_producer_info where pdate > ?) t2 on t1.id = t2.global_id;"
	result := []producerInfo{}
	db := util.GetSqlDB()
	err = db.Select(&result, strSql, cityId, ptType, today)
	if err != nil {
		return nil, err
	}
	if len(result) == 0 {
		return nil, errors.New(fmt.Sprintf("1::have not init config for city: %d", cityId))
	}
	plist := []map[string]interface{}{}
	tempKV := map[string]interface{}{}
	invalidDays := map[string]interface{}{}
	if len(result) > 0 {
		for _, pinfo := range result {
			if pinfo.TimeRange.String == "*" {
				invalidDays[pinfo.PDate.String] = struct{}{}
				continue
			}
			tempKV[pinfo.PDate.String+pinfo.TimeRange.String] = map[string]interface{}{
				"pdate":     pinfo.PDate.String,
				"timeRange": pinfo.TimeRange.String,
				"remainNum": pinfo.RemainNum.Int64,
			}
		}
	}
	gnum := result[0].GNum
	for i := 1; i <= qDays; i++ {
		d := time.Duration(int64(time.Hour) * int64(24*i))
		tdate := now.Add(d).Format("2006-01-02")
		if _, ok := invalidDays[tdate]; ok {
			plist = append(plist, map[string]interface{}{
				"pdate":     tdate,
				"timeRange": "*",
				"remainNum": int64(0),
			})
			continue
		}
		for _, tr := range timeRanges {
			if v, ok := tempKV[tdate+tr]; ok {
				plist = append(plist, v.(map[string]interface{}))
				continue
			}
			plist = append(plist, map[string]interface{}{
				"pdate":     tdate,
				"timeRange": tr,
				"remainNum": int64(gnum),
			})
		}
	}
	var resultList = map[string]ptValues{}
	var (
		pdate string
	)
	for _, pi := range plist {
		val := &ptValue{
			TimeRange: pi["timeRange"].(string),
			RemainNum: pi["remainNum"].(int64),
		}
		pdate = pi["pdate"].(string)
		resultList[pdate] = append(resultList[pdate], val)
	}
	return map[string]interface{}{
		"pt_gid":  result[0].GId,
		"pt_list": resultList,
	}, nil
}