XT_New/controllers/supply_order_api_contorller.go

package controllers

import (
	"XT_New/enums"
	"XT_New/models"
	"XT_New/service"
	"XT_New/utils"
	"encoding/json"
	"fmt"
	"github.com/astaxie/beego"
	"github.com/jinzhu/gorm"
	"reflect"
	"strconv"
	"strings"
	"time"
)

type SupplyOrderApiController struct {
	BaseAuthAPIController
}

func SupplyOrderApiRegistRouters() {
	//获取供应商列表GetSupplyList
	beego.Router("/api/supply/getsupplylist", &SupplyOrderApiController{}, "get:GetSupplyList")
	//保存供应商及联系人（用于更改）
	beego.Router("/api/supply/updatesupply", &SupplyOrderApiController{}, "post:UpdateSupply")
	//删除单条联系人
	beego.Router("/api/supply/delcontactone", &SupplyOrderApiController{}, "get:DelContactOne")
	//获取单条供应商和涉及到的联系人记录
	beego.Router("/api/supply/getsupplyandcontactone", &SupplyOrderApiController{}, "get:GetSupplyAndContactOne")
	//获取供应商类别
	beego.Router("/api/supply/getsupplytype", &SupplyOrderApiController{}, "get:GetSupplyType")
	//删除供应商及联系人
	beego.Router("/api/supply/delsupply", &SupplyOrderApiController{}, "post:DelSupply")
	//获取供应商编码
	beego.Router("/api/supply/getsupplycode", &SupplyOrderApiController{}, "get:GetSupplyCode")
	//保存供应商及联系人（用于新增）
	beego.Router("/api/supply/savesupply", &SupplyOrderApiController{}, "post:SaveSupply")

	beego.Router("/api/supply/getinitorder", &SupplyOrderApiController{}, "get:GetInitOrder")
	//保存购货订单
	beego.Router("/api/supply/savepurchaseorder", &SupplyOrderApiController{}, "post:SavePurchaseOrder")
	//获取所有供应商
	beego.Router("/api/supply/getallsupply", &SupplyOrderApiController{}, "get:GetAllSupply")
	//获取供应商订单列表
	beego.Router("/api/supply/getallpurchaseorderlist", &SupplyOrderApiController{}, "get:GetAllPurchaseOrderList")
	//修改购货订单
	beego.Router("/api/supply/updatepurchaseorder", &SupplyOrderApiController{}, "Post:UpdatePurchaseOrder")
	//审核购货订单
	beego.Router("/api/supply/checkpurchaseorder", &SupplyOrderApiController{}, "get:UpdateSupplyWaresing")
	//获取购货订单详情
	beego.Router("/api/supply/getpurchaseorderdetail", &SupplyOrderApiController{}, "get:GetPurchaseOrderDetail")
	//新增购货单
	beego.Router("/api/supply/addgoodorder", &SupplyOrderApiController{}, "post:AddGoodOrder")
	//获取购货单列表
	beego.Router("/api/supply/getallgoodorderlist", &SupplyOrderApiController{}, "Get:GetAllGoodOderList")
	//修改购货订单详情
	beego.Router("/api/supply/getgoodorderdetail", &SupplyOrderApiController{}, "Get:GetGoodOrderDetail")
	//修改购货订单
	beego.Router("/api/supply/updategoodorder", &SupplyOrderApiController{}, "Post:UpdateGoodOrder")
	//删除购货订单
	beego.Router("/api/supply/deletepurchorder", &SupplyOrderApiController{}, "Get:DeletePurchOrder")
	//生成购货单的判断
	beego.Router("/api/supply/getallordercountlist", &SupplyOrderApiController{}, "Get:GetAllOrderCountList")
	// 生成购货单
	beego.Router("/api/supply/getpurchaseorderinfo", &SupplyOrderApiController{}, "Get:GetPurchOrderInfo")
	//反审核 获取关联的购货单数据
	beego.Router("/api/supply/getgoodorderlist", &SupplyOrderApiController{}, "Get:GetGoodOrderList")
	//反审核购货订单
	beego.Router("/api/supply/getreturnorder", &SupplyOrderApiController{}, "Get:GetReturnOrder")
	//判断是否全部入库
	beego.Router("/api/supply/getgoodordercountlist", &SupplyOrderApiController{}, "Get:GetGoodOrderCountList")
	//修改购货订单入库状态
	beego.Router("/api/supply/modefysupplywarehousing", &SupplyOrderApiController{}, "Get:ModefySupplyWarehousing")
	//保存退货单
	beego.Router("/api/supply/savegoodreturnOrder", &SupplyOrderApiController{}, "Post:SaveGoodReturnOrder")
	//获取退货单列表
	beego.Router("/api/supply/getallgoodreturnorderlist", &SupplyOrderApiController{}, "Get:GetAllGoodReturnOrderList")
	//获取退库详情
	beego.Router("/api/supply/getgoodreturndetail", &SupplyOrderApiController{}, "Get:GetGoodReturnDetail")
	//修改退库
	beego.Router("/api/supply/updategoodreturn", &SupplyOrderApiController{}, "Post:UpdateGoodReturn")
	//反审核采购单
	beego.Router("/api/supply/mofygoodorder", &SupplyOrderApiController{}, "Get:ModefyGoodOrder")
	//更改入库状态
	beego.Router("/api/supply/updatesupplywarehousing", &SupplyOrderApiController{}, "Get:UpdateSupplyWarehousing")
	//删除购货单
	beego.Router("/api/supply/deletegoodorder", &SupplyOrderApiController{}, "Get:DeleteGoodOrder")
	//生成采购退货单数据
	beego.Router("/api/supply/getsupplywarehouseoutbyid", &SupplyOrderApiController{}, "Get:GetSupplyWarehouseById")
}

//判断前端参数是否为空
func CheckParams(this *SupplyOrderApiController, m *map[string][]string) (map[string]string, error) {
	tmp := make(map[string]string)
	for k, v := range *m {
		t := this.GetString(k)
		if v[0] == "must" && t == "" {
			return nil, fmt.Errorf(v[2] + "不能为空")
		}
		tmp[k] = t
	}
	return tmp, nil
}

//获取供应商列表GetSupplyList
func (this *SupplyOrderApiController) GetSupplyList() {
	ctype, _ := this.GetInt64("ctype") //供应商类别
	page, _ := this.GetInt64("page")   //页码
	limit, _ := this.GetInt64("limit") //每一页查出来的条数
	check := map[string][]string{
		"page":  {"must", "string", "page"},
		"limit": {"must", "string", "limit"},
	}
	_, err := CheckParams(this, &check)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, err.Error())
	}
	//if page == 0 || limit == 0 {
	//	this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "page或limit参数不能为空")
	//	return
	//}
	keyword := this.GetString("keyword") //供应商编号\供应商名称\联系人名字
	orgId := this.GetAdminUserInfo().CurrentOrgId
	//获取分页的数据
	list, total, err := service.GetSupplyList(ctype, page, limit, keyword)
	//获取供应商类别
	costClassify := "供应商类别"
	drugTypeParent, _ := service.GetDrugDataConfig(0, costClassify)
	drugTypeList, _ := service.GetParentDataConfig(drugTypeParent.ID, orgId)
	tmpmap := make(map[int64]string)    //储存供应商类别
	namemap := make(map[string]string)  //储存首要联系人
	phonemap := make(map[string]string) //手机号
	for i := 0; i < len(drugTypeList); i++ {
		k := int64(drugTypeList[i].Value)
		v := drugTypeList[i].Name
		tmpmap[k] = v
	}
	if err == nil {
		for i := 0; i < len(list); i++ {
			code := list[i].SupplierCode
			fistname, errs := service.FindName(code)
			if errs != nil && errs.Error() != "record not found" {
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
				return
			}
			namemap[code] = fistname.Name
			phonemap[code] = fistname.Phone
		}
		type SpSupplierNameList struct { //基于SpSupplierName结构体修改的，为了方便前端取数据整合了一下，删除了几个用不到的字段，添加了联系人名字和供应商类别两个字段
			ID           int64
			SupplierCode string
			SupplierName string
			SupplierType int64
			VatRate      float64
			Number       string
			Bank         string
			BankAccount  string
			UserOrgId    int64
			Status       int64
			ContactsId   int64
			ConName      string //供应商主要联系人名字
			TypeName     string //供应商类别
			Phone        string //电话
		}
		//初始化该结构体
		tmplist := []*SpSupplierNameList{}
		for i := 0; i < len(list); i++ {
			var typename string //类别名称
			if list[i].SupplierType == 0 {
				typename = ""
			} else {
				typename = tmpmap[list[i].SupplierType]
			}
			tlist := &SpSupplierNameList{
				list[i].ID,
				list[i].SupplierCode,
				list[i].SupplierName,
				list[i].SupplierType,
				list[i].VatRate,
				list[i].Number,
				list[i].Bank,
				list[i].BankAccount,
				list[i].UserOrgId,
				list[i].Status,
				list[i].ContactsId,
				namemap[list[i].SupplierCode],
				typename,
				phonemap[list[i].SupplierCode],
			}
			tmplist = append(tmplist, tlist)

		}
		this.ServeSuccessJSON(map[string]interface{}{
			"list":  tmplist,
			"total": total,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

//保存供应商及联系人（用于更改）
func (this *SupplyOrderApiController) UpdateSupply() {
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	supplierName := dataBody["suppliername"].(string)
	if supplierName == "" {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商名称不能为空")
		return
	}
	//upplierCode := this.GetString("suppliercode") //供应商编码
	supplierCode := dataBody["suppliercode"].(string)
	if supplierCode == "" {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商编号不能为空")
		return
	}
	//supplierid, _ := this.GetInt64("id") //供应商id
	//fmt.Println(dataBody["id"])
	//utils.InfoLog("+++++++++++++前++++++++++++++++++", dataBody["id"])
	supplierid := int64(dataBody["id"].(float64))
	//utils.InfoLog("+++++++++++++后++++++++++++++++++", supplierid)
	if supplierid == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商id不能为空")
		return
	}
	//查询供应商的信息
	supply, err := service.GetSupplyOne(supplierid)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	if supplierName != supply.SupplierName {
		//判断供应商名称是否有重复的
		sbool, _ := service.FindSupplierName(supplierName)
		if sbool { //有重复的
			this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商名称重复")
			return
		}
	}
	if supplierCode != supply.SupplierCode {
		//判断供应商编号是否有重复的
		codebool, _ := service.FindSupplierCode(supplierCode)
		if codebool {
			this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商编号重复")
			return
		}
	}
	//supplierType, _ := this.GetInt64("suppliertype") //供应商类别
	if dataBody["suppliertype"] == "" || dataBody["suppliertype"] == 0 {
		var tmp float64 = 0
		dataBody["suppliertype"] = tmp
	}
	if dataBody["vatrate"] == "" {
		dataBody["vatrate"] = 0
	}
	supplierType := int64(dataBody["suppliertype"].(float64)) //供应商类别
	//vatRate, _ := this.GetFloat("vatrate")           //增值税税率
	vatRate, _ := dataBody["suppliertype"].(float64) //增值税税率
	//number := this.GetString("number")               //纳税人识别号
	number := dataBody["number"].(string) //纳税人识别号
	//bank := this.GetString("bank")                   //开户银行
	bank := dataBody["bank"].(string) //纳税人识别号
	//bankAccount := this.GetString("bankAccount")     //银行账号
	bankAccount := dataBody["bankaccount"].(string)
	orgId := this.GetAdminUserInfo().CurrentOrgId
	//contacts := this.Get("contacts")//联系人
	//dataBody := make(map[string]interface{}, 0)
	//err = json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	//if err != nil {
	//	utils.ErrorLog(err.Error())
	//	this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
	//	return
	//}
	//保存联系人
	if dataBody["contacts"] != nil && reflect.TypeOf(dataBody["contacts"]).String() == "[]interface {}" {
		thisStockIn, _ := dataBody["contacts"].([]interface{})
		if len(thisStockIn) > 0 {
			if len(thisStockIn) == 1 {
				for _, item := range thisStockIn {
					items := item.(map[string]interface{})
					items["is_first"] = 1
				}
			}
			tmodify := this.GetAdminUserInfo().AdminUser.Id
			err = service.UpdateSupplyAndContact(thisStockIn, supplierid, orgId, supplierType, tmodify, supplierCode, supplierName, number, bank, bankAccount, vatRate)
			if err != nil {
				this.ServeFailJsonSend(enums.ErrorCodeParamWrong, err.Error())
				return
			}
		} else {
			this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "联系人不能为空")
			return
		}
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": "保存成功",
	})
	return
}

//获取单条供应商和涉及到的联系人记录
func (this *SupplyOrderApiController) GetSupplyAndContactOne() {
	id, _ := this.GetInt64("id")
	check := map[string][]string{
		"id": {"must", "string", "id"},
	}
	_, err := CheckParams(this, &check)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, err.Error())
	}
	//if id == 0 {
	//	this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商id不能为空")
	//	return
	//}
	supply, contact, err := service.GetSupplyAndContactOne(id)
	//获取供应商类别
	orgId := this.GetAdminUserInfo().CurrentOrgId
	costClassify := "供应商类别"
	drugTypeParent, _ := service.GetDrugDataConfig(0, costClassify)
	drugTypeList, _ := service.GetParentDataConfig(drugTypeParent.ID, orgId)
	tmpmap := make(map[int64]string) //储存供应商类别
	for i := 0; i < len(drugTypeList); i++ {
		k := int64(drugTypeList[i].Value)
		v := drugTypeList[i].Name
		tmpmap[k] = v
	}
	type SpSupplierNameList struct { //基于SpSupplierName结构体修改的，为了方便前端取数据整合了一下，删除了几个用不到的字段，添加了联系人名字和供应商类别两个字段
		Id           int64   `json:"id"`
		Suppliercode string  `json:"suppliercode"`
		Suppliername string  `json:"suppliername"`
		Suppliertype int64   `json:"suppliertype"`
		Vatrate      float64 `json:"vatrate"`
		Number       string  `json:"number"`
		Bank         string  `json:"bank"`
		Bankaccount  string  `json:"bankaccount"`
		Userorgid    int64   `json:"userorgid"`
		Status       int64   `json:"status"`
		Contactsid   int64   `json:"contactsid"`
		Typename     string  `json:"typename"` //供应商类别
	}

	var typename string //类别名称
	if supply.SupplierType == 0 {
		typename = ""
	} else {
		typename = tmpmap[supply.SupplierType]
	}
	tlist := &SpSupplierNameList{
		supply.ID,
		supply.SupplierCode,
		supply.SupplierName,
		supply.SupplierType,
		supply.VatRate,
		supply.Number,
		supply.Bank,
		supply.BankAccount,
		supply.UserOrgId,
		supply.Status,
		supply.ContactsId,
		typename,
	}
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	fmt.Println(tlist)
	this.ServeSuccessJSON(map[string]interface{}{
		"supply":  tlist,
		"contact": contact,
	})
	return
}

//获取供应商类别
func (this *SupplyOrderApiController) GetSupplyType() {
	orgId := this.GetAdminUserInfo().CurrentOrgId
	costClassify := "供应商类别"
	drugTypeParent, _ := service.GetDrugDataConfig(0, costClassify)
	drugTypeList, _ := service.GetParentDataConfig(drugTypeParent.ID, orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": drugTypeList,
	})
	return
}

//删除供应商及联系人
func (this *SupplyOrderApiController) DelSupply() {
	//拿到供应商的id
	suid, _ := this.GetInt64("id")
	if suid == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商id不能为空")
		return
	}
	supply := models.SpSupplierName{
		ID: suid,
	}
	err := service.DelSupply(supply)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": "删除成功",
	})
	return
}

//删除单条联系人记录
func (this *SupplyOrderApiController) DelContactOne() {
	id, _ := this.GetInt64("id")
	if id == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "联系人id不能为空")
		return
	}
	err := service.DelContactOne(id)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": "删除成功",
	})
	return
}

//获取供应商编码
func (this *SupplyOrderApiController) GetSupplyCode() {
	supply, err := service.GetSuppliyCode()
	if err != nil {
		return
	}
	if len(supply) == 0 { //如果数据库中没有gys类型的编码则设置默认值
		//supply[0].SupplierCode ="gys001"
		supply = []*models.SpSupplierName{
			{
				SupplierCode: "gys001",
			},
		}
	} else { //获取数据库中最大的编码值，并加一
		tmp := supply[0].SupplierCode
		tmp = tmp[3:]
		var code int
		code, err = strconv.Atoi(tmp)
		code++
		tmp = strconv.Itoa(code)
		for len(tmp) < 3 {
			tmp = "0" + tmp
		}
		tmp = "gys" + tmp
		supply[0].SupplierCode = tmp
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"supplycode": supply,
	})
	return
}

//保存供应商
func (this *SupplyOrderApiController) SaveSupply() {
	//supplierName := this.GetString("suppliername") //供应商名称
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	supplierName := dataBody["suppliername"].(string)
	if supplierName == "" {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商名称不能为空")
		return
	}
	//判断供应商名称是否有重复的
	sbool, _ := service.FindSupplierName(supplierName)
	if sbool { //有重复的
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商名称重复")
		return
	}
	//supplierCode := this.GetString("suppliercode") //供应商编码
	supplierCode := dataBody["suppliercode"].(string) //供应商编码
	if supplierCode == "" {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商编号不能为空")
		return
	}
	//判断供应商编号是否有重复的
	codebool, _ := service.FindSupplierCode(supplierCode)
	if codebool {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商编号重复")
		return
	}
	if dataBody["suppliertype"] == "" {
		var tmp int64 = 0
		dataBody["suppliertype"] = tmp
	}
	if dataBody["vatrate"] == "" {
		dataBody["vatrate"] = 0
	}
	//supplierType, _ := this.GetInt64("suppliertype")
	if dataBody["suppliertype"] == "" || dataBody["suppliertype"] == 0 {
		var tmp float64 = 0
		dataBody["suppliertype"] = tmp
	}
	supplierType := int64(dataBody["suppliertype"].(float64)) //供应商类别
	//vatRate, _ := this.GetFloat("vatrate")
	vatRate, _ := dataBody["suppliertype"].(float64) //增值税税率
	//number := this.GetString("number")
	number := dataBody["number"].(string)
	//bank := this.GetString("bank")
	bank := dataBody["bank"].(string)
	//bankAccount := this.GetString("bankAccount")
	bankAccount := dataBody["bankaccount"].(string)
	orgId := this.GetAdminUserInfo().CurrentOrgId
	//contacts := this.Get("contacts")//联系人
	//err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	//if err != nil {
	//	utils.ErrorLog(err.Error())
	//	this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
	//	return
	//}
	//保存联系人
	if dataBody["contacts"] != nil && reflect.TypeOf(dataBody["contacts"]).String() == "[]interface {}" {
		thisStockIn, _ := dataBody["contacts"].([]interface{})
		if len(thisStockIn) > 0 {
			if len(thisStockIn) == 1 {
				for _, item := range thisStockIn {
					items := item.(map[string]interface{})
					items["is_first"] = 1
				}
			}
			tcreater := this.GetAdminUserInfo().AdminUser.Id
			err = service.SaveSupplyAndContact(thisStockIn, orgId, supplierType, tcreater, supplierCode, supplierName, number, bank, bankAccount, vatRate)
			if err != nil {
				this.ServeFailJsonSend(enums.ErrorCodeParamWrong, err.Error())
				return
			}
		} else {
			this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "联系人不能为空")
			return
		}
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": "保存成功",
	})
	return
}

func (this *SupplyOrderApiController) GetInitOrder() {

	orgId := this.GetAdminUserInfo().CurrentOrgId
	//获取药品库数据
	baseList, _ := service.GetSupplyDrugList(orgId)

	goodList, _ := service.GetSupplyGoodList(orgId)

	manufactuerList, _ := service.GetAllManufacturerList(orgId)

	goodTypeList, _ := service.GetAllGoodType(orgId)

	supplyList, _ := service.GetSupplierList(orgId)

	var drugType = "药品类型"
	drugTypeParent, _ := service.GetDrugDataConfig(0, drugType)
	drugTypeList, _ := service.GetParentDataConfig(drugTypeParent.ID, orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"drugList":        baseList,
		"goodList":        goodList,
		"manufactuerList": manufactuerList,
		"goodTypeList":    goodTypeList,
		"drugTypeList":    drugTypeList,
		"supplyList":      supplyList,
	})
	return
}

func (this *SupplyOrderApiController) SavePurchaseOrder() {

	supplier_id, _ := this.GetInt64("supplier_name")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}

	rate_of_concession := this.GetString("rate_of_concession")
	rate_of_concession_float, _ := strconv.ParseFloat(rate_of_concession, 64)
	discount_amount := this.GetString("discount_amount")
	discount_amount_float, _ := strconv.ParseFloat(discount_amount, 64)

	dataBody := make(map[string]interface{}, 0)

	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	//生成购货订单
	timeStr := time.Now().Format("2006-01-02")
	timeArr := strings.Split(timeStr, "-")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	total, _ := service.FindAllSupplyOrder(orgId)
	total = total + 1
	warehousing_order := "CGDD" + timeArr[0] + timeArr[1] + timeArr[2] + "00" + strconv.FormatInt(total, 10)
	recordDateStr := time.Now().Format("2006-01-02")
	recordDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
	fmt.Scan("parseDateErr", parseDateErr)
	record_date := recordDate.Unix()
	return_remake := dataBody["return_remake"].(string)
	info := models.SupplierWarehouseInfo{
		Number:           warehousing_order,
		UserOrgId:        orgId,
		Creater:          this.GetAdminUserInfo().AdminUser.Id,
		Ctime:            time.Now().Unix(),
		Mtime:            0,
		Status:           1,
		RecordDate:       record_date,
		IsCheck:          2,
		RateOfConcession: rate_of_concession_float,
		DiscountAmount:   discount_amount_float,
		DocumentDate:     startTime,
		DeliveryDate:     endTime,
		SupplierId:       supplier_id,
		IsWarehouse:      2,
		ReturnRemake:     return_remake,
	}
	err = service.CreateSupplyWarehouse(info)
	warehouseInfo, _ := service.FindLastSupplyWarehouseInfo(orgId)
	var warehousingInfo []*models.SupplierWarehousingInfoOrder

	if dataBody["stockIn"] != nil && reflect.TypeOf(dataBody["stockIn"]).String() == "[]interface {}" {
		thisStockIn, _ := dataBody["stockIn"].([]interface{})
		if len(thisStockIn) > 0 {
			for _, item := range thisStockIn {
				items := item.(map[string]interface{})

				if items["project_id"] == nil || reflect.TypeOf(items["project_id"]).String() != "float64" {
					utils.ErrorLog("project_id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				project_id := int64(items["project_id"].(float64))

				if items["supply_count"] == nil || reflect.TypeOf(items["supply_count"]).String() != "float64" {
					utils.ErrorLog("supply_count")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_count := int64(items["supply_count"].(float64))

				if items["supply_license_number"] == nil || reflect.TypeOf(items["supply_license_number"]).String() != "string" {
					utils.ErrorLog("supply_license_number")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				supply_license_number := items["supply_license_number"].(string)

				if items["supply_price"] == nil || reflect.TypeOf(items["supply_price"]).String() != "string" {
					utils.ErrorLog("supply_price")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_price := items["supply_price"].(string)

				supply_price_float, _ := strconv.ParseFloat(supply_price, 64)

				if items["supply_remake"] == nil || reflect.TypeOf(items["supply_remake"]).String() != "string" {
					utils.ErrorLog("supply_remake")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				supply_remake := items["supply_remake"].(string)

				if items["supply_total_price"] == nil || reflect.TypeOf(items["supply_total_price"]).String() != "string" {
					utils.ErrorLog("supply_total_price")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_total_price := items["supply_total_price"].(string)

				supply_total_price_float, _ := strconv.ParseFloat(supply_total_price, 64)
				if items["type"] == nil || reflect.TypeOf(items["type"]).String() != "float64" {
					utils.ErrorLog("type")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				is_source := int64(items["type"].(float64))

				if items["supply_type"] == nil || reflect.TypeOf(items["supply_type"]).String() != "string" {
					utils.ErrorLog("supply_type")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				supply_type := items["supply_type"].(string)

				if items["supply_specification_name"] == nil || reflect.TypeOf(items["supply_specification_name"]).String() != "string" {
					utils.ErrorLog("supply_specification_name")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				supply_specification_name := items["supply_specification_name"].(string)

				if items["supply_total"] == nil || reflect.TypeOf(items["supply_total"]).String() != "string" {
					utils.ErrorLog("supply_total")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				supply_total := items["supply_total"].(string)

				if items["supply_manufacturer"] == nil || reflect.TypeOf(items["supply_manufacturer"]).String() != "string" {
					utils.ErrorLog("supply_manufacturer")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				supply_manufacturer := items["supply_manufacturer"].(string)

				if items["name"] == nil || reflect.TypeOf(items["name"]).String() != "string" {
					utils.ErrorLog("name")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				name := items["name"].(string)

				if items["supply_unit"] == nil || reflect.TypeOf(items["supply_unit"]).String() != "string" {
					utils.ErrorLog("supply_unit")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				supply_unit := items["supply_unit"].(string)

				if items["manufacturer_id"] == nil || reflect.TypeOf(items["manufacturer_id"]).String() != "float64" {
					utils.ErrorLog("manufacturer_id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				manufacturer_id := int64(items["manufacturer_id"].(float64))

				order := models.SupplierWarehousingInfoOrder{
					OrderNumber:             warehousing_order,
					IsSource:                is_source,
					Count:                   supply_count,
					Price:                   supply_price_float,
					Amount:                  supply_total_price_float,
					Remark:                  supply_remake,
					UserOrgId:               orgId,
					Ctime:                   time.Now().Unix(),
					Status:                  1,
					Mtime:                   0,
					WarehousingId:           warehouseInfo.ID,
					ProjectId:               project_id,
					SupplyLicenseNumber:     supply_license_number,
					SupplyType:              supply_type,
					SupplySpecificationName: supply_specification_name,
					SupplyTotal:             supply_total,
					SupplyManufacturer:      supply_manufacturer,
					Name:                    name,
					SupplyUnit:              supply_unit,
					ManufacturerId:          manufacturer_id,
				}

				warehousingInfo = append(warehousingInfo, &order)
			}
		}
	}

	for _, item := range warehousingInfo {
		err = service.CreateSupplyWarehousingOrder(item)
	}

	//查询
	orderInfo, err := service.GetSupplyWarehousingOrderInfo(warehouseInfo.ID)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"order":         warehousingInfo,
			"warehouseInfo": warehouseInfo,
			"orderInfo":     orderInfo,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) GetAllSupply() {

	orgId := this.GetAdminUserInfo().CurrentOrgId
	appId := this.GetAdminUserInfo().CurrentAppId
	supplyList, err := service.GetSupplierList(orgId)
	doctorList, err := service.GetAllDoctorSix(orgId, appId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"supplyList": supplyList,
			"doctorList": doctorList,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) GetAllPurchaseOrderList() {

	check_id, _ := this.GetInt64("check_id")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	keyword := this.GetString("keyword")

	page, _ := this.GetInt64("page")

	limit, _ := this.GetInt64("limit")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, total, err := service.GetAllPurchaseOrderList(check_id, startTime, endTime, keyword, page, limit, orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list":  list,
			"total": total,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) UpdatePurchaseOrder() {
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	supplier_id, _ := this.GetInt64("supplier_name")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 00:00:00", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}

	rate_of_concession := this.GetString("rate_of_concession")
	rate_of_concession_float, _ := strconv.ParseFloat(rate_of_concession, 64)
	discount_amount := this.GetString("discount_amount")
	discount_amount_float, _ := strconv.ParseFloat(discount_amount, 64)
	warehousing_id, _ := this.GetInt64("id")
	number := this.GetString("number")
	return_remake := dataBody["return_remake"].(string)
	orgId := this.GetAdminUserInfo().CurrentOrgId
	info := models.SupplierWarehouseInfo{
		RateOfConcession: rate_of_concession_float,
		DiscountAmount:   discount_amount_float,
		DocumentDate:     startTime,
		DeliveryDate:     endTime,
		SupplierId:       supplier_id,
		Mtime:            time.Now().Unix(),
		ReturnRemake:     return_remake,
	}
	service.ModefySupplyWarehouseInfo(warehousing_id, info)

	var warehousingInfo []*models.SupplierWarehousingInfoOrder
	var updateWarehousingInfo []*models.SupplierWarehousingInfoOrder
	if dataBody["stockIn"] != nil && reflect.TypeOf(dataBody["stockIn"]).String() == "[]interface {}" {
		thisStockIn, _ := dataBody["stockIn"].([]interface{})
		if len(thisStockIn) > 0 {
			for _, item := range thisStockIn {
				items := item.(map[string]interface{})

				if items["id"] == nil || reflect.TypeOf(items["id"]).String() != "float64" {
					utils.ErrorLog("id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				id := int64(items["id"].(float64))

				if items["project_id"] == nil || reflect.TypeOf(items["project_id"]).String() != "float64" {
					utils.ErrorLog("project_id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				project_id := int64(items["project_id"].(float64))

				if items["supply_count"] == nil || reflect.TypeOf(items["supply_count"]).String() != "float64" {
					utils.ErrorLog("supply_count")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_count := int64(items["supply_count"].(float64))

				if items["supply_license_number"] == nil || reflect.TypeOf(items["supply_license_number"]).String() != "string" {
					utils.ErrorLog("supply_license_number")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				supply_license_number := items["supply_license_number"].(string)

				if items["supply_price"] == nil || reflect.TypeOf(items["supply_price"]).String() != "string" {
					utils.ErrorLog("supply_price")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_price := items["supply_price"].(string)

				supply_price_float, _ := strconv.ParseFloat(supply_price, 64)

				if items["supply_remake"] == nil || reflect.TypeOf(items["supply_remake"]).String() != "string" {
					utils.ErrorLog("supply_remake")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				supply_remake := items["supply_remake"].(string)

				if items["supply_total_price"] == nil || reflect.TypeOf(items["supply_total_price"]).String() != "string" {
					utils.ErrorLog("supply_total_price")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_total_price := items["supply_total_price"].(string)

				supply_total_price_float, _ := strconv.ParseFloat(supply_total_price, 64)
				if items["type"] == nil || reflect.TypeOf(items["type"]).String() != "float64" {
					utils.ErrorLog("type")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				is_source := int64(items["type"].(float64))

				if items["supply_type"] == nil || reflect.TypeOf(items["supply_type"]).String() != "string" {
					utils.ErrorLog("supply_type")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				supply_type := items["supply_type"].(string)

				if items["supply_specification_name"] == nil || reflect.TypeOf(items["supply_specification_name"]).String() != "string" {
					utils.ErrorLog("supply_specification_name")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				supply_specification_name := items["supply_specification_name"].(string)

				if items["supply_total"] == nil || reflect.TypeOf(items["supply_total"]).String() != "string" {
					utils.ErrorLog("supply_total")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				supply_total := items["supply_total"].(string)

				if items["supply_manufacturer"] == nil || reflect.TypeOf(items["supply_manufacturer"]).String() != "string" {
					utils.ErrorLog("supply_manufacturer")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				supply_manufacturer := items["supply_manufacturer"].(string)

				if items["name"] == nil || reflect.TypeOf(items["name"]).String() != "string" {
					utils.ErrorLog("name")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				name := items["name"].(string)

				if items["supply_unit"] == nil || reflect.TypeOf(items["supply_unit"]).String() != "string" {
					utils.ErrorLog("supply_unit")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}

				supply_unit := items["supply_unit"].(string)

				if items["manufacturer_id"] == nil || reflect.TypeOf(items["manufacturer_id"]).String() != "float64" {
					utils.ErrorLog("manufacturer_id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				manufacturer_id := int64(items["manufacturer_id"].(float64))
				if id > 0 {
					order := models.SupplierWarehousingInfoOrder{
						ID:                      id,
						IsSource:                is_source,
						Count:                   supply_count,
						Price:                   supply_price_float,
						Amount:                  supply_total_price_float,
						Remark:                  supply_remake,
						Ctime:                   time.Now().Unix(),
						Status:                  1,
						Mtime:                   0,
						ProjectId:               project_id,
						SupplyLicenseNumber:     supply_license_number,
						SupplyType:              supply_type,
						SupplySpecificationName: supply_specification_name,
						SupplyTotal:             supply_total,
						SupplyManufacturer:      supply_manufacturer,
						Name:                    name,
						SupplyUnit:              supply_unit,
						ManufacturerId:          manufacturer_id,
					}

					updateWarehousingInfo = append(updateWarehousingInfo, &order)
				}

				if id == 0 {

					order := models.SupplierWarehousingInfoOrder{
						OrderNumber:             number,
						IsSource:                is_source,
						Count:                   supply_count,
						Price:                   supply_price_float,
						Amount:                  supply_total_price_float,
						Remark:                  supply_remake,
						UserOrgId:               orgId,
						Ctime:                   time.Now().Unix(),
						Status:                  1,
						Mtime:                   0,
						WarehousingId:           warehousing_id,
						ProjectId:               project_id,
						SupplyLicenseNumber:     supply_license_number,
						SupplyType:              supply_type,
						SupplySpecificationName: supply_specification_name,
						SupplyTotal:             supply_total,
						SupplyManufacturer:      supply_manufacturer,
						Name:                    name,
						SupplyUnit:              supply_unit,
						ManufacturerId:          manufacturer_id,
					}
					warehousingInfo = append(warehousingInfo, &order)
				}

			}
		}
		if len(warehousingInfo) > 0 {
			for _, item := range warehousingInfo {
				service.CreateSupplyWarehousingOrder(item)
			}

		}
		if len(updateWarehousingInfo) > 0 {
			for _, item := range updateWarehousingInfo {
				service.ModifySupplyWarehouseOrder(item)
			}

		}
		this.ServeSuccessJSON(map[string]interface{}{
			"warehousingInfo": warehousingInfo,
		})

	}
}

func (this *SupplyOrderApiController) UpdateSupplyWaresing() {

	id, _ := this.GetInt64("id")
	recordDateStr := time.Now().Format("2006-01-02")
	recordDate, _ := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)

	record_date := recordDate.Unix()
	checker := this.GetAdminUserInfo().AdminUser.Id
	info := models.SupplierWarehouseInfo{
		Mtime:     time.Now().Unix(),
		Status:    1,
		IsCheck:   1,
		Checker:   checker,
		CheckTime: record_date,
	}
	parseDateErr := service.UpdateSupplyWaresing(id, info)
	if parseDateErr == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"info": info,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) GetPurchaseOrderDetail() {

	id, _ := this.GetInt64("id")
	info, _ := service.GetPurchaseOrderDetail(id)
	//查询
	orderInfo, err := service.GetSupplyWarehousingOrderInfo(id)
	orgId := this.GetAdminUserInfo().CurrentOrgId
	supplyList, _ := service.GetSupplierList(orgId)
	//获取药品库数据
	baseList, _ := service.GetSupplyDrugList(orgId)

	goodList, _ := service.GetSupplyGoodList(orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"info":       info,
			"orderInfo":  orderInfo,
			"supplyList": supplyList,
			"baseList":   baseList,
			"goodList":   goodList,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) AddGoodOrder() {
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	supplier_id, _ := this.GetInt64("supplier_id")
	start_time := this.GetString("start")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	arrerage := this.GetString("arrerage")
	arrerage_float, _ := strconv.ParseFloat(arrerage, 64)
	payment := this.GetString("payment")
	payment_float, _ := strconv.ParseFloat(payment, 64)
	warehousing_id, _ := this.GetInt64("warehousing_id")
	number := this.GetString("number")
	rate_of_concession := this.GetString("rate_of_concession")
	rate_of_concession_float, _ := strconv.ParseFloat(rate_of_concession, 64)
	discount_amount := this.GetString("discount_amount")
	discount_amount_float, _ := strconv.ParseFloat(discount_amount, 64)
	return_remake := dataBody["return_remake"].(string)
	orgId := this.GetAdminUserInfo().CurrentOrgId
	creater := this.GetAdminUserInfo().AdminUser.Id
	//生成购货单
	timeStr := time.Now().Format("2006-01-02")
	timeArr := strings.Split(timeStr, "-")
	total, _ := service.FindAllSupplyWarehouseOutOrder(orgId)
	total = total + 1
	warehousing_order := "CG" + timeArr[0] + timeArr[1] + timeArr[2] + "00" + strconv.FormatInt(total, 10)
	recordDateStr := time.Now().Format("2006-01-02")
	recordDate, _ := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)

	warehouse_out := models.SpSupplierWarehouseOut{
		Number:           number,
		UserOrgId:        orgId,
		Creater:          creater,
		Ctime:            time.Now().Unix(),
		Mtime:            0,
		Status:           1,
		RecordDate:       recordDate.Unix(),
		IsCheck:          2,
		WarehousingId:    warehousing_id,
		GoodNumber:       warehousing_order,
		Arrearage:        arrerage_float,
		Payment:          payment_float,
		RateOfConcession: rate_of_concession_float,
		DiscountAmount:   discount_amount_float,
		DocumentDate:     startTime,
		SupplierId:       supplier_id,
		Checker:          0,
		CheckTime:        0,
		ReturnRemake:     return_remake,
	}

	service.CreateSupplyWarehouseOut(warehouse_out)

	//获取最后一条
	warehouseOut, _ := service.FindSupplyWarehouseOutById(orgId)

	var warehousingOut []*models.SpSupplierWarehousingOutOrder
	if dataBody["stockIn"] != nil && reflect.TypeOf(dataBody["stockIn"]).String() == "[]interface {}" {
		thisStockIn, _ := dataBody["stockIn"].([]interface{})
		if len(thisStockIn) > 0 {
			for _, item := range thisStockIn {
				items := item.(map[string]interface{})

				if items["supply_count"] == nil || reflect.TypeOf(items["supply_count"]).String() != "float64" {
					utils.ErrorLog("supply_count")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_count := int64(items["supply_count"].(float64))

				if items["id"] == nil || reflect.TypeOf(items["id"]).String() != "float64" {
					utils.ErrorLog("id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				id := int64(items["id"].(float64))

				if items["manufacturer_id"] == nil || reflect.TypeOf(items["manufacturer_id"]).String() != "float64" {
					utils.ErrorLog("manufacturer_id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				manufacturer_id := int64(items["manufacturer_id"].(float64))

				if items["name"] == nil || reflect.TypeOf(items["name"]).String() != "string" {
					utils.ErrorLog("name")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				name := items["name"].(string)

				if items["order_number"] == nil || reflect.TypeOf(items["order_number"]).String() != "string" {
					utils.ErrorLog("order_number")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				order_number := items["order_number"].(string)

				if items["supply_price"] == nil || reflect.TypeOf(items["supply_price"]).String() != "string" {
					utils.ErrorLog("supply_price")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_price := items["supply_price"].(string)

				price_float, _ := strconv.ParseFloat(supply_price, 64)

				if items["supply_total_price"] == nil || reflect.TypeOf(items["supply_total_price"]).String() != "string" {
					utils.ErrorLog("supply_total_price")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_total_price := items["supply_total_price"].(string)

				supply_total_price_float, _ := strconv.ParseFloat(supply_total_price, 64)

				if items["project_id"] == nil || reflect.TypeOf(items["project_id"]).String() != "float64" {
					utils.ErrorLog("project_id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				project_id := int64(items["project_id"].(float64))

				if items["supply_remake"] == nil || reflect.TypeOf(items["supply_remake"]).String() != "string" {
					utils.ErrorLog("supply_remake")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_remake := items["supply_remake"].(string)

				if items["supply_batch_number"] == nil || reflect.TypeOf(items["supply_batch_number"]).String() != "string" {
					utils.ErrorLog("supply_batch_number")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_batch_number := items["supply_batch_number"].(string)

				var supply_expiry_date_time int64
				if items["supply_expiry_date"] == nil || reflect.TypeOf(items["supply_expiry_date"]).String() != "string" {
					utils.ErrorLog("supply_expiry_date")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_expiry_date := items["supply_expiry_date"].(string)

				if len(supply_expiry_date) > 0 {
					theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", supply_expiry_date+" 00:00:00", loc)
					if err != nil {
						this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
						return
					}
					supply_expiry_date_time = theTime.Unix()
				}

				if items["supply_license_number"] == nil || reflect.TypeOf(items["supply_license_number"]).String() != "string" {
					utils.ErrorLog("supply_license_number")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_license_number := items["supply_license_number"].(string)

				var supply_product_date_time int64
				if items["supply_product_date"] == nil || reflect.TypeOf(items["supply_product_date"]).String() != "string" {
					utils.ErrorLog("supply_product_date")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_product_date := items["supply_product_date"].(string)

				if len(supply_product_date) > 0 {
					theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", supply_product_date+" 00:00:00", loc)
					if err != nil {
						this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
						return
					}
					supply_product_date_time = theTime.Unix()
				}

				if items["supply_specification_name"] == nil || reflect.TypeOf(items["supply_specification_name"]).String() != "string" {
					utils.ErrorLog("supply_specification_name")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_specification_name := items["supply_specification_name"].(string)

				if items["supply_total"] == nil || reflect.TypeOf(items["supply_total"]).String() != "string" {
					utils.ErrorLog("supply_total")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_total := items["supply_total"].(string)

				if items["supply_type"] == nil || reflect.TypeOf(items["supply_type"]).String() != "string" {
					utils.ErrorLog("supply_type")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_type := items["supply_type"].(string)

				if items["supply_unit"] == nil || reflect.TypeOf(items["supply_unit"]).String() != "string" {
					utils.ErrorLog("supply_unit")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_unit := items["supply_unit"].(string)

				if items["type"] == nil || reflect.TypeOf(items["type"]).String() != "float64" {
					utils.ErrorLog("type")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				is_source := int64(items["type"].(float64))

				if items["supply_manufacturer"] == nil || reflect.TypeOf(items["supply_manufacturer"]).String() != "string" {
					utils.ErrorLog("supply_manufacturer")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_manufacturer := items["supply_manufacturer"].(string)
				order := models.SpSupplierWarehousingOutOrder{
					OrderNumber:             order_number,
					ProjectId:               project_id,
					IsSource:                is_source,
					Count:                   supply_count,
					Amount:                  supply_total_price_float,
					Price:                   price_float,
					Remark:                  supply_remake,
					IsCheck:                 2,
					UserOrgId:               orgId,
					Status:                  1,
					Ctime:                   time.Now().Unix(),
					Mtime:                   0,
					WarehouseOutId:          warehouseOut.ID,
					Type:                    1,
					SupplyBatchNumber:       supply_batch_number,
					SupplyProductDate:       supply_product_date_time,
					SupplyExpiryDate:        supply_expiry_date_time,
					WarehousingId:           warehousing_id,
					WarehouseInfoId:         id,
					SupplyType:              supply_type,
					SupplyUnit:              supply_unit,
					SupplyTotal:             supply_total,
					SupplySpecificationName: supply_specification_name,
					SupplyLicenseNumber:     supply_license_number,
					Name:                    name,
					ManufacturerId:          manufacturer_id,
					GoodNumber:              warehouseOut.GoodNumber,
					SupplyManufacturer:      supply_manufacturer,
				}
				warehousingOut = append(warehousingOut, &order)
			}
		}
	}

	for _, item := range warehousingOut {
		//如果是手动新增的，type 等于2
		if item.WarehouseInfoId == 0 {
			item.Type = 2
		}
		err = service.CreateSupplyWarehousOutOrder(item)
	}

	list, parseDateErr := service.GetSupplyWarehouseOutById(warehouseOut.ID, orgId)

	if parseDateErr == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list":         list,
			"warehouseOut": warehouseOut,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) GetAllGoodOderList() {

	check_id, _ := this.GetInt64("check_id")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	keyword := this.GetString("keyword")
	page, _ := this.GetInt64("page")
	limit, _ := this.GetInt64("limit")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 00:00:00", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()

	}
	orgId := this.GetAdminUserInfo().CurrentOrgId

	list, total, err := service.GetAllGoodOderList(check_id, keyword, page, limit, startTime, endTime, orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list":  list,
			"total": total,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) GetGoodOrderDetail() {

	id, _ := this.GetInt64("id")
	ids := this.GetString("ids")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	if len(ids) == 0 {
		out, err := service.GetGoodOrderDetail(id, orgId)
		list, _ := service.GetSupplyWarehouseOutById(id, orgId)
		drugList, _ := service.GetSupplyDrugList(orgId)
		goodList, _ := service.GetSupplyGoodList(orgId)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"out":      out,
				"list":     list,
				"goodList": goodList,
				"drugList": drugList,
			})
		} else {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		}
	}
	if len(ids) > 0 {
		idArray := strings.Split(ids, ",")
		out, err := service.GetGoodOrderDetail(id, orgId)
		list, _ := service.GetSupplyWarehouseOutByIdOne(id, orgId, idArray)
		drugList, _ := service.GetSupplyDrugList(orgId)
		goodList, _ := service.GetSupplyGoodList(orgId)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"out":      out,
				"list":     list,
				"goodList": goodList,
				"drugList": drugList,
			})
		} else {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		}
	}

}

func (this *SupplyOrderApiController) UpdateGoodOrder() {
	supplier_id, _ := this.GetInt64("supplier_id")
	start_time := this.GetString("start")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	arrerage := this.GetString("arrerage")
	arrerage_float, _ := strconv.ParseFloat(arrerage, 64)
	payment := this.GetString("payment")
	payment_float, _ := strconv.ParseFloat(payment, 64)
	warehose_out_id, _ := this.GetInt64("warehose_out_id")
	number := this.GetString("number")
	rate_of_concession := this.GetString("rate_of_concession")
	rate_of_concession_float, _ := strconv.ParseFloat(rate_of_concession, 64)
	discount_amount := this.GetString("discount_amount")
	discount_amount_float, _ := strconv.ParseFloat(discount_amount, 64)
	good_number := this.GetString("good_number")
	fmt.Println(supplier_id, startTime, arrerage, payment, warehose_out_id, number, rate_of_concession, discount_amount)
	orgId := this.GetAdminUserInfo().CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	var warehousingOut []*models.SpSupplierWarehousingOutOrder
	var updateWarehout []*models.SpSupplierWarehousingOutOrder
	return_remake := dataBody["return_remake"].(string)
	if dataBody["stockIn"] != nil && reflect.TypeOf(dataBody["stockIn"]).String() == "[]interface {}" {
		thisStockIn, _ := dataBody["stockIn"].([]interface{})
		if len(thisStockIn) > 0 {
			for _, item := range thisStockIn {
				items := item.(map[string]interface{})

				if items["id"] == nil || reflect.TypeOf(items["id"]).String() != "float64" {
					utils.ErrorLog("id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				id := int64(items["id"].(float64))

				if items["supply_count"] == nil || reflect.TypeOf(items["supply_count"]).String() != "float64" {
					utils.ErrorLog("supply_count")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_count := int64(items["supply_count"].(float64))

				if items["manufacturer_id"] == nil || reflect.TypeOf(items["manufacturer_id"]).String() != "float64" {
					utils.ErrorLog("manufacturer_id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				manufacturer_id := int64(items["manufacturer_id"].(float64))

				if items["name"] == nil || reflect.TypeOf(items["name"]).String() != "string" {
					utils.ErrorLog("name")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				name := items["name"].(string)

				if items["order_number"] == nil || reflect.TypeOf(items["order_number"]).String() != "string" {
					utils.ErrorLog("order_number")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				order_number := items["order_number"].(string)

				if items["supply_price"] == nil || reflect.TypeOf(items["supply_price"]).String() != "string" {
					utils.ErrorLog("supply_price")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_price := items["supply_price"].(string)

				price_float, _ := strconv.ParseFloat(supply_price, 64)

				if items["supply_total_price"] == nil || reflect.TypeOf(items["supply_total_price"]).String() != "string" {
					utils.ErrorLog("supply_total_price")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_total_price := items["supply_total_price"].(string)

				supply_total_price_float, _ := strconv.ParseFloat(supply_total_price, 64)

				if items["project_id"] == nil || reflect.TypeOf(items["project_id"]).String() != "float64" {
					utils.ErrorLog("project_id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				project_id := int64(items["project_id"].(float64))

				if items["supply_remake"] == nil || reflect.TypeOf(items["supply_remake"]).String() != "string" {
					utils.ErrorLog("supply_remake")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_remake := items["supply_remake"].(string)

				if items["supply_batch_number"] == nil || reflect.TypeOf(items["supply_batch_number"]).String() != "string" {
					utils.ErrorLog("supply_batch_number")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_batch_number := items["supply_batch_number"].(string)

				var supply_expiry_date_time int64
				if items["supply_expiry_date"] == nil || reflect.TypeOf(items["supply_expiry_date"]).String() != "string" {
					utils.ErrorLog("supply_expiry_date")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_expiry_date := items["supply_expiry_date"].(string)

				if len(supply_expiry_date) > 0 {
					theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", supply_expiry_date+" 00:00:00", loc)
					if err != nil {
						this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
						return
					}
					supply_expiry_date_time = theTime.Unix()
				}

				if items["supply_license_number"] == nil || reflect.TypeOf(items["supply_license_number"]).String() != "string" {
					utils.ErrorLog("supply_license_number")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_license_number := items["supply_license_number"].(string)

				var supply_product_date_time int64
				if items["supply_product_date"] == nil || reflect.TypeOf(items["supply_product_date"]).String() != "string" {
					utils.ErrorLog("supply_product_date")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_product_date := items["supply_product_date"].(string)

				if len(supply_product_date) > 0 {
					theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", supply_product_date+" 00:00:00", loc)
					if err != nil {
						this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
						return
					}
					supply_product_date_time = theTime.Unix()
				}

				if items["supply_specification_name"] == nil || reflect.TypeOf(items["supply_specification_name"]).String() != "string" {
					utils.ErrorLog("supply_specification_name")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_specification_name := items["supply_specification_name"].(string)

				if items["supply_total"] == nil || reflect.TypeOf(items["supply_total"]).String() != "string" {
					utils.ErrorLog("supply_total")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_total := items["supply_total"].(string)

				if items["supply_type"] == nil || reflect.TypeOf(items["supply_type"]).String() != "string" {
					utils.ErrorLog("supply_type")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_type := items["supply_type"].(string)

				if items["supply_unit"] == nil || reflect.TypeOf(items["supply_unit"]).String() != "string" {
					utils.ErrorLog("supply_unit")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_unit := items["supply_unit"].(string)

				if items["type"] == nil || reflect.TypeOf(items["type"]).String() != "float64" {
					utils.ErrorLog("type")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				is_source := int64(items["type"].(float64))

				if items["supply_manufacturer"] == nil || reflect.TypeOf(items["supply_manufacturer"]).String() != "string" {
					utils.ErrorLog("supply_manufacturer")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_manufacturer := items["supply_manufacturer"].(string)

				if items["warehouse_info_id"] == nil || reflect.TypeOf(items["warehouse_info_id"]).String() != "float64" {
					utils.ErrorLog("warehouse_info_id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				warehouse_info_id := int64(items["warehouse_info_id"].(float64))

				if items["warehousing_id"] == nil || reflect.TypeOf(items["warehousing_id"]).String() != "float64" {
					utils.ErrorLog("warehouse_info_id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				warehousing_id := int64(items["warehousing_id"].(float64))
				if id > 0 {
					order := models.SpSupplierWarehousingOutOrder{
						ID:                      id,
						OrderNumber:             order_number,
						ProjectId:               project_id,
						IsSource:                is_source,
						Count:                   supply_count,
						Amount:                  supply_total_price_float,
						Price:                   price_float,
						Remark:                  supply_remake,
						IsCheck:                 2,
						UserOrgId:               orgId,
						Status:                  1,
						Ctime:                   time.Now().Unix(),
						Mtime:                   0,
						WarehouseOutId:          warehose_out_id,
						Type:                    1,
						SupplyBatchNumber:       supply_batch_number,
						SupplyProductDate:       supply_product_date_time,
						SupplyExpiryDate:        supply_expiry_date_time,
						SupplyType:              supply_type,
						SupplyUnit:              supply_unit,
						SupplyTotal:             supply_total,
						SupplySpecificationName: supply_specification_name,
						SupplyLicenseNumber:     supply_license_number,
						Name:                    name,
						ManufacturerId:          manufacturer_id,
						GoodNumber:              good_number,
						SupplyManufacturer:      supply_manufacturer,
						WarehouseInfoId:         warehouse_info_id,
						WarehousingId:           warehousing_id,
					}
					updateWarehout = append(updateWarehout, &order)
				}

				if id == 0 {
					order := models.SpSupplierWarehousingOutOrder{
						OrderNumber:             order_number,
						ProjectId:               project_id,
						IsSource:                is_source,
						Count:                   supply_count,
						Amount:                  supply_total_price_float,
						Price:                   price_float,
						Remark:                  supply_remake,
						IsCheck:                 2,
						UserOrgId:               orgId,
						Status:                  1,
						Ctime:                   time.Now().Unix(),
						Mtime:                   0,
						WarehouseOutId:          warehose_out_id,
						Type:                    1,
						SupplyBatchNumber:       supply_batch_number,
						SupplyProductDate:       supply_product_date_time,
						SupplyExpiryDate:        supply_expiry_date_time,
						WarehouseInfoId:         id,
						SupplyType:              supply_type,
						SupplyUnit:              supply_unit,
						SupplyTotal:             supply_total,
						SupplySpecificationName: supply_specification_name,
						SupplyLicenseNumber:     supply_license_number,
						Name:                    name,
						ManufacturerId:          manufacturer_id,
						GoodNumber:              good_number,
						SupplyManufacturer:      supply_manufacturer,
					}
					warehousingOut = append(warehousingOut, &order)
				}

			}
		}
	}
	out := models.SpSupplierWarehouseOut{
		Arrearage:        arrerage_float,
		Payment:          payment_float,
		RateOfConcession: rate_of_concession_float,
		DiscountAmount:   discount_amount_float,
		SupplierId:       supplier_id,
		DocumentDate:     startTime,
		ReturnRemake:     return_remake,
	}
	//更改购货单据
	service.UpdateGoodWarehouseOut(warehose_out_id, out)

	for _, item := range warehousingOut {
		//如果是手动新增的，type 等于2
		if item.WarehouseInfoId == 0 {
			item.Type = 2
		}
		err = service.CreateSupplyWarehousOutOrder(item)
	}
	for _, item := range updateWarehout {

		service.UpdateGoodWarehouseOutOrder(item)
	}
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"out": out,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) DeletePurchOrder() {

	id, _ := this.GetInt64("id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	err := service.DeletePurchOrder(id, orgId)
	if err == nil {
		returnData := make(map[string]interface{}, 0)
		returnData["msg"] = "ok"
		this.ServeSuccessJSON(returnData)
		return
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}

}

func (this *SupplyOrderApiController) GetAllOrderCountList() {

	id, _ := this.GetInt64("id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	//获取购货订单的数据
	purcaseOrder, _ := service.GetAllPurcaseOrderById(id, orgId)
	//获取购货单的数据
	goodOrder, err := service.GetAllGoodOrderById(id, orgId)
	drugList, err := service.GetSupplyDrugList(orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"purcaseOrder": purcaseOrder,
			"goodOrder":    goodOrder,
			"drugList":     drugList,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) GetPurchOrderInfo() {
	id, _ := this.GetInt64("id")
	ids := this.GetString("ids")
	if len(ids) == 0 {
		info, _ := service.GetPurchaseOrderDetail(id)
		//查询
		orderInfo, err := service.GetSupplyWarehousingOrderInfo(id)
		orgId := this.GetAdminUserInfo().CurrentOrgId
		supplyList, _ := service.GetSupplierList(orgId)
		//获取药品库数据
		baseList, _ := service.GetSupplyDrugList(orgId)

		goodList, _ := service.GetSupplyGoodList(orgId)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"info":       info,
				"orderInfo":  orderInfo,
				"supplyList": supplyList,
				"baseList":   baseList,
				"goodList":   goodList,
			})
		} else {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		}
	}
	if len(ids) > 0 {
		idArray := strings.Split(ids, ",")
		info, _ := service.GetPurchaseOrderDetail(id)
		//查询
		orderInfo, err := service.GetSupplyWarehousingOrderInfoTwo(id, idArray)
		orgId := this.GetAdminUserInfo().CurrentOrgId
		supplyList, _ := service.GetSupplierList(orgId)
		//获取药品库数据
		baseList, _ := service.GetSupplyDrugList(orgId)

		goodList, _ := service.GetSupplyGoodList(orgId)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"info":       info,
				"orderInfo":  orderInfo,
				"supplyList": supplyList,
				"baseList":   baseList,
				"goodList":   goodList,
			})
		} else {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		}
	}
}

func (this *SupplyOrderApiController) GetGoodOrderList() {

	id, _ := this.GetInt64("id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, err := service.GetGoodOrderList(id, orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list": list,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) GetReturnOrder() {

	id, _ := this.GetInt64("id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	err := service.GetReturnOrder(id, orgId)
	if err == nil {
		returnData := make(map[string]interface{}, 0)
		returnData["msg"] = "ok"
		this.ServeSuccessJSON(returnData)
		return
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) GetGoodOrderCountList() {
	id, _ := this.GetInt64("id")
	warehousing_id, _ := this.GetInt64("warehousing_id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	checker := this.GetAdminUserInfo().AdminUser.Id
	recordDateStr := time.Now().Format("2006-01-02")
	recordDate, _ := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
	record_date := recordDate.Unix()
	out := models.SpSupplierWarehouseOut{
		IsCheck:   1,
		Checker:   checker,
		CheckTime: record_date,
	}
	err := service.CheckGoodOrder(id, orgId, out)
	fmt.Println(err)
	//获取购货订单的数据
	purcaseOrder, _ := service.GetAllPurcaseOrderById(warehousing_id, orgId)
	//获取购货单的数据
	goodOrder, _ := service.GetAllGoodOrderByIdTwo(warehousing_id, orgId)

	//查询该购货单是否审核成功
	detail, _ := service.GetGoodOrderDetail(id, orgId)
	var warehousingInfo []*models.WarehousingInfo
	var warehouseInfoDetail []*models.DrugWarehouseInfo
	var drugFlow []*models.DrugFlow
	//如果审核成功
	if detail.IsCheck == 1 {
		//入库
		if len(goodOrder) > 0 {
			for _, item := range goodOrder {
				//药品
				if item.IsSource == 1 {
					//获取药品类型
					medical, _ := service.GetBaseDrugMedical(item.ID)
					timeStr := time.Now().Format("2006-01-02")
					timeArr := strings.Split(timeStr, "-")
					total, _ := service.FindAllWarehouseTotalOne(orgId)
					total = total + 1

					warehousing_order := "YPRKD" + strconv.FormatInt(orgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000" + strconv.FormatInt(total, 10)

					operation_time := time.Now().Unix()
					warehousing := models.DrugWarehouse{
						WarehousingOrder:  warehousing_order,
						OperationTime:     operation_time,
						OrgId:             orgId,
						Creater:           checker,
						Ctime:             time.Now().Unix(),
						Status:            1,
						WarehousingTime:   record_date,
						Type:              1,
						SupplyWarehouseId: id,
					}
					//查询今日是否存在入库单号
					_, errcode := service.GetSingleDrugWarehouseOrder(record_date, orgId)
					if errcode == gorm.ErrRecordNotFound {
						service.AddSigleDrugWarehouse(&warehousing)
					}
					drugWarehouseInfo, _ := service.GetLastDrugWarehouse(orgId)

					warehouseInfoDetailOne := &models.DrugWarehouseInfo{
						WarehousingOrder:  drugWarehouseInfo.WarehousingOrder,
						WarehousingId:     drugWarehouseInfo.ID,
						DrugId:            item.ProjectId,
						Number:            item.SupplyLicenseNumber,
						ProductDate:       item.SupplyProductDate,
						ExpiryDate:        item.SupplyExpiryDate,
						WarehousingCount:  item.Count,
						Price:             item.Price,
						TotalPrice:        0,
						Status:            1,
						Ctime:             time.Now().Unix(),
						Remark:            item.Remark,
						OrgId:             orgId,
						Type:              1,
						Manufacturer:      item.ManufacturerId,
						Dealer:            0,
						StockMaxNumber:    item.Count,
						RetailTotalPrice:  0,
						BatchNumber:       item.SupplyBatchNumber,
						MaxUnit:           item.SupplyUnit,
						MinUnit:           item.SupplyUnit,
						RetailPrice:       medical.MinPrice,
						SupplyWarehouseId: id,
					}
					if medical.MaxUnit == medical.MinUnit {
						warehouseInfoDetailOne.StockMaxNumber = item.Count
						warehouseInfoDetailOne.StockMinNumber = 0
						warehouseInfoDetailOne.MaxUnit = item.SupplyUnit
					}
					if item.SupplyUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
						warehouseInfoDetailOne.StockMaxNumber = 0
						warehouseInfoDetailOne.StockMinNumber = item.Count
						warehouseInfoDetailOne.MaxUnit = item.SupplyUnit
					}
					warehouseInfoDetail = append(warehouseInfoDetail, warehouseInfoDetailOne)

					drugflow := &models.DrugFlow{
						WarehousingOrder:  drugWarehouseInfo.WarehousingOrder,
						WarehousingId:     drugWarehouseInfo.ID,
						DrugId:            item.ProjectId,
						Number:            item.SupplyBatchNumber,
						ProductDate:       item.SupplyProductDate,
						ExpireDate:        item.SupplyExpiryDate,
						Count:             item.Count,
						Price:             item.Price,
						Status:            1,
						Ctime:             time.Now().Unix(),
						UserOrgId:         orgId,
						Manufacturer:      item.ManufacturerId,
						Dealer:            0,
						BatchNumber:       item.SupplyBatchNumber,
						MaxUnit:           item.SupplyUnit,
						MinUnit:           item.SupplyUnit,
						ConsumableType:    1,
						IsEdit:            1,
						Creator:           checker,
						IsSys:             0,
						SupplyWarehouseId: id,
					}

					if medical.MaxUnit == medical.MinUnit {
						drugflow.MaxUnit = item.SupplyUnit

					}
					if item.SupplyUnit == medical.MinUnit {
						warehouseInfoDetailOne.MaxUnit = warehouseInfoDetailOne.MinUnit
					}
					drugFlow = append(drugFlow, drugflow)
				}
				//耗材
				if item.IsSource == 2 {
					//获取耗材类型
					good, _ := service.GetGoodInformationByGoodId(item.ProjectId)
					timeStr := time.Now().Format("2006-01-02")
					timeArr := strings.Split(timeStr, "-")
					total, _ := service.FindAllWarehouseTotal(orgId)
					total = total + 1
					warehousing_order := "RKD" + strconv.FormatInt(orgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000" + strconv.FormatInt(total, 10)
					operation_time := time.Now().Unix()
					creater := this.GetAdminUserInfo().AdminUser.Id
					warehousing := models.Warehousing{
						WarehousingOrder:  warehousing_order,
						OperationTime:     operation_time,
						OrgId:             orgId,
						Creater:           creater,
						Ctime:             time.Now().Unix(),
						Status:            1,
						WarehousingTime:   record_date,
						Type:              1,
						SupplyWarehouseId: id,
					}
					//查询是否存在入库单
					_, errcose := service.GetSindleWarehouse(record_date, orgId)
					if errcose == gorm.ErrRecordNotFound {
						service.AddSigleWarehouse(&warehousing)
					}
					info, _ := service.GetLastWarehouseInfoByInfo(orgId)

					//入库单表格
					warehouseInfo := &models.WarehousingInfo{
						WarehousingOrder:  info.WarehousingOrder,
						WarehousingId:     info.ID,
						GoodId:            item.ProjectId,
						Number:            item.SupplyBatchNumber,
						GoodTypeId:        good.GoodTypeId,
						ProductDate:       item.SupplyProductDate,
						ExpiryDate:        item.SupplyExpiryDate,
						WarehousingCount:  item.Count,
						Price:             item.Price,
						TotalPrice:        0,
						Status:            1,
						Ctime:             time.Now().Unix(),
						Remark:            item.Remark,
						OrgId:             orgId,
						Type:              1,
						Manufacturer:      item.ManufacturerId,
						StockCount:        item.Count,
						Dealer:            good.Dealer,
						LicenseNumber:     item.SupplyLicenseNumber,
						PackingPrice:      good.PackingPrice,
						SupplyWarehouseId: id,
					}
					warehousingInfo = append(warehousingInfo, warehouseInfo)
				}
			}
		}
	}

	for _, item := range warehousingInfo {
		service.CreatedWarehouseingDetail(item)
		warehousinginfo, _ := service.GetLastWarehousingInfo(item.GoodId)
		flow := models.VmStockFlow{
			WarehousingOrder:    item.WarehousingOrder,
			WarehousingId:       item.ID,
			GoodId:              item.GoodId,
			Number:              item.Number,
			ProductDate:         item.ProductDate,
			ExpireDate:          item.ExpiryDate,
			Count:               item.WarehousingCount,
			Price:               item.Price,
			Status:              1,
			Ctime:               time.Now().Unix(),
			UserOrgId:           orgId,
			Manufacturer:        item.Manufacturer,
			Dealer:              item.Dealer,
			LicenseNumber:       item.LicenseNumber,
			IsEdit:              1,
			Creator:             checker,
			SystemTime:          record_date,
			ConsumableType:      1,
			WarehousingDetailId: warehousinginfo.ID,
			SupplyWarehouseId:   id,
		}
		service.CreateStockFlowOne(flow)
	}
	//创建入库单
	errs := service.CreateDrugWarehousingInfo(warehouseInfoDetail)
	fmt.Println(errs)
	for _, items := range drugFlow {
		drugWarehouseInfo, _ := service.GetLastDrugWarehouseInfo(items.DrugId)
		items.WarehousingDetailId = drugWarehouseInfo.ID
	}
	//创建流水单
	service.CreateDrugFlow(drugFlow)

	drugList, _ := service.GetSupplyDrugList(orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"purcaseOrder": purcaseOrder,
			"goodOrder":    goodOrder,
			"drugList":     drugList,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) ModefySupplyWarehousing() {

	is_warehouse, _ := this.GetInt64("is_warehouse")
	warehousing_id, _ := this.GetInt64("warehousing_id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	err := service.ModefySupplyWarehousing(is_warehouse, warehousing_id, orgId)
	if err == nil {
		returnData := make(map[string]interface{}, 0)
		returnData["msg"] = "ok"
		this.ServeSuccessJSON(returnData)
		return
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) SaveGoodReturnOrder() {
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	return_remark := dataBody["return_marke"].(string)

	supplier_id, _ := this.GetInt64("supplier_id")
	start_time := this.GetString("start")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	warehouse_out_id, _ := this.GetInt64("warehouse_out_id")
	arrerage := this.GetString("arrerage")
	arrerage_float, _ := strconv.ParseFloat(arrerage, 64)
	payment := this.GetString("payment")
	payment_float, _ := strconv.ParseFloat(payment, 64)
	rate_of_concession := this.GetString("rate_of_concession")
	rate_of_concession_float, _ := strconv.ParseFloat(rate_of_concession, 64)
	discount_amount := this.GetString("discount_amount")
	discount_amount_float, _ := strconv.ParseFloat(discount_amount, 64)

	orgId := this.GetAdminUserInfo().CurrentOrgId
	total, _ := service.GetSupplyCancelOrder(orgId)
	creater := this.GetAdminUserInfo().AdminUser.Id
	//生成购货单
	timeStr := time.Now().Format("2006-01-02")
	timeArr := strings.Split(timeStr, "-")
	total = total + 1
	warehousing_order := "CGT" + timeArr[0] + timeArr[1] + timeArr[2] + "00" + strconv.FormatInt(total, 10)
	recordDateStr := time.Now().Format("2006-01-02")
	recordDate, _ := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
	cancel := models.SpSupplierWarehouseCancel{
		Number:           warehousing_order,
		UserOrgId:        orgId,
		Creater:          creater,
		Ctime:            time.Now().Unix(),
		Mtime:            0,
		Status:           1,
		RecordDate:       recordDate.Unix(),
		IsCheck:          2,
		WarehouseOutId:   warehouse_out_id,
		RateOfConcession: rate_of_concession_float,
		DiscountAmount:   discount_amount_float,
		DocumentDate:     startTime,
		SupplierId:       supplier_id,
		Checker:          0,
		CheckTime:        0,
		Arrearage:        arrerage_float,
		Payment:          payment_float,
		ReturnRemark:     return_remark,
	}
	err = service.CreateReturnCacelOrder(cancel)
	order, _ := service.GetLastReturnCancelOrder(orgId)

	var warehouseCancel []*models.SpSupplierWarehousingCancelOrder
	if dataBody["stockIn"] != nil && reflect.TypeOf(dataBody["stockIn"]).String() == "[]interface {}" {
		thisStockIn, _ := dataBody["stockIn"].([]interface{})
		if len(thisStockIn) > 0 {
			for _, item := range thisStockIn {
				items := item.(map[string]interface{})

				if items["supply_count"] == nil || reflect.TypeOf(items["supply_count"]).String() != "float64" {
					utils.ErrorLog("supply_count")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_count := int64(items["supply_count"].(float64))

				if items["manufacturer_id"] == nil || reflect.TypeOf(items["manufacturer_id"]).String() != "float64" {
					utils.ErrorLog("manufacturer_id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				manufacturer_id := int64(items["manufacturer_id"].(float64))

				if items["name"] == nil || reflect.TypeOf(items["name"]).String() != "string" {
					utils.ErrorLog("name")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				name := items["name"].(string)

				if items["order_number"] == nil || reflect.TypeOf(items["order_number"]).String() != "string" {
					utils.ErrorLog("order_number")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				order_number := items["order_number"].(string)

				if items["good_number"] == nil || reflect.TypeOf(items["good_number"]).String() != "string" {
					utils.ErrorLog("good_number")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				good_number := items["good_number"].(string)

				if items["supply_price"] == nil || reflect.TypeOf(items["supply_price"]).String() != "string" {
					utils.ErrorLog("supply_price")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_price := items["supply_price"].(string)

				price_float, _ := strconv.ParseFloat(supply_price, 64)

				if items["project_id"] == nil || reflect.TypeOf(items["project_id"]).String() != "float64" {
					utils.ErrorLog("project_id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				project_id := int64(items["project_id"].(float64))

				if items["supply_remake"] == nil || reflect.TypeOf(items["supply_remake"]).String() != "string" {
					utils.ErrorLog("supply_remake")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_remake := items["supply_remake"].(string)

				if items["supply_license_number"] == nil || reflect.TypeOf(items["supply_license_number"]).String() != "string" {
					utils.ErrorLog("supply_license_number")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_license_number := items["supply_license_number"].(string)

				if items["supply_specification_name"] == nil || reflect.TypeOf(items["supply_specification_name"]).String() != "string" {
					utils.ErrorLog("supply_specification_name")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_specification_name := items["supply_specification_name"].(string)

				if items["supply_total"] == nil || reflect.TypeOf(items["supply_total"]).String() != "string" {
					utils.ErrorLog("supply_total")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_total := items["supply_total"].(string)

				if items["supply_type"] == nil || reflect.TypeOf(items["supply_type"]).String() != "string" {
					utils.ErrorLog("supply_type")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_type := items["supply_type"].(string)

				if items["supply_unit"] == nil || reflect.TypeOf(items["supply_unit"]).String() != "string" {
					utils.ErrorLog("supply_unit")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_unit := items["supply_unit"].(string)

				if items["type"] == nil || reflect.TypeOf(items["type"]).String() != "float64" {
					utils.ErrorLog("type")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				is_source := int64(items["type"].(float64))

				if items["supply_manufacturer"] == nil || reflect.TypeOf(items["supply_manufacturer"]).String() != "string" {
					utils.ErrorLog("supply_manufacturer")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_manufacturer := items["supply_manufacturer"].(string)

				cancelOrder := &models.SpSupplierWarehousingCancelOrder{
					ManufacturerId:          manufacturer_id,
					OrderNumber:             order_number,
					ProjectId:               project_id,
					GoodNumber:              good_number,
					IsSource:                is_source,
					Count:                   supply_count,
					Price:                   price_float,
					Remark:                  supply_remake,
					RateOfConcession:        rate_of_concession_float,
					DiscountAmount:          discount_amount_float,
					UserOrgId:               orgId,
					Ctime:                   time.Now().Unix(),
					Status:                  1,
					Mtime:                   0,
					WarehouseCancelId:       order.ID,
					Type:                    1,
					ReturnNumber:            order.Number,
					WarehouseOutId:          warehouse_out_id,
					SupplySpecificationName: supply_specification_name,
					SupplyType:              supply_type,
					SupplyTotal:             supply_total,
					SupplyManufacturer:      supply_manufacturer,
					Name:                    name,
					SupplyUnit:              supply_unit,
					SupplyLicenseNumber:     supply_license_number,
				}
				warehouseCancel = append(warehouseCancel, cancelOrder)
			}
		}
	}

	for _, item := range warehouseCancel {
		service.CreateCancelReturnOrder(item)
	}

	cancelOrder, err := service.GetReturnCancelOrder(order.ID, orgId)

	list, err := service.GetReturnCancelOrderList(order.ID, orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"warehouseCancel": warehouseCancel,
			"cancelOrder":     cancelOrder,
			"list":            list,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) GetAllGoodReturnOrderList() {
	check_id, _ := this.GetInt64("check_id")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	keyword := this.GetString("keyword")
	page, _ := this.GetInt64("page")
	limit, _ := this.GetInt64("limit")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 00:00:00", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()

	}
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, total, err := service.GetAllGoodReturnOrderList(check_id, keyword, page, limit, startTime, endTime, orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"total": total,
			"list":  list,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) GetGoodReturnDetail() {

	id, _ := this.GetInt64("id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	detail, err := service.GetGoodReturnDetail(id, orgId)
	orderDetail, err := service.GetGoodReturnOrderDetail(id, orgId)
	//获取药品库数据
	baseList, _ := service.GetSupplyDrugList(orgId)

	goodList, _ := service.GetSupplyGoodList(orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"cancelDetail":      detail,
			"orderCancelDetail": orderDetail,
			"drugList":          baseList,
			"goodList":          goodList,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) UpdateGoodReturn() {

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	return_remark := dataBody["return_marke"].(string)

	supplier_id, _ := this.GetInt64("supplier_id")
	start_time := this.GetString("start")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	warehouse_out_id, _ := this.GetInt64("warehouse_out_id")
	arrerage := this.GetString("arrerage")
	arrerage_float, _ := strconv.ParseFloat(arrerage, 64)
	payment := this.GetString("payment")
	payment_float, _ := strconv.ParseFloat(payment, 64)
	rate_of_concession := this.GetString("rate_of_concession")
	rate_of_concession_float, _ := strconv.ParseFloat(rate_of_concession, 64)
	discount_amount := this.GetString("discount_amount")
	discount_amount_float, _ := strconv.ParseFloat(discount_amount, 64)
	return_number := this.GetString("return_number")
	orgId := this.GetAdminUserInfo().CurrentOrgId

	cancel := models.SpSupplierWarehouseCancel{
		ID:               0,
		Number:           return_number,
		RateOfConcession: rate_of_concession_float,
		DiscountAmount:   discount_amount_float,
		DocumentDate:     startTime,
		SupplierId:       supplier_id,
		Arrearage:        arrerage_float,
		Payment:          payment_float,
		ReturnRemark:     return_remark,
	}

	service.UpdateWarehouseCancel(warehouse_out_id, cancel)

	var warehouseCancel []*models.SpSupplierWarehousingCancelOrder
	var updateWarehouseCancel []*models.SpSupplierWarehousingCancelOrder
	if dataBody["stockIn"] != nil && reflect.TypeOf(dataBody["stockIn"]).String() == "[]interface {}" {
		thisStockIn, _ := dataBody["stockIn"].([]interface{})
		if len(thisStockIn) > 0 {
			for _, item := range thisStockIn {
				items := item.(map[string]interface{})
				if items["id"] == nil || reflect.TypeOf(items["id"]).String() != "float64" {
					utils.ErrorLog("id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				id := int64(items["id"].(float64))
				if items["supply_count"] == nil || reflect.TypeOf(items["supply_count"]).String() != "float64" {
					utils.ErrorLog("supply_count")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_count := int64(items["supply_count"].(float64))

				if items["manufacturer_id"] == nil || reflect.TypeOf(items["manufacturer_id"]).String() != "float64" {
					utils.ErrorLog("manufacturer_id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				manufacturer_id := int64(items["manufacturer_id"].(float64))

				if items["name"] == nil || reflect.TypeOf(items["name"]).String() != "string" {
					utils.ErrorLog("name")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				name := items["name"].(string)

				if items["order_number"] == nil || reflect.TypeOf(items["order_number"]).String() != "string" {
					utils.ErrorLog("order_number")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				order_number := items["order_number"].(string)

				if items["good_number"] == nil || reflect.TypeOf(items["good_number"]).String() != "string" {
					utils.ErrorLog("good_number")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				good_number := items["good_number"].(string)

				if items["supply_price"] == nil || reflect.TypeOf(items["supply_price"]).String() != "string" {
					utils.ErrorLog("supply_price")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_price := items["supply_price"].(string)

				price_float, _ := strconv.ParseFloat(supply_price, 64)

				if items["project_id"] == nil || reflect.TypeOf(items["project_id"]).String() != "float64" {
					utils.ErrorLog("project_id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				project_id := int64(items["project_id"].(float64))

				if items["supply_remake"] == nil || reflect.TypeOf(items["supply_remake"]).String() != "string" {
					utils.ErrorLog("supply_remake")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_remake := items["supply_remake"].(string)

				if items["supply_license_number"] == nil || reflect.TypeOf(items["supply_license_number"]).String() != "string" {
					utils.ErrorLog("supply_license_number")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_license_number := items["supply_license_number"].(string)

				if items["supply_specification_name"] == nil || reflect.TypeOf(items["supply_specification_name"]).String() != "string" {
					utils.ErrorLog("supply_specification_name")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_specification_name := items["supply_specification_name"].(string)

				if items["supply_total"] == nil || reflect.TypeOf(items["supply_total"]).String() != "string" {
					utils.ErrorLog("supply_total")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_total := items["supply_total"].(string)

				if items["supply_type"] == nil || reflect.TypeOf(items["supply_type"]).String() != "string" {
					utils.ErrorLog("supply_type")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_type := items["supply_type"].(string)

				if items["supply_unit"] == nil || reflect.TypeOf(items["supply_unit"]).String() != "string" {
					utils.ErrorLog("supply_unit")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_unit := items["supply_unit"].(string)

				if items["type"] == nil || reflect.TypeOf(items["type"]).String() != "float64" {
					utils.ErrorLog("type")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				is_source := int64(items["type"].(float64))

				if items["supply_manufacturer"] == nil || reflect.TypeOf(items["supply_manufacturer"]).String() != "string" {
					utils.ErrorLog("supply_manufacturer")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				supply_manufacturer := items["supply_manufacturer"].(string)

				if id > 0 {
					cancelOrder := &models.SpSupplierWarehousingCancelOrder{
						ManufacturerId:          manufacturer_id,
						OrderNumber:             order_number,
						ProjectId:               project_id,
						GoodNumber:              good_number,
						IsSource:                is_source,
						Count:                   supply_count,
						Price:                   price_float,
						Remark:                  supply_remake,
						RateOfConcession:        rate_of_concession_float,
						DiscountAmount:          discount_amount_float,
						UserOrgId:               orgId,
						Ctime:                   time.Now().Unix(),
						Status:                  1,
						Mtime:                   0,
						WarehouseCancelId:       warehouse_out_id,
						Type:                    1,
						ReturnNumber:            return_number,
						WarehouseOutId:          warehouse_out_id,
						SupplySpecificationName: supply_specification_name,
						SupplyType:              supply_type,
						SupplyTotal:             supply_total,
						SupplyManufacturer:      supply_manufacturer,
						Name:                    name,
						SupplyUnit:              supply_unit,
						SupplyLicenseNumber:     supply_license_number,
					}
					updateWarehouseCancel = append(updateWarehouseCancel, cancelOrder)
				}

				if id == 0 {
					cancelOrder := &models.SpSupplierWarehousingCancelOrder{
						ManufacturerId:          manufacturer_id,
						OrderNumber:             order_number,
						ProjectId:               project_id,
						GoodNumber:              good_number,
						IsSource:                is_source,
						Count:                   supply_count,
						Price:                   price_float,
						Remark:                  supply_remake,
						RateOfConcession:        rate_of_concession_float,
						DiscountAmount:          discount_amount_float,
						UserOrgId:               orgId,
						Ctime:                   time.Now().Unix(),
						Status:                  1,
						Mtime:                   0,
						WarehouseCancelId:       warehouse_out_id,
						Type:                    1,
						ReturnNumber:            return_number,
						WarehouseOutId:          warehouse_out_id,
						SupplySpecificationName: supply_specification_name,
						SupplyType:              supply_type,
						SupplyTotal:             supply_total,
						SupplyManufacturer:      supply_manufacturer,
						Name:                    name,
						SupplyUnit:              supply_unit,
						SupplyLicenseNumber:     supply_license_number,
					}
					warehouseCancel = append(warehouseCancel, cancelOrder)
				}
			}
		}

		if len(updateWarehouseCancel) > 0 {
			for _, item := range warehouseCancel {
				service.UpdateWarehouseCancelOrder(item)
			}
		}
		if len(warehouseCancel) > 0 {
			for _, item := range warehouseCancel {
				service.CreateCancelReturnOrder(item)
			}
		}
		if err == nil {
			returnData := make(map[string]interface{}, 0)
			returnData["msg"] = "ok"
			this.ServeSuccessJSON(returnData)
			return
		} else {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		}
	}
}

func (this *SupplyOrderApiController) ModefyGoodOrder() {

	id, _ := this.GetInt64("id")
	orgId := this.GetAdminUserInfo().CurrentOrgId

	//获取购货订单的数据
	purcaseOrder, _ := service.GetAllPurcaseOrderById(id, orgId)
	//获取购货单的数据
	goodOrder, _ := service.GetAllGoodOrderById(id, orgId)
	drugList, _ := service.GetSupplyDrugList(orgId)
	//获取已有关联的退货单
	cancelList, _ := service.GetSupplyCancelWarehouse(id, orgId)
	//查询是否存在退货单
	_, errcode := service.GetSupplyCancelOrderById(id, orgId)
	//无退库单
	if errcode == gorm.ErrRecordNotFound {
		//反审核成功
		out := models.SpSupplierWarehouseOut{
			IsCheck:   2,
			Checker:   0,
			CheckTime: 0,
		}
		err := service.UpdateSupplyGoodOrder(id, out)

		//查询该订单不是采购入库的数据
		list, _ := service.GetDrugSupplyWarehousingById(id, orgId)
		if len(list) == 0 {
			service.UpdateSupplyWarehousing(id, orgId)
		}
		goodList, _ := service.GetGoodSupplyWarehousingById(id, orgId)

		if len(goodList) == 0 {
			service.UpdateGoodWarehousing(id, orgId)
		}
		//删除药品入库单
		service.UpdateDrugSupplyWarehousingInfo(id, orgId)
		//删除入库流水
		service.UpdateDrugSupplyFlow(id, orgId)

		//删除耗材入库单
		service.UpdateGoodSupplyWarehousingInfo(id, orgId)

		//删除耗材入库流水
		service.UpdateGoodSupplyFlow(id, orgId)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"cancelList":   cancelList,
				"purcaseOrder": purcaseOrder,
				"goodOrder":    goodOrder,
				"drugList":     drugList,
				"msg":          1,
			})
			return
		} else {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		}
	} else if errcode == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"cancelList":   cancelList,
			"purcaseOrder": purcaseOrder,
			"goodOrder":    goodOrder,
			"drugList":     drugList,
			"msg":          2,
		})
		return
	}

}

func (this *SupplyOrderApiController) UpdateSupplyWarehousing() {

	warehousing_id, _ := this.GetInt64("warehousing_id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	err := service.UpdateSupplyWarehousingById(warehousing_id, orgId)
	if err == nil {
		returnData := make(map[string]interface{}, 0)
		returnData["msg"] = "ok"
		this.ServeSuccessJSON(returnData)
		return
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) DeleteGoodOrder() {

	id, _ := this.GetInt64("id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	err := service.DeleteGoodOrder(id, orgId)
	if err == nil {
		returnData := make(map[string]interface{}, 0)
		returnData["msg"] = "ok"
		this.ServeSuccessJSON(returnData)
		return
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) GetSupplyWarehouseById() {

	id, _ := this.GetInt64("id")
	orgId := this.GetAdminUserInfo().CurrentOrgId

	//获取已有关联的退货单
	cancelList, err := service.GetSupplyCancelWarehouse(id, orgId)
	//获取采购单数据
	outList, _ := service.GetGoodOrderListById(id, orgId)
	//获取退货单数据
	cancelOrderList, _ := service.GetGoodCanceListById(id, orgId)
	//获取药品库数据
	baseList, _ := service.GetSupplyDrugList(orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"cancelList":      cancelList,
			"outList":         outList,
			"drugList":        baseList,
			"cancelOrderList": cancelOrderList,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}