package api

import (
	"../../pkg/app"
	"../../pkg/e"
	"../../pkg/logging"
	"../../pkg/setting"
	"../../routers/restful"
	"bytes"
	"database/sql"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/360EntSecGroup-Skylar/excelize"
	"github.com/Anderson-Lu/gofasion/gofasion"
	"github.com/Knetic/govaluate"
	"github.com/gin-gonic/gin"
	"github.com/tealeg/xlsx"
	"github.com/xormplus/xorm"
	"io/ioutil"
	"math"
	"net/http"
	"os"
	"path"
	"regexp"
	"sort"
	"strconv"
	"strings"
	"time"
)

// @Summary   根据SQL执行得到数据集
// @Tags getData
// @Accept json
// @Produce  json
// @Param  sql  query   string true "sql"
// @Success 200 {string} json  "{ "code": 200, "data": {}, "msg": "ok" }"
// @Failure 400 {string} json "{"code":400,  "data":null,"msg":"请求参数错误"}"
// @Failure 404 {string} json "{ "code": 404, "data":null,"msg":"请求参数错误"}"
// @Router /data/getdata  [POST]
func GetData(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	sqlstr := fsion.Get("sql").ValueStr()
	offset := fsion.Get("offset").ValueDefaultInt(0)
	pagecount := fsion.Get("pagecount").ValueDefaultInt(0)
	returntype := fsion.Get("returntype").ValueDefaultStr("map")
	queryData, err := getDataBySql(sqlstr, offset, pagecount, returntype, nil)

	if err != nil {
		appG.Response(http.StatusOK, e.ERROR, err.Error())
	} else {
		appG.Response(http.StatusOK, e.SUCCESS, queryData)
	}
}

func Testpartitions(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	databaseName := fsion.Get("databaseName").ValueStr()                     //获取新数据库名称
	user := fsion.Get("user").ValueStr()                                     //获取新数据库用户
	passWord := fsion.Get("passWord").ValueStr()                             //获取新数据库名称
	host := fsion.Get("host").ValueStr()                                     //获取新数据库名称
	port := fsion.Get("port").ValueStr()                                     //获取新数据库名称
	sqls, err1 := restful.Engine.SQL("SELECT * FROM sql_new ").QueryString() //获取新数据库表
	if sqls == nil || err1 != nil {
		appG.Response(http.StatusOK, e.SUCCESS, "失败："+err1.Error())
	}
	sqlstrs := strings.Split(sqls[0]["sql"], ";") //分割sql
	connecting := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8", user, passWord, host, port, "mysql")
	mydb, err := sql.Open("mysql", connecting) //连接新连接
	if err != nil {
		println("err1", err.Error())
	}
	_, err = mydb.Exec("CREATE DATABASE IF NOT EXISTS `" + databaseName + "`") // 创建数据库
	if err != nil {
		println("err2", err.Error())
	}

	mydb.Close()

	connecting = fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8", user, passWord, host, port, databaseName) //连接新数据库，创建表格
	mydb, err = sql.Open("mysql", connecting)
	if err != nil {
		println("err3", err.Error())
	}
	defer mydb.Close()
	if err == nil {
		mydb.SetMaxOpenConns(10)
		mydb.SetMaxIdleConns(10)
	}
	errmsg := ""
	if err == nil {
		//tx ,_ :=mydb.Begin()

		for _, sqlstr := range sqlstrs {
			//println("sqlstr---",sqlstr)
			if sqlstr == "" {
				continue
			}
			_, err = mydb.Exec(sqlstr)
			if err != nil {
				println("err4", err.Error())
				errmsg = err.Error()
				//err1 :=tx.Rollback()
			}
		}

		//_, err = mydb.Exec("CREATE TABLE `sql_new` (`sql` text DEFAULT NULL) ENGINE=InnoDB DEFAULT CHARSET=latin1;")
		//err =tx.Commit()

	}
	if errmsg == "" {
		appG.Response(http.StatusOK, e.SUCCESS, "成功"+databaseName)
	} else {
		appG.Response(http.StatusOK, e.SUCCESS, "失败"+errmsg)
	}

}

func TestData(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	sqlstr := fsion.Get("sql").ValueStr()
	token := ""
	if tempv, exists := c.Get("jwt_username"); exists {
		token = tempv.(string)
	}
	appG.Response(http.StatusOK, e.SUCCESS, "你录入的名字是："+sqlstr+"；token:"+token)
}

// @Summary   根据APISQL表中SQL执行得到数据集
// @Tags GetDataByName
// @Accept json
// @Produce  json
// @Param  sqlname  body   string true "sqlname"
// @Param  offset  body   int true "offset"
// @Param  pagecount  body   int true "pagecount"
// @Param  returntype  body   string true "returntype"
// @Success 200 {string} json  "{ "code": 200, "data": {}, "msg": "ok" }"
// @Failure 400 {string} json "{"code":400,  "data":null,"msg":"请求参数错误"}"
// @Failure 404 {string} json "{ "code": 404, "data":null,"msg":"请求参数错误"}"
// @Router /data/GetDataByName  [POST]

func GetDataByName(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	sqlnamestr := fsion.Get("name").ValueStr()
	offset := fsion.Get("offset").ValueDefaultInt(0)
	pagecount := fsion.Get("pagecount").ValueDefaultInt(0)
	returntype := fsion.Get("returntype").ValueDefaultStr("map")

	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			logging.Error("tx.Begin 事务启动失败__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()

	sql, p := restful.GetSqlByNameDBT(sqlnamestr, tx)
	//fmt.Println("sql========\n",sqlnamestr,sql)
	if sql != "" {
		s_params := make([]interface{}, 0)
		if fsion.HasKey("parammaps") {
			parammaps := fsion.Get("parammaps")
			if sqlnamestr != "getNoMesList" && sqlnamestr != "getNoMesCount" {
				logging.Info("GetDataByName", c.Keys, c.Request.RemoteAddr, sqlnamestr, parammaps.ValueStr())
			}

			paramslist := strings.Split(p, ",")
			if len(paramslist) > 0 && p != "" {
				for _, value := range paramslist {
					if strings.ToLower(strings.Trim(value, " ")) == "jwt_username" {
						if tempv, exists := c.Get("jwt_username"); exists {
							s_params = append(s_params, tempv.(string))
						} else {
							s_params = append(s_params, "")
						}
					} else {
						s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
					}
				}
			}

		} else if fsion.HasKey("params") {
			params := fsion.Get("params").Array()
			logging.Info("GetDataByName", c.Keys, c.Request.RemoteAddr, sqlnamestr, params)
			for _, v_params := range params {
				s_params = append(s_params, v_params.ValueStr())
			}
		}
		if returntype == "xlsx" {
			var xlsxfile *xlsx.File
			xlsxfile, _ = restful.QueryByXlsx(sql, s_params)
			//c.File("c:/dd.xlsx")
			c.Header("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
			c.Header("Content-Disposition", "attachment; filename="+"Workbook.xlsx")
			c.Header("Content-Transfer-Encoding", "binary")
			_ = xlsxfile.Write(c.Writer)

		} else {

			queryData, err := getDataBySqlT(sql, offset, pagecount, returntype, s_params, tx)
			//fmt.Printf("%v+\n",queryData)
			if err != nil {
				logging.Error("GetDataByName  err: ", err)
				msg := geterrmsg(err.Error())
				appG.Response(http.StatusOK, e.ERROR, msg)
			} else {
				appG.Response(http.StatusOK, e.SUCCESS, queryData)
			}
		}

	} else {
		appG.Response(http.StatusOK, e.SUCCESS, nil)
	}
}
func GetDataBySqlIN(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	sqlnamestr := fsion.Get("name").ValueStr()
	offset := fsion.Get("offset").ValueDefaultInt(0)
	pagecount := fsion.Get("pagecount").ValueDefaultInt(0)
	returntype := fsion.Get("returntype").ValueDefaultStr("map")

	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			logging.Error("tx.Begin 事务启动失败__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()
	sql, p := restful.GetSqlByNameDBT(sqlnamestr, tx)
	//fmt.Println("sql========\n",sqlnamestr,sql)
	if sql != "" {
		s_params := make([]interface{}, 0)
		if fsion.HasKey("parammaps") {
			parammaps := fsion.Get("parammaps")
			if sqlnamestr != "getNoMesList" && sqlnamestr != "getNoMesCount" {
				logging.Info("GetDataByName", c.Keys, c.Request.RemoteAddr, sqlnamestr, parammaps.ValueStr())
			}

			paramslist := strings.Split(p, ",")
			if len(paramslist) > 0 && p != "" {
				for _, value := range paramslist {
					if strings.ToLower(strings.Trim(value, " ")) == "jwt_username" {
						if tempv, exists := c.Get("jwt_username"); exists {
							s_params = append(s_params, tempv.(string))
						} else {
							s_params = append(s_params, "")
						}
					} else {
						s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
					}
				}
			}

		} else if fsion.HasKey("params") {
			params := fsion.Get("params").Array()
			logging.Info("GetDataByName", c.Keys, c.Request.RemoteAddr, sqlnamestr, params)
			for _, v_params := range params {
				s_params = append(s_params, v_params.ValueStr())
			}
		}
		if returntype == "xlsx" {
			var xlsxfile *xlsx.File
			xlsxfile, _ = restful.QueryByXlsx(sql, s_params)
			//c.File("c:/dd.xlsx")
			c.Header("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
			c.Header("Content-Disposition", "attachment; filename="+"Workbook.xlsx")
			c.Header("Content-Transfer-Encoding", "binary")
			_ = xlsxfile.Write(c.Writer)

		} else {

			queryData, err := getDataBySqlT(sql, offset, pagecount, returntype, s_params, tx)
			//fmt.Printf("%v+\n",queryData)
			if err != nil {
				logging.Error("GetDataByName  err: ", err)
				msg := geterrmsg(err.Error())
				appG.Response(http.StatusOK, e.ERROR, msg)
			} else {
				appG.Response(http.StatusOK, e.SUCCESS, queryData)
			}
		}

	} else {
		appG.Response(http.StatusOK, e.SUCCESS, nil)
	}
}

func geterrmsg(errstr string) (msgstr string) {
	var hzRegexp = regexp.MustCompile("^[\u4e00-\u9fa5]$") // 判断是否为汉字
	rs := []rune(errstr)
	if hzRegexp.MatchString(string(rs[0])) {
		msgstr = errstr
		return
	}

	if strings.Contains(errstr, "Duplicate entry") {
		strs := strings.Split(errstr, ` key '`)
		if len(strs) > 1 {
			if len(strs[len(strs)-1]) > 1 {
				errstr = "Duplicate entry :" + strs[len(strs)-1]
			}
		}
	}

	msg, err := restful.Engine.SQL("SELECT msg FROM err_msg where err = ? ", errstr).QueryString()
	if err != nil {
		msgstr = errstr
		return
	}
	if msg == nil || len(msg) == 0 {
		var param []interface{}
		param = append(param, errstr, errstr)
		go func() {
			tx := restful.Engine.NewSession()
			err := tx.Begin()
			defer func() {
				switch {
				case err != nil:
					logging.Error("tx.Begin 事务启动失败__error:", err)
					if tx != nil {
						tx.Rollback()
					}
				default:
					if tx != nil {
						err = tx.Commit()
					}
				}
				if tx != nil {
					tx.Close()
				}
			}()
			_, err = restful.ExecQueryT("insert into err_msg(err,msg) VALUES(?,?) ON DUPLICATE KEY UPDATE err=err", param, tx)
			if err != nil {
				logging.Error("insert into err_msg(err,msg) err", err)
			}

		}()
		msgstr = errstr
	} else {
		msgstr = msg[0]["msg"]
	}
	return
}

// @Summary   根据APISQL表中SQL执行得到数据集
// @Tags GetDataByNameForm
// @Accept json
// @Produce  json
// @Param  sqlname  body   json true "sqlname"
// @Param  offset  query   int true "offset"
// @Param  pagecount  query   int true "pagecount"
// @Param  returntype  query   string true "returntype"
// @Param  s formData   json true "ss"
// @Success 200 {string} json  "{ "code": 200, "data": {}, "msg": "ok" }"
// @Failure 400 {string} json "{"code":400,  "data":null,"msg":"请求参数错误"}"
// @Failure 404 {string} json "{ "code": 404, "data":null,"msg":"请求参数错误"}"
// @Router /data/GetDataByNameForm  [POST]
func GetDataByNameForm(c *gin.Context) {
	appG := app.Gin{C: c}
	//sqlnamestr := c.PostForm("measureNumber")
	//dataByte, _ := ioutil.ReadAll(c.Request.Body)
	//fsion := gofasion.NewFasion(string(dataByte))
	//sqlnamestr := fsion.Get("name").ValueStr()
	//offset := fsion.Get("offset").ValueInt()
	//pagecount := fsion.Get("pagecount").ValueInt()
	//returntype := fsion.Get("returntype").ValueStr()
	//params := fsion.Get("params").Array()

	c.Request.ParseForm()
	params := c.Request.Form
	offset := 0
	pageSize_ := 0
	returntype := params.Get("page")
	if returntype == "" {
		returntype = "0"
	}
	if tempv, exists := c.Get("jwt_username"); exists {
		params.Set("JwtUserName", tempv.(string))
	} else {
		params.Set("JwtUserName", "")
	}
	sqlnamestr := params.Get("name")
	logging.Info("GetDataByNameForm ", c.Keys, sqlnamestr)
	s_params := make([]interface{}, 0)
	if returntype == "1" {
		pageNum, error := strconv.Atoi(params.Get("pageNum"))
		if error != nil {
			appG.ResponseEq(http.StatusOK, e.ERROR, 0, "页码不是整数")
		}
		pageSize, error := strconv.Atoi(params.Get("pageSize"))
		if error != nil {
			appG.ResponseEq(http.StatusOK, e.ERROR, 0, "每页行数不是整数")
		}
		pageSize_ = pageSize
		offset = pageNum
	}

	sql, p := restful.GetSqlByNameDB(sqlnamestr)

	paramslist := strings.Split(p, ",")
	if len(paramslist) > 0 && p != "" {
		for _, value := range paramslist {
			s_params = append(s_params, params.Get(strings.Trim(value, " ")))
		}
	}

	if sql != "" {
		if returntype == "xlsx" {
			var xlsxfile *xlsx.File
			xlsxfile, _ = restful.QueryByXlsx(sql, s_params)
			c.Header("Content-Type", "application/octet-stream")
			c.Header("Content-Disposition", "attachment; filename="+sqlnamestr+".xlsx")
			c.Header("Content-Transfer-Encoding", "binary")
			_ = xlsxfile.Write(c.Writer)
		} else {
			queryData, err := getDataBySql(sql, offset, pageSize_, returntype, s_params)

			if err != nil {
				appG.ResponseEq(http.StatusOK, e.ERROR, 1, err.Error())
			} else {
				appG.ResponseEq(http.StatusOK, e.SUCCESS, 0, queryData)
			}
		}

	} else {
		appG.ResponseEq(http.StatusOK, e.SUCCESS, 0, "后台没有数据接口")
	}
}

// @Summary   递归获取所有
// @Tags menu
// @Accept json
// @Produce  json
// @Param  Ton  query  string true "Ton"
// @Success 200 {string} json "{ "code": 200, "data": {}, "msg": "ok" }"
// @Router /authdata/GetRoleMenus  [GET]
func GetRecuDataByName(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	sqlnamestr := fsion.Get("name").ValueStr()
	parentidname := fsion.Get("idname").ValueStr()
	sql, p := restful.GetSqlByNameDB(sqlnamestr)
	params := make(map[string]interface{})
	s_params := make([]interface{}, 0)
	if fsion.HasKey("params") {

		for _, v_params := range fsion.Get("params").Array() {
			s_params = append(s_params, v_params.ValueStr())
		}
		params["params"] = s_params

	} else {
		jparams := fsion.Get("parammaps")
		paramslist := strings.Split(p, ",")
		if len(paramslist) > 0 && p != "" {
			for _, value := range paramslist {
				if strings.ToLower(strings.Trim(value, " ")) == "jwt_username" {
					if tempv, exists := c.Get("jwt_username"); exists {
						params[value] = tempv.(string)
					} else {
						params[value] = ""
					}
				} else {
					params[value] = jparams.Get(strings.Trim(value, " ")).ValueStr()
				}
			}

		}
	}
	queryData, err := GetRecuData_BySql(sql, p, parentidname, params, fsion.HasKey("params"))
	logging.Info("sqlname parammaps", c.Keys, c.Request.RemoteAddr, sqlnamestr, params)
	if err != nil {
		appG.Response(http.StatusOK, e.ERROR, err.Error())
	}
	appG.Response(http.StatusOK, e.SUCCESS, queryData)
}

// @Summary   根据APISQL表中SQL执行得到数据集
// @Tags GetDataByNames
// @Accept json
// @Produce  json
// @RequestBody  sqlname  query   string true "sqlname"
// @Param  offset  query   int true "offset"
// @Param  pagecount  query   int true "pagecount"
// @Param  returntype  query   string true "returntype"
// @Success 200 {string} json  "{ "code": 200, "data": {}, "msg": "ok" }"
// @Failure 400 {string} json "{"code":400,  "data":null,"msg":"请求参数错误"}"
// @Failure 404 {string} json "{ "code": 404, "data":null,"msg":"请求参数错误"}"
// @Router /data/GetDataByNames  [POST]
func GetDataByNames(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	sqlParams := fsion.Array()
	queryData := make(map[string]interface{})
	for _, v := range sqlParams {
		fsion2 := gofasion.NewFasion(v.Json())
		logging.Info("GetDataByNames", c.Keys, fsion2.Get("name").ValueStr(), c.Request.RemoteAddr)
		sql, p := restful.GetSqlByNameDB(fsion2.Get("name").ValueStr())
		if sql == "" {
			errorm := make(map[string]interface{})
			errorm["code"] = e.ERROR
			errorm["message"] = "sql没找到"
			queryData[fsion2.Get("name").ValueStr()] = errorm
			continue
		} else if sql != "" {
			offset := fsion2.Get("offset").ValueInt()
			pagecount := fsion2.Get("pagecount").ValueInt()
			returntype := fsion2.Get("returntype").ValueStr()
			s_params := make([]interface{}, 0)
			if fsion2.HasKey("parammaps") {
				parammaps := fsion2.Get("parammaps")
				paramslist := strings.Split(p, ",")
				if len(paramslist) > 0 && p != "" {
					for _, value := range paramslist {
						if strings.ToLower(strings.Trim(value, " ")) == "jwt_username" {
							if tempv, exists := c.Get("jwt_username"); exists {
								s_params = append(s_params, tempv.(string))
							} else {
								s_params = append(s_params, "")
							}
						} else {
							s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
						}
					}
				}
			} else if fsion2.HasKey("params") {
				params := fsion2.Get("params").Array()
				for _, v_params := range params {
					s_params = append(s_params, v_params.ValueStr())
				}
			}

			queryData1, err := getDataBySql(sql, offset, pagecount, returntype, s_params)

			if err != nil {
				errorm := make(map[string]interface{})
				errorm["code"] = e.ERROR
				errorm["message"] = err.Error()
				queryData[fsion2.Get("name").ValueStr()] = errorm
				logging.Error("GetDataByNames  err: ", err)
				continue
			} else {
				queryData[fsion2.Get("name").ValueStr()] = queryData1
			}
		}
	}
	appG.Response(http.StatusOK, e.SUCCESS, queryData)
}

// @Summary   根据APISQL表中SQL执行得到数据集
// @Tags PostDataByNameForm
// @Accept json
// @Produce  json
// @Param  sqlname  query   string true "sqlname"
// @Param  offset  query   int true "offset"
// @Param  pagecount  query   int true "pagecount"
// @Param  returntype  query   string true "returntype"
// @Success 200 {string} json  "{ "code": 200, "data": {}, "msg": "ok" }"
// @Failure 400 {string} json "{"code":400,  "data":null,"msg":"请求参数错误朱红彬彬"}"
// @Failure 404 {string} json "{ "code": 404, "data":null,"msg":"请求参数错误"}"
// @Router /data/PostDataByNameForm  [POST]
func PostDataByNameForm(c *gin.Context) {
	appG := app.Gin{C: c}

	c.Request.ParseForm()
	params := c.Request.Form
	sqlnamestr := params.Get("name")
	logging.Info("PostDataByNameForm ", c.Keys, sqlnamestr)

	s_params := make([]interface{}, 0)

	sql, p := restful.GetSqlByNameDB(sqlnamestr)
	paramslist := strings.Split(p, ",")

	if len(paramslist) > 0 {
		for _, value := range paramslist {
			s_params = append(s_params, params.Get(strings.Trim(value, " ")))
		}
	}

	if sql != "" {
		queryData, err := execDataBySql(sql, s_params)

		if err != nil {
			appG.ResponseEq(http.StatusOK, e.ERROR, 1, err.Error())
		} else {
			appG.ResponseEq(http.StatusOK, e.SUCCESS, 0, queryData)
		}
	} else {
		appG.ResponseEq(http.StatusOK, e.SUCCESS, 0, "后台没有数据接口")
	}
}

func GetReportform(c *gin.Context) {

	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)

	fsion := gofasion.NewFasion(string(dataByte))
	sqlnamestr := fsion.Get("name").ValueStr()
	parammaps := fsion.Get("parammaps")
	logging.Info("GetReportform ", c.Keys, sqlnamestr, parammaps)
	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			fmt.Println("__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()

	queryData, _ := praseReportform(sqlnamestr, parammaps, tx)

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

func praseReportform(sqlnamestr string, parammaps *gofasion.Fasion, tx *xorm.Session) (queryData map[string]interface{}, err error) {

	sql, p := restful.GetSqlByNameDBT(sqlnamestr, tx)
	s_params := make([]interface{}, 0)
	if sql != "" {
		paramslist := strings.Split(p, ",")
		if len(paramslist) > 0 && p != "" {
			for _, value := range paramslist {
				s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
			}
		}
	}
	queryList, _ := tx.SQL(sql, s_params...).Query().List()
	temstr := ""
	switch sqlnamestr {
	case "getAccuracyAllHL", "getAccuracyAllQX", "getAccuracyAllJH", "getFeedEffMR", "getFeedEffHL", "getHomepageCB", "getAccuraa", "judgenurFTReportDetail":
		temstr = sqlnamestr
	default:
		temstr = sqlnamestr[:10]
	}

	switch temstr {
	case "getAccurac", "getFeedEff":
		queryData, err = getAccuracy(queryList) // 不定参数
	case "getprocess":
		//queryData, err = getAccuracyV3v1(queryList)
		queryData, err = getAccuracyV3(queryList)
	case "getHomepro":
		queryData, err = getAccuracyV3(queryList)
	case "getAccuracyAllHL", "getAccuracyAllQX", "getAccuracyAllJH", "getFeedEffMR", "getFeedEffHL", "getHomepageCB", "getAccuraa":
		queryData, err = getAccuracyV2(queryList) //固定维度 日期
	case "getMateria":
		queryData, err = getAccuracyV4(queryList)
	case "getPriceAn":
		queryData, err = getAccuracyV5(queryList)
	case "getJT1Accu":
		queryData, err = getAccuracyV6(queryList) //固定维度 牧场
	case "judgenurFT":
		queryData, err = getAccuracyV7(queryList)
	case "judgenurFTReportDetail":
		queryData, err = getAccuracyV8(queryList)
	default:
		queryData, err = nil, nil
	}
	return
	//switch sqlnamestr {
	//case "getAccuracyAllFT", "getAccuracyAllNQ", "getAccuracyAllCC", "getAccuracyAllLS","getFeedEffSL","getFeedEffZH","getFeedEffCB","getFeedEffCBLS","getFeedEffCBFT":
	//	queryData, err = getAccuracy(queryList)
	//case "getprocessAnalysisTB","getHomeprocessAnalysis":
	//	queryData, err = getAccuracyV3(queryList)
	//case "getAccuracyAllHL", "getAccuracyAllQX","getAccuracyAllJH","getFeedEffMR","getFeedEffHL","getHomepageCB":
	//	queryData, err = getAccuracyV2(queryList)
	//default:
	//	queryData, err = nil, nil
	//}
	//return
}
func getAccuracyV8(queryList []map[string]interface{}) (map[string]interface{}, error) {
	queryData := make(map[string]interface{})
	chartData := make(map[string]interface{})
	//list := make(map[string]interface{})
	data := []interface{}{}

	for i := 0; i < len(queryList); i++ {

		dry, _ := strconv.ParseFloat(queryList[i]["dry"].(string), 64)
		Hrate, _ := strconv.ParseFloat(queryList[i]["Hrate"].(string), 64)
		Srate, _ := strconv.ParseFloat(queryList[i]["Srate"].(string), 64)
		trans35f, _ := strconv.ParseFloat(queryList[i]["trans35f"].(string), 64)
		jcrate, _ := strconv.ParseFloat(queryList[i]["jcrate"].(string), 64)
		uprice, _ := strconv.ParseFloat(queryList[i]["uprice"].(string), 64)
		kprice, _ := strconv.ParseFloat(queryList[i]["dry"].(string), 64)

		adf, _ := strconv.ParseFloat(queryList[i]["adf"].(string), 64)
		ca, _ := strconv.ParseFloat(queryList[i]["ca"].(string), 64)
		cdry, _ := strconv.ParseFloat(queryList[i]["cdry"].(string), 64)
		cad, _ := strconv.ParseFloat(queryList[i]["cad"].(string), 64)
		cndf, _ := strconv.ParseFloat(queryList[i]["cndf"].(string), 64)
		cp, _ := strconv.ParseFloat(queryList[i]["cp"].(string), 64)
		cpd, _ := strconv.ParseFloat(queryList[i]["cpd"].(string), 64)
		fat, _ := strconv.ParseFloat(queryList[i]["fat"].(string), 64)
		ndf, _ := strconv.ParseFloat(queryList[i]["ndf"].(string), 64)
		nm, _ := strconv.ParseFloat(queryList[i]["nm"].(string), 64)
		nmd, _ := strconv.ParseFloat(queryList[i]["nmd"].(string), 64)
		nuint, _ := strconv.ParseFloat(queryList[i]["nuint"].(string), 64)
		p, _ := strconv.ParseFloat(queryList[i]["p"].(string), 64)
		pd, _ := strconv.ParseFloat(queryList[i]["pd"].(string), 64)
		starch, _ := strconv.ParseFloat(queryList[i]["starch"].(string), 64)
		trans4f, _ := strconv.ParseFloat(queryList[i]["trans4f"].(string), 64)

		list := make(map[string]interface{})
		list["ft"] = dry
		list["index"] = "干物质（kg）"
		list["tmr"] = TransFloat(dry * Hrate)
		list["cyl"] = TransFloat(dry * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = jcrate
		list["index"] = "粗精比（%）"
		list["tmr"] = TransFloat(jcrate * Hrate)
		list["cyl"] = TransFloat(jcrate * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = uprice
		list["index"] = "日粮成本（元）"

		list["tmr"] = TransFloat(uprice * Hrate)
		list["cyl"] = TransFloat(uprice * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = kprice
		list["index"] = "公斤奶成本"

		list["tmr"] = TransFloat(kprice * Hrate)
		list["cyl"] = TransFloat(kprice * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = cdry
		list["index"] = "粗料中的干物质"

		list["tmr"] = TransFloat(cdry * Hrate)
		list["cyl"] = TransFloat(cdry * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = nm
		list["index"] = " 产奶净能（MJ）"

		list["tmr"] = TransFloat(nm * Hrate)
		list["cyl"] = TransFloat(nm * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = nuint
		list["index"] = "奶牛能量单位(NND)"

		list["tmr"] = TransFloat(nuint * Hrate)
		list["cyl"] = TransFloat(nuint * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = cp
		list["index"] = "粗蛋白（g）"

		list["tmr"] = TransFloat(cp * Hrate)
		list["cyl"] = TransFloat(cp * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = cpd
		list["index"] = "粗蛋白（%DM）"

		list["tmr"] = TransFloat(cpd * Hrate)
		list["cyl"] = TransFloat(cpd * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = ca
		list["index"] = "钙（g）"

		list["tmr"] = TransFloat(ca * Hrate)
		list["cyl"] = TransFloat(ca * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = p
		list["index"] = "磷（g）"

		list["tmr"] = TransFloat(p * Hrate)
		list["cyl"] = TransFloat(p * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = nmd
		list["index"] = "产奶净能（Mcal/DM）"

		list["tmr"] = TransFloat(nmd * Hrate)
		list["cyl"] = TransFloat(nmd * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = fat
		list["index"] = "脂肪"
		list["tmr"] = TransFloat(fat * Hrate)
		list["cyl"] = TransFloat(fat * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = starch
		list["index"] = "淀粉"
		list["tmr"] = TransFloat(starch * Hrate)
		list["cyl"] = TransFloat(starch * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = ndf
		list["index"] = "NDF（%DM）"
		list["tmr"] = TransFloat(ndf * Hrate)
		list["cyl"] = TransFloat(ndf * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = cndf
		list["index"] = "粗料中的NDF（%DM）"
		list["tmr"] = TransFloat(cndf * Hrate)
		list["cyl"] = TransFloat(cndf * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = adf
		list["index"] = " ADF（%DM）"
		list["tmr"] = TransFloat(adf * Hrate)
		list["cyl"] = TransFloat(adf * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = cad
		list["index"] = "钙（%DM）"
		list["tmr"] = TransFloat(cad * Hrate)
		list["cyl"] = TransFloat(cad * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = pd
		list["index"] = " 磷（%DM）"
		list["tmr"] = TransFloat(pd * Hrate)
		list["cyl"] = TransFloat(pd * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = trans35f
		list["index"] = "(3.5)FCR(kg/DM)"
		list["tmr"] = TransFloat(trans35f * Hrate)
		list["cyl"] = TransFloat(trans35f * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["ft"] = trans4f
		list["index"] = "(4.0)FCR(kg/DM)"
		list["tmr"] = TransFloat(trans4f * Hrate)
		list["cyl"] = TransFloat(trans4f * Srate)
		data = append(data, list)

	}

	chartData["data"] = data

	queryData["list"] = chartData
	queryData["code"] = 0
	queryData["message"] = "ok"
	queryData["data"] = queryList
	return queryData, nil
}

func TransFloat(flo float64)(float64){
	hf,_ :=strconv.ParseFloat(fmt.Sprintf("%.3f", float64(flo)), 64)
	return  hf
}
func getAccuracyV7(queryList []map[string]interface{}) (map[string]interface{}, error) {
	queryData := make(map[string]interface{})
	chartData := make(map[string]interface{})
	//list := make(map[string]interface{})
	data := []interface{}{}

	for i := 0; i < len(queryList); i++ {

		dry, _ := strconv.ParseFloat(queryList[i]["dry"].(string), 64)
		Hrate, _ := strconv.ParseFloat(queryList[i]["Hrate"].(string), 64)
		Srate, _ := strconv.ParseFloat(queryList[i]["Srate"].(string), 64)
		trans35f, _ := strconv.ParseFloat(queryList[i]["trans35f"].(string), 64)
		jcrate, _ := strconv.ParseFloat(queryList[i]["jcrate"].(string), 64)
		uprice, _ := strconv.ParseFloat(queryList[i]["uprice"].(string), 64)
		kprice, _ := strconv.ParseFloat(queryList[i]["dry"].(string), 64)

		list := make(map[string]interface{})
		list["tname"] = queryList[i]["tname"]
		list["ftid"] = queryList[i]["ftid"]
		list["ft"] = dry
		list["index"] = "干物质（kg）"
		list["tmr"] = TransFloat(dry * Hrate)
		list["cyl"] = TransFloat(dry * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["tname"] = queryList[i]["tname"]
		list["ftid"] = queryList[i]["ftid"]
		list["ft"] = trans35f
		list["index"] = "(3.5)FCR(kg/DM)"
		list["tmr"] = TransFloat(trans35f * Hrate)
		list["cyl"] = TransFloat(trans35f * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["tname"] = queryList[i]["tname"]
		list["ftid"] = queryList[i]["ftid"]
		list["ft"] = jcrate
		list["index"] = "粗精比（%）"
		list["tmr"] = TransFloat(jcrate * Hrate)
		list["cyl"] = TransFloat(jcrate * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["tname"] = queryList[i]["tname"]
		list["ftid"] = queryList[i]["ftid"]
		list["ft"] = uprice
		list["index"] = "日粮成本（元）"
		list["tmr"] = TransFloat(uprice * Hrate)
		list["cyl"] = TransFloat(uprice * Srate)
		data = append(data, list)

		list = make(map[string]interface{})
		list["tname"] = queryList[i]["tname"]
		list["ftid"] = queryList[i]["ftid"]
		list["ft"] = kprice
		list["index"] = "公斤奶成本"
		list["tmr"] = TransFloat(kprice * Hrate)
		list["cyl"] = TransFloat(kprice * Srate)
		data = append(data, list)

	}

	chartData["data"] = data

	queryData["list"] = chartData
	queryData["code"] = 0
	queryData["message"] = "ok"
	queryData["data"] = queryList
	return queryData, nil
}
func getAccuracyV6(queryList []map[string]interface{}) (map[string]interface{}, error) {
	queryData := make(map[string]interface{})
	chartData := make(map[string]interface{})
	data := []interface{}{}
	data1 := []interface{}{}
	data2 := []interface{}{}
	data3 := []interface{}{}
	data4 := []interface{}{}

	for i := 0; i < len(queryList); i++ {
		data = append(data, queryList[i]["牧场"])
		data1 = append(data1, queryList[i]["field1"])
		data2 = append(data2, queryList[i]["field2"])
		data3 = append(data3, queryList[i]["field3"])
		data4 = append(data4, queryList[i]["field4"])
	}

	chartData["data1"] = data
	chartData["data2"] = data1
	chartData["data3"] = data2
	chartData["data4"] = data3
	chartData["data5"] = data4

	queryData["list"] = chartData
	queryData["code"] = 0
	queryData["message"] = "ok"
	queryData["data"] = queryList
	return queryData, nil
}

func getAccuracyV5(queryList []map[string]interface{}) (map[string]interface{}, error) {
	queryData := make(map[string]interface{})
	chartData := make(map[string]interface{})
	datamap1 := make(map[string]interface{})
	datamap2 := make(map[string]interface{})
	temsmap := make(map[interface{}]interface{})
	mapc2 := make(map[interface{}]interface{})
	data3 := []interface{}{}
	datamap2child := make(map[string]interface{})
	data2 := []interface{}{}
	data1 := []interface{}{}

	var dtem interface{}
	var temstr interface{}
	var typestr interface{}

	count2 := 0

	a := 0

	for i := 0; i < len(queryList); i++ {
		if i == 0 {
			temstr = queryList[i]["fname"]
			typestr = queryList[i]["typestr"]
		}
		if temstr == queryList[i]["fname"] {
			temsmap[queryList[i]["feedname"]] = 1
		}
		if _, ok := mapc2[queryList[i]["feedname"]]; !ok {
			mapc2[queryList[i]["feedname"]] = count2
			mapc2[count2] = queryList[i]["feedname"]
			count2++
		}
	}
	//for i := 0; i<count2 ; i++ {
	//	reslist := make([]map[string]interface{},1)
	//	res := make(map[string]interface{})
	//	res["fname"] = "分界线"
	//	res["feedname"] = mapc2[i]
	//	res["饲料名称"] = mapc2[i]
	//	reslist[0] = res
	//	queryList = append(reslist,queryList...)
	//}

	for i := 0; i < count2; i++ { // 将所有饲料种类新增为第一行 测试
		if _, ok := temsmap[mapc2[i]]; !ok {
			reslist := make([]map[string]interface{}, 1)
			res := make(map[string]interface{})
			res["fname"] = temstr
			res["feedname"] = mapc2[i]
			res["饲料名称"] = mapc2[i]
			res["typestr"] = typestr
			reslist[0] = res
			queryList = append(reslist, queryList...)
		}
	}

	for i := 0; i < len(queryList); i++ {
		a = mapc2[queryList[i]["feedname"]].(int) * 2
		if i == 0 {
			datamap2["label"] = "饲料名称"
			switch queryList[i]["typestr"].(type) {
			case string:
				datamap2child["label"] = queryList[i]["typestr"].(string) + "/饲料参数"
			default:
				datamap2child["label"] = "/饲料参数"
			}
			datamap2child["prop"] = "A"
			data3 = append(data3, datamap2child)
			datamap2["children"] = data3
			data2 = append(data2, datamap2)
			data3 = []interface{}{}
			datamap2child = make(map[string]interface{})
			datamap2 = make(map[string]interface{})

			dtem = queryList[i]["fname"]
		}
		if dtem != queryList[i]["fname"] && i != 0 {
			data1 = append(data1, datamap1)
			dtem = queryList[i]["fname"]
			datamap1 = make(map[string]interface{})
		}
		if queryList[i]["fname"] == temstr {
			datamap2["label"] = queryList[i]["feedname"]
			datamap2child["label"] = "理论"
			datamap2child["prop"] = "a" + strconv.Itoa(a)
			data3 = append(data3, datamap2child)
			datamap2child = make(map[string]interface{})

			datamap2child["label"] = "实际"
			datamap2child["prop"] = "a" + strconv.Itoa(a+1)
			data3 = append(data3, datamap2child)
			datamap2child = make(map[string]interface{})

			datamap2["children"] = data3
			data2 = append(data2, datamap2)
			data3 = []interface{}{}
			datamap2 = make(map[string]interface{})
			datamap2child = make(map[string]interface{})

		}
		datamap1["A"] = queryList[i]["fname"]
		datamap1["a"+strconv.Itoa(a)] = queryList[i]["lweight"]
		datamap1["a"+strconv.Itoa(a+1)] = queryList[i]["actualweightminus"]
		datamap2["label"] = queryList[i]["饲料名称"]
		a = a + 2

	}

	data1 = append(data1, datamap1)

	chartData["data1"] = data1
	chartData["data2"] = data2

	queryData["list"] = chartData

	queryData["code"] = 0
	queryData["message"] = "ok"
	queryData["data"] = queryList
	return queryData, nil
}
func getAccuracyV4(queryList []map[string]interface{}) (map[string]interface{}, error) {
	queryData := make(map[string]interface{})
	chartData := make(map[string]interface{})
	datamap1 := make(map[string]interface{})
	datamap2 := make(map[string]interface{})
	temsmap := make(map[interface{}]interface{})
	mapc2 := make(map[interface{}]interface{})
	mapc3 := make(map[interface{}]interface{})

	data3 := []interface{}{}
	datamap2child := make(map[string]interface{})
	data2 := []interface{}{}
	data1 := []interface{}{}
	a := 0

	var dtem interface{}

	count2 := 0

	var tem interface{}
	var temstr interface{}
	var typestr interface{}

	for i := 0; i < len(queryList); i++ { // 获取所有饲料种类
		if i == 0 {
			temstr = queryList[i]["fname"]
			typestr = queryList[i]["typestr"]
		}
		if temstr == queryList[i]["fname"] {
			temsmap[queryList[i]["feedname"]] = 1
		}

		if _, ok := mapc2[queryList[i]["feedname"]]; !ok {
			mapc2[queryList[i]["feedname"]] = count2 // 编号
			mapc2[count2] = queryList[i]["feedname"]
			count2++
		}
	}
	for i := 0; i < count2; i++ { // 将所有饲料种类新增为第一行 测试
		if _, ok := temsmap[mapc2[i]]; !ok {
			reslist := make([]map[string]interface{}, 1)
			res := make(map[string]interface{})
			res["fname"] = temstr
			res["feedname"] = mapc2[i]
			res["饲料名称"] = mapc2[i]
			res["typestr"] = typestr
			reslist[0] = res
			queryList = append(reslist, queryList...)
		}
	}

	//for i := 0; i<count2 ; i++ {
	//	reslist := make([]map[string]interface{},1)
	//	res := make(map[string]interface{})
	//	res["fname"] = "分界线"
	//	res["feedname"] = mapc2[i]
	//	res["饲料名称"] = mapc2[i]
	//	res["typestr"] =typestr
	//	reslist[0] = res
	//	queryList = append(reslist,queryList...)
	//}

	for i := 0; i < len(queryList); i++ {
		if i == 0 {
			tem = queryList[i]["fname"]
		}

		if queryList[i]["fname"] == tem {
			mapc3[queryList[i]["feedname"]] = i
		}

	}

	for i := 0; i < len(queryList); i++ {
		a = mapc2[queryList[i]["feedname"]].(int) * 4
		if i == 0 {
			datamap2["label"] = "饲料名称"
			switch queryList[i]["typestr"].(type) {
			case string:
				datamap2child["label"] = queryList[i]["typestr"].(string) + "/饲料参数"
			default:
				datamap2child["label"] = "/饲料参数"
			}
			datamap2child["prop"] = "A"
			data3 = append(data3, datamap2child)
			datamap2["children"] = data3
			data2 = append(data2, datamap2)
			data3 = []interface{}{}
			datamap2child = make(map[string]interface{})
			datamap2 = make(map[string]interface{})

			dtem = queryList[i]["fname"]
		}

		if dtem != queryList[i]["fname"] && i != 0 {
			data1 = append(data1, datamap1)
			dtem = queryList[i]["fname"]
			datamap1 = make(map[string]interface{})
		}

		if queryList[i]["fname"] == temstr {
			datamap2["label"] = queryList[i]["feedname"]
			datamap2child["label"] = "理论"
			datamap2child["prop"] = "a" + strconv.Itoa(a)
			data3 = append(data3, datamap2child)
			datamap2child = make(map[string]interface{})

			datamap2child["label"] = "实际"
			datamap2child["prop"] = "a" + strconv.Itoa(a+1)
			data3 = append(data3, datamap2child)
			datamap2child = make(map[string]interface{})

			datamap2child["label"] = "误差值"
			datamap2child["prop"] = "a" + strconv.Itoa(a+2)
			data3 = append(data3, datamap2child)
			datamap2child = make(map[string]interface{})

			datamap2child["label"] = "误差率"
			datamap2child["prop"] = "a" + strconv.Itoa(a+3)
			data3 = append(data3, datamap2child)
			datamap2["children"] = data3
			data2 = append(data2, datamap2)
			data3 = []interface{}{}
			datamap2 = make(map[string]interface{})
			datamap2child = make(map[string]interface{})

		}

		datamap1["A"] = queryList[i]["fname"]
		datamap1["a"+strconv.Itoa(a)] = queryList[i]["lweight"]
		datamap1["a"+strconv.Itoa(a+1)] = queryList[i]["actualweightminus"]
		datamap1["a"+strconv.Itoa(a+2)] = queryList[i]["diff"]
		datamap1["a"+strconv.Itoa(a+3)] = queryList[i]["diffrate"]
		datamap2["label"] = queryList[i]["饲料名称"]

	}

	data1 = append(data1, datamap1)

	chartData["data1"] = data1
	chartData["data2"] = data2

	queryData["list"] = chartData

	queryData["code"] = 0
	queryData["message"] = "ok"
	queryData["data"] = queryList
	return queryData, nil
}

func getAccuracyV3(queryList []map[string]interface{}) (map[string]interface{}, error) {
	queryData := make(map[string]interface{})
	chartData := make(map[string]interface{})
	data := []interface{}{}
	data1 := []interface{}{}
	data2 := []interface{}{}
	data3 := []interface{}{}
	data4 := []interface{}{}
	datatem := []interface{}{}
	t1 := make(map[interface{}]string, 0)
	for i := 0; i < len(queryList); i++ {
		data = append(data, queryList[i]["mtime"])
		data1 = append(data1, queryList[i]["lweight"])
		data2 = append(data2, queryList[i]["weight"])
		//data3 = append(data3, queryList[i]["field3"])
		//data4 = append(data4, queryList[i]["field4"])
		if _, ok := t1[queryList[i]["id"]]; !ok {
			datatem = append(datatem, queryList[i]["startstime"], queryList[i]["lastactualweight"])
			data3 = append(data3, datatem)
			datatem = []interface{}{}
			datatem = append(datatem, queryList[i]["intime"], queryList[i]["actualweight"])
			data3 = append(data3, datatem)
			datatem = []interface{}{}
		}
		t1[queryList[i]["id"]] = "1"
	}

	chartData["data1"] = data
	chartData["data2"] = data1
	chartData["data3"] = data2
	chartData["data4"] = data3
	chartData["data5"] = data4

	queryData["list"] = chartData
	queryData["code"] = 0
	queryData["message"] = "ok"
	queryData["data"] = queryList
	return queryData, nil
}
func getAccuracyV3v1(queryList []map[string]interface{}) (map[string]interface{}, error) {
	queryData := make(map[string]interface{})
	chartData := make(map[string]interface{})
	data := []interface{}{}
	data1 := []interface{}{}
	data2 := []interface{}{}
	data3 := []interface{}{}
	data4 := []interface{}{}
	datatem := []interface{}{}
	//t1 := make(map[interface{}]string, 0)
	jsonstr := ""
	jsonmap := make([]map[string]interface{},0)
	if len(queryList)>0{

		queryjsonList, _ := restful.Engine.SQL("select weightjson from recweightmuster where pid = ? and pastureid = ?" ,queryList[0]["pid"],queryList[0]["pastureid"]).Query().List()

		if len(queryjsonList)>0{
			jsonstr = queryjsonList[0]["weightjson"].(string)
		}
	}
	err := json.Unmarshal([]byte(jsonstr),&jsonmap)
	if err != nil{
		logging.Error("json.Unmarshal err",err)
	}

	for i := 0; i < len(queryList); i++ {

		datatem = append(datatem, queryList[i]["startstime"], queryList[i]["lastactualweight"])
		data3 = append(data3, datatem)
		datatem = []interface{}{}
		datatem = append(datatem, queryList[i]["intime"], queryList[i]["actualweight"])
		data3 = append(data3, datatem)
		datatem = []interface{}{}
	}
	j := 0
	for i := 0; i < len(jsonmap); i++ {
		if jsonmap[i]["mt"].(string)>queryList[j]["intime"].(string){
			if j < len(queryList)-1{
				j++
			}

		}
		data1 = append(data1, queryList[j]["lweight"])
		data = append(data, jsonmap[i]["mt"])
		data2 = append(data2, jsonmap[i]["w"])
	}

	chartData["data1"] = data
	chartData["data2"] = data1
	chartData["data3"] = data2
	chartData["data4"] = data3
	chartData["data5"] = data4

	queryData["list"] = chartData
	queryData["code"] = 0
	queryData["message"] = "ok"
	queryData["data"] = queryList
	return queryData, nil
}

func getAccuracyV2(queryList []map[string]interface{}) (map[string]interface{}, error) {
	queryData := make(map[string]interface{})
	chartData := make(map[string]interface{})
	data := []interface{}{}
	data1 := []interface{}{}
	data2 := []interface{}{}
	data3 := []interface{}{}
	data4 := []interface{}{}

	for i := 0; i < len(queryList); i++ {
		data = append(data, queryList[i]["日期"])
		data1 = append(data1, queryList[i]["field1"])
		data2 = append(data2, queryList[i]["field2"])
		data3 = append(data3, queryList[i]["field3"])
		data4 = append(data4, queryList[i]["field4"])
	}

	chartData["data1"] = data
	chartData["data2"] = data1
	chartData["data3"] = data2
	chartData["data4"] = data3
	chartData["data5"] = data4

	queryData["list"] = chartData
	queryData["code"] = 0
	queryData["message"] = "ok"
	queryData["data"] = queryList
	return queryData, nil
}

func getAccuracy(queryList []map[string]interface{}) (map[string]interface{}, error) {

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

	t1 := make(map[interface{}]interface{}, 0)
	t2 := make(map[interface{}]interface{}, 0)
	data := make(map[string][]interface{}, 0)
	t := make([]map[string][]interface{}, 0)

	e1 := []interface{}{}
	e2 := []string{}

	for _, value := range queryList {
		if _, ok := t1[value["名称"]]; !ok {
			e1 = append(e1, value["名称"])
		}
		if _, ok := t2[value["日期"]]; !ok {
			switch value["日期"].(type) {
			case string:
				e2 = append(e2, value["日期"].(string))
			}

		}
		t1[value["名称"]] = value["名称"]
		t2[value["日期"]] = value["日期"]
	}
	sort.Strings(e2)

	var b interface{}
	a := 0
	for i := 0; i < len(queryList); i++ {
		if i == 0 {
			b = queryList[i]["名称"]
		}
		if b != queryList[i]["名称"] {
			if a < len(e2)-1 {
				for k := 0; k < len(e2)-a; k++ {
					data["data"] = append(data["data"], "")
				}
			}
			t = append(t, data)
			data = make(map[string][]interface{}, 0)
			b = queryList[i]["名称"]
			a = 0
		}
		switch queryList[i]["日期"].(type) {
		case string:
			dates, _ := time.Parse("2006-01-02", queryList[i]["日期"].(string))
			dates1 := ""
			if a < len(e2) -1{
				dates1 = e2[a]
			}else {
				dates1 = e2[len(e2)-1]
			}
			if a < len(e2)-1 {
				if e2[a] != queryList[i]["日期"].(string) {
					if e2[a] < queryList[i]["日期"].(string) {
						dates1 = queryList[i]["日期"].(string)
						dates, _ = time.Parse("2006-01-02", e2[a])
						for ; a < len(e2)-1; a++ {
							if e2[a] >= queryList[i]["日期"].(string) {
								break
							}
						}
					}
					for ; dates.Format("2006-01-02") < dates1; dates = dates.Add(24 * time.Hour) {
						data["data"] = append(data["data"], "")
					}
				}
			}

		}

		data["data"] = append(data["data"], queryList[i]["准确率"])
		a++
	}
	if a < len(e2)-1 {
		for k := 0; k < len(e2)-a; k++ {
			data["data"] = append(data["data"], "")
		}
	}
	t = append(t, data)

	chartData["data1"] = e1
	chartData["data2"] = e2
	chartData["data3"] = t

	queryData["list"] = chartData
	queryData["code"] = 0
	queryData["message"] = "ok"
	queryData["data"] = queryList
	return queryData, nil
}

func GetUpkeepPlan(c *gin.Context) {

	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)

	fsion := gofasion.NewFasion(string(dataByte))
	sqlnamestr := fsion.Get("name").ValueStr()
	offset := fsion.Get("offset").ValueDefaultInt(0)
	pagecount := fsion.Get("pagecount").ValueDefaultInt(0)
	returntype := fsion.Get("returntype").ValueDefaultStr("map")
	month := fsion.Get("month").ValueDefaultStr("map")
	logging.Info("GetUpkeepPlan ", c.Keys, sqlnamestr, month)
	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			fmt.Println("__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()
	sql, p := restful.GetSqlByNameDBT(sqlnamestr, tx)
	if sql != "" {
		s_params := make([]interface{}, 0)
		if fsion.HasKey("parammaps") {
			parammaps := fsion.Get("parammaps")
			paramslist := strings.Split(p, ",")
			if len(paramslist) > 0 && p != "" {
				for _, value := range paramslist {
					if strings.ToLower(strings.Trim(value, " ")) == "jwt_username" {
						if tempv, exists := c.Get("jwt_username"); exists {
							s_params = append(s_params, tempv.(string))
						} else {
							s_params = append(s_params, "")
						}
					} else {
						s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
					}
				}
			}

		} else if fsion.HasKey("params") {
			params := fsion.Get("params").Array()
			for _, v_params := range params {
				s_params = append(s_params, v_params.ValueStr())
			}
		}
		if returntype == "xlsx" {
			var xlsxfile *xlsx.File
			xlsxfile, _ = restful.QueryByXlsx(sql, s_params)
			//c.File("c:/dd.xlsx")
			c.Header("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
			c.Header("Content-Disposition", "attachment; filename="+"Workbook.xlsx")
			c.Header("Content-Transfer-Encoding", "binary")
			_ = xlsxfile.Write(c.Writer)

		} else {
			queryData, err := getDataBySqlT(sql, offset, pagecount, returntype, s_params, tx)

			if err != nil {
				appG.Response(http.StatusOK, e.ERROR, err.Error())
			} else {
				for index, value := range queryData.(map[string]interface{})["list"].([]map[string]interface{}) {
					if v, ok := value["id"]; ok {
						//month = "2020-03"
						seviceplans, _ := tx.SQL("SELECT * FROM seviceplan where eqId = ? and month=? ", v, month).QueryString() //获取保养计划
						if seviceplans != nil {
							for _, va := range seviceplans { //根据保养计划获取保养单
								//day,_ :=strconv.Atoi(va["day"])
								bigupkeeps, _ := tx.SQL("SELECT * FROM bigupkeep where seviceplanId = ?", va["id"]).QueryString() //获取保养计划中的保养单
								//buk := make(map[string]map[string]string)
								for _, bu := range bigupkeeps { //日期为key ，保养单为value 存到map中
									jstr := ""
									if bu["plantime"][8:9] == "0" {
										jstr = "m" + bu["plantime"][9:]
									} else {
										jstr = "m" + bu["plantime"][8:]
									}

									if bu["flowCompeleted"] < "2" && bu["plantime"] < time.Now().Format("2006-01-02") { //如果保养状态是0并且小于当前日期 则状态已延期2
										queryData.(map[string]interface{})["list"].([]map[string]interface{})[index][jstr] = va["upkeepName"] + "#" + va["id"] + "#2" + "#" + bu["id"] + "#" + bu["pushbackId"]
									} else {
										if bu["flowCompeleted"] >= "2" {
											queryData.(map[string]interface{})["list"].([]map[string]interface{})[index][jstr] = va["upkeepName"] + "#" + va["id"] + "#1" + "#" + bu["id"] + "#" + bu["pushbackId"]
										} else {
											queryData.(map[string]interface{})["list"].([]map[string]interface{})[index][jstr] = va["upkeepName"] + "#" + va["id"] + "#0" + "#" + bu["id"] + "#" + bu["pushbackId"]
										}
									}
								}

							}

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

			}
		}
	} else {
		appG.Response(http.StatusOK, e.SUCCESS, nil)
	}
}
func GetArrList(c *gin.Context) {

	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)

	fsion := gofasion.NewFasion(string(dataByte))
	sqlnamestr := fsion.Get("name").ValueStr()
	sqlnamestr1 := fsion.Get("name1").ValueStr()
	offset := fsion.Get("offset").ValueDefaultInt(0)
	pagecount := fsion.Get("pagecount").ValueDefaultInt(0)
	returntype := fsion.Get("returntype").ValueDefaultStr("map")
	month := fsion.Get("month").ValueDefaultStr("map")
	logging.Info("GetUpkeepPlan ", c.Keys, sqlnamestr, month)
	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			fmt.Println("__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()

	//STR :=Httppostdata("http://192.168.1.104:8081/authdata/GetDataBySqlIN","POST",string(dataByte),tx)

	sql, p := restful.GetSqlByNameDBT(sqlnamestr, tx)
	sql1, p1 := restful.GetSqlByNameDBT(sqlnamestr1, tx)
	if sql != "" {
		s_params := make([]interface{}, 0)
		if fsion.HasKey("parammaps") {
			parammaps := fsion.Get("parammaps")
			paramslist := strings.Split(p, ",")
			if len(paramslist) > 0 && p != "" {
				for _, value := range paramslist {
					if strings.ToLower(strings.Trim(value, " ")) == "jwt_username" {
						if tempv, exists := c.Get("jwt_username"); exists {
							s_params = append(s_params, tempv.(string))
						} else {
							s_params = append(s_params, "")
						}
					} else {
						s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
					}
				}
			}

		}

		queryData, err := getDataBySqlT(sql, offset, pagecount, returntype, s_params, tx)
		if err != nil {
			appG.Response(http.StatusOK, e.ERROR, err.Error())

		} else {
			paramslist1 := strings.Split(p1, ",")
			for index, value := range queryData.(map[string]interface{})["list"].([]map[string]interface{}) {
				s_params1 := make([]interface{}, 0)
				if len(paramslist1) > 0 && p1 != "" {
					for _, v := range paramslist1 {
						s_params1 = append(s_params1, value[strings.ToLower(strings.Trim(v, " "))])
					}
				}
				arr, _ := tx.SQL(sql1, s_params1...).QueryString() //获取
				queryData.(map[string]interface{})["list"].([]map[string]interface{})[index]["arrList"] = arr
			}
			appG.Response(http.StatusOK, e.SUCCESS, queryData)
		}
	} else {
		appG.Response(http.StatusOK, e.SUCCESS, nil)
	}
}

func GetRJSBData(c *gin.Context) {

	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)

	fsion := gofasion.NewFasion(string(dataByte))
	sqlnamestr := fsion.Get("name").ValueStr()
	sqlnamestr1 := fsion.Get("name1").ValueStr()
	offset := fsion.Get("offset").ValueDefaultInt(0)
	pagecount := fsion.Get("plancount").ValueDefaultInt(0)
	returntype := fsion.Get("returntype").ValueDefaultStr("map")
	month := fsion.Get("month").ValueDefaultStr("map")
	logging.Info("GetUpkeepPlan ", c.Keys, sqlnamestr, month)
	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			fmt.Println("__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()

	//STR :=Httppostdata("http://192.168.1.104:8081/authdata/GetDataBySqlIN","POST",string(dataByte),tx)

	sql, p := restful.GetSqlByNameDBT(sqlnamestr, tx)
	sql1, p1 := restful.GetSqlByNameDBT(sqlnamestr1, tx)
	if sql != "" {
		s_params := make([]interface{}, 0)
		if fsion.HasKey("parammaps") {
			parammaps := fsion.Get("parammaps")
			paramslist := strings.Split(p, ",")
			if len(paramslist) > 0 && p != "" {
				for _, value := range paramslist {
					if strings.ToLower(strings.Trim(value, " ")) == "jwt_username" {
						if tempv, exists := c.Get("jwt_username"); exists {
							s_params = append(s_params, tempv.(string))
						} else {
							s_params = append(s_params, "")
						}
					} else {
						s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
					}
				}
			}

		}

		queryData, err := getDataBySqlT(sql, offset, pagecount, returntype, s_params, tx)
		if err != nil {
			appG.Response(http.StatusOK, e.ERROR, err.Error())

		} else {
			paramslist1 := strings.Split(p1, ",")
			for index, value := range queryData.(map[string]interface{})["list"].([]map[string]interface{}) {
				s_params1 := make([]interface{}, 0)
				if len(paramslist1) > 0 && p1 != "" {
					for _, v := range paramslist1 {
						s_params1 = append(s_params1, value[strings.ToLower(strings.Trim(v, " "))])
					}
				}
				arr, _ := tx.SQL(sql1, s_params1...).QueryString() //获取
				queryData.(map[string]interface{})["list"].([]map[string]interface{})[index]["arrList"] = arr
			}
			appG.Response(http.StatusOK, e.SUCCESS, queryData)
		}
	} else {
		appG.Response(http.StatusOK, e.SUCCESS, nil)
	}
}

func GetAccount(c *gin.Context) {

	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	sqlnamestr := fsion.Get("name").ValueStr()
	offset := fsion.Get("offset").ValueDefaultInt(0)
	pagecount := fsion.Get("pagecount").ValueDefaultInt(0)
	returntype := fsion.Get("returntype").ValueDefaultStr("map")
	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			logging.Error("tx.Begin 事务启动失败__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()
	sql, p := restful.GetSqlByNameDBT(sqlnamestr, tx)
	//fmt.Println("sql========\n",sqlnamestr,sql)
	if sql != "" {
		s_params := make([]interface{}, 0)
		if fsion.HasKey("parammaps") {
			parammaps := fsion.Get("parammaps")
			if sqlnamestr != "getNoMesList" && sqlnamestr != "getNoMesCount" {
				logging.Info("GetDataByName", c.Keys, c.Request.RemoteAddr, sqlnamestr, parammaps.ValueStr())
			}

			paramslist := strings.Split(p, ",")
			if len(paramslist) > 0 && p != "" {
				for _, value := range paramslist {
					if strings.ToLower(strings.Trim(value, " ")) == "jwt_username" {
						if tempv, exists := c.Get("jwt_username"); exists {
							s_params = append(s_params, tempv.(string))
						} else {
							s_params = append(s_params, "")
						}
					} else {
						s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
					}
				}
			}

		} else if fsion.HasKey("params") {
			params := fsion.Get("params").Array()
			logging.Info("GetDataByName", c.Keys, c.Request.RemoteAddr, sqlnamestr, params)
			for _, v_params := range params {
				s_params = append(s_params, v_params.ValueStr())
			}
		}
		if returntype == "xlsx" {
			var xlsxfile *xlsx.File
			xlsxfile, _ = restful.QueryByXlsx(sql, s_params)
			//c.File("c:/dd.xlsx")
			c.Header("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
			c.Header("Content-Disposition", "attachment; filename="+"Workbook.xlsx")
			c.Header("Content-Transfer-Encoding", "binary")
			_ = xlsxfile.Write(c.Writer)

		} else {
			queryData, err := getDataBySqlT(sql, offset, pagecount, returntype, s_params, tx)

			if err != nil {
				logging.Error("GetDataByName  err: ", err)
				msg := geterrmsg(err.Error())
				appG.Response(http.StatusOK, e.ERROR, msg)
				//appG.Response(http.StatusOK, e.ERROR, err.Error())
			} else {
				appG.Response(http.StatusOK, e.SUCCESS, queryData)
			}
		}

	} else {
		appG.Response(http.StatusOK, e.SUCCESS, nil)
	}
}

// @Summary   根据APISQL表中SQL执行得到数据集
// @Tags PostDataByName
// @Accept json
// @Produce  json
// @Param  sqlname  query   string true "sqlname"
// @Param  offset  query   int true "offset"
// @Param  pagecount  query   int true "pagecount"
// @Param  returntype  query   string true "returntype"
// @Success 200 {string} json  "{ "code": 200, "data": {}, "msg": "ok" }"
// @Failure 400 {string} json "{"code":400,  "data":null,"msg":"请求参数错误"}"
// @Failure 404 {string} json "{ "code": 404, "data":null,"msg":"请求参数错误"}"
// @Router /data/PostDataByName  [POST]
func PostDataByName(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	sqlnamestr := fsion.Get("name").ValueStr()

	s_params := make([]interface{}, 0)
	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			fmt.Println("__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()
	sql, p := restful.GetSqlByNameDBT(sqlnamestr, tx)
	if sql != "" {
		if fsion.HasKey("parammaps") {
			parammaps := fsion.Get("parammaps")
			logging.Info("PostDataByName ", c.Keys, c.Request.RemoteAddr, sqlnamestr, parammaps.ValueStr())
			paramslist := strings.Split(p, ",")
			if len(paramslist) > 0 && p != "" {
				for _, value := range paramslist {
					if strings.ToLower(strings.Trim(value, " ")) == "jwt_username" {
						if tempv, exists := c.Get("jwt_username"); exists {
							s_params = append(s_params, tempv.(string))
						} else {
							s_params = append(s_params, "")
						}
					} else if strings.ToLower(strings.Trim(value, " ")) == "snowid" {
						ids, err := setting.SnowIds.NextId()
						if err != nil {
							ids = time.Now().UnixNano()
							logging.Info("create SnowIds err", err)
						}
						s_params = append(s_params, ids)
					} else {
						s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
					}
				}
			}
		} else if fsion.HasKey("params") {
			params := fsion.Get("params").Array()
			logging.Info("PostDataByName ", c.Keys, c.Request.RemoteAddr, sqlnamestr, params)
			//ids,err := setting.SnowIds.NextId()
			//if err !=nil{
			//	ids = time.Now().UnixNano()
			//	logging.Info("create SnowIds err",err)
			//}
			//s_params = append(s_params, ids)
			for _, v_params := range params {
				s_params = append(s_params, v_params.ValueStr())
			}
		}
		queryData, err := execDataBySqlT(sql, s_params, tx)
		if err != nil {
			logging.Error("PostDataByName  err: ", err)
			//appG.Response(http.StatusOK, e.ERROR, err.Error())
			msg := geterrmsg(err.Error())
			appG.Response(http.StatusOK, e.ERROR, msg)
		} else {
			appG.Response(http.StatusOK, e.SUCCESS, queryData)
		}
	} else {
		appG.Response(http.StatusOK, e.SUCCESS, nil)
	}
}

func PostRJSBData(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))

	s_params := make([]interface{}, 0)
	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			fmt.Println("__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()
	sql, p := restful.GetSqlByNameDBT("updatedownloadedplanYJ", tx)
	sql1, p1 := restful.GetSqlByNameDBT("updated1YJ", tx)
	sql2, p2 := restful.GetSqlByNameDBT("updated1execYJ", tx)
	sql3, p3 := restful.GetSqlByNameDBT("updated2YJ", tx)
	if !fsion.HasKey("parammaps") {
		appG.Response(http.StatusOK, e.ERROR, "参数解析失败")
		return
	}
	parammaps := fsion.Get("parammaps")

	// ==========================1========================
	paramslist := strings.Split(p, ",")
	if len(paramslist) > 0 && p != "" {
		for _, value := range paramslist {
			s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
		}
	}
	_, err = tx.SQL(sql, s_params...).Execute()
	if err != nil {
		fmt.Println(err)
		logging.Error("PostRJSBData  err: ", err)
		msg := geterrmsg(err.Error())
		appG.Response(http.StatusOK, e.ERROR, msg)
		return
	}

	// ==========================2========================
	s_params = make([]interface{}, 0)
	paramslist = strings.Split(p1, ",")
	if len(paramslist) > 0 && p1 != "" {
		for _, value := range paramslist {
			s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
		}
	}
	_, err = tx.SQL(sql1, s_params...).Execute()
	if err != nil {
		logging.Error("PostRJSBData1  err: ", err)
		msg := geterrmsg(err.Error())
		appG.Response(http.StatusOK, e.ERROR, msg)
		return
	}
	s_params = make([]interface{}, 0)
	// ==========================3========================

	paramslist = strings.Split(p2, ",")
	if len(paramslist) > 0 && p2 != "" {
		for _, value := range paramslist {
			s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
		}
	}
	_, err = tx.SQL(sql2, s_params...).Execute()
	if err != nil {
		logging.Error("PostRJSBData2  err: ", err)
		msg := geterrmsg(err.Error())
		appG.Response(http.StatusOK, e.ERROR, msg)
		return
	}
	s_params = make([]interface{}, 0)

	// ==========================4========================

	paramslist = strings.Split(p3, ",")
	if len(paramslist) > 0 && p3 != "" {
		for _, value := range paramslist {
			s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
		}
	}
	_, err = tx.SQL(sql3, s_params...).Execute()
	if err != nil {
		logging.Error("PostRJSBData3  err: ", err)
		msg := geterrmsg(err.Error())
		appG.Response(http.StatusOK, e.ERROR, msg)
		return
	}
	appG.Response(http.StatusOK, e.SUCCESS, "ok")
}
func PostRJSBDatas(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsions := gofasion.NewFasion(string(dataByte)).Array()


	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			fmt.Println("__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()
	sql, p := restful.GetSqlByNameDBT("updatedownloadedplanYJ", tx)
	sql1, p1 := restful.GetSqlByNameDBT("updated1YJV2", tx)
	sql2, p2 := restful.GetSqlByNameDBT("updated1execYJV2", tx)
	sql3, p3 := restful.GetSqlByNameDBT("updated2YJV2", tx)

	for _, fsion := range fsions {
		if !fsion.HasKey("parammaps") {
			appG.Response(http.StatusOK, e.ERROR, "参数解析失败")
			return
		}
		parammaps := fsion.Get("parammaps")
		s_params := make([]interface{}, 0)
		// ==========================1========================
		paramslist := strings.Split(p, ",")
		if len(paramslist) > 0 && p != "" {
			for _, value := range paramslist {
				s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
			}
		}
		fmt.Println("}}}}}}}}}}}}}}}}}}}",s_params)
		_, err = tx.SQL(sql, s_params...).Execute()

		if err != nil {
			fmt.Println(err)
			logging.Error("PostRJSBData  err: ", err)
			msg := geterrmsg(err.Error())
			appG.Response(http.StatusOK, e.ERROR, msg)
			return
		}

		// ==========================2========================
		s_params = make([]interface{}, 0)
		paramslist = strings.Split(p1, ",")
		if len(paramslist) > 0 && p1 != "" {
			for _, value := range paramslist {
				s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
			}
		}
		_, err = tx.SQL(sql1, s_params...).Execute()
		if err != nil {
			logging.Error("PostRJSBData1  err: ", err)
			msg := geterrmsg(err.Error())
			appG.Response(http.StatusOK, e.ERROR, msg)
			return
		}
		s_params = make([]interface{}, 0)
		// ==========================3========================

		paramslist = strings.Split(p2, ",")
		if len(paramslist) > 0 && p2 != "" {
			for _, value := range paramslist {
				s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
			}
		}
		_, err = tx.SQL(sql2, s_params...).Execute()
		if err != nil {
			logging.Error("PostRJSBData2  err: ", err)
			msg := geterrmsg(err.Error())
			appG.Response(http.StatusOK, e.ERROR, msg)
			return
		}
		s_params = make([]interface{}, 0)

		// ==========================4========================

		paramslist = strings.Split(p3, ",")
		if len(paramslist) > 0 && p3 != "" {
			for _, value := range paramslist {
				s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
			}
		}
		_, err = tx.SQL(sql3, s_params...).Execute()
		if err != nil {
			logging.Error("PostRJSBData3  err: ", err)
			msg := geterrmsg(err.Error())
			appG.Response(http.StatusOK, e.ERROR, msg)
			return
		}
	}
	appG.Response(http.StatusOK, e.SUCCESS, "ok")
}
// @Summary   根据APISQL表中SQL执行得到数据集
// @Tags ExecDataByConfig
// @Accept json
// @Produce  json
// @Param  sqlname  query   string true "sqlname"
// @Param  offset  query   int true "offset"
// @Param  pagecount  query   int true "pagecount"
// @Param  returntype  query   string true "returntype"
// @Success 200 {string} json  "{ "code": 200, "data": {}, "msg": "ok" }"
// @Failure 400 {string} json "{"code":400,  "data":null,"msg":"请求参数错误"}"
// @Failure 404 {string} json "{ "code": 404, "data":null,"msg":"请求参数错误"}"
// @Router /data/PostDataByName  [POST]

func ExecDataByConfig(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	tempval_ := make(map[string]interface{})
	tempCommon := make(map[string]interface{})
	tempval := make([]map[string]interface{}, 0)
	err := json.Unmarshal(dataByte, &tempval_)
	logging.Info("ExecDataByConfig ", c.Keys, c.Request.RemoteAddr, tempval_["common"], tempval_["data"])
	if err != nil {
		fmt.Println("error:", err)
	} else {
		if v, ok := tempval_["common"].(map[string]interface{}); ok {
			tempCommon = v
		}

		if v, ok := tempval_["data"].([]interface{}); ok {
			for _, Tvalue := range v {
				if v1, ok := Tvalue.(map[string]interface{}); ok {
					tempval = append(tempval, v1)
				}
			}
		}
		tx := restful.Engine.NewSession()

		err := tx.Begin()
		if err != nil {
			logging.Error("tx.Begin 事务启动失败__error:", err)
		}
		defer func() {
			switch {
			case err != nil:
				fmt.Println("__error:", err)
				if tx != nil {
					tx.Rollback()
				}
			default:
				if tx != nil {
					err = tx.Commit()
				}
			}
			if tx != nil {
				tx.Close()
			}
		}()

		if err == nil {
			if tempv, exists := c.Get("jwt_username"); exists {
				tempCommon["jwt_username"] = tempv.(string)
			}

			for _, paramvalue := range tempval {
				if _, ok := paramvalue["resultname"]; !ok {
					paramvalue["resultname"] = paramvalue["name"]
				}
				_, err = ExecDataParam(paramvalue, tempCommon, tempval, nil, nil, tx)
				if err != nil {
					logging.Error("ExecDataParam error:", err)
					break
				}
			}
			if err == nil {
				if tempCommon["returnmap"] != nil && tempCommon["returnmap"] != "" {
					appG.Response(http.StatusOK, e.SUCCESS, tempval)
				} else {
					appG.Response(http.StatusOK, e.SUCCESS, "成功执行！")
				}
			} else {
				msg := geterrmsg(err.Error())
				appG.Response(http.StatusOK, e.ERROR, msg)
				//appG.Response(http.StatusOK, e.ERROR, err.Error())
			}
		}
	}
	if err != nil {
		msg := geterrmsg(err.Error())
		appG.Response(http.StatusOK, e.ERROR, msg)
		//appG.Response(http.StatusOK, e.ERROR, err.Error())
	}
}

func interfacetostring(val interface{}) string {
	switch val.(type) {
	case string:
		ss := val.(string)
		return ss
		break
	case int:
		ss := val.(int)
		return strconv.Itoa(ss)
		break
	case int64:
		ss := val.(int64)
		return strconv.FormatInt(ss, 10)
		break
	case float64:
		ss := val.(float64)
		return strconv.FormatFloat(ss, 'E', -1, 32)
		break
	}
	return ""
}

func getParamValue(parammaps map[string]interface{}, value string, ParamMap []map[string]interface{}) string {

	if valuestring, ok := parammaps[strings.Trim(value, " ")].(string); ok {

		tempstrb := strings.IndexAny(valuestring, "@")
		tempstre := strings.IndexAny(valuestring, ".")
		if tempstrb > -1 && tempstre > -1 {
			for _, ParamMapList := range ParamMap {
				if v, ok := ParamMapList["resultname"]; ok {
					if v == valuestring[tempstrb+1:tempstre] {
						if v1, ok := ParamMapList["resultmaps"]; ok {
							if newA, ok := v1.([]map[string]interface{}); ok {
								return interfacetostring(newA[0][valuestring[tempstre+1:]])
							} else if newA, ok := v1.(map[string]interface{}); ok {
								return interfacetostring(newA[valuestring[tempstre+1:]])
							}

						}
					}
				}
			}
		} else {
			return valuestring
		}
	} else if valuestring, ok := parammaps[strings.Trim(value, " ")].(float64); ok {
		return strconv.FormatInt(int64(valuestring), 10)
	}
	return ""
}

func getParamValue_(parammaps map[string]interface{}, value string, ParamMap map[string]interface{}) string {
	if valuestring, ok := parammaps[strings.Trim(value, " ")].(string); ok {
		tempstrb := strings.IndexAny(valuestring, "@")
		tempstre := strings.IndexAny(valuestring, ".")
		if tempstrb > -1 && tempstre > -1 {
			if v, ok := ParamMap[valuestring[tempstre+1:]]; ok {
				if s, ok := v.(string); ok {
					return s
				} else if s, ok := v.(float64); ok {
					return strconv.FormatInt(int64(s), 10)
				}
			}
		}
	}

	return ""
}

func ExecDataParam(fasion map[string]interface{}, CommonParamMap map[string]interface{}, ParamMap []map[string]interface{}, ParentParamMap map[string]interface{}, sameParamMap []map[string]interface{}, tx *xorm.Session) ([]map[string]interface{}, error) {
	sqlname := fasion["name"].(string)
	sqltype := "" //v  校验/s1 查询/sm 查询/e  执行
	if v, ok := fasion["type"]; ok {
		sqltype = v.(string)
	}
	sql := ""
	p := ""
	s_params := make([]interface{}, 0)
	if sqltype != "" {
		sql, p = restful.GetSqlByName(sqlname, tx)
		//sqlApi, _ := models.GetApisqlByName(sqlname)
		if v, ok := fasion["parammaps"].(map[string]interface{}); ok {
			paramslist := strings.Split(p, ",")
			if len(paramslist) > 0 && p != "" {
				for _, value := range paramslist {
					ss := ""
					if strings.ToLower(strings.Trim(value, " ")) == "snowid" {
						ids, err := setting.SnowIds.NextId()
						if err != nil {
							ids = time.Now().UnixNano()
							logging.Info("create SnowIds err", err)
						}
						s_params = append(s_params, ids)
					} else {
						if ss == "" && CommonParamMap != nil {
							if valuestring, ok := v[strings.Trim(value, " ")].(string); ok {
								ss = valuestring
								tempstrb := strings.IndexAny(valuestring, "@")
								tempstre := strings.IndexAny(valuestring, ".")
								if (tempstre > tempstrb) && (strings.ToLower(valuestring[tempstrb+1:tempstre]) == "common") {
									if CommonParamMap[valuestring[tempstre+1:]] != nil {
										ss = CommonParamMap[valuestring[tempstre+1:]].(string)
									}
								} else {
									ss = ""
								}
							}

						}
						if ss == "" && ParentParamMap != nil {
							ss = getParamValue_(v, value, ParentParamMap)
						}

						if ss == "" && sameParamMap != nil {
							ss = getParamValue(v, value, sameParamMap)
						}

						if ss == "" && ParamMap != nil {
							ss = getParamValue(v, value, ParamMap)
						}
						s_params = append(s_params, ss)
					}

				}
			}

		}
	}
	if sql == "" {
		sqltype = ""
	}
	fmt.Printf("%v+ \n", s_params, sqlname)
	if sqltype == "s1" {
		tempValParam, err := restful.QueryByMap(sql, 0, 1, s_params)
		if v, ok := tempValParam.(map[string]interface{}); ok {
			fasion["resultmaps"] = v["list"].([]map[string]interface{})
		}
		if err != nil {
			return nil, err
		}
		err = ExitsChildrenParam(fasion, tempValParam, ParamMap, CommonParamMap, tx)
		if err != nil {
			return nil, err
		}
		return tempValParam.(map[string]interface{})["list"].([]map[string]interface{}), err
	} else if sqltype == "sm" {
		tempValParam, err := restful.QueryByMap(sql, 0, 0, s_params)
		if v, ok := tempValParam.(map[string]interface{}); ok {
			fasion["resultmaps"] = v["list"].([]map[string]interface{})
		} else {
			fmt.Println("sm", tempValParam)
		}

		if err != nil {
			return nil, err
		}
		err = ExitsChildrenParam(fasion, tempValParam, ParamMap, CommonParamMap, tx)
		if err != nil {
			return nil, err
		}
		return tempValParam.(map[string]interface{})["list"].([]map[string]interface{}), err

	} else if sqltype == "v" {
		tempValParam, err := restful.QueryByMap(sql, 0, 1, s_params)
		if v, ok := tempValParam.(map[string]interface{}); ok {
			fasion["resultmaps"] = v["list"].([]map[string]interface{})
		} else {
			fmt.Println("v", tempValParam)
		}
		if err != nil {
			return nil, err
		}
		if tempValParam.(map[string]interface{})["list"].([]map[string]interface{})[0]["vmsg"] != "" {
			return nil, errors.New(tempValParam.(map[string]interface{})["list"].([]map[string]interface{})[0]["vmsg"].(string))
		}
	} else if sqltype == "e" {
		tempVal_arrary := make([]map[string]interface{}, 0)
		tempVal_map := make(map[string]interface{})
		tempValParam, err := restful.ExecQueryT(sql, s_params, tx)
		if err == nil {
			fasion["resultmaps"] = tempValParam.(map[string]interface{})
			tempVal_map["result"] = tempValParam.(map[string]interface{})["result"]
			tempVal_map["LastInsertId"] = tempValParam.(map[string]interface{})["LastInsertId"]
			tempVal_arrary = append(tempVal_arrary, tempVal_map)
			return tempVal_arrary, err
		}
		return nil, err
	} else {
		if tempValParam, ok := fasion["resultmaps"].(map[string]interface{}); ok {
			err := ExitsChildrenParam(fasion, tempValParam, ParamMap, CommonParamMap, tx)
			if err != nil {
				return nil, err
			}
			return nil, err
		}
	}
	return nil, nil
}

func ExitsChildrenParam(fasion map[string]interface{}, tempValParam interface{}, ParamMap []map[string]interface{}, commonParam map[string]interface{}, tx *xorm.Session) error {
	var err error
	subarray, ok := fasion["children"]

	if ok {
		for _, v := range tempValParam.(map[string]interface{})["list"].([]interface{}) { //遍历父集有多少行数据
			tempVal_arrary := make([]map[string]interface{}, 0)
			for _, subarrayvalue := range subarray.([]interface{}) { //遍历所有执行命令
				tempVal_ := make(map[string]interface{})
				if _, ok := subarrayvalue.(map[string]interface{})["resultname"]; !ok {
					tempVal_["resultname"] = subarrayvalue.(map[string]interface{})["name"]
				} else {
					tempVal_["resultname"] = subarrayvalue.(map[string]interface{})["resultname"]
				}
				tempVal_["resultmaps"], err = ExecDataParam(subarrayvalue.(map[string]interface{}), commonParam, ParamMap, v.(map[string]interface{}), tempVal_arrary, tx) //递归调用执行

				if err != nil {
					return err
				}
				tempVal_arrary = append(tempVal_arrary, tempVal_)
			}
			v.(map[string]interface{})["children"] = tempVal_arrary
		}
	}
	return nil
}

// @Summary   删除图片
// @Tags RemovePicByName
// @Accept json
// @Produce  json
// @Param  sqlname  query   string true "sqlname"
// @Param  offset  query   int true "offset"
// @Param  pagecount  query   int true "pagecount"
// @Param  returntype  query   string true "returntype"
// @Success 200 {string} json  "{ "code": 200, "data": {}, "msg": "ok" }"
// @Failure 400 {string} json "{"code":400,  "data":null,"msg":"请求参数错误"}"
// @Failure 404 {string} json "{ "code": 404, "data":null,"msg":"请求参数错误"}"
// @Router /data/PostDataByName  [POST]
func RemovePicByName(c *gin.Context) {
	logging.Info("RemovePicByName ", c.Keys)
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	sqlnamestr := fsion.Get("name").ValueStr()
	picname := fsion.Get("picname").ValueStr()
	sql, _ := restful.GetSqlByNameDB(sqlnamestr)
	params := fsion.Get("params").Array()
	s_params := make([]interface{}, 0)
	for _, v_params := range params {
		s_params = append(s_params, v_params.ValueStr())
	}
	if sql != "" {
		queryData, err := execDataBySql(sql, s_params)

		if picname != "" {
			// Destination
			distPath := path.Join(setting.CurrentPath, setting.AppSetting.ImageSavePath, picname)

			err := os.Remove(distPath) //删除文件test.txt
			if err != nil {
				//如果删除失败则输出 file remove Error!
				fmt.Println("file remove Error!")
				//输出错误详细信息
				fmt.Printf("%s", err)
			} else {
				//如果删除成功则输出 file remove OK!
				fmt.Print("file remove OK!")
			}
			distPath = path.Join(setting.CurrentPath, setting.AppSetting.ThumbnailSavePath, picname)

			err = os.Remove(distPath) //删除文件test.txt
			if err != nil {
				//如果删除失败则输出 file remove Error!
				fmt.Println("file remove Error!")
				//输出错误详细信息
				fmt.Printf("%s", err)
			} else {
				//如果删除成功则输出 file remove OK!
				fmt.Print("file remove OK!")
			}
		}

		if err != nil {
			appG.Response(http.StatusOK, e.ERROR, err.Error())
		} else {
			appG.Response(http.StatusOK, e.SUCCESS, queryData)
		}
	} else {
		appG.Response(http.StatusOK, e.SUCCESS, nil)
	}
}

// @Summary   删除文件
// @Tags RemoveFileByName
// @Accept json
// @Produce  json
// @Param  sqlname  query   string true "sqlname"
// @Param  offset  query   int true "offset"
// @Param  pagecount  query   int true "pagecount"
// @Param  returntype  query   string true "returntype"
// @Success 200 {string} json  "{ "code": 200, "data": {}, "msg": "ok" }"
// @Failure 400 {string} json "{"code":400,  "data":null,"msg":"请求参数错误"}"
// @Failure 404 {string} json "{ "code": 404, "data":null,"msg":"请求参数错误"}"
// @Router /data/PostDataByName  [POST]
func RemoveFileByName(c *gin.Context) {
	appG := app.Gin{C: c}
	id := c.Param("id")
	logging.Info("DownloadFile ", c.Keys, id)
	eqdoc, err := restful.Engine.SQL("SELECT * FROM eq_doc where id = ? ", id).QueryString()
	if eqdoc == nil {
		appG.Response(http.StatusOK, e.ERROR, err.Error())
		return
	}
	distPath := path.Join(setting.CurrentPath, setting.AppSetting.FileSavePath, eqdoc[0]["docpath"], eqdoc[0]["newdocname"])

	err = os.Remove(distPath) //删除文件test.txt
	if err != nil {
		//如果删除失败则输出 file remove Error!
		fmt.Println("file remove Error!")
		//输出错误详细信息
		fmt.Printf("%s", err)
		appG.Response(http.StatusOK, e.ERROR, err.Error())
		return
	}
	fmt.Print("file remove OK!")
	_, err = restful.Engine.SQL("delete FROM eq_doc where id = ? ", id).QueryString()
	appG.Response(http.StatusOK, e.SUCCESS, "OK")

	//dataByte, _ := ioutil.ReadAll(c.Request.Body)
	//fsion := gofasion.NewFasion(string(dataByte))
	//sqlnamestr := fsion.Get("name").ValueStr()
	//filename := fsion.Get("filename").ValueStr()
	//sql, _ := restful.GetSqlByNameDB(sqlnamestr)
	//params := fsion.Get("params").Array()
	//s_params := make([]interface{}, 0)
	//for _, v_params := range params {
	//	s_params = append(s_params, v_params.ValueStr())
	//}
	//if sql != "" {
	//	queryData, err := execDataBySql(sql, s_params)
	//
	//	if filename != "" {
	//		// Destination
	//		distPath := path.Join(setting.CurrentPath, setting.AppSetting.FileSavePath, filename)
	//
	//		err := os.Remove(distPath) //删除文件test.txt
	//		if err != nil {
	//			//如果删除失败则输出 file remove Error!
	//			fmt.Println("file remove Error!")
	//			//输出错误详细信息
	//			fmt.Printf("%s", err)
	//		} else {
	//			//如果删除成功则输出 file remove OK!
	//			fmt.Print("file remove OK!")
	//		}
	//	}

	//	if err != nil {
	//		appG.Response(http.StatusOK, e.ERROR, err.Error())
	//	} else {
	//		appG.Response(http.StatusOK, e.SUCCESS, "OK")
	//	}
	//} else {
	//	appG.Response(http.StatusOK, e.SUCCESS, nil)
	//}
}

// @Summary   根据APISQL表中SQL执行得到数据集
// @Tags PostDataByName
// @Accept json
// @Produce  json
// @Param  sqlname  query   string true "sqlname"
// @Param  offset  query   int true "offset"
// @Param  pagecount  query   int true "pagecount"
// @Param  returntype  query   string true "returntype"
// @Success 200 {string} json  "{ "code": 200, "data": {}, "msg": "ok" }"
// @Failure 400 {string} json "{"code":400,  "data":null,"msg":"请求参数错误"}"
// @Failure 404 {string} json "{ "code": 404, "data":null,"msg":"请求参数错误"}"
// @Router /data/PostDataByName  [POST]
func UpdateDataRelation(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	tablename := fsion.Get("name").ValueStr()
	dataname := fsion.Get("dataname").ValueStr()
	datavalue := fsion.Get("datavalue").ValueStr()
	valuename := fsion.Get("valuename").ValueStr()
	logging.Info("UpdateDataRelation ", c.Keys, c.Request.RemoteAddr, tablename, dataname, datavalue, valuename)
	values := fsion.Get("values").Array()
	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			fmt.Println("__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()
	insertSqlstr := "insert into " + tablename + "( " + dataname + "," + valuename + ") select DISTINCT  ?, ? from DUAL " +
		" where NOT EXISTS (select " + valuename + " from " + tablename + " where " + valuename + " = ? and " + dataname + " = ?)"

	d_params := make([]interface{}, 4)
	d_params[0] = datavalue
	s_params := ""

	for _, v_values := range values {
		d_params[1] = v_values.ValueStr()
		if s_params == "" {
			s_params = v_values.ValueStr()
		} else {
			s_params = s_params + "," + v_values.ValueStr()
		}
		d_params[2] = d_params[1]
		d_params[3] = d_params[0]
		_, err := execDataBySqlT(insertSqlstr, d_params, tx)
		if err != nil {
			appG.Response(http.StatusOK, e.ERROR, err.Error())
			break
		}
	}

	if s_params != "" {

		deleteSqlstr := "delete from " + tablename + " " +
			"           where " + dataname + " = " + datavalue + " and " + valuename + " not in (" + s_params + ")"
		queryData, err := execDataBySqlT(deleteSqlstr, nil, tx)
		if err != nil {
			appG.Response(http.StatusOK, e.ERROR, err.Error())
		} else if err == nil {
			appG.Response(http.StatusOK, e.SUCCESS, queryData)
		}
	} else {
		deleteSqlstr := "delete from " + tablename + " " +
			"           where " + dataname + " = " + datavalue
		queryData, err := execDataBySqlT(deleteSqlstr, nil, tx)
		if err != nil {
			appG.Response(http.StatusOK, e.ERROR, err.Error())
		} else if err == nil {
			appG.Response(http.StatusOK, e.SUCCESS, queryData)
		}
	}
}

// @Summary   根据APISQL表中SQL执行得到数据集
// @Tags PostDatasByName
// @Accept json
// @Produce  json
// @Param  sqlname  query   string true "sqlname"
// @Param  offset  query   int true "offset"
// @Param  pagecount  query   int true "pagecount"
// @Param  returntype  query   string true "returntype"
// @Success 200 {string} json  "{ "code": 200, "data": {}, "msg": "ok" }"
// @Failure 400 {string} json "{"code":400,  "data":null,"msg":"请求参数错误"}"
// @Failure 404 {string} json "{ "code": 404, "data":null,"msg":"请求参数错误"}"
// @Router /data/PostDatasByName  [POST]
func PostDataByNames(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	sqlParams := fsion.Array()
	queryData := make(map[string]interface{})
	for _, v := range sqlParams {
		fsion2 := gofasion.NewFasion(v.Json())
		logging.Info("PostDataByNames ", c.Keys, fsion2.Get("name").ValueStr())
		sql, p := restful.GetSqlByNameDB(fsion2.Get("name").ValueStr())
		if sql == "" {
			errorm := make(map[string]interface{})
			errorm["code"] = e.ERROR
			errorm["message"] = "sql没有找到"
			errorm["param"] = ""
			queryData[fsion2.Get("name").ValueStr()] = errorm
			continue
		} else if sql != "" {
			s_params := make([]interface{}, 0)
			if fsion2.HasKey("parammaps") {
				parammaps := fsion2.Get("parammaps")

				paramslist := strings.Split(p, ",")
				if len(paramslist) > 0 && p != "" {
					for _, value := range paramslist {
						if strings.ToLower(strings.Trim(value, " ")) == "jwt_username" {
							if tempv, exists := c.Get("jwt_username"); exists {
								s_params = append(s_params, tempv.(string))
							} else {
								s_params = append(s_params, "")
							}
						} else if strings.ToLower(strings.Trim(value, " ")) == "snowid" {
							ids, err := setting.SnowIds.NextId()
							if err != nil {
								ids = time.Now().UnixNano()
								logging.Info("create SnowIds err", err)
							}
							s_params = append(s_params, ids)
						} else {
							s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
						}
					}
				}
			} else if fsion2.HasKey("params") {
				params := fsion2.Get("params").Array()
				//ids,err := setting.SnowIds.NextId()
				//if err !=nil{
				//	ids = time.Now().UnixNano()
				//	logging.Info("create SnowIds err",err)
				//}
				//s_params = append(s_params, ids)
				for _, v_params := range params {
					s_params = append(s_params, v_params.ValueStr())
				}
			}
			_, err := execDataBySql(sql, s_params)

			if err != nil {
				logging.Error("PostDataByName  err: ", err)
				errorm := make(map[string]interface{})
				errorm["code"] = e.ERROR
				errorm["message"] = err.Error()
				errorm["param"] = s_params
				queryData[fsion2.Get("name").ValueStr()] = errorm
				continue
			} else {
				errorm := make(map[string]interface{})
				errorm["code"] = e.SUCCESS
				errorm["message"] = "success"
				queryData[fsion2.Get("name").ValueStr()] = errorm
				continue
			}
		} else {
			errorm := make(map[string]interface{})
			errorm["code"] = e.ERROR
			errorm["message"] = "NO SQL"
			errorm["param"] = ""
			queryData[fsion2.Get("name").ValueStr()] = errorm
		}
	}
	appG.Response(http.StatusOK, e.SUCCESS, queryData)
}

func getDataBySql(sqlstr string, offset, pagecount int, returntype string, params []interface{}) (interface{}, error) {
	if offset > 0 {
		offset = offset - 1
	}
	//if pagecount == 0 {
	//	pagecount = setting.AppSetting.PageSize
	//}else if pagecount>setting.AppSetting.PageSize{
	//	pagecount = setting.AppSetting.PageSize
	//}
	if returntype == "list" {
		queryData, err := restful.QueryByList(sqlstr, offset, pagecount, params)
		return queryData, err
	} else if returntype == "listlist" {
		queryData, err := restful.QueryByListList(sqlstr, offset, pagecount, params)
		return queryData, err
	} else {
		queryData, err := restful.QueryByMap(sqlstr, offset, pagecount, params)
		return queryData, err
	}
}
func getDataBySqlT(sqlstr string, offset, pagecount int, returntype string, params []interface{}, tx *xorm.Session) (interface{}, error) {
	if offset > 0 {
		offset = offset - 1
	}
	//if pagecount == 0 {
	//	pagecount = setting.AppSetting.PageSize
	//}else if pagecount>setting.AppSetting.PageSize{
	//	pagecount = setting.AppSetting.PageSize
	//}
	if returntype == "list" {
		queryData, err := restful.QueryByListT(sqlstr, offset, pagecount, params, tx)
		return queryData, err
	} else if returntype == "listlist" {
		queryData, err := restful.QueryByListListT(sqlstr, offset, pagecount, params, tx)
		return queryData, err
	} else {
		queryData, err := restful.QueryByMapT(sqlstr, offset, pagecount, params, tx)
		return queryData, err
	}
}
func GetRecuData_BySql(sql string, Params string, idname string, thisParams map[string]interface{}, isList bool) (interface{}, error) {
	paramslist := strings.Split(Params, ",")
	s_params := make([]interface{}, 0)
	if isList {
		for _, v_params := range thisParams["params"].([]interface{}) {
			s_params = append(s_params, v_params)
		}
	} else {
		paramslist := strings.Split(Params, ",")
		if len(paramslist) > 0 && Params != "" {
			for _, value := range paramslist {
				s_params = append(s_params, thisParams[strings.Trim(value, " ")])
			}
		}
	}
	queryData, err := restful.QueryByMapMenu(sql, 0, 0, s_params)
	for _, queryData_ := range queryData {
		if v, ok := queryData_["haschildren"]; (ok && v.(int64) > 0) || !ok {
			if isList {
				//fmt.Println(idname, "--------------             -queryData_[idname]", queryData_)
				if queryData_[idname] != nil {
					thisParams["params"].([]interface{})[len(thisParams["params"].([]interface{}))-1] = queryData_[idname].(interface{})
				}

			} else {
				if queryData_[idname] != nil {
					thisParams[idname] = queryData_[idname].(interface{})
				}
				if len(paramslist) > 0 && Params != "" {
					s_params = make([]interface{}, 0)
					for _, value := range paramslist {
						s_params = append(s_params, thisParams[strings.Trim(value, " ")])
					}
				}
			}
			queryData_["children"], _ = GetRecuData_BySql(sql, Params, idname, thisParams, isList)
		} else {

		}
	}
	return queryData, err
}

func execDataBySql(sqlstr string, params []interface{}) (interface{}, error) {
	queryData, err := restful.ExecQuery(sqlstr, params)
	return queryData, err
}
func execDataBySqlT(sqlstr string, params []interface{}, tx *xorm.Session) (interface{}, error) {
	queryData, err := restful.ExecQueryT(sqlstr, params, tx)
	return queryData, err
}

func ExecDataBySql(sqlstr string, params []interface{}) (interface{}, error) {
	queryData, err := restful.ExecQuery(sqlstr, params)
	return queryData, err
}

// @Summary   导入excel文件到数据库，excel第一行作为参数
// @Tags ImportExcel
// @Accept json
// @Produce  json
// @Param  file  query   string true "文件名"
// @Param  name  header   string  true "执行sql的名字"
// @Success 200 {string} json  "{ "code": 200, "data": {}, "msg": "ok" }"
// @Failure 400 {string} json "{"code":400,  "data":null,"msg":"请求参数错误"}"
// @Failure 404 {string} json "{ "code": 404, "data":null,"msg":"请求参数错误"}"
// @Router /data/ImportExcel  [POST]
func ImportExcel(c *gin.Context) {
	appG := app.Gin{C: c}

	inputdata := ""
	c.Request.ParseForm()
	//tempv1, _ := c.Get("jwt_username")
	//fmt.Println("=======================",tempv1)
	params := c.Request.Form
	file, _, err := c.Request.FormFile("file")
	if err != nil {
		appG.Response(http.StatusOK, e.ERROR, err)
		return
	}
	sqlnamestrs := params.Get("name")
	sheetname := params.Get("sheetname")
	pastureid := params.Get("pastureid")
	//importParams := params.Get("importParams")
	logging.Info("ImportExcel ", c.Keys, c.Request.RemoteAddr, sqlnamestrs)

	//paramslist := strings.Split(importParams, ",")
	//paramslist = append(paramslist, "jwt_username")
	requiredParams := params.Get("requiredParams")
	dateParams := params.Get("dateParams")
	numParams := params.Get("numParams")

	dateParamslist := strings.Split(dateParams, ",")
	requiredParamslist := strings.Split(requiredParams, ",")
	numParamslist := strings.Split(numParams, ",")
	queryData := make([]interface{}, 0)
	sqlslist := strings.Split(sqlnamestrs, ",")
	xlsx1, err := excelize.OpenReader(file)
	if err != nil {
		fmt.Println(err)
		return
	}
	ok := 0
	error := 0
	isdone := true

	rows, _ := xlsx1.GetRows(sheetname)

	if len(rows) > 10000 {    // 限制1000条
		rows = rows[:10000]
	}
	for i, row := range rows {
		if i > 0 {

			entry := make(map[string]interface{})
			outentry := make(map[string]interface{})
			for j, colCell := range rows[0] {
				for k, colCell1 := range row {
					if j == k {
						outentry[colCell] = colCell1
						entry[colCell] = colCell1
					}
				}
			}
			inputdata = ""
			a := ""
			for _, v := range dateParamslist {
				if v == ""{
					continue
				}
				if d, ok := outentry[strings.Trim(v, " ")]; ok {
					dtime,err := TransfTime(d.(string))
					if err != nil {
						a = strings.Trim(v, " ")
						break
					}
					outentry[strings.Trim(v, " ")] = dtime
				}
			}
			if a != "" {
				outentry["error_msg"] = a + " 格式错误"
				error++
				queryData = append(queryData, outentry)
				continue
			}
			a = ""
			for _, v := range requiredParamslist {
				if v == ""{
					continue
				}

				if d, ok := outentry[strings.Trim(v, " ")]; !ok || d == "" {
					a = strings.Trim(v, " ")
					break
				}
			}
			if a != "" {
				outentry["error_msg"] = a + " 未填或格式错误"
				error++
				queryData = append(queryData, outentry)
				continue
			}
			a = ""
			for _, v := range numParamslist {
				if v == ""{
					continue
				}
				d, ok := outentry[strings.Trim(v, " ")]
				if !ok || d == "" {
					outentry[strings.Trim(v, " ")] = 0
				}else {
					var fl float64
					switch d.(type) {
					case string :
						fl,err = strconv.ParseFloat(d.(string),64)
					}
					if err != nil || fl<0 {
						a = strings.Trim(v, " ")
						break
					}
				}
			}
			if a != "" {
				outentry["error_msg"] = a + " 为数值类型且不可为负数"
				error++
				queryData = append(queryData, outentry)
				continue
			}

			tx := restful.Engine.NewSession()
			err := tx.Begin()

			for _, sqlnamestr := range sqlslist {
				sql, paramslists := restful.GetSqlByNameDB(sqlnamestr)
				paramslist := strings.Split(paramslists, ",")
				if len(paramslist) > 0 {
					s_params := make([]interface{}, 0)

					for _, value := range paramslist {
						if strings.ToLower(strings.Trim(value, " ")) == "jwt_username" {
							if tempv, exists := c.Get("jwt_username"); exists {
								s_params = append(s_params, tempv.(string))
							} else {
								s_params = append(s_params, "")
							}
						}else if strings.ToLower(strings.Trim(value, " ")) == "pastureid"{
								s_params = append(s_params, pastureid)

						} else if strings.ToLower(strings.Trim(value, " ")) == "snowid" {
							ids, err := setting.SnowIds.NextId()
							if err != nil {
								ids = time.Now().UnixNano()
								logging.Info("create SnowIds err", err)
							}
							s_params = append(s_params, ids)
						}else {
							if outentry[strings.Trim(value, " ")] == nil {
								s_params = append(s_params,"")
							}else{

								s_params = append(s_params, outentry[strings.Trim(value, " ")])
							}

						}
					}
					//fmt.Println("================",s_params)
					outentry["input"] = inputdata
					returnmsgmap1, err := tx.SQL(sql, s_params...).Query().List()

					if err != nil {
						if tx != nil {
							tx.Rollback()
						}
						if tx != nil {
							tx.Close()
						}

						msg := geterrmsg(err.Error())
						outentry["error_msg"] = msg
						error++
						queryData = append(queryData, outentry)
						isdone = true
						break
					} else{
						if len(returnmsgmap1) > 0 {
							if va,ok :=returnmsgmap1[0]["msg"]  ; ok && va != "" {
								if tx != nil {
									tx.Rollback()
								}
								if tx != nil {
									tx.Close()
								}
								msg := geterrmsg(va.(string))
								outentry["error_msg"] = msg
								error++
								queryData = append(queryData, outentry)
								isdone = true
								break
							}
						}
						isdone = false
					}
				}
			}
			switch {
			case err != nil:
				if tx != nil {
					tx.Rollback()
				}
			default:
				if tx != nil {
					err = tx.Commit()
				}
			}
			if tx != nil {
				tx.Close()
			}
		}
		if !isdone{
			ok++
			isdone = true
		}
	}
	data := make(map[string]interface{})
	data["result"] = queryData
	data["success"] = ok
	data["err_count"] = error
	appG.Response(http.StatusOK, e.SUCCESS, data)
}

func TransfTime(timestr string) (string,error) {
	if timestr == "" {
		return time.Now().Format("2006-01-02"),nil
	}
	days, err := strconv.Atoi(timestr)
	if err != nil {
		if len(timestr) == 8 && strings.Count(timestr, "-") == 2 {
			return "20" + timestr[6:] + "-" + timestr[:5],nil
		}
		_,err :=time.Parse("2006-01-02",timestr)
		if err != nil{
			t,err :=time.Parse("2006/01/02",timestr)
			if err != nil{
				t,err :=time.Parse("2006.01.02",timestr)
				if err != nil {
					return "",err
				}else {
					return t.Format("2006-01-02"),nil
				}
			}else {
				return t.Format("2006-01-02"),nil
			}
		}else {
			return timestr,nil
		}
	}
	times, _ := time.Parse("2006-01-02", "1899-12-30")
	times = times.AddDate(0, 0, days)

	return times.Format("2006-01-02"),nil
}

func Createchart(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	chart_name := fsion.Get("chart_name").ValueStr()
	desc := fsion.Get("desc").ValueStr()
	pastureid := fsion.Get("pastureid").ValueStr()
	source_id := fsion.Get("source_id").ValueStr()
	emp := fsion.Get("emp").ValueStr()
	content := fsion.Get("content").Json()
	//fmt.Println("=============",parammaW.Json())
	var mapResult map[string]interface{}
	err1 := json.Unmarshal([]byte(content), &mapResult)
	if err1 != nil {
		fmt.Println("JsonToMapDemo err: ", err1)
	}
	//fmt.Println("---------",mapResult)

	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			logging.Error("tx.Begin 事务启动失败__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()

	ids, err := setting.SnowIds.NextId()
	if err != nil {
		ids = time.Now().UnixNano()
		logging.Info("create SnowIds err", err)
	}

	exec, err := tx.Exec("insert into chart(id,pastureid,cname,statue,emp,opratetime,content,sourceid)VALUEs(?,?,?,?,?,?,?)",
		ids, pastureid, chart_name, 0, emp, desc, source_id)
	if err != nil {
		appG.Response(http.StatusOK, e.ERROR, err.Error())
	} else {
		appG.Response(http.StatusOK, e.SUCCESS, exec)
	}
}
func Updatedashboard(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	dashboard_id := fsion.Get("dashboard_id").ValueStr()
	pastureid := fsion.Get("pastureid").ValueStr()
	content := fsion.Get("content").Json()
	//fmt.Println("=============",parammaW.Json())
	var mapResult map[string]interface{}
	err1 := json.Unmarshal([]byte(content), &mapResult)
	if err1 != nil {
		fmt.Println("JsonToMapDemo err: ", err1)
	}

	layout := mapResult["layout"]
	fmt.Println("---------", layout)
	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			logging.Error("tx.Begin 事务启动失败__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()
	//fmt.Println("sql========\n",sqlnamestr,sql)
	exec, err := tx.SQL("select content from dashboard where pastureid=? and id=?", pastureid, dashboard_id).Query().List()
	if err != nil {
		println("2", err.Error())
		appG.Response(http.StatusOK, e.ERROR, err.Error())
	} else {
		if exec != nil {
			if exec[0]["content"] == nil {
				mapR := make(map[string]interface{})
				mapR["layout"] = layout
				mjson, _ := json.Marshal(mapR)
				mString := string(mjson)
				exec1, err3 := tx.Exec("update dashboard set content=? where pastureid=? and id=?", mString, pastureid, dashboard_id)
				if err3 != nil {
					println("3", err3.Error())
					appG.Response(http.StatusOK, e.ERROR, err3.Error())
				} else {
					appG.Response(http.StatusOK, e.SUCCESS, exec1)
				}
			} else {
				var mapR map[string]interface{}
				err2 := json.Unmarshal([]byte(exec[0]["content"].(string)), &mapR)
				if err1 != nil {
					fmt.Println("JsonToMapDemo err: ", err2)
				}
				mapR["layout"] = layout
				mjson, _ := json.Marshal(mapR)
				mString := string(mjson)
				exec1, err3 := tx.Exec("update dashboard set content=? where pastureid=? and id=?", mString, pastureid, dashboard_id)
				if err3 != nil {
					println("3", err3.Error())
					appG.Response(http.StatusOK, e.ERROR, err3.Error())
				} else {
					appG.Response(http.StatusOK, e.SUCCESS, exec1)
				}
			}

		} else {
			appG.Response(http.StatusOK, e.ERROR, "未找到对应的仪表盘")
		}

	}
}

func ExecSQL(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	content := fsion.Get("content").Json()
	pastureid := fsion.Get("pastureid").ValueStr()
	//pastureid := fsion.Get("pastureid").ValueStr()
	//println(pastureid,"==================")
	//fmt.Println("=============",parammaW.Json())
	var mapResult map[string]interface{}
	err1 := json.Unmarshal([]byte(content), &mapResult)
	if err1 != nil {
		fmt.Println("JsonToMapDemo err: ", err1)
	}
	//fmt.Println("---------",mapResult)
	sqlstr := "select "
	groupstr := " GROUP BY "
	for _, value := range mapResult["selectedDimension"].([]interface{}) {

		sqlstr = sqlstr + value.(map[string]interface{})["Column"].(string) + ","
		groupstr = groupstr + value.(map[string]interface{})["Column"].(string) + ","
	}

	for _, value := range mapResult["selectedCalcul"].([]interface{}) {
		if value.(map[string]interface{})["calculFunc"].(string) == "none" {
			sqlstr = sqlstr + value.(map[string]interface{})["Column"].(string) + ","
			groupstr = groupstr + value.(map[string]interface{})["Column"].(string) + ","
		} else {
			tem := value.(map[string]interface{})["calculFunc"].(string) + "(" + value.(map[string]interface{})["Column"].(string) + ") as " + value.(map[string]interface{})["Column"].(string)
			sqlstr = sqlstr + tem + ","
		}
	}
	if _, ok := mapResult["selectedCalcul2"]; ok {
		for _, value := range mapResult["selectedCalcul2"].([]interface{}) {
			if value.(map[string]interface{})["calculFunc"].(string) == "none" {
				sqlstr = sqlstr + value.(map[string]interface{})["Column"].(string) + ","
				groupstr = groupstr + value.(map[string]interface{})["Column"].(string) + ","
			} else {
				tem := value.(map[string]interface{})["calculFunc"].(string) + "(" + value.(map[string]interface{})["Column"].(string) + ") as " + value.(map[string]interface{})["Column"].(string)
				sqlstr = sqlstr + tem + ","
			}
		}
	}

	//
	sqlstr = sqlstr[0 : len(sqlstr)-1]
	sqlstr = sqlstr + " from " + mapResult["dataSrc"].(string)
	//if len(mapResult["filters"].([]interface {}))>0{
	sqlstr = sqlstr + " where pastureid=" + pastureid
	//}
	//
	for _, value := range mapResult["filters"].([]interface{}) {
		switch value.(map[string]interface{})["filterOperator"].(string) {
		case ">", "=", "<", ">=", "<=", "!=", "like":
			sqlstr = sqlstr + value.(map[string]interface{})["filteCol"].(string) + value.(map[string]interface{})["filterOperator"].(string) + " " + value.(map[string]interface{})["value"].(map[string]interface{})["value1"].(string) + " AND "
		case "IN":
			sqlstr = sqlstr + value.(map[string]interface{})["filteCol"].(string) + " " + value.(map[string]interface{})["filterOperator"].(string) + "("
			for _, value1 := range value.(map[string]interface{})["value"].(map[string]interface{})["arrValue"].([]interface{}) {
				sqlstr = sqlstr + value1.(string) + ","
			}
			sqlstr = sqlstr[0 : len(sqlstr)-1]
			sqlstr = sqlstr + ")" + " AND "
		case "BETWEEN":
			sqlstr = sqlstr + value.(map[string]interface{})["filteCol"].(string) + " " + value.(map[string]interface{})["filterOperator"].(string) + " " + value.(map[string]interface{})["value"].(map[string]interface{})["value1"].(string) + " and " + value.(map[string]interface{})["value"].(map[string]interface{})["value2"].(string) + " AND "
		}

	}
	if len(mapResult["filters"].([]interface{})) > 0 {
		sqlstr = sqlstr[0 : len(sqlstr)-4]
	}

	//
	groupstr = groupstr[0 : len(groupstr)-1]
	sqlstr = sqlstr + groupstr + " "
	if len(mapResult["orderByStrs"].([]interface{})) > 0 {
		sqlstr = sqlstr + " order by "
	}
	//
	for key, value := range mapResult["orderByStrs"].([]interface{}) {
		if key == len(mapResult["orderByStrs"].([]interface{}))-1 {
			sqlstr = sqlstr + value.(string) + " "
		} else {
			sqlstr = sqlstr + value.(string) + ","
		}
	}
	//
	sqlstr = sqlstr + " limit " + strconv.Itoa(int(mapResult["limit"].(float64)))

	//fmt.Println("====++---------",sqlstr)
	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			logging.Error("tx.Begin 事务启动失败__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()
	//fmt.Println("sql========\n",sqlnamestr,sql)
	//ids,err := setting.SnowIds.NextId()
	//if err !=nil{
	//	ids = time.Now().UnixNano()
	//	logging.Info("create SnowIds err",err)
	//}
	//	exec,err :=tx.Exec("insert into chart(id,pastureid,cname,statue,emp,opratetime,content,sourceid)VALUEs(?,?,?,?,?,?,?)",
	//ids,pastureid,chart_name,0,emp,desc,source_id)

	exec, err := tx.SQL(sqlstr).Query().List()
	if err != nil {
		appG.Response(http.StatusOK, e.ERROR, err.Error())
	} else {
		appG.Response(http.StatusOK, e.SUCCESS, exec)
	}
}

func Dashboards(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)

	fsion := gofasion.NewFasion(string(dataByte))
	sqlnamestr := fsion.Get("name").ValueStr()
	//sqlnamestr1 := fsion.Get("name1").ValueStr()
	offset := fsion.Get("offset").ValueDefaultInt(0)
	pagecount := fsion.Get("pagecount").ValueDefaultInt(0)
	returntype := fsion.Get("returntype").ValueDefaultStr("map")
	month := fsion.Get("month").ValueDefaultStr("map")
	logging.Info("GetUpkeepPlan ", c.Keys, sqlnamestr, month)
	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			fmt.Println("__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()

	sql, p := restful.GetSqlByNameDBT(sqlnamestr, tx)
	//sql1, p1 := restful.GetSqlByNameDBT(sqlnamestr1, tx)
	if sql != "" {
		s_params := make([]interface{}, 0)
		if fsion.HasKey("parammaps") {
			parammaps := fsion.Get("parammaps")
			paramslist := strings.Split(p, ",")
			if len(paramslist) > 0 && p != "" {
				for _, value := range paramslist {
					if strings.ToLower(strings.Trim(value, " ")) == "jwt_username" {
						if tempv, exists := c.Get("jwt_username"); exists {
							s_params = append(s_params, tempv.(string))
						} else {
							s_params = append(s_params, "")
						}
					} else {
						s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
					}
				}
			}

		}

		queryData, err := getDataBySqlT(sql, offset, pagecount, returntype, s_params, tx)
		if err != nil {
			appG.Response(http.StatusOK, e.ERROR, err.Error())
		} else {
			//paramslist1 := strings.Split(p1, ",")

			dids := make([]interface{}, 0)
			for index, value := range queryData.(map[string]interface{})["list"].([]map[string]interface{}) {

				var mapResult map[string]interface{}
				dids = append(dids, value["dashboard_id"])

				if value["content"] != nil {
					err1 := json.Unmarshal([]byte(value["content"].(string)), &mapResult)
					if err1 != nil {
						println("JsonToMapDemo1 err: ", err1)
					}
					//fmt.Printf("%v+\n",value["content"].(string))
					temap := make(map[string]interface{})
					tem := mapResult["layout"].([]interface{})
					if v, ok := value["chartids"]; ok {
						chartids := strings.Split(v.(string), ",")
						for _, va := range chartids {
							a := false
							for _, v2 := range tem {
								if v2.(map[string]interface{})["id"].(string) == va {
									a = true
									//println("va1======",va)
								}
							}

							if !a {
								laytem := "{\"bottomLine\":[[3,18],[15,18]],\"h\":9,\"i\":\"" +
									va + "\",\"id\":\"" + va +
									"\",\"moved\":false,\"topLine\":[[3,9],[15,9]],\"w\":12,\"x\":0,\"xOffSet\":15,\"y\":100,\"yOffSet\":18}"
								var mapTem map[string]interface{}
								err1 := json.Unmarshal([]byte(laytem), &mapTem)
								if err1 != nil {
									println("JsonToMapDemo err: ", err1)
								}
								tem = append(tem, mapTem)
							}

						}
						temap["layout"] = tem
						queryData.(map[string]interface{})["list"].([]map[string]interface{})[index]["content"] = temap
					}

				} else {

					temap := make(map[string]interface{})
					tem := make([]interface{}, 0)
					if v, ok := value["chartids"]; ok {

						chartids := strings.Split(v.(string), ",")
						for _, va := range chartids {

							laytem := "{\"bottomLine\":[[3,18],[15,18]],\"h\":9,\"i\":\"" +
								va + "\",\"id\":\"" + va +
								"\",\"moved\":false,\"topLine\":[[3,9],[15,9]],\"w\":12,\"x\":0,\"xOffSet\":15,\"y\":0,\"yOffSet\":18}"
							var mapTem map[string]interface{}
							err1 := json.Unmarshal([]byte(laytem), &mapTem)
							if err1 != nil {
								println("JsonToMapDemo err: ", err1)
							}
							tem = append(tem, mapTem)
						}
						temap["layout"] = tem
						queryData.(map[string]interface{})["list"].([]map[string]interface{})[index]["content"] = temap
					}
				}

			}

			queryData.(map[string]interface{})["order"] = dids
			queryData.(map[string]interface{})["dashboards"] = queryData.(map[string]interface{})["list"]
			appG.Response(http.StatusOK, e.SUCCESS, queryData)
		}
	} else {
		appG.Response(http.StatusOK, e.SUCCESS, nil)
	}

}


//type Nur struct {
//	Avgmonthage float64 `json : "avgmonthage"` //月龄
//	Bw          float64 `json : "bw"` //体重
//	Dayw        float64 `json : "dayw"` //日增重
//	Fetal       float64 `json : "fetal"` //胎次
//	Avgdim      float64 `json : "avgdim"` //平均泌乳天数
//	Dayspre     float64 `json : "dayspre"` //怀孕天数
//	Product     float64 `json : "product"` //产奶量
//	Fat         float64 `json : "fat"` //乳脂率
//	Pro         float64 `json : "pro"` //乳蛋白率
//	Lactose     float64 `json : "lactose"` //乳糖率
//	Source      string  `json : "source"` //来源
//	Tem         float64 `json : "tem"` //温度
//	Cowsum      float64 `json : "cowsum"` //牛头数
//	Cowclass    float64 `json : "cowclass"` //牲畜类别
//	Cowclassid  float64 `json : "cowclassid"` //牲畜类别id
//	Bigcowclass string  `json : "bigcowclass"` //牲畜大类
//}

type Nur struct {
	Avgmonthage float64 //月龄
	Bw          float64 //体重
	Dayw        float64 //日增重
	Fetal       float64 //胎次
	Avgdim      float64 //平均泌乳天数
	Dayspre     float64 //怀孕天数
	Product     float64 //产奶量
	Fat         float64 //乳脂率
	Pro         float64 //乳蛋白率
	Lactose     float64 //乳糖率
	Source      string  //来源
	Tem         float64 //温度
	Cowsum      float64 //牛头数
	Cowclass    string  //牲畜类别
	Cowclassid  float64 //牲畜类别id
	Bigcowclass string  //牲畜大类
}

func GETNurJudge(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	nurstr := fsion.Get("parammaps").Json()
	parammaps := make(map[string]interface{})
	nur := Nur{}
	_ = json.Unmarshal([]byte(nurstr), &nur)       //需要json 的类型相同
	_ = json.Unmarshal([]byte(nurstr), &parammaps) //需要json 的类型相同
	tx := restful.Engine.NewSession()
	err := tx.Begin()
	defer func() {
		switch {
		case err != nil:
			fmt.Println("__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()

	formulas, _ := tx.SQL("select * from tb_formula_d where cowclass = ? "+
		"and if (?='',''='', nutrition=? ) ORDER BY nutrition", nur.Bigcowclass, nur.Source, nur.Source).Query().List()
	resnur, err := CalNUR(formulas, &nur)
	if err != nil {
		logging.Error("GETNurJudge  err: ", err)
		msg := geterrmsg(err.Error())
		appG.Response(http.StatusOK, e.ERROR, msg)
	}

	resf, err := FeedproviderV2(parammaps, tx)

	reslist := make([]map[string]interface{}, 21)

	if len(resf) > 1 {
		for key, _ := range resf[0] {
			//println(key)
			str, sort := switchname(key)
			res := make(map[string]interface{}, 0)
			res["standard"] = str
			res["cowneed"] = resnur[key] // 奶牛需要
			res["ftpro"] = resf[0][key]  // 配方提供
			res["hprov"] = resf[1][key]  // tmr料
			res["sprov"] = resf[2][key]  //采食量
			reslist[sort] = res

		}
	}

	if err != nil {
		logging.Error("GETNurJudge  err: ", err)
		msg := geterrmsg(err.Error())
		appG.Response(http.StatusOK, e.ERROR, msg)
	} else {
		appG.Response(http.StatusOK, e.SUCCESS, reslist)
	}
}

func GETNurJudgeRport(c *gin.Context) {
	appG := app.Gin{C: c}
	dataByte, _ := ioutil.ReadAll(c.Request.Body)
	fsion := gofasion.NewFasion(string(dataByte))
	nurstr := fsion.Get("parammaps").Json()
	parammaps := make(map[string]interface{})
	_ = json.Unmarshal([]byte(nurstr), &parammaps)

	startTime, err := time.Parse("2006-01-02", parammaps["startTime"].(string))
	if err != nil {
		appG.Response(http.StatusOK, e.ERROR, err.Error())
		return
	}
	stopTime, err := time.Parse("2006-01-02", parammaps["stopTime"].(string))

	if err != nil {
		appG.Response(http.StatusOK, e.ERROR, err.Error())
		return
	}
	if stopTime.Sub(startTime) > 31*24*time.Hour {
		appG.Response(http.StatusOK, e.ERROR, errors.New("日期范围过大"))
		return
	}

	tx := restful.Engine.NewSession()
	err = tx.Begin()
	defer func() {
		switch {
		case err != nil:
			fmt.Println("__error:", err)
			if tx != nil {
				tx.Rollback()
			}
		default:
			if tx != nil {
				err = tx.Commit()
			}
		}
		if tx != nil {
			tx.Close()
		}
	}()

	//CulNurReportCow("getbmdetaillist",parammaps,tx)
	res, err := CulNurReportFT(parammaps, tx)

	if err != nil {
		logging.Error("GETNurJudgeRport  err: ", err)
		//appG.Response(http.StatusOK, e.ERROR, err.Error())
		msg := geterrmsg(err.Error())
		appG.Response(http.StatusOK, e.ERROR, msg)
	} else {
		appG.Response(http.StatusOK, e.SUCCESS, res)
	}
}

func CulNurReportCow(sqlname string, parammaps map[string]interface{}, tx *xorm.Session) (map[string]interface{}, error) {
	var nur Nur
	sql, p := restful.GetSqlByNameDBT(sqlname, tx)
	s_params := make([]interface{}, 0)
	paramslist := strings.Split(p, ",")
	if len(paramslist) > 0 && p != "" {
		for _, value := range paramslist {
			s_params = append(s_params, parammaps[strings.Trim(value, " ")])
		}
	}
	res, err := tx.SQL(sql, s_params...).Query().List()
	if len(res) > 0 {
		resstr, _ := json.Marshal(res[0])
		err = json.Unmarshal(resstr, &nur)
		if err != nil {
			return nil, err
		}
	}
	formulas, _ := tx.SQL("select * from tb_formula_d where cowclass = ? and if (?='',''='', nutrition=? ) ORDER BY nutrition", nur.Bigcowclass, nur.Source, nur.Source).Query().List()
	//println(len(formulas))
	resnur, err := CalNUR(formulas, &nur)
	if err != nil {
		return nil, err
	}
	return resnur, err

}

func CulNurReportFT(parammaps map[string]interface{}, tx *xorm.Session) (res []map[string]interface{}, err error) {

	barids, err := tx.SQL("SELECT trim(fp.barid) barid,fp.ccount,DATE_FORMAT(fp.date, '%Y-%m-%d')date,fp.barname FROM feedpdate fp WHERE fp.pastureid = ? AND  fp.date BETWEEN ? AND ? AND  fp.`ftid` = ? GROUP BY fp.`barid` order by fp.barid",
		parammaps["pastureid"], parammaps["startTime"], parammaps["stopTime"], parammaps["ftid"]).Query().List()
	//println(parammaps["pastureid"].(string), parammaps["startTime"].(string), parammaps["stopTime"].(string), parammaps["ftid"].(string))
	if err != nil {
		return nil, err
	}
	bartem := ""

	//println("barids", len(barids))
	dates := make([]string, 0)

	for key, value := range barids {
		if key == 0 {
			bartem = value["barid"].(string)
			parammaps["barid"] = value["barid"]
		}
		if bartem != value["barid"].(string) || key == len(barids)-1 || key == 0{
			if key == len(barids)-1 || key == 0{
				dates = append(dates, value["date"].(string))
			}
			parammaps["date"] = value["date"]
			parammaps["barid"] = value["barid"]
			barres, err := FeedproviderV3(parammaps, dates, tx)
			if err != nil {
				return nil, err
			}
			resnur, err := CulNurReportCow("getbmdetaillist", parammaps, tx)
			if err != nil {
				return nil, err
			}
			restem := make(map[string]interface{}, 0)

			for k, _ := range barres[0] {
				//println("wwwwwww",k)
				restem["barid"] = value["barid"].(string)
				restem["barname"] = value["barname"].(string)
				restem["ccount"] = value["ccount"].(int64)
				restem[k+"-nur"] = resnur[k]
				restem[k+"-FT"] = barres[0][k]
				restem[k+"-H"] = barres[1][k]
				restem[k+"-S"] = barres[2][k]
			}

			res = append(res, restem)
			if err != nil {
				return nil, err
			}
			bartem = value["barid"].(string)
			dates = make([]string, 0)
			parammaps["barid"] = value["barid"]
		}
		dates = append(dates, value["date"].(string))
	}
	return res, err
}
func switchname(str string) (string, int) {
	tstr := ""
	sort := 0
	switch str {
	case "dry":
		tstr = "干物质（kg）"
		sort = 0
	case "nm":
		tstr = "产奶净能（MJ）"
		sort = 1
	case "nuint":
		tstr = "奶牛能量单位(NND)"
		sort = 2
	case "cp":
		tstr = "粗蛋白（g）"
		sort = 3
	case "ca":
		tstr = " 钙（g）"
		sort = 4
	case "p":
		tstr = "磷（g）"
		sort = 5
	case "nmd":
		tstr = "产奶净能（MCal/DM）"
		sort = 6
	case "cpd":
		tstr = "粗蛋白(%DM)"
		sort = 7
	case "fat":
		tstr = "脂肪"
		sort = 8
	case "starch":
		tstr = "淀粉"
		sort = 9
	case "ndf":
		tstr = "NDF（%DM）"
		sort = 10
	case "cndf":
		tstr = "粗料中的NDF（%DM）"
		sort = 11
	case "adf":
		tstr = "ADF（%DM）"
		sort = 12
	case "cad":
		tstr = " 钙(%DM)"
		sort = 13
	case "pd":
		tstr = "磷(%DM)"
		sort = 14
	case "trans35f":
		tstr = "(3.5)饲料转化效率（kg/DM）"
		sort = 15
	case "trans4f":
		tstr = "(4.0)饲料转化效率（kg/DM）"
		sort = 16
	case "jcrate":
		tstr = "精粗比"
		sort = 17
	case "uprice":
		tstr = "日粮成本(元)"
		sort = 18
	case "upriced":
		tstr = "干物质成本（元/公斤）"
		sort = 19
	case "kprice":
		tstr = "公斤奶成本(元)	"
		sort = 20
	default:
		tstr = str
		sort = 21
	}
	return tstr, sort
}
func FeedproviderV2(parammaps map[string]interface{}, tx *xorm.Session) ([]map[string]float64, error) {
	startTime, err := time.Parse("2006-01-02", parammaps["startTime"].(string))
	if err != nil {
		return nil, err
	}
	stopTime, err := time.Parse("2006-01-02", parammaps["stopTime"].(string))

	if err != nil {
		return nil, err
	}
	if stopTime.Sub(startTime) > 31*24*time.Hour {
		return nil, errors.New("日期范围过大")
	}
	dates := make([]string, 0)
	for stopTime.Sub(startTime) >= 0 {
		dates = append(dates, startTime.Format("2006-01-02"))
		startTime = startTime.Add(24 * time.Hour)
	}
	resall, err := FeedproviderV3(parammaps, dates, tx)
	return resall, err
}

func FeedproviderV3(parammaps map[string]interface{}, dates []string, tx *xorm.Session) ([]map[string]float64, error) {

	res := make(map[string]float64, 0)
	resH := make(map[string]float64, 0)
	resS := make(map[string]float64, 0)
	i := 0

	for _, date := range dates {
		i++
		//println(date)
		parammaps["date"] = date
		restem, err := Feedprovider(parammaps, tx)
		if err != nil {
			return nil, err
		}
		restemSH, err := SHprovider(parammaps, tx)
		if err != nil {
			return nil, err
		}
		var h, s float64
		if len(restemSH) > 1 {
			switch restemSH[0]["actualweightminus"].(type) {
			case string:
				h, _ = strconv.ParseFloat(restemSH[0]["actualweightminus"].(string), 64)
			}
			switch restemSH[1]["actualweightminus"].(type) {
			case string:
				s, _ = strconv.ParseFloat(restemSH[1]["actualweightminus"].(string), 64)
			}
		}
		if len(restem) > 0 {
			b, _ := strconv.ParseFloat(restem[0]["jcrate"].(string), 64)
			res["jcrate"] = res["jcrate"] + b

			resH["jcrate"] = resH["jcrate"] + h*b
			resS["jcrate"] = resS["jcrate"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["cpd"].(string), 64)
			res["cpd"] = res["cpd"] + b

			resH["cpd"] = resH["cpd"] + h*b
			resS["cpd"] = resS["cpd"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["adf"].(string), 64)
			res["adf"] = res["adf"] + b

			resH["adf"] = resH["adf"] + h*b
			resS["adf"] = resS["adf"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["ca"].(string), 64)
			res["ca"] = res["ca"] + b

			resH["ca"] = resH["ca"] + h*b
			resS["ca"] = resS["ca"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["cad"].(string), 64)
			res["cad"] = res["cad"] + b

			resH["cad"] = resH["cad"] + h*b
			resS["cad"] = resS["cad"] + s*b

			//b,_ =strconv.ParseFloat(restem[0]["cdry"].(string),64)
			//res["cdry"] =  res["cdry"]+b
			//
			//resH["cdry"] = resH["cdry"]+ h*b
			//resS["cdry"] = resS["cdry"]+ s*b

			b, _ = strconv.ParseFloat(restem[0]["cndf"].(string), 64)
			res["cndf"] = res["cndf"] + b

			resH["cndf"] = resH["cndf"] + h*b
			resS["cndf"] = resS["cndf"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["cp"].(string), 64)
			res["cp"] = res["cp"] + b

			resH["cp"] = resH["cp"] + h*b
			resS["cp"] = resS["cp"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["dry"].(string), 64)
			res["dry"] = res["dry"] + b

			resH["dry"] = resH["dry"] + h*b
			resS["dry"] = resS["dry"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["fat"].(string), 64)
			res["fat"] = res["fat"] + b

			resH["fat"] = resH["fat"] + h*b
			resS["fat"] = resS["fat"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["kprice"].(string), 64)
			res["kprice"] = res["kprice"] + b

			resH["kprice"] = resH["kprice"] + h*b
			resS["kprice"] = resS["kprice"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["nm"].(string), 64)
			res["nm"] = res["nm"] + b

			resH["nm"] = resH["nm"] + h*b
			resS["nm"] = resS["nm"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["ndf"].(string), 64)
			res["ndf"] = res["ndf"] + b

			resH["ndf"] = resH["ndf"] + h*b
			resS["ndf"] = resS["ndf"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["nm"].(string), 64)
			res["nm"] = res["nm"] + b

			resH["nm"] = resH["nm"] + h*b
			resS["nm"] = resS["nm"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["nmd"].(string), 64)
			res["nmd"] = res["nmd"] + b

			resH["nmd"] = resH["nmd"] + h*b
			resS["nmd"] = resS["nmd"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["nuint"].(string), 64)
			res["nuint"] = res["nuint"] + b

			resH["nuint"] = resH["nuint"] + h*b
			resS["nuint"] = resS["nuint"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["p"].(string), 64)
			res["p"] = res["p"] + b

			resH["p"] = resH["p"] + h*b
			resS["p"] = resS["p"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["pd"].(string), 64)
			res["pd"] = res["pd"] + b

			resH["pd"] = resH["pd"] + h*b
			resS["pd"] = resS["pd"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["starch"].(string), 64)
			res["starch"] = res["starch"] + b

			resH["starch"] = resH["starch"] + h*b
			resS["starch"] = resS["starch"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["trans4f"].(string), 64)
			res["trans4f"] = res["trans4f"] + b

			resH["trans4f"] = resH["trans4f"] + h*b
			resS["trans4f"] = resS["trans4f"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["trans35f"].(string), 64)
			res["trans35f"] = res["trans35f"] + b

			resH["trans35f"] = resH["trans35f"] + h*b
			resS["trans35f"] = resS["trans35f"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["uprice"].(string), 64)
			res["uprice"] = res["uprice"] + b

			resH["uprice"] = resH["uprice"] + h*b
			resS["uprice"] = resS["uprice"] + s*b

			b, _ = strconv.ParseFloat(restem[0]["upriced"].(string), 64)
			res["upriced"] = res["upriced"] + b

			resH["upriced"] = resH["upriced"] + h*b
			resS["upriced"] = resS["upriced"] + s*b

		}
	}

	for key, _ := range res {
		resf, _ := strconv.ParseFloat(fmt.Sprintf("%.3f", res[key]/float64(i)), 64)
		resHf, _ := strconv.ParseFloat(fmt.Sprintf("%.3f", resH[key]/float64(i)), 64)
		resSf, _ := strconv.ParseFloat(fmt.Sprintf("%.3f", resS[key]/float64(i)), 64)
		res[key] = resf
		resH[key] = resHf
		resS[key] = resSf
	}
	resAll := make([]map[string]float64, 0)
	resAll = append(resAll, res, resH, resS)
	return resAll, nil
}

func Feedprovider(parammaps map[string]interface{}, tx *xorm.Session) ([]map[string]interface{}, error) {
	sql, p := restful.GetSqlByNameDBT(parammaps["name"].(string), tx)
	s_params := make([]interface{}, 0)
	paramslist := strings.Split(p, ",")
	if len(paramslist) > 0 && p != "" {
		for _, value := range paramslist {
			s_params = append(s_params, parammaps[strings.Trim(value, " ")])
		}
	}
	res, err := tx.SQL(sql, s_params...).Query().List()

	return res, err

}

func SHprovider(parammaps map[string]interface{}, tx *xorm.Session) ([]map[string]interface{}, error) {
	sql, p := restful.GetSqlByNameDBT(parammaps["name1"].(string), tx)
	//println(parammaps["name1"].(string),sql)
	s_params := make([]interface{}, 0)
	paramslist := strings.Split(p, ",")
	if len(paramslist) > 0 && p != "" {
		for _, value := range paramslist {
			s_params = append(s_params, parammaps[strings.Trim(value, " ")])
		}
	}
	res, err := tx.SQL(sql, s_params...).Query().List()

	return res, err

}

func CalNUR(formulas []map[string]interface{}, nur *Nur) (map[string]interface{}, error) {
	//formulaADF := make([]map[string]interface{},1)//ADF
	//formulaNDF := make([]map[string]interface{},1)//NDF
	//formulaNFC := make([]map[string]interface{},1)//NFC
	//formulacprotedm := make([]map[string]interface{},1)//小肠可消化粗蛋白
	//formuladry := make([]map[string]interface{},1)   //干物质
	//formulastarch := make([]map[string]interface{},1)//淀粉
	//formulap := make([]map[string]interface{},1)//磷
	//formulacNDF := make([]map[string]interface{},1)//粗料中的NDF %DM
	//formulajcrate := make([]map[string]interface{},1)//粗料比例
	//formulacprote := make([]map[string]interface{},1)//粗蛋白
	//formulaenergy := make([]map[string]interface{},1)//能量
	//formulafat := make([]map[string]interface{},1)//脂肪
	//formulaga := make([]map[string]interface{},1)//钙
	//formulafeedrate := make([]map[string]interface{},1)//饲料转化效率，标准乳/干物质4.0
	//formulafeed35rate := make([]map[string]interface{},1)//饲料转化效率，标准乳/干物质3.5

	resmap := make(map[string]float64)
	resmapstr := make(map[string]string)
	resAll := make(map[string]interface{})

	for _, formula := range formulas {
		if formula["type"].(int64) == 0 {
			resmapstr[formula["note"].(string)] = formula["formula"].(string)
			continue
		}
		res, err := PraseFormula(formula["formula"].(string), nur)
		if err != nil {
			logging.Error("PraseFormula err", err.Error(), formula["nutrition"].(string))
			//println("PraseFormula err", err.Error(), formula["nutrition"].(string))
		}
		switch res.(type) {
		case string:
			resmapstr[formula["note"].(string)] = res.(string)
		case float64, int, float32, int64, int32, int16, int8:
			var rest float64
			switch res.(type) {
			case float64:
				rest = res.(float64)
			case int:
				rest = float64(res.(int))
			case int64:
				rest = float64(res.(int64))
			case int32:
				rest = float64(res.(int32))
			case int16:
				rest = float64(res.(int16))
			case int8:
				rest = float64(res.(int8))
			}
			//fmt.Printf("==============oo %+v  %+v    %+v\n", res,rest,formula["nutrition"].(string))
			switch formula["nutrition"].(string) {
			case "ADF %DM":
				resmap["adf"] = resmap["adf"] + rest
			case "NDF %DM":
				resmap["ndf"] = resmap["ndf"] + rest
			case "NFC %DM":
				resmap["nfc"] = resmap["nfc"] + rest
			//case "小肠可消化粗蛋白":
			//	resmap["cprotedm"] = resmap["cprotedm"] + rest
			case "干物质":
				resmap["dry"] = resmap["dry"] + rest
			case "淀粉":
				resmap["starch"] = resmap["starch"] + rest
			case "磷":
				resmap["p"] = resmap["p"] + rest
			case "粗料中的NDF %DM":
				resmap["cndf"] = resmap["cndf"] + rest
			case "粗料比例":
				resmap["jcrate"] = resmap["jcrate"] + rest
			case "粗蛋白":
				resmap["cp"] = resmap["cp"] + rest
			case "能量":
				resmap["nm"] = resmap["nm"] + rest
			case "脂肪":
				resmap["fat"] = resmap["fat"] + rest
			case "钙":
				resmap["ca"] = resmap["ca"] + rest
			case "饲料转化效率，标准乳/干物质":
				resmap["trans4f"] = resmap["trans4f"] + rest
			case "饲料转化效率，标准乳/干物质3.5":
				resmap["trans35f"] = resmap["trans35f"] + rest
			}

		default:
			fmt.Printf("===============%T \n", res)
		}
	}
	if resmap["dry"] == 0 { //粗蛋白%dm = 粗蛋白/干物质
		resmap["cpd"] = 0
		resmap["cad"] = 0
		resmap["pd"] = 0
		resmap["nuint"] = 0
		resmap["nmd"] = 0

	} else {
		resmap["cpd"] = resmap["cp"] / resmap["dry"] / 10
		resmap["cad"] = resmap["ca"] / resmap["dry"] / 10
		resmap["pd"] = resmap["p"] / resmap["dry"] / 10
		resmap["nuint"] = resmap["nm"] / 3.138
		resmap["nmd"] = resmap["nm"] * 0.2389 / resmap["dry"]
	}
	for key, value := range resmap {
		va, _ := strconv.ParseFloat(fmt.Sprintf("%.3f", value), 64)
		resAll[key] = va
	}
	for key, value := range resmapstr {
		//println(key, value)
		resAll[key] = value
	}
	resAll["uprice"] = ""
	resAll["upriced"] = ""
	resAll["kprice"] = ""
	return resAll, nil

}

func PraseFormula(formula string, nur *Nur) (interface{}, error) {
	str := formula
	str = strings.ReplaceAll(str, "日增重", strconv.FormatFloat(nur.Dayw, 'f', -1, 64))
	//str = strings.ReplaceAll(str, "体重",  nur.Bw)
	str = strings.ReplaceAll(str, "怀孕天数", strconv.FormatFloat(nur.Dayspre, 'f', -1, 64))
	str = strings.ReplaceAll(str, "产量", strconv.FormatFloat(nur.Product, 'f', -1, 64))

	str = strings.ReplaceAll(str, "乳脂率", strconv.FormatFloat(nur.Fat, 'f', -1, 64))
	str = strings.ReplaceAll(str, "乳蛋白率", strconv.FormatFloat(nur.Pro, 'f', -1, 64))
	str = strings.ReplaceAll(str, "乳糖率", strconv.FormatFloat(nur.Lactose, 'f', -1, 64))
	str = strings.ReplaceAll(str, "标准乳", strconv.FormatFloat(0.35*nur.Product+15*nur.Fat/100*nur.Product, 'f', -1, 64)) // 3.5乳脂率
	//str = strings.ReplaceAll(str, "标准乳", strconv.FormatFloat(0.35*nur.Product+18.57*nur.Fat/100*nur.Product, 'f', -1, 64))
	//println("标准乳--",strconv.FormatFloat(0.4*nur.Product+15*nur.Fat/100*nur.Product, 'f', -1, 64))
	str = strings.ReplaceAll(str, "泌乳天数", strconv.FormatFloat(nur.Avgdim, 'f', -1, 64))
	str = strings.ReplaceAll(str, "月龄", strconv.FormatFloat(nur.Avgmonthage, 'f', -1, 64))
	str = strings.ReplaceAll(str, "温度", strconv.FormatFloat(nur.Tem, 'f', -1, 64))
	str = strings.ReplaceAll(str, "胎次", strconv.FormatFloat(nur.Fetal, 'f', -1, 64))
	str = strings.ReplaceAll(str, "体重", strconv.FormatFloat(nur.Bw, 'f', -1, 64))

	str = strings.ReplaceAll(str, "Math.pow", "Mathpow")
	str = strings.ReplaceAll(str, "Math.round", "Mathround")
	str = strings.ReplaceAll(str, "Math.log", "Mathlog")
	str = strings.ReplaceAll(str, "Math.exp", "Mathexp")

	//str := "(体重>200?4.2/0.55*Math.pow(体重,0.75):3.5/0.55*Math.pow(体重,0.75))"
	functions := map[string]govaluate.ExpressionFunction{
		"strlen": func(args ...interface{}) (interface{}, error) {
			length := len(args[0].(string))
			return (float64)(length), nil
		},
		"Mathpow": func(args ...interface{}) (interface{}, error) {
			c := math.Pow(args[0].(float64), args[1].(float64))
			return (float64)(c), nil
		},
		"Mathround": func(args ...interface{}) (interface{}, error) {
			c := math.Round(args[0].(float64))
			return (float64)(c), nil
		},
		"Mathlog": func(args ...interface{}) (interface{}, error) {
			c := math.Log(args[0].(float64))
			return (float64)(c), nil
		},
		"Mathexp": func(args ...interface{}) (interface{}, error) {
			c := math.Exp(args[0].(float64))
			return (float64)(c), nil
		},
	}

	expression, err := govaluate.NewEvaluableExpressionWithFunctions(str, functions)
	if err != nil {
		return 0, err
	}
	//fmt.Printf("== %+v\n", str)
	result, err := expression.Evaluate(nil)
	//fmt.Printf("== %+v\n", result)
	if err != nil || result == nil {
		return 0, err
	}
	return result, err
}

func HttpPostData(url, RequestMethod, parammaps string, tx *xorm.Session) string {
	fsion := gofasion.NewFasion(parammaps)
	sqlnamestr := fsion.Get("name").ValueStr()
	sqlnamestr1 := fsion.Get("name1").ValueStr()
	offset := fsion.Get("offset").ValueDefaultInt(0)
	pagecount := fsion.Get("pagecount").ValueDefaultInt(0)
	returntype := fsion.Get("returntype").ValueDefaultStr("map")

	sql, p := restful.GetSqlByNameDBT(sqlnamestr, tx)
	sql1, p1 := restful.GetSqlByNameDBT(sqlnamestr1, tx)
	body := []byte("")
	if sql != "" {
		s_params := make([]interface{}, 0)
		if fsion.HasKey("parammaps") {
			parammaps := fsion.Get("parammaps")
			paramslist := strings.Split(p, ",")
			if len(paramslist) > 0 && p != "" {
				for _, value := range paramslist {
					s_params = append(s_params, parammaps.Get(strings.Trim(value, " ")).ValueStr())
				}
			}
		}
		queryData, err := getDataBySqlT(sql, offset, pagecount, returntype, s_params, tx)
		if err != nil {

		} else {
			paramslist1 := strings.Split(p1, ",")
			for index, value := range queryData.(map[string]interface{})["list"].([]map[string]interface{}) {
				s_params1 := make([]interface{}, 0)
				if len(paramslist1) > 0 && p1 != "" {
					for _, v := range paramslist1 {
						s_params1 = append(s_params1, value[strings.ToLower(strings.Trim(v, " "))])
					}
				}
				arr, _ := tx.SQL(sql1, s_params1...).QueryString() //获取
				queryData.(map[string]interface{})["list"].([]map[string]interface{})[index]["arrList"] = arr
				body, _ = json.Marshal(queryData)
			}
		}

	}

	bs := bytes.NewBuffer(body)
	client := &http.Client{}
	//body1 := bytes.NewBuffer([]byte("{\"username\":\"00028\",\"password\":\"123456\"}"))
	req, err := http.NewRequest(RequestMethod,
		url,
		bs,
	)
	if err != nil {

	}
	req.Header.Set("Content-Type", "application/json;charset=utf-8")
	req.Header.Set("token", "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6IjAwMDI4IiwicGFzc3dvcmQiOiJlMTBhZGMzOTQ5YmE1OWFiYmU1NmUwNTdmMjBmODgzZSIsImV4cCI6MTYxOTM4NjU0MiwiaXNzIjoiaHR0cHM6Ly9naXRodWIuY29tL2twdHl1bi9nby1hZG1pbi8ifQ.sJwnE9HTOVnDNOaeHqOQzi7cSydYkWS4uQHxtjY7UMY")
	if err != nil {
		// handle error
	}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println(err)
		return ""
	}

	defer resp.Body.Close()

	result_body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println(err)
		return ""
	}

	fmt.Println(string(result_body))
	return ""
}