tmrgo/routers/api/spillage.go

package api

import (
	"io/ioutil"
	"log"
	"net/http"
	"time"

	"../../pkg/app"
	"../../pkg/e"
	"../../pkg/logging"
	"../../pkg/setting"
	"../../routers/restful"

	"github.com/Anderson-Lu/gofasion/gofasion"
	"github.com/gin-gonic/gin"
	"github.com/xormplus/xorm"
)

type feedtemplet struct {
	Id     int64  `xorm:"id"`
	Ccname string `xorm:"ccname"`
	Cname  string `xorm:"tname"`
}

type tmrStruct struct {
	Id          int64   `xorm:"id"`
	Tname       string  `xorm:"tname"`
	Maxstirfeed float64 `xorm:"maxstirfeed"`
}

type lpplanStruct struct {
	Id          int64   `xorm:"id"`
	Tmrname     string  `xorm:"tmrname"`
	Tmrid       int64   `xorm:"tmrid"`
	Sort        int64   `xorm:"sort"`
	Sel         int64   `xorm:"sel"`
	Times       int64   `xorm:"times"`
	Ftname      string  `xorm:"ftname"`
	Ftid        int64   `xorm:"ftid"`
	Maxweight   float64 `xorm:"maxweight"`
	Sumweight   float64 `xorm:"sumweight"`
	Sumcowcount int64   `xorm:"sumcowcount"`
	Pastureid   string  `xorm:"pastureid"`
}

type sysopt struct {
	Inforvalue int `xorm:"inforvalue"`
}

type lpplanQueryInfo struct {
	Pastureid   int64   `xorm:"pastureid"`
	Lppid       int64   `xorm:"id"`
	Maxweight   float64 `xorm:"maxweight"`
	Lweight     float64 `xorm:"lweight"`
	Lweighthis  float64 `xorm:"lweighthis"`
	Barid       int64   `xorm:"barid"`
	Barname     string  `xorm:"barname"`
	Sort        int64   `xorm:"sort"`
	Tmrid       int64   `xorm:"tmrid"`
	Tmrname     string  `xorm:"tmrname"`
	Cowcount    int64   `xorm:"cowcount"`
	Ccountradio float64 `xorm:"ccountradio"`
	Background  string  `xorm:"background"`
	Times       int64   `xorm:"times"`
	Ftid        int64   `xorm:"ftid"`
}

type fpdetailQueryInfo struct {
	Fpdid       int64   `xorm:"fpdid"`
	Ptsuse      float64 `xorm:"ptsuse"`
	Ptuse       float64 `xorm:"ptuse"`
	Weight      float64 `xorm:"weight"`
	Barid       int64   `xorm:"barid"`
	Barname     string  `xorm:"barname"`
	Cowcount    int64   `xorm:"cowcount"`
	Ccountradio float64 `xorm:"ccountradio"`
}

type lpplandtl1 struct {
	Pastureid   int64   `xorm:"pastureid"`
	Lppid       int64   `xorm:"lppid"`
	Barid       int64   `xorm:"barid"`
	Barname     string  `xorm:"barname"`
	Fpdid       int64   `xorm:"fpdid"`
	Fttype      int64   `xorm:"fttype"`
	Lweight     float64 `xorm:"lweight"`
	Sort        int64   `xorm:"sort"`
	Tmrid       int64   `xorm:"tmrid"`
	Tmrname     string  `xorm:"tmrname"`
	Cowcount    int64   `xorm:"cowcount"`
	Ccountradio float64 `xorm:"ccountradio"`
	Background  string  `xorm:"background"`
	Lweighthis  float64 `xorm:"lweighthis"`
}

//撒料计划 自动生成
func Autogeneration(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	pastureid := fsion.Get("pastureid").ValueStr()
	typeIN := fsion.Get("type").ValueInt64()

	tx := restful.Engine.NewSession()
	feedtempletlist, err := getfeedtemplet(pastureid, tx)
	if err != nil {
		appG.Response(http.StatusOK, e.ERROR, false)
		return
	}

	tmrlist, err := gettmr(pastureid, tx)
	if err != nil {
		appG.Response(http.StatusOK, e.ERROR, false)
		return
	}

	times, err := gettimes(pastureid, tx)
	if err != nil {
		appG.Response(http.StatusOK, e.ERROR, false)
		return
	}

	lpplanlist, err := getLpplanlist(pastureid, tx)
	if err != nil {
		appG.Response(http.StatusOK, e.ERROR, false)
		return
	}
	// var wg sync.WaitGroup
	// wg.Add(len(feedtempletlist))
	for _, tem := range feedtempletlist {

		// go func(tem *feedtemplet) {
		// defer wg.Done()
		count, err := getLpplanCount(tx)
		if err != nil {
			appG.Response(http.StatusOK, e.ERROR, false)
			return
		}
		for _, tmr := range tmrlist {
			for i := 1; i <= times; i++ {
				exist := false
				for _, lpp := range lpplanlist {

					// session.Where("pastureid = ? ", pastureid)
					// session.Where("times = ? ", times)
					// session.Where("tmrid = ? ", tmrid)
					// session.Where("ftid = ? ", ftid)
					if lpp.Tmrid == tmr.Id && lpp.Times == int64(i) && lpp.Ftid == tem.Id {
						exist = true
						break
					}
				}
				// exist, err := getLpplanExist(tmr.Id, tem.Id, i, pastureid, tx)
				// if err != nil {
				// 	appG.Response(http.StatusOK, e.ERROR, false)
				// 	return
				// }
				if !exist {
					ids, err := setting.SnowIds.NextId()
					if err != nil {
						ids = time.Now().UnixNano()
						logging.Info("create SnowIds err", err)
					}
					count++
					lpplan := &lpplanStruct{
						Id:          ids,
						Tmrname:     tmr.Tname,
						Tmrid:       tmr.Id,
						Sort:        count,
						Sel:         1,
						Times:       int64(i),
						Ftname:      tem.Cname,
						Ftid:        tem.Id,
						Maxweight:   tmr.Maxstirfeed,
						Sumweight:   0,
						Sumcowcount: 0,
						Pastureid:   pastureid,
					}
					err = addLpplan(lpplan, tx)
					if err != nil {
						appG.Response(http.StatusOK, e.ERROR, false)
						return
					}
				}
			}
		}
		// }(tem)
	}

	go func(typeIN int64, pastureid string, tx *xorm.Session) {
		err = autogeneration(typeIN, pastureid, tx)
		if err != nil {
			appG.Response(http.StatusOK, e.ERROR, false)
			return
		}
	}(typeIN, pastureid, tx)
	appG.Response(http.StatusOK, e.SUCCESS, true)
}

//查看配方模板
func getfeedtemplet(pastureid string, tx *xorm.Session) ([]*feedtemplet, error) {
	data := make([]*feedtemplet, 0)
	err := tx.Table("feedtemplet").Select("id,ccname,tname").Where("pastureid = ? ", pastureid).Find(&data)
	if err != nil {
		log.Println("getfeedtemplet-error", err)
		return nil, err
	}

	return data, nil
}

//查看tmr设备
func gettmr(pastureid string, tx *xorm.Session) ([]*tmrStruct, error) {
	data := make([]*tmrStruct, 0)
	session := tx.Table("tmr")

	session.Select("TRIM(id) id,tname,maxstirfeed")
	session.Where("pastureid = ? ", pastureid)
	session.Where("enable = 1")
	session.In("tclassid", "1,2,3")

	err := session.Find(&data)
	if err != nil {
		log.Println("gettmr-error", err)
		return nil, err
	}

	return data, nil
}

//判断计划种是否有该车次
func getLpplanExist(tmrid, ftid int64, times int, pastureid string, tx *xorm.Session) (bool, error) {
	session := tx.Table("lpplan")

	session.Where("pastureid = ? ", pastureid)
	session.Where("times = ? ", times)
	session.Where("tmrid = ? ", tmrid)
	session.Where("ftid = ? ", ftid)

	exist, err := session.Exist()
	if err != nil {
		log.Println("getLpplanExist-error", err)
		return false, err
	}
	return exist, nil
}

type lpplanList struct {
	Tmrid int64 `xorm:"tmrid"`
	Times int64 `xorm:"times"`
	Ftid  int64 `xorm:"ftid"`
}

func getLpplanlist(patsureid string, tx *xorm.Session) ([]*lpplanList, error) {
	session := tx.Table("lpplan")
	session.Select("times,tmrid,ftid")
	session.Where("pastureid = ? ", patsureid)
	data := make([]*lpplanList, 0)
	err := session.Find(&data)
	if err != nil {
		log.Println("getLpplanlist-error", err)
		return nil, err
	}
	return data, nil
}

// 添加车次计划
func addLpplan(lpplan *lpplanStruct, tx *xorm.Session) error {
	_, err := tx.Table("lpplan").Insert(lpplan)
	if err != nil {
		log.Println("addLpplan-error", err)
		return err
	}
	return nil
}

//获取车次数量
func getLpplanCount(tx *xorm.Session) (int64, error) {
	count, err := tx.Table("lpplan").Count()
	if err != nil {
		log.Println("getLpplanCount-error", err)
		return 0, err
	}
	return count, err
}

//获取班次信息
func gettimes(pastureid string, tx *xorm.Session) (int, error) {
	session := tx.Table("sysopt")

	session.Where("pastureid = ? ", pastureid)
	session.Where("inforname = 'times' ")

	data := new(sysopt)
	_, err := session.Get(data)
	if err != nil {
		log.Println("gettimes-error", err)
		return 0, err
	}
	return data.Inforvalue, nil
}

func autogeneration(typeIN int64, pastureid string, tx *xorm.Session) error {

	tx.Begin()
	if typeIN == 1 {
		_, err := tx.SQL(`DELETE FROM lpplandtl1 WHERE pastureid = ?`, pastureid).Execute()
		if err != nil {
			log.Println("autogeneration-error-1", err)
			tx.Rollback()
			return err
		}
		_, err = tx.SQL(`update  fpdetail
		 set ptuse = 0,ptsuse=0
		WHERE pastureid = ?`, pastureid).Execute()
		if err != nil {
			log.Println("autogeneration-error-2", err)
			tx.Rollback()
			return err
		}
	}

	lpplansession := tx.SQL(`select  
	t1.sort,t1.tmrid,t1.tmrname,
	 t1.pastureid,t1.id ,t1.maxweight,ifnull(t2.lweight,0) as lweight from lpplan t1 
	left join ( select ifnull(sum(lweight),0) as lweight,lppid  from lpplandtl1  where pastureid =?   GROUP BY lppid) t2 on t1.id = t2.lppid
	where t1.pastureid = ?  and t1.maxweight >  ifnull(t2.lweight,0)  `, pastureid, pastureid)

	lpplanlist := make([]*lpplanQueryInfo, 0)

	err := lpplansession.Find(&lpplanlist)
	if err != nil {
		log.Println("autogeneration-error-3", err)
		tx.Rollback()
		return err
	}

	for _, lpplan := range lpplanlist {
		fpdetailsession := tx.Table("fpdetail").Alias("fpd")
		fpdetailsession.Select("fpd.barid,fpd.barname,fpd.id as fpdid ,fpd.weight as weight,ifnull(fpd.ptuse,0) as ptuse,ifnull(fpd.ptsuse,0) as ptsuse,fpd.barid,fpd.barname,fpd.cowcount,fpd.ccountradio")
		fpdetailsession.Join("inner", []string{"lpplan", "lpp"},
			"lpp.pastureid = fpd.pastureid ").And("lpp.ftid = fpd.ptid").And(
			"lpp.times = fpd.times").And("lpp.id = ?", lpplan.Lppid)
		fpdetailsession.Where("fpd.pastureid = ? ", pastureid)
		fpdetailsession.GroupBy("fpd.id")

		fpdetaillist := make([]*fpdetailQueryInfo, 0)
		err = fpdetailsession.Find(&fpdetaillist)
		if err != nil {
			log.Println("autogeneration-error-4", err)
			tx.Rollback()
			return err
		}

		for _, fpdetail := range fpdetaillist {
			// 	//剩余料
			weight := fpdetail.Weight*(1-fpdetail.Ptsuse) - fpdetail.Ptuse
			if lpplan.Maxweight <= lpplan.Lweight || weight == 0 {
				continue
			}

			var insertlweight float64
			if lpplan.Maxweight-lpplan.Lweight > weight {
				insertlweight = weight
			} else {
				insertlweight = lpplan.Maxweight - lpplan.Lweight
			}
			lpplan.Lweight += insertlweight
			lpplan.Lweighthis = insertlweight
			fpdetail.Ptuse += insertlweight

			// updatefpd := tx.Table("fpdetail").Alias("fpd")
			// updatefpd.Join("INNER", []string{"lpplan", "lpp"}, "lpp.pastureid = fpd.pastureid")
			// updatefpd.Where("lpp.ftid = fpd.ptid").And("lpp.times = fpd.times")
			// _, err = updatefpd.Update(fpdetail)
			_, err = tx.SQL(` update fpdetail fpd  join lpplan lpp  on lpp.pastureid = fpd.pastureid  and  lpp.ftid = fpd.ptid and lpp.times = fpd.times
			 set   fpd.ptuse = ?  where fpd.id = ? `, fpdetail.Ptuse, fpdetail.Fpdid).Execute()
			if err != nil {
				log.Println("autogeneration-error-5", err)
				tx.Rollback()
				return err
			}

			lpplandtlExecute, err := tx.SQL(`select id from lpplandtl1 where pastureid= ?
				and  lppid = ?  and fpdid =? and  fttype = ? `, pastureid, lpplan.Lppid, fpdetail.Fpdid, 1).Exist()
			if err != nil {
				log.Println("autogeneration-error-6", err)
				tx.Rollback()
				return err
			}
			if lpplandtlExecute {
				lpplandtl1query := new(lpplandtl1)
				query := tx.Table("lpplandtl1")
				query.Where("pastureid = ?", pastureid)
				query.Where("lppid = ?", lpplan.Lppid)
				query.Where("fpdid = ?", fpdetail.Fpdid)
				query.Where("fttype = 1")
				_, err = query.Get(lpplandtl1query)
				if err != nil {
					log.Println("autogeneration-error-7", err)
					tx.Rollback()
					return err
				}

				upLpplandtl1 := tx.Table("lpplandtl1")
				data := &lpplandtl1{
					Pastureid:   lpplan.Pastureid,
					Lppid:       lpplan.Lppid,
					Barid:       fpdetail.Barid,
					Barname:     fpdetail.Barname,
					Fpdid:       fpdetail.Fpdid,
					Fttype:      1,
					Lweight:     lpplandtl1query.Lweight + insertlweight,
					Sort:        lpplan.Sort,
					Tmrid:       lpplan.Tmrid,
					Tmrname:     lpplan.Tmrname,
					Cowcount:    fpdetail.Cowcount,
					Ccountradio: fpdetail.Ccountradio,
					// Background:  lpplan.Background,
					Lweighthis: insertlweight,
				}
				upLpplandtl1.Where("pastureid = ?", pastureid)
				upLpplandtl1.Where("lppid = ?", lpplan.Lppid)
				upLpplandtl1.Where("fpdid = ?", fpdetail.Fpdid)
				upLpplandtl1.Where("fttype = 1")
				_, err = upLpplandtl1.Update(data)
				if err != nil {
					log.Println("autogeneration-error-8", err)
					tx.Rollback()
					return err
				}
			} else {
				data := &lpplandtl1{
					Pastureid:   lpplan.Pastureid,
					Lppid:       lpplan.Lppid,
					Barid:       lpplan.Barid,
					Barname:     lpplan.Barname,
					Fpdid:       fpdetail.Fpdid,
					Fttype:      1,
					Lweight:     insertlweight,
					Sort:        lpplan.Sort,
					Tmrid:       lpplan.Tmrid,
					Tmrname:     lpplan.Tmrname,
					Cowcount:    lpplan.Cowcount,
					Ccountradio: lpplan.Ccountradio,
					Background:  lpplan.Background,
					Lweighthis:  insertlweight,
				}

				addLpplandtl1 := tx.Table("lpplandtl1")
				_, err = addLpplandtl1.Insert(data)
				if err != nil {
					log.Println("autogeneration-error-9", err)
					tx.Rollback()
					return err
				}
			}
		}
	}

	err = tx.Commit()
	if err != nil {
		log.Println("autogeneration-error-10", err)
		return err
	}
	return nil
}