tmrgo/routers/api/spillage.go

package api

import (
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"strconv"
	"strings"
	"sync"
	"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"`
	Display     string  `xorm:"display"`
	Issplit     int64   `xorm:"issplit"`
	BeginTime   string  `xorm:"begintime"`
}

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"`
	Ptsrate     float64 `xorm:"ptsrate"`
	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"`
	Fttypeid    int64   `xorm:"fttypeid"`
	Times       int64   `xorm:"times"`
	Ptid        int64   `xorm:"ptid"`
	Background  string  `xorm:"background"`
}

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()
	log.Println(time.Now())
	tx := restful.Engine.NewSession()
	defer tx.Close()
	var times int
	var wg sync.WaitGroup
	var tmrlist *[]*tmrStruct
	var feedtempletlist *[]*feedtemplet
	var err error
	var lpplanlist *[]*lpplanList
	var fpdetailWeightList *[]*fpdetailWeight

	wg.Add(1)
	go func() {
		defer wg.Done()
		feedtempletlist, err = getfeedtemplet(pastureid, tx)
		if err != nil {
			appG.Response(http.StatusOK, e.ERROR, false)
			return
		}
	}()
	wg.Wait()
	wg.Add(1)
	go func() {
		defer wg.Done()
		tmrlist, err = gettmr(pastureid, tx)
		if err != nil {
			appG.Response(http.StatusOK, e.ERROR, false)
			return
		}
	}()
	wg.Wait()
	wg.Add(1)
	go func() {
		defer wg.Done()
		times, err = gettimes(pastureid, tx)
		if err != nil {
			appG.Response(http.StatusOK, e.ERROR, false)
			return
		}
	}()
	wg.Wait()
	wg.Add(1)
	go func() {
		defer wg.Done()
		lpplanlist, err = getLpplanlist(pastureid, tx)
		if err != nil {
			appG.Response(http.StatusOK, e.ERROR, false)
			return
		}
	}()
	wg.Wait()
	wg.Add(1)
	go func() {
		defer wg.Done()
		fpdetailWeightList, err = getFpdetail(pastureid, tx)
		if err != nil {
			appG.Response(http.StatusOK, e.ERROR, false)
			return
		}
		for _, fpd := range *fpdetailWeightList {
			for _, lpp := range *lpplanlist {
				if (lpp.Ftid == fpd.Ptid || lpp.Ftid == fpd.Ptsid) && lpp.Times == fpd.Times {
					fpd.Weight = fpd.Weight - (lpp.Maxweight - lpp.Lweight)
				}
			}
		}
	}()

	wg.Wait()
	// 避免车次数量为0造成死循环
	max := false
	for _, tmr := range *tmrlist {
		if tmr.Maxstirfeed > 0 {
			max = true
			break
		}
	}

	for i := 1; i <= times; i++ {
		count, err := getLpplanCount(tx, i, pastureid)
		if err != nil {
			appG.Response(http.StatusOK, e.ERROR, false)
			return
		}
		for _, tem := range *feedtempletlist {
			for _, fpd := range *fpdetailWeightList {
				if tem.Id == fpd.Temid && i == int(fpd.Times) {
					var ftid int64
					if fpd.Ptid != 0 {
						ftid = fpd.Ptid
					} else {
						ftid = fpd.Ptsid
					}
					for fpd.Weight > 0 && max {
						for _, tmr := range *tmrlist {
							if tmr.Maxstirfeed > 0 {
								count++
								ids, err := setting.SnowIds.NextId()
								if err != nil {
									ids = time.Now().UnixNano()
									logging.Info("create SnowIds err", err)
								}
								display := tem.Cname
								if i == 1 {
									display += "第一班"
								} else if i == 2 {
									display += "第二班"
								} else if i == 3 {
									display += "第三班"
								} else if i == 4 {
									display += "第四班"
								}

								lpplan := &lpplanStruct{
									Id:          ids,
									Tmrname:     tmr.Tname,
									Tmrid:       tmr.Id,
									Sort:        count,
									Sel:         1,
									Times:       int64(i),
									Ftname:      tem.Cname,
									Ftid:        ftid,
									Maxweight:   tmr.Maxstirfeed,
									Sumweight:   0,
									Sumcowcount: 0,
									Pastureid:   pastureid,
									Display:     display,
								}
								err = addLpplan(lpplan, tx)
								if err != nil {
									appG.Response(http.StatusOK, e.ERROR, false)
									return
								}
								fpd.Weight = fpd.Weight - tmr.Maxstirfeed
							}
							if fpd.Weight < 0 {
								break
							}
						}
					}
				}
			}
		}
	}
	// wg.Wait()

	err = autogeneration(typeIN, pastureid, tx)
	if err != nil {
		appG.Response(http.StatusOK, e.ERROR, false)
		return
	}
	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 fpdetailWeight struct {
	Times     int64   `xorm:"times"`
	Weight    float64 `xorm:"weight"`
	Pastureid int64   `xorm:"pastureid"`
	Ptid      int64   `xorm:"ptid"`
	Ptsid     int64   `xorm:"ptsid"`
	Cowcount  int64   `xorm:"cowcount"`
	Temid     int64   `xorm:"Temid"`
}

//获取料数量
func getFpdetail(pastureid string, tx *xorm.Session) (*[]*fpdetailWeight, error) {
	fpdetaillist := make([]*fpdetailWeight, 0)

	err := tx.SQL(`	select t1.temid,t1.times,ifnull(t2.weight,0)+sum(t1.weight) as weight ,TRIM(t1.pastureid) pastureid,TRIM(t1.ptid) ptid,TRIM(t1.ptsid ) ptsid ,t1.cowcount  from (SELECT fpd.id,ft.id as temid,fpd.times, ROUND((1-fpd.ptsrate)*fpd.weight,2)-fpd.ptuse weight,TRIM(fpd.pastureid) pastureid,TRIM(fpd.ptid) ptid,TRIM(fpd.ptsid ) ptsid ,fpd.cowcount  FROM fpdetail fpd
	join feedp  fp on    fp.ftid = fpd.ptid and fp.pastureid = fpd.pastureid
	inner join  feedtemplet ft on ft.id = fp.ftid  and ft.pastureid = fpd.pastureid
	WHERE fpd.pastureid = ? AND fpd.ptuse<ROUND((1-fpd.ptsrate)*fpd.weight,2) and fpd.ptid > 0
	group by fpd.id,fpd.times) t1  
left join (	select t1.id,t1.temid as temid, t1.times,sum(t1.weight)  weight,TRIM(t1.pastureid) pastureid,TRIM(t1.ptid) ptid,TRIM(t1.ptsid ) ptsid ,
	t1.cowcount from  (SELECT fpd.id,ft.id as temid, fpd.times,ROUND(fpd.ptsrate*fpd.weight,2)-fpd.ptsuse weight,TRIM(fpd.pastureid) pastureid,TRIM(fpd.ptid) ptid,TRIM(fpd.ptsid ) ptsid ,
	cowcount FROM fpdetail fpd
	join feedp  fp on   fp.ptsfid  = fpd.ptsid and fp.pastureid = fpd.pastureid
	inner join  feedtemplet ft on ft.id = fp.ftid  and ft.pastureid = fpd.pastureid
	WHERE fpd.pastureid = ? AND  fpd.ptsuse< ROUND(fpd.ptsrate*fpd.weight,2)   and fpd.ptsid > 0
	group by fpd.id,fpd.times) t1 
	group by t1.temid,t1.times) t2  on t2.temid = t1.temid and t2.times = t1.times
group by t1.temid,t1.times
	`, pastureid, pastureid).Find(&fpdetaillist)
	if err != nil {
		log.Println("getFpdetail-error", err)
		tx.Rollback()
		return nil, err
	}

	return &fpdetaillist, nil
}

type lpplanList struct {
	Tmrid     int64   `xorm:"tmrid"`
	Times     int64   `xorm:"times"`
	Ftid      int64   `xorm:"ftid"`
	Maxweight float64 `xorm:"maxweight"`
	Lweight   float64 `xorm:"lweight"`
}

func getLpplanlist(patsureid string, tx *xorm.Session) (*[]*lpplanList, error) {

	session := tx.SQL(` select  t1.times,t1.tmrid,t1.ftid,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 = ? `, patsureid, 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, times int, pastureid string) (int64, error) {
	count, err := tx.Table("lpplan").Where("times = ?", times).And("pastureid = ?", pastureid).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
}

type upfpdetail struct {
	insertlweight float64
	fttypeid      int64
	fpdid         int64
}

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.ftid,
	 t1.pastureid,t1.id ,t1.maxweight,ifnull(t2.lweight,0) as lweight,t1.times 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
	}
	fpdetaillist := make([]*fpdetailQueryInfo, 0)
	err = tx.SQL(`SELECT ft.tcolor  background,fpd.ptid,ft.fttypeid,fpd.cowcount,fpd.ccountradio,fpd.id as fpdid,times,tratio,ROUND((1-fpd.ptsrate)*fpd.weight,2)-fpd.ptuse weight,TRIM(fpd.barid) barid,TRIM(fpd.pastureid) pastureid,TRIM(fpd.ptid) ptid,TRIM(fpd.ptsid ) ptsid ,
		(select bname  from bar where pastureid =fpd.pastureid and id = fpd.barid ) barname,cowcount,ccountradio,0 isfill  FROM fpdetail fpd
			join feedp  fp on   fp.ftid = fpd.ptid and fp.pastureid = fpd.pastureid
	inner join  feedtemplet ft on ft.id = fp.ftid  and ft.pastureid = fpd.pastureid
		WHERE  fpd.pastureid = ? AND ptuse<ROUND((1-fpd.ptsrate)*fpd.weight,2)
		group by fpd.id , fpd.times `, pastureid).Find(&fpdetaillist)
	if err != nil {
		log.Println("autogeneration-error-4", err)
		tx.Rollback()
		return err
	}
	log.Println(time.Now(), "333333333333")
	var wg sync.WaitGroup
	for _, lpplan := range lpplanlist {
		lpplandtl1List := make([]*lpplandtl1, 0)
		upfpdetailList := make([]*upfpdetail, 0)
		for _, fpdetail := range fpdetaillist {
			if fpdetail.Ptid == lpplan.Ftid && fpdetail.Times == lpplan.Times {
				var weight float64
				weight = fpdetail.Weight
				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

				exist := false
				for _, up := range upfpdetailList {
					if up.fpdid == fpdetail.Fpdid {
						up.insertlweight += insertlweight
						exist = true
						break
					}
				}

				if !exist {
					upfpdetailList = append(upfpdetailList, &upfpdetail{
						fpdid:         fpdetail.Fpdid,
						insertlweight: insertlweight,
						fttypeid:      fpdetail.Fttypeid,
					})
				}

				fpdetail.Weight = fpdetail.Weight - insertlweight

				exist = false
				for _, lpplandtl1 := range lpplandtl1List {
					if lpplandtl1.Lppid == lpplan.Lppid && lpplan.Pastureid == lpplandtl1.Pastureid && lpplandtl1.Fttype == fpdetail.Fttypeid && lpplandtl1.Fpdid == fpdetail.Fpdid {
						lpplandtl1.Lweight += insertlweight
						lpplandtl1.Lweighthis = insertlweight
						exist = true
						break
					}
				}
				if !exist {
					lpplandtl1List = append(lpplandtl1List, &lpplandtl1{
						Pastureid:   lpplan.Pastureid,
						Lppid:       lpplan.Lppid,
						Barid:       fpdetail.Barid,
						Barname:     fpdetail.Barname,
						Fpdid:       fpdetail.Fpdid,
						Fttype:      fpdetail.Fttypeid,
						Lweight:     insertlweight,
						Sort:        lpplan.Sort,
						Tmrid:       lpplan.Tmrid,
						Tmrname:     lpplan.Tmrname,
						Cowcount:    lpplan.Cowcount,
						Ccountradio: lpplan.Ccountradio,
						Background:  fpdetail.Background,
						Lweighthis:  insertlweight,
					})
				}
			}
		}

		for _, lpplpplandtl1 := range lpplandtl1List {
			wg.Add(1)
			go func(lpplpplandtl1 *lpplandtl1) {
				defer wg.Done()
				_, err = tx.SQL(`insert into lpplandtl1(pastureid,lppid,barid,barname,fpdid,fttype,lweight,sort,tmrid,tmrname,
				cowcount,ccountradio,background,lweighthis)
			value(?,?,?,?,?,?,?,?,?,?,?,?,?,?)
			ON DUPLICATE KEY UPDATE lweight = lweight + lweight, lweighthis=lweighthis`, lpplpplandtl1.Pastureid,
					lpplpplandtl1.Lppid,
					lpplpplandtl1.Barid,
					lpplpplandtl1.Barname,
					lpplpplandtl1.Fpdid,
					lpplpplandtl1.Fttype,
					lpplpplandtl1.Lweight,
					lpplpplandtl1.Sort,
					lpplpplandtl1.Tmrid,
					lpplpplandtl1.Tmrname,
					lpplpplandtl1.Cowcount,
					lpplpplandtl1.Ccountradio,
					lpplpplandtl1.Background,
					lpplpplandtl1.Lweighthis).Execute()
				if err != nil {
					log.Println("autogeneration-error-6", err)
					tx.Rollback()
					return
				}
			}(lpplpplandtl1)
		}
		wg.Wait()

		for _, up := range upfpdetailList {
			wg.Add(1)
			go func(up *upfpdetail) {
				defer wg.Done()
				_, err = tx.SQL(` UPDATE fpdetail SET ptuse=IF(?=1,IF(ptuse+? <0,0,ptuse+?),ptuse),ptsuse=IF(?=0,IF(ptsuse+?<0,0,ptsuse+?),ptsuse)
			WHERE pastureid=? AND id=? `, up.fttypeid, up.insertlweight, up.insertlweight, up.fttypeid, up.insertlweight, up.insertlweight, pastureid, up.fpdid).Execute()
				if err != nil {
					log.Println("autogeneration-error-5", err)
					tx.Rollback()
					return
				}
			}(up)
		}
		wg.Wait()
	}

	if typeIN == 1 {
		_, err = tx.SQL("update lpplan set sel = 1 where pastureid = ?", pastureid).Execute()
		if err != nil {
			log.Println("autogeneration-error-10", err)
			return err
		}
	}

	supplement := tx.Table("fpdetail").Alias("fpd")
	supplement.Select("ft.tcolor  background,fpd.id as fpdid,fpd.barid,ft.id as temid, fpd.times,ROUND(fpd.ptsrate*fpd.weight,2)-fpd.ptsuse weight,TRIM(fpd.pastureid) pastureid,TRIM(fpd.ptid) ptid,TRIM(fpd.ptsid ) ptsid ,cowcount")
	supplement.Join("inner", []string{"feedp", "fp"}, "fp.ptsfid  = fpd.ptsid").And("fp.pastureid = fpd.pastureid")
	supplement.Join("inner", []string{"feedtemplet", "ft"}, "ft.id = fp.ftid").And("ft.pastureid = fpd.pastureid")
	supplement.Where("fpd.pastureid =  ?", pastureid).And("fpd.ptsuse< ROUND(fpd.ptsrate*fpd.weight,2)").And("fpd.ptsid > 0")
	supplement.GroupBy("fpd.id,fpd.times")
	supplementList := make([]*fpdetailQueryInfo, 0)
	err = supplement.Find(&supplementList)
	if err != nil {
		log.Println("autogeneration-error-11", err)
		return err
	}

	if len(supplementList) > 0 {
		for _, lpplan := range lpplanlist {
			if lpplan.Maxweight <= lpplan.Lweight {
				continue
			}
			lppids := []string{strconv.FormatInt(lpplan.Lppid, 10)}
			for _, lpp := range lpplanlist {
				if lpp.Ftid == lpplan.Ftid && lpp.Times == lpplan.Times {
					lppids = append(lppids, strconv.FormatInt(lpp.Lppid, 10))
				}
			}

			lpplandtl1List := make([]*lpplandtl1, 0)
			upfpdetailList := make([]*upfpdetail, 0)
			lpplandtllist := make([]*lpplandtl1, 0)
			err = tx.Table("lpplandtl1").Select("barid").Where(fmt.Sprintf("lppid  in (%s)", strings.Join(lppids, ","))).And("").Find(&lpplandtllist)
			if err != nil {
				log.Println("autogeneration-error-11", err)
				return err
			}

			for _, fpdetail := range supplementList {
				if lpplan.Times != fpdetail.Times {
					continue
				}
				exist := false
				for _, bar := range lpplandtllist {
					if bar.Barid == fpdetail.Barid {
						exist = true
						break
					}
				}
				if !exist {
					continue
				}
				var weight float64
				weight = fpdetail.Weight
				if 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

				exist = false
				for _, up := range upfpdetailList {
					if up.fpdid == fpdetail.Fpdid {
						up.insertlweight += insertlweight
						exist = true
						break
					}
				}
				if !exist {
					upfpdetailList = append(upfpdetailList, &upfpdetail{
						fpdid:         fpdetail.Fpdid,
						insertlweight: insertlweight,
						fttypeid:      0,
					})
				}

				fpdetail.Weight = fpdetail.Weight - insertlweight

				exist = false
				for _, lpplandtl1 := range lpplandtl1List {
					if lpplandtl1.Lppid == lpplan.Lppid && lpplan.Pastureid == lpplandtl1.Pastureid && lpplandtl1.Fttype == fpdetail.Fttypeid && lpplandtl1.Fpdid == fpdetail.Fpdid {
						lpplandtl1.Lweight += insertlweight
						lpplandtl1.Lweighthis = insertlweight
						exist = true
						break
					}
				}
				if !exist {
					lpplandtl1List = append(lpplandtl1List, &lpplandtl1{
						Pastureid:   lpplan.Pastureid,
						Lppid:       lpplan.Lppid,
						Barid:       fpdetail.Barid,
						Barname:     fpdetail.Barname,
						Fpdid:       fpdetail.Fpdid,
						Fttype:      0,
						Lweight:     insertlweight,
						Sort:        lpplan.Sort,
						Tmrid:       lpplan.Tmrid,
						Tmrname:     lpplan.Tmrname,
						Cowcount:    lpplan.Cowcount,
						Ccountradio: lpplan.Ccountradio,
						Background:  fpdetail.Background,
						Lweighthis:  insertlweight,
					})
				}
			}
			for _, lpplpplandtl1 := range lpplandtl1List {
				wg.Add(1)
				go func(lpplpplandtl1 *lpplandtl1) {
					defer wg.Done()
					_, err = tx.SQL(`insert into lpplandtl1(pastureid,lppid,barid,barname,fpdid,fttype,lweight,sort,tmrid,tmrname,
					cowcount,ccountradio,background,lweighthis)
				value(?,?,?,?,?,?,?,?,?,?,?,?,?,?)
				ON DUPLICATE KEY UPDATE lweight = lweight + lweight, lweighthis=lweighthis`, lpplpplandtl1.Pastureid,
						lpplpplandtl1.Lppid,
						lpplpplandtl1.Barid,
						lpplpplandtl1.Barname,
						lpplpplandtl1.Fpdid,
						lpplpplandtl1.Fttype,
						lpplpplandtl1.Lweight,
						lpplpplandtl1.Sort,
						lpplpplandtl1.Tmrid,
						lpplpplandtl1.Tmrname,
						lpplpplandtl1.Cowcount,
						lpplpplandtl1.Ccountradio,
						lpplpplandtl1.Background,
						lpplpplandtl1.Lweighthis).Execute()
					if err != nil {
						log.Println("autogeneration-error-6", err)
						tx.Rollback()
						return
					}
				}(lpplpplandtl1)
			}
			wg.Wait()

			for _, up := range upfpdetailList {
				wg.Add(1)
				go func(up *upfpdetail) {
					defer wg.Done()
					_, err = tx.SQL(` UPDATE fpdetail SET ptuse=IF(?=1,IF(ptuse+? <0,0,ptuse+?),ptuse),ptsuse=IF(?=0,IF(ptsuse+?<0,0,ptsuse+?),ptsuse)
				WHERE pastureid=? AND id=? `, up.fttypeid, up.insertlweight, up.insertlweight, up.fttypeid, up.insertlweight, up.insertlweight, pastureid, up.fpdid).Execute()
					if err != nil {
						log.Println("autogeneration-error-5", err)
						tx.Rollback()
						// return err
						return
					}
				}(up)
			}
			wg.Wait()
		}
	}
	err = tx.Commit()
	if err != nil {
		log.Println("autogeneration-error-11", err)
		return err
	}
	return nil
}

func GetSpillage(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	parammaps := fsion.Get("parammaps")
	pastureid := parammaps.Get("pastureid").ValueInt64()
	times := parammaps.Get("times").ValueInt64()
	ftid := parammaps.Get("ftid").ValueDefaultInt64(0)
	// refresh 0  全部 ， 1 车次信息， 2 班次
	refresh := parammaps.Get("refresh").ValueInt64()
	tx := restful.Engine.NewSession()
	defer tx.Close()

	data := make(map[string]interface{})

	if refresh == 0 || refresh == 2 {
		sqlStr := `SELECT trim(feedp.pastureid) pastureid,barname,trim(barid) barid,trim(ftid) arrid,1 as type,? as times,ft.tname ftname,ft.tcolor  background,0 isfill FROM feedp 
		inner join  feedtemplet ft
	on ft.id = feedp.ftid and  ft.pastureid=?
	WHERE feedp.pastureid = ?  %s
	GROUP BY feedp.ftid
	UNION
	SELECT trim(feedp.pastureid) pastureid,barname,barid,trim(ptsfid) arrid,0 as type,? as times,ft.tname ptsfname ,ft.tcolor  background,1 isfill  FROM feedp
	inner join  feedtemplet ft
	on ft.id = feedp.ptsfid and  ft.pastureid=?
	WHERE feedp.pastureid = ?  %s and  (SELECT inforvalue FROM sysopt WHERE sysopt.pastureid=feedp.pastureid AND sysopt.inforname= 'isEnableSupplyFeed') = 1
	GROUP BY feedp.ptsfid`

		if ftid != 0 {
			sqlStr = fmt.Sprintf(sqlStr, fmt.Sprintf(" and ft.id = %d ", ftid), fmt.Sprintf(" and ft.id = %d ", ftid))
		} else {
			sqlStr = fmt.Sprintf(sqlStr, "", "")
		}

		ftList, err := tx.SQL(sqlStr, times, pastureid, pastureid, times, pastureid, pastureid).Query().List()
		if err != nil {
			log.Println("GetSpillage-error-1: ", err)
			appG.Response(http.StatusOK, e.ERROR, nil)
			return
		}

		ftDetailList, err := tx.SQL(`SELECT TRIM(id) id,times,tratio,ROUND(ptsrate*weight,2)-ptsuse weight,TRIM(barid) barid,TRIM(pastureid) pastureid,TRIM(ptid) ptid,TRIM(ptsid ) ptsid ,
	(select bname  from bar where pastureid =fpdetail.pastureid and id = fpdetail.barid ) barname,0 AS fttype,cowcount,ccountradio,1 isfill  FROM fpdetail
	WHERE fpdetail.pastureid = ?  AND times=? AND  ptsuse< ROUND(ptsrate*weight,2) 
	UNION
	SELECT TRIM(id) id,times,tratio,ROUND((1-ptsrate)*weight,2)-ptuse weight,TRIM(barid) barid,TRIM(pastureid) pastureid,TRIM(ptid) ptid,TRIM(ptsid ) ptsid ,
	(select bname  from bar where pastureid =fpdetail.pastureid and id = fpdetail.barid ) barname,1 AS fttype,cowcount,ccountradio,0 isfill  FROM fpdetail
	WHERE fpdetail.pastureid = ?  AND times=? AND ptuse<ROUND((1-ptsrate)*weight,2)
	ORDER BY  barid`, pastureid, times, pastureid, times).Query().List()
		if err != nil {
			log.Println("GetSpillage-error-2: ", err)
			appG.Response(http.StatusOK, e.ERROR, nil)
			return
		}

		for _, ft := range ftList {
			arrList := make([]map[string]interface{}, 0)
			arrid := ft["arrid"].(string)
			for _, detail := range ftDetailList {
				if _, ok := detail["ptid"]; ok {
					if arrid == detail["ptid"].(string) && ft["isfill"].(int64) == detail["isfill"].(int64) {
						detail["background"] = ft["background"]
						arrList = append(arrList, detail)
					}
				} else if _, ok := detail["ptsid"]; ok {
					if arrid == detail["ptsid"].(string) && ft["isfill"].(int64) == detail["isfill"].(int64) {
						detail["background"] = ft["background"]
						arrList = append(arrList, detail)
					}
				}
			}
			if len(arrList) > 0 {
				ft["arrList"] = arrList
			}
		}

		data["ftlist"] = ftList
	}

	if refresh == 0 || refresh == 1 {
		sqlstr := `SELECT
		ifnull((select eqcode from tmr where pastureid =lpplan.pastureid and id = lpplan.tmrid ),lpplan.tmrname) tmrname,trim(tmrid) tmrid,sort,sel,
		CASE times
		WHEN 1 THEN
		'第一班'
	WHEN 2 THEN
	'第二班'
	WHEN 3 THEN
	'第三班'
	WHEN 4 THEN
	'第四班'
	END timesstr,issplit,
	times,display,begintime,
	(select tname from feedtemplet where pastureid =lpplan.pastureid and id = lpplan.ftid ) ftname,sumcowcount,
	IFNULL(round((SELECT SUM(lpplandtl1.lweight) FROM lpplandtl1 WHERE lpplandtl1.lppid=lpplan.id),2),0) sumweight ,
	ifnull((select maxstirfeed from tmr where pastureid =lpplan.pastureid and id = lpplan.tmrid ),100000) maxweight,
	TRIM(ftid) ftid,
	TRIM(id) id,
	TRIM(id) lppid,
	TRIM(pastureid) pastureid
	
	FROM
	  lpplan
	WHERE pastureid = ?   and times <= (SELECT sysopt.inforvalue  FROM sysopt 
	 WHERE sysopt.pastureid= lpplan.pastureid  AND sysopt.inforname='times')
	`
		arrsql := `SELECT
		trim(lpplandtl1.lppid) lppid,lweight,
		lpplandtl1.lweight weight,lpplandtl1.sort,
		(select bname  from bar where pastureid =lpplandtl1.pastureid and id = lpplandtl1.barid ) barname,
		TRIM(lpplandtl1.fpdid) fpdid,
		TRIM(lpplandtl1.barid) barid,
		TRIM(lpplandtl1.id) id,
		TRIM(lpplandtl1.pastureid) pastureid,
		(SELECT tcolor FROM feedtemplet WHERE pastureid =lpplandtl1.pastureid AND id = IF(lpplandtl1.fttype=1,fpdetail.ptid,fpdetail.ptsid) ) background,
		lpplandtl1.fttype,
		trim(lpplandtl1.tmrid) tmrid,
		ifnull((select eqcode  from tmr where pastureid =lpplandtl1.pastureid and id = lpplandtl1.tmrid ),lpplandtl1.tmrname) tmrname,
		ifnull((select tcolor from tmr where pastureid =lpplandtl1.pastureid and id = lpplandtl1.tmrid ),'#ccc') tbackground,
		fpdetail.ptid,
		fpdetail.ptsid,
		fpdetail.times,
		fpdetail.cowcount,
		fpdetail.ccountradio
		FROM
		  lpplandtl1
		inner join  fpdetail
		on  lpplandtl1.fpdid= fpdetail.id and lpplandtl1.pastureid = fpdetail.pastureid
		WHERE lpplandtl1.pastureid = ?   and lpplandtl1.lweight>0
		`

		var args []interface{}
		args = append(args, pastureid)
		if times != 0 {
			sqlstr += " and times = ? "
			arrsql += " and times = ? "
			args = append(args, times)
		}
		sqlstr += "ORDER BY  times,lpplan.sort"
		session := tx.SQL(sqlstr, args...)
		lppList, err := session.Query().List()
		if err != nil {
			log.Println("GetSpillage-error-3: ", err)
			appG.Response(http.StatusOK, e.ERROR, nil)
			return
		}

		arrsql += " ORDER BY  lpplandtl1.sort"
		arrList, err := tx.SQL(arrsql, args...).QueryString() //获取
		if err != nil {
			log.Println("GetSpillage-error-4: ", err)
			appG.Response(http.StatusOK, e.ERROR, nil)
			return
		}

		for _, query := range lppList {
			list := make([]map[string]string, 0)
			for _, arr := range arrList {
				if query["lppid"].(string) == arr["lppid"] {
					list = append(list, arr)
				}
			}
			query["arrList"] = list
		}
		data["list"] = lppList
		data["total"] = len(lppList)
	}

	appG.Response(http.StatusOK, e.SUCCESS, data)
}

type lpplanTrains struct {
	Id        string `xorm:"id"`
	Sort      int64  `xorm:"sort"`
	Pastureid string `xorm:"pastureid"`
}

//修改车次顺序
func UpdateTrains(c *gin.Context) {
	appG := app.Gin{C: c}
	lppList := make([]*lpplanTrains, 0)

	err := c.Bind(&lppList)
	if err != nil {
		log.Println("UpdateTrains-error-1: ", err)
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, err)
		return
	}

	tx := restful.Engine.NewSession()
	defer tx.Close()
	tx.Begin()
	for _, item := range lppList {
		_, err = tx.Table("lpplan").Where("id = ?", item.Id).And("pastureid = ? ", item.Pastureid).Update(item)
		if err != nil {
			log.Println("UpdateTrains-error-2: ", err)
			appG.Response(http.StatusInternalServerError, e.ERROR, err)
			tx.Rollback()
			return
		}
	}
	err = tx.Commit()
	if err != nil {
		log.Println("UpdateTrains-error-2: ", err)
		appG.Response(http.StatusInternalServerError, e.ERROR, err)
		tx.Rollback()
		return
	}
	appG.Response(http.StatusOK, e.SUCCESS, true)
}

type ReqAddLpplan struct {
	Id        string  `xorm:"id"`
	Tmrid     string  `xorm:"tmrid"`
	TmrName   string  `xorm:"tmrname"`
	Sort      int64   `xorm:"sort"`
	Sel       int64   `xorm:"sel"`
	Times     int64   `xorm:"times"`
	Ftname    string  `xorm:"ftname"`
	Ftid      string  `xorm:"ftid"`
	Maxweight float64 `xorm:"maxweight"`
	// Sumweight   int64   `xorm:"sumweight"`
	Sumcowcount int64  `xorm:"sumcowcount"`
	Pastureid   string `xorm:"pastureid"`
	Display     string `xorm:"display"`
	Issplit     int64  `xorm:"issplit"`
	BeginTime   string `xorm:"begintime"`
}

//添加车次并返回添加的车次信息
func AddLpplan(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	parammaps := fsion.Get("parammaps")
	req := new(ReqAddLpplan)
	err := json.Unmarshal([]byte(parammaps.Json()), req)
	if err != nil {
		log.Println("AddLpplan-error-1: ", err)
		appG.Response(http.StatusInternalServerError, e.ERROR, err)
		return
	}

	if req.Times == 0 {
		log.Println("AddLpplan-error-1: ", err)
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, errors.New(" 班次错误 times = 0  ！！！"))
		return
	}
	tx := restful.Engine.NewSession()
	defer tx.Close()

	ids, err := setting.SnowIds.NextId()
	if err != nil {
		ids = time.Now().UnixNano()
		logging.Info("AddLpplan-error-1: ", err)
	}
	req.Id = strconv.FormatInt(ids, 10)

	count, err := tx.Table("lpplan").Where("pastureid = ?", req.Pastureid).And(" times = ?", req.Times).Count()
	if err != nil {
		log.Println("AddLpplan-error-2: ", err)
		appG.Response(http.StatusInternalServerError, e.ERROR, err)
		return
	}
	req.Sort = count + 1
	_, err = tx.Table("lpplan").Insert(req)
	if err != nil {
		log.Println("AddLpplan-error-3: ", err)
		appG.Response(http.StatusInternalServerError, e.ERROR, err)
		return
	}

	appG.Response(http.StatusOK, e.SUCCESS, req)
}

//修改车次信息，如果修改tmrid信息则删除栏舍信息
func UpdateLpplan(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	parammaps := fsion.Get("parammaps")
	lpplanid := parammaps.Get("id").ValueStr()
	pastureid := parammaps.Get("pastureid").ValueStr()
	tmrid := parammaps.Get("tmrid").ValueStr()
	tmrname := parammaps.Get("tmrname").ValueStr()
	begintime := parammaps.Get("begintime").ValueStr()

	times := parammaps.Get("times").ValueInt64()
	ftid := parammaps.Get("ftid").ValueStr()
	ftname := parammaps.Get("ftname").ValueStr()
	sel := parammaps.Get("sel").ValueInt64()
	issplit := parammaps.Get("issplit").ValueInt64()
	lpplan := new(ReqAddLpplan)
	lpplan.Tmrid = tmrid
	lpplan.TmrName = tmrname
	lpplan.BeginTime = begintime
	lpplan.Sel = sel
	lpplan.Issplit = issplit
	lpplan.Times = times
	lpplan.Ftid = ftid
	lpplan.Ftname = ftname
	tx := restful.Engine.NewSession()
	defer tx.Close()
	tx.Begin()
	lpplanData := new(lpplanStruct)
	_, err := tx.Table("lpplan").Select("tmrid").Where(" id = ? ", lpplanid).And(" pastureid = ? ", pastureid).Get(lpplanData)
	if err != nil {
		log.Println("UpdateLpplan-error-1: ", err)
		appG.Response(http.StatusInternalServerError, e.ERROR, err)
		tx.Rollback()
		return
	}

	_, err = tx.Table("lpplan").Where(" id = ? ", lpplanid).And(" pastureid = ? ", pastureid).
		MustCols("tmrid,tmrname,begintime,sel,issplit,times,ftid,ftname").Update(lpplan)
	if err != nil {
		log.Println("UpdateLpplan-error-1: ", err)
		appG.Response(http.StatusInternalServerError, e.ERROR, err)
		tx.Rollback()
		return
	}

	// if tmrid != lpplan.Tmrid {
	// 	_, err = tx.SQL(`delete from lpplandtl1 where lppid = ? and pastureid = ? `, lpplanid, pastureid).Execute()
	// 	if err != nil {
	// 		log.Println("UpdateLpplan-error-2: ", err)
	// 		appG.Response(http.StatusInternalServerError, e.ERROR, err)
	// 		tx.Rollback()
	// 		return
	// 	}
	// }
	err = tx.Commit()
	if err != nil {
		log.Println("UpdateLpplan-error-3: ", err)
		appG.Response(http.StatusInternalServerError, e.ERROR, err)
		tx.Rollback()
		return
	}

	appG.Response(http.StatusOK, e.SUCCESS, true)
}