XT_New/controllers/drug_stock_api_contorller.go

package controllers

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

type StockDrugApiController struct {
	BaseAuthAPIController
}

func DrugStockManagerApiRegistRouters() {

	//入库管理和其他入库管理相关接口
	beego.Router("/api/drugwarehouse/create", &StockDrugApiController{}, "post:CreateDrugWarehouse")
	beego.Router("/api/drugwarehouse/list", &StockDrugApiController{}, "get:GetDrugWarehouseList")
	beego.Router("/api/drugwarehouse/delete", &StockDrugApiController{}, "post:DeleteDrugWarehouse")
	beego.Router("/api/drugwarehouseinfo/delete", &StockDrugApiController{}, "post:DeleteDrugWarehouseInfo")
	beego.Router("/api/drugwarehouseinfo/list", &StockDrugApiController{}, "get:GetDrugWarehouseInfoList")
	beego.Router("/api/drugwarehouse/edit", &StockDrugApiController{}, "post:EditDrugWarehouse")

	//退货管理和其他退货管理相关接口
	beego.Router("/api/drugsalesreturn/create", &StockDrugApiController{}, "post:CreateDrugSalesReturn")
	beego.Router("/api/drugsalesreturn/delete", &StockDrugApiController{}, "post:DeleteDrugSalesReturn")
	beego.Router("/api/drugsalesreturninfo/delete", &StockDrugApiController{}, "post:DeleteDrugSalesReturnInfo")
	beego.Router("/api/drugsalesreturninfo/list", &StockDrugApiController{}, "get:GetDrugSalesReturnInfoList")
	beego.Router("/api/drugsalesreturn/list", &StockDrugApiController{}, "get:GetDrugSalesReturnList")
	beego.Router("/api/drugsalesreturn/edit", &StockDrugApiController{}, "post:EditDrugReturnInfo")

	//出库管理和其他出库管理相关接口
	beego.Router("/api/drugwarehouseout/create", &StockDrugApiController{}, "post:CreateDrugWarehouseOut")
	beego.Router("/api/drugwarehouseout/delete", &StockDrugApiController{}, "post:DeleteDrugWarehouseOut")
	beego.Router("/api/drugwarehouseoutinfo/delete", &StockDrugApiController{}, "post:DeleteDrugWarehouseOutInfo")
	beego.Router("/api/drugwarehouseout/list", &StockDrugApiController{}, "get:GetDrugWarehouseOutList")
	beego.Router("/api/drugwarehouseout/edit", &StockDrugApiController{}, "post:EditDrugWarehouseOut")
	beego.Router("/api/drugwarehouseout/info", &StockDrugApiController{}, "get:GetDrugWarehouseOutInfoList")

	//出库退库管理和其他出库退库管理相关接口
	beego.Router("/api/drugcancelstock/create", &StockDrugApiController{}, "post:CreateDrugCancelStock")
	beego.Router("/api/drugcancelstock/list", &StockDrugApiController{}, "get:GetDrugCancelStockList")
	beego.Router("/api/drugcancelstock/info", &StockDrugApiController{}, "get:GetDrugCancelStockInfoList")
	beego.Router("/api/drugcancelstock/delete", &StockDrugApiController{}, "post:DeleteDrugCancelStock")
	beego.Router("/api/drugcancelstockinfo/delete", &StockDrugApiController{}, "post:DeleteDrugCancelStockInfo")
	beego.Router("/api/drugcancelstockinfo/edit", &StockDrugApiController{}, "post:EditDrugCancelStock")

	////库存相关全局配置
	beego.Router("/api/drugstock/config", &StockDrugApiController{}, "get:GetAllConfig")
	//beego.Router("/api/drugreturn/config", &StockDrugApiController{}, "get:GetAllSalesReturnConfig")
	//
	////库存查询
	beego.Router("/api/drugstock/query", &StockDrugApiController{}, "get:GetDrugQueryInfo")
	//
	//beego.Router("/api/drugstock/detail", &StockDrugApiController{}, "get:GetDetailInfo")
	//
	beego.Router("/api/drugwarehouseout/user", &StockDrugApiController{}, "get:GetUserDetailInfo")

	beego.Router("/api/drugstock/get", &StockDrugApiController{}, "get:GetAllDrugStock")

	beego.Router("/api/drug/getcanceldrugorderprint", &StockDrugApiController{}, "get:GetCancelDrugOrderPrint")
	beego.Router("/api/drug/drugcancelexportlist", &StockDrugApiController{}, "get:GetDrugCancelExportList")
	beego.Router("/api/drug/getdrugwarehouseinfoprint", &StockDrugApiController{}, "get:GetDrugWarehouseInfoPrint")
	beego.Router("/api/drug/getdrugoutorderprint", &StockDrugApiController{}, "get:GetDrugOutOrderPrint")

	beego.Router("/api/drugstock/config/list", &StockDrugApiController{}, "get:GetConfigList")

}

func (c *StockDrugApiController) CreateDrugWarehouse() {

	warehousing_time := c.GetString("warehousing_time")

	types, _ := c.GetInt64("type", 0)
	storehouse_id, _ := c.GetInt64("storehouse_id")

	ctime := time.Now().Unix()
	adminUserInfo := c.GetAdminUserInfo()

	warehousingDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", warehousing_time)
	if parseDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", warehousingDate, parseDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	timeStr := time.Now().Format("2006-01-02")
	timeArr := strings.Split(timeStr, "-")
	total, _ := service.FindAllWarehouseTotalOne(adminUserInfo.CurrentOrgId)
	total = total + 1

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

	operation_time := time.Now().Unix()
	creater := adminUserInfo.AdminUser.Id
	warehousing := models.DrugWarehouse{
		WarehousingOrder: warehousing_order,
		OperationTime:    operation_time,
		OrgId:            adminUserInfo.CurrentOrgId,
		Creater:          creater,
		Ctime:            ctime,
		Status:           1,
		WarehousingTime:  warehousingDate.Unix(),
		Type:             types,
		StorehouseId:     storehouse_id,
	}
	service.AddSigleDrugWarehouse(&warehousing)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	var warehousingInfo []*models.DrugWarehouseInfo
	var drugFlow []*models.DrugFlow
	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["drug_id"] == nil || reflect.TypeOf(items["drug_id"]).String() != "float64" {
					utils.ErrorLog("drug_id")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				drug_id := int64(items["drug_id"].(float64))

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

				warehousing_count, _ := strconv.ParseInt(items["warehousing_count"].(string), 10, 64)

				if items["last_price"] == nil || reflect.TypeOf(items["last_price"]).String() != "string" {
					utils.ErrorLog("last_price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				last_price, _ := strconv.ParseFloat(items["last_price"].(string), 64)
				total := float64(warehousing_count) * last_price

				retail_price_total := float64(warehousing_count) * last_price

				var productDates int64
				var expiryDates int64

				if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "string" {
					expiryDates = 0
				} else {
					if len(items["expiry_date"].(string)) == 0 {
						expiryDates = 0

					} else {
						expiryDate, _ := items["expiry_date"].(string)
						expiry_date, _ := utils.ParseTimeStringToTime("2006-01-02", expiryDate)
						expiryDates = expiry_date.Unix()

					}

				}
				if items["product_date"] == nil || reflect.TypeOf(items["product_date"]).String() != "string" {
					productDates = 0
				} else {
					if len(items["product_date"].(string)) == 0 {
						productDates = 0

					} else {
						productDate, _ := items["product_date"].(string)
						product_date, _ := utils.ParseTimeStringToTime("2006-01-02", productDate)
						productDates = product_date.Unix()
					}

				}

				number, _ := items["number"].(string)

				batch_number, _ := items["batch_number"].(string)

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

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

				var remark string
				if items["remark"] == nil || reflect.TypeOf(items["remark"]).String() != "string" {
					remark = ""
				} else {
					remark = items["remark"].(string)
				}

				manufacturer := int64(items["manufacturer"].(float64))

				dealer := int64(items["dealer"].(float64))

				if items["retail_price"] == nil || reflect.TypeOf(items["retail_price"]).String() != "string" {
					utils.ErrorLog("retail_price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				retail_price, _ := strconv.ParseFloat(items["retail_price"].(string), 64)

				warehouseInfo := &models.DrugWarehouseInfo{
					WarehousingOrder: warehousing.WarehousingOrder,
					WarehousingId:    warehousing.ID,
					DrugId:           drug_id,
					Number:           number,
					ProductDate:      productDates,
					ExpiryDate:       expiryDates,
					WarehousingCount: warehousing_count,
					Price:            last_price,
					TotalPrice:       total,
					Status:           1,
					Ctime:            ctime,
					Remark:           remark,
					OrgId:            adminUserInfo.CurrentOrgId,
					Type:             types,
					Manufacturer:     manufacturer,
					Dealer:           dealer,
					StockMaxNumber:   warehousing_count,
					RetailTotalPrice: retail_price_total,
					BatchNumber:      batch_number,
					MaxUnit:          max_unit,
					MinUnit:          min_unit,
					RetailPrice:      retail_price,
					StorehouseId:     storehouse_id,
				}
				medical, _ := service.GetBaseDrugMedical(drug_id)
				if medical.MaxUnit == medical.MinUnit {
					warehouseInfo.StockMaxNumber = warehousing_count
					warehouseInfo.StockMinNumber = 0
					warehouseInfo.MaxUnit = min_unit
				}
				if max_unit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
					warehouseInfo.StockMaxNumber = 0
					warehouseInfo.StockMinNumber = warehousing_count
					warehouseInfo.MaxUnit = min_unit
				}
				warehousingInfo = append(warehousingInfo, warehouseInfo)

				drugflow := &models.DrugFlow{
					WarehousingOrder: warehousing.WarehousingOrder,
					WarehousingId:    warehousing.ID,
					DrugId:           drug_id,
					Number:           number,
					ProductDate:      productDates,
					ExpireDate:       expiryDates,
					Count:            warehousing_count,
					Price:            last_price,
					Status:           1,
					Ctime:            ctime,
					UserOrgId:        adminUserInfo.CurrentOrgId,
					Manufacturer:     manufacturer,
					Dealer:           dealer,
					BatchNumber:      batch_number,
					MaxUnit:          max_unit,
					MinUnit:          min_unit,
					ConsumableType:   1,
					IsEdit:           1,
					Creator:          adminUserInfo.AdminUser.Id,
					IsSys:            0,
					StorehouseId:     storehouse_id,
				}

				if medical.MaxUnit == medical.MinUnit {
					drugflow.MaxUnit = min_unit

				}
				if max_unit == medical.MinUnit {
					warehouseInfo.MaxUnit = min_unit
				}
				drugFlow = append(drugFlow, drugflow)

			}
		}
	}
	//创建入库单
	errs := service.CreateDrugWarehousingInfo(warehousingInfo)

	if errs == nil {
		//更改库存
		var total float64
		var min_number int64
		for _, item := range warehousingInfo {
			//查询刚入库耗材的药品
			wareseInfo, _ := service.FindDrugWaresingCount(item.DrugId, item.OrgId)
			//更新药品库的总量
			info, _ := service.FindeDrugInfo(item.DrugId)

			min_number = wareseInfo.StockMaxNumber*info.MinNumber + wareseInfo.StockMinNumber
			str := strconv.FormatInt(min_number, 10)
			minFloat, _ := strconv.ParseFloat(str, 64)
			total = info.Total + minFloat
			lib := models.BaseDrugLib{
				Total: total,
			}
			service.UpdateBaseDrug(&lib, item.DrugId)

			//查询默认仓库
			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)
		}
	}
	for _, items := range drugFlow {
		drugWarehouseInfo, _ := service.GetLastDrugWarehouseInfo(items.DrugId)
		items.WarehousingDetailId = drugWarehouseInfo.ID
	}
	//创建流水单
	service.CreateDrugFlow(drugFlow)

	info, _ := service.FindLastDrugWarehousingInfo(warehousing.WarehousingOrder)

	if errs != nil {
		utils.ErrorLog(errs.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
		return
	}

	c.ServeSuccessJSON(map[string]interface{}{
		"msg":               "入库成功",
		"warehousing_order": warehousing_order,
		"info":              info,
	})

}
func (c *StockDrugApiController) GetDrugWarehouseList() {
	page, _ := c.GetInt64("page", -1)
	limit, _ := c.GetInt64("limit", -1)
	start_time := c.GetString("start_time")
	end_time := c.GetString("end_time")
	types, _ := c.GetInt64("type", 0)
	keywords := c.GetString("keywords")
	storehouse_id, _ := c.GetInt64("storehouse_id")
	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 {
			fmt.Println(err)
			c.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())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}

	adminUserInfo := c.GetAdminUserInfo()
	//按药品名称搜索
	var ids []int64
	var idArray []int64
	list, _ := service.GetDrugNameByKeyword(keywords, adminUserInfo.CurrentOrgId)
	for _, item := range list {
		ids = append(ids, item.ID)
	}

	//查找入库单详情
	if len(ids) > 0 {
		info, _ := service.GetDrugWarehouseOrderDetailTwo(ids, adminUserInfo.CurrentOrgId, startTime, endTime, storehouse_id)
		for _, it := range info {
			idArray = append(idArray, it.WarehousingId)
		}
	}

	warehouseList, total, err := service.FindAllDrugWarehousingListOne(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords, idArray, storehouse_id)
	houseList, _ := service.GetAllStoreHouseList(adminUserInfo.CurrentOrgId)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"list":      warehouseList,
			"total":     total,
			"houseList": houseList,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}
func (c *StockDrugApiController) GetDrugWarehouseInfoList() {
	id, _ := c.GetInt64("id", 0)

	if id <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	admin := c.GetAdminUserInfo()

	warehousing, err := service.FindDrugWarehousingById(id, admin.CurrentOrgId)

	manufacturerList, _ := service.GetAllManufacturerList(admin.CurrentOrgId)
	dealerList, _ := service.GetAllDealerList(admin.CurrentOrgId)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}

	if warehousing.ID <= 0 {
		return
	}

	warehousingInfo, err := service.FindDrugWarehousingInfoByIdThree(id, admin.CurrentOrgId)
	list, _ := service.GetAllStoreHouseListThree(admin.CurrentOrgId)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"info":             warehousingInfo,
			"warehousing":      warehousing,
			"manufacturerList": manufacturerList,
			"dealerList":       dealerList,
			"list":             list,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (c *StockDrugApiController) EditDrugWarehouse() {

	warehousing_time := c.GetString("warehousing_time")
	id, _ := c.GetInt64("id", 0)
	types, _ := c.GetInt64("type", 0)
	storehouse_id, _ := c.GetInt64("storehouse_id")

	if id == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	ctime := time.Now().Unix()
	mtime := time.Now().Unix()
	adminUserInfo := c.GetAdminUserInfo()

	warehousingDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", warehousing_time)
	if parseDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", warehousingDate, parseDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	warehouse, _ := service.FindDrugWarehousingById(id, adminUserInfo.CurrentOrgId)

	warehousing := models.DrugWarehouse{
		WarehousingOrder: warehouse.WarehousingOrder,
		OrgId:            adminUserInfo.CurrentOrgId,
		Modifier:         adminUserInfo.AdminUser.Id,
		Mtime:            mtime,
		Status:           1,
		WarehousingTime:  warehousingDate.Unix(),
		Type:             warehouse.Type,
		StorehouseId:     storehouse_id,
	}

	service.EditDrugWarehousingOne(warehousing, id)

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

	var warehousingInfo []*models.DrugWarehouseInfo
	var upDateWarehousingInfo []*models.DrugWarehouseInfo
	var drugFlow []*models.DrugFlow
	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["drug_id"] == nil || reflect.TypeOf(items["drug_id"]).String() != "float64" {
					utils.ErrorLog("drug_id")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				drug_id := int64(items["drug_id"].(float64))

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

				warehousing_count, _ := strconv.ParseInt(items["warehousing_count"].(string), 10, 64)

				if items["price"] == nil || reflect.TypeOf(items["price"]).String() != "string" {
					utils.ErrorLog("price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				price, _ := strconv.ParseFloat(items["price"].(string), 64)
				total := float64(warehousing_count) * price

				if items["last_price"] == nil || reflect.TypeOf(items["last_price"]).String() != "string" {
					utils.ErrorLog("last_price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				last_price, _ := strconv.ParseFloat(items["last_price"].(string), 64)

				retail_price_total := float64(warehousing_count) * last_price

				retail_price, _ := strconv.ParseFloat(items["retail_price"].(string), 64)

				var productDates int64
				var expiryDates int64

				if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "string" {
					expiryDates = 0
				} else {
					if len(items["expiry_date"].(string)) == 0 {
						expiryDates = 0

					} else {
						expiryDate, _ := items["expiry_date"].(string)
						expiry_date, _ := utils.ParseTimeStringToTime("2006-01-02", expiryDate)
						expiryDates = expiry_date.Unix()

					}
				}

				if items["product_date"] == nil || reflect.TypeOf(items["product_date"]).String() != "string" {
					productDates = 0
				} else {
					if len(items["product_date"].(string)) == 0 {
						productDates = 0

					} else {
						productDate, _ := items["product_date"].(string)
						product_date, _ := utils.ParseTimeStringToTime("2006-01-02", productDate)
						productDates = product_date.Unix()
					}

				}

				number, _ := items["number"].(string)

				batch_number, _ := items["batch_number"].(string)

				max_unit, _ := items["max_unit"].(string)

				min_unit, _ := items["min_unit"].(string)

				var remark string
				if items["remark"] == nil || reflect.TypeOf(items["remark"]).String() != "string" {
					remark = ""
				} else {
					remark = items["remark"].(string)
				}

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

				manufacturer := int64(items["manufacturer"].(float64))

				dealer := int64(items["dealer"].(float64))

				medical, _ := service.GetBaseDrugMedical(drug_id)
				if id == 0 {
					warehouseInfo := &models.DrugWarehouseInfo{
						WarehousingOrder: warehouse.WarehousingOrder,
						WarehousingId:    warehouse.ID,
						DrugId:           drug_id,
						Number:           number,
						ProductDate:      productDates,
						ExpiryDate:       expiryDates,
						WarehousingCount: warehousing_count,
						Price:            price,
						TotalPrice:       total,
						Status:           1,
						Ctime:            ctime,
						Remark:           remark,
						OrgId:            adminUserInfo.CurrentOrgId,
						Type:             types,
						Manufacturer:     manufacturer,
						Dealer:           dealer,
						RetailPrice:      retail_price,
						RetailTotalPrice: retail_price_total,
						BatchNumber:      batch_number,
						MaxUnit:          max_unit,
						MinUnit:          min_unit,
						StockMaxNumber:   warehousing_count,
						StorehouseId:     storehouse_id,
					}

					if medical.MaxUnit == medical.MinUnit {
						warehouseInfo.StockMaxNumber = warehousing_count
						warehouseInfo.StockMinNumber = 0
						warehouseInfo.MaxUnit = min_unit
					}
					if max_unit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
						warehouseInfo.StockMaxNumber = 0
						warehouseInfo.StockMinNumber = warehousing_count
						warehouseInfo.MaxUnit = min_unit
					}
					warehousingInfo = append(warehousingInfo, warehouseInfo)

				} else {

					warehouseInfo := &models.DrugWarehouseInfo{
						ID:               id,
						WarehousingOrder: warehouse.WarehousingOrder,
						WarehousingId:    warehouse.ID,
						DrugId:           drug_id,
						Number:           number,
						ProductDate:      productDates,
						ExpiryDate:       expiryDates,
						WarehousingCount: warehousing_count,
						Price:            price,
						TotalPrice:       total,
						Status:           1,
						Ctime:            ctime,
						Remark:           remark,
						OrgId:            adminUserInfo.CurrentOrgId,
						Type:             types,
						Manufacturer:     manufacturer,
						Dealer:           dealer,
						RetailPrice:      retail_price,
						RetailTotalPrice: retail_price_total,
						MaxUnit:          max_unit,
						MinUnit:          min_unit,
						BatchNumber:      batch_number,
						StorehouseId:     storehouse_id,
					}
					if medical.MaxUnit == medical.MinUnit {
						warehouseInfo.StockMaxNumber = warehousing_count
						warehouseInfo.StockMinNumber = 0
						warehouseInfo.MaxUnit = min_unit
					}

					if medical.MinUnit != medical.MaxUnit {

						if max_unit == medical.MaxUnit {
							warehouseInfo.StockMaxNumber = warehousing_count
							warehouseInfo.StockMinNumber = 0
							warehouseInfo.MaxUnit = max_unit
							warehouseInfo.MinUnit = medical.MinUnit
						}
						if max_unit == medical.MinUnit {

							warehouseInfo.StockMaxNumber = 0
							warehouseInfo.StockMinNumber = warehousing_count
							warehouseInfo.MaxUnit = medical.MinUnit
							warehouseInfo.MinUnit = medical.MinUnit
						}
					}

					upDateWarehousingInfo = append(upDateWarehousingInfo, warehouseInfo)

					drugflow := &models.DrugFlow{
						WarehousingOrder:    warehousing.WarehousingOrder,
						WarehousingId:       warehouse.ID,
						DrugId:              drug_id,
						Number:              number,
						ProductDate:         productDates,
						ExpireDate:          expiryDates,
						Count:               warehousing_count,
						Price:               last_price,
						Status:              1,
						Ctime:               ctime,
						UserOrgId:           adminUserInfo.CurrentOrgId,
						Manufacturer:        manufacturer,
						Dealer:              dealer,
						BatchNumber:         batch_number,
						MaxUnit:             max_unit,
						MinUnit:             min_unit,
						ConsumableType:      1,
						IsEdit:              1,
						Creator:             adminUserInfo.AdminUser.Id,
						IsSys:               0,
						WarehousingDetailId: id,
						StorehouseId:        storehouse_id,
					}

					if max_unit == min_unit {
						drugflow.MaxUnit = min_unit
					}

					drugFlow = append(drugFlow, drugflow)
				}
			}
		}
	}
	var errs error
	if len(warehousingInfo) > 0 {
		errs = service.CreateDrugWarehousingInfo(warehousingInfo)
		if errs == nil {
			//更改库存
			service.UpdateDrugInfo(warehousingInfo)

			for _, it := range warehousingInfo {
				info, _ := service.GetLastDrugWarehouseInfSix(it.DrugId)

				//查询默认仓库
				houseConfig, _ := service.GetAllStoreHouseConfig(it.OrgId)
				//查询默认仓库剩余多少库存
				list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, it.OrgId, it.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(it.DrugId, sum_count, sum_in_count, it.OrgId)

				flows := models.DrugFlow{
					WarehousingOrder:    info.WarehousingOrder,
					WarehousingId:       info.WarehousingId,
					DrugId:              info.DrugId,
					Number:              info.Number,
					ProductDate:         info.ProductDate,
					ExpireDate:          info.ExpiryDate,
					Count:               info.WarehousingCount,
					Price:               info.Price,
					Status:              1,
					Ctime:               ctime,
					UserOrgId:           adminUserInfo.CurrentOrgId,
					Manufacturer:        info.Manufacturer,
					Dealer:              info.Dealer,
					BatchNumber:         info.BatchNumber,
					MaxUnit:             info.MaxUnit,
					MinUnit:             "",
					ConsumableType:      1,
					IsEdit:              1,
					Creator:             adminUserInfo.AdminUser.Id,
					IsSys:               0,
					WarehousingDetailId: info.ID,
					StorehouseId:        storehouse_id,
				}
				if info.MaxUnit == info.MinUnit {
					flows.MaxUnit = info.MinUnit
				}
				_, existerrcodes := service.GetDrugFlowIsExist(info.ID, info.DrugId)

				if existerrcodes == gorm.ErrRecordNotFound {
					service.CreateDrugFlowOne(flows)
				}
			}
		}

	}

	if len(upDateWarehousingInfo) > 0 {
		var total int64
		var minNumber float64
		var allTotal int64
		var chaTotal int64
		for _, item := range upDateWarehousingInfo {
			//查询修改的记录
			orderInfo, _ := service.GetDrugWarehouseOrderOne(id, item.DrugId)

			info, _ := service.FindeDrugInfo(item.DrugId)

			//历史入库总数
			total = orderInfo.StockMaxNumber*info.MinNumber + orderInfo.StockMinNumber

			if item.MaxUnit == info.MaxUnit {
				allTotal = item.WarehousingCount * info.MinNumber
			}
			if item.MaxUnit == info.MinUnit {
				allTotal = item.WarehousingCount
			}

			//如果历史的入库总数 大于当前入库总数 则需要扣减
			if total > allTotal {
				chaTotal = total - allTotal
				str := strconv.FormatInt(chaTotal, 10)
				minFloat, _ := strconv.ParseFloat(str, 64)

				minNumber = info.Total - minFloat

				lib := models.BaseDrugLib{
					Total: minNumber,
				}
				service.UpdateBaseDrug(&lib, item.DrugId)

			}

			//如果历史的入库总数 小于当前入库总数 则需增加库存

			if total < allTotal {

				chaTotal = allTotal - total
				str := strconv.FormatInt(chaTotal, 10)
				minFloat, _ := strconv.ParseFloat(str, 64)

				minNumber = info.Total + minFloat

				lib := models.BaseDrugLib{
					Total: minNumber,
				}
				service.UpdateBaseDrug(&lib, item.DrugId)
			}

			warehouseInfo, _ := service.FindeLastWarehouseInfo(item.ID)

			var total int64

			// 如果当前的入库数量 大于 历史入库数量
			if item.WarehousingCount > warehouseInfo.WarehousingCount {
				total = item.WarehousingCount - warehouseInfo.WarehousingCount
				item.StockMaxNumber = warehouseInfo.StockMaxNumber + total
				errs = service.UpDateDrugWarehousingInfo(item)
				//查询默认仓库
				houseConfig, _ := service.GetAllStoreHouseConfig(adminUserInfo.CurrentOrgId)
				//查询默认仓库剩余多少库存
				list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, adminUserInfo.CurrentOrgId, 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)
				if len(drugFlow) > 0 {
					for _, it := range drugFlow {
						flow := models.DrugFlow{
							Count:        it.Count,
							Manufacturer: it.Manufacturer,
							Dealer:       it.Dealer,
							Number:       it.Number,
							BatchNumber:  it.BatchNumber,
							Price:        it.Price,
							MaxUnit:      info.MaxUnit,
							ExpireDate:   it.ExpireDate,
							StorehouseId: it.StorehouseId,
						}
						if info.MaxUnit == info.MinUnit {
							flow.MaxUnit = info.MinUnit
						}

						parseDateErr := service.UpdateDrugFlowNight(flow, it.DrugId, it.WarehousingDetailId)
						fmt.Println(parseDateErr)

					}
				}
			}

			// 如果当前的入库数量 小于 历史入库数量
			if item.WarehousingCount < warehouseInfo.WarehousingCount {
				total = warehouseInfo.WarehousingCount - item.WarehousingCount
				item.StockMaxNumber = warehouseInfo.StockMaxNumber - total

				errs = service.UpDateDrugWarehousingInfo(item)
				//查询默认仓库
				houseConfig, _ := service.GetAllStoreHouseConfig(adminUserInfo.CurrentOrgId)
				//查询默认仓库剩余多少库存
				list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, adminUserInfo.CurrentOrgId, 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)
				if len(drugFlow) > 0 {
					for _, it := range drugFlow {
						flow := models.DrugFlow{
							Count:        it.Count,
							MaxUnit:      it.MaxUnit,
							MinUnit:      it.MinUnit,
							Number:       it.Number,
							BatchNumber:  it.BatchNumber,
							Price:        it.Price,
							ExpireDate:   it.ExpireDate,
							StorehouseId: it.StorehouseId,
						}
						if info.MaxUnit == info.MinUnit {
							flow.MaxUnit = info.MinUnit
						}
						parseDateErr := service.UpdateDrugFlowNight(flow, it.DrugId, it.WarehousingDetailId)
						fmt.Println(parseDateErr)
					}
				}

			}

			// 如果当前的入库数量 等于 历史入库数量
			if item.WarehousingCount == warehouseInfo.WarehousingCount {

				item.OrgId = item.OrgId
				warehouseinfo := &models.DrugWarehouseInfo{
					Number:       item.Number,
					ProductDate:  item.ProductDate,
					ExpiryDate:   item.ExpiryDate,
					Price:        item.Price,
					TotalPrice:   item.TotalPrice,
					Dealer:       item.Dealer,
					Manufacturer: item.Manufacturer,
					Remark:       item.Remark,
					BatchNumber:  item.BatchNumber,
					MaxUnit:      item.MaxUnit,
					MinUnit:      item.MinUnit,
					RetailPrice:  item.RetailPrice,
					StorehouseId: item.StorehouseId,
				}
				if item.MaxUnit == info.MaxUnit && info.MaxUnit != info.MinUnit {
					warehouseinfo.StockMaxNumber = item.WarehousingCount
					warehouseinfo.StockMinNumber = 0
				}
				if item.MaxUnit == info.MaxUnit && info.MaxUnit == info.MinUnit {
					warehouseinfo.StockMaxNumber = item.WarehousingCount
					warehouseinfo.StockMinNumber = 0
				}
				if item.MaxUnit == info.MinUnit && info.MaxUnit != info.MinUnit {
					warehouseinfo.StockMaxNumber = 0
					warehouseinfo.StockMinNumber = item.WarehousingCount
				}

				if len(drugFlow) > 0 {
					for _, it := range drugFlow {
						flow := models.DrugFlow{
							Count:        it.Count,
							MaxUnit:      it.MaxUnit,
							MinUnit:      it.MinUnit,
							Number:       it.Number,
							BatchNumber:  it.BatchNumber,
							Price:        it.Price,
							ExpireDate:   it.ExpireDate,
							StorehouseId: it.StorehouseId,
						}
						if info.MaxUnit == info.MinUnit {
							flow.MaxUnit = info.MinUnit
						}
						parseDateErr := service.UpdateDrugFlowNight(flow, it.DrugId, it.WarehousingDetailId)
						fmt.Println(parseDateErr)
					}
				}
				if item.MaxUnit == warehouseInfo.MaxUnit {
					errs = service.UpDateDrugWarehousingInfoSix(item.ID, warehouseinfo)
				}

				//查询默认仓库
				houseConfig, _ := service.GetAllStoreHouseConfig(adminUserInfo.CurrentOrgId)
				//查询默认仓库剩余多少库存
				list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, adminUserInfo.CurrentOrgId, 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)
			}

		}

	}

	if errs != nil {
		utils.ErrorLog(errs.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
		return
	}

	c.ServeSuccessJSON(map[string]interface{}{
		"msg": "编辑成功",
	})

}
func (c *StockDrugApiController) DeleteDrugWarehouse() {
	ids := c.GetString("ids")

	if len(ids) == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	idArray := strings.Split(ids, ",")
	orgId := c.GetAdminUserInfo().CurrentOrgId
	err := service.DeleteDrugWarehouse(idArray)
	list, _ := service.GetLastDrugwarehouseInfoByIdTwenty(idArray, orgId)

	for _, it := range list {
		//查询默认仓库
		houseConfig, _ := service.GetAllStoreHouseConfig(it.OrgId)
		//查询默认仓库剩余多少库存
		list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, it.OrgId, it.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(it.DrugId, sum_count, sum_in_count, it.OrgId)
	}

	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteFail)
	} else {
		c.ServeSuccessJSON(map[string]interface{}{
			"msg": "删除成功",
		})
	}
}
func (c *StockDrugApiController) DeleteDrugWarehouseInfo() {
	id, _ := c.GetInt64("id", 0)

	if id == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	err := service.UpDateDrugWarehouseStatus(id)
	service.UpdateDrugFlowById(id)
	var sum_total int64
	list, _ := service.GetDrugWarehouseInfoByIdTwenty(id)
	medical, _ := service.GetBaseDrugMedical(list.DrugId)
	sum_total += list.StockMaxNumber*medical.MinNumber + list.StockMinNumber
	storeConfig, _ := service.GetAllStoreHouseConfig(list.OrgId)
	if storeConfig.DrugStorehouseInfo == list.StorehouseId {
		service.ModifyDrugReduceInformationTwo(list.DrugId, sum_total, list.OrgId)
	}

	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteFail)
	} else {
		c.ServeSuccessJSON(map[string]interface{}{
			"msg": "删除成功",
		})
	}

}

func (c *StockDrugApiController) CreateDrugSalesReturn() {
	dealer_id, _ := c.GetInt64("dealer_id", 0)
	manufacturer_id, _ := c.GetInt64("manufacturer_id", 0)
	sales_return_time := c.GetString("time")
	types, _ := c.GetInt64("type", 0)

	salesReturnDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", sales_return_time)
	if parseDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", salesReturnDate, parseDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := c.GetAdminUserInfo()
	operation_time := time.Now().Unix()
	creater := adminUserInfo.AdminUser.Id
	ctime := time.Now().Unix()

	timeStr := time.Now().Format("2006-01-02")
	timeArr := strings.Split(timeStr, "-")
	total, _ := service.FindAllSalesReturnTotal(adminUserInfo.CurrentOrgId)
	total = total + 1
	orderNumber := "YPTHD" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000" + strconv.FormatInt(total, 10)

	salesReturn := models.DrugSalesReturn{
		OrderNumber:  orderNumber,
		OperaTime:    operation_time,
		OrgId:        adminUserInfo.CurrentOrgId,
		Creater:      creater,
		Ctime:        ctime,
		Status:       1,
		ReturnTime:   salesReturnDate.Unix(),
		Dealer:       dealer_id,
		Manufacturer: manufacturer_id,
		Type:         types,
	}

	service.AddSigleDrugSalesReturn(&salesReturn)

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

	var salesReturnInfos []*models.DrugSalesReturnInfo

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

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

				return_count, _ := items["return_count"].(string)
				if len(return_count) == 0 {
					utils.ErrorLog("len(return_count) == 0")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)

					return
				}
				count, _ := strconv.ParseInt(return_count, 10, 64)

				if items["price"] == nil || reflect.TypeOf(items["price"]).String() != "string" {
					utils.ErrorLog("price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				price, _ := strconv.ParseFloat(items["price"].(string), 64)
				total := float64(count) * price

				if items["retail_price"] == nil || reflect.TypeOf(items["retail_price"]).String() != "string" {
					utils.ErrorLog("retail_price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				retail_price, _ := strconv.ParseFloat(items["retail_price"].(string), 64)
				retail_price_total := float64(count) * retail_price

				salesReturnInfo := &models.DrugSalesReturnInfo{
					OrderNumber:      salesReturn.OrderNumber,
					SalesReturnId:    salesReturn.ID,
					DrugId:           drug_id,
					Count:            count,
					Price:            price,
					Total:            total,
					Status:           1,
					Ctime:            ctime,
					OrgId:            adminUserInfo.CurrentOrgId,
					Type:             types,
					Manufacturer:     manufacturer_id,
					Dealer:           dealer_id,
					RetailPrice:      retail_price,
					RetailTotalPrice: retail_price_total,
				}

				salesReturnInfos = append(salesReturnInfos, salesReturnInfo)

			}
		}
	}
	errs := service.CreateDrugSalesReturnInfo(salesReturnInfos)
	if errs != nil {
		utils.ErrorLog(errs.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateReturnFail)
		return
	}

	c.ServeSuccessJSON(map[string]interface{}{
		"msg": "退货成功",
	})

}
func (c *StockDrugApiController) GetDrugSalesReturnList() {
	page, _ := c.GetInt64("page", -1)
	limit, _ := c.GetInt64("limit", -1)
	start_time := c.GetString("start_time")
	end_time := c.GetString("end_time")
	types, _ := c.GetInt64("type", 0)
	keywords := c.GetString("keywords")

	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 {
			c.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())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}

	adminUserInfo := c.GetAdminUserInfo()
	returnList, total, err := service.FindAllDrugReturnList(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"list":  returnList,
			"total": total,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}

}
func (this *StockDrugApiController) DeleteDrugSalesReturn() {
	ids := this.GetString("ids")

	if len(ids) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	idArray := strings.Split(ids, ",")
	err := service.DeleteDrugSalesReturn(idArray)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteFail)
	} else {
		this.ServeSuccessJSON(map[string]interface{}{
			"msg": "删除成功",
		})
	}
}
func (this *StockDrugApiController) DeleteDrugSalesReturnInfo() {
	id, _ := this.GetInt64("id", 0)
	fmt.Println(id)
	if id == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	err := service.UpDateDrugSaleReturnStatus(id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteFail)
	} else {
		this.ServeSuccessJSON(map[string]interface{}{
			"msg": "删除成功",
		})
	}

}
func (this *StockDrugApiController) GetDrugSalesReturnInfoList() {
	id, _ := this.GetInt64("id", 0)
	adminUserInfo := this.GetAdminUserInfo()

	list, _ := service.FindAllDrugSalesReturnInfoById(id, adminUserInfo.CurrentOrgId)
	salesReturn, _ := service.FindAllDrugSalesReturnById(id, adminUserInfo.CurrentOrgId)

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

}
func (c *StockDrugApiController) EditDrugReturnInfo() {
	return_time := c.GetString("return_time")
	id, _ := c.GetInt64("id", 0)
	types, _ := c.GetInt64("type", 0)
	manufacturer_id, _ := c.GetInt64("manufacturer_id", 0)
	dealer_id, _ := c.GetInt64("dealer_id", 0)

	if id == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	ctime := time.Now().Unix()
	mtime := time.Now().Unix()
	adminUserInfo := c.GetAdminUserInfo()

	returnDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", return_time)
	if parseDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", returnDate, parseDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	salesReturns, _ := service.FindDrugSalesReturnById(id)

	sales := models.DrugSalesReturn{
		ID:           salesReturns.ID,
		Mtime:        mtime,
		ReturnTime:   returnDate.Unix(),
		Manufacturer: manufacturer_id,
		Dealer:       dealer_id,
	}

	service.EditDrugSaleReturn(sales)

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

	var returnInfos []*models.DrugSalesReturnInfo
	var upDateReturnInfos []*models.DrugSalesReturnInfo

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

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

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

				count, _ := strconv.ParseInt(items["count"].(string), 10, 64)

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

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

				price, _ := strconv.ParseFloat(items["price"].(string), 64)
				total := float64(count) * price

				if items["retail_price"] == nil || reflect.TypeOf(items["retail_price"]).String() != "string" {
					utils.ErrorLog("retail_price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				retail_price, _ := strconv.ParseFloat(items["retail_price"].(string), 64)
				retail_price_total := float64(count) * retail_price

				if id == 0 {
					returnInfo := &models.DrugSalesReturnInfo{
						DrugId:           drug_id,
						Count:            count,
						Status:           1,
						Ctime:            ctime,
						OrgId:            adminUserInfo.CurrentOrgId,
						OrderNumber:      sales.OrderNumber,
						SalesReturnId:    sales.ID,
						Mtime:            time.Now().Unix(),
						Type:             types,
						Manufacturer:     manufacturer_id,
						Dealer:           dealer_id,
						RetailPrice:      retail_price,
						RetailTotalPrice: retail_price_total,
						Total:            total,
						Price:            price,
					}
					returnInfos = append(returnInfos, returnInfo)

				} else {
					returnInfo := &models.DrugSalesReturnInfo{
						ID:               id,
						DrugId:           drug_id,
						Count:            count,
						Status:           1,
						Ctime:            ctime,
						OrgId:            adminUserInfo.CurrentOrgId,
						OrderNumber:      sales.OrderNumber,
						SalesReturnId:    sales.ID,
						Mtime:            time.Now().Unix(),
						Type:             types,
						Manufacturer:     manufacturer_id,
						Dealer:           dealer_id,
						RetailPrice:      retail_price,
						RetailTotalPrice: retail_price_total,
						Total:            total,
						Price:            price,
					}
					upDateReturnInfos = append(upDateReturnInfos, returnInfo)
				}
			}
		}
	}
	var errs error
	if len(returnInfos) > 0 {
		errs = service.CreateDrugSalesReturnInfo(returnInfos)
	}

	if len(upDateReturnInfos) > 0 {
		for _, item := range upDateReturnInfos {
			errs = service.UpDateDrugSalesReturnInfo(item)
		}
	}

	if errs != nil {
		utils.ErrorLog(errs.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateReturnFail)
		return
	}

	c.ServeSuccessJSON(map[string]interface{}{
		"msg": "编辑成功",
	})

}

func (c *StockDrugApiController) CreateDrugWarehouseOut() {

	types, _ := c.GetInt64("type", 0)
	storehouse_id, _ := c.GetInt64("storehouse_id")
	ctime := time.Now().Unix()
	adminUserInfo := c.GetAdminUserInfo()

	warehousing_out_time := c.GetString("warehousing_out_time")
	warehousingOutDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", warehousing_out_time)
	if parseDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", warehousingOutDate, parseDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	timeStr := time.Now().Format("2006-01-02")
	timeArr := strings.Split(timeStr, "-")
	total, _ := service.FindAllDrugWarehouseOut(adminUserInfo.CurrentOrgId)

	total = total + 1
	warehousing_out_order := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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 := adminUserInfo.AdminUser.Id

	warehouseOut := models.DrugWarehouseOut{
		WarehouseOutOrderNumber: warehousing_out_order,
		OperationTime:           operation_time,
		OrgId:                   adminUserInfo.CurrentOrgId,
		Creater:                 creater,
		Ctime:                   ctime,
		Status:                  1,
		WarehouseOutTime:        warehousingOutDate.Unix(),
		Type:                    types,
		StorehouseId:            storehouse_id,
	}

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

	var warehousingOutInfo []*models.DrugWarehouseOutInfo

	if dataBody["stockOut"] != nil && reflect.TypeOf(dataBody["stockOut"]).String() == "[]interface {}" {
		thisStockIn, _ := dataBody["stockOut"].([]interface{})

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

				items := item.(map[string]interface{})

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

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

				if items["price"] == nil || reflect.TypeOf(items["price"]).String() != "string" {
					utils.ErrorLog("price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				price, _ := strconv.ParseFloat(items["price"].(string), 64)

				count, _ := strconv.ParseInt(items["count"].(string), 10, 64)

				total := float64(count) * price
				retail_price_total := float64(count) * price
				remark := items["remark"].(string)
				max_unit := items["max_unit"].(string)
				dealer := int64(items["dealer"].(float64))

				manufacturer := int64(items["manufacturer"].(float64))

				number := items["number"].(string)
				batch_number := items["batch_number"].(string)

				warehouse_info_id := int64(items["warehouse_info_id"].(float64))
				var productDates int64
				var expiryDates int64
				if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "string" {
					expiryDates = 0
				} else {
					if len(items["expiry_date"].(string)) == 0 {
						expiryDates = 0

					} else {
						expiryDate, _ := items["expiry_date"].(string)
						expiry_date, _ := utils.ParseTimeStringToTime("2006-01-02", expiryDate)
						expiryDates = expiry_date.Unix()

					}

				}
				if items["product_date"] == nil || reflect.TypeOf(items["product_date"]).String() != "string" {
					productDates = 0
				} else {
					if len(items["product_date"].(string)) == 0 {
						productDates = 0

					} else {
						productDate, _ := items["product_date"].(string)
						product_date, _ := utils.ParseTimeStringToTime("2006-01-02", productDate)
						productDates = product_date.Unix()
					}
				}

				admin_user_id := int64(items["admin_user_id"].(float64))

				//if items["last_price"] == nil || reflect.TypeOf(items["last_price"]).String() != "string" {
				//  utils.ErrorLog("last_price")
				//  c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				//  return
				//}
				//last_price, _ := strconv.ParseFloat(items["last_price"].(string), 64)

				stock_count, _ := items["stock_count"].(string)

				warehouseOutInfo := &models.DrugWarehouseOutInfo{

					WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
					WarehouseOutId:          warehouseOut.ID,
					DrugId:                  drug_id,
					Count:                   count,
					Price:                   price,
					TotalPrice:              total,
					Status:                  1,
					Ctime:                   ctime,
					Remark:                  remark,
					OrgId:                   adminUserInfo.CurrentOrgId,
					Type:                    types,
					Manufacturer:            manufacturer,
					Dealer:                  dealer,
					RetailPrice:             price,
					RetailTotalPrice:        retail_price_total,
					CountUnit:               max_unit,
					ExpiryDate:              expiryDates,
					ProductDate:             productDates,
					Number:                  number,
					BatchNumber:             batch_number,
					IsSys:                   0,
					WarehouseInfoId:         warehouse_info_id,
					StorehouseId:            storehouse_id,
					AdminUserId:             admin_user_id,
					StockCount:              stock_count,
				}
				warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)

			}
		}
	}

	var total_count int64              //总库存
	var prescribing_number_total int64 //出库数据
	//调用出库逻辑
	for _, item := range warehousingOutInfo {
		//获取药品库存
		info, _ := service.GetDrugTotalCountTwo(item.DrugId, storehouse_id)

		for _, it := range info {
			total_count += it.StockMaxNumber*it.MinNumber + it.StockMinNumber
		}
		//查询改药品信息
		medical, _ := service.GetBaseDrugMedical(item.DrugId)

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

		//判断单位
		if total_count == 0 {
			goodObj, _ := service.GetDrugByGoodId(item.DrugId)
			c.ServeSuccessJSON(map[string]interface{}{
				"msg":        "1",
				"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.DrugId)
			c.ServeSuccessJSON(map[string]interface{}{
				"msg":        "1",
				"drug_name":  goodObj.DrugName,
				"dose":       goodObj.Dose,
				"dose_unit":  goodObj.DoseUnit,
				"min_number": goodObj.MinNumber,
				"min_unit":   goodObj.MinUnit,
				"max_unit":   goodObj.MaxUnit,
			})
			return
		} else {
			service.AddSigleDrugWarehouseOut(&warehouseOut)

			// 出库流程
			// 1.查询改药品在药品库的规格信息，并将处方里的规格进行换算（尽量将拆零单位转换成包装单位）
			drup, _ := service.FindBaseDrugLibRecord(item.OrgId, item.DrugId)
			if drup.ID > 0 {
				prescribingNumber := item.Count
				service.AutoDrugDeliverInfoTwentyOne(item.OrgId, prescribingNumber, &warehouseOut, &drup, item)
			}
			prescribing_number_total = 0
			total_count = 0
		}

	}

	c.ServeSuccessJSON(map[string]interface{}{
		"msg":        "2",
		"drug_name":  "",
		"dose":       "",
		"dose_unit":  "",
		"min_number": "",
		"min_unit":   "",
		"max_unit":   "",
	})
	return
}
func (c *StockDrugApiController) GetDrugWarehouseOutList() {
	page, _ := c.GetInt64("page", -1)
	limit, _ := c.GetInt64("limit", -1)
	start_time := c.GetString("start_time")
	end_time := c.GetString("end_time")
	types, _ := c.GetInt64("type", 0)
	keywords := c.GetString("keywords")
	storehouse_id, _ := c.GetInt64("storehouse_id")
	way_type, _ := c.GetInt64("way_type")
	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 {
			c.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())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}

	adminUserInfo := c.GetAdminUserInfo()

	var ids []int64
	var goodids []int64
	if len(keywords) > 0 {
		//查询商品名称
		list, _ := service.GetDrugNameByKeyword(keywords, adminUserInfo.CurrentOrgId)
		for _, item := range list {
			goodids = append(goodids, item.ID)
		}

		if len(goodids) > 0 {
			//出库详情但里面查询
			info, _ := service.GetDrugWarehouseOrderDetail(goodids, adminUserInfo.CurrentOrgId, startTime, endTime, storehouse_id)
			for _, it := range info {
				ids = append(ids, it.WarehouseOutId)
			}
		}

	}

	warehouseOutList, total, err := service.FindAllDrugWarehouseOutListOne(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords, ids, storehouse_id, way_type)

	houseList, _ := service.GetAllStoreHouseList(adminUserInfo.CurrentOrgId)
	fmt.Println(err)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"list":      warehouseOutList,
			"total":     total,
			"houseList": houseList,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}
func (c *StockDrugApiController) DeleteDrugWarehouseOut() {
	ids := c.GetString("ids")

	if len(ids) == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	idArray := strings.Split(ids, ",")
	err := service.DeleteDrugWarehouseOut(idArray)

	list, _ := service.GetDrugWarhouseOutByIds(idArray)
	for _, item := range list {
		medical, _ := service.GetBaseDrugMedical(item.DrugId)
		if item.CountUnit == medical.MaxUnit {

			service.UpdateDrugInfoByIds(item.WarehouseInfoId, item.Count)

		}
		if medical.MaxUnit != medical.MinUnit && item.CountUnit == medical.MinUnit {
			service.UpdateDrugInfoByIdsOne(item.WarehouseInfoId, item.Count)
		}

		//查询默认仓库
		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)
	}
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteFail)
	} else {
		c.ServeSuccessJSON(map[string]interface{}{
			"msg": "删除成功",
		})
	}
}
func (this *StockDrugApiController) DeleteDrugWarehouseOutInfo() {
	id, _ := this.GetInt64("id", 0)
	if id == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	//查询详情
	info, _ := service.GetDrugWarehosueOutInfo(id)

	//查询默认仓库
	houseConfig, _ := service.GetAllStoreHouseConfig(info.OrgId)
	//查询默认仓库剩余多少库存
	list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, info.OrgId, info.DrugId)

	for _, it := range list {

		//查询默认仓库
		houseConfig, _ := service.GetAllStoreHouseConfig(it.OrgId)
		//查询默认仓库剩余多少库存
		list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, it.OrgId, it.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(it.DrugId, sum_count, sum_in_count, it.OrgId)

	}

	//删除流水
	service.DeleteDrugWarehouseOutInfoById(info.ID)
	err := service.UpDateDrugWarehouseOutStatus(id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteFail)
	} else {
		this.ServeSuccessJSON(map[string]interface{}{
			"msg": "删除成功",
		})
	}

}
func (c *StockDrugApiController) GetDrugWarehouseOutInfoList() {
	id, _ := c.GetInt64("id", 0)
	adminInfo := c.GetAdminUserInfo()
	warehouseOutInfo, _ := service.FindDrugWarehouseOutInfoById(id, adminInfo.CurrentOrgId)
	warehouseOut, _ := service.FindDrugWareHouseOutById(id, adminInfo.CurrentOrgId)
	manulist, _ := service.GetAllManufacturerList(adminInfo.CurrentOrgId)
	dealerList, _ := service.GetAllDealerList(adminInfo.CurrentOrgId)
	houstList, _ := service.GetAllStoreHouseList(adminInfo.CurrentOrgId)
	appId := c.GetAdminUserInfo().CurrentAppId
	doctorList, _ := service.GetAllDoctorListSix(adminInfo.CurrentOrgId, appId)
	c.ServeSuccessJSON(map[string]interface{}{
		"list":       warehouseOutInfo,
		"info":       warehouseOut,
		"manulist":   manulist,
		"dealerList": dealerList,
		"houstList":  houstList,
		"doctorList": doctorList,
	})

}
func (c *StockDrugApiController) EditDrugWarehouseOut() {
	warehouse_out_time := c.GetString("warehouse_out_time")
	id, _ := c.GetInt64("id", 0)
	types, _ := c.GetInt64("type", 0)
	storehouse_id, _ := c.GetInt64("storehouse_id")
	if id == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	ctime := time.Now().Unix()
	mtime := time.Now().Unix()
	adminUserInfo := c.GetAdminUserInfo()

	warehouseOutDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", warehouse_out_time)
	if parseDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", warehouseOutDate, parseDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	warehouseOut, _ := service.FindDrugWareHouseOutById(id, adminUserInfo.CurrentOrgId)

	tempWarehouseOut := models.DrugWarehouseOut{
		ID:                      warehouseOut.ID,
		Mtime:                   mtime,
		WarehouseOutTime:        warehouseOutDate.Unix(),
		WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
		StorehouseId:            storehouse_id,
	}

	service.EditDrugWarehouseOut(tempWarehouseOut)

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

	var warehousingOutInfo []*models.DrugWarehouseOutInfo
	var upDateWarehouseOutInfos []*models.DrugWarehouseOutInfo

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

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

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

				count, _ := strconv.ParseInt(items["count"].(string), 10, 64)

				count_unit, _ := items["count_unit"].(string)

				if items["price"] == nil || reflect.TypeOf(items["price"]).String() != "string" {
					utils.ErrorLog("price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				price, _ := strconv.ParseFloat(items["price"].(string), 64)

				if items["retail_price"] == nil || reflect.TypeOf(items["retail_price"]).String() != "string" {
					utils.ErrorLog("retail_price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				retail_price, _ := strconv.ParseFloat(items["retail_price"].(string), 64)

				total := float64(count) * price
				retail_price_total := float64(count) * retail_price

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

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

				dealer := int64(items["dealer"].(float64))
				manufacturer := int64(items["manufacturer"].(float64))

				batch_number := items["batch_number"].(string)
				number := items["number"].(string)
				max_unit := items["count_unit"].(string)
				warehouse_info_id := int64(items["warehouse_info_id"].(float64))
				var productDates int64
				var expiryDates int64
				if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "string" {
					expiryDates = 0
				} else {
					if len(items["expiry_date"].(string)) == 0 {
						expiryDates = 0

					} else {
						expiryDate, _ := items["expiry_date"].(string)
						expiry_date, _ := utils.ParseTimeStringToTime("2006-01-02", expiryDate)
						expiryDates = expiry_date.Unix()

					}

				}

				if items["product_date"] == nil || reflect.TypeOf(items["product_date"]).String() != "string" {
					productDates = 0
				} else {
					if len(items["product_date"].(string)) == 0 {
						productDates = 0

					} else {
						productDate, _ := items["product_date"].(string)
						product_date, _ := utils.ParseTimeStringToTime("2006-01-02", productDate)
						productDates = product_date.Unix()
					}

				}

				admin_user_id := int64(items["admin_user_id"].(float64))

				//if items["last_price"] == nil || reflect.TypeOf(items["last_price"]).String() != "string" {
				//  utils.ErrorLog("last_price")
				//  c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				//  return
				//}
				//last_price, _ := strconv.ParseFloat(items["last_price"].(string), 64)

				stock_count, _ := items["stock_count"].(string)

				if id == 0 {
					warehouseOutInfo := &models.DrugWarehouseOutInfo{
						WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
						WarehouseOutId:          warehouseOut.ID,
						DrugId:                  drug_id,
						Count:                   count,
						Price:                   price,
						TotalPrice:              total,
						Status:                  1,
						Ctime:                   ctime,
						Remark:                  remark,
						OrgId:                   adminUserInfo.CurrentOrgId,
						Type:                    types,
						Manufacturer:            manufacturer,
						Dealer:                  dealer,
						IsSys:                   0,
						SysRecordTime:           0,
						RetailPrice:             retail_price,
						RetailTotalPrice:        retail_price_total,
						BatchNumber:             batch_number,
						Number:                  number,
						ProductDate:             productDates,
						ExpiryDate:              expiryDates,
						CountUnit:               count_unit,
						WarehouseInfoId:         warehouse_info_id,
						StorehouseId:            storehouse_id,
						AdminUserId:             admin_user_id,
						StockCount:              stock_count,
					}
					warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)

					drugflow := &models.DrugFlow{
						WarehousingOrder:        "",
						WarehousingId:           0,
						DrugId:                  drug_id,
						Number:                  number,
						ProductDate:             productDates,
						ExpireDate:              expiryDates,
						Count:                   count,
						Price:                   price,
						Status:                  1,
						Ctime:                   ctime,
						UserOrgId:               adminUserInfo.CurrentOrgId,
						Manufacturer:            manufacturer,
						Dealer:                  dealer,
						BatchNumber:             batch_number,
						MaxUnit:                 max_unit,
						ConsumableType:          1,
						IsEdit:                  1,
						Creator:                 adminUserInfo.AdminUser.Id,
						IsSys:                   0,
						WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
						WarehouseOutId:          id,
						StorehouseId:            storehouse_id,
						AdminUserId:             admin_user_id,
						StockCount:              stock_count,
					}

					drugFlow = append(drugFlow, drugflow)

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

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

					warehouseOutInfo := &models.DrugWarehouseOutInfo{
						ID:                      id,
						WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
						WarehouseOutId:          warehouseOut.ID,
						DrugId:                  drug_id,
						Count:                   count,
						Price:                   price,
						TotalPrice:              total,
						Status:                  1,
						Ctime:                   ctime,
						Remark:                  remark,
						OrgId:                   adminUserInfo.CurrentOrgId,
						Mtime:                   time.Now().Unix(),
						Type:                    types,
						Manufacturer:            manufacturer,
						Dealer:                  dealer,
						IsSys:                   is_sys,
						SysRecordTime:           sys_record_time,
						RetailPrice:             retail_price,
						RetailTotalPrice:        retail_price_total,
						BatchNumber:             batch_number,
						Number:                  number,
						ProductDate:             productDates,
						ExpiryDate:              expiryDates,
						CountUnit:               count_unit,
						WarehouseInfoId:         warehouse_info_id,
						StorehouseId:            storehouse_id,
						AdminUserId:             admin_user_id,
						StockCount:              stock_count,
					}
					upDateWarehouseOutInfos = append(upDateWarehouseOutInfos, warehouseOutInfo)

					drugflow := &models.DrugFlow{
						WarehousingOrder:        "",
						WarehousingId:           0,
						DrugId:                  drug_id,
						Number:                  number,
						ProductDate:             productDates,
						ExpireDate:              expiryDates,
						Count:                   count,
						Price:                   price,
						Status:                  1,
						Ctime:                   ctime,
						UserOrgId:               adminUserInfo.CurrentOrgId,
						Manufacturer:            manufacturer,
						Dealer:                  dealer,
						BatchNumber:             batch_number,
						MaxUnit:                 max_unit,
						ConsumableType:          1,
						IsEdit:                  1,
						Creator:                 adminUserInfo.AdminUser.Id,
						IsSys:                   0,
						WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
						WarehouseOutId:          warehouseOut.ID,
						StorehouseId:            storehouse_id,
						AdminUserId:             admin_user_id,
						StockCount:              stock_count,
					}

					drugFlow = append(drugFlow, drugflow)
				}
			}
		}
	}
	var errs error
	if len(warehousingOutInfo) > 0 {

		var total_count int64
		var prescribing_number_total int64
		//调用出库逻辑
		for _, item := range warehousingOutInfo {

			//获取药品库存
			info, _ := service.GetDrugTotalCount(item.DrugId, item.OrgId, storehouse_id)
			//查询改药品信息
			medical, _ := service.GetBaseDrugMedical(item.DrugId)
			//判断单位是否相等
			if medical.MaxUnit == item.CountUnit {
				//转化为最小单位
				total_count = info.Count * medical.MinNumber
				prescribing_number_total = item.Count * medical.MinNumber
			}
			if medical.MinUnit == item.CountUnit {
				total_count = info.Count
				prescribing_number_total = item.Count
			}

			//判断单位
			if total_count == 0 {
				goodObj, _ := service.GetDrugByGoodId(item.DrugId)
				c.ServeSuccessJSON(map[string]interface{}{
					"msg":        "1",
					"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.DrugId)
				c.ServeSuccessJSON(map[string]interface{}{
					"msg":        "1",
					"drug_name":  goodObj.DrugName,
					"dose":       goodObj.Dose,
					"dose_unit":  goodObj.DoseUnit,
					"min_number": goodObj.MinNumber,
					"min_unit":   goodObj.MinUnit,
					"max_unit":   goodObj.MaxUnit,
				})
				return
			} else {

				// 出库流程
				// 1.查询改药品在药品库的规格信息，并将处方里的规格进行换算（尽量将拆零单位转换成包装单位）
				drup, _ := service.FindBaseDrugLibRecord(item.OrgId, item.DrugId)
				if drup.ID > 0 {
					prescribingNumber := item.Count
					service.AutoDrugDeliverInfoTwentyOne(item.OrgId, prescribingNumber, &tempWarehouseOut, &drup, item)
				}
			}

		}
	}

	if len(upDateWarehouseOutInfos) > 0 {
		for _, item := range upDateWarehouseOutInfos {
			//获取药品库存
			info, _ := service.GetDrugTotalCount(item.DrugId, item.OrgId, storehouse_id)
			//查询改药品信息
			medical, _ := service.GetBaseDrugMedical(item.DrugId)
			//查询最后一次出库记录
			outInfo, _ := service.GetLastDrugWarehouseOutInfo(item.DrugId, item.WarehouseOutId, item.OrgId)
			var min_number int64 //最后一次出库数量
			var max_number int64 //当前出库数量
			var all_number int64 //总库存
			var cha_number int64 //库存差
			var maxNumber int64
			var minNumber int64

			if medical.MaxUnit == outInfo.CountUnit {
				//转为最小单位
				min_number = outInfo.Count * medical.MinNumber
			}

			if medical.MinUnit == outInfo.CountUnit {
				min_number = outInfo.Count
			}

			if medical.MaxUnit == item.CountUnit {
				max_number = item.Count * medical.MinNumber
			}

			if medical.MinUnit == item.CountUnit {
				max_number = item.Count
			}

			all_number = info.Count*medical.MinNumber + info.StockMinNumber

			//比较当前出库数量 小于等于 最后一次出库数量,则需要退库
			if max_number <= min_number {
				errs = service.UpDateDrugWarehouseOutInfo(item)
				flow := models.DrugFlow{
					Count:          max_number,
					ExpireDate:     item.ExpiryDate,
					ProductDate:    item.ProductDate,
					Price:          item.Price,
					Manufacturer:   item.Manufacturer,
					Dealer:         item.Dealer,
					Number:         item.Number,
					WarehouseOutId: item.WarehouseOutId,
					StorehouseId:   item.StorehouseId,
					AdminUserId:    item.AdminUserId,
					StockCount:     item.StockCount,
				}
				service.UpdateDrugFlowSix(item.WarehouseOutId, item.DrugId, item.WarehouseOutOrderNumber, flow)
				cha_number = min_number - max_number

				if item.CountUnit == medical.MaxUnit {
					maxNumber = cha_number / medical.MinNumber

					parseDateErr := service.UpdateWarehouseInfo(maxNumber, item.DrugId, item.OrgId, outInfo.WarehouseInfoId)

					if parseDateErr != nil {
						utils.ErrorLog(errs.Error())
						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockOutFail)
						return
					}

					c.ServeSuccessJSON(map[string]interface{}{
						"msg":        "2",
						"drug_name":  "",
						"dose":       "",
						"dose_unit":  "",
						"min_number": "",
						"min_unit":   "",
						"max_unit":   "",
					})
					minNumber = cha_number % medical.MinNumber
					if minNumber < 0 {
						minNumber = 0
					}
					parseDateErr = service.UpdateWarehouseInfoOne(minNumber, item.DrugId, item.OrgId, outInfo.WarehouseInfoId)

					if parseDateErr != nil {
						utils.ErrorLog(errs.Error())
						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockOutFail)
						return
					}

					c.ServeSuccessJSON(map[string]interface{}{
						"msg":        "2",
						"drug_name":  "",
						"dose":       "",
						"dose_unit":  "",
						"min_number": "",
						"min_unit":   "",
						"max_unit":   "",
					})
				}
				if item.CountUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
					parseDateErr := service.UpdateWarehouseInfoOne(cha_number, item.DrugId, item.OrgId, outInfo.WarehouseInfoId)

					if parseDateErr != nil {
						utils.ErrorLog(errs.Error())
						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockOutFail)
						return
					}

					c.ServeSuccessJSON(map[string]interface{}{
						"msg":        "2",
						"drug_name":  "",
						"dose":       "",
						"dose_unit":  "",
						"min_number": "",
						"min_unit":   "",
						"max_unit":   "",
					})
				}

			}
			//比较当前出库数量 大于 最后一次出库数量,则需要出库
			if max_number > min_number {

				cha_number = max_number - min_number
				//如果总库存大于差,正常出库
				if all_number > cha_number {

					errs = service.UpDateDrugWarehouseOutInfo(item)
					flow := models.DrugFlow{
						Count:        max_number,
						ExpireDate:   item.ExpiryDate,
						ProductDate:  item.ProductDate,
						Price:        item.Price,
						Manufacturer: item.Manufacturer,
						Dealer:       item.Dealer,
						Number:       item.Number,
						StorehouseId: item.StorehouseId,
						AdminUserId:  item.AdminUserId,
					}
					service.UpdateDrugFlowSix(item.WarehouseOutId, item.DrugId, item.WarehouseOutOrderNumber, flow)

					service.UpdateWarehouseInfoTwentyFive(cha_number, item.DrugId, item.OrgId, storehouse_id, &medical)

					//if item.CountUnit == medical.MaxUnit {
					//	maxNumber = cha_number / medical.MinNumber
					//
					//  service.UpdateWarehouseInfoTwentyFive(maxNumber,item.DrugId,item.OrgId,storehouse_id)
					//
					//  ////如果库存大于差
					//  //if(warehouse.StockMaxNumber > maxNumber){
					//  // service.UpdateWarehouseInfoTwenty(maxNumber,warehouse.ID)
					//  //}
					//  ////如果库存小于差
					//  //if(warehouse.StockMaxNumber < maxNumber){
					//  //
					//  //   //先出库完上一个批次的
					//  //  service.UpdateWarehouseInfoTwentyOne(warehouse.ID)
					//  //}
					//
					//	parseDateErr := service.UpdateWarehouseInfoTwo(maxNumber, item.DrugId, item.OrgId)
					//	fmt.Println("parseDateErr", parseDateErr)
					//	if parseDateErr != nil {
					//		utils.ErrorLog(errs.Error())
					//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockOutFail)
					//		return
					//	}
					//
					//	c.ServeSuccessJSON(map[string]interface{}{
					//		"msg":        "2",
					//		"drug_name":  "",
					//		"dose":       "",
					//		"dose_unit":  "",
					//		"min_number": "",
					//		"min_unit":   "",
					//		"max_unit":   "",
					//	})
					//	minNumber = cha_number % medical.MinNumber
					//	if minNumber < 0 {
					//		minNumber = 0
					//	}
					//	parseDateErr = service.UpdateWarehouseInfoFour(minNumber, item.DrugId, item.OrgId)
					//
					//	if parseDateErr != nil {
					//		utils.ErrorLog(errs.Error())
					//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockOutFail)
					//		return
					//	}
					//
					//	c.ServeSuccessJSON(map[string]interface{}{
					//		"msg":        "2",
					//		"drug_name":  "",
					//		"dose":       "",
					//		"dose_unit":  "",
					//		"min_number": "",
					//		"min_unit":   "",
					//		"max_unit":   "",
					//	})
					//}
					//if item.CountUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
					//	parseDateErr := service.UpdateWarehouseInfoFour(cha_number, item.DrugId, item.OrgId)
					//
					//	if parseDateErr != nil {
					//		utils.ErrorLog(errs.Error())
					//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockOutFail)
					//		return
					//	}
					//
					//	c.ServeSuccessJSON(map[string]interface{}{
					//		"msg":        "2",
					//		"drug_name":  "",
					//		"dose":       "",
					//		"dose_unit":  "",
					//		"min_number": "",
					//		"min_unit":   "",
					//		"max_unit":   "",
					//	})
					//}
				}

				if all_number == cha_number {
					warehouseInfo := models.XtDrugWarehouseInfo{
						Number:       item.Number,
						ProductDate:  item.ProductDate,
						ExpiryDate:   item.ExpiryDate,
						Price:        item.Price,
						TotalPrice:   item.TotalPrice,
						Dealer:       item.Dealer,
						Manufacturer: item.Manufacturer,
						Remark:       item.Remark,
						BatchNumber:  item.BatchNumber,
						MaxUnit:      item.CountUnit,
						StorehouseId: item.StorehouseId,
					}
					parseDateErr := service.UpdateDrugWarehouseingInfoSix(item.ID, warehouseInfo)

					if parseDateErr != nil {
						utils.ErrorLog(errs.Error())
						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockOutFail)
						return
					}
					fmt.Println("单位123223232323", item.CountUnit)
					fmt.Println("单位232232323323232", medical.MaxUnit)

					errs = service.UpDateDrugWarehouseOutInfo(item)
					flow := models.DrugFlow{
						Count:        item.Count,
						ExpireDate:   item.ExpiryDate,
						ProductDate:  item.ProductDate,
						Price:        item.Price,
						Manufacturer: item.Manufacturer,
						Dealer:       item.Dealer,
						Number:       item.Number,
						StorehouseId: item.StorehouseId,
						AdminUserId:  item.AdminUserId,
					}
					service.UpdateDrugFlowSix(item.WarehouseOutId, item.DrugId, item.WarehouseOutOrderNumber, flow)
					if item.CountUnit == medical.MaxUnit {
						maxNumber = cha_number / medical.MinNumber

						parseDateErr := service.UpdateWarehouseInfoTwo(maxNumber, item.DrugId, item.OrgId)

						fmt.Println("parseDateErr", parseDateErr)
						if parseDateErr != nil {
							utils.ErrorLog(errs.Error())
							c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockOutFail)
							return
						}

						c.ServeSuccessJSON(map[string]interface{}{
							"msg":        "2",
							"drug_name":  "",
							"dose":       "",
							"dose_unit":  "",
							"min_number": "",
							"min_unit":   "",
							"max_unit":   "",
						})
						minNumber = cha_number % medical.MinNumber
						if minNumber < 0 {
							minNumber = 0
						}
						parseDateErr = service.UpdateWarehouseInfoFour(minNumber, item.DrugId, item.OrgId)

						if parseDateErr != nil {
							utils.ErrorLog(errs.Error())
							c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockOutFail)
							return
						}

						c.ServeSuccessJSON(map[string]interface{}{
							"msg":        "2",
							"drug_name":  "",
							"dose":       "",
							"dose_unit":  "",
							"min_number": "",
							"min_unit":   "",
							"max_unit":   "",
						})
					}
					if item.CountUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
						parseDateErr := service.UpdateWarehouseInfoFour(cha_number, item.DrugId, item.OrgId)

						if parseDateErr != nil {
							utils.ErrorLog(errs.Error())
							c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockOutFail)
							return
						}

						c.ServeSuccessJSON(map[string]interface{}{
							"msg":        "2",
							"drug_name":  "",
							"dose":       "",
							"dose_unit":  "",
							"min_number": "",
							"min_unit":   "",
							"max_unit":   "",
						})
					}

				}
				if all_number < cha_number {
					goodObj, _ := service.GetDrugByGoodId(item.DrugId)
					c.ServeSuccessJSON(map[string]interface{}{
						"msg":        "1",
						"drug_name":  goodObj.DrugName,
						"dose":       goodObj.Dose,
						"dose_unit":  goodObj.DoseUnit,
						"min_number": goodObj.MinNumber,
						"min_unit":   goodObj.MinUnit,
						"max_unit":   goodObj.MaxUnit,
					})
					return
				}
			}

			//查询默认仓库
			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)

		}
	}

	if errs != nil {
		utils.ErrorLog(errs.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockOutFail)
		return
	}

	c.ServeSuccessJSON(map[string]interface{}{
		"msg":        "2",
		"drug_name":  "",
		"dose":       "",
		"dose_unit":  "",
		"min_number": "",
		"min_unit":   "",
		"max_unit":   "",
	})

}

func (c *StockDrugApiController) CreateDrugCancelStock() {
	dealer_id, _ := c.GetInt64("dealer_id", 0)
	manufacturer_id, _ := c.GetInt64("manufacturer_id", 0)
	cancel_stock_time := c.GetString("time")
	types, _ := c.GetInt64("type", 0)
	storehouse_id, _ := c.GetInt64("storehouse_id")

	cancelStockDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", cancel_stock_time)
	if parseDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", cancelStockDate, parseDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	adminUserInfo := c.GetAdminUserInfo()
	operation_time := time.Now().Unix()
	creater := adminUserInfo.AdminUser.Id

	ctime := time.Now().Unix()
	timeStr := time.Now().Format("2006-01-02")
	timeArr := strings.Split(timeStr, "-")
	total, _ := service.FindAllDrugCancelStockTotal(adminUserInfo.CurrentOrgId)
	total = total + 1
	orderNumber := "CKTKD" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000" + strconv.FormatInt(total, 10)

	cancelStock := models.DrugCancelStock{
		OrderNumber:  orderNumber,
		OperaTime:    operation_time,
		OrgId:        adminUserInfo.CurrentOrgId,
		Creater:      creater,
		Ctime:        ctime,
		Status:       1,
		ReturnTime:   cancelStockDate.Unix(),
		Dealer:       dealer_id,
		Manufacturer: manufacturer_id,
		Type:         types,
		StorehouseId: storehouse_id,
	}
	service.AddSigleDrugCancelStock(&cancelStock)

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

	var cancelStockInfos []*models.DrugCancelStockInfo
	var drugFlow []*models.DrugFlow

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

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

				return_count, _ := items["return_count"].(string)
				if len(return_count) == 0 {
					utils.ErrorLog("len(return_count) == 0")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)

					return
				}

				count, _ := strconv.ParseInt(return_count, 10, 64)

				if items["price"] == nil || reflect.TypeOf(items["price"]).String() != "string" {
					utils.ErrorLog("price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				price, _ := strconv.ParseFloat(items["price"].(string), 64)
				total := float64(count) * price

				if items["retail_price"] == nil || reflect.TypeOf(items["retail_price"]).String() != "string" {
					utils.ErrorLog("retail_price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				retail_price, _ := strconv.ParseFloat(items["retail_price"].(string), 64)
				retail_price_total := float64(count) * retail_price

				register_account, _ := items["register_account"].(string)

				remark, _ := items["remark"].(string)

				var productDates int64
				var expiryDates int64

				if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "string" {
					expiryDates = 0
				} else {
					if len(items["expiry_date"].(string)) == 0 {
						expiryDates = 0

					} else {
						expiryDate, _ := items["expiry_date"].(string)
						expiry_date, _ := utils.ParseTimeStringToTime("2006-01-02", expiryDate)
						expiryDates = expiry_date.Unix()

					}

				}
				if items["product_date"] == nil || reflect.TypeOf(items["product_date"]).String() != "string" {
					productDates = 0
				} else {
					if len(items["product_date"].(string)) == 0 {
						productDates = 0

					} else {
						productDate, _ := items["product_date"].(string)
						product_date, _ := utils.ParseTimeStringToTime("2006-01-02", productDate)
						productDates = product_date.Unix()
					}

				}

				manufacturer, _ := items["manufacturer"].(string)

				dealer, _ := items["dealer"].(string)

				batch_number := items["batch_number"].(string)
				max_unit := items["max_unit"].(string)
				batch_number_id := int64(items["batch_number_id"].(float64))
				var manufacturer_id int64
				var dealer_id int64
				manufacturerList, _ := service.GetAllManufacturerList(adminUserInfo.CurrentOrgId)
				dealerList, _ := service.GetAllDealerList(adminUserInfo.CurrentOrgId)
				for _, item := range manufacturerList {
					if manufacturer == item.ManufacturerName {
						manufacturer_id = item.ID
					}
				}
				for _, item := range dealerList {
					if dealer == item.DealerName {
						dealer_id = item.ID
					}
				}
				cancelInfo, _ := service.GetLastDrugCancelStockById(adminUserInfo.CurrentOrgId)
				cancelStockInfo := &models.DrugCancelStockInfo{
					OrderNumber:      cancelInfo.OrderNumber,
					CancelStockId:    cancelInfo.ID,
					DrugId:           drug_id,
					Count:            count,
					Status:           1,
					Ctime:            ctime,
					OrgId:            adminUserInfo.CurrentOrgId,
					Type:             types,
					Manufacturer:     manufacturer,
					Dealer:           dealer,
					Total:            total,
					RetailPrice:      retail_price,
					RetailTotalPrice: retail_price_total,
					Price:            price,
					RegisterAccount:  register_account,
					Remark:           remark,
					BatchNumber:      batch_number,
					MaxUnit:          max_unit,
					ProductDate:      productDates,
					ExpiryDate:       expiryDates,
					BatchNumberId:    batch_number_id,
					StorehouseId:     storehouse_id,
				}
				cancelStockInfos = append(cancelStockInfos, cancelStockInfo)

				flow := &models.DrugFlow{
					WarehousingId:           0,
					DrugId:                  drug_id,
					Number:                  "",
					BatchNumber:             batch_number,
					Count:                   count,
					UserOrgId:               adminUserInfo.CurrentOrgId,
					PatientId:               0,
					SystemTime:              ctime,
					ConsumableType:          4,
					IsSys:                   0,
					WarehousingOrder:        "",
					WarehouseOutId:          0,
					WarehouseOutOrderNumber: "",
					IsEdit:                  0,
					CancelStockId:           cancelStock.ID,
					CancelOrderNumber:       cancelStock.OrderNumber,
					Manufacturer:            manufacturer_id,
					Dealer:                  dealer_id,
					Creator:                 adminUserInfo.AdminUser.Id,
					UpdateCreator:           0,
					Status:                  1,
					Ctime:                   time.Now().Unix(),
					Mtime:                   0,
					Price:                   price,
					WarehousingDetailId:     0,
					WarehouseOutDetailId:    0,
					CancelOutDetailId:       0,
					ExpireDate:              expiryDates,
					ProductDate:             productDates,
					MaxUnit:                 max_unit,
					MinUnit:                 "",
					StorehouseId:            storehouse_id,
				}
				drugFlow = append(drugFlow, flow)
			}
		}
	}
	//扣减库存逻辑
	for _, item := range cancelStockInfos {

		var total_number int64
		var out_number int64
		var can_number int64
		medical, _ := service.GetBaseDrugMedical(item.DrugId)
		//将当前退库数转为最小单位
		if item.MaxUnit == medical.MaxUnit {
			total_number = item.Count * medical.MinNumber
		}
		if item.MaxUnit == medical.MinUnit {
			total_number = item.Count
		}
		//查询当前药品退库的批次号的总入库数
		infoWareInfo, _ := service.GetDrugWarehouseInfo(item.BatchNumberId)
		var total_count int64
		total_count = infoWareInfo.WarehousingCount * medical.MinNumber

		//查询该批次的出库数量
		outInfo, _ := service.GetDrugWarehouseOutInfo(item.BatchNumberId, item.DrugId)

		//查询该批次总的退库数量
		canInfo, _ := service.GetCancelDrugStockOutInfo(item.BatchNumberId, item.DrugId)

		for _, it := range canInfo {
			if it.MaxUnit == medical.MaxUnit {
				it.Count = it.Count * medical.MinNumber
			}
			if it.MaxUnit == medical.MinUnit {
				it.Count = it.Count
			}
		}

		for _, it := range canInfo {
			can_number += it.Count
		}

		for _, it := range outInfo {
			if it.CountUnit == medical.MaxUnit {
				it.Count = it.Count * medical.MinNumber
			}
			if it.CountUnit == medical.MinUnit {
				it.Count = it.Count
			}
		}
		for _, it := range outInfo {
			out_number += it.Count
		}

		if out_number == 0 {
			service.UpdateDrugCancel(item.CancelStockId)
			c.ServeSuccessJSON(map[string]interface{}{
				"msg": "2",
			})
			return
		}
		fmt.Println("当前退库数", total_count)
		fmt.Println("当前批次总库存", total_count)
		fmt.Println("总出库数", out_number)
		//判断退库数量是否大于总入库数量
		if total_number > total_count {
			service.UpdateDrugCancel(item.CancelStockId)
			c.ServeSuccessJSON(map[string]interface{}{
				"msg": "2",
			})
			return
		}

		//判断总退库数量是否大于出库数量

		if can_number+total_number > out_number {
			//清空退库单
			service.UpdateDrugCancel(item.CancelStockId)
			c.ServeSuccessJSON(map[string]interface{}{
				"msg": "2",
			})
			return
		}

		//正常退库
		if total_number <= out_number {
			//创建退库详情
			errs := service.CreateCancelStockInfoTwo(item)
			lastInfo, _ := service.GetLastStockInfoThree(item.DrugId)
			//创建库存明细
			flows := models.DrugFlow{
				WarehousingId:           0,
				DrugId:                  item.DrugId,
				Number:                  "",
				BatchNumber:             item.BatchNumber,
				Count:                   item.Count,
				UserOrgId:               adminUserInfo.CurrentOrgId,
				PatientId:               0,
				SystemTime:              ctime,
				ConsumableType:          4,
				IsSys:                   0,
				WarehousingOrder:        infoWareInfo.WarehousingOrder,
				WarehouseOutId:          0,
				WarehouseOutOrderNumber: "",
				IsEdit:                  0,
				CancelStockId:           cancelStock.ID,
				CancelOrderNumber:       cancelStock.OrderNumber,
				Manufacturer:            manufacturer_id,
				Dealer:                  dealer_id,
				Creator:                 adminUserInfo.AdminUser.Id,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				Mtime:                   0,
				Price:                   item.Price,
				WarehousingDetailId:     0,
				WarehouseOutDetailId:    0,
				CancelOutDetailId:       lastInfo.ID,
				ExpireDate:              item.ExpiryDate,
				ProductDate:             item.ProductDate,
				MaxUnit:                 item.MaxUnit,
				MinUnit:                 "",
				StorehouseId:            storehouse_id,
			}
			errs = service.CreateDrugFlowOne(flows)

			var total int64

			if medical.MaxUnit == item.MaxUnit {
				total = item.Count

				warehouseInfo := models.XtDrugWarehouseInfo{
					StockMaxNumber: total,
				}

				errs = service.UpdateDrugWarehouseInfo(&warehouseInfo, item.BatchNumberId)
				//查询默认仓库
				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)
				if errs != nil {
					utils.ErrorLog(errs.Error())
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCancelStockFail)
					return
				}

				c.ServeSuccessJSON(map[string]interface{}{
					"msg": "1",
				})
			}

			if medical.MinUnit == item.MaxUnit && medical.MaxUnit != medical.MinUnit {
				total = item.Count
				warehouseInfo := models.XtDrugWarehouseInfo{
					StockMinNumber: total,
				}

				errs = service.UpdateDrugWarehouseInfoOne(&warehouseInfo, item.BatchNumberId)
				//查询默认仓库
				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)
				if errs != nil {
					utils.ErrorLog(errs.Error())
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCancelStockFail)
					return
				}

				c.ServeSuccessJSON(map[string]interface{}{
					"msg": "1",
				})
			}
		}

	}
}
func (c *StockDrugApiController) GetDrugCancelStockInfoList() {
	id, _ := c.GetInt64("id", 0)
	adminUserInfo := c.GetAdminUserInfo()

	cancelStockInfoList, _ := service.FindDrugCancelStockInfoById(id, adminUserInfo.CurrentOrgId)

	info, _ := service.FindCancelDrugById(id, adminUserInfo.CurrentOrgId)

	list, _ := service.GetAllStoreHouseList(adminUserInfo.CurrentOrgId)
	c.ServeSuccessJSON(map[string]interface{}{
		"list":      cancelStockInfoList,
		"info":      info,
		"houselist": list,
	})

}
func (c *StockDrugApiController) GetDrugCancelStockList() {
	page, _ := c.GetInt64("page", -1)
	limit, _ := c.GetInt64("limit", -1)
	start_time := c.GetString("start_time")
	end_time := c.GetString("end_time")
	types, _ := c.GetInt64("type", 0)
	keywords := c.GetString("keywords")
	storehouse_id, _ := c.GetInt64("storehouse_id")
	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 {
			c.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())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}

	adminUserInfo := c.GetAdminUserInfo()
	returnList, total, err := service.FindAllDrugCancelList(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords, storehouse_id)
	houseList, _ := service.GetAllStoreHouseList(adminUserInfo.CurrentOrgId)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"list":      returnList,
			"total":     total,
			"houseList": houseList,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}

}
func (this *StockDrugApiController) DeleteDrugCancelStock() {
	ids := this.GetString("ids")

	if len(ids) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	idArray := strings.Split(ids, ",")
	//获取入库数据
	list, _ := service.GetDrugWareInfoByCancelId(idArray)
	for _, item := range list {
		medical, _ := service.GetBaseDrugMedical(item.DrugId)
		if item.MaxUnit == medical.MaxUnit {
			//回退库存
			service.ModifyDrugWarehouseByInfoId(item.BatchNumberId, item.Count)

		}
		if item.MaxUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
			service.ModifyDrugWarehouseByStockMin(item.BatchNumberId, item.Count)
		}

		//查询默认仓库
		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)
	}
	err := service.DeleteDrugCancelStock(idArray)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteFail)
	} else {
		this.ServeSuccessJSON(map[string]interface{}{
			"msg": "删除成功",
		})
	}
}
func (this *StockDrugApiController) DeleteDrugCancelStockInfo() {
	id, _ := this.GetInt64("id", 0)

	if id == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	//查询
	cancelinfo, _ := service.GetDrugCancelById(id)

	drug, _ := service.GetBaseDrugMedical(cancelinfo.DrugId)
	if drug.MaxUnit == cancelinfo.MaxUnit {
		service.ModeFyDrugWareseInfo(cancelinfo.BatchNumberId, cancelinfo.Count)

	}
	if drug.MinUnit == cancelinfo.MaxUnit && drug.MaxUnit != drug.MinUnit {
		service.ModeFyDrugWarehouseMin(cancelinfo.BatchNumberId, cancelinfo.Count)
	}

	//扣减库存
	err := service.UpDateDrugCancleStockStatus(id)

	//删除流水
	service.UpDateDrugCancelStockById(cancelinfo.ID)

	//查询默认仓库
	houseConfig, _ := service.GetAllStoreHouseConfig(cancelinfo.OrgId)
	//查询默认仓库剩余多少库存
	list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, cancelinfo.OrgId, cancelinfo.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(cancelinfo.DrugId, sum_count, sum_in_count, cancelinfo.OrgId)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteFail)
	} else {
		this.ServeSuccessJSON(map[string]interface{}{
			"msg": "删除成功",
		})
	}

}
func (c *StockDrugApiController) EditDrugCancelStock() {
	cancel_time := c.GetString("cancel_time")
	id, _ := c.GetInt64("id", 0)
	types, _ := c.GetInt64("type", 0)
	manufacturer_id, _ := c.GetInt64("manufacturer_id", 0)
	dealer_id, _ := c.GetInt64("dealer_id", 0)
	storehouse_id, _ := c.GetInt64("storehouse_id")
	if id == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	ctime := time.Now().Unix()
	mtime := time.Now().Unix()
	adminUserInfo := c.GetAdminUserInfo()

	cancelDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", cancel_time)
	if parseDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", cancelDate, parseDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	cancelStock, _ := service.FindDrugCancelStockById(id)

	tempCancelStock := models.DrugCancelStock{
		ID:           cancelStock.ID,
		Mtime:        mtime,
		ReturnTime:   cancelDate.Unix(),
		Manufacturer: manufacturer_id,
		Dealer:       dealer_id,
		StorehouseId: storehouse_id,
	}

	service.EditDrugCancelStock(tempCancelStock)

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

	var cancelStockInfos []*models.DrugCancelStockInfo
	var upDateCancelStockInfos []*models.DrugCancelStockInfo
	var drugFlow []*models.DrugFlow
	if dataBody["cancelStock"] != nil && reflect.TypeOf(dataBody["cancelStock"]).String() == "[]interface {}" {
		thisCancelStock, _ := dataBody["cancelStock"].([]interface{})
		if len(thisCancelStock) > 0 {
			for _, item := range thisCancelStock {
				items := item.(map[string]interface{})

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

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

				count, _ := strconv.ParseInt(items["count"].(string), 10, 64)

				if items["price"] == nil || reflect.TypeOf(items["price"]).String() != "string" {
					utils.ErrorLog("price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				price, _ := strconv.ParseFloat(items["price"].(string), 64)
				total := float64(count) * price

				if items["retail_price"] == nil || reflect.TypeOf(items["retail_price"]).String() != "string" {
					utils.ErrorLog("retail_price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				retail_price, _ := strconv.ParseFloat(items["retail_price"].(string), 64)
				retail_price_total := float64(count) * retail_price

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

				max_unit := items["max_unit"].(string)
				batch_number := items["batch_number"].(string)

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

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

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

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

				var productDates int64
				var expiryDates int64

				if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "string" {
					expiryDates = 0
				} else {
					if len(items["expiry_date"].(string)) == 0 {
						expiryDates = 0

					} else {
						expiryDate, _ := items["expiry_date"].(string)
						expiry_date, _ := utils.ParseTimeStringToTime("2006-01-02", expiryDate)
						expiryDates = expiry_date.Unix()

					}

				}
				if items["product_date"] == nil || reflect.TypeOf(items["product_date"]).String() != "string" {
					productDates = 0
				} else {
					if len(items["product_date"].(string)) == 0 {
						productDates = 0

					} else {
						productDate, _ := items["product_date"].(string)
						product_date, _ := utils.ParseTimeStringToTime("2006-01-02", productDate)
						productDates = product_date.Unix()
					}

				}

				batch_number_id := int64(items["batch_number_id"].(float64))
				if id == 0 {
					cancelStockInfo := &models.DrugCancelStockInfo{
						DrugId:           drug_id,
						Count:            count,
						Status:           1,
						Ctime:            ctime,
						OrgId:            adminUserInfo.CurrentOrgId,
						OrderNumber:      cancelStock.OrderNumber,
						CancelStockId:    cancelStock.ID,
						Mtime:            time.Now().Unix(),
						Type:             types,
						RetailPrice:      retail_price,
						RetailTotalPrice: retail_price_total,
						Price:            price,
						Total:            total,
						Manufacturer:     manufacturer,
						Dealer:           dealer,
						RegisterAccount:  register_account,
						MaxUnit:          max_unit,
						BatchNumber:      batch_number,
						Remark:           remark,
						ProductDate:      productDates,
						ExpiryDate:       expiryDates,
						BatchNumberId:    batch_number_id,
						StorehouseId:     storehouse_id,
					}
					cancelStockInfos = append(cancelStockInfos, cancelStockInfo)

				} else {
					cancelStockInfo := &models.DrugCancelStockInfo{
						ID:               id,
						DrugId:           drug_id,
						Count:            count,
						Status:           1,
						Ctime:            ctime,
						OrgId:            adminUserInfo.CurrentOrgId,
						OrderNumber:      cancelStock.OrderNumber,
						CancelStockId:    cancelStock.ID,
						Mtime:            time.Now().Unix(),
						Type:             types,
						RetailPrice:      retail_price,
						RetailTotalPrice: retail_price_total,
						Price:            price,
						Total:            total,
						Manufacturer:     manufacturer,
						Dealer:           dealer,
						RegisterAccount:  register_account,
						MaxUnit:          max_unit,
						BatchNumber:      batch_number,
						Remark:           remark,
						ProductDate:      productDates,
						ExpiryDate:       expiryDates,
						BatchNumberId:    batch_number_id,
						StorehouseId:     storehouse_id,
					}
					upDateCancelStockInfos = append(upDateCancelStockInfos, cancelStockInfo)
				}

				flow := &models.DrugFlow{
					WarehousingId:           0,
					DrugId:                  drug_id,
					Number:                  "",
					BatchNumber:             batch_number,
					Count:                   count,
					UserOrgId:               adminUserInfo.CurrentOrgId,
					PatientId:               0,
					SystemTime:              time.Now().Unix(),
					ConsumableType:          4,
					IsSys:                   0,
					WarehousingOrder:        "",
					WarehouseOutId:          0,
					WarehouseOutOrderNumber: "",
					IsEdit:                  0,
					CancelStockId:           cancelStock.ID,
					CancelOrderNumber:       cancelStock.OrderNumber,
					Manufacturer:            0,
					Dealer:                  0,
					Creator:                 adminUserInfo.AdminUser.Id,
					UpdateCreator:           adminUserInfo.AdminUser.Id,
					Status:                  1,
					Ctime:                   time.Now().Unix(),
					Mtime:                   0,
					Price:                   price,
					WarehousingDetailId:     0,
					WarehouseOutDetailId:    0,
					CancelOutDetailId:       0,
					ExpireDate:              expiryDates,
					ProductDate:             productDates,
					MaxUnit:                 max_unit,
					MinUnit:                 "",
					StorehouseId:            storehouse_id,
				}
				drugFlow = append(drugFlow, flow)
			}
		}
	}

	var errs error
	if len(cancelStockInfos) > 0 {

		//扣减库存逻辑
		for _, item := range cancelStockInfos {
			medical, _ := service.GetBaseDrugMedical(item.DrugId)
			//查询当前药品退库的批次号的总入库数
			infoWareInfo, _ := service.GetDrugWarehouseInfo(item.BatchNumberId)

			var total_count int64
			var cancel_count int64
			var out_count int64
			total_count = infoWareInfo.StockMaxNumber*medical.MinNumber + infoWareInfo.StockMinNumber
			//转化为最小单位
			var total_number int64
			if item.MaxUnit == medical.MaxUnit {
				total_number = item.Count * medical.MinNumber
			}
			if item.MaxUnit == medical.MinUnit {
				total_number = item.Count
			}

			//统计该批次的总出库数
			outInfo, _ := service.GetDrugWarehouseOutInfo(item.BatchNumberId, item.DrugId)
			for _, item := range outInfo {
				if item.CountUnit == medical.MaxUnit {
					item.Count = item.Count * medical.MinNumber
				}
				if item.CountUnit == medical.MinUnit {
					item.Count = item.Count
				}
			}

			for _, item := range outInfo {
				out_count += item.Count
			}

			//判断退库数量是否大于出库数量
			cancelInfo, _ := service.GetCancelDrugStockOutInfo(item.BatchNumberId, item.DrugId)
			for _, item := range cancelInfo {
				if item.MaxUnit == medical.MaxUnit {
					item.Count = item.Count * medical.MinNumber
				}
				if item.MaxUnit == medical.MinUnit {
					item.Count = item.Count
				}
			}

			for _, item := range cancelInfo {
				cancel_count += item.Count
			}

			if total_number+cancel_count > out_count {
				c.ServeSuccessJSON(map[string]interface{}{
					"msg": "4",
				})
				return
			}

			//判断退库数量是否大于总入库数量
			if total_number > total_count {
				c.ServeSuccessJSON(map[string]interface{}{
					"msg": "2",
				})
				return
			}

			//正常退库
			if total_number <= total_count {
				//创建退库详情
				errs := service.CreateDrugCancelStockInfo(cancelStockInfos)
				//创建库存明细
				//查询这个药品这个订单是否已存在流水
				for _, items := range drugFlow {
					drugwarehouseinfo, _ := service.GetLastDrugCancelStockInfoById(items.DrugId)
					items.CancelOutDetailId = drugwarehouseinfo.ID
					_, errsId := service.GetCancelStockId(items.CancelStockId, items.DrugId)
					if errsId == gorm.ErrRecordNotFound {

						errs = service.CreateDrugFlowTwo(items)
					}
				}

				//获取该批次最后一条退库详情
				lastCancel, _ := service.GetLastCancelStockInfo(id)
				var cancel_number int64
				if lastCancel.MaxUnit == medical.MaxUnit {
					cancel_number = lastCancel.Count * medical.MinNumber
				}

				if lastCancel.MaxUnit == medical.MinUnit {
					cancel_number = lastCancel.Count
				}

				var total int64

				if medical.MaxUnit == item.MaxUnit {
					total = item.Count - cancel_number

					warehouseInfo := models.XtDrugWarehouseInfo{
						StockMaxNumber: total,
					}
					errs = service.UpdateDrugWarehouseInfo(&warehouseInfo, item.BatchNumberId)

					if errs != nil {
						utils.ErrorLog(errs.Error())
						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCancelStockFail)
						return
					}

					c.ServeSuccessJSON(map[string]interface{}{
						"msg": "1",
					})
				}
				if medical.MinUnit == item.MaxUnit && medical.MaxUnit != medical.MinUnit {
					total = item.Count - cancel_number
					warehouseInfo := models.XtDrugWarehouseInfo{
						StockMinNumber: total,
					}

					errs = service.UpdateDrugWarehouseInfoOne(&warehouseInfo, item.BatchNumberId)

					//查询默认仓库
					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)

					if errs != nil {
						utils.ErrorLog(errs.Error())
						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCancelStockFail)
						return
					}

					c.ServeSuccessJSON(map[string]interface{}{
						"msg": "1",
					})
				}

			}

		}
	}
	if len(drugFlow) > 0 {
		for _, items := range drugFlow {
			_, errsId := service.GetCancelStockId(items.CancelStockId, items.DrugId)
			if errsId == gorm.ErrRecordNotFound {
				errs = service.CreateDrugFlowTwo(items)
			}
		}
	}

	if len(upDateCancelStockInfos) > 0 {
		var total int64
		var out_count int64
		var cancel_count int64
		var now_count int64
		var all_count int64
		for _, item := range upDateCancelStockInfos {

			//查询最后一条退库记录
			info, _ := service.GetLastCancelStockInfoOne(id, item.DrugId)

			errs = service.UpDateDrugCancelStockInfo(item)

			//查询该药品的信息
			medical, _ := service.GetBaseDrugMedical(item.DrugId)
			//统计该批次的总出库数
			outInfo, _ := service.GetDrugWarehouseOutInfo(item.BatchNumberId, item.DrugId)
			//查询该批次的总退库数量
			cancelInfo, _ := service.GetTotalDrugCancelInfo(item.BatchNumberId, item.DrugId, item.ID)
			for _, item := range outInfo {
				if item.CountUnit == medical.MaxUnit {
					item.Count = item.Count * medical.MinNumber
				}
				if item.CountUnit == medical.MinUnit {
					item.Count = item.Count
				}
			}

			for _, item := range outInfo {
				out_count += item.Count
			}

			for _, item := range cancelInfo {
				if item.MaxUnit == medical.MaxUnit {
					item.Count = item.Count * medical.MinNumber
				}
				if item.MaxUnit == medical.MinUnit {
					item.Count = item.Count
				}
			}

			for _, item := range cancelInfo {
				cancel_count += item.Count
			}

			fmt.Println("out_count232233332232323223", out_count)

			if item.MaxUnit == medical.MaxUnit {
				now_count = item.Count * medical.MinNumber
			}
			if item.MaxUnit == medical.MinUnit {
				now_count = item.Count
			}
			fmt.Println("hhhhhh2323322323", now_count+cancel_count)
			//总退库批次
			all_count = now_count + cancel_count

			//该批次的总出库数小与退库数报错返回
			if all_count > out_count {
				c.ServeSuccessJSON(map[string]interface{}{
					"msg": "4",
				})
				return
			}

			if item.MaxUnit == medical.MaxUnit {
				//更新库存
				total = item.Count - info.Count
				parseDateErr := service.UpdatedDrugInfo(item.BatchNumberId, total)
				fmt.Println("parseDateErr", parseDateErr)

				flow := models.DrugFlow{
					Count: item.Count,
				}
				service.UpdatedDrugFlow(info.CancelStockId, item.DrugId, flow)
			}

			if item.MaxUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
				item.Count = item.Count
				total = item.Count - info.Count
				service.UpdatedDrugInfoOne(item.BatchNumberId, total)

				flow := models.DrugFlow{
					Count: item.Count,
				}
				service.UpdatedDrugFlow(info.CancelStockId, item.DrugId, flow)
			}

			//查询默认仓库
			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)

		}
	}

	if errs != nil {
		utils.ErrorLog(errs.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateCancelStockFail)
		return
	}

	c.ServeSuccessJSON(map[string]interface{}{
		"msg": "1",
	})

}

func (c *StockDrugApiController) GetAllConfig() {
	adminUserInfo := c.GetAdminUserInfo()
	manufacturer, _ := service.FindAllManufacturer(adminUserInfo.CurrentOrgId)
	dealer, _ := service.FindAllDealer(adminUserInfo.CurrentOrgId)
	stockIns, _ := service.FindStockInNumber(adminUserInfo.CurrentOrgId)
	drugs, _ := service.GetDrugs(adminUserInfo.CurrentOrgId)
	list, _ := service.GetAllStoreHouseListThree(adminUserInfo.CurrentOrgId)
	configlist, _ := service.GetAllStoreHouseConfig(adminUserInfo.CurrentOrgId)
	appId := c.GetAdminUserInfo().CurrentAppId
	doctorList, _ := service.GetAllDoctorListSix(adminUserInfo.CurrentOrgId, appId)
	c.ServeSuccessJSON(map[string]interface{}{
		"manufacturer": manufacturer,
		"dealer":       dealer,
		"drugs":        drugs,
		"numbers":      stockIns,
		"list":         list,
		"configlist":   configlist,
		"doctorList":   doctorList,
	})
}

func (c *StockDrugApiController) GetAllDrugStock() {
	adminUserInfo := c.GetAdminUserInfo()
	manufacturer_id, _ := c.GetInt64("manufacturer_id", 0)
	dealer_id, _ := c.GetInt64("dealer_id", 0)
	drugs, err := service.FindAllDrugByManufactureId(manufacturer_id, dealer_id, adminUserInfo.CurrentOrgId)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"drugs": drugs,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (c *StockDrugApiController) GetDrugQueryInfo() {
	page, _ := c.GetInt64("page", -1)
	limit, _ := c.GetInt64("limit", -1)
	keyword := c.GetString("keyword")
	drug_category, _ := c.GetInt64("drug_category")
	start_time := c.GetString("start_time")
	end_time := c.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 {
			fmt.Println(err)
			c.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())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	adminUserInfo := c.GetAdminUserInfo()
	list, total, err := service.FindAllDrugStockInfo(adminUserInfo.CurrentOrgId, page, limit, keyword, drug_category, startTime, endTime)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"list":  list,
			"total": total,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (this *StockDrugApiController) GetUserDetailInfo() {
	order_id, _ := this.GetInt64("id")
	if order_id <= 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	adminUserInfo := this.GetAdminUserInfo()
	userDetails, err, total := service.FindDrugStockUserDetailById(adminUserInfo.CurrentOrgId, order_id)

	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list":  userDetails,
			"total": total,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}

}

func (this *StockDrugApiController) GetCancelDrugOrderPrint() {

	orderId := this.GetString("order_id")
	ids := strings.Split(orderId, ",")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, _ := service.GetCancelDrugOrderPrint(ids, orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *StockDrugApiController) GetDrugCancelExportList() {

	orderId := this.GetString("order_id")
	fmt.Println("order_id2323232323223", orderId)
	ids := strings.Split(orderId, ",")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, _ := service.GetDrugCancelExportList(ids, orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (c *StockDrugApiController) GetDrugWarehouseInfoPrint() {

	start_time := c.GetString("start_time")
	end_time := c.GetString("end_time")
	fmt.Println("开始实际23323233322323", start_time)
	order_type, _ := c.GetInt64("order_type")
	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 {
			fmt.Println(err)
			c.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())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	adminUserInfo := c.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	if order_type == 1 {
		list, err := service.GetDrugWarehouseInfoPrint(startTime, endTime, orgId)
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"list": list,
			})
			return
		}
	}
}

func (c *StockDrugApiController) GetDrugOutOrderPrint() {

	start_time := c.GetString("start_time")
	end_time := c.GetString("end_time")
	order_type, _ := c.GetInt64("order_type")
	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 {
			fmt.Println(err)
			c.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())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	adminUserInfo := c.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	if order_type == 2 {
		list, err := service.GetDrugOutOrderInfoPrintList(startTime, endTime, orgId)
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"list": list,
			})
			return
		}
	}

}

func (c *StockDrugApiController) GetConfigList() {
	adminUserInfo := c.GetAdminUserInfo()
	manufacturer, _ := service.FindAllManufacturer(adminUserInfo.CurrentOrgId)
	dealer, _ := service.FindAllDealer(adminUserInfo.CurrentOrgId)
	stockIns, _ := service.FindStockInNumber(adminUserInfo.CurrentOrgId)
	list, _ := service.GetAllStoreHouseListThree(adminUserInfo.CurrentOrgId)
	configlist, _ := service.GetAllStoreHouseConfig(adminUserInfo.CurrentOrgId)
	appId := c.GetAdminUserInfo().CurrentAppId
	doctorList, _ := service.GetAllDoctorListSix(adminUserInfo.CurrentOrgId, appId)
	c.ServeSuccessJSON(map[string]interface{}{
		"manufacturer": manufacturer,
		"dealer":       dealer,
		"numbers":      stockIns,
		"list":         list,
		"configlist":   configlist,
		"doctorList":   doctorList,
	})
}