XT_New/controllers/stock_in_api_controller.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 StockManagerApiController struct {
	BaseAuthAPIController
}

func StockManagerApiRegistRouters() {

	//入库管理和其他入库管理相关接口
	beego.Router("/api/warehouse/create", &StockManagerApiController{}, "post:CreateWarehouse")
	beego.Router("/api/warehouse/list", &StockManagerApiController{}, "get:GetWarehouseList")
	beego.Router("/api/warehouse/delete", &StockManagerApiController{}, "post:DeleteWarehouse")
	beego.Router("/api/warehouseinfo/delete", &StockManagerApiController{}, "post:DeleteWarehouseInfo")
	beego.Router("/api/warehouseinfo/list", &StockManagerApiController{}, "get:GetWarehouseInfoList")
	beego.Router("/api/warehouse/edit", &StockManagerApiController{}, "post:EditWarehouse")

	//退货管理和其他退货管理相关接口
	beego.Router("/api/salesreturn/create", &StockManagerApiController{}, "post:CreateSalesReturn")
	beego.Router("/api/salesreturn/delete", &StockManagerApiController{}, "post:DeleteSalesReturn")
	beego.Router("/api/salesreturninfo/delete", &StockManagerApiController{}, "post:DeleteSalesReturnInfo")
	beego.Router("/api/salesreturninfo/list", &StockManagerApiController{}, "get:GetSalesReturnInfoList")
	beego.Router("/api/salesreturn/list", &StockManagerApiController{}, "get:GetSalesReturnList")
	beego.Router("/api/salesreturn/edit", &StockManagerApiController{}, "post:EditReturnInfo")

	//出库管理和其他出库管理相关接口
	beego.Router("/api/warehouseout/create", &StockManagerApiController{}, "post:CreateWarehouseOut")
	beego.Router("/api/warehouseout/delete", &StockManagerApiController{}, "post:DeleteWarehouseOut")
	beego.Router("/api/warehouseoutinfo/delete", &StockManagerApiController{}, "post:DeleteWarehouseOutInfo")
	beego.Router("/api/warehouseout/list", &StockManagerApiController{}, "get:GetWarehouseOutList")
	beego.Router("/api/warehouseout/edit", &StockManagerApiController{}, "post:EditWarehouseOut")
	beego.Router("/api/warehouseout/info", &StockManagerApiController{}, "get:GetWarehouseOutInfoList")

	//出库退库管理和其他出库退库管理相关接口
	beego.Router("/api/cancelstock/create", &StockManagerApiController{}, "post:CreateCancelStock")
	beego.Router("/api/cancelstock/list", &StockManagerApiController{}, "get:GetCancelStockList")
	beego.Router("/api/cancelstock/info", &StockManagerApiController{}, "get:GetCancelStockInfoList")
	beego.Router("/api/cancelstock/delete", &StockManagerApiController{}, "post:DeleteCancelStock")
	beego.Router("/api/cancelstockinfo/delete", &StockManagerApiController{}, "post:DeleteCancelStockInfo")
	beego.Router("/api/cancelstockinfo/edit", &StockManagerApiController{}, "post:EditCancelStock")
	beego.Router("/api/cancelstockinfo/config", &StockManagerApiController{}, "get:GetCancelStockConfig")

	//库存相关全局配置
	beego.Router("/api/stock/config", &StockManagerApiController{}, "get:GetAllConfig")
	beego.Router("/api/return/config", &StockManagerApiController{}, "get:GetAllSalesReturnConfig")

	//库存查询
	beego.Router("/api/stock/query", &StockManagerApiController{}, "get:GetQueryInfo")

	beego.Router("/api/stock/detail", &StockManagerApiController{}, "get:GetDetailInfo")

	beego.Router("/api/warehouseout/user", &StockManagerApiController{}, "get:GetUserDetailInfo")

	beego.Router("/api/warehouseout/postsearchstock", &StockManagerApiController{}, "Get:PostSearchStock")

	beego.Router("/api/warehouseout/getoutstocktotalcount", &StockManagerApiController{}, "Get:GetOutStockTotalCount")

	beego.Router("/api/good/postgoodinformation", &StockManagerApiController{}, "Post:AddGoodInformation")

	beego.Router("/api/good/postdruginformation", &StockManagerApiController{}, "Post:AddDrugInformation")

	beego.Router("/api/good/initializtion", &StockManagerApiController{}, "Get:GetInitializtion")

	beego.Router("/api/good/getwarehouseorderinfolist", &StockManagerApiController{}, "Get:GetWarehouseOrderInfolist")

	beego.Router("/api/good/postsearchgoodlist", &StockManagerApiController{}, "Get:PostSearchGoodList")

	beego.Router("/api/good/getallstocklist", &StockManagerApiController{}, "Get:GetAllStockList")

	beego.Router("/api/stock/getstocklistbyid", &StockManagerApiController{}, "Get:GetStockListById")
	beego.Router("/api/stock/getstockoutlist", &StockManagerApiController{}, "Get:GetStockOutList")

	beego.Router("/api/good/getstockdrugcount", &StockManagerApiController{}, "Get:GetStockDrugCount")

	beego.Router("/api/good/getorderdetialbyorderid", &StockManagerApiController{}, "Get:GetOrderDetialByOrderId")
	beego.Router("/api/good/getorderdetaibyid", &StockManagerApiController{}, "Get:GetOrderDetailById")
	beego.Router("/api/good/getsingleoutorderdetail", &StockManagerApiController{}, "Get:GetSingleOutOrderDetail")
	beego.Router("/api/stock/getexportstocklist", &StockManagerApiController{}, "Get:GetExprotStockList")
	beego.Router("/api/stock/getoutexprotlist", &StockManagerApiController{}, "Get:GetOutExprotList")
	beego.Router("/api/stock/getsinglecancelorder", &StockManagerApiController{}, "Get:GetSingleCancelOrder")
	beego.Router("/api/stock/getcancelstockorderprint", &StockManagerApiController{}, "Get:GetCancelStockOrderPrint")
	beego.Router("/api/stock/getstockbatchnumber", &StockManagerApiController{}, "Get:GetStockBatchNumber")

	beego.Router("/api/stock/getstockflow", &StockManagerApiController{}, "Get:GetStockFlow")

	beego.Router("/api/cancel/getcancelexportlist", &StockManagerApiController{}, "Get:GetCancelExportList")

	//耗材调价
	beego.Router("/api/stock/postsearchgoodwarehouselist", &StockManagerApiController{}, "Get:GetSearchGoodWarehouseList")
	beego.Router("/api/stock/saveadjustprice", &StockManagerApiController{}, "Post:SaveAdjuestPrice")
	beego.Router("/api/stock/getallstockprice", &StockManagerApiController{}, "Get:GetAllStockPrice")
	beego.Router("/api/stock/savecheckedprice", &StockManagerApiController{}, "Get:SaveCheckPrice")
	beego.Router("/api/stock/getadjustpriceinfo", &StockManagerApiController{}, "Get:GetAdjustPriceById")
	beego.Router("/api/stock/savereportstock", &StockManagerApiController{}, "Post:SaveReportStock")
	beego.Router("/api/stock/getreportstocklist", &StockManagerApiController{}, "Get:GetReportStockList")
	beego.Router("/api/stock/savecheckdamage", &StockManagerApiController{}, "Get:SaveCheckDamage")
	beego.Router("/api/stock/saveinventory", &StockManagerApiController{}, "Post:SaveInventory")
	beego.Router("/api/stock/getinventorylist", &StockManagerApiController{}, "Get:GetInventorylist")
	beego.Router("/api/stock/savecheckinventory", &StockManagerApiController{}, "Get:SaveCheckInventory")
	beego.Router("/api/stock/getmodifypriceDetail", &StockManagerApiController{}, "Get:GetModifyPriceDetail")
	beego.Router("/api/stock/updatestockprice", &StockManagerApiController{}, "Get:UpdateStockPrice")
	beego.Router("/api/stock/deletestockprice", &StockManagerApiController{}, "Get:DeleteStockPrice")
	beego.Router("/api/stock/getstockdamagedetal", &StockManagerApiController{}, "Get:GetStockDamageDetail")
	beego.Router("/api/sotck/modifyprice", &StockManagerApiController{}, "Get:ModifyPrice")
	beego.Router("/api/stock/deletestockdamage", &StockManagerApiController{}, "Get:DeleteDamage")
	beego.Router("/api/stock/getstockdamagebyid", &StockManagerApiController{}, "Get:GetStockDamageById")
	beego.Router("api/sotck/getinventorydetail", &StockManagerApiController{}, "Get:GetInventoryDetail")
	beego.Router("/api/stock/modifyinventory", &StockManagerApiController{}, "Get:ModifyInventory")
	beego.Router("/api/stock/deleteinventory", &StockManagerApiController{}, "Get:DeleteInventory")
	beego.Router("/api/stock/getinventorydetaillist", &StockManagerApiController{}, "Get:GetInventoryDetailList")
	beego.Router("/api/stock/getinventoryprintlist", &StockManagerApiController{}, "Get:GetInventoryPrintList")
	beego.Router("/api/stock/getinventorydetailprintlist", &StockManagerApiController{}, "Get:GetInventoryDetailPrintList")
	beego.Router("/api/drug/deletedrugprice", &StockManagerApiController{}, "Get:DeleteDrugPrice")
	beego.Router("/api/stock/getgoodwarehouselist", &StockManagerApiController{}, "Get:GetGoodWarehouseList")
	beego.Router("/api/stock/proofinventory", &StockManagerApiController{}, "Get:ProofInventory")
	beego.Router("/api/stock/getwarehousetotal", &StockManagerApiController{}, "Get:GetWarehouseTotal")
	beego.Router("/api/stock/getgoodinventorywarehouselist", &StockManagerApiController{}, "Get:GetGoodInventoryWarehouseList")
	beego.Router("/api/stock/savestockinentorylist", &StockManagerApiController{}, "Post:SaveStockInventoryList")
	beego.Router("/api/sotck/getdamagedetailbygoodid", &StockManagerApiController{}, "Get:GetDamageDetailByGoodId")
	beego.Router("/api/stock/getinventoryexportlist", &StockManagerApiController{}, "Get:GetInventoryExportList")

	//处理历史数据
	beego.Router("/api/stock/updatecancelstockorder", &StockManagerApiController{}, "Get:UpdateCancelStockOrder")

	beego.Router("/api/stock/getdrugdetailsummary", &StockManagerApiController{}, "Get:GetDrugDetailSummary")
	beego.Router("/api/stock/getgooddetialsummary", &StockManagerApiController{}, "Get:GetGoodDetailSummary")

	//库存优化接口
	beego.Router("/api/stock/checkwarehouseout", &StockManagerApiController{}, "Get:CheckWarehouseOut")
	beego.Router("/api/stock/returncheckwarehouseout", &StockManagerApiController{}, "Get:ReturnCheckWarehouseOut")
	beego.Router("/api/stock/tocheckwarehouseinfo", &StockManagerApiController{}, "Get:CheckWarehouseInfo")
	beego.Router("/api/stock/returncheckwarehouseinfo", &StockManagerApiController{}, "Get:ReturnCheckWarehouseInfo")
	beego.Router("/api/stock/checkstockwarehouseinfo", &StockManagerApiController{}, "Get:CheckStockWarehouseInfo")
	beego.Router("/api/stock/checkreturnstockwarehouseinfo", &StockManagerApiController{}, "Get:CheckReturnStockWarehouseInfo")
	beego.Router("/api/stock/getprintlist", &StockManagerApiController{}, "Get:GetPrintList")

	beego.Router("/api/stock/getwarehouseinfolist", &StockManagerApiController{}, "Get:GetInvetoryWarehouseInfoList")

	//结算成功后调用操作库存相关接口
	beego.Router("/api/settle/stock", &StockManagerApiController{}, "Get:HandleSettleStock")
	beego.Router("/api/settle/cancelstock", &StockManagerApiController{}, "Get:HandleRefundStock")

	beego.Router("/api/stock/getnewgoodwarehouseinfo", &StockManagerApiController{}, "Get:GetNewGoodWarehouseInfo")
	beego.Router("/api/stock/getnewwarehouseoutinfolist", &StockManagerApiController{}, "Get:GetNewWarehouseOutInfoList")

}
func (c *StockManagerApiController) HandleRefundStock() {
	order_id, _ := c.GetInt64("order_id", 0)
	order, _ := service.GetHisOrderByIDThree(order_id)
	if order.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	orders, _ := service.GetHisOrderDetailByNumberThree(order.Number, order.UserOrgId)
	houseConfig, _ := service.GetAllStoreHouseConfig(order.UserOrgId)
	var goods []*models.DialysisBeforePrepareGoods
	var newGoods []*models.NewDialysisBeforePrepareGoods
	var infos []*models.HisDoctorAdviceInfo

	for _, info := range orders {
		if info.AdviceId > 0 && info.ProjectId == 0 {
			infos = append(infos, &info.HisDoctorAdviceInfo)
		}
		if info.ProjectId > 0 && info.AdviceId == 0 {
			if info.HisPrescriptionProject.Type == 3 {
				var good models.DialysisBeforePrepareGoods
				var newGood models.NewDialysisBeforePrepareGoods
				good.GoodId = info.HisPrescriptionProject.VMGoodInfo.ID
				good.GoodTypeId = info.HisPrescriptionProject.VMGoodInfo.GoodTypeId
				count, _ := strconv.Atoi(info.HisPrescriptionProject.Count)
				good.Count = int64(count)
				good.StorehouseId = houseConfig.StorehouseOutInfo
				good.ProjectId = info.HisPrescriptionProject.ID
				goods = append(goods, &good)

				newGood.GoodId = info.HisPrescriptionProject.VMGoodInfo.ID
				newGood.GoodTypeId = info.HisPrescriptionProject.VMGoodInfo.GoodTypeId
				count2, _ := strconv.Atoi(info.HisPrescriptionProject.Count)
				newGood.Count = int64(count2)
				newGood.StorehouseId = houseConfig.StorehouseOutInfo
				newGood.ProjectId = info.HisPrescriptionProject.ID
				newGoods = append(newGoods, &newGood)
			}
		}
	}
	for _, item := range infos {
		//service.HisDrugsDelivery(item.UserOrgId, order.Creator, item)
		service.DrugAutoAddCancelInfo(item, order.Creator)

	}

}
func (c *StockManagerApiController) HandleSettleStock() {
	order_id, _ := c.GetInt64("order_id", 0)
	order, _ := service.GetHisOrderByID(order_id)
	if order.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	orders, _ := service.GetHisOrderDetailByNumberTwo(order.Number, order.UserOrgId)
	houseConfig, _ := service.GetAllStoreHouseConfig(order.UserOrgId)
	var goods []*models.DialysisBeforePrepareGoods
	var newGoods []*models.NewDialysisBeforePrepareGoods
	var infos []*models.HisDoctorAdviceInfo

	for _, info := range orders {
		if info.AdviceId > 0 && info.ProjectId == 0 {
			infos = append(infos, &info.HisDoctorAdviceInfo)
		}
		if info.ProjectId > 0 && info.AdviceId == 0 {
			if info.HisPrescriptionProject.Type == 3 {
				var good models.DialysisBeforePrepareGoods
				var newGood models.NewDialysisBeforePrepareGoods
				good.GoodId = info.HisPrescriptionProject.VMGoodInfo.ID
				good.GoodTypeId = info.HisPrescriptionProject.VMGoodInfo.GoodTypeId
				count, _ := strconv.Atoi(info.HisPrescriptionProject.Count)
				good.Count = int64(count)
				good.StorehouseId = houseConfig.StorehouseOutInfo
				good.ProjectId = info.HisPrescriptionProject.ID
				goods = append(goods, &good)

				newGood.GoodId = info.HisPrescriptionProject.VMGoodInfo.ID
				newGood.GoodTypeId = info.HisPrescriptionProject.VMGoodInfo.GoodTypeId
				count2, _ := strconv.Atoi(info.HisPrescriptionProject.Count)
				newGood.Count = int64(count2)
				newGood.StorehouseId = houseConfig.StorehouseOutInfo
				newGood.ProjectId = info.HisPrescriptionProject.ID
				newGoods = append(newGoods, &newGood)
			}
		}
	}
	service.ConsumablesDeliveryTotal(order.UserOrgId, order.PatientId, order.SettleAccountsDate, goods, newGoods, order.Creator)
	for _, item := range infos {
		service.HisDrugsDelivery(item.UserOrgId, order.Creator, item)
	}
}

func (c *StockManagerApiController) CreateWarehouse() {

	warehousing_time := c.GetString("warehousing_time")
	types, _ := c.GetInt64("type", 0)
	storehouse_id, _ := c.GetInt64("storehouse_id")
	warehousing_info_id, _ := c.GetInt64("warehousing_info_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.FindAllWarehouseTotal(adminUserInfo.CurrentOrgId)
	total = total + 1
	warehousing_order := "RKD" + 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.Warehousing{
		WarehousingOrder: warehousing_order,
		OperationTime:    operation_time,
		OrgId:            adminUserInfo.CurrentOrgId,
		Creater:          creater,
		Ctime:            ctime,
		Status:           1,
		WarehousingTime:  warehousingDate.Unix(),
		Type:             types,
		StorehouseId:     storehouse_id,
		IsCheck:          2,
	}
	if warehousing_info_id == 0 {
		service.AddSigleWarehouse(&warehousing)
	}
	if warehousing_info_id > 0 {
		service.UpdateWarehouse(warehousing_info_id, storehouse_id)
	}
	info, _ := service.FindLastWarehousingSix(adminUserInfo.CurrentOrgId)
	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.WarehousingInfo

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

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

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

				if items["good_type_id"] == nil || reflect.TypeOf(items["good_type_id"]).String() != "float64" {
					utils.ErrorLog("good_type_id")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				good_type_id := int64(items["good_type_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["packing_price"] == nil || reflect.TypeOf(items["packing_price"]).String() != "string" {
					utils.ErrorLog("packing_price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				packing_price, _ := strconv.ParseFloat(items["packing_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)

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

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

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

				register_number, _ := items["register_number"].(string)
				//入库单表格
				warehouseInfo := &models.WarehousingInfo{
					ID:               id,
					WarehousingOrder: warehousing.WarehousingOrder,
					WarehousingId:    info.ID,
					GoodId:           good_id,
					Number:           number,
					GoodTypeId:       good_type_id,
					ProductDate:      productDates,
					ExpiryDate:       expiryDates,
					WarehousingCount: warehousing_count,
					Price:            price,
					TotalPrice:       total,
					Status:           1,
					Ctime:            warehousingDate.Unix(),
					Remark:           remark,
					OrgId:            adminUserInfo.CurrentOrgId,
					Type:             types,
					Manufacturer:     manufacturer,
					StockCount:       0,
					Dealer:           dealer,
					LicenseNumber:    license_number,
					PackingPrice:     packing_price,
					StorehouseId:     storehouse_id,
					IsCheck:          2,
					RegisterNumber:   register_number,
				}
				warehousingInfo = append(warehousingInfo, warehouseInfo)

			}
		}
	}

	for _, item := range warehousingInfo {
		if item.ID == 0 {
			service.CreatedWarehouseingDetail(item)
		}
		if item.ID > 0 {
			service.UpdateWarehouseDetail(item, item.ID)
		}

	}

	//查询入库数据
	list, _ := service.GetGoodWarehouseInfoById(info.ID, info.OrgId)
	dealerList, _ := service.GetAllDealerList(adminUserInfo.CurrentOrgId)
	manufacturerList, _ := service.GetAllManufacturerList(adminUserInfo.CurrentOrgId)

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

}
func (c *StockManagerApiController) GetWarehouseList() {
	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")
	check_type, _ := c.GetInt64("check_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()
	var ids []int64
	var goodids []int64
	//查询商品名称
	if len(keywords) > 0 {
		//查询商品名称
		list, _ := service.GetGoodInforByGoodName(keywords, adminUserInfo.CurrentOrgId)
		for _, item := range list {
			goodids = append(goodids, item.ID)
			//入库详情但里面查询
		}
		if len(goodids) > 0 {
			info, _ := service.GetWarehoureOrderInfoByGoodId(goodids, startTime, endTime, adminUserInfo.CurrentOrgId, storehouse_id)
			for _, it := range info {
				ids = append(ids, it.WarehousingId)
			}
		}
	}
	warehouseList, total, err := service.FindAllWarehousingList(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords, ids, storehouse_id, check_type)
	fmt.Println("ottal--------", total)
	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 *StockManagerApiController) GetWarehouseInfoList() {

	id := c.GetString("id")
	idArray := strings.Split(id, ",")
	warehousing, err := service.FindWarehousingByIdOne(idArray)

	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}

	var ids []int64

	for _, item := range warehousing {
		ids = append(ids, item.ID)
	}

	warehousingInfo, err := service.FindWarehousingInfoByIdOne(ids)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"info":        warehousingInfo,
			"warehousing": warehousing,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}
func (c *StockManagerApiController) EditWarehouse() {
	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.FindWarehousingById(id)

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

	service.EditWarehousing(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.WarehousingInfo
	var upDateWarehousingInfo []*models.WarehousingInfo
	var stockFlow []*models.VmStockFlow

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

				if items["good_type_id"] == nil || reflect.TypeOf(items["good_type_id"]).String() != "float64" {
					utils.ErrorLog("good_type_id")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				good_type_id := int64(items["good_type_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["packing_price"] == nil || reflect.TypeOf(items["packing_price"]).String() != "string" {
					utils.ErrorLog("packing_price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				packing_price, _ := strconv.ParseFloat(items["packing_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)

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

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

				if id == 0 {
					warehouseInfo := &models.WarehousingInfo{
						WarehousingOrder: warehouse.WarehousingOrder,
						WarehousingId:    warehouse.ID,
						GoodId:           good_id,
						Number:           number,
						GoodTypeId:       good_type_id,
						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,
						StockCount:       warehousing_count,
						LicenseNumber:    license_number,
						PackingPrice:     packing_price,
						StorehouseId:     storehouse_id,
						IsCheck:          2,
						RegisterNumber:   register_number,
					}
					warehousingInfo = append(warehousingInfo, warehouseInfo)

				} else {

					warehouseInfo := &models.WarehousingInfo{
						ID:               id,
						WarehousingOrder: warehouse.WarehousingOrder,
						WarehousingId:    warehouse.ID,
						GoodId:           good_id,
						Number:           number,
						GoodTypeId:       good_type_id,
						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,
						LicenseNumber:    license_number,
						PackingPrice:     packing_price,
						StorehouseId:     storehouse_id,
						RegisterNumber:   register_number,
					}
					upDateWarehousingInfo = append(upDateWarehousingInfo, warehouseInfo)

					flow := &models.VmStockFlow{
						WarehousingOrder:    warehousing.WarehousingOrder,
						WarehousingId:       id,
						GoodId:              good_id,
						Number:              number,
						ProductDate:         productDates,
						ExpireDate:          expiryDates,
						Count:               warehousing_count,
						Price:               price,
						Status:              1,
						Ctime:               ctime,
						UserOrgId:           adminUserInfo.CurrentOrgId,
						Manufacturer:        manufacturer,
						Dealer:              dealer,
						LicenseNumber:       license_number,
						IsEdit:              2,
						Creator:             adminUserInfo.AdminUser.Id,
						SystemTime:          ctime,
						ConsumableType:      1,
						WarehousingDetailId: warehouseInfo.ID,
						StorehouseId:        storehouse_id,
						RegisterNumber:      register_number,
					}

					stockFlow = append(stockFlow, flow)
				}
			}
		}
	}
	var errs error
	if len(warehousingInfo) > 0 {
		errs = service.CreateWarehousingInfo(warehousingInfo)
	}

	if len(upDateWarehousingInfo) > 0 {
		for _, item := range upDateWarehousingInfo {
			service.UpdateWarehouseInfoByGoodIdOne(item, item.ID)
		}
	}

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

	list, _ := service.GetAllStockInList(id, adminUserInfo.CurrentOrgId)
	manufacturerList, _ := service.GetAllManufacturerList(adminUserInfo.CurrentOrgId)
	dealerList, _ := service.GetAllDealerList(adminUserInfo.CurrentOrgId)
	c.ServeSuccessJSON(map[string]interface{}{
		"msg":              "编辑成功",
		"list":             list,
		"manufacturerList": manufacturerList,
		"dealerList":       dealerList,
	})

}
func (c *StockManagerApiController) DeleteWarehouse() {
	ids := c.GetString("ids")
	if len(ids) == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	idArray := strings.Split(ids, ",")
	err := service.DeleteWarehouse(idArray)
	//删除流水
	service.DeleteStockFlow(idArray)

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

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

	err := service.UpDateWarehouseStatus(id)
	service.UpdatedStockFlowById(id)
	//查询入库记录
	info, _ := service.GetWarehouseInfoByIdTwenty(id, orgId)
	//查询该机构默认仓库
	storeConfig, _ := service.GetAllStoreHouseConfig(orgId)
	//查询剩余库存
	goodList, _ := service.GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, info.GoodId, orgId)
	var sum_count int64
	var sum_in_count int64
	for _, item := range goodList {
		sum_count += item.StockCount
		sum_in_count += item.WarehousingCount
	}
	service.UpdateGoodByGoodId(info.GoodId, sum_count, sum_in_count, info.OrgId)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteFail)
	} else {
		c.ServeSuccessJSON(map[string]interface{}{
			"msg": "删除成功",
		})
	}

}

func (c *StockManagerApiController) CreateSalesReturn() {
	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 := "THD" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000" + strconv.FormatInt(total, 10)

	salesReturn := models.SalesReturn{
		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.AddSigleSalesReturn(&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.SalesReturnInfo

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

				if items["good_type_id"] == nil || reflect.TypeOf(items["good_type_id"]).String() != "float64" {
					utils.ErrorLog("good_type_id")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				good_type_id := int64(items["good_type_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)
				price, _ := strconv.ParseFloat(items["price"].(string), 10)
				total := float64(count) * price

				salesReturnInfo := &models.SalesReturnInfo{
					OrderNumber:   salesReturn.OrderNumber,
					SalesReturnId: salesReturn.ID,
					GoodId:        good_id,
					GoodTypeId:    good_type_id,
					Count:         count,
					Price:         price,
					Total:         total,
					Status:        1,
					Ctime:         ctime,
					OrgId:         adminUserInfo.CurrentOrgId,
					Type:          types,
					Manufacturer:  manufacturer_id,
					Dealer:        dealer_id,
				}

				salesReturnInfos = append(salesReturnInfos, salesReturnInfo)

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

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

}
func (c *StockManagerApiController) GetSalesReturnList() {
	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.FindAllReturnList(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 *StockManagerApiController) DeleteSalesReturn() {
	ids := this.GetString("ids")

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

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

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

}
func (this *StockManagerApiController) GetSalesReturnInfoList() {
	id, _ := this.GetInt64("id", 0)
	list, _ := service.FindAllSalesReturnInfoById(id)
	salesReturn, _ := service.FindAllSalesReturnById(id)

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

}
func (c *StockManagerApiController) EditReturnInfo() {
	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.FindSalesReturnById(id)

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

	service.EditSaleReturn(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.SalesReturnInfo
	var upDateReturnInfos []*models.SalesReturnInfo

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

				if items["good_type_id"] == nil || reflect.TypeOf(items["good_type_id"]).String() != "float64" {
					utils.ErrorLog("good_type_id")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				good_type_id := int64(items["good_type_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 id == 0 {
					returnInfo := &models.SalesReturnInfo{
						GoodId:        good_id,
						GoodTypeId:    good_type_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,
					}
					returnInfos = append(returnInfos, returnInfo)

				} else {
					returnInfo := &models.SalesReturnInfo{
						ID:            id,
						GoodId:        good_id,
						GoodTypeId:    good_type_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,
					}
					upDateReturnInfos = append(upDateReturnInfos, returnInfo)
				}
			}
		}
	}
	var errs error
	if len(returnInfos) > 0 {
		errs = service.CreateSalesReturnInfo(returnInfos)
	}

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

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

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

}

func (c *StockManagerApiController) CreateWarehouseOut() {

	types, _ := c.GetInt64("type", 0)
	storehouse_id, _ := c.GetInt64("storehouse_id")
	warehouseOut_id, _ := c.GetInt64("warehouseOut_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.FindAllWarehouseOut(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 = "CKD" + strconv.FormatInt(number, 10)

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

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

	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.WarehouseOutInfo

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

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

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

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

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

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

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

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

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

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

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

				timeLayout := "2006-01-02"
				loc, _ := time.LoadLocation("Local")
				var expiryDate int64
				if len(expiry_date) > 0 {
					theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", expiry_date+" 00:00:00", loc)
					if err != nil {
						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
						return
					}
					expiryDate = theTime.Unix()
				}

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

				var productDate int64
				if len(product_date) > 0 {
					theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", product_date+" 00:00:00", loc)
					if err != nil {
						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
						return
					}
					productDate = theTime.Unix()
				}
				license_number := items["license_number"].(string)

				warehouseOutInfo := &models.WarehouseOutInfo{
					ID:                      id,
					WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
					WarehouseOutId:          warehouseOut.ID,
					GoodId:                  good_id,
					GoodTypeId:              good_type_id,
					Count:                   count,
					Price:                   price,
					TotalPrice:              total,
					Status:                  1,
					Ctime:                   ctime,
					Remark:                  remark,
					OrgId:                   adminUserInfo.CurrentOrgId,
					Type:                    types,
					Manufacturer:            manufacturer,
					Number:                  number,
					ExpiryDate:              expiryDate,
					ProductDate:             productDate,
					Dealer:                  dealer,
					LicenseNumber:           license_number,
					WarehouseInfotId:        warehouse_info_id,
					StorehouseId:            storehouse_id,
					AdminUserId:             admin_user_id,
					BuyPrice:                buy_price,
					StockCount:              stock_count,
					IsCheck:                 2,
					RegisterNumber:          register_number,
					SysRecordTime:           warehouseOut.WarehouseOutTime,
				}
				warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)

			}
		}
	}
	fmt.Println("warehouseOut_id", warehouseOut_id)
	if warehouseOut_id == 0 {
		//查询是否生成出库单
		_, errcodes := service.FindStockOutByIsSys(adminUserInfo.CurrentOrgId, 0, operation_time)
		if errcodes == gorm.ErrRecordNotFound {
			service.AddSigleWarehouseOut(&warehouseOut)
		}
	}

	if warehouseOut_id > 0 {
		service.UpdateSingleWarehoseOut(warehouseOut_id, storehouse_id)
	}

	goodWarehouseOut, _ := service.GetLastGoodWarehouseOutTwenty(adminUserInfo.CurrentOrgId)

	for _, it := range warehousingOutInfo {
		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			WarehouseOutId:          goodWarehouseOut.ID,
			WarehouseInfotId:        0,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  it.Remark,
			OrgId:                   adminUserInfo.CurrentOrgId,
			Type:                    1,
			Manufacturer:            it.Manufacturer,
			Dealer:                  it.Dealer,
			IsSys:                   0,
			SysRecordTime:           it.SysRecordTime,
			GoodTypeId:              it.GoodTypeId,
			GoodId:                  it.GoodId,
			ExpiryDate:              it.ExpiryDate,
			ProductDate:             it.ProductDate,
			Number:                  it.Number,
			Price:                   it.Price,
			LicenseNumber:           it.LicenseNumber,
			SupplyWarehouseId:       0,
			StorehouseId:            storehouse_id,
			AdminUserId:             it.AdminUserId,
			BuyPrice:                it.BuyPrice,
			StockCount:              it.StockCount,
			Count:                   it.Count,
			IsCheck:                 2,
			RegisterNumber:          it.RegisterNumber,
		}
		if it.ID == 0 {
			service.AddSigleWarehouseOutInfo(warehouseOutInfo)

		}
		if it.ID > 0 {
			service.ModifyWarehouseOutInfo(it.ID, warehouseOutInfo)
		}
	}
	appId := adminUserInfo.CurrentAppId

	warehouseOutInfoList, _ := service.GetLastGoodWarehouseOutInfo(adminUserInfo.CurrentOrgId, goodWarehouseOut.ID)
	manufacturerList, _ := service.GetAllManufacturerList(adminUserInfo.CurrentOrgId)
	dealerList, _ := service.GetAllDealerList(adminUserInfo.CurrentOrgId)
	doctorList, _ := service.GetAllDoctorListSix(adminUserInfo.CurrentOrgId, appId)
	c.ServeSuccessJSON(map[string]interface{}{
		"msg":                  "2",
		"good_name":            "",
		"specification_name":   "",
		"warehouseOut":         goodWarehouseOut,
		"warehouseOutInfoList": warehouseOutInfoList,
		"manufacturerList":     manufacturerList,
		"dealerList":           dealerList,
		"doctorList":           doctorList,
	})
	return
}
func (c *StockManagerApiController) GetWarehouseOutList() {
	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")
	check_type, _ := c.GetInt64("check_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.GetGoodInforByGoodName(keywords, adminUserInfo.CurrentOrgId)
		for _, item := range list {
			goodids = append(goodids, item.ID)
		}

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

	}
	warehouseOutList, total, err := service.FindAllWarehouseOutListOne(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords, ids, storehouse_id, way_type, check_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 *StockManagerApiController) DeleteWarehouseOut() {
	ids := c.GetString("ids")

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

	idArray := strings.Split(ids, ",")

	err := service.DeleteWarehouseOut(idArray)
	//list, _ := service.GetWarehouseOutInfoByIds(idArray)
	//for _, item := range list {
	//	//添加库存
	//	service.UpdateWarehouseInfoById(item.WarehouseInfotId, item.Count)
	//	//添加库存
	//	//查询该机构默认仓库
	//	storeConfig, _ := service.GetAllStoreHouseConfig(item.OrgId)
	//	//查询剩余库存
	//	goodList, _ := service.GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, item.GoodId, item.OrgId)
	//	var sum_count int64
	//	var sum_in_count int64
	//	for _, item := range goodList {
	//		sum_count += item.StockCount
	//		sum_in_count += item.WarehousingCount
	//	}
	//	service.UpdateGoodByGoodId(item.GoodId, sum_count, sum_in_count, item.OrgId)
	//}
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteFail)
	} else {
		c.ServeSuccessJSON(map[string]interface{}{
			"msg": "删除成功",
		})
	}
}
func (this *StockManagerApiController) DeleteWarehouseOutInfo() {
	id, _ := this.GetInt64("id", 0)
	fmt.Println(id)
	if id == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	err := service.UpDateWarehouseOutStatus(id)
	//添加库存
	//out, _ := service.GetWarhouseOutById(id)
	//
	//service.UpdateWareInfoById(out.WarehouseInfotId, out.Count)
	//
	////查询该机构默认仓库
	//storeConfig, _ := service.GetAllStoreHouseConfig(out.OrgId)
	////查询剩余库存
	//goodList, _ := service.GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, out.GoodId, out.OrgId)
	//var sum_count int64
	//var sum_in_count int64
	//for _, item := range goodList {
	//	sum_count += item.StockCount
	//	sum_in_count += item.WarehousingCount
	//}
	//service.UpdateGoodByGoodId(out.GoodId, sum_count, sum_in_count, out.OrgId)
	//
	//
	//service.UpdateStockFlowWarehouseOutById(id)

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

}
func (c *StockManagerApiController) GetWarehouseOutInfoList() {
	id, _ := c.GetInt64("id", 0)
	warehouseOutInfo, _ := service.FindWarehouseOutInfoById(id)
	warehouseOut, _ := service.FindWareHouseOutById(id)
	adminUserInfo := c.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	wareoutList, _ := service.GetWareOutInfoById(id, orgId)
	c.ServeSuccessJSON(map[string]interface{}{
		"list":        warehouseOutInfo,
		"info":        warehouseOut,
		"wareoutList": wareoutList,
	})

}
func (c *StockManagerApiController) EditWarehouseOut() {
	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
	}

	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.FindWareHouseOutById(id)

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

	service.EditWarehouseOut(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.WarehouseOutInfo
	var upDateWarehouseOutInfos []*models.WarehouseOutInfo

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

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

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

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

				timeLayout := "2006-01-02"
				loc, _ := time.LoadLocation("Local")
				expiry_date := items["expiry_date"].(string)

				var expiryDate int64
				if len(expiry_date) > 0 {
					theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", expiry_date+" 00:00:00", loc)
					if err != nil {
						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
						return
					}
					expiryDate = theTime.Unix()
				}

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

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

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

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

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

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

				var productDate int64
				if len(product_date) > 0 {
					theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", product_date+" 00:00:00", loc)
					if err != nil {
						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
						return
					}
					productDate = theTime.Unix()
				}

				if id == 0 {
					warehouseOutInfo := &models.WarehouseOutInfo{
						WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
						WarehouseOutId:          warehouseOut.ID,
						GoodId:                  good_id,
						GoodTypeId:              good_type_id,
						Count:                   count,
						Price:                   price,
						TotalPrice:              total,
						Status:                  1,
						Ctime:                   warehouseOut.WarehouseOutTime,
						Mtime:                   time.Now().Unix(),
						Remark:                  remark,
						OrgId:                   adminUserInfo.CurrentOrgId,
						Type:                    types,
						IsSys:                   0,
						SysRecordTime:           warehouseOut.WarehouseOutTime,
						Number:                  number,
						ExpiryDate:              expiryDate,
						ProductDate:             productDate,
						Dealer:                  dealer,
						Manufacturer:            manufacturer,
						LicenseNumber:           license_number,
						ConsumableType:          1,
						WarehouseInfotId:        warehouse_info_id,
						StorehouseId:            storehouse_id,
						AdminUserId:             admin_user_id,
						StockCount:              stock_count,
						RegisterNumber:          register_number,
					}
					warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)

				} 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.WarehouseOutInfo{
						ID:                      id,
						WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
						WarehouseOutId:          warehouseOut.ID,
						GoodId:                  good_id,
						GoodTypeId:              good_type_id,
						Count:                   count,
						Price:                   price,
						TotalPrice:              total,
						Status:                  1,
						Ctime:                   warehouseOut.WarehouseOutTime,
						Remark:                  remark,
						OrgId:                   adminUserInfo.CurrentOrgId,
						Mtime:                   time.Now().Unix(),
						Type:                    types,
						Manufacturer:            manufacturer,
						IsSys:                   is_sys,
						SysRecordTime:           sys_record_time,
						Number:                  number,
						ExpiryDate:              expiryDate,
						ProductDate:             productDate,
						Dealer:                  dealer,
						LicenseNumber:           license_number,
						ConsumableType:          2,
						WarehouseInfotId:        warehouse_info_id,
						StorehouseId:            storehouse_id,
						AdminUserId:             admin_user_id,
						StockCount:              stock_count,
						RegisterNumber:          register_number,
					}
					upDateWarehouseOutInfos = append(upDateWarehouseOutInfos, warehouseOutInfo)
				}
			}
		}
	}

	var errs error

	//新增出库
	if len(warehousingOutInfo) > 0 {

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

		for _, item := range warehousingOutInfo {
			service.AddSigleWarehouseOutInfo(item)
		}
	}

	if len(upDateWarehouseOutInfos) > 0 {
		for _, item := range upDateWarehouseOutInfos {
			service.UpDateWarehouseOutInfo(item)
			////1.查询该耗材该批次的最后一次出库记录
			//lastGood, _ := service.GetLastGoodInformationByGoodId(item.GoodId, item.WarehouseInfotId, item.OrgId)
			//
			////如果出库数量大于 最后一次批次的数量(那么要进行出库)
			//
			//if item.Count > lastGood.Count {
			//
			//	//查询该耗材是否还有库存
			//	warehouseinfo, _ := service.GetTotalCountByGoodId(item.GoodId, item.StorehouseId)
			//
			//	//无库存
			//	if warehouseinfo.StockCount <= 0 {
			//		c.ServeSuccessJSON(map[string]interface{}{
			//			"msg": "5",
			//		})
			//		return
			//	}
			//
			//	//有库存,进行出库,调用出库接口
			//	if warehouseinfo.StockCount > 0 {
			//		var total int64
			//		var stock_cout int64
			//		var total_count int64
			//		//计算和最后一次出库数据的差
			//		total = item.Count - lastGood.Count
			//
			//		if total > warehouseinfo.StockCount {
			//			c.ServeSuccessJSON(map[string]interface{}{
			//				"msg": "6",
			//			})
			//			return
			//		}
			//		//获取该耗材该批次的剩余库存量
			//		info, _ := service.GetLastGoodCountById(item.GoodId, item.WarehouseInfotId)
			//
			//		//判断该批次的剩余库存 和出库的库存进行比较
			//		//如果出库的库存大于该批次的剩余库存,那么需要出库下一批次的库存
			//
			//		if total > info.StockCount {
			//			//计算出库和该批次相差的库存
			//			total_count = item.Count - info.StockCount
			//			//清空本批次次库存
			//			service.DeleteWarehouseInfo(item.WarehouseInfotId)
			//			//调用出库逻辑
			//			parseDateErr := service.ConsumablesDeliveryTwo(item.OrgId, item, total_count)
			//			if parseDateErr != nil {
			//				utils.ErrorLog(errs.Error())
			//				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
			//				return
			//			}
			//		}
			//		//如果与上次比的库存小于或等于于该批次的剩余库存,那么需要该批次出库
			//		if total <= info.StockCount {
			//			stock_cout = lastGood.Count + total
			//			fmt.Println(stock_cout)
			//			//扣减库存
			//			warehouse := models.WarehousingInfo{
			//				StockCount: info.StockCount - total,
			//			}
			//			errs := service.UpdateWarehousingInfo(warehouse, info.ID)
			//
			//			warehouseOutInfo := &models.WarehouseOutInfo{
			//				WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			//				WarehouseOutId:          id,
			//				WarehouseInfotId:        item.WarehouseInfotId,
			//				Status:                  1,
			//				Ctime:                   time.Now().Unix(),
			//				Remark:                  item.Remark,
			//				OrgId:                   item.OrgId,
			//				Type:                    1,
			//				Manufacturer:            item.Manufacturer,
			//				Dealer:                  item.Dealer,
			//				IsSys:                   0,
			//				SysRecordTime:           item.SysRecordTime,
			//				GoodTypeId:              item.GoodTypeId,
			//				GoodId:                  item.GoodId,
			//				ExpiryDate:              item.ExpiryDate,
			//				ProductDate:             item.ProductDate,
			//				Number:                  item.Number,
			//				Price:                   item.Price,
			//				LicenseNumber:           item.LicenseNumber,
			//				Count:                   item.Count,
			//				ConsumableType:          2,
			//				StorehouseId:            item.StorehouseId,
			//				AdminUserId:             item.AdminUserId,
			//				StockCount:              item.StockCount,
			//			}
			//
			//			//查询是否存在
			//			_, errcode := service.GetWarehouseOutInfoIsExist(item.ID)
			//			if errcode == gorm.ErrRecordNotFound {
			//
			//				errOne := service.AddSigleWarehouseOutInfo(warehouseOutInfo)
			//				if errOne != nil {
			//					utils.ErrorLog(errs.Error())
			//					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
			//					return
			//				}
			//			} else if errcode == nil {
			//				service.UpDateWarehouseOutInfo(item)
			//				//更新流水
			//				flow := models.VmStockFlow{
			//					Number:        item.Number,
			//					LicenseNumber: item.LicenseNumber,
			//					Count:         item.Count,
			//					Manufacturer:  item.Manufacturer,
			//					Dealer:        item.Dealer,
			//					ProductDate:   item.ProductDate,
			//					ExpireDate:    item.ExpiryDate,
			//					Price:         item.Price,
			//					StorehouseId:  item.StorehouseId,
			//					AdminUserId:   item.AdminUserId,
			//					StockCount:    item.StockCount,
			//				}
			//				service.UpdateStockFlowByDetailId(flow, item.ID)
			//
			//				goodInfo := models.GoodInfo{
			//					Manufacturer: item.Manufacturer,
			//					Dealer:       item.Dealer,
			//				}
			//				service.UpdatedGoodInfo(goodInfo, item.GoodId)
			//			}
			//		}
			//	}
			//}
			//
			//var last_count int64
			//var all_total int64
			//var stock_total int64
			////如果退库数量小于最后一次批次的数量(要么要进行退库)
			//if item.Count < lastGood.Count {
			//
			//	//退库数量和最后一次出库数据进行计算
			//	last_count = lastGood.Count - item.Count
			//
			//	//获取该耗材该批次的剩余库存量
			//	infoInfo, _ := service.GetLastGoodCountById(item.GoodId, item.WarehouseInfotId)
			//
			//	//退库数量和最后一次出库数据进行计算的差 加上 剩余库存的数量与 该批次的入库数量进行比较
			//	all_total = last_count + infoInfo.StockCount
			//
			//	//如果库存大于总数量，则退回到这个批次
			//
			//	if infoInfo.WarehousingCount > all_total {
			//		stock_total = last_count + infoInfo.StockCount
			//
			//		//退回该批次,计算数量
			//		warehousingInfoOne := models.WarehousingInfo{
			//			StockCount:   stock_total,
			//			ID:           item.WarehouseInfotId,
			//			OrgId:        item.OrgId,
			//			StorehouseId: item.StorehouseId,
			//		}
			//
			//		parseDateErr := service.UpdateWarehousingInfo(warehousingInfoOne, item.WarehouseInfotId)
			//
			//		fmt.Println("parseDateErr", parseDateErr)
			//		//插入一条新纪录
			//		warehouseOutInfoThree := &models.WarehouseOutInfo{
			//			WarehouseOutOrderNumber: item.WarehouseOutOrderNumber,
			//			WarehouseOutId:          id,
			//			WarehouseInfotId:        item.WarehouseInfotId,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			Remark:                  item.Remark,
			//			OrgId:                   item.OrgId,
			//			Type:                    1,
			//			Manufacturer:            item.Manufacturer,
			//			Dealer:                  item.Dealer,
			//			IsSys:                   0,
			//			GoodTypeId:              item.GoodTypeId,
			//			GoodId:                  item.GoodId,
			//			ExpiryDate:              item.ExpiryDate,
			//			ProductDate:             item.ProductDate,
			//			Number:                  item.Number,
			//			Price:                   item.Price,
			//			LicenseNumber:           item.LicenseNumber,
			//			ConsumableType:          2,
			//			Count:                   item.Count,
			//			StorehouseId:            item.StorehouseId,
			//			AdminUserId:             item.AdminUserId,
			//			StockCount:              item.StockCount,
			//		}
			//		//查询是否存在
			//		_, errcode := service.GetWarehouseOutInfoIsExist(item.ID)
			//		if errcode == gorm.ErrRecordNotFound {
			//			errOne := service.AddSigleWarehouseOutInfo(warehouseOutInfoThree)
			//			if errOne != nil {
			//				utils.ErrorLog(errs.Error())
			//				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
			//				return
			//			}
			//
			//		} else if errcode == nil {
			//			service.UpDateWarehouseOutInfo(item)
			//			flow := models.VmStockFlow{
			//				Number:        item.Number,
			//				LicenseNumber: item.LicenseNumber,
			//				Count:         item.Count,
			//				Manufacturer:  item.Manufacturer,
			//				Dealer:        item.Dealer,
			//				ProductDate:   item.ProductDate,
			//				ExpireDate:    item.ExpiryDate,
			//				Price:         item.Price,
			//				StorehouseId:  item.StorehouseId,
			//				AdminUserId:   item.AdminUserId,
			//				StockCount:    item.StockCount,
			//			}
			//			service.UpdateStockFlowByDetailId(flow, item.ID)
			//			goodInfo := models.GoodInfo{
			//				Manufacturer: item.Manufacturer,
			//				Dealer:       item.Dealer,
			//			}
			//			service.UpdatedGoodInfo(goodInfo, item.GoodId)
			//
			//		}
			//	}
			//
			//	//如果库存小于总数量，则报错提醒，该批次的退库数据大于入库数据了无法退库,则需要退库到另一个批次
			//	if infoInfo.WarehousingCount < all_total {
			//		c.ServeSuccessJSON(map[string]interface{}{
			//			"msg": "6",
			//		})
			//		return
			//	}
			//}
			//
			//if item.Count == lastGood.Count {
			//
			//	errs = service.UpDateWarehouseOutInfo(item)
			//	flow := models.VmStockFlow{
			//		Number:        item.Number,
			//		LicenseNumber: item.LicenseNumber,
			//		Count:         item.Count,
			//		Manufacturer:  item.Manufacturer,
			//		Dealer:        item.Dealer,
			//		ProductDate:   item.ProductDate,
			//		ExpireDate:    item.ExpiryDate,
			//		Price:         item.Price,
			//		StorehouseId:  item.StorehouseId,
			//		AdminUserId:   item.AdminUserId,
			//		BuyPrice:      item.BuyPrice,
			//		StockCount:    item.StockCount,
			//	}
			//	service.UpdateStockFlowByDetailId(flow, item.ID)
			//	goodInfo := models.GoodInfo{
			//		Manufacturer: item.Manufacturer,
			//		Dealer:       item.Dealer,
			//	}
			//	service.UpdatedGoodInfo(goodInfo, item.GoodId)
			//
			//}
			//
			////查询该机构默认仓库
			//storeConfig, _ := service.GetAllStoreHouseConfig(adminUserInfo.CurrentOrgId)
			////查询剩余库存
			//goodList, _ := service.GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, item.GoodId, adminUserInfo.CurrentOrgId)
			//var sum_count int64
			//var sum_in_count int64
			//for _, item := range goodList {
			//	sum_count += item.StockCount
			//	sum_in_count += item.WarehousingCount
			//}
			//service.UpdateGoodByGoodId(item.GoodId, sum_count, sum_in_count, item.OrgId)

		}
	}

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

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

}

func (c *StockManagerApiController) CreateCancelStock() {

	cancel_stock_time := c.GetString("time")
	types, _ := c.GetInt64("type", 0)
	storehouse_id, _ := c.GetInt64("storehouse_id")
	cancel_stock_id, _ := c.GetInt64("cancel_stock_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.FindAllCancelStockTotal(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.CancelStock{
		OrderNumber:  orderNumber,
		OperaTime:    operation_time,
		OrgId:        adminUserInfo.CurrentOrgId,
		Creater:      creater,
		Ctime:        ctime,
		Status:       1,
		ReturnTime:   cancelStockDate.Unix(),
		Type:         types,
		StorehouseId: storehouse_id,
		IsCheck:      2,
	}
	if cancel_stock_id == 0 {
		service.AddSigleCancelStock(&cancelStock)
	} else {
		service.UpdateSigleCancelStock(cancel_stock_id, 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 cancelStockInfos []*models.CancelStockInfo
	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["id"] == nil || reflect.TypeOf(items["id"]).String() != "float64" {
					utils.ErrorLog("id")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				id := int64(items["id"].(float64))
				if items["good_id"] == nil || reflect.TypeOf(items["good_id"]).String() != "float64" {
					utils.ErrorLog("good_id")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				good_id := int64(items["good_id"].(float64))

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

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

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

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

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

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

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

					}
				}

				var productDates int64
				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()

					}
				}

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

				retail_prices := items["price"].(string)
				price, _ := strconv.ParseFloat(retail_prices, 64)
				cancelStockInfo := &models.CancelStockInfo{
					ID:              id,
					OrderNumber:     cancelStock.OrderNumber,
					CancelStockId:   cancelStock.ID,
					GoodId:          good_id,
					GoodTypeId:      good_type_id,
					Count:           count,
					Status:          1,
					Ctime:           ctime,
					OrgId:           adminUserInfo.CurrentOrgId,
					Type:            types,
					Manufacturer:    manufacturer,
					Dealer:          dealer,
					Number:          number,
					ProductDate:     productDates,
					ExpiryDate:      expiryDates,
					RegisterAccount: register_account,
					Remark:          remark,
					Price:           price,
					WarehouseInfoId: warehouse_info_id,
					StorehouseId:    storehouse_id,
					IsCheck:         2,
				}
				cancelStockInfos = append(cancelStockInfos, cancelStockInfo)

			}
		}
	}
	lastCancelStock, _ := service.GetLastCancelStockById(adminUserInfo.CurrentOrgId)
	for _, item := range cancelStockInfos {
		item.CancelStockId = lastCancelStock.ID
		if item.ID == 0 {
			service.CreateCancelStockInfoOne(item)
		}
		if item.ID > 0 {
			service.ModifyCancelStockInfo(item.ID, item)
		}
	}

	list, _ := service.GetCancelStockInfo(lastCancelStock.ID, adminUserInfo.CurrentOrgId)

	manufacturerList, _ := service.GetAllManufacturerList(adminUserInfo.CurrentOrgId)

	dealerList, _ := service.GetAllDealerList(adminUserInfo.CurrentOrgId)

	//	storehouse, _ := service.FindStoreHouseByStorehouseId(item.StorehouseId, item.OrgId)
	//	goodObj, _ := service.GetGoodInformationByGoodId(item.GoodId)
	//	info, _ := service.GetWarehoureOrderStockOutFlow(item.GoodId, item.OrgId, item.WarehouseInfoId, storehouse_id)
	//	if item.Count > info.Count {
	//		service.UpdateCancelInfo(item.CancelStockId)
	//
	//		c.ServeSuccessJSON(map[string]interface{}{
	//			"msg":                "2",
	//			"good_name":          goodObj.GoodName,
	//			"specification_name": goodObj.SpecificationName,
	//			"storehouse_name":    storehouse.StorehouseName,
	//		})
	//		return
	//	}
	//
	//	//查询该批次入库的值
	//	infolist, _ := service.GetWarehouseInfoByIdSeven(item.WarehouseInfoId)
	//
	//	if item.Count > infolist.WarehousingCount {
	//		c.ServeSuccessJSON(map[string]interface{}{
	//			"msg":                "4",
	//			"good_name":          goodObj.GoodName,
	//			"specification_name": goodObj.SpecificationName,
	//			"storehouse_name":    storehouse.StorehouseName,
	//		})
	//		return
	//	}
	//
	//	if item.Count <= infolist.WarehousingCount {
	//		_, msgerrkonde := service.GetCancelStockDetailByOrderNumber(orderNumber, adminUserInfo.CurrentOrgId)
	//		if msgerrkonde == gorm.ErrRecordNotFound {
	//			service.AddSigleCancelStock(&cancelStock)
	//		}
	//		listcancel, _ := service.GetLastCancelStockById(adminUserInfo.CurrentOrgId)
	//
	//		item.CancelStockId = listcancel.ID
	//		errs := service.CreateCancelStockInfoOne(item)
	//		list, _ := service.GetAllManufacturerList(adminUserInfo.CurrentOrgId)
	//
	//		var manufacturer_id int64
	//
	//		for _, items := range list {
	//			if item.Manufacturer == items.ManufacturerName {
	//				manufacturer_id = items.ID
	//			}
	//		}
	//		flow := models.VmStockFlow{
	//			WarehousingId:           0,
	//			GoodId:                  item.GoodId,
	//			Number:                  item.Number,
	//			LicenseNumber:           "",
	//			Count:                   item.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:            manufacturer_id,
	//			Dealer:                  0,
	//			Creator:                 adminUserInfo.AdminUser.Id,
	//			UpdateCreator:           0,
	//			Status:                  1,
	//			Ctime:                   time.Now().Unix(),
	//			Mtime:                   0,
	//			Price:                   item.Price,
	//			WarehousingDetailId:     0,
	//			WarehouseOutDetailId:    0,
	//			CancelOutDetailId:       0,
	//			ProductDate:             item.ProductDate,
	//			ExpireDate:              item.ExpiryDate,
	//			StorehouseId:            item.StorehouseId,
	//		}
	//		cancelStockInfo, _ := service.GetLastCancelStockInfoByGoodId(item.GoodId)
	//		flow.CancelStockId = cancelStockInfo.CancelStockId
	//		flow.CancelOutDetailId = cancelStockInfo.ID
	//		service.CreateStockFlowOne(flow)
	//		if errs != nil {
	//			utils.ErrorLog(errs.Error())
	//			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCancelStockFail)
	//			return
	//		}
	//
	//		//查询该批次的剩余库存
	//		wareouseinfo, _ := service.GetWarehouseInfoById(item.WarehouseInfoId)
	//		if (wareouseinfo.StockCount + item.Count) > wareouseinfo.WarehousingCount {
	//			c.ServeSuccessJSON(map[string]interface{}{
	//				"msg":                "5",
	//				"good_name":          goodObj.GoodName,
	//				"specification_name": goodObj.SpecificationName,
	//				"storehouse_name":    storehouse.StorehouseName,
	//			})
	//			return
	//		}
	//		//更改入库数量
	//		errs = service.UpdateWareInfoById(item.WarehouseInfoId, item.Count)
	//
	//		storeConfig, _ := service.GetAllStoreHouseConfig(adminUserInfo.CurrentOrgId)
	//		//查询剩余库存
	//		goodList, _ := service.GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, item.GoodId, adminUserInfo.CurrentOrgId)
	//		var sum_count int64
	//		var sum_in_count int64
	//		for _, it := range goodList {
	//			sum_count += it.StockCount
	//			sum_in_count += it.WarehousingCount
	//		}
	//		service.UpdateGoodByGoodId(item.GoodId, sum_count, sum_in_count, adminUserInfo.CurrentOrgId)
	//
	//		if err != nil {
	//			utils.ErrorLog(err.Error())
	//			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
	//			return
	//		}
	//	}
	//}

	c.ServeSuccessJSON(map[string]interface{}{
		"cancelStock":      lastCancelStock,
		"list":             list,
		"manufacturerList": manufacturerList,
		"dealerList":       dealerList,
	})
	return

}
func (c *StockManagerApiController) GetCancelStockInfoList() {
	id, _ := c.GetInt64("id", 0)

	cancelStockInfoList, _ := service.FindCancelStockInfoById(id)
	info, _ := service.FindCancelStockById(id, c.GetAdminUserInfo().CurrentOrgId)
	manufacturerList, _ := service.GetAllManufacturerList(c.GetAdminUserInfo().CurrentOrgId)
	dealerList, _ := service.GetAllDealerList(c.GetAdminUserInfo().CurrentOrgId)

	c.ServeSuccessJSON(map[string]interface{}{
		"list":             cancelStockInfoList,
		"info":             info,
		"manufacturerList": manufacturerList,
		"dealerList":       dealerList,
	})

}
func (c *StockManagerApiController) GetCancelStockList() {
	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")
	check_type, _ := c.GetInt64("check_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()
	returnList, total, err := service.FindAllCancelList(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords, storehouse_id, check_type)
	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 *StockManagerApiController) DeleteCancelStock() {
	ids := this.GetString("ids")

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

	idArray := strings.Split(ids, ",")
	////获取
	//list, _ := service.GetCancelWarehosueInfo(idArray)
	//for _, item := range list {
	//	info, _ := service.GetCancelStockById(item.WarehouseInfoId)
	//	warehousingInfo := models.WarehousingInfo{
	//		StockCount: info.Count,
	//	}
	//	//扣减库存
	//	service.ModefyWarehouseInfoNight(warehousingInfo, info.WarehouseInfoId)
	//
	//	//查询该机构默认仓库
	//	storeConfig, _ := service.GetAllStoreHouseConfig(item.OrgId)
	//	//查询剩余库存
	//	goodList, _ := service.GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, info.GoodId, item.OrgId)
	//	var sum_count int64
	//	var sum_in_count int64
	//	for _, item := range goodList {
	//		sum_count += item.StockCount
	//		sum_in_count += item.WarehousingCount
	//	}
	//	service.UpdateGoodByGoodId(info.GoodId, sum_count, sum_in_count, info.OrgId)
	//
	//	//删除流水
	//	service.UpdatedStockFlowByCancelId(info.ID, info.GoodId)
	//}
	//获取
	err := service.DeleteCancelStock(idArray)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteFail)
	} else {
		this.ServeSuccessJSON(map[string]interface{}{
			"msg": "删除成功",
		})
	}
}
func (this *StockManagerApiController) DeleteCancelStockInfo() {
	id, _ := this.GetInt64("id", 0)
	//fmt.Println(id)
	if id == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	////改变库存
	//info, _ := service.GetCancelStockById(id)
	//
	//warehousingInfo := models.WarehousingInfo{
	//	StockCount: info.Count,
	//}
	////扣减库存
	//service.ModefyWarehouseInfoNight(warehousingInfo, info.WarehouseInfoId)
	//
	////查询该机构默认仓库
	//storeConfig, _ := service.GetAllStoreHouseConfig(info.OrgId)
	////查询剩余库存
	//goodList, _ := service.GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, info.GoodId, info.OrgId)
	//var sum_count int64
	//var sum_in_count int64
	//for _, item := range goodList {
	//	sum_count += item.StockCount
	//	sum_in_count += item.WarehousingCount
	//}
	//service.UpdateGoodByGoodId(info.GoodId, sum_count, sum_in_count, info.OrgId)

	//删除详情
	err := service.UpDateCancleStockStatus(id)
	//删除流水
	//err = service.UpdatedStockFlowByCancelId(id, info.GoodId)

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

}
func (c *StockManagerApiController) EditCancelStock() {
	cancel_time := c.GetString("cancel_time")
	id, _ := c.GetInt64("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.FindCancelStockById(id, c.GetAdminUserInfo().CurrentOrgId)

	tempCancelStock := models.CancelStock{
		ID:           cancelStock.ID,
		Mtime:        mtime,
		ReturnTime:   cancelDate.Unix(),
		StorehouseId: storehouse_id,
	}

	service.EditCancelStock(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.CancelStockInfo
	var upDateCancelStockInfos []*models.CancelStockInfo
	var stockFlow []*models.VmStockFlow
	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["good_id"] == nil || reflect.TypeOf(items["good_id"]).String() != "float64" {
					utils.ErrorLog("good_id")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				good_id := int64(items["good_id"].(float64))

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

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

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

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

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

				var productDates int64
				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()

					}

				}
				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["price"] == nil || reflect.TypeOf(items["price"]).String() != "string" {
					utils.ErrorLog("price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				price, _ := strconv.ParseFloat(items["price"].(string), 64)

				warehouse_info_id := int64(items["warehouse_info_id"].(float64))
				if id == 0 {
					cancelStockInfo := &models.CancelStockInfo{
						GoodId:          good_id,
						GoodTypeId:      good_type_id,
						Count:           count,
						Status:          1,
						Ctime:           ctime,
						OrgId:           adminUserInfo.CurrentOrgId,
						OrderNumber:     cancelStock.OrderNumber,
						CancelStockId:   cancelStock.ID,
						Mtime:           time.Now().Unix(),
						Number:          number,
						RegisterAccount: register_account,
						Manufacturer:    manufacturer,
						Dealer:          dealer,
						ProductDate:     productDates,
						ExpiryDate:      expiryDates,
						Remark:          remark,
						Price:           price,
						WarehouseInfoId: warehouse_info_id,
						StorehouseId:    storehouse_id,
					}
					cancelStockInfos = append(cancelStockInfos, cancelStockInfo)

					flow := &models.VmStockFlow{
						WarehousingId:           0,
						GoodId:                  good_id,
						Number:                  number,
						LicenseNumber:           "",
						Count:                   count,
						UserOrgId:               adminUserInfo.CurrentOrgId,
						PatientId:               0,
						SystemTime:              time.Now().Unix(),
						ConsumableType:          4,
						IsSys:                   0,
						WarehousingOrder:        "",
						WarehouseOutId:          0,
						WarehouseOutOrderNumber: "",
						IsEdit:                  2,
						CancelStockId:           cancelStock.ID,
						CancelOrderNumber:       cancelStock.OrderNumber,
						Manufacturer:            0,
						Dealer:                  0,
						Creator:                 adminUserInfo.AdminUser.Id,
						UpdateCreator:           0,
						Status:                  1,
						Ctime:                   time.Now().Unix(),
						Mtime:                   0,
						Price:                   price,
						WarehousingDetailId:     warehouse_info_id,
						WarehouseOutDetailId:    0,
						CancelOutDetailId:       0,
						ProductDate:             productDates,
						ExpireDate:              expiryDates,
						StorehouseId:            storehouse_id,
					}

					stockFlow = append(stockFlow, flow)

				} else {
					cancelStockInfo := &models.CancelStockInfo{
						ID:              id,
						GoodId:          good_id,
						GoodTypeId:      good_type_id,
						Count:           count,
						Status:          1,
						Ctime:           ctime,
						OrgId:           adminUserInfo.CurrentOrgId,
						OrderNumber:     cancelStock.OrderNumber,
						CancelStockId:   cancelStock.ID,
						Mtime:           time.Now().Unix(),
						Number:          number,
						RegisterAccount: register_account,
						Manufacturer:    manufacturer,
						Dealer:          dealer,
						ProductDate:     productDates,
						ExpiryDate:      expiryDates,
						Remark:          remark,
						Price:           price,
						WarehouseInfoId: warehouse_info_id,
						StorehouseId:    storehouse_id,
					}
					upDateCancelStockInfos = append(upDateCancelStockInfos, cancelStockInfo)

					list, _ := service.GetAllManufacturerList(adminUserInfo.CurrentOrgId)

					var manufacuture_id int64
					for _, it := range list {
						if it.ManufacturerName == manufacturer {
							manufacuture_id = it.ID
						}
					}

					flow := &models.VmStockFlow{
						WarehousingId:           0,
						GoodId:                  good_id,
						Number:                  number,
						LicenseNumber:           "",
						Count:                   count,
						UserOrgId:               adminUserInfo.CurrentOrgId,
						PatientId:               0,
						SystemTime:              time.Now().Unix(),
						ConsumableType:          4,
						IsSys:                   0,
						WarehousingOrder:        "",
						WarehouseOutId:          0,
						WarehouseOutOrderNumber: "",
						IsEdit:                  2,
						CancelStockId:           cancelStock.ID,
						CancelOrderNumber:       cancelStock.OrderNumber,
						Manufacturer:            manufacuture_id,
						Dealer:                  0,
						Creator:                 adminUserInfo.AdminUser.Id,
						UpdateCreator:           0,
						Status:                  1,
						Ctime:                   time.Now().Unix(),
						Mtime:                   0,
						Price:                   price,
						WarehousingDetailId:     warehouse_info_id,
						WarehouseOutDetailId:    0,
						CancelOutDetailId:       0,
						ProductDate:             productDates,
						ExpireDate:              expiryDates,
						StorehouseId:            storehouse_id,
					}

					stockFlow = append(stockFlow, flow)
				}
			}
		}
	}
	var errs error
	for _, item := range cancelStockInfos {
		service.CreateCancelStockInfoOne(item)
	}
	if len(upDateCancelStockInfos) > 0 {
		for _, item := range upDateCancelStockInfos {
			service.ModifyCancelStockInfo(item.ID, item)
		}
	}
	//判断是否更改了仓库
	//if storehouse_id == cancelStock.ID {
	//
	//	if len(cancelStockInfos) > 0 {
	//
	//		for _, item := range cancelStockInfos {
	//			//统计该耗材的出库数量
	//			info, _ := service.GetWarehoureOrderStockOutFlow(item.GoodId, item.OrgId, item.WarehouseInfoId, storehouse_id)
	//			storeObj, _ := service.FindStoreHouseByStorehouseId(storehouse_id, item.OrgId)
	//			if item.Count > info.Count {
	//				c.ServeSuccessJSON(map[string]interface{}{
	//					"msg":             "2",
	//					"storehouse_name": storeObj.StorehouseName,
	//				})
	//				return
	//			}
	//			//查询该批次入库的值
	//			infolist, _ := service.GetWarehouseInfoByIdSix(item.WarehouseInfoId, storehouse_id)
	//
	//			if item.Count > infolist.WarehousingCount {
	//				c.ServeSuccessJSON(map[string]interface{}{
	//					"msg":             "4",
	//					"storehouse_name": storeObj.StorehouseName,
	//				})
	//				return
	//			}
	//
	//			if item.Count <= infolist.WarehousingCount {
	//
	//				errs := service.CreateCancelStockInfo(cancelStockInfos)
	//
	//				if errs != nil {
	//					utils.ErrorLog(errs.Error())
	//					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCancelStockFail)
	//					return
	//				}
	//
	//				//更改入库数量
	//				errs = service.UpdateWareInfoById(item.WarehouseInfoId, item.Count)
	//
	//				//查询该机构默认仓库
	//				storeConfig, _ := service.GetAllStoreHouseConfig(adminUserInfo.CurrentOrgId)
	//				//查询剩余库存
	//				goodList, _ := service.GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, item.GoodId, adminUserInfo.CurrentOrgId)
	//				var sum_count int64
	//				var sum_in_count int64
	//				for _, it := range goodList {
	//					sum_count += it.StockCount
	//					sum_in_count += it.WarehousingCount
	//				}
	//				service.UpdateGoodByGoodId(info.GoodId, sum_count, sum_in_count, adminUserInfo.CurrentOrgId)
	//
	//				break
	//			}
	//
	//		}
	//
	//		if len(stockFlow) > 0 {
	//			for _, itemcancel := range stockFlow {
	//				//查询是否存在
	//				stockInfo, errcode := service.IsExsitStockFlow(itemcancel.GoodId, itemcancel.CancelOrderNumber)
	//				if errcode == gorm.ErrRecordNotFound {
	//					service.CreateStockFlowSix(itemcancel)
	//				} else {
	//					flow := models.VmStockFlow{
	//						Count:        itemcancel.Count,
	//						Manufacturer: itemcancel.Manufacturer,
	//						Dealer:       itemcancel.Dealer,
	//						Price:        itemcancel.Price,
	//						ProductDate:  itemcancel.ProductDate,
	//						ExpireDate:   itemcancel.ExpireDate,
	//						StorehouseId: itemcancel.StorehouseId,
	//					}
	//					service.UpdateStockFlowThree(stockInfo.ID, flow)
	//				}
	//			}
	//		}
	//	}
	//
	//	if len(upDateCancelStockInfos) > 0 {
	//		for _, item := range upDateCancelStockInfos {
	//
	//			var all_total int64
	//			//获取该批次最后一套退库记录
	//			info, _ := service.GetLastCancelInfo(item.WarehouseInfoId, item.GoodId)
	//			//查询该批次总的退库数量
	//			list, _ := service.GetAllCancelInfoById(item.WarehouseInfoId, item.GoodId)
	//			for _, it := range list {
	//				all_total += it.Count
	//			}
	//
	//			//比较退库库数量和最后一次退库库数据大小
	//			//退库(加)
	//			if item.Count > info.Count {
	//				var total = item.Count - info.Count
	//				errs = service.UpDateCancelStockInfo(item)
	//
	//				warehouseinfo, _ := service.GetWarehouseInfoByIdSix(item.WarehouseInfoId, storehouse_id)
	//				storeObj, _ := service.FindStoreHouseByStorehouseId(storehouse_id, item.OrgId)
	//
	//				// 总退库数量大于入库数据
	//				if all_total > warehouseinfo.StockCount {
	//					c.ServeSuccessJSON(map[string]interface{}{
	//						"msg":             "5",
	//						"storehouse_name": storeObj.StorehouseName,
	//					})
	//					return
	//				}
	//				parseDateErr := service.UpdateWareInfoById(item.WarehouseInfoId, total)
	//
	//				if parseDateErr != nil {
	//					utils.ErrorLog(errs.Error())
	//					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
	//					break
	//				}
	//			}
	//			//(减)
	//			if item.Count < info.Count {
	//				errs = service.UpDateCancelStockInfo(item)
	//
	//				var total_count = info.Count - item.Count
	//
	//				parseDateErr := service.UpdateWareInfoByIdSix(item.WarehouseInfoId, total_count)
	//
	//				if parseDateErr != nil {
	//					utils.ErrorLog(errs.Error())
	//					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
	//					return
	//				}
	//
	//			}
	//			if item.Count == info.Count {
	//				errs = service.UpDateCancelStockInfo(item)
	//
	//			}
	//
	//			//查询该机构默认仓库
	//			storeConfig, _ := service.GetAllStoreHouseConfig(adminUserInfo.CurrentOrgId)
	//			//查询剩余库存
	//			goodList, _ := service.GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, item.GoodId, adminUserInfo.CurrentOrgId)
	//			var sum_count int64
	//			var sum_in_count int64
	//			for _, it := range goodList {
	//				sum_count += it.StockCount
	//				sum_in_count += it.WarehousingCount
	//			}
	//			service.UpdateGoodByGoodId(info.GoodId, sum_count, sum_in_count, adminUserInfo.CurrentOrgId)
	//		}
	//	}
	//
	//	if len(stockFlow) > 0 {
	//		for _, itemcancel := range stockFlow {
	//
	//			//查询是否存在
	//			stockInfo, errcode := service.IsExsitStockFlow(itemcancel.GoodId, itemcancel.CancelOrderNumber)
	//			if errcode == gorm.ErrRecordNotFound {
	//
	//			} else {
	//				flow := models.VmStockFlow{
	//					Count:         itemcancel.Count,
	//					Manufacturer:  itemcancel.Manufacturer,
	//					Dealer:        itemcancel.Dealer,
	//					Price:         itemcancel.Price,
	//					LicenseNumber: itemcancel.LicenseNumber,
	//					Number:        itemcancel.Number,
	//					ExpireDate:    itemcancel.ExpireDate,
	//					ProductDate:   itemcancel.ProductDate,
	//					StorehouseId:  itemcancel.StorehouseId,
	//				}
	//				service.UpdateStockFlowThree(stockInfo.ID, flow)
	//			}
	//		}
	//	}
	//
	//}

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

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

}
func (this *StockManagerApiController) GetCancelStockConfig() {
	types, _ := this.GetInt64("type", 0)
	adminUserInfo := this.GetAdminUserInfo()
	warehouseOutInfoList, _ := service.FindAllWarehouseOutInfo(adminUserInfo.CurrentOrgId, types)
	this.ServeSuccessJSON(map[string]interface{}{
		"warehouseOutInfoList": warehouseOutInfoList,
	})
}

func (c *StockManagerApiController) GetQueryInfo() {
	page, _ := c.GetInt64("page", -1)
	limit, _ := c.GetInt64("limit", -1)
	keyword := c.GetString("keyword")
	start_time := c.GetString("start_time")
	end_time := c.GetString("end_time")
	type_name, _ := c.GetInt64("type_name")
	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.FindAllStockInfo(adminUserInfo.CurrentOrgId, page, limit, keyword, startTime, endTime, type_name)
	info, err := service.GetCoutWareseOutInfo(startTime, endTime, adminUserInfo.CurrentOrgId)

	infomationList, err := service.GetGoodInfomationList(adminUserInfo.CurrentOrgId, "")
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"list":           list,
			"total":          total,
			"info":           info,
			"infomationList": infomationList,
			"orgid":          adminUserInfo.CurrentOrgId,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

func (c *StockManagerApiController) SearchWarehouse() {
	keywords := c.GetString("keywords")
	adminUserInfo := c.GetAdminUserInfo()
	warehouseList, total, err := service.FindAllWarehouseByKeyword(adminUserInfo.CurrentOrgId, 1, 10, keywords)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"list":  warehouseList,
			"total": total,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}
func (c *StockManagerApiController) GetAllConfig() {
	adminUserInfo := c.GetAdminUserInfo()
	manufacturer, _ := service.FindAllManufacturer(adminUserInfo.CurrentOrgId)
	dealer, _ := service.FindAllDealer(adminUserInfo.CurrentOrgId)
	goodType, _ := service.FindAllGoodType(adminUserInfo.CurrentOrgId)
	goodInfo, _ := service.FindAllGoodInfoTwo(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,
		"goodType":     goodType,
		"goodInfo":     goodInfo,
		"list":         list,
		"configlist":   configList,
		"doctorList":   doctorList,
	})
}
func (this *StockManagerApiController) GetAllSalesReturnConfig() {
	types, _ := this.GetInt64("type", 0)
	adminUserInfo := this.GetAdminUserInfo()
	warehouseInfoList, _ := service.FindAllWarehouseInfo(adminUserInfo.CurrentOrgId, types)
	this.ServeSuccessJSON(map[string]interface{}{
		"warehouseInfoList": warehouseInfoList,
	})
}

func (this *StockManagerApiController) GetDetailInfo() {

	page, _ := this.GetInt64("page", 0)
	limit, _ := this.GetInt64("limit", 0)
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	types, _ := this.GetInt64("type", 0)

	keywords := this.GetString("keywords")
	manufacturer, _ := this.GetInt64("manufacturer", 0)
	order_type, _ := this.GetInt64("order_type", 0)
	dealer, _ := this.GetInt64("dealer", 0)

	storehouse_id, _ := this.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 {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}

	adminUserInfo := this.GetAdminUserInfo()

	var list []*models.WarehousingInfo
	var list1 []*models.WarehouseOutInfo
	var list2 []*models.SalesReturnInfo
	var list3 []*models.CancelStockInfo

	var total int64
	var err error
	var total_price float64
	houseList, _ := service.GetAllStoreHouseList(adminUserInfo.CurrentOrgId)
	manufacturerList, _ := service.GetAllManufacturerList(adminUserInfo.CurrentOrgId)
	dealerList, _ := service.GetAllDealerList(adminUserInfo.CurrentOrgId)
	if types == 1 {
		list, total, err = service.FindStockInDetailList(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, keywords, manufacturer, order_type, dealer, storehouse_id)
		_, total_price = service.GetStockInDetailTotal(adminUserInfo.CurrentOrgId, startTime, endTime, keywords, manufacturer, order_type, dealer, storehouse_id)

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

	} else if types == 2 {
		list1, total, err = service.FindStockOutDetailList(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, keywords, manufacturer, order_type, dealer, storehouse_id)
		_, total_price = service.GetStockOutDetailTotal(adminUserInfo.CurrentOrgId, startTime, endTime, keywords, manufacturer, order_type, dealer, storehouse_id)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"list":             list1,
				"total":            total,
				"total_price":      total_price,
				"houseList":        houseList,
				"manufacturerList": manufacturerList,
				"dealerList":       dealerList,
			})
		} else {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		}
	} else if types == 3 {
		list2, total, err = service.FindSalesReturnDetailList(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, keywords, manufacturer, order_type, dealer)

		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"list":             list2,
				"total":            total,
				"manufacturerList": manufacturerList,
				"dealerList":       dealerList,
			})
		} else {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		}
	} else if types == 4 {
		list3, total, err = service.FindCancelDetailList(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, keywords, manufacturer, order_type, dealer, storehouse_id)
		listGroup, err := service.FindeCancelGroup(adminUserInfo.CurrentOrgId, startTime, endTime, keywords, manufacturer, order_type, dealer, storehouse_id)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"list":             list3,
				"total":            total,
				"listgroup":        listGroup,
				"houseList":        houseList,
				"manufacturerList": manufacturerList,
				"dealerList":       dealerList,
			})
		} else {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		}
	}

}

func (this *StockManagerApiController) GetUserDetailInfo() {
	order_id, _ := this.GetInt64("id")
	if order_id <= 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	adminUserInfo := this.GetAdminUserInfo()
	userDetails, err, total := service.FindUserDetailById(adminUserInfo.CurrentOrgId, order_id)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list":  userDetails,
			"total": total,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}

}

func (this *StockManagerApiController) PostSearchStock() {

	keyword := this.GetString("keyword")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	stock, err := service.PostSearchStock(keyword, orgId)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteFail)
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"stock": stock,
	})
}

func (this *StockManagerApiController) GetOutStockTotalCount() {

	warehouseOutTime, _ := this.GetInt64("warehouse_out_time")
	adminUserInfo := this.GetAdminUserInfo()
	stockCount, err := service.GetOutStockTotalCount(warehouseOutTime, adminUserInfo.CurrentOrgId)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteFail)
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"stockCount": stockCount,
	})
}

func (this *StockManagerApiController) AddGoodInformation() {

	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		return
	}
	utils.ErrorLog("%v", dataBody)
	var goods []*models.GoodInfo
	var total_goods []interface{}
	tempGoods := dataBody["goods"].([]interface{})

	total_goods = tempGoods
	for index, goodMap := range tempGoods {
		goodNameM := goodMap.(map[string]interface{})

		var good models.GoodInfo

		if goodNameM["good_name"] == nil || reflect.TypeOf(goodNameM["good_name"]).String() != "string" {
			utils.ErrorLog("good_name")
			return
		}

		good_name, _ := goodNameM["good_name"].(string)
		if len(good_name) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    5,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的耗材名称不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		good.GoodName = good_name

		// 获取数据字典数据
		var good_kind_id int64
		var name = "耗材种类"
		config, _ := service.GetDrugDataConfig(0, name)

		good_kind := goodNameM["good_kind"].(string)

		if len(good_kind) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    5,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的耗材种类不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		if len(good_kind) != 0 {
			_, errcodegoodkind := service.IsExistDicConfig(config.ID, good_kind, orgId)
			lastConfig, _ := service.GetLastDicConfig(config.ID, orgId)
			dataconfig := models.DictDataconfig{
				ParentId:       config.ID,
				Module:         "system",
				OrgId:          orgId,
				Name:           good_kind,
				FieldName:      "",
				Value:          lastConfig.Value + 1,
				CreatedTime:    "",
				UpdatedTime:    "",
				CreateUserId:   adminUserInfo.AdminUser.Id,
				Status:         1,
				Remark:         "",
				DeleteIdSystem: 0,
				Title:          "",
				Content:        "",
				Order:          0,
				Code:           "",
			}
			if errcodegoodkind == gorm.ErrRecordNotFound {
				service.CreatedDicConfig(&dataconfig)
			}
		}

		dataConfig, _ := service.GetParentDataConfig(config.ID, orgId)
		for _, it := range dataConfig {
			if good_kind == it.Name {
				fmt.Println(it.Name)
				good_kind_id = int64(it.Value)
			}
		}
		good.GoodKind = good_kind_id

		good_type := goodNameM["type_name"].(string)
		if len(good_type) == 0 {
			err_log := models.ExportErrLog{
				LogType:    5,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的耗材类型不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}
		if len(good_type) != 0 {
			_, errcodegoodtype := service.GetGoodType(good_type, orgId)
			if errcodegoodtype == gorm.ErrRecordNotFound {
				goodsType := models.GoodsType{
					TypeName:       good_type,
					Remark:         "",
					Ctime:          time.Now().Unix(),
					Mtime:          0,
					Creater:        adminUserInfo.AdminUser.Id,
					Modifier:       0,
					OrgId:          adminUserInfo.CurrentOrgId,
					Status:         1,
					Type:           0,
					Number:         0,
					OutStock:       0,
					StockAttribute: 1,
				}
				service.CreatedGoodType(&goodsType)
			}
		}

		goodType, _ := service.GetAllGoodType(orgId)
		var good_type_id int64
		for _, it := range goodType {
			if good_type == it.TypeName {
				good_type_id = it.ID
			}
		}
		good.GoodTypeId = good_type_id

		medical_insurance_level := goodNameM["medical_insurance_level"].(string)
		if len(medical_insurance_level) <= 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    5,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的医保等级不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		var medical_insurance_id int64
		var medicalInsurance = "医保等级"
		medicalInsuranceDataConfig, _ := service.GetDrugDataConfig(0, medicalInsurance)

		if len(medical_insurance_level) != 0 {
			_, errcodemedicalInsurance := service.IsExistDicConfig(medicalInsuranceDataConfig.ID, medical_insurance_level, orgId)
			if errcodemedicalInsurance == gorm.ErrRecordNotFound {
				mediConfigOne, _ := service.GetLastDicConfig(medicalInsuranceDataConfig.ID, orgId)
				dataconfig := models.DictDataconfig{
					ParentId:       medicalInsuranceDataConfig.ID,
					Module:         "system",
					OrgId:          orgId,
					Name:           medical_insurance_level,
					FieldName:      "",
					Value:          mediConfigOne.Value + 1,
					CreatedTime:    "",
					UpdatedTime:    "",
					CreateUserId:   adminUserInfo.AdminUser.Id,
					Status:         1,
					Remark:         "",
					DeleteIdSystem: 0,
					Title:          "",
					Content:        "",
					Order:          0,
					Code:           "",
				}
				service.CreatedDicConfig(&dataconfig)
			}
		}

		medicalInsuranceList, _ := service.GetParentDataConfig(medicalInsuranceDataConfig.ID, orgId)
		for _, it := range medicalInsuranceList {
			if medical_insurance_level == it.Name {
				medical_insurance_id = int64(it.Value)
			}
		}
		good.MedicalInsuranceLevel = medical_insurance_id

		if goodNameM["specification_name"] == nil || reflect.TypeOf(goodNameM["specification_name"]).String() != "string" {
			utils.ErrorLog("specification_name")
			return
		}
		specification_name := goodNameM["specification_name"].(string)
		if len(specification_name) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    5,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "规格型号不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		good.SpecificationName = specification_name

		var manufacturer_id int64
		manufacturer := goodNameM["manufacturer"].(string)
		if len(manufacturer) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    5,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的生产厂商不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}
		if len(manufacturer) != 0 {
			_, errcodes := service.GetManufacturerName(orgId, manufacturer)
			manu := models.Manufacturer{
				ManufacturerName: manufacturer,
				Status:           1,
				OrgId:            orgId,
				Creater:          adminUserInfo.AdminUser.Id,
			}
			if errcodes == gorm.ErrRecordNotFound {

				service.CreateManufacturer(&manu)

			}
		}

		manufacturerList, _ := service.GetAllManufacturerList(orgId)
		for _, it := range manufacturerList {
			if manufacturer == it.ManufacturerName {
				manufacturer_id = it.ID
			}
		}

		good.Manufacturer = manufacturer_id

		if goodNameM["unit_id"] == nil || reflect.TypeOf(goodNameM["unit_id"]).String() != "float64" {
			utils.ErrorLog("unit_id")
			return
		}

		unit_id := int64(goodNameM["unit_id"].(float64))
		if unit_id <= 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    5,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的单位不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		good.GoodUnit = unit_id

		retail_prices := goodNameM["retail_price"].(string)
		retail_price, _ := strconv.ParseFloat(retail_prices, 64)
		if retail_price <= 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    5,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的价格不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		good.RetailPrice = retail_price

		if goodNameM["stock_warn_count"] == nil || reflect.TypeOf(goodNameM["stock_warn_count"]).String() != "float64" {
			utils.ErrorLog("stock_warn_count")
			return
		}

		stock_warn_count := int64(goodNameM["stock_warn_count"].(float64))
		if stock_warn_count <= 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    5,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的库存警戒不能为空或内容与系统不匹配",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		good.StockWarnCount = stock_warn_count

		var dealer_id int64
		dealerName := goodNameM["dealer"].(string)

		fmt.Println("经销商", dealerName)
		dealer := models.Dealer{
			OrgId:      orgId,
			Status:     1,
			DealerName: dealerName,
			Creater:    adminUserInfo.AdminUser.Id,
			Ctime:      time.Now().Unix(),
		}
		if len(dealerName) != 0 {
			_, errcodedealer := service.GetDealerByName(orgId, dealerName)

			if errcodedealer == gorm.ErrRecordNotFound {
				service.CreateDealer(&dealer)
			}
		}

		dealerList, _ := service.GetAllDealerList(orgId)
		for _, it := range dealerList {
			if dealerName == it.DealerName {
				dealer_id = it.ID
			}
		}

		good.Dealer = dealer_id
		if goodNameM["pinyin"] == nil || reflect.TypeOf(goodNameM["pinyin"]).String() != "string" {
			utils.ErrorLog("pinyin")
			return
		}
		pinyin := goodNameM["pinyin"].(string)

		good.Pinyin = pinyin

		if goodNameM["wubi"] == nil || reflect.TypeOf(goodNameM["wubi"]).String() != "string" {
			utils.ErrorLog("wubi")
			return
		}
		wubi := goodNameM["wubi"].(string)

		good.Wubi = wubi

		buy_prices := goodNameM["buy_price"].(string)
		buy_price, _ := strconv.ParseFloat(buy_prices, 64)
		good.BuyPrice = buy_price

		if goodNameM["social_security_directory_code"] == nil || reflect.TypeOf(goodNameM["social_security_directory_code"]).String() != "string" {
			utils.ErrorLog("social_security_directory_code")
			return
		}
		social_security_directory_code := goodNameM["social_security_directory_code"].(string)

		good.SocialSecurityDirectoryCode = social_security_directory_code

		if goodNameM["is_special_diseases"] == nil || reflect.TypeOf(goodNameM["is_special_diseases"]).String() != "float64" {
			utils.ErrorLog("is_special_diseases")
			return
		}

		is_special_diseases := int64(goodNameM["is_special_diseases"].(float64))
		good.IsSpecialDiseases = is_special_diseases

		if goodNameM["is_record"] == nil || reflect.TypeOf(goodNameM["is_record"]).String() != "float64" {
			utils.ErrorLog("is_record")
			return
		}

		is_record := int64(goodNameM["is_record"].(float64))
		good.IsRecord = is_record

		if goodNameM["good_status"] == nil || reflect.TypeOf(goodNameM["good_status"]).String() != "string" {
			utils.ErrorLog("good_status")
			return
		}
		good_status := goodNameM["good_status"].(string)
		good.GoodStatus = good_status

		if goodNameM["medical_insurance_number"] == nil || reflect.TypeOf(goodNameM["medical_insurance_number"]).String() != "string" {
			utils.ErrorLog("medical_insurance_number")
			return
		}
		medical_insurance_number := goodNameM["medical_insurance_number"].(string)
		good.MedicalInsuranceNumber = medical_insurance_number

		if goodNameM["production_type"] == nil || reflect.TypeOf(goodNameM["production_type"]).String() != "string" {
			utils.ErrorLog("production_type")
			return
		}
		production_type := goodNameM["production_type"].(string)
		good.ProductionType = production_type

		if goodNameM["remark"] == nil || reflect.TypeOf(goodNameM["remark"]).String() != "string" {
			utils.ErrorLog("remark")
			return
		}
		remark := goodNameM["remark"].(string)
		good.Remark = remark

		statistics_category := goodNameM["statistics_category"].(string)

		var categoryName = "统计分类"
		var statistic_id int64
		drugDataConfig, _ := service.GetDrugDataConfig(0, categoryName)

		if len(statistics_category) != 0 {
			_, errcodecagegory := service.IsExistDicConfig(drugDataConfig.ID, statistics_category, orgId)

			if errcodecagegory == gorm.ErrRecordNotFound {
				dicConfigThree, _ := service.GetLastDicConfig(drugDataConfig.ID, orgId)
				dataconfig := models.DictDataconfig{
					ParentId:       drugDataConfig.ID,
					Module:         "system",
					OrgId:          orgId,
					Name:           statistics_category,
					FieldName:      "",
					Value:          dicConfigThree.Value + 1,
					CreatedTime:    "",
					UpdatedTime:    "",
					CreateUserId:   adminUserInfo.AdminUser.Id,
					Status:         1,
					Remark:         "",
					DeleteIdSystem: 0,
					Title:          "",
					Content:        "",
					Order:          0,
					Code:           "",
				}
				service.CreatedDicConfig(&dataconfig)
			}
		}

		parentDataConfig, _ := service.GetParentDataConfig(drugDataConfig.ID, orgId)

		for _, it := range parentDataConfig {
			if statistics_category == it.Name {
				statistic_id = int64(it.Value)
			}
		}

		good.StatisticsCategory = statistic_id

		special_medical := goodNameM["special_medical"].(string)
		good.SpecialMedical = special_medical

		packing_unit := goodNameM["good_unit"].(string)
		good.PackingUnit = packing_unit

		goods = append(goods, &good)

	}

	export_time := time.Now().Unix()
	errLogs, _ := service.FindPatientExportLogTwo(this.GetAdminUserInfo().CurrentOrgId, export_time)
	if len(goods) > 0 {

		for _, item := range goods {

			goodInfo := models.GoodInfo{
				GoodName:                    item.GoodName,
				SpecificationName:           item.SpecificationName,
				GoodKind:                    item.GoodKind,
				GoodTypeId:                  item.GoodTypeId,
				Dealer:                      item.Dealer,
				GoodUnit:                    item.GoodUnit,
				IsRecord:                    item.IsRecord,
				IsSpecialDiseases:           item.IsSpecialDiseases,
				Manufacturer:                item.Manufacturer,
				Pinyin:                      item.Pinyin,
				GoodStatus:                  item.GoodStatus,
				ProductionType:              item.ProductionType,
				Remark:                      item.Remark,
				RetailPrice:                 item.RetailPrice,
				SocialSecurityDirectoryCode: item.SocialSecurityDirectoryCode,
				SpecialMedical:              item.SpecialMedical,
				Wubi:                        item.Wubi,
				StockWarnCount:              item.StockWarnCount,
				MedicalInsuranceLevel:       item.MedicalInsuranceLevel,
				OrgId:                       orgId,
				Status:                      1,
				Ctime:                       time.Now().Unix(),
				StatisticsCategory:          item.StatisticsCategory,
				GoodCode:                    item.GoodCode,
				BuyPrice:                    item.BuyPrice,
				MedicalInsuranceNumber:      item.MedicalInsuranceNumber,
				IsUser:                      2,
				PackingUnit:                 item.PackingUnit,
				PackingPrice:                item.RetailPrice,
				IsWarehouse:                 1,
			}

			//查询同种耗材名称同种类型同种规格的耗材是否存在
			_, errcodegood := service.GetGoodsInformaitonIsExist(item.GoodName, item.GoodTypeId, item.SpecificationName, orgId)

			if errcodegood == gorm.ErrRecordNotFound {
				service.CreateGoodsInfomation(&goodInfo)
			} else if errcodegood == nil {
				service.UpdateGoodsInformation(&goodInfo, item.GoodName, item.GoodTypeId, item.SpecificationName, orgId)
			}

			log := models.ExportLog{
				LogType:    5,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				TotalNum:   int64(len(total_goods)),
				FailNum:    int64(len(errLogs)),
				SuccessNum: int64(len(goods)),
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: export_time,
				Status:     1,
			}
			service.CreateExportLog(&log)
			this.ServeSuccessJSON(map[string]interface{}{
				"msg":         "导入成功",
				"total_num":   len(total_goods),
				"success_num": len(goods),
				"fail_num":    int64(len(errLogs)),
			})
		}
	} else {
		log := models.ExportLog{
			LogType:    5,
			UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
			TotalNum:   int64(len(total_goods)),
			FailNum:    int64(len(errLogs)),
			SuccessNum: int64(len(goods)),
			CreateTime: time.Now().Unix(),
			UpdateTime: time.Now().Unix(),
			ExportTime: export_time,
			Status:     1,
		}
		service.CreateExportLog(&log)

		this.ServeSuccessJSON(map[string]interface{}{
			"msg":         "导入成功",
			"total_num":   len(total_goods),
			"success_num": len(goods),
			"fail_num":    int64(len(errLogs)),
		})
	}
}

func (this *StockManagerApiController) AddDrugInformation() {
	adminUser := this.GetAdminUserInfo()
	orgId := adminUser.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		return
	}
	utils.ErrorLog("%v", dataBody)
	var drugList []*models.BaseDrugLib
	var total_goods []interface{}
	tempDrugs := dataBody["drugs"].([]interface{})

	total_goods = tempDrugs
	for index, drugMap := range tempDrugs {

		goodNameM := drugMap.(map[string]interface{})
		var drug models.BaseDrugLib
		if goodNameM["drug_name"] == nil || reflect.TypeOf(goodNameM["drug_name"]).String() != "string" {
			utils.ErrorLog("drug_name")
			return
		}

		drug_name, _ := goodNameM["drug_name"].(string)
		if len(drug_name) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的药品名称不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		drug.DrugName = drug_name

		dose_unit := goodNameM["dose_unit"].(string)
		drug.DoseUnit = dose_unit

		if goodNameM["min_number"] == nil || reflect.TypeOf(goodNameM["min_number"]).String() != "string" {
			utils.ErrorLog("min_number")
			return
		}
		min_number, _ := goodNameM["min_number"].(string)
		minNumber, _ := strconv.ParseInt(min_number, 10, 64)
		if len(min_number) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的拆零不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		drug.MinNumber = minNumber

		min_unit := goodNameM["min_unit"].(string)
		if len(min_unit) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的拆零单位不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		drug.MinUnit = min_unit

		max_unit_id := goodNameM["max_unit"].(string)
		if len(max_unit_id) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的剂量单位不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		drug.MaxUnit = max_unit_id

		max_unit := goodNameM["max_unit"].(string)
		if len(max_unit) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的包装单位不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		drug.MaxUnit = max_unit

		drug_type := goodNameM["drug_type"].(string)
		if len(drug_type) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的药品类型不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		var drug_type_id int64
		var drugType = "药品类型"

		drugconfig, _ := service.GetDrugDataConfig(0, drugType)
		if len(drug_type) != 0 {
			_, errcodes := service.IsExistDicConfig(drugconfig.ID, drug_type, orgId)
			if errcodes == gorm.ErrRecordNotFound {
				//获取该型号最后一条数据型号
				config, _ := service.GetLastDicConfig(drugconfig.ID, orgId)

				dataconfig := models.DictDataconfig{
					ParentId:       drugconfig.ID,
					Module:         "system",
					OrgId:          orgId,
					Name:           drug_type,
					FieldName:      "",
					Value:          config.Value + 1,
					CreatedTime:    "",
					UpdatedTime:    "",
					CreateUserId:   adminUser.AdminUser.Id,
					Status:         1,
					Remark:         "",
					DeleteIdSystem: 0,
					Title:          "",
					Content:        "",
					Order:          0,
					Code:           "",
				}
				service.CreatedDicConfig(&dataconfig)
			}
		}

		drugTypeList, _ := service.GetParentDataConfig(drugconfig.ID, orgId)
		for _, it := range drugTypeList {
			if drug_type == it.Name {
				drug_type_id = int64(it.Value)
			}
		}

		drug.DrugType = drug_type_id

		drug_stock_limit, _ := goodNameM["drug_stock_limit"].(string)
		if len(drug_stock_limit) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的库存警戒不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		drug.DrugStockLimit = drug_stock_limit

		drug_origin_place, _ := goodNameM["drug_origin_place"].(string)
		if len(drug_origin_place) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的产地不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		drug.DrugOriginPlace = drug_origin_place

		drug_dosage_form := goodNameM["drug_dosage_form"].(string)

		if len(drug_dosage_form) == 0 {
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的药品剂型不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		var drug_dosage = "药品剂型"
		var drug_dosage_form_id int64
		drugDosageconfig, _ := service.GetDrugDataConfig(0, drug_dosage)
		if len(drug_dosage_form) != 0 {
			_, errcodess := service.IsExistDicConfig(drugDosageconfig.ID, drug_dosage_form, orgId)
			if errcodess == gorm.ErrRecordNotFound {
				configOne, _ := service.GetLastDicConfig(drugDosageconfig.ID, orgId)
				dataconfig := models.DictDataconfig{
					ParentId:       drugDosageconfig.ID,
					Module:         "system",
					OrgId:          orgId,
					Name:           drug_dosage_form,
					FieldName:      "",
					Value:          configOne.Value + 1,
					CreatedTime:    "",
					UpdatedTime:    "",
					CreateUserId:   adminUser.AdminUser.Id,
					Status:         1,
					Remark:         "",
					DeleteIdSystem: 0,
					Title:          "",
					Content:        "",
					Order:          0,
					Code:           "",
				}
				service.CreatedDicConfig(&dataconfig)
			}
		}

		drugDosageList, _ := service.GetParentDataConfig(drugDosageconfig.ID, orgId)
		for _, it := range drugDosageList {
			if drug_dosage_form == it.Name {
				drug_dosage_form_id = int64(it.Value)
			}
		}

		drug.DrugDosageForm = drug_dosage_form_id

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

		if retail_price <= 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的拆零售价不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		drug.RetailPrice = retail_price

		last_prices := goodNameM["last_price"].(string)
		last_price, _ := strconv.ParseFloat(last_prices, 64)
		if last_price <= 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的进货价不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		drug.LastPrice = last_price

		drug_classify := goodNameM["drug_classify"].(string)

		if len(drug_classify) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的药物分类不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		var drugClassify = "药物分类"
		var drug_classify_id int64
		drugClassifyConfig, _ := service.GetDrugDataConfig(0, drugClassify)

		if len(drug_classify) != 0 {
			_, errcodesClass := service.IsExistDicConfig(drugClassifyConfig.ID, drug_classify, orgId)
			if errcodesClass == gorm.ErrRecordNotFound {
				drugClassConfig, _ := service.GetLastDicConfig(drugClassifyConfig.ID, orgId)
				dataconfig := models.DictDataconfig{
					ParentId:       drugClassifyConfig.ID,
					Module:         "system",
					OrgId:          orgId,
					Name:           drug_classify,
					FieldName:      "",
					Value:          drugClassConfig.Value + 1,
					CreatedTime:    "",
					UpdatedTime:    "",
					CreateUserId:   adminUser.AdminUser.Id,
					Status:         1,
					Remark:         "",
					DeleteIdSystem: 0,
					Title:          "",
					Content:        "",
					Order:          0,
					Code:           "",
				}
				service.CreatedDicConfig(&dataconfig)
			}
		}

		drugClassList, _ := service.GetParentDataConfig(drugClassifyConfig.ID, orgId)
		for _, it := range drugClassList {
			if drug_classify == it.Name {
				drug_classify_id = int64(it.Value)
			}
		}

		drug.DrugClassify = strconv.FormatInt(drug_classify_id, 10)
		drug_dose := goodNameM["drug_dose"].(string)

		if len(drug_dose) == 0 {
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的默认单次用量不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}
		drugDoses, _ := strconv.ParseFloat(drug_dose, 64)
		drug.DrugDose = drugDoses

		var units = "单位"
		var unit_id int64

		drugDoseUnit := goodNameM["drug_dose_unit"].(string)
		if len(drugDoseUnit) == 0 {
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的默认单次用量单位不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		manufacturer := goodNameM["manufacturer"].(string)
		if len(manufacturer) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的生产商不能为空或内容与系统不匹配",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		if len(manufacturer) != 0 {
			_, errcodema := service.GetManufacturerName(orgId, manufacturer)
			if errcodema == gorm.ErrRecordNotFound {
				manufactur := models.Manufacturer{
					OrgId:            orgId,
					Status:           1,
					ManufacturerName: manufacturer,
					Ctime:            time.Now().Unix(),
					Creater:          adminUser.AdminUser.Id,
				}
				service.CreateManufacturer(&manufactur)
			}
		}

		var manufacturer_id int64

		manufacturList, _ := service.GetAllManufacturerList(orgId)
		for _, it := range manufacturList {
			if manufacturer == it.ManufacturerName {
				manufacturer_id = it.ID
			}
		}

		drug.Manufacturer = manufacturer_id

		dealer := goodNameM["dealer"].(string)
		if len(dealer) != 0 {
			_, errcodesdealer := service.GetDealerByName(orgId, dealer)
			if errcodesdealer == gorm.ErrRecordNotFound {
				dealerconfig := models.Dealer{
					DealerName: dealer,
					Status:     1,
					OrgId:      orgId,
					Ctime:      time.Now().Unix(),
					Creater:    adminUser.AdminUser.Id,
				}
				service.CreateDealer(&dealerconfig)
			}
		}

		var dealer_id int64
		dealerList, _ := service.GetAllDealerList(orgId)
		for _, it := range dealerList {
			if dealer == it.DealerName {
				dealer_id = it.ID
			}
		}
		drug.Dealer = dealer_id

		delivery_way := goodNameM["delivery_way"].(string)

		drug.DeliveryWay = delivery_way

		execution_frequency := goodNameM["execution_frequency"].(string)

		drug.ExecutionFrequency = execution_frequency

		lmt_used_flags := int64(goodNameM["lmt_used_flag"].(float64))

		drug.LmtUsedFlag = lmt_used_flags

		dataConfig, _ := service.GetDataConfigIsExist(0, units)
		if len(drugDoseUnit) != 0 {
			_, errcodedataconfig := service.GetChildeConfigIsExist(dataConfig.ID, drugDoseUnit, orgId)
			if errcodedataconfig == gorm.ErrRecordNotFound {
				childConfig, _ := service.GetLastChildeConfig(dataConfig.ID, orgId)
				dataconfig := models.Dataconfig{
					ParentId:       dataConfig.ID,
					Module:         "hemodialysis",
					OrgId:          orgId,
					Name:           drugDoseUnit,
					FieldName:      "",
					Value:          childConfig.Value + 1,
					CreatedTime:    "",
					UpdatedTime:    "",
					CreateUserId:   adminUser.AdminUser.Id,
					Status:         1,
					Remark:         "",
					DeleteIdSystem: 0,
					Title:          "",
					Content:        "",
					Order:          0,
					Code:           "",
					FieldType:      0,
				}
				service.CreateDataConfig(&dataconfig)
			}
		}
		list, _ := service.FindAllDataConfigList(orgId, dataConfig.ID)
		for _, it := range list {
			if drugDoseUnit == it.Name {
				unit_id = int64(it.Value)
			}
		}
		drug.DrugDoseUnit = unit_id

		if goodNameM["drug_alias"] == nil || reflect.TypeOf(goodNameM["drug_alias"]).String() != "string" {
			utils.ErrorLog("drug_alias")
			return
		}

		drug_alias, _ := goodNameM["drug_alias"].(string)

		drug.DrugAlias = drug_alias

		drug_category := goodNameM["drug_category"].(string)

		var drugCategory = "药品类别"
		var drug_category_id int64

		drugCategoryConfig, _ := service.GetDrugDataConfig(0, drugCategory)

		if len(drug_category) != 0 {
			_, drugcategoryerrcodes := service.IsExistDicConfig(drugCategoryConfig.ID, drug_category, orgId)
			if drugcategoryerrcodes == gorm.ErrRecordNotFound {
				drugCategoryConfigSix, _ := service.GetLastDicConfig(drugCategoryConfig.ID, orgId)
				dataconfig := models.DictDataconfig{
					ParentId:       drugCategoryConfig.ID,
					Module:         "system",
					OrgId:          orgId,
					Name:           drug_category,
					FieldName:      "",
					Value:          drugCategoryConfigSix.Value + 1,
					CreatedTime:    "",
					UpdatedTime:    "",
					CreateUserId:   adminUser.AdminUser.Id,
					Status:         1,
					Remark:         "",
					DeleteIdSystem: 0,
					Title:          "",
					Content:        "",
					Order:          0,
					Code:           "",
				}
				service.CreatedDicConfig(&dataconfig)
			}
		}

		drugCategoryList, _ := service.GetParentDataConfig(drugCategoryConfig.ID, orgId)
		fmt.Println("drugCategoryList", drugCategoryList)
		for _, it := range drugCategoryList {
			if drug_category == it.Name {
				drug_category_id = int64(it.Value)
			}
		}

		drug.DrugCategory = drug_category_id

		statistics_category := goodNameM["statistics_category"].(string)

		var statisticsCategory = "统计分类"
		var statistics_category_id int64

		statistcConfig, _ := service.GetDrugDataConfig(0, statisticsCategory)
		if len(statistics_category) != 0 {
			_, errcodestatistc := service.IsExistDicConfig(statistcConfig.ID, statistics_category, orgId)
			if errcodestatistc == gorm.ErrRecordNotFound {
				staConfig, _ := service.GetLastDicConfig(statistcConfig.ID, orgId)
				dataconfig := models.DictDataconfig{
					ParentId:       statistcConfig.ID,
					Module:         "system",
					OrgId:          orgId,
					Name:           statistics_category,
					FieldName:      "",
					Value:          staConfig.Value + 1,
					CreatedTime:    "",
					UpdatedTime:    "",
					CreateUserId:   adminUser.AdminUser.Id,
					Status:         1,
					Remark:         "",
					DeleteIdSystem: 0,
					Title:          "",
					Content:        "",
					Order:          0,
					Code:           "",
				}
				service.CreatedDicConfig(&dataconfig)
			}

		}

		statisticsCategoryList, _ := service.GetParentDataConfig(statistcConfig.ID, orgId)
		for _, it := range statisticsCategoryList {
			if statistics_category == it.Name {
				statistics_category_id = int64(it.Value)
			}
		}
		drug.StatisticsCategory = statistics_category_id

		hosp_appr_flag := int64(goodNameM["hosp_appr_flag"].(float64))
		drug.HospApprFlag = hosp_appr_flag
		medical_insurance_number := goodNameM["medical_insurance_number"].(string)
		drug.MedicalInsuranceNumber = medical_insurance_number

		pharmacology_category := goodNameM["pharmacology_category"].(string)

		var pharmacology = "药理分类"
		var pharmacology_category_id int64
		pharmacologyConfig, _ := service.GetDrugDataConfig(0, pharmacology)
		if len(pharmacology_category) != 0 {
			_, errcodespharmacology := service.IsExistDicConfig(pharmacologyConfig.ID, pharmacology_category, orgId)
			if errcodespharmacology == gorm.ErrRecordNotFound {
				dicConfig, _ := service.GetLastDicConfig(pharmacologyConfig.ID, orgId)
				dataconfig := models.DictDataconfig{
					ParentId:       pharmacologyConfig.ID,
					Module:         "system",
					OrgId:          orgId,
					Name:           pharmacology_category,
					FieldName:      "",
					Value:          dicConfig.Value + 1,
					CreatedTime:    "",
					UpdatedTime:    "",
					CreateUserId:   adminUser.AdminUser.Id,
					Status:         1,
					Remark:         "",
					DeleteIdSystem: 0,
					Title:          "",
					Content:        "",
					Order:          0,
					Code:           "",
				}
				service.CreatedDicConfig(&dataconfig)
			}
		}

		pharmacologyList, _ := service.GetParentDataConfig(pharmacologyConfig.ID, orgId)
		for _, it := range pharmacologyList {
			if pharmacology_category == it.Name {
				pharmacology_category_id = int64(it.Value)
			}
		}
		drug.PharmacologyCategory = pharmacology_category_id

		code := goodNameM["code"].(string)
		drug.Code = code
		is_special_diseases := int64(goodNameM["is_special_diseases"].(float64))
		drug.IsSpecialDiseases = is_special_diseases
		is_record := int64(goodNameM["is_record"].(float64))
		drug.IsRecord = is_record
		prescription_mark := int64(goodNameM["prescription_mark"].(float64))
		drug.PrescriptionMark = prescription_mark
		social_security_directory_code := goodNameM["social_security_directory_code"].(string)
		drug.SocialSecurityDirectoryCode = social_security_directory_code
		record_date := goodNameM["record_date"].(string)

		timeLayout := "2006-01-02"
		loc, _ := time.LoadLocation("Local")

		theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
		drug.RecordDate = theTime.Unix()
		drug_remark := goodNameM["drug_remark"].(string)
		drug.DrugRemark = drug_remark
		drug_status := goodNameM["drug_status"].(string)
		drug.DrugStatus = drug_status
		limit_remark := goodNameM["limit_remark"].(string)
		drug.LimitRemark = limit_remark
		min_prices := goodNameM["min_price"].(string)
		min_price, _ := strconv.ParseFloat(min_prices, 64)
		drug.MinPrice = min_price
		dose := goodNameM["dose"].(string)
		//dose, _ := strconv.ParseFloat(doses, 64)
		if len(dose) < 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的剂量不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		drug.Dose = dose

		if len(dose) < 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的剂量单位不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}
		drugList = append(drugList, &drug)
	}
	export_time := time.Now().Unix()
	errLogs, _ := service.FindPatientExportLogOne(this.GetAdminUserInfo().CurrentOrgId, export_time)

	if len(drugList) > 0 {
		for _, item := range drugList {
			fmt.Println("retial2332332233232323223322323", item.DoseUnit)
			goodInfo := models.BaseDrugLib{
				DrugName:                    item.DrugName,
				DrugAlias:                   item.DrugAlias,
				DrugSpec:                    item.DrugSpec,
				DrugType:                    item.DrugType,
				DrugStockLimit:              item.DrugStockLimit,
				DrugOriginPlace:             item.DrugOriginPlace,
				DrugDosageForm:              item.DrugDosageForm,
				MedicalInsuranceLevel:       item.MedicalInsuranceLevel,
				MaxUnit:                     item.MaxUnit,
				MinUnit:                     item.MinUnit,
				UnitMatrixing:               item.UnitMatrixing,
				RetailPrice:                 item.RetailPrice,
				LastPrice:                   item.LastPrice,
				DrugClassify:                item.DrugClassify,
				Manufacturer:                item.Manufacturer,
				Dealer:                      item.Dealer,
				OrgId:                       orgId,
				Status:                      1,
				Ctime:                       time.Now().Unix(),
				Pinyin:                      item.Pinyin,
				Wubi:                        item.Wubi,
				DrugAliasPinyin:             item.DrugAliasPinyin,
				DrugAliasWubi:               item.DrugAliasWubi,
				DrugControl:                 item.DrugControl,
				Number:                      item.Number,
				HospApprFlag:                item.HospApprFlag,
				MedicalInsuranceNumber:      item.MedicalInsuranceNumber,
				PharmacologyCategory:        item.PharmacologyCategory,
				StatisticsCategory:          item.StatisticsCategory,
				Code:                        item.Code,
				IsSpecialDiseases:           item.IsSpecialDiseases,
				IsRecord:                    item.IsRecord,
				PrescriptionMark:            item.PrescriptionMark,
				SocialSecurityDirectoryCode: item.SocialSecurityDirectoryCode,
				RecordDate:                  item.RecordDate,
				DrugRemark:                  item.DrugRemark,
				DrugStatus:                  item.DrugStatus,
				LimitRemark:                 item.LimitRemark,
				DrugCategory:                item.DrugCategory,
				DrugDose:                    item.DrugDose,
				DrugDoseUnit:                item.DrugDoseUnit,
				LmtUsedFlag:                 item.LmtUsedFlag,
				DrugDay:                     item.DrugDay,
				DeliveryWay:                 item.DeliveryWay,
				ExecutionFrequency:          item.ExecutionFrequency,
				DoseUnit:                    item.DoseUnit,
				Dose:                        item.Dose,
				MinNumber:                   item.MinNumber,
				IsUse:                       2,
				MinPrice:                    item.MinPrice,
			}

			//查询同种药品同种规格是否存在
			_, drugerror := service.IsExistDrugByNameOne(item.DrugName, item.Dose, item.DoseUnit, item.MinNumber, item.MinUnit, item.MaxUnit, orgId)

			if drugerror == gorm.ErrRecordNotFound {
				service.CreateDrugsInfomation(&goodInfo)
			} else if drugerror == nil {
				service.UpdateDrugsInformation(&goodInfo, item.DrugName, item.DrugSpec, orgId)
			}
			log := models.ExportLog{
				LogType:    4,
				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
				TotalNum:   int64(len(total_goods)),
				FailNum:    int64(len(errLogs)),
				SuccessNum: int64(len(drugList)),
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: export_time,
				Status:     1,
			}
			service.CreateExportLog(&log)
			this.ServeSuccessJSON(map[string]interface{}{
				"msg":         "导入成功",
				"total_num":   len(total_goods),
				"success_num": len(drugList),
				"fail_num":    int64(len(errLogs)),
			})
		}
	} else {
		log := models.ExportLog{
			LogType:    4,
			UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
			TotalNum:   int64(len(total_goods)),
			FailNum:    int64(len(errLogs)),
			SuccessNum: int64(len(drugList)),
			CreateTime: time.Now().Unix(),
			UpdateTime: time.Now().Unix(),
			ExportTime: export_time,
			Status:     1,
		}
		service.CreateExportLog(&log)

		this.ServeSuccessJSON(map[string]interface{}{
			"msg":         "导入成功",
			"total_num":   len(total_goods),
			"success_num": len(drugList),
			"fail_num":    int64(len(errLogs)),
		})
	}

}

func (this *StockManagerApiController) GetInitializtion() {

	orgId := this.GetAdminUserInfo().CurrentOrgId
	var drugCategory = "药品类别"
	var drugType = "药品类型"
	var drugDosageForm = "药品剂型"
	var medicalInsuranceLevel = "医保等级"
	var drugControl = "开药控制"
	var drugClassify = "药物分类"
	var statisticsCategory = "统计分类"
	var pharmacologyCategory = "药理分类"
	var goodKind = "耗材种类"
	var tubeColor = "试管颜色"
	var costClassify = "费用类别"
	drugTypeParent, _ := service.GetDrugDataConfig(0, drugType)
	drugTypeList, _ := service.GetParentDataConfig(drugTypeParent.ID, orgId)

	drugCategoryParent, _ := service.GetDrugDataConfig(0, drugCategory)
	drugCategoryList, _ := service.GetParentDataConfig(drugCategoryParent.ID, orgId)

	drugDosageFormParent, _ := service.GetDrugDataConfig(0, drugDosageForm)
	drugDosageFormList, _ := service.GetParentDataConfig(drugDosageFormParent.ID, orgId)

	medicalInsuranceLevelParent, _ := service.GetDrugDataConfig(0, medicalInsuranceLevel)
	medicalInsuranceLevelList, _ := service.GetParentDataConfig(medicalInsuranceLevelParent.ID, orgId)

	drugControlParent, _ := service.GetDrugDataConfig(0, drugControl)
	drugControlList, _ := service.GetParentDataConfig(drugControlParent.ID, orgId)

	drugClassifyParent, _ := service.GetDrugDataConfig(0, drugClassify)
	drugClassifyList, _ := service.GetParentDataConfig(drugClassifyParent.ID, orgId)

	statisticsCategoryParent, _ := service.GetDrugDataConfig(0, statisticsCategory)
	statisticsCategoryList, _ := service.GetParentDataConfig(statisticsCategoryParent.ID, orgId)

	pharmacologyCategoryParent, _ := service.GetDrugDataConfig(0, pharmacologyCategory)
	pharmacologyCategoryList, _ := service.GetParentDataConfig(pharmacologyCategoryParent.ID, orgId)

	goodKindParent, _ := service.GetDrugDataConfig(0, goodKind)
	goodKindList, _ := service.GetParentDataConfig(goodKindParent.ID, orgId)

	tubeColorParent, _ := service.GetDrugDataConfig(0, tubeColor)
	tubeColorList, _ := service.GetParentDataConfig(tubeColorParent.ID, orgId)

	costClassifyParent, _ := service.GetDrugDataConfig(0, costClassify)
	costClassifyList, _ := service.GetParentDataConfig(costClassifyParent.ID, orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"drugCategoryList":          drugCategoryList,
		"drugTypeList":              drugTypeList,
		"drugDosageFormList":        drugDosageFormList,
		"medicalInsuranceLevelList": medicalInsuranceLevelList,
		"drugControlList":           drugControlList,
		"drugClassifyList":          drugClassifyList,
		"statisticsCategoryList":    statisticsCategoryList,
		"pharmacologyCategoryList":  pharmacologyCategoryList,
		"goodKindList":              goodKindList,
		"tubeColorList":             tubeColorList,
		"costClassifyList":          costClassifyList,
	})
}

func (this *StockManagerApiController) GetWarehouseOrderInfolist() {

	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	list, _ := service.GetWarehouseOrderInfoList(orgId)

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

func (this *StockManagerApiController) PostSearchGoodList() {

	keyword := this.GetString("keyword")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId

	storehouse_id, _ := this.GetInt64("storehouse_id")
	list, _ := service.GetSearchGoodListSix(keyword, orgId, storehouse_id)

	manufacturerList, _ := service.GetAllManufacturerList(orgId)
	dealerList, _ := service.GetAllDealerList(orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":             list,
		"manufacturerList": manufacturerList,
		"dealerList":       dealerList,
	})
}

func (this *StockManagerApiController) GetAllStockList() {

	page, _ := this.GetInt64("page", -1)
	limit, _ := this.GetInt64("limit", -1)
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	types, _ := this.GetInt64("type", 0)
	keywords := this.GetString("keywords")
	good_id, _ := this.GetInt64("good_id")
	storehouse_id, _ := this.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 {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId

	list, total, _ := service.GetAllGoodInfoStockList(page, limit, startTime, endTime, types, keywords, orgId, good_id, storehouse_id)
	manufacturerList, _ := service.GetAllManufacturerList(orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":             list,
		"total":            total,
		"manufacturerList": manufacturerList,
	})
}

func (this *StockManagerApiController) GetStockListById() {

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

	var startFistTime int64
	if len(start_first_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_first_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startFistTime = theTime.Unix()
	}
	var endFirstTime int64
	if len(end_first_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_first_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endFirstTime = theTime.Unix()
	}
	manufacturerList, _ := service.GetAllManufacturerList(orgId)
	list, total, _ := service.GetStockListById(id, orgId, limit, page, startTime, endTime, startFistTime, endFirstTime)
	houseList, _ := service.GetAllStoreHouseList(orgId)
	good, _ := service.GetGoodInformationByGoodId(id)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":             list,
		"total":            total,
		"manufacturerList": manufacturerList,
		"houseList":        houseList,
		"good":             good,
	})

}

func (this *StockManagerApiController) GetStockOutList() {

	id, _ := this.GetInt64("id")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	is_sys, _ := this.GetInt64("is_sys")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	outList, total, _ := service.GetStockOutList(id, orgId, limit, page, startTime, endTime, is_sys)

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

func (this *StockManagerApiController) GetStockDrugCount() {

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

	count, _ := service.GetStockDrugCount(startTime, endTime, orgId)
	outList, _ := service.GetAutoDiallysisBefor(startTime, endTime, orgId)
	autoCount, _ := service.GetOutStockTotalCountFour(startTime, endTime, orgId)
	totalCount, _ := service.GetCancelOutTotalCount(startTime, endTime, orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"count":      count,
		"outList":    outList,
		"autoCount":  autoCount,
		"totalCount": totalCount,
	})
}

func (this *StockManagerApiController) GetOrderDetialByOrderId() {

	ids := this.GetString("id")

	idsArray := strings.Split(ids, ",")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	order, _ := service.GetWarehouseOutOrder(idsArray, orgId)
	list, _ := service.GetOrderDetialByOrderIdOne(idsArray, orgId)
	stockFlowListGroup, _ := service.GetOrderDetailStockFlowByStorehouseById(idsArray, orgId)
	stockFlowList, _ := service.GetOrderDetailStockFlow(idsArray, orgId)
	//获取耗材退库数据
	cancelInfolist, _ := service.GetOrderStockFlow(idsArray, orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":               list,
		"order":              order,
		"stockFlowList":      stockFlowList,
		"stockFlowListGroup": stockFlowListGroup,
		"cancelInfolist":     cancelInfolist,
	})
}

func (this *StockManagerApiController) GetOrderDetailById() {

	id, _ := this.GetInt64("id")
	good_id, _ := this.GetInt64("good_id")
	record_time, _ := this.GetInt64("record_time")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	//自动出库
	userDetails, err, total := service.FindUserDetailByIdOne(good_id, record_time, orgId)

	//手动出库
	info, _ := service.GetWarehouseOutInfoById(id, good_id)

	//出库数据
	stockFlowList, err := service.GetStockFlowBatchNumberOne(id, good_id)
	//退库数据
	cancelInfo, err := service.GetStockFlowCancelInfo(id, good_id)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list":          userDetails,
			"total":         total,
			"info":          info,
			"stockFlowList": stockFlowList,
			"cancelInfo":    cancelInfo,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}
}

func (this *StockManagerApiController) GetSingleOutOrderDetail() {
	id, _ := this.GetInt64("id", 0)
	orgId := this.GetAdminUserInfo().CurrentOrgId

	warehouseOutInfo, _ := service.GetOrderDetialByOrderId(id, orgId)
	out, _ := service.GetGoodWarehouseOutById(id, orgId)
	storelist, _ := service.GetAllStoreHouseList(orgId)
	manufacturerList, _ := service.GetAllManufacturerList(orgId)
	dealerList, _ := service.GetAllDealerList(orgId)
	goodType, _ := service.GetAllGoodType(orgId)
	appId := this.GetAdminUserInfo().CurrentAppId
	doctorlist, _ := service.GetAllDoctorListSix(orgId, appId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":             warehouseOutInfo,
		"dealerList":       dealerList,
		"manufacturerList": manufacturerList,
		"goodType":         goodType,
		"out":              out,
		"storelist":        storelist,
		"doctorlist":       doctorlist,
	})
}

func (this *StockManagerApiController) GetExprotStockList() {

	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	storehouse_id, _ := this.GetInt64("storehouse_id")
	idArray := this.GetString("id")
	ids := strings.Split(idArray, ",")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	list, _ := service.GetExprotStockListTwenty(orgId, ids, startTime, endTime, storehouse_id)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *StockManagerApiController) GetOutExprotList() {

	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	idArray := this.GetString("id")
	ids := strings.Split(idArray, ",")
	fmt.Println("ids2222222222", ids)
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	list, _ := service.GetOutExprotList(orgId, ids, startTime, endTime)
	outCount, _ := service.GetOutStockTotalCountOne(startTime, endTime, orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":  list,
		"count": outCount,
	})
}

func (this *StockManagerApiController) GetSingleCancelOrder() {

	id, _ := this.GetInt64("id")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	order, _ := service.GetSingleCancelOrder(id, orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": order,
	})
}

func (this *StockManagerApiController) GetCancelStockOrderPrint() {
	id := this.GetString("id")
	idStr := strings.Split(id, ",")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, _ := service.GetCancelStockOrderPrintOne(idStr, orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *StockManagerApiController) GetStockBatchNumber() {

	id, _ := this.GetInt64("id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, _ := service.GetStockBatchNumber(id, orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *StockManagerApiController) GetStockFlow() {

	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	good_id, _ := this.GetInt64("good_id")
	consumable_type, _ := this.GetInt64("is_sys")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")

	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}

	list, total, _ := service.GetStockFlowList(limit, page, consumable_type, orgId, startTime, endTime, good_id)
	manufacturerList, _ := service.GetAllManufacturerList(orgId)
	good, _ := service.GetGoodInformationByGoodId(good_id)
	houseList, _ := service.GetAllStoreHouseList(adminUserInfo.CurrentOrgId)
	patients, _ := service.GetAllPatientListSix(adminUserInfo.CurrentOrgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":             list,
		"total":            total,
		"manufacturerList": manufacturerList,
		"good":             good,
		"houseList":        houseList,
		"patients":         patients,
	})
}

func (this *StockManagerApiController) GetCancelExportList() {

	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	idArray := this.GetString("order_id")
	fmt.Println("232323232323232232", idArray)
	ids := strings.Split(idArray, ",")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	list, _ := service.GetCancelExportList(startTime, endTime, ids, orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *StockManagerApiController) GetSearchGoodWarehouseList() {

	keyword := this.GetString("keyword")
	storehouse_id, _ := this.GetInt64("storehouse_id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, _ := service.GetSearchGoodWarehouseList(keyword, orgId, storehouse_id)
	manufacturerList, _ := service.GetAllManufacturerList(orgId)
	dealerList, _ := service.GetAllDealerList(orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":             list,
		"manufacturerList": manufacturerList,
		"dealerList":       dealerList,
	})
}

func (this *StockManagerApiController) SaveAdjuestPrice() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	tableData, _ := dataBody["tableData"].([]interface{})
	if len(tableData) > 0 {
		for _, item := range tableData {
			items := item.(map[string]interface{})

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			if items["start_time"] == nil || reflect.TypeOf(items["start_time"]).String() != "string" {
				utils.ErrorLog("start_time")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			var startTime int64
			start_time := items["start_time"].(string)
			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)
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				startTime = theTime.Unix()
			}
			orgId := this.GetAdminUserInfo().CurrentOrgId
			adjustprice := models.XtStockAdjustPrice{
				GoodName:          good_name,
				SpecificationName: specification_name,
				WarehousingUnit:   warehousing_unit,
				Count:             count,
				BuyPrice:          buy_price,
				PackingPrice:      packing_price,
				NewPrice:          new_price,
				Manufacturer:      manufacturer,
				Dealer:            dealer,
				Remark:            remark,
				GoodId:            good_id,
				UserOrgId:         orgId,
				Ctime:             time.Now().Unix(),
				Mtime:             0,
				Status:            1,
				WarehousingOrder:  warehousing_order,
				LicenseNumber:     license_number,
				StartTime:         startTime,
				Creater:           this.GetAdminUserInfo().AdminUser.Id,
				CheckerStatus:     2,
			}

			service.CreateAdjustPrice(&adjustprice)
		}
	}

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

func (this *StockManagerApiController) GetAllStockPrice() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println(err)
	orgId := this.GetAdminUserInfo().CurrentOrgId
	keyword := this.GetString("keyword")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}

	list, total, _ := service.GetAllStockPrice(orgId, startTime, endTime, keyword, limit, page)
	doctor, _ := service.GetAllDoctorThree(orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":   list,
		"doctor": doctor,
		"total":  total,
	})
}

func (this *StockManagerApiController) SaveCheckPrice() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println(err)
	idstr := this.GetString("ids")
	ids := strings.Split(idstr, ",")
	check_time := this.GetString("check_time")
	var checkTime int64
	if len(check_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", check_time+" 00:00:00", loc)
		if err != nil {
			fmt.Println(err)
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		checkTime = theTime.Unix()
	}
	checker, _ := this.GetInt64("checker")
	adjustPrice := models.XtStockAdjustPrice{
		Checker:       checker,
		CheckerStatus: 1,
		CheckerTime:   checkTime,
	}
	err = service.UpdateAdjustPrice(ids, adjustPrice)
	fmt.Println(err)

	list, _ := service.GetAdjustCheckPriceList(ids)
	fmt.Println("list2333223323232323232323", list)
	for _, item := range list {
		info := models.GoodInfo{
			PackingPrice: item.NewPrice,
			BuyPrice:     item.NewPrice,
		}
		err = service.UpdateAdjustCheckPrice(&info, item.GoodId)
		fmt.Println(err)
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"adjustPrice": adjustPrice,
	})
}

func (this *StockManagerApiController) GetAdjustPriceById() {

	ids := this.GetString("ids")
	fmt.Println("ids23232233223233232", ids)
	splitIds := strings.Split(ids, ",")
	list, _ := service.GetAdjustPricebyIdOne(splitIds)
	fmt.Println("list2322322323", list)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *StockManagerApiController) SaveReportStock() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	tableData, _ := dataBody["tableData"].([]interface{})
	if len(tableData) > 0 {
		for _, item := range tableData {
			items := item.(map[string]interface{})

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			if items["product_date"] == nil || reflect.TypeOf(items["product_date"]).String() != "float64" {
				utils.ErrorLog("product_date")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			product_date := int64(items["product_date"].(float64))
			orgId := this.GetAdminUserInfo().CurrentOrgId
			Creater := this.GetAdminUserInfo().AdminUser.Id

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

			if items["good_origin_place"] == nil || reflect.TypeOf(items["good_origin_place"]).String() != "string" {
				utils.ErrorLog("good_origin_place")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			good_origin_place := items["good_origin_place"].(string)
			reportPrice := models.XtStockReportPrice{
				GoodName:          good_name,
				SpecificationName: specification_name,
				WarehousingUnit:   warehousing_unit,
				Count:             count,
				BuyPrice:          buy_price,
				PackingPrice:      packing_price,
				Manufacturer:      manufacturer,
				Dealer:            dealer,
				Remark:            remark,
				GoodId:            good_id,
				UserOrgId:         orgId,
				Ctime:             time.Now().Unix(),
				Mtime:             0,
				Status:            1,
				WarehousingOrder:  warehousing_order,
				LicenseNumber:     license_number,
				StartTime:         startTime,
				Creater:           Creater,
				Checker:           0,
				CheckerStatus:     2,
				CheckerTime:       0,
				Number:            number,
				WarehousingInfoId: warehousing_info_id,
				ExpiryDate:        expiry_date,
				ProductDate:       product_date,
				Total:             total,
				GoodOriginPlace:   good_origin_place,
			}
			err := service.CreateReportPrice(&reportPrice)
			fmt.Println(err)
		}
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"msg": "保存成功!",
	})
}

func (this *StockManagerApiController) GetReportStockList() {

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

	}

	orgId := this.GetAdminUserInfo().CurrentOrgId
	keyword := this.GetString("keyword")
	list, total, _ := service.GetStockDamagedList(orgId, keyword, page, limit, startTime, endTime, storehouse_id)
	damageList, _ := service.GetStockDamagedCount(orgId)
	doctorlist, _ := service.GetAllDoctorThree(orgId)
	houseList, _ := service.GetAllStoreHouseList(orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":       list,
		"total":      total,
		"doctorlist": doctorlist,
		"damageList": damageList,
		"houseList":  houseList,
	})
}

func (this *StockManagerApiController) SaveCheckDamage() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	idstr := this.GetString("ids")
	ids := strings.Split(idstr, ",")
	check_time := this.GetString("check_time")
	var checkTime int64
	if len(check_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", check_time+" 00:00:00", loc)
		if err != nil {
			fmt.Println(err)
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		checkTime = theTime.Unix()
	}
	checker, _ := this.GetInt64("checker")
	reportprice := models.XtStockReportPrice{
		Checker:       checker,
		CheckerStatus: 1,
		CheckerTime:   checkTime,
	}
	err := service.UpdateCheckDamage(ids, reportprice)
	fmt.Println(err)

	//获取当前核对的数据
	list, _ := service.GetCheckDamageList(ids)

	ctime := time.Now().Unix()
	adminUserInfo := this.GetAdminUserInfo()
	timeStr := time.Now().Format("2006-01-02")
	timeArr := strings.Split(timeStr, "-")
	total, _ := service.FindAllWarehouseOut(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 = "CKD" + strconv.FormatInt(number, 10)
	operation_time := time.Now().Unix()
	creater := adminUserInfo.AdminUser.Id

	warehouseOut := models.WarehouseOut{
		WarehouseOutOrderNumber: warehousing_out_order,
		OperationTime:           operation_time,
		OrgId:                   adminUserInfo.CurrentOrgId,
		Creater:                 creater,
		Ctime:                   ctime,
		Status:                  1,
		WarehouseOutTime:        ctime,
		Type:                    1,
	}

	_, errcodes := service.FindStockOutByIsSys(adminUserInfo.CurrentOrgId, 0, operation_time)

	if errcodes == gorm.ErrRecordNotFound {
		service.AddSigleWarehouseOut(&warehouseOut)

	}
	out, _ := service.GetLastGoodWarehouseOut(adminUserInfo.CurrentOrgId)
	manufacturerList, _ := service.GetAllManufacturerList(adminUserInfo.CurrentOrgId)
	dealerList, _ := service.GetAllDealerList(adminUserInfo.CurrentOrgId)
	var manufacturer_id int64
	var dealer_id int64

	for _, item := range list {
		for _, it := range manufacturerList {
			if item.Manufacturer == it.ManufacturerName {
				manufacturer_id = it.ID
			}
		}
		for _, its := range dealerList {
			if item.Dealer == its.DealerName {
				dealer_id = its.ID
			}
		}
		goodinfo, _ := service.GetGoodInformationByGoodId(item.GoodId)
		//插入出库单
		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseOutOrderNumber: out.WarehouseOutOrderNumber,
			WarehouseOutId:          out.ID,
			GoodId:                  item.GoodId,
			Count:                   item.Count,
			Price:                   item.PackingPrice,
			Status:                  1,
			Ctime:                   ctime,
			Remark:                  item.Remark,
			OrgId:                   adminUserInfo.CurrentOrgId,
			Type:                    2,
			Manufacturer:            manufacturer_id,
			Number:                  item.Number,
			ExpiryDate:              item.ExpiryDate,
			ProductDate:             item.ProductDate,
			Dealer:                  dealer_id,
			LicenseNumber:           item.LicenseNumber,
			GoodTypeId:              goodinfo.GoodTypeId,
		}
		errOne := service.AddSigleWarehouseOutInfo(warehouseOutInfo)
		fmt.Println("99999999999999", errOne)

		//更改库存
		info, _ := service.GetWarehouseInfoById(item.WarehousingInfoId)

		warehousingInfo := models.WarehousingInfo{
			StockCount: info.StockCount - item.Count,
		}
		errOne = service.UpdateGoodWarehouseInfo(item.WarehousingInfoId, warehousingInfo)
		fmt.Println(errOne)
		flow := models.VmStockFlow{
			WarehousingId:           0,
			GoodId:                  item.GoodId,
			Number:                  item.Number,
			LicenseNumber:           item.LicenseNumber,
			Count:                   item.Count,
			UserOrgId:               adminUserInfo.CurrentOrgId,
			PatientId:               0,
			SystemTime:              time.Now().Unix(),
			ConsumableType:          5,
			IsSys:                   0,
			WarehousingOrder:        "",
			WarehouseOutId:          out.ID,
			WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber,
			IsEdit:                  0,
			CancelStockId:           0,
			CancelOrderNumber:       "",
			Manufacturer:            0,
			Dealer:                  0,
			Creator:                 adminUserInfo.AdminUser.Id,
			UpdateCreator:           0,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Mtime:                   0,
			Price:                   item.PackingPrice,
			WarehousingDetailId:     0,
			WarehouseOutDetailId:    0,
			CancelOutDetailId:       0,
			ProductDate:             item.ProductDate,
			ExpireDate:              item.ExpiryDate,
		}
		service.CreateStockFlowOne(flow)
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"reportPrice": reportprice,
	})
}

func (this *StockManagerApiController) SaveInventory() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	tableData, _ := dataBody["tableData"].([]interface{})
	if len(tableData) > 0 {
		for _, item := range tableData {
			items := item.(map[string]interface{})

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			if items["good_origin_place"] == nil || reflect.TypeOf(items["good_origin_place"]).String() != "string" {
				utils.ErrorLog("good_origin_place")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			good_origin_place := items["good_origin_place"].(string)
			orgId := this.GetAdminUserInfo().CurrentOrgId
			Creater := this.GetAdminUserInfo().AdminUser.Id

			inventory := models.XtStockInventory{
				GoodName:          good_name,
				SpecificationName: specification_name,
				WarehousingUnit:   warehousing_unit,
				Count:             count,
				BuyPrice:          buy_price,
				PackingPrice:      packing_price,
				NewPrice:          0,
				Manufacturer:      manufacturer,
				Dealer:            dealer,
				Remark:            remark,
				GoodId:            good_id,
				UserOrgId:         orgId,
				Ctime:             time.Now().Unix(),
				Mtime:             0,
				Status:            1,
				WarehousingOrder:  warehousing_order,
				LicenseNumber:     license_number,
				StartTime:         startTime,
				Creater:           Creater,
				Checker:           0,
				CheckerStatus:     2,
				CheckerTime:       0,
				Total:             total,
				ExpireDate:        expiry_date,
				ProductDate:       product_date,
				Number:            number,
				WarehousingInfoId: warehousing_info_id,
				GoodOriginPlace:   good_origin_place,
			}
			err = service.CreateInentory(inventory)
			fmt.Println(err)
		}
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"msg": "保存成功!",
	})
}

func (this *StockManagerApiController) GetInventorylist() {

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

	}

	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, total, _ := service.GetInventorylist(startTime, endTime, page, limit, inventory_status, keyword, orgId)
	doctorlist, _ := service.GetAllDoctorThree(orgId)

	houseList, _ := service.GetAllStoreHouseList(orgId)
	houseConfig, _ := service.GetAllStoreHouseConfig(orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":        list,
		"total":       total,
		"doctorlist":  doctorlist,
		"houseList":   houseList,
		"houseConfig": houseConfig,
	})
}

func (this *StockManagerApiController) SaveCheckInventory() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println(err)
	idstr := this.GetString("ids")
	ids := strings.Split(idstr, ",")
	check_time := this.GetString("check_time")
	var checkTime int64
	if len(check_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", check_time+" 00:00:00", loc)
		if err != nil {
			fmt.Println(err)
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		checkTime = theTime.Unix()
	}
	checker, _ := this.GetInt64("checker")
	inventory := models.XtStockInventory{
		Checker:       checker,
		CheckerStatus: 1,
		CheckerTime:   checkTime,
	}
	adminUserInfo := this.GetAdminUserInfo()
	err = service.UpdateCheckInventory(ids, inventory)
	manufacturerList, _ := service.GetAllManufacturerList(adminUserInfo.CurrentOrgId)
	dealerList, _ := service.GetAllDealerList(adminUserInfo.CurrentOrgId)
	var manufactuer_id int64
	var dealer_id int64
	//查询耗材信息
	list, _ := service.GetInventoryDetailById(ids)
	for _, item := range list {
		for _, it := range manufacturerList {
			if item.Manufacturer == it.ManufacturerName {
				manufactuer_id = it.ID
			}
		}

		for _, its := range dealerList {
			if item.Dealer == its.DealerName {
				dealer_id = its.ID
			}
		}
		//查寻该批次的库存量
		list, _ := service.GetWarehouseInfoById(item.WarehousingInfoId)

		//查询该耗材最后1条批次
		info, _ := service.GetLastWarehouseInfo(item.GoodId)
		good, _ := service.GetGoodInformationByGoodId(item.GoodId)
		fmt.Println("总共", item.Count)
		fmt.Println("数据", list.StockCount)
		//盘点盘点库存和et实际库存的大小
		// 如果盘点库存大于实际库存，怎需要入库
		if item.Count > list.StockCount {

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

			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := service.FindAllWarehouseTotal(adminUserInfo.CurrentOrgId)
			total = total + 1
			warehousing_order := "RKD" + 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.Warehousing{
				WarehousingOrder: warehousing_order,
				OperationTime:    operation_time,
				OrgId:            adminUserInfo.CurrentOrgId,
				Creater:          creater,
				Ctime:            ctime,
				Status:           1,
				WarehousingTime:  ctime,
				Type:             1,
			}
			service.AddSigleWarehouse(&warehousing)

			//获取最
			//入库单表格
			warehouseInfo := models.WarehousingInfo{
				WarehousingOrder: warehousing.WarehousingOrder,
				WarehousingId:    warehousing.ID,
				GoodId:           item.GoodId,
				Number:           info.Number,
				ProductDate:      info.ProductDate,
				ExpiryDate:       info.ExpiryDate,
				WarehousingCount: item.Count - list.StockCount,
				Price:            info.Price,
				Status:           1,
				Ctime:            ctime,
				Remark:           item.Remark,
				OrgId:            adminUserInfo.CurrentOrgId,
				Type:             1,
				Manufacturer:     manufactuer_id,
				StockCount:       item.Count - list.StockCount,
				Dealer:           dealer_id,
				LicenseNumber:    info.LicenseNumber,
				WarehouseInfoId:  item.WarehousingInfoId,
				GoodTypeId:       good.GoodTypeId,
			}

			flow := models.VmStockFlow{
				WarehousingOrder:    warehousing.WarehousingOrder,
				WarehousingId:       warehousing.ID,
				GoodId:              item.GoodId,
				Number:              info.Number,
				ProductDate:         info.ProductDate,
				ExpireDate:          info.ExpiryDate,
				Count:               item.Count - list.StockCount,
				Price:               item.BuyPrice,
				Status:              1,
				Ctime:               ctime,
				UserOrgId:           adminUserInfo.CurrentOrgId,
				Manufacturer:        info.Manufacturer,
				Dealer:              info.Dealer,
				LicenseNumber:       info.LicenseNumber,
				IsEdit:              1,
				Creator:             adminUserInfo.AdminUser.Id,
				SystemTime:          operation_time,
				ConsumableType:      1,
				WarehousingDetailId: warehouseInfo.ID,
			}

			service.CreateWarehouseInfo(warehouseInfo)
			service.CreateStockFlowOne(flow)

		}

		//如果盘点库存小于实际库存，需要出库
		if item.Count < list.StockCount {
			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := service.FindAllWarehouseOut(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 = "CKD" + strconv.FormatInt(number, 10)
			operation_time := time.Now().Unix()
			creater := adminUserInfo.AdminUser.Id

			//查询最早的1条批次
			warehouseInfo, _ := service.GetFirstWarehouseInfo(item.GoodId)
			warehouseOut := models.WarehouseOut{
				WarehouseOutOrderNumber: warehousing_out_order,
				OperationTime:           operation_time,
				OrgId:                   adminUserInfo.CurrentOrgId,
				Creater:                 creater,
				Ctime:                   time.Now().Unix(),
				Status:                  1,
				WarehouseOutTime:        time.Now().Unix(),
				Type:                    1,
			}
			err = service.CreateWarehouseOut(warehouseOut)
			fmt.Println(err)
			out, _ := service.GetLastGoodWarehouseOut(adminUserInfo.CurrentOrgId)
			warehouseOutInfo := &models.WarehouseOutInfo{
				WarehouseOutOrderNumber: out.WarehouseOutOrderNumber,
				WarehouseOutId:          out.ID,
				GoodId:                  warehouseInfo.GoodId,
				Count:                   list.StockCount - item.Count,
				Price:                   warehouseInfo.Price,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				Remark:                  item.Remark,
				OrgId:                   adminUserInfo.CurrentOrgId,
				Type:                    1,
				Manufacturer:            manufactuer_id,
				Number:                  warehouseInfo.Number,
				ExpiryDate:              warehouseInfo.ExpiryDate,
				ProductDate:             warehouseInfo.ProductDate,
				Dealer:                  dealer_id,
				LicenseNumber:           warehouseInfo.LicenseNumber,
				GoodTypeId:              good.GoodTypeId,
				SysRecordTime:           time.Now().Unix(),
			}

			stockFlow := models.VmStockFlow{
				WarehousingId:           item.WarehousingInfoId,
				GoodId:                  warehouseInfo.GoodId,
				Number:                  warehouseInfo.Number,
				LicenseNumber:           warehouseInfo.LicenseNumber,
				Count:                   list.StockCount - item.Count,
				UserOrgId:               warehouseInfo.OrgId,
				PatientId:               0,
				SystemTime:              time.Now().Unix(),
				ConsumableType:          2,
				IsSys:                   2,
				WarehousingOrder:        "",
				WarehouseOutId:          out.ID,
				WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
				IsEdit:                  1,
				CancelStockId:           0,
				CancelOrderNumber:       "",
				Manufacturer:            manufactuer_id,
				Dealer:                  dealer_id,
				Creator:                 adminUserInfo.AdminUser.Id,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				Mtime:                   0,
				Price:                   warehouseInfo.Price,
				WarehousingDetailId:     0,
				WarehouseOutDetailId:    out.ID,
				CancelOutDetailId:       0,
				ProductDate:             warehouseInfo.ProductDate,
				ExpireDate:              warehouseInfo.ExpiryDate,
			}
			errOne := service.AddSigleWarehouseOutInfo(warehouseOutInfo)
			fmt.Println(errOne)
			//创建出库明细
			service.CreateStockFlowOne(stockFlow)

			//更改库存
			warehousingInfos := models.WarehousingInfo{
				StockCount: item.Count,
			}
			service.UpdateStockOut(item.WarehousingInfoId, warehousingInfos)

		}
	}
	fmt.Println(err)
	this.ServeSuccessJSON(map[string]interface{}{
		"inventory": inventory,
	})
}

func (this *StockManagerApiController) GetModifyPriceDetail() {

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

	detail, _ := service.GetModifyPriceDetail(id)
	this.ServeSuccessJSON(map[string]interface{}{
		"detail": detail,
	})
}

func (this *StockManagerApiController) UpdateStockPrice() {

	id, _ := this.GetInt64("id")
	newPrice := this.GetString("new_price")
	new_price, _ := strconv.ParseFloat(newPrice, 64)
	good_name := this.GetString("good_name")
	packingPrice := this.GetString("packing_price")
	packing_price, _ := strconv.ParseFloat(packingPrice, 64)
	remark := this.GetString("remark")
	good_id, _ := this.GetInt64("good_id")
	manufacturer := this.GetString("manufacturer")
	dealer := this.GetString("dealer")
	adjust := models.XtStockAdjustPrice{
		NewPrice:     new_price,
		GoodName:     good_name,
		PackingPrice: packing_price,
		Remark:       remark,
		GoodId:       good_id,
		Manufacturer: manufacturer,
		Dealer:       dealer,
	}
	err := service.UpdateStockPrice(adjust, id)
	fmt.Println(err)
	this.ServeSuccessJSON(map[string]interface{}{
		"adjust": adjust,
	})
}

func (this *StockManagerApiController) DeleteStockPrice() {

	id, _ := this.GetInt64("id")
	err := service.DeleteStockPrice(id)
	fmt.Println(err)
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *StockManagerApiController) GetStockDamageDetail() {

	id, _ := this.GetInt64("id")
	detail, err := service.GetStockDamageDetail(id)
	fmt.Println(err)
	this.ServeSuccessJSON(map[string]interface{}{
		"detail": detail,
	})
}

func (this *StockManagerApiController) ModifyPrice() {

	count, _ := this.GetInt64("count")
	id, _ := this.GetInt64("id")
	good_name := this.GetString("good_name")
	specification_name := this.GetString("specification_name")
	number := this.GetString("number")
	warehousing_unit := this.GetString("warehousing_unit")
	buyPrice := this.GetString("buy_price")
	buy_price, _ := strconv.ParseFloat(buyPrice, 64)
	packingPrice := this.GetString("packing_price")
	packing_price, _ := strconv.ParseFloat(packingPrice, 64)
	good_origin_place := this.GetString("good_origin_place")
	manufacturer := this.GetString("manufacturer")
	dealer := this.GetString("dealer")
	total, _ := this.GetInt64("total")
	remark := this.GetString("remark")
	warehousing_info_id, _ := this.GetInt64("warehousing_info_id")
	good_id, _ := this.GetInt64("good_id")
	adjust := models.XtStockReportPrice{
		Count:             count,
		SpecificationName: specification_name,
		Number:            number,
		GoodName:          good_name,
		WarehousingUnit:   warehousing_unit,
		BuyPrice:          buy_price,
		PackingPrice:      packing_price,
		GoodOriginPlace:   good_origin_place,
		Manufacturer:      manufacturer,
		Dealer:            dealer,
		Total:             total,
		Remark:            remark,
		WarehousingInfoId: warehousing_info_id,
		GoodId:            good_id,
	}
	err := service.ModifyPrice(id, adjust)
	fmt.Println(err)
	this.ServeSuccessJSON(map[string]interface{}{
		"adjust": adjust,
	})
}

func (this *StockManagerApiController) DeleteDamage() {

	id, _ := this.GetInt64("id")
	err := service.DeleteDamage(id)
	fmt.Println(err)
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *StockManagerApiController) GetStockDamageById() {
	ids := this.GetString("ids")

	splitIds := strings.Split(ids, ",")
	list, _ := service.GetStockDamageById(splitIds)

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

func (this *StockManagerApiController) GetInventoryDetail() {
	id, _ := this.GetInt64("id")
	detail, _ := service.GetInventoryDetail(id)
	this.ServeSuccessJSON(map[string]interface{}{
		"detail": detail,
	})
}

func (this *StockManagerApiController) ModifyInventory() {
	id, _ := this.GetInt64("id")
	good_id, _ := this.GetInt64("good_id")
	good_name := this.GetString("good_name")
	specification_name := this.GetString("specification_name")
	number := this.GetString("number")
	warehousing_unit := this.GetString("warehousing_unit")
	buyPrice := this.GetString("buy_price")
	buy_price, _ := strconv.ParseFloat(buyPrice, 64)
	packingPrice := this.GetString("packing_price")
	packing_price, _ := strconv.ParseFloat(packingPrice, 64)
	total, _ := this.GetInt64("total")
	good_origin_place := this.GetString("good_origin_place")
	license_number := this.GetString("license_number")
	dealer := this.GetString("dealer")
	manufacturer := this.GetString("manufacturer")
	count, _ := this.GetInt64("count")
	remark := this.GetString("remark")
	inventory := models.XtStockInventory{
		GoodId:            good_id,
		GoodName:          good_name,
		SpecificationName: specification_name,
		Number:            number,
		WarehousingUnit:   warehousing_unit,
		BuyPrice:          buy_price,
		PackingPrice:      packing_price,
		Total:             total,
		GoodOriginPlace:   good_origin_place,
		LicenseNumber:     license_number,
		Dealer:            dealer,
		Manufacturer:      manufacturer,
		Count:             count,
		Remark:            remark,
	}
	err := service.ModifyInventory(id, inventory)
	fmt.Println(err)
	this.ServeSuccessJSON(map[string]interface{}{
		"inventory": inventory,
	})
}

func (this *StockManagerApiController) DeleteInventory() {
	id, _ := this.GetInt64("id")
	err := service.DeleteInventory(id)
	fmt.Println(err)
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *StockManagerApiController) GetInventoryDetailList() {
	keyword := this.GetString("keyword")
	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	appId := this.GetAdminUserInfo().CurrentAppId
	storehouse_id, _ := this.GetInt64("storehouse_id")
	houseList, _ := service.GetAllStoreHouseList(orgId)
	list, total, _ := service.GetInventoryDetailList(keyword, limit, page, orgId, storehouse_id)
	doclist, _ := service.GetAllDoctorListSix(orgId, appId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":      list,
		"total":     total,
		"houseList": houseList,
		"doclist":   doclist,
	})
}

func (this *StockManagerApiController) GetInventoryPrintList() {

	ids := this.GetString("ids")
	splitIds := strings.Split(ids, ",")
	list, _ := service.GetInventoryPrintList(splitIds)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *StockManagerApiController) GetInventoryDetailPrintList() {
	ids := this.GetString("ids")
	splitIds := strings.Split(ids, ",")
	list, _ := service.GetInventoryDetailPrintList(splitIds)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *StockManagerApiController) DeleteDrugPrice() {

	id, _ := this.GetInt64("id")
	err := service.DeleteDrugPrice(id)
	fmt.Println(err)
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *StockManagerApiController) GetGoodWarehouseList() {

	id, _ := this.GetInt64("id")
	list, _ := service.GetGoodWarehouseList(id)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *StockManagerApiController) ProofInventory() {

	id, _ := this.GetInt64("id")
	good_id, _ := this.GetInt64("good_id")
	warehousing_info_id, _ := this.GetInt64("warehousing_info_id")
	proof_count, _ := this.GetInt64("proof_count")
	total, _ := this.GetInt64("total")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	creater := this.GetAdminUserInfo().AdminUser.Id

	info := models.WarehousingInfo{
		GoodId:     good_id,
		StockCount: proof_count,
	}
	err := service.UpdateProofInventory(warehousing_info_id, info)
	inventory := models.XtStockInventory{
		Total: proof_count,
	}
	err = service.UpdateStockInventory(inventory, id)
	fmt.Println(err)
	record := models.XtStockCorrectRecord{
		GoodId:            good_id,
		OrdCount:          total,
		WarehousingInfoId: warehousing_info_id,
		NewCount:          proof_count,
		UserOrgId:         orgId,
		Status:            1,
		Creater:           creater,
		Ctime:             time.Now().Unix(),
		Mtime:             0,
	}
	service.CeateStockCorrectRecord(record)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": info,
	})
}

func (this *StockManagerApiController) GetWarehouseTotal() {

	id, _ := this.GetInt64("id")
	list, _ := service.GetWarehouseTotal(id)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *StockManagerApiController) GetGoodInventoryWarehouseList() {

	id, _ := this.GetInt64("id")
	storehouse_id, _ := this.GetInt64("storehouse_id")
	list, _ := service.GetGoodInventoryWarehouseList(id, storehouse_id)
	orgId := this.GetAdminUserInfo().CurrentOrgId
	fmt.Println(orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *StockManagerApiController) SaveStockInventoryList() {

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println(err)

	tableData, _ := dataBody["tableData"].([]interface{})
	if len(tableData) > 0 {
		for _, item := range tableData {
			items := item.(map[string]interface{})
			good_name := items["good_name"].(string)
			if items["good_name"] == nil || reflect.TypeOf(items["good_name"]).String() != "string" {
				utils.ErrorLog("good_name")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}

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

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

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

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

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

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

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

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

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

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

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

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

			orgId := this.GetAdminUserInfo().CurrentOrgId
			adminId := this.GetAdminUserInfo().AdminUser.Id

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

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

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

			if stock_count > last_stock_count {
				total_count = stock_count - last_stock_count
				inventory_type = 11
			}
			if stock_count < last_stock_count {
				total_count = last_stock_count - stock_count
				inventory_type = 10
			}

			creater := this.GetAdminUserInfo().AdminUser.Id
			inventory := models.XtStockInventory{
				GoodName:          good_name,
				SpecificationName: specification_name,
				WarehousingUnit:   warehousing_unit,
				Count:             total_count,
				BuyPrice:          price,
				PackingPrice:      price,
				NewPrice:          0,
				Manufacturer:      manufacturer_name,
				Dealer:            "",
				Remark:            "",
				GoodId:            good_id,
				UserOrgId:         orgId,
				Ctime:             time.Now().Unix(),
				Mtime:             0,
				Status:            1,
				WarehousingOrder:  warehousing_order,
				LicenseNumber:     number,
				StartTime:         time.Now().Unix(),
				Creater:           adminId,
				Checker:           0,
				CheckerStatus:     0,
				CheckerTime:       0,
				Total:             0,
				Number:            number,
				WarehousingInfoId: id,
				ExpireDate:        expiry_date,
				ProductDate:       product_date,
				GoodOriginPlace:   "",
				Type:              10,
				InventoryType:     stock_type,
				LastStockCount:    last_stock_count,
				StockCount:        stock_count,
				StorehouseId:      storehouse_id,
			}
			service.CreateInentory(inventory)

			stockFlow := models.VmStockFlow{
				WarehousingId:           0,
				GoodId:                  good_id,
				Number:                  number,
				LicenseNumber:           "",
				Count:                   total_count,
				UserOrgId:               orgId,
				PatientId:               0,
				SystemTime:              0,
				ConsumableType:          inventory_type,
				IsSys:                   0,
				WarehousingOrder:        "",
				WarehouseOutId:          0,
				WarehouseOutOrderNumber: warehousing_order,
				IsEdit:                  0,
				CancelStockId:           0,
				CancelOrderNumber:       "",
				Manufacturer:            manufacturer,
				Dealer:                  0,
				Creator:                 creater,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				Mtime:                   0,
				Price:                   price,
				WarehousingDetailId:     0,
				WarehouseOutDetailId:    0,
				CancelOutDetailId:       0,
				ProductDate:             product_date,
				ExpireDate:              expiry_date,
				ReturnCount:             0,
				StorehouseId:            storehouse_id,
			}

			info := models.WarehousingInfo{
				StockCount:       last_stock_count,
				WarehousingCount: last_stock_count,
			}

			warehosueinfos, _ := service.GetWarehouseInfoByIdNight(id)
			//如果当前的盘点后的数量大于当前库存数量,则新增库存
			if last_stock_count > warehosueinfos.StockCount && last_stock_count <= warehosueinfos.WarehousingCount {
				//更改库存
				service.UpdatedWarehousingInfo(info, id)
			}

			if last_stock_count > warehosueinfos.StockCount && last_stock_count > warehosueinfos.WarehousingCount {

				//更改库存
				service.UpdatedWarehousingInfoSix(info, id)
			}
			//如果当前的盘点后的数量大于当前库存数量,则扣减库存
			if last_stock_count < warehosueinfos.StockCount {

				//更改库存
				service.UpdatedWarehousingInfo(info, id)
			}
			//查询该机构默认仓库
			storeConfig, _ := service.GetAllStoreHouseConfig(warehosueinfos.OrgId)
			goodListOne, _ := service.GetSumGoodList(orgId, storeConfig.StorehouseOutInfo, good_id)
			var flush_count int64
			for _, it := range goodListOne {
				flush_count += it.StockCount
			}

			if stock_count != last_stock_count {
				stockFlow.OverCount = flush_count
				service.CreateStockFlowOne(stockFlow)
			}

			//查询已审核单据的剩余库存
			goodList, _ := service.GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, good_id, warehosueinfos.OrgId)
			var sum_count int64
			var sum_in_count int64
			for _, item := range goodList {
				sum_count += item.StockCount
				sum_in_count += item.WarehousingCount
			}
			service.UpdateGoodByGoodId(good_id, sum_count, sum_in_count, warehosueinfos.OrgId)

			service.UpdateSumGood(orgId, storeConfig.StorehouseOutInfo, good_id, flush_count)
			this.ServeSuccessJSON(map[string]interface{}{
				"inventory": inventory,
			})
		}
	}
}

func (this *StockManagerApiController) GetDamageDetailByGoodId() {

	good_id, _ := this.GetInt64("good_id")
	warehousing_order := this.GetString("warehousing_order")
	inventory_type, _ := this.GetInt64("type")
	list, _ := service.GetDamageDetailByGoodId(good_id, warehousing_order, inventory_type)
	orgId := this.GetAdminUserInfo().CurrentOrgId
	damageList, _ := service.GetStockDamagedCountOne(orgId, warehousing_order, inventory_type)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":       list,
		"damageList": damageList,
	})
}

func (this *StockManagerApiController) GetInventoryExportList() {

	orgId := this.GetAdminUserInfo().CurrentOrgId

	list, _ := service.GetInventoryExportList(orgId)
	manufacturerList, _ := service.GetAllManufacturerList(orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":             list,
		"manufacturerList": manufacturerList,
	})
}

func (this *StockManagerApiController) UpdateCancelStockOrder() {

	type_id, _ := this.GetInt64("type_id")
	//获取目前在使用的机构ID
	list, _ := service.GetOrgIdList()

	//耗材
	if type_id == 1 {
		for _, item := range list {
			//查询该机构的所有耗材
			goodList, _ := service.GetAllGoodList(item.OrgId)

			for _, it := range goodList {
				//查询该耗材的入库总数
				info, _ := service.GetStockCountWarehouseInfoById(it.ID)
				var total int64
				for _, its := range info {
					total += its.StockCount
				}
				//更新库存
				service.ModifyGoodAddInformationSeven(it.ID, total, it.OrgId)
			}
		}
	}

	//药品
	if type_id == 2 {

		for _, item := range list {
			fmt.Println(item)
			//查询该机构的所有药品
			drugList, _ := service.GetAllBaseDrugStockList(4)
			for _, it := range drugList {
				//查询该药品的入库总数
				info, _ := service.GetDrugStockCountWarehoseInfoById(it.ID)
				var sum_count int64
				for _, its := range info {
					if its.MaxUnit == it.MaxUnit {
						its.StockMaxNumber = its.StockMaxNumber * it.MinNumber
					}
					sum_count += its.StockMaxNumber + its.StockMinNumber
				}
				service.UpdateModifyDrugInfoById(it.ID, sum_count, it.OrgId)
			}

		}
	}
}

func (this *StockManagerApiController) GetDrugDetailSummary() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")

	end_time := this.GetString("end_time")

	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
		fmt.Println("开始时间", startTime)
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 00:00:00", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}

	keyword := this.GetString("keyword")
	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, total, err := service.GetDrugDetailSummary(startTime, endTime, keyword, limit, page, orgId)
	druglist, _, _ := service.GetDrugDetailSummaryOne(startTime, endTime, keyword, limit, page, orgId)

	patients, _ := service.GetAllpatient(orgId)
	var drugType = "药品类型"
	drugTypeParent, _ := service.GetDrugDataConfig(0, drugType)
	drugTypeList, _ := service.GetParentDataConfig(drugTypeParent.ID, orgId)
	for _, item := range list {
		for _, it := range druglist {
			if item.DrugId == it.DrugId {
				item.ChildDoctorAdvice = append(item.ChildDoctorAdvice, it)
			}
		}
	}
	drug, _ := service.GetAllDrugSummary(orgId)

	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list":         list,
			"total":        total,
			"drug":         drug,
			"drugTypeList": drugTypeList,
			"patients":     patients,
		})
	}
}

func (this *StockManagerApiController) GetGoodDetailSummary() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")

	end_time := this.GetString("end_time")

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

	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 00:00:00", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}

	keyword := this.GetString("keyword")
	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, total, err := service.GetGoodDetailSummary(startTime, endTime, keyword, limit, page, orgId)

	goodlist, _, _ := service.GetGoodDetailSummaryOne(startTime, endTime, keyword, limit, page, orgId)
	for _, item := range list {
		for _, it := range goodlist {
			if item.ProjectId == it.ProjectId {
				item.ChildDoctorAdvice = append(item.ChildDoctorAdvice, it)
			}
		}
	}

	information, _ := service.GeAllGoodInformation(orgId)
	patients, _ := service.GetAllpatient(orgId)
	goodType, _ := service.GetAllGoodType(orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list":     list,
			"total":    total,
			"good":     information,
			"patients": patients,
			"goodType": goodType,
		})
	}
}

func (this *StockManagerApiController) CheckWarehouseOut() {

	id, _ := this.GetInt64("id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	creater := this.GetAdminUserInfo().AdminUser.Id
	warehouseOut, errcode := service.GetWarehouseById(id)
	if errcode != nil {
		goodErrcode := models.XtGoodErrcode{
			UserOrgId:      orgId,
			Errcode:        "查询审核出库单报错",
			GoodId:         0,
			Status:         0,
			Ctime:          0,
			Mtime:          0,
			Count:          0,
			StockCount:     0,
			Creater:        creater,
			BatchNumberId:  0,
			WarehouseOutId: 0,
		}
		service.CreateGoodErrcode(goodErrcode)
	}
	//查询已审核的单据
	warehousingOutInfo, erroce := service.GetWarehouseOutById(id, orgId)
	if erroce != nil {
		goodErrcode := models.XtGoodErrcode{
			UserOrgId:      orgId,
			Errcode:        "查询已审核出库详情单报错",
			GoodId:         0,
			Status:         0,
			Ctime:          0,
			Mtime:          0,
			Count:          0,
			StockCount:     0,
			Creater:        creater,
			BatchNumberId:  0,
			WarehouseOutId: 0,
		}
		service.CreateGoodErrcode(goodErrcode)
	}
	////出库逻辑
	for _, item := range warehousingOutInfo {
		// 查询该耗材是否有库存
		warehouseOne, _ := service.FindWarehousingInfoTen(item.GoodId, item.StorehouseId)
		storehouse, _ := service.FindStoreHouseByStorehouseId(item.StorehouseId, item.OrgId)

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

			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgId,
				Errcode:        "出库数量大于该批次剩余库存",
				GoodId:         0,
				Status:         0,
				Ctime:          0,
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creater,
				BatchNumberId:  warehouseOne.ID,
				WarehouseOutId: item.ID,
			}
			service.CreateGoodErrcode(goodErrcode)
			goodObj, _ := service.GetGoodInformationByGoodId(item.GoodId)
			this.ServeSuccessJSON(map[string]interface{}{
				"msg":                "1",
				"good_name":          goodObj.GoodName,
				"specification_name": goodObj.SpecificationName,
				"storehose_name":     storehouse.StorehouseName,
			})
			return
		}

	}
	for _, item := range warehousingOutInfo {

		creater := this.GetAdminUserInfo().AdminUser.Id

		//出库
		err := service.ConsumablesDeliveryThirty(orgId, item.SysRecordTime, item, &warehouseOut, item.Count, creater)
		if err != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgId,
				Errcode:        "调用出库接口报错",
				GoodId:         item.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creater,
				BatchNumberId:  0,
				WarehouseOutId: 0,
			}
			service.CreateGoodErrcode(goodErrcode)
		}

		goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
		var flush_count int64
		for _, it := range goodList {
			flush_count += it.StockCount
		}
		errs := service.UpdateSumGood(orgId, item.StorehouseId, item.GoodId, flush_count)
		if errs != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgId,
				Errcode:        "手动出库更新剩余出库失败",
				GoodId:         item.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creater,
				BatchNumberId:  0,
				WarehouseOutId: 0,
			}
			service.CreateGoodErrcode(goodErrcode)
		}

		orgId := this.GetAdminUserInfo().CurrentOrgId
		//查询默认仓库
		storeHouseConfig, _ := service.GetAllStoreHouseConfig(orgId)
		stockList, _ := service.GetStockCountByGoodId(item.GoodId, storeHouseConfig.StorehouseOutInfo, orgId)
		var total_count int64
		for _, it := range stockList {
			total_count += it.StockCount
		}
		//基础库扣减库存
		errsum := service.UpdateGoodInfoReduceSumCount(item.GoodId, total_count, orgId)
		if errsum != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgId,
				Errcode:        "基础库扣减库存报错",
				GoodId:         item.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creater,
				BatchNumberId:  0,
				WarehouseOutId: 0,
			}
			service.CreateGoodErrcode(goodErrcode)
		}
	}

	//审核单据
	err := service.UpdatedWarehouseOut(id)
	if err != nil {
		goodErrcode := models.XtGoodErrcode{
			UserOrgId:      orgId,
			Errcode:        "审核单据报错",
			GoodId:         0,
			Status:         1,
			Ctime:          time.Now().Unix(),
			Mtime:          0,
			Count:          0,
			StockCount:     0,
			Creater:        creater,
			BatchNumberId:  0,
			WarehouseOutId: 0,
		}
		service.CreateGoodErrcode(goodErrcode)
	}
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"msg":                "2",
			"good_name":          "",
			"specification_name": "",
			"storehose_name":     "",
		})
	}

}

func (this *StockManagerApiController) ReturnCheckWarehouseOut() {

	id, _ := this.GetInt64("id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	creater := this.GetAdminUserInfo().AdminUser.Id
	// 查询出库数据
	list, err := service.GetWarehouseOutById(id, orgId)
	if err != nil {
		goodErrcode := models.XtGoodErrcode{
			UserOrgId:      orgId,
			Errcode:        "反审核查询出库单报错",
			GoodId:         0,
			Status:         1,
			Ctime:          time.Now().Unix(),
			Mtime:          0,
			Count:          0,
			StockCount:     0,
			Creater:        creater,
			BatchNumberId:  0,
			WarehouseOutId: 0,
		}
		service.CreateGoodErrcode(goodErrcode)
	}
	for _, item := range list {
		//回退库存
		err := service.UpdateaGoodWarehouseInfo(item.Count, item.GoodId, item.OrgId, item.WarehouseInfotId)
		if err != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgId,
				Errcode:        "反审核回退库存报错",
				GoodId:         0,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creater,
				BatchNumberId:  0,
				WarehouseOutId: 0,
			}
			service.CreateGoodErrcode(goodErrcode)
		}
		//查询默认仓库
		storeHouseConfig, errs := service.GetAllStoreHouseConfig(orgId)
		if errs != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgId,
				Errcode:        "反审核查询默认仓库报错",
				GoodId:         0,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creater,
				BatchNumberId:  0,
				WarehouseOutId: 0,
			}
			service.CreateGoodErrcode(goodErrcode)
		}
		stockList, errcodes := service.GetStockCountByGoodId(item.GoodId, storeHouseConfig.StorehouseOutInfo, orgId)
		if errcodes != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgId,
				Errcode:        "反审核查询默认仓库库存报错",
				GoodId:         0,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creater,
				BatchNumberId:  0,
				WarehouseOutId: 0,
			}
			service.CreateGoodErrcode(goodErrcode)
		}
		var total_count int64
		for _, it := range stockList {
			total_count += it.StockCount
		}
		//基础库扣减库存
		errs = service.UpdateGoodInfoReduceSumCount(item.GoodId, total_count, orgId)
		if errs != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgId,
				Errcode:        "反审核基础库扣减库存报错",
				GoodId:         0,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creater,
				BatchNumberId:  0,
				WarehouseOutId: 0,
			}
			service.CreateGoodErrcode(goodErrcode)
		}

		goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
		var flush_count int64
		for _, it := range goodList {
			flush_count += it.StockCount
		}
		erros := service.UpdateSumGood(orgId, item.StorehouseId, item.GoodId, flush_count)
		if erros != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgId,
				Errcode:        "手动出库更新剩余库存报错",
				GoodId:         0,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creater,
				BatchNumberId:  0,
				WarehouseOutId: 0,
			}
			service.CreateGoodErrcode(goodErrcode)
		}
		//扣减出库数据
		errcoeds := service.ModifyReduceGoodSumCount(item.StorehouseId, item.Count, orgId, item.GoodId)
		if errcoeds != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgId,
				Errcode:        "反审核扣减出库数据报错",
				GoodId:         0,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creater,
				BatchNumberId:  0,
				WarehouseOutId: 0,
			}
			service.CreateGoodErrcode(goodErrcode)
		}

	}
	//删除流水，改变审核状态
	errcos := service.ModifyGoodWarehouseOut(id)
	if errcos != nil {
		goodErrcode := models.XtGoodErrcode{
			UserOrgId:      orgId,
			Errcode:        "反审核删除流水，改变审核状态报错",
			GoodId:         0,
			Status:         1,
			Ctime:          time.Now().Unix(),
			Mtime:          0,
			Count:          0,
			StockCount:     0,
			Creater:        creater,
			BatchNumberId:  0,
			WarehouseOutId: 0,
		}
		service.CreateGoodErrcode(goodErrcode)
	}

	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list": "list",
		})
	}
}

func (this *StockManagerApiController) CheckWarehouseInfo() {

	warehousing_info_id, _ := this.GetInt64("warehousing_info_id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	Creator := this.GetAdminUserInfo().AdminUser.Id
	//查询默认仓库
	storeHouseConfig, _ := service.GetAllStoreHouseConfig(orgId)

	checker := this.GetAdminUserInfo().AdminUser.Id
	//更改审核状态
	err := service.UpdateCheckWarehouseInfo(warehousing_info_id, checker)
	if err == nil {
		list, _ := service.GetWarehouseInfoList(warehousing_info_id, orgId)

		for _, item := range list {
			service.UpdateWarehouseInfoByIdListThree(item.WarehousingCount, item.ID)

			//查询该耗材剩余库存库
			stockList, _ := service.GetStockCountByGoodId(item.GoodId, storeHouseConfig.StorehouseOutInfo, orgId)
			var total_count int64
			var sum_in_count int64
			for _, it := range stockList {
				total_count += it.StockCount
				sum_in_count += it.WarehousingCount
			}
			//基础库插入数据
			service.UpdateGoodInfoAddSumCount(item.GoodId, total_count, orgId, sum_in_count)

			//查询该仓库是否有数据
			_, errcode := service.GetGoodStockCount(orgId, item.StorehouseId, item.GoodId)
			goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
			var flush_count int64
			for _, it := range goodList {
				flush_count += it.StockCount
			}
			stockFlow := models.VmStockFlow{
				WarehousingId:           item.WarehousingId,
				GoodId:                  item.GoodId,
				Number:                  item.Number,
				LicenseNumber:           item.LicenseNumber,
				Count:                   item.WarehousingCount,
				UserOrgId:               item.OrgId,
				PatientId:               0,
				SystemTime:              0,
				ConsumableType:          1,
				IsSys:                   1,
				WarehousingOrder:        item.WarehousingOrder,
				WarehouseOutId:          0,
				WarehouseOutOrderNumber: "",
				IsEdit:                  1,
				CancelStockId:           0,
				CancelOrderNumber:       "",
				Manufacturer:            item.Manufacturer,
				Dealer:                  item.Dealer,
				Creator:                 Creator,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   item.Ctime,
				Mtime:                   0,
				Price:                   item.PackingPrice,
				WarehousingDetailId:     item.ID,
				WarehouseOutDetailId:    0,
				CancelOutDetailId:       0,
				ProductDate:             item.ProductDate,
				ExpireDate:              item.ExpiryDate,
				SupplyWarehouseId:       item.SupplyWarehouseId,
				StorehouseId:            item.StorehouseId,
				AdminUserId:             0,
				BuyPrice:                item.Price,
				StockCount:              "",
				BatchNumberCount:        item.WarehousingCount,
				IsCheck:                 1,
				OverCount:               flush_count,
			}
			//创建出库流水
			service.CreateStockFlowOne(stockFlow)

			if errcode == gorm.ErrRecordNotFound {

				goodCount := models.XtGoodStockCount{
					UserOrgId:        orgId,
					GoodId:           item.GoodId,
					StorehouseId:     item.StorehouseId,
					Status:           1,
					Ctime:            time.Now().Unix(),
					Mtime:            time.Now().Unix(),
					StockInCount:     item.WarehousingCount,
					StockOutCount:    0,
					StockCancelCount: 0,
					FlushCount:       flush_count,
					StockActOutCount: 0,
				}
				service.CreateGoodCount(goodCount)
			}
			if errcode == nil {
				service.UpdateGoodStockCount(orgId, item.StorehouseId, item.GoodId, item.WarehousingCount, flush_count)
			}
		}
	}

	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list": "list",
		})
	}
}

func (this *StockManagerApiController) ReturnCheckWarehouseInfo() {

	warehousing_info_id, _ := this.GetInt64("warehousing_info_id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	//查询入库数据
	list, _ := service.GetWarehouseInfoList(warehousing_info_id, orgId)
	for _, item := range list {
		//查询该耗材 是否有出库数据
		outlist, _ := service.GetWarehouseOutByWarehouseInfoId(item.ID, item.GoodId, item.OrgId)

		if len(outlist) > 0 {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCheckGoodParamWrong)
			return
		}
	}
	//for _, item := range list {
	//
	//	//扣减数量
	//	service.UpdateWarehouseInfoByIdListTwo(item.WarehousingCount, item.ID)
	//
	//	//删除流水
	//	service.UpdateWarehouseInfoFlow(item.ID)
	//
	//	goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
	//	var flush_count int64
	//	for _, it := range goodList {
	//		flush_count += it.StockCount
	//	}
	//
	//	//扣减数量
	//	service.UpdateGoodInCount(item.WarehousingCount, item.OrgId, item.GoodId, item.StorehouseId, flush_count)
	//
	//	//查询默认仓库
	//	storeHouseConfig, _ := service.GetAllStoreHouseConfig(orgId)
	//	//查询该耗材剩余多少库存
	//	stockList, _ := service.GetStockCountByGoodId(item.GoodId, storeHouseConfig.StorehouseOutInfo, orgId)
	//	var sum_count int64
	//	var sum_in_count int64
	//	for _, it := range stockList {
	//		sum_count += it.StockCount
	//		sum_in_count += it.WarehousingCount
	//	}
	//	service.UpdateGoodInfoAddSumCount(item.GoodId, sum_count, orgId, sum_in_count)
	//}
	//err := service.ReturnCheckWarehouseInfo(warehousing_info_id)

	err := service.UpdateWarehouseInfoMap(list, warehousing_info_id, orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"msg": "反审核成功!",
		})
		return
	}

}

func (this *StockManagerApiController) CheckStockWarehouseInfo() {

	cancel_stock_id, _ := this.GetInt64("cancel_stock_id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, _ := service.GetCancelStockInfoListById(cancel_stock_id, orgId)
	creater := this.GetAdminUserInfo().AdminUser.Id

	manufacturerlist, _ := service.GetAllManufacturerList(orgId)
	dealerList, _ := service.GetAllDealerList(orgId)
	var manufacturer_id int64
	var cancel_total_count int64
	var out_total_count int64
	var dealer_id int64
	for _, item := range list {

		//查询该药品该批次的出库数量是否满足退库需求
		outList, _ := service.GetWarehouseOutList(item.OrgId, item.GoodId, item.WarehouseInfoId)
		for _, it := range outList {
			out_total_count += it.Count
		}
		warehouseList, _ := service.GetCancelWarehouseList(item.OrgId, item.GoodId, item.WarehouseInfoId)
		for _, it := range warehouseList {
			cancel_total_count += it.Count
		}
		if cancel_total_count > out_total_count {
			goodObj, _ := service.GetGoodInformationByGoodId(item.GoodId)
			this.ServeSuccessJSON(map[string]interface{}{
				"msg":                "2",
				"good_name":          goodObj.GoodName,
				"specification_name": goodObj.SpecificationName,
			})
			return
		}
	}

	cancelStock := models.CancelStock{
		IsCheck: 1,
	}
	service.CheckCancelStock(cancelStock, cancel_stock_id, orgId)

	//回退库存
	cancellist, _ := service.GetCancelStockInfoById(cancel_stock_id, orgId)
	for _, item := range cancellist {
		for _, items := range manufacturerlist {
			if item.Manufacturer == items.ManufacturerName {
				manufacturer_id = items.ID
			}
		}
		for _, it := range dealerList {
			if item.Dealer == it.DealerName {
				dealer_id = it.ID
			}
		}
		//回退库存
		service.UpdateCancelStockNumber(item.Count, item.WarehouseInfoId, orgId)
		//更新基础库库存
		service.UpdateGoodSumCount(item.Count, item.GoodId, orgId)
		goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
		//退库数量增加
		service.UpdateSumAddCancelCount(orgId, item.GoodId, item.StorehouseId, item.Count)
		var flush_count int64
		for _, it := range goodList {
			flush_count += it.StockCount
		}

		stockFlow := models.VmStockFlow{
			ID:                        0,
			WarehousingId:             item.WarehouseInfoId,
			GoodId:                    item.GoodId,
			Number:                    item.Number,
			LicenseNumber:             "",
			Count:                     item.Count,
			UserOrgId:                 item.OrgId,
			PatientId:                 item.PatientId,
			SystemTime:                item.RecordDate,
			ConsumableType:            4,
			IsSys:                     0,
			WarehousingOrder:          "",
			WarehouseOutId:            0,
			WarehouseOutOrderNumber:   "",
			IsEdit:                    0,
			CancelStockId:             cancel_stock_id,
			CancelOrderNumber:         item.OrderNumber,
			Manufacturer:              manufacturer_id,
			Dealer:                    dealer_id,
			Creator:                   creater,
			UpdateCreator:             0,
			Status:                    1,
			Ctime:                     time.Now().Unix(),
			Mtime:                     0,
			Price:                     item.Price,
			WarehousingDetailId:       item.WarehouseInfoId,
			WarehouseOutDetailId:      0,
			CancelOutDetailId:         item.ID,
			ProductDate:               item.ProductDate,
			ExpireDate:                item.ExpiryDate,
			ReturnCount:               0,
			ProjectId:                 0,
			SupplyWarehouseId:         0,
			SupplyCancelOutId:         0,
			SupplyWarehouseDetailInfo: 0,
			StorehouseId:              item.StorehouseId,
			SecondWarehouseInfoId:     0,
			AdminUserId:               0,
			BuyPrice:                  item.Price,
			StockCount:                "",
			OverCount:                 flush_count,
		}
		//创建流水
		service.CreateStockFlowOne(stockFlow)
		//更新剩余库存
		errs := service.UpdateSumGood(orgId, item.StorehouseId, item.GoodId, flush_count)

		//出库数量减少
		service.ModifyAddGoodSumCount(item.StorehouseId, item.Count, orgId, item.GoodId)
		if errs != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      item.OrgId,
				Errcode:        "手动退库更新剩余出库失败",
				GoodId:         item.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creater,
				BatchNumberId:  0,
				WarehouseOutId: 0,
			}
			service.CreateGoodErrcode(goodErrcode)
		}

	}
	this.ServeSuccessJSON(map[string]interface{}{
		"msg":                "1",
		"good_name":          "",
		"specification_name": "",
	})
	return
}

func (this *StockManagerApiController) CheckReturnStockWarehouseInfo() {

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

	orgId := this.GetAdminUserInfo().CurrentOrgId
	cancelStock := models.CancelStock{
		IsCheck: 2,
	}
	list, _ := service.GetCancelStockInfoListById(cancel_stock_id, orgId)
	creater := this.GetAdminUserInfo().AdminUser.Id
	for _, item := range list {
		//回退库存
		service.UpdateStockNumberWarehouseInfo(item.WarehouseInfoId, item.GoodId, item.OrgId, item.Count)

		service.UpdateStockWarehouseInfoStockFlow(item.ID, orgId, item.GoodId)

		//退库数量增加
		service.UpdateSumReduceCancelCount(orgId, item.GoodId, item.StorehouseId, item.Count)

		goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
		var flush_count int64
		for _, it := range goodList {
			flush_count += it.StockCount
		}
		errs := service.UpdateSumGood(orgId, item.StorehouseId, item.GoodId, flush_count)

		//出库数量增加
		service.UpdateSumAddOutCount(orgId, item.GoodId, item.StorehouseId, item.Count)

		if errs != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      item.OrgId,
				Errcode:        "手动退库反审核更新剩余出库失败",
				GoodId:         item.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creater,
				BatchNumberId:  0,
				WarehouseOutId: 0,
			}
			service.CreateGoodErrcode(goodErrcode)
		}

	}
	err := service.UpdateStockWarehouseInfo(cancel_stock_id, orgId, cancelStock)

	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"msg": "反审核成功!",
		})
		return
	}
}

func (this *StockManagerApiController) GetPrintList() {

	storehouse_id, _ := this.GetInt64("storehouse_id")
	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	good_name := this.GetString("good_name")
	ids := this.GetString("ids")
	idSplit := strings.Split(ids, ",")
	fmt.Println(storehouse_id, good_name)
	orgId := this.GetAdminUserInfo().CurrentOrgId
	houseList, _ := service.GetAllStoreHouseList(orgId)
	list, total, _ := service.GetInventoryDetailPrintMapList(good_name, limit, page, orgId, storehouse_id, idSplit)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":      list,
		"total":     total,
		"houseList": houseList,
	})
}

func (this *StockManagerApiController) GetInvetoryWarehouseInfoList() {

	storehouse_id, _ := this.GetInt64("storehouse_id")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, _ := service.GetInvetoryWarehouseInfoList(orgId, storehouse_id)
	manufacturerList, _ := service.GetAllManufacturerList(orgId)
	dealerList, _ := service.GetAllDealerList(orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":             list,
		"manufacturerList": manufacturerList,
		"dealerList":       dealerList,
	})
}

func (this *StockManagerApiController) GetNewGoodWarehouseInfo() {

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

	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	storehouse_id, _ := this.GetInt64("storehouse_id")

	keywords := this.GetString("keywords")

	orgId := this.GetAdminUserInfo().CurrentOrgId

	var goodids []int64
	//查询商品名称
	if len(keywords) > 0 {
		//查询商品名称
		list, _ := service.GetGoodInforByGoodName(keywords, orgId)
		for _, item := range list {
			goodids = append(goodids, item.ID)
			//入库详情但里面查询
		}
	}

	list, _ := service.GetNewGoodWarehouseInfo(startTime, endTime, orgId, goodids, storehouse_id)
	manufacturerList, _ := service.GetAllManufacturerList(orgId)
	dealerList, _ := service.GetAllDealerList(orgId)
	storeHouseList, _ := service.GetAllStoreHouseList(orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":             list,
		"manufacturerList": manufacturerList,
		"dealerList":       dealerList,
		"storeHouseList":   storeHouseList,
	})
}

func (this *StockManagerApiController) GetNewWarehouseOutInfoList() {

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

	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	storehouse_id, _ := this.GetInt64("storehouse_id")

	keywords := this.GetString("keyword")

	orgId := this.GetAdminUserInfo().CurrentOrgId
	var goodids []int64
	//查询商品名称
	if len(keywords) > 0 {
		//查询商品名称
		list, _ := service.GetGoodInforByGoodName(keywords, orgId)
		for _, item := range list {
			goodids = append(goodids, item.ID)
			//入库详情但里面查询
		}
	}

	list, _ := service.GetNewWarehouseOutInfoList(startTime, endTime, orgId, goodids, storehouse_id)

	manufacturerList, _ := service.GetAllManufacturerList(orgId)
	dealerList, _ := service.GetAllDealerList(orgId)
	storeHouseList, _ := service.GetAllStoreHouseList(orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":             list,
		"manufacturerList": manufacturerList,
		"dealerList":       dealerList,
		"storeHouseList":   storeHouseList,
	})
}