tmrgo/.svn/pristine/e8/e8376e37ea1c93cf051ccffa291b8a20719542b9.svn-base

package api

import (
	"../../pkg/app"
	"../../pkg/e"
	"../../pkg/logging"
	"../../pkg/setting"
	"../../routers/restful"
	"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
	}
	msg, err := restful.Engine.SQL("SELECT msg FROM err_msg where err = ? ", errstr).QueryString()
	if err != nil {
		msgstr = errstr
		return
	}
	if msg == nil {
		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 msg=msg", 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":
		temstr = sqlnamestr
	default:
		temstr = sqlnamestr[:10]
	}

	switch temstr {
	case "getAccurac", "getFeedEff":
		queryData, err = getAccuracy(queryList) // 不定参数
	case "getprocess", "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)//固定维度 牧场
	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 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{})
	mapc := make(map[interface{}]interface{})
	data3 := []interface{}{}
	datamap2child := make(map[string]interface{})
	data2 := []interface{}{}
	data1 := []interface{}{}
	a := 0
	var dtem interface{}

	count := 0
	maxi := 0
	var max interface{}
	for i := 0; i < len(queryList); i++ {
		if max != queryList[i]["fname"] {
			mapc[count] = max
			max = queryList[i]["fname"]
			if maxi < count {
				maxi = count
			}
			count = 0
		}
		count++
	}
	mapc[count] = max
	if maxi < count {
		maxi = count
	}

	for i := 0; i < len(queryList); i++ {
		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{})
			a = 0
		}
		if mapc[maxi] == queryList[i]["fname"] {
			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{})
	mapc := make(map[interface{}]interface{})
	data3 := []interface{}{}
	datamap2child := make(map[string]interface{})
	data2 := []interface{}{}
	data1 := []interface{}{}
	a := 0
	var dtem interface{}

	count := 0
	maxi := 0
	var max interface{}
	for i := 0; i < len(queryList); i++ {
		if max != queryList[i]["fname"] {
			mapc[count] = max
			max = queryList[i]["fname"]
			if maxi < count {
				maxi = count
			}
			count = 0
		}
		count++
	}
	mapc[count] = max
	if maxi < count {
		maxi = count
	}

	for i := 0; i < len(queryList); i++ {
		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{})
			a = 0
		}
		if mapc[maxi] == queryList[i]["fname"] {
			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]["饲料名称"]
		a = a + 4

	}

	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 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 := []interface{}{}
	e2 := []string{}

	for _, value := range queryList {
		if _, ok := t1[value["名称"]]; !ok {
			e1 = append(e1, value["名称"])
		}
		if _, ok := t2[value["日期"]]; !ok {
			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))
			if a < len(e2)-1 {
				if e2[a] != queryList[i]["日期"].(string) {
					for ; dates.Format("2006-01-02") < e2[a]; dates = dates.Add(24 * time.Hour) {
						println("======", dates.Format("2006-01-02"), e2[a])
						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"], "")
			println(k)
		}
	}
	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()
		}
	}()

	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 && p != "" {
					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)
	}
}

// @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
	}
	sqlnamestr := params.Get("name")
	sheetname := params.Get("sheetname")
	importParams := params.Get("importParams")
	dateParams := params.Get("dateParams")
	requiredParams := params.Get("requiredParams")
	logging.Info("ImportExcel ", c.Keys, c.Request.RemoteAddr, sqlnamestr)
	sql, _ := restful.GetSqlByNameDB(sqlnamestr)
	paramslist := strings.Split(importParams, ",")
	dateParamslist := strings.Split(dateParams, ",")
	requiredParamslist := strings.Split(requiredParams, ",")
	paramslist = append(paramslist, "jwt_username")
	queryData := make([]interface{}, 0)

	xlsx1, err := excelize.OpenReader(file)
	if err != nil {
		fmt.Println(err)
		return
	}
	ok := 0
	error := 0

	rows, _ := xlsx1.GetRows(sheetname)
	if len(rows) > 1000 {
		rows = rows[:1000]
	}
	//fmt.Println("============================",rows)
	for i, row := range rows {
		fmt.Println("============================", row)
		if i > 0 {
			if len(paramslist) > 0 {
				s_params := make([]interface{}, 0)
				entry := make(map[string]interface{})
				outentry := make(map[string]interface{})
				inputdata = ""
				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 {
						for j, colCell := range rows[0] {
							if strings.Trim(value, " ") == colCell {
								for k, colCell1 := range row {
									if j == k {
										outentry[colCell] = colCell1
										entry[colCell] = colCell1
										//inputdata = inputdata + colCell + ":" + colCell1 + ";"
									}
								}
							}
						}
						s_params = append(s_params, entry[strings.Trim(value, " ")])
					}
				}
				for _, v := range dateParamslist {
					if d, ok := outentry[strings.Trim(v, " ")]; ok  {
						outentry[strings.Trim(v, " ")] = TransfTime(d.(string))
					}
					println(outentry[strings.Trim(v, " ")].(string))
				}
				a := ""
				for _, v := range requiredParamslist {
					if d, ok := outentry[strings.Trim(v, " ")]; !ok || d ==""  {
						a = strings.Trim(v, " ")
						break
					}
				}
				outentry["input"] = inputdata
				if a != ""{
					outentry["error_msg"] = a+" 未填或格式错误"
					error++
					queryData = append(queryData, outentry)
					continue
				}


				//	returnmsg, err := execDataBySql(sqlApi.Sqlstr, s_params)
				returnmsg, err := getDataBySql(sql, 0, 0, "4", s_params)

				returnmsgmap, _ := returnmsg.(map[string]interface{})
				returnmsgmap1, _ := returnmsgmap["list"].([]map[string]interface{})
				if err != nil {
					outentry["error_msg"] = err.Error()
					error++
					queryData = append(queryData, outentry)
				} else if (len(returnmsgmap1) > 0) && (returnmsgmap1[0]["msg"] == "success") {
					ok++
				} else {
					msg := geterrmsg(returnmsgmap1[0]["msg"].(string))
					//appG.Response(http.StatusOK, e.ERROR, msg)
					outentry["error_msg"] = msg
					error++
					queryData = append(queryData, outentry)
				}
			}
		}
	}
	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{
	if timestr == ""{
		return ""
	}
	days,err := strconv.Atoi(timestr)
	if err != nil {
		if len(timestr) == 8  && strings.Count(timestr,"-") == 2{
			return "20"+timestr[6:]+"-"+ timestr[:5]
		}
		if len(timestr) == 10  && (strings.Count(timestr,"-") == 2 || strings.Count(timestr,"/") == 2){
			return timestr
		}
		return ""
	}
	times , _ := time.Parse("2006-01-02","1899-12-30")
	times = times.AddDate(0,0,days)

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

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()
		}
	}()
	//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)
	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("mapResult======%+v\n", mapResult)
					//fmt.Printf("%v+\n",value["content"].(string))
					temap := make(map[string]interface{})
					tem := mapResult["layout"].([]interface{})
					fmt.Printf("tem======%+v\n", tem)
					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 {
								println("va2==-----------======", va)
								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)
								}
								//println("mapTem========== ", mapTem)
								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{},22)

	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)> 7*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` = ? 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 {
			if key==len(barids)-1{
				dates =  append(dates,value["date"].(string))
			}
			parammaps["date"] = value["date"]
			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)> 7*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 {
			h,_ =strconv.ParseFloat(restemSH[0]["actualweightminus"].(string),64)
			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
	}

	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
}