XT_New/controllers/supply_order_api_contorller.go

package controllers

import (
	"encoding/json"
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"time"

	"XT_New/enums"
	"XT_New/models"
	"XT_New/service"
	"XT_New/utils"
	"github.com/astaxie/beego"
	"github.com/jinzhu/gorm"
)

type SupplyOrderApiController struct {
	BaseAuthAPIController
}

func SupplyOrderApiRegistRouters() {
	//获取供应商列表
	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")
	//审核采购单
	beego.Router("/api/supply/checkgoodorderbyid", &SupplyOrderApiController{}, "Get:CheckGoodOrderById")
	//审核退货单
	beego.Router("/api/supply/checkreturnorder", &SupplyOrderApiController{}, "Get:CheckReturnOrder")

	//删除采购订单
	beego.Router("api/supply/deletepurchaseorder", &SupplyOrderApiController{}, "Get:DeletePurchaseOrder")
	//删除采购单
	beego.Router("/api/supply/deletegoodorderbyid", &SupplyOrderApiController{}, "Get:DeleteGoodOrderById")
	//删除退货单
	beego.Router("/api/supply/deletereturnorder", &SupplyOrderApiController{}, "Get:DeleteReturnOrder")
	//删除
	beego.Router("/api/supply/deletereturnorderbyid", &SupplyOrderApiController{}, "Get:DeleteReturnOrderById")
	//反审核退货单
	beego.Router("/api/supply/modefyreturnorder", &SupplyOrderApiController{}, "Get:ModefyReturnOrder")

	//获取采购数据
	beego.Router("/api/supply/getgoodorderdetaillist", &SupplyOrderApiController{}, "Get:GetGoodOrderDetailList")
}

// 判断前端参数是否为空
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() {
	var err error
	defer func() {
		if rec := recover(); rec != nil {
			err = fmt.Errorf("程序异常：%v", rec)
		}
		if err != nil {
			service.SaveErrs(this.GetAdminUserInfo().CurrentOrgId, this.Ctx.Input, err)
		}
	}()
	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())
	}
	keyword := this.GetString("keyword") //供应商编号\供应商名称\联系人名字
	orgId := this.GetAdminUserInfo().CurrentOrgId
	//获取分页的数据
	var list []*models.SpSupplierName
	var total int64
	list, total, err = service.GetSupplyList(ctype, page, limit, keyword, orgId)
	//获取供应商类别
	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, orgId)
			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() {
	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
	}
	supplierName := dataBody["suppliername"].(string)
	if supplierName == "" {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商名称不能为空")
		return
	}
	supplierCode := dataBody["suppliercode"].(string)
	if supplierCode == "" {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商编号不能为空")
		return
	}
	supplierid := int64(dataBody["id"].(float64))
	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, orgId)
		if sbool { //有重复的
			this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商名称重复")
			return
		}
	}
	if supplierCode != supply.SupplierCode {
		//判断供应商编号是否有重复的
		codebool, _ := service.FindSupplierCode(supplierCode, supplierid, orgId)
		if codebool {
			this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商编号重复")
			return
		}
	}
	if dataBody["suppliertype"] == "" || dataBody["suppliertype"] == 0 {
		var tmp float64 = 0
		dataBody["suppliertype"] = tmp
	}
	if dataBody["vatrate"] == "" {
		dataBody["vatrate"] = 0
	}
	supplierType := int64(dataBody["suppliertype"].(float64)) //供应商类别
	var tmpvarrate float64
	datavarrate := dataBody["vatrate"]
	switch datavarrate.(type) {
	case float64:
		tmpvarrate = datavarrate.(float64)
	case string:
		tmpvarrate, _ = strconv.ParseFloat(dataBody["vatrate"].(string), 64)
	}
	vatRate := tmpvarrate                           //增值税税率
	number := dataBody["number"].(string)           //纳税人识别号
	bank := dataBody["bank"].(string)               //开户银行
	bankAccount := dataBody["bankaccount"].(string) //银行账号
	tmodify := this.GetAdminUserInfo().AdminUser.Id //修改者
	//保存联系人
	if dataBody["contacts"] != nil && reflect.TypeOf(dataBody["contacts"]).String() == "[]interface {}" {
		thisStockIn, _ := dataBody["contacts"].([]interface{})
		if len(thisStockIn) > 0 {
			for _, v := range thisStockIn { //这个循环是用来检测当填了手机号时联系人不能为空
				vtem := v.(map[string]interface{})
				if vtem["phone"].(string) != "" && vtem["name"].(string) == "" {
					this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "联系人不能为空")
					return
				}
			}
			if len(thisStockIn) == 1 { //当只有一条联系人时强制设为首要联系人
				for _, item := range thisStockIn {
					items := item.(map[string]interface{})
					items["is_first"] = 1
					//如果电话和联系人都为空，不保存联系人
					if items["phone"] == "" && items["name"] == nil {
						upsupply := models.SpSupplierName{
							ID:           supplierid,
							SupplierCode: supplierCode,
							SupplierName: supplierName,
							SupplierType: supplierType,
							VatRate:      vatRate,
							Number:       number,
							Bank:         bank,
							BankAccount:  bankAccount,
							UserOrgId:    orgId,
							Status:       1,
							Mtime:        time.Now().Unix(),
							Modify:       tmodify,
						}
						err = service.UpdateSupplyName(upsupply)
						if err != nil {
							this.ServeFailJsonSend(enums.ErrorCodeParamWrong, err.Error())
							return
						}
						this.ServeSuccessJSON(map[string]interface{}{
							"list": "保存成功",
						})
						return
					}
				}
			}
			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 {
			//如果联系人是空的，直接保存供应商
			//更新供应商
			upsupply := models.SpSupplierName{
				ID:           supplierid,
				SupplierCode: supplierCode,
				SupplierName: supplierName,
				SupplierType: supplierType,
				VatRate:      vatRate,
				Number:       number,
				Bank:         bank,
				BankAccount:  bankAccount,
				Status:       1,
				Mtime:        time.Now().Unix(),
				Modify:       tmodify,
			}
			err = service.UpdateSupplyName(upsupply)
			if err != nil {
				this.ServeFailJsonSend(enums.ErrorCodeParamWrong, err.Error())
				return
			}

		}
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": "保存成功",
	})
	return
}

// 获取单条供应商和涉及到的联系人记录
func (this *SupplyOrderApiController) GetSupplyAndContactOne() {
	orgId := this.GetAdminUserInfo().CurrentOrgId
	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())
	}
	supply, contact, err := service.GetSupplyAndContactOne(id, orgId)
	//获取供应商类别
	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() {
	orgId := this.GetAdminUserInfo().CurrentOrgId
	//拿到供应商的id
	suid, _ := this.GetInt64("id")
	if suid == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商id不能为空")
		return
	}
	supply := models.SpSupplierName{
		ID: suid,
	}
	shiwu, err := service.DelSupply(supply, orgId)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list":  "删除成功",
		"shiwu": shiwu,
	})
	return
}

// 删除单条联系人记录
func (this *SupplyOrderApiController) DelContactOne() {
	id, _ := this.GetInt64("id")
	if id == 0 {
		this.ServeSuccessJSON(map[string]interface{}{
			"list": "删除成功,没有走数据库",
		})
		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() {
	orgId := this.GetAdminUserInfo().CurrentOrgId
	supply, err := service.GetSuppliyCode(orgId)
	if err != nil {
		return
	}
	if len(supply) == 0 { //如果数据库中没有gys类型的编码则设置默认值
		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() {
	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
	}
	supplierName := dataBody["suppliername"].(string)
	if supplierName == "" {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商名称不能为空")
		return
	}
	//判断供应商名称是否有重复的
	sbool, _ := service.FindSupplierName(supplierName, orgId)
	if sbool { //有重复的
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商名称重复")
		return
	}
	supplierCode := dataBody["suppliercode"].(string) //供应商编码
	if supplierCode == "" {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商编号不能为空")
		return
	}
	//判断供应商编号是否有重复的
	codebool, _ := service.FindSupplierCodes(supplierCode, orgId)
	if codebool {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "供应商编号重复")
		return
	}
	if dataBody["suppliertype"] == "" {
		var tmp int64 = 0
		dataBody["suppliertype"] = tmp
	}
	if dataBody["vatrate"] == "" {
		dataBody["vatrate"] = "0"
	}
	if dataBody["suppliertype"] == "" || dataBody["suppliertype"] == 0 {
		var tmp float64 = 0
		dataBody["suppliertype"] = tmp
	}
	supplierType := int64(dataBody["suppliertype"].(float64)) //供应商类别
	var tmpvarrate float64
	datavarrate := dataBody["vatrate"]
	switch datavarrate.(type) {
	case float64:
		tmpvarrate = datavarrate.(float64)
	case string:
		tmpvarrate, _ = strconv.ParseFloat(dataBody["vatrate"].(string), 64)
	}
	vatRate := tmpvarrate //增值税税率
	number, _ := dataBody["number"].(string)
	bank := dataBody["bank"].(string)
	bankAccount := dataBody["bankaccount"].(string)
	tcreater := this.GetAdminUserInfo().AdminUser.Id
	//保存联系人
	if dataBody["contacts"] != nil && reflect.TypeOf(dataBody["contacts"]).String() == "[]interface {}" {
		thisStockIn, _ := dataBody["contacts"].([]interface{})
		if len(thisStockIn) > 0 {
			for _, v := range thisStockIn { //这个循环是用来检测当填了手机号时联系人不能为空
				vtem := v.(map[string]interface{})
				if vtem["phone"] != "" && vtem["name"] == nil {
					this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "联系人不能为空")
					return
				}
			}
			if len(thisStockIn) == 1 { //当只有一条联系人时强制设为首要联系人,
				for _, item := range thisStockIn {
					items := item.(map[string]interface{})
					items["is_first"] = 1
					//如果电话和联系人都为空，不保存联系人
					if items["phone"] == "" && items["name"] == nil {
						supply := models.SpSupplierName{
							SupplierCode: supplierCode,
							SupplierName: supplierName,
							SupplierType: supplierType,
							VatRate:      vatRate,
							Number:       number,
							Bank:         bank,
							BankAccount:  bankAccount,
							UserOrgId:    orgId,
							Status:       1,
							Ctime:        time.Now().Unix(),
							Mtime:        0,
							Creater:      tcreater,
							Modify:       tcreater,
						}
						err = service.SaveSupply(supply)
						if err != nil {
							this.ServeFailJsonSend(enums.ErrorCodeParamWrong, err.Error())
							return
						}
						this.ServeSuccessJSON(map[string]interface{}{
							"list": "保存成功",
						})
						return
					}
				}
			}
			err = service.SaveSupplyAndContact(thisStockIn, orgId, supplierType, tcreater, supplierCode, supplierName, number, bank, bankAccount, vatRate)
			if err != nil {
				this.ServeFailJsonSend(enums.ErrorCodeParamWrong, err.Error())
				return
			}
		} else {
			//如果联系人是空的，这里直接保存供应商
			supply := models.SpSupplierName{
				SupplierCode: supplierCode,
				SupplierName: supplierName,
				SupplierType: supplierType,
				VatRate:      vatRate,
				Number:       number,
				Bank:         bank,
				BankAccount:  bankAccount,
				UserOrgId:    orgId,
				Status:       1,
				Ctime:        time.Now().Unix(),
				Mtime:        0,
				Creater:      tcreater,
				Modify:       tcreater,
			}
			err = service.SaveSupply(supply)
			if err != nil {
				this.ServeFailJsonSend(enums.ErrorCodeParamWrong, err.Error())
				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)
			}

		}
		//查询
		orderInfo, _ := service.GetSupplyWarehousingOrderInfo(warehousing_id)
		this.ServeSuccessJSON(map[string]interface{}{
			"warehousingInfo": warehousingInfo,
			"orderInfo":       orderInfo,
		})

	}
}

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["min_price"] == nil || reflect.TypeOf(items["min_price"]).String() != "string" {
					utils.ErrorLog("min_price")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				min_price := items["min_price"].(string)

				min_price_float, _ := strconv.ParseFloat(min_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,
					MinPrice:                min_price_float,
					IsWarehosue:             2,
				}
				warehousingOut = append(warehousingOut, &order)
			}
		}
	}

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

		if item.WarehouseInfoId > 0 {
			//查询该商品是否来源于采购订单,如果存在则关联， 如果不存在则取消关联
			_, errcode := service.GetGoodIsSource(warehousing_id, item.ProjectId, orgId)

			if errcode == gorm.ErrRecordNotFound {
				item.WarehousingId = 0
				item.WarehouseInfoId = 0
				item.OrderNumber = ""
				item.Type = 2
				err = service.CreateSupplyWarehousOutOrder(item)
				//更新采购单
				service.ModfySupplyWarehouseOut(warehousing_id, orgId)
			}
			if errcode == nil {
				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)
		for _, item := range list {

			if item.IsSource == 1 {
				waresingList, _ := service.GetAllDrugWaresingList(item.ProjectId, orgId)
				medical, _ := service.GetBaseDrugMedical(item.ProjectId)
				item.DrugWarehouseInfo = waresingList
				item.SpBaseDrug = medical
			}
			if item.IsSource == 2 {
				waresingList, _ := service.GetAllGoodWaresingList(item.ProjectId, orgId)

				item.GoodWarehouseInfo = waresingList
			}
		}
		drugList, _ := service.GetSupplyDrugList(orgId)
		goodList, _ := service.GetSupplyGoodList(orgId)
		supplyList, _ := service.GetSupplierList(orgId)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"out":        out,
				"list":       list,
				"goodList":   goodList,
				"drugList":   drugList,
				"supplyList": supplyList,
			})
		} 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)
		for _, item := range list {
			if item.IsSource == 1 {
				waresingList, _ := service.GetAllDrugWaresingList(item.ProjectId, orgId)
				medical, _ := service.GetBaseDrugMedical(item.ProjectId)
				item.DrugWarehouseInfo = waresingList
				item.SpBaseDrug = medical
			}
			if item.IsSource == 2 {
				waresingList, _ := service.GetAllGoodWaresingList(item.ProjectId, orgId)

				item.GoodWarehouseInfo = waresingList
			}
		}
		drugList, _ := service.GetSupplyDrugList(orgId)
		goodList, _ := service.GetSupplyGoodList(orgId)
		supplyList, _ := service.GetSupplierList(orgId)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"out":        out,
				"list":       list,
				"goodList":   goodList,
				"drugList":   drugList,
				"supplyList": supplyList,
			})
		} 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["min_price"] == nil || reflect.TypeOf(items["min_price"]).String() != "string" {
					utils.ErrorLog("min_price")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				min_price := items["min_price"].(string)

				min_price_float, _ := strconv.ParseFloat(min_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("warehousing_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,
						MinPrice:                min_price_float,
					}
					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,
						MinPrice:                min_price_float,
						IsWarehosue:             2,
					}
					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)
	}
	//for _, item := range updateWarehout {
	//	service.UpdateGoodWarehouseOutOrder(item)
	//	//查询该商品是否来源于采购订单,如果存在则关联， 如果不存在则取消关联
	//	_, errcode := service.GetGoodIsSource(item.WarehousingId, item.ProjectId, orgId)
	//	if errcode == gorm.ErrRecordNotFound {
	//		item.WarehousingId = 0
	//		item.WarehouseInfoId = 0
	//		item.Type = 2
	//		item.OrderNumber = ""
	//
	//		//更新采购单
	//		service.ModfySupplyWarehouseOut(item.WarehousingId, orgId)
	//	}
	//}
	list, _ := service.GetSupplyWarehouseOutById(warehose_out_id, orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"out":  out,
			"list": list,
		})
	} 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.GetAllGoodOrderByIdSix(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(id, orgId)

	houseConfig, _ := service.GetAllStoreHouseConfig(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,
						StorehouseId:      houseConfig.DrugStorehouseInfo,
						IsCheck:           1,
					}
					//查询今日是否存在入库单号
					//_, 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:               item.MinPrice,
						SupplyWarehouseId:         id,
						SupplyWarehouseDetailInfo: item.ID,
						StorehouseId:              houseConfig.DrugStorehouseInfo,
						IsCheck:                   1,
					}
					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,
						SupplyWarehouseDetailInfo: item.ID,
						StorehouseId:              houseConfig.DrugStorehouseInfo,
					}

					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,
						StorehouseId:      houseConfig.StorehouseInfo,
						IsCheck:           1,
					}
					//查询是否存在入库单
					//_, 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:              item.MinPrice,
						SupplyWarehouseId:         id,
						SupplyWarehouseDetailInfo: item.ID,
						StorehouseId:              houseConfig.StorehouseInfo,
						IsCheck:                   1,
					}
					warehousingInfo = append(warehousingInfo, warehouseInfo)
				}
			}
		}
	}

	for _, item := range warehousingInfo {
		service.CreatedWarehouseingDetail(item)

		//查询该机构默认仓库
		storeConfig, _ := service.GetAllStoreHouseConfig(item.OrgId)
		//查询剩余库存
		goodList, _ := service.GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, item.GoodId, item.OrgId)
		var sum_count int64
		var sum_in_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
			sum_in_count += item.WarehousingCount
		}
		service.UpdateGoodByGoodId(item.GoodId, sum_count, sum_in_count, item.OrgId)

		//查询是否有该耗材
		goodStock, _ := service.GetGoodSumCount(storeConfig.StorehouseOutInfo, item.GoodId, item.OrgId)
		if goodStock.ID > 0 {
			//增加入库数量
			service.AddGoodSumInCount(storeConfig.StorehouseOutInfo, item.GoodId, item.OrgId, item.WarehousingCount)
		}
		if goodStock.ID == 0 {
			stock := models.XtGoodStockCount{
				UserOrgId:        item.OrgId,
				GoodId:           item.GoodId,
				StorehouseId:     storeConfig.StorehouseOutInfo,
				Status:           1,
				Ctime:            time.Now().Unix(),
				Mtime:            0,
				StockInCount:     item.WarehousingCount,
				StockOutCount:    0,
				StockCancelCount: 0,
				FlushCount:       sum_count,
				StockActOutCount: 0,
			}
			service.CreateGoodStockCount(stock)
		}

		//更新剩余库存
		service.UpdateGoodFlushCount(storeConfig.StorehouseOutInfo, item.GoodId, item.OrgId, sum_count)
		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,
			SupplyWarehouseDetailInfo: item.ID,
			StorehouseId:              houseConfig.StorehouseInfo,
		}
		service.CreateStockFlowOne(flow)
	}
	//创建入库单
	errs := service.CreateDrugWarehousingInfoSix(warehouseInfoDetail)

	//改变入库状态
	for _, items := range warehouseInfoDetail {

		//查询默认仓库
		houseConfig, _ := service.GetAllStoreHouseConfig(items.OrgId)
		//查询默认仓库剩余多少库存
		list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, items.OrgId, items.DrugId)
		var sum_count int64
		var sum_in_count int64
		var sum_waresing_count int64
		baseDrug, _ := service.GetBaseDrugMedical(items.DrugId)
		for _, it := range list {
			if it.MaxUnit == baseDrug.MaxUnit {
				it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
				it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
			}
			sum_count += it.StockMaxNumber + it.StockMinNumber
			sum_in_count += it.WarehousingCount
		}
		if items.MaxUnit == baseDrug.MaxUnit {
			sum_waresing_count = items.WarehousingCount * baseDrug.MinNumber
		}
		if items.MaxUnit == baseDrug.MinUnit {
			sum_waresing_count = items.WarehousingCount
		}

		service.UpdateMedicalSumCount(items.DrugId, sum_count, sum_in_count, items.OrgId)

		//查询是否有
		drugStock, _ := service.GetDrugStockCountSix(houseConfig.DrugStorehouseOut, items.DrugId, items.OrgId)
		fmt.Println("drugStockwoowowowowoowowowo", drugStock.ID)
		if drugStock.ID == 0 {
			drug := models.XtDrugStockCount{
				UserOrgId:      items.OrgId,
				StorehouseId:   houseConfig.DrugStorehouseOut,
				SumInCount:     sum_waresing_count,
				SumOutCount:    0,
				SumCancelCount: 0,
				DrugId:         items.DrugId,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Status:         1,
				FlushCount:     sum_count,
				SumActOutCount: 0,
			}
			service.CreateDrugStock(drug)
		}
		if drugStock.ID > 0 {
			//更新入库数量和剩余库存
			service.UpdateDrugCount(houseConfig.DrugStorehouseOut, items.OrgId, items.DrugId, sum_in_count, sum_count)
		}

	}
	fmt.Println(errs)
	for _, items := range drugFlow {
		drugWarehouseInfo, _ := service.GetLastDrugWarehouseInfo(items.DrugId)
		items.WarehousingDetailId = drugWarehouseInfo.ID
	}
	//创建流水单
	service.CreateDrugFlowSix(drugFlow)

	drugList, _ := service.GetSupplyDrugList(orgId)

	for _, items := range goodOrder {
		service.UpdateWarehouseingById(items.ID)
	}
	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_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()
	}
	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["count"] == nil || reflect.TypeOf(items["count"]).String() != "string" {
					utils.ErrorLog("count")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				count := items["count"].(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 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 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)

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

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

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

				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["id"] == nil || reflect.TypeOf(items["id"]).String() != "float64" {
					utils.ErrorLog("id")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				id := int64(items["id"].(float64))

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

				deposit_rate_float, _ := strconv.ParseFloat(deposit_rate, 64)
				cancelOrder := &models.SpSupplierWarehousingCancelOrder{
					ManufacturerId:            manufacturer_id,
					OrderNumber:               order_number,
					ProjectId:                 project_id,
					GoodNumber:                good_number,
					IsSource:                  is_source,
					Count:                     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,
					SupplyBatchNumber:         supply_batch_number,
					SupplyExpiryDate:          supply_expiry_date,
					SupplyProductDate:         supply_product_date,
					WarehouseInfoId:           warehouse_info_id,
					WarehousingId:             warehousing_id,
					SourceCount:               count,
					SupplyWarehouseDetailInfo: id,
					SupplyCount:               supply_count,
					DepositRate:               deposit_rate_float,
				}
				warehouseCancel = append(warehouseCancel, cancelOrder)
			}
		}
	}

	for _, item := range warehouseCancel {
		if item.SupplyWarehouseDetailInfo > 0 {
			item.Type = 1
		} else {
			item.Type = 2
		}
		service.CreateCancelReturnOrder(item)
		//查询该商品在退库单中是否存在
		_, errcodes := service.GetSupplyWarehouseOutIsExsit(item.WarehouseOutId, item.ProjectId, orgId)
		//如果不存在则情况退库单的关联信息
		if errcodes == gorm.ErrRecordNotFound {
			service.ModfySupplyCancel(item.WarehouseCancelId, orgId, item.ProjectId)

		}

	}

	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)
	supplyList, _ := service.GetSupplierList(orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"cancelDetail":      detail,
			"orderCancelDetail": orderDetail,
			"drugList":          baseList,
			"goodList":          goodList,
			"supplyList":        supplyList,
		})
	} 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 items["count"] == nil || reflect.TypeOf(items["count"]).String() != "string" {
					utils.ErrorLog("count")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				count := items["count"].(string)

				if items["deposit_rate"] == nil || reflect.TypeOf(items["deposit_rate"]).String() != "string" {
					utils.ErrorLog("deposit_rate")
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				deposit_rate := items["deposit_rate"].(string)
				deposit_rate_float, _ := strconv.ParseFloat(deposit_rate, 64)
				if id > 0 {
					cancelOrder := &models.SpSupplierWarehousingCancelOrder{
						ID:                      id,
						ManufacturerId:          manufacturer_id,
						OrderNumber:             order_number,
						ProjectId:               project_id,
						GoodNumber:              good_number,
						IsSource:                is_source,
						Count:                   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,
						SupplyCount:             supply_count,
						DepositRate:             deposit_rate_float,
					}
					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:                   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:                    2,
						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,
						SupplyCount:             supply_count,
						DepositRate:             deposit_rate_float,
					}
					warehouseCancel = append(warehouseCancel, cancelOrder)
				}
			}
		}

		if len(updateWarehouseCancel) > 0 {
			for _, item := range updateWarehouseCancel {

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

				service.CreateCancelReturnOrder(item)
			}
		}
		list, err := service.GetReturnCancelOrderList(warehouse_out_id, orgId)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"list": list,
				"msg":  "msg",
			})
			return

		} else {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		}
	}
}

func (this *SupplyOrderApiController) ModefyGoodOrder() {

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

	//获取购货单的数据
	goodOrder, _ := service.GetAllGoodOrderById(id, orgId)

	//判断该订单是否有出库记录
	for _, it := range goodOrder {

		if it.IsSource == 1 {
			out, _ := service.GetDrugWarehosueInfoByWarehousingId(it.ProjectId, id, orgId)

			if out.ID > 0 {
				this.ServeSuccessJSON(map[string]interface{}{
					"cancelList":   "",
					"purcaseOrder": "",
					"goodOrder":    "",
					"drugList":     "",
					"msg":          3,
				})
				return
			}
		}
		if it.IsSource == 2 {

			out, _ := service.GetGoodWarehouseInfoByWarehousingId(it.ProjectId, id, orgId)
			if out.ID > 0 {
				this.ServeSuccessJSON(map[string]interface{}{
					"cancelList":   "",
					"purcaseOrder": "",
					"goodOrder":    "",
					"drugList":     "",
					"msg":          3,
				})
				return
			}
		}
	}

	//获取购货订单的数据
	purcaseOrder, _ := service.GetAllPurcaseOrderById(warehousing_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)

		for _, its := range goodOrder {
			//改变采购单状态
			service.UpdateSupplyOrderListById(its.ID)
		}

		//查询该订单不是采购入库的数据
		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)
		// 查询入库单
		drugInfo, _ := service.GetDrugSupplyWarehouseIdSeven(id, orgId)
		if len(drugInfo) > 0 {
			for _, item := range drugInfo {
				//查询默认仓库
				houseConfig, _ := service.GetAllStoreHouseConfig(item.OrgId)
				//查询默认仓库剩余多少库存
				list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, item.OrgId, item.DrugId)
				var sum_count int64
				var sum_in_count int64
				for _, it := range list {
					baseDrug, _ := service.GetBaseDrugMedical(it.DrugId)
					if it.MaxUnit == baseDrug.MaxUnit {
						it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
						it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber

					}
					sum_count += it.StockMaxNumber + it.StockMinNumber
					sum_in_count += it.WarehousingCount
				}
				service.UpdateMedicalSumCount(item.DrugId, sum_count, sum_in_count, item.OrgId)

				//更新库存
				service.UpdateDrugCount(houseConfig.DrugStorehouseOut, item.OrgId, item.DrugId, sum_in_count, sum_count)
			}
		} else {
			for _, it := range goodOrder {
				if it.IsSource == 1 {

					service.UpdateMedicalSumCount(it.ProjectId, 0, 0, this.GetAdminUserInfo().CurrentOrgId)
				}
			}

		}

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

		//删除耗材入库流水
		service.UpdateGoodSupplyFlow(id, orgId)

		//查寻入库单
		info, _ := service.GetSupplySupplyWarehouseIdSeven(id, orgId)
		if len(info) > 0 {
			for _, item := range info {
				//扣减库存
				//查询该机构默认仓库
				storeConfig, _ := service.GetAllStoreHouseConfig(item.OrgId)
				//查询剩余库存
				goodList, _ := service.GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, item.GoodId, item.OrgId)
				var sum_count int64
				var sum_in_count int64
				for _, item := range goodList {
					sum_count += item.StockCount
					sum_in_count += item.WarehousingCount
				}
				service.UpdateGoodByGoodId(item.GoodId, sum_count, sum_in_count, item.OrgId)
			}
		} else {
			for _, it := range goodOrder {
				if it.IsSource == 2 {
					service.UpdateGoodByGoodId(it.ProjectId, 0, 0, this.GetAdminUserInfo().CurrentOrgId)
				}
			}
		}

		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)
	}
}

func (this *SupplyOrderApiController) CheckGoodOrderById() {

	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

	out := models.SpSupplierWarehouseOut{
		IsCheck:   1,
		Checker:   checker,
		CheckTime: record_date,
	}

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

func (this *SupplyOrderApiController) CheckReturnOrder() {

	id, _ := this.GetInt64("id")
	warehouse_out_id, _ := this.GetInt64("warehouse_out_id")
	recordDateStr := time.Now().Format("2006-01-02")
	recordDate, _ := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
	orgId := this.GetAdminUserInfo().CurrentOrgId
	record_date := recordDate.Unix()
	checker := this.GetAdminUserInfo().AdminUser.Id
	houseConfig, _ := service.GetAllStoreHouseConfig(this.GetAdminUserInfo().CurrentOrgId)
	//获取退库单详情
	list, _ := service.GetSupplyCancelOrderDetail(id, orgId)
	for _, item := range list {

		var total_count int64
		var prescribing_number_total int64
		//药品
		if item.IsSource == 1 {

			//获取药品库存
			info, _ := service.GetDrugTotalCountTwenTy(item.ProjectId, item.SupplyWarehouseDetailInfo, item.Type, houseConfig.DrugStorehouseOut)

			for _, it := range info {

				if it.MaxUnit == it.CountUnit {
					it.StockMaxNumber = it.StockMaxNumber * it.MinNumber

				}
				total_count += (it.StockMaxNumber + it.StockMinNumber)
			}

			//查询改药品信息
			medical, _ := service.GetBaseDrugMedical(item.ProjectId)

			//判断单位是否相等
			if medical.MaxUnit == item.SupplyUnit {
				//转化为最小单位
				prescribing_number_total = item.SupplyCount * medical.MinNumber
			}
			if medical.MinUnit == item.SupplyUnit {
				prescribing_number_total = item.SupplyCount
			}

			//判断单位
			if total_count == 0 {
				goodObj, _ := service.GetDrugByGoodId(item.ProjectId)
				this.ServeSuccessJSON(map[string]interface{}{
					"msg":        "3",
					"drug_name":  goodObj.DrugName,
					"dose":       goodObj.Dose,
					"dose_unit":  goodObj.DoseUnit,
					"min_number": goodObj.MinNumber,
					"min_unit":   goodObj.MinUnit,
					"max_unit":   goodObj.MaxUnit,
				})
				return
			}

			if prescribing_number_total > total_count {

				goodObj, _ := service.GetDrugByGoodId(item.ProjectId)
				this.ServeSuccessJSON(map[string]interface{}{
					"msg":        "3",
					"drug_name":  goodObj.DrugName,
					"dose":       goodObj.Dose,
					"dose_unit":  goodObj.DoseUnit,
					"min_number": goodObj.MinNumber,
					"min_unit":   goodObj.MinUnit,
					"max_unit":   goodObj.MaxUnit,
				})
				return
			}

			ctime := time.Now().Unix()
			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := service.FindAllDrugWarehouseOut(orgId)

			total = total + 1
			warehousing_out_order := strconv.FormatInt(orgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
			number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
			number = number + total
			warehousing_out_order = "YPCKD" + strconv.FormatInt(number, 10)
			//operation_time := time.Now().Unix()
			creater := this.GetAdminUserInfo().AdminUser.Id
			recordDateStr := time.Now().Format("2006-01-02")
			recordDate, _ := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
			orgId := this.GetAdminUserInfo().CurrentOrgId
			record_date := recordDate.Unix()
			warehouseOut := models.DrugWarehouseOut{
				WarehouseOutOrderNumber: warehousing_out_order,
				OperationTime:           record_date,
				OrgId:                   orgId,
				Creater:                 creater,
				Ctime:                   ctime,
				Status:                  1,
				WarehouseOutTime:        record_date,
				Type:                    1,
				SupplyCancelOutId:       id,
				SupplyWarehouseId:       warehouse_out_id,
				StorehouseId:            houseConfig.DrugStorehouseOut,
				IsCheck:                 1,
			}
			// 查询今日是否存在出库单
			_, errcodes := service.GetDrugWarehouseOutById(orgId, record_date)
			if errcodes == gorm.ErrRecordNotFound {
				service.AddSigleDrugWarehouseOut(&warehouseOut)
			}

			lastDrug, _ := service.GetLastDrugWarehouseById(orgId, record_date)

			//获取
			warehouseOutInfo := &models.DrugWarehouseOutInfo{

				WarehouseOutOrderNumber: lastDrug.WarehouseOutOrderNumber,
				WarehouseOutId:          lastDrug.ID,
				DrugId:                  item.ProjectId,
				Count:                   item.SupplyCount,
				Price:                   item.Price,
				Status:                  1,
				Ctime:                   ctime,
				Remark:                  "",
				OrgId:                   orgId,
				Type:                    1,
				Manufacturer:            item.ManufacturerId,
				Dealer:                  0,
				CountUnit:               item.SupplyUnit,
				ExpiryDate:              item.SupplyExpiryDate,
				ProductDate:             item.SupplyProductDate,
				Number:                  item.SupplyLicenseNumber,
				BatchNumber:             item.SupplyBatchNumber,
				IsSys:                   0,
				WarehouseInfoId:         0,
				SupplyCancelOutId:       id,
				SupplyWarehouseId:       warehouse_out_id,
				SysRecordTime:           record_date,
				IsSource:                item.Type,
				StorehouseId:            houseConfig.DrugStorehouseOut,
				IsCheck:                 1,
			}

			drup, _ := service.FindBaseDrugLibRecord(orgId, item.ProjectId)
			if drup.ID > 0 {
				prescribingNumber := item.SupplyCount
				service.AutoDrugDeliverInfoNight(orgId, prescribingNumber, &warehouseOut, &drup, warehouseOutInfo, warehouse_out_id, id)
			}

			//查询默认仓库
			houseConfig, _ := service.GetAllStoreHouseConfig(orgId)
			//查询默认仓库剩余多少库存
			list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgId, drup.ID)
			var sum_count int64
			var sum_in_count int64
			for _, it := range list {
				baseDrug, _ := service.GetBaseDrugMedical(it.DrugId)
				if it.MaxUnit == baseDrug.MaxUnit {
					it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
					it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber

				}
				sum_count += it.StockMaxNumber + it.StockMinNumber
				sum_in_count += it.WarehousingCount
			}
			service.UpdateDrugCountOne(houseConfig.DrugStorehouseOut, orgId, drup.ID, sum_count)

		}

		//耗材
		if item.IsSource == 2 {
			// 查询该耗材是否有库存
			warehouseOne, _ := service.FindWarehousingInfoTwenTy(item.ProjectId, item.SupplyWarehouseDetailInfo, item.Type, houseConfig.StorehouseOutInfo)

			// 如果出库数量大于该批次剩余库存数量
			if item.SupplyCount > warehouseOne.StockCount {

				goodObj, _ := service.GetGoodInformationByGoodId(item.ProjectId)
				this.ServeSuccessJSON(map[string]interface{}{
					"msg":                "2",
					"good_name":          goodObj.GoodName,
					"specification_name": goodObj.SpecificationName,
				})
				return

			}
			ctime := time.Now().Unix()

			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := service.FindAllWarehouseOut(orgId)

			total = total + 1
			warehousing_out_order := strconv.FormatInt(orgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
			number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
			number = number + total
			warehousing_out_order = "CKD" + strconv.FormatInt(number, 10)
			//operation_time := time.Now().Unix()
			creater := this.GetAdminUserInfo().AdminUser.Id
			recordDateStr := time.Now().Format("2006-01-02")
			recordDate, _ := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)

			record_date := recordDate.Unix()
			warehouseOut := models.WarehouseOut{
				WarehouseOutOrderNumber: warehousing_out_order,
				OperationTime:           record_date,
				OrgId:                   orgId,
				Creater:                 creater,
				Ctime:                   ctime,
				Status:                  1,
				WarehouseOutTime:        record_date,
				Type:                    1,
				SupplyCancelOutId:       id,
				SupplyWarehouseId:       warehouse_out_id,
				IsSys:                   0,
				StorehouseId:            houseConfig.StorehouseOutInfo,
				IsCheck:                 1,
			}
			//查询是否生成出库单
			_, errcodes := service.FindStockOutByIsSys(orgId, 0, record_date)
			if errcodes == gorm.ErrRecordNotFound {
				service.AddSigleWarehouseOutOne(&warehouseOut)
			}
			outWarehouse, _ := service.GetlastWarehouseOutById(orgId, record_date)

			goodObj, _ := service.GetGoodInformationByGoodId(item.ProjectId)
			info := &models.WarehouseOutInfo{
				WarehouseOutOrderNumber: outWarehouse.WarehouseOutOrderNumber,
				WarehouseOutId:          outWarehouse.ID,
				WarehouseInfotId:        0,
				GoodId:                  item.ProjectId,
				GoodTypeId:              goodObj.GoodTypeId,
				Count:                   item.SupplyCount,
				Price:                   item.Price,
				TotalPrice:              0,
				ProductDate:             item.SupplyProductDate,
				ExpiryDate:              item.SupplyExpiryDate,
				Type:                    0,
				Dealer:                  0,
				Manufacturer:            item.ManufacturerId,
				IsSys:                   0,
				SysRecordTime:           record_date,
				Number:                  item.SupplyBatchNumber,
				LicenseNumber:           item.SupplyLicenseNumber,
				ConsumableType:          0,
				SupplyCancelOutId:       id,
				OrgId:                   orgId,
				SupplyWarehouseId:       warehouse_out_id,
				IsSource:                item.Type,
				StorehouseId:            houseConfig.StorehouseOutInfo,
				IsCheck:                 1,
			}
			//出库逻辑
			parseDateErr := service.ConsumablesDeliveryNight(orgId, record_date, info, &warehouseOut, item.SupplyCount, creater, warehouse_out_id, id)

			if parseDateErr != nil {
				utils.ErrorLog(parseDateErr.Error())
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
				return
			}
			//查询该机构默认仓库
			storeConfig, _ := service.GetAllStoreHouseConfig(orgId)
			//查询剩余库存
			goodList, _ := service.GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, item.ProjectId, orgId)
			var sum_count int64
			for _, item := range goodList {
				sum_count += item.StockCount
			}
			//更新剩余库存
			service.UpdateGoodFlushCount(storeConfig.StorehouseOutInfo, item.ProjectId, orgId, sum_count)

		}
	}
	cancel := models.SpSupplierWarehouseCancel{
		IsCheck:   1,
		Checker:   checker,
		CheckTime: record_date,
	}
	err := service.CheckReturnOrder(id, orgId, cancel)

	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"msg":        "1",
			"drug_name":  "",
			"dose":       "",
			"dose_unit":  "",
			"min_number": "",
			"min_unit":   "",
			"max_unit":   "",
		})
		return
	}

}

func (this *SupplyOrderApiController) DeletePurchaseOrder() {

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

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

func (this *SupplyOrderApiController) DeleteReturnOrder() {

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

func (this *SupplyOrderApiController) DeleteReturnOrderById() {

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

func (this *SupplyOrderApiController) ModefyReturnOrder() {
	id, _ := this.GetInt64("id")
	err := service.ModefyReturnOrder(id)
	//获取退库单据日期
	cancel, _ := service.GetReturnOrderById(id)
	orgId := this.GetAdminUserInfo().CurrentOrgId

	houseConfig, _ := service.GetAllStoreHouseConfig(orgId)
	if err == nil {
		//获取退库单详情
		list, _ := service.GetSupplyCancelOrderDetail(id, orgId)
		for _, item := range list {

			//药品
			if item.IsSource == 1 {
				base, _ := service.GetDrugDetailByDrugId(item.ProjectId)
				//更改库存
				if item.SupplyUnit == base.MaxUnit {
					//退库
					drugInfo := models.DrugWarehouseInfo{
						StockMaxNumber: item.SupplyCount,
					}

					service.UpdateDrugWasehousring(item.ProjectId, item.SupplyWarehouseDetailInfo, drugInfo)
					var sum_count int64
					sum_count = item.SupplyCount * base.MinNumber
					service.ModifyDrugAddInformation(item.ProjectId, sum_count, orgId)
					//出库数量减少
					service.ReduceDrugSumOut(houseConfig.DrugStorehouseOut, orgId, item.ProjectId, sum_count)
				}

				if item.SupplyType == base.MinUnit && base.MaxUnit != base.MinUnit {
					drugInfo := models.DrugWarehouseInfo{
						StockMinNumber: item.SupplyCount,
					}
					service.UpdateDrugWasehousringOne(item.ProjectId, item.SupplyWarehouseDetailInfo, drugInfo)
					service.ModifyDrugAddInformation(item.ProjectId, item.SupplyCount, orgId)
					//出库数量减少
					service.ReduceDrugSumOut(houseConfig.DrugStorehouseOut, orgId, item.ProjectId, item.SupplyCount)

				}

				//删除流水
				service.DeleteDrugWarehouseOutNight(item.ProjectId, item.WarehouseCancelId)
				//查询出库订单
				drugOut, _ := service.GetDrugWarehouseByDate(cancel.RecordDate, orgId)

				drugOutList, _ := service.GetDrugWarehouseByIdList(drugOut.ID, orgId)
				if len(drugOutList) == 0 {
					service.UpdateDrugWarehouseById(drugOut.ID)
				}

				//查询默认仓库剩余多少库存
				list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgId, item.ProjectId)
				var sum_count int64
				var sum_in_count int64
				for _, it := range list {
					baseDrug, _ := service.GetBaseDrugMedical(it.DrugId)
					if it.MaxUnit == baseDrug.MaxUnit {
						it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
						it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber

					}
					sum_count += it.StockMaxNumber + it.StockMinNumber
					sum_in_count += it.WarehousingCount
				}
				service.UpdateDrugCountOne(houseConfig.DrugStorehouseOut, orgId, item.ProjectId, sum_count)

			}
			//耗材
			if item.IsSource == 2 {

				//退库
				info := models.WarehousingInfo{
					StockCount: item.SupplyCount,
				}

				//更改库存
				err := service.UpdateWarehousingInfoById(item.ProjectId, item.SupplyWarehouseDetailInfo, info)
				fmt.Println("更改库存3232323223322332")
				service.ModifyGoodAddInformation(item.ProjectId, item.SupplyCount, item.UserOrgId)

				//扣减出库数量
				service.ReduceGoodSumOutCount(houseConfig.StorehouseOutInfo, item.ProjectId, item.UserOrgId, item.SupplyCount)

				//查询剩余库存
				goodList, _ := service.GetGoodSumCountByStoreId(houseConfig.StorehouseOutInfo, item.ProjectId, item.UserOrgId)
				var sum_count int64
				for _, item := range goodList {
					sum_count += item.StockCount
				}
				//更新剩余库存
				service.UpdateGoodFlushCount(houseConfig.StorehouseOutInfo, item.ProjectId, item.UserOrgId, sum_count)
				fmt.Println(err)
				//删除出库记录
				service.DeleteGoodWarehouseOut(item.ProjectId, item.WarehouseCancelId, orgId)

				//查询今日的出库单是
				out, _ := service.GetWarehouseOutByDate(cancel.RecordDate, orgId)
				warehouseOutList, _ := service.GetWarehouseOutById(out.ID, orgId)
				if len(warehouseOutList) == 0 {
					//删除出库单
					service.DeleteWarehouseOutById(out.ID)
				}

			}
		}
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}

	if err == nil {
		returnData := make(map[string]interface{}, 0)
		returnData["msg"] = "ok"
		this.ServeSuccessJSON(returnData)
		return
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *SupplyOrderApiController) GetGoodOrderDetailList() {
	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)
		for _, item := range list {

			if item.IsSource == 1 {
				waresingList, _ := service.GetAllDrugWaresingList(item.ProjectId, orgId)
				medical, _ := service.GetBaseDrugMedical(item.ProjectId)
				item.DrugWarehouseInfo = waresingList
				item.SpBaseDrug = medical
			}
			if item.IsSource == 2 {
				waresingList, _ := service.GetAllGoodWaresingList(item.ProjectId, orgId)

				item.GoodWarehouseInfo = waresingList
			}
		}
		drugList, _ := service.GetSupplyDrugList(orgId)
		goodList, _ := service.GetSupplyGoodList(orgId)
		supplyList, _ := service.GetSupplierList(orgId)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"out":        out,
				"list":       list,
				"goodList":   goodList,
				"drugList":   drugList,
				"supplyList": supplyList,
			})
		} 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)
		for _, item := range list {
			if item.IsSource == 1 {
				waresingList, _ := service.GetAllDrugWaresingList(item.ProjectId, orgId)
				medical, _ := service.GetBaseDrugMedical(item.ProjectId)
				item.DrugWarehouseInfo = waresingList
				item.SpBaseDrug = medical
			}
			if item.IsSource == 2 {
				waresingList, _ := service.GetAllGoodWaresingList(item.ProjectId, orgId)

				item.GoodWarehouseInfo = waresingList
			}
		}
		drugList, _ := service.GetSupplyDrugList(orgId)
		goodList, _ := service.GetSupplyGoodList(orgId)
		supplyList, _ := service.GetSupplierList(orgId)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"out":        out,
				"list":       list,
				"goodList":   goodList,
				"drugList":   drugList,
				"supplyList": supplyList,
			})
		} else {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		}
	}
}