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

func (c *StockManagerApiController) CreateWarehouse() {

	warehousing_time := c.GetString("warehousing_time")
	dealer_id, _ := c.GetInt64("dealer_id", 0)
	manufacturer_id, _ := c.GetInt64("manufacturer_id", 0)

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

	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(),
		Dealer:           dealer_id,
		Manufacturer:     manufacturer_id,
		Type:             types,
	}
	service.AddSigleWarehouse(&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

	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

				var productDates int64
				var expiryDates int64

				fmt.Println()

				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)

				warehouseInfo := &models.WarehousingInfo{
					WarehousingOrder: warehousing.WarehousingOrder,
					WarehousingId:    warehousing.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_id,
					Dealer:           dealer_id,
					StockCount:       warehousing_count,
				}
				warehousingInfo = append(warehousingInfo, warehouseInfo)

			}
		}
	}
	errs := service.CreateWarehousingInfo(warehousingInfo)
	info, _ := service.FindLastWarehousingInfo(warehousing.WarehousingOrder)

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

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

	//else {
	//	warehouse, err1 := service.FindWareHouseByOrderNumber(warehousing_order)
	//	if (err1 != nil) {
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
	//		return
	//	}
	//
	//	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["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.ServeFailJSONWithSGJErrorCod  Fe(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["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "string" {
	//					utils.ErrorLog("expiry_date")
	//					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
	//					return
	//				}
	//
	//				expiryDate, _ := items["expiry_date"].(string)
	//				if len(expiryDate) == 0 {
	//					utils.ErrorLog("len(expiry_date) == 0")
	//					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
	//
	//					return
	//				}
	//
	//				expiry_date, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", expiryDate)
	//				if parseDateErr != nil {
	//					c.ErrorLog("日期(%v)解析错误：%v", expiry_date, parseDateErr)
	//				}
	//
	//				var productDates int64
	//
	//				if items["product_date"] == nil || reflect.TypeOf(items["product_date"]).String() != "string" {
	//					productDates = 0;
	//				} else {
	//					productDate, _ := items["product_date"].(string)
	//					product_date, _ := utils.ParseTimeStringToTime("2006-01-02", productDate)
	//					productDates = product_date.Unix()
	//
	//				}
	//
	//				if items["number"] == nil || reflect.TypeOf(items["number"]).String() != "string" {
	//					utils.ErrorLog("number")
	//					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
	//					return
	//				}
	//				number, _ := items["number"].(string)
	//
	//				var remark string
	//				if items["number"] == nil || reflect.TypeOf(items["number"]).String() != "string" {
	//					remark = ""
	//				} else {
	//					remark = items["remark"].(string)
	//				}
	//
	//				warehouseInfo := &models.WarehousingInfo{
	//					WarehousingOrder: warehousing_order,
	//					WarehousingId:    warehouse.ID,
	//					GoodId:           good_id,
	//					Number:           number,
	//					GoodTypeId:       good_type_id,
	//					ProductDate:      productDates,
	//					ExpiryDate:       expiry_date.Unix(),
	//					WarehousingCount: warehousing_count,
	//					Price:            price,
	//					TotalPrice:       total,
	//					Status:           1,
	//					Ctime:            ctime,
	//					Remark:           remark,
	//					OrgId:            adminUserInfo.CurrentOrgId,
	//				}
	//				warehousingInfo = append(warehousingInfo, warehouseInfo)
	//
	//			}
	//		}
	//	}
	//	errs := service.CreateWarehousingInfo(warehousingInfo)
	//	info, _ := service.FindLastWarehousingInfo(warehousing_order)
	//
	//	if (errs != nil) {
	//		utils.ErrorLog(errs.Error())
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
	//		return
	//	}
	//
	//	c.ServeSuccessJSON(map[string]interface{}{
	//		"msg":  "入库成功",
	//		"info": info,
	//	})
	//
	//}

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

	fmt.Println(start_time)
	fmt.Println(end_time)

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

	adminUserInfo := c.GetAdminUserInfo()
	warehouseList, total, err := service.FindAllWarehousingList(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"list":  warehouseList,
			"total": total,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}
func (c *StockManagerApiController) GetWarehouseInfoList() {
	id, _ := c.GetInt64("id", 0)

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

	warehousing, err := service.FindWarehousingById(id)

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

	if warehousing.ID <= 0 {
		return
	}

	warehousingInfo, err := service.FindWarehousingInfoById(id)
	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)
	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()

	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,
		Dealer:           dealer_id,
		Manufacturer:     manufacturer_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

	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

				var productDates int64
				var expiryDates int64

				fmt.Println()

				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)

				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_id,
						Dealer:           dealer_id,
					}
					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_id,
						Dealer:           dealer_id,
					}
					upDateWarehousingInfo = append(upDateWarehousingInfo, warehouseInfo)
				}
			}
		}
	}
	var errs error
	if len(warehousingInfo) > 0 {
		errs = service.CreateWarehousingInfo(warehousingInfo)
	}

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

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

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

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

	err := service.UpDateWarehouseStatus(id)
	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() {
	dealer_id, _ := c.GetInt64("dealer_id", 0)
	manufacturer_id, _ := c.GetInt64("manufacturer_id", 0)
	types, _ := c.GetInt64("type", 0)

	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(),
		Dealer:                  dealer_id,
		Manufacturer:            manufacturer_id,
		Type:                    types,
	}
	service.AddSigleWarehouseOut(&warehouseOut)
	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 beforePrepares []*models.DialysisBeforePrepareGoods
	var newBeforePrepares []*models.NewDialysisBeforePrepareGoods
	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["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)

				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:                   ctime,
					Remark:                  remark,
					OrgId:                   adminUserInfo.CurrentOrgId,
					Type:                    types,
					Manufacturer:            manufacturer_id,
					Dealer:                  dealer_id,
				}
				warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)

				prepareGoods := &models.DialysisBeforePrepareGoods{
					GoodTypeId: good_type_id,
					GoodId:     good_id,
					Count:      count,
				}

				beforePrepares = append(beforePrepares, prepareGoods)

				newPrepareGoods := &models.NewDialysisBeforePrepareGoods{
					GoodTypeId: good_type_id,
					GoodId:     good_id,
					Count:      count,
				}
				newBeforePrepares = append(newBeforePrepares, newPrepareGoods)
			}
		}
	}

	//查询库存
	for _, item := range warehousingOutInfo {
		parseDateErr := service.ConsumablesDeliveryOne(adminUserInfo.CurrentOrgId, warehousingOutDate.Unix(), item, &warehouseOut, item.Count)
		fmt.Println(parseDateErr)
	}

	//errs := service.CreateWarehousingOutInfo(warehousingOutInfo)
	//info, _ := service.FindLastWarehousingOutInfo(warehouseOut.WarehouseOutOrderNumber)
	//if errs != nil {
	//	utils.ErrorLog(errs.Error())
	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
	//	return
	//}

	c.ServeSuccessJSON(map[string]interface{}{
		"msg":                   "出库成功",
		"warehousing_out_order": warehousing_out_order,
	})

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

	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()
	warehouseOutList, total, err := service.FindAllWarehouseOutList(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords)
	fmt.Println(err)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"list":  warehouseOutList,
			"total": total,
		})
	} 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)
	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)
	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)
	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()

	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(),
		Manufacturer:     manufacturer_id,
		Dealer:           dealer_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))

				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:                   ctime,
						Remark:                  remark,
						OrgId:                   adminUserInfo.CurrentOrgId,
						Type:                    types,
						Manufacturer:            manufacturer_id,
						Dealer:                  dealer_id,
						IsSys:                   0,
						SysRecordTime:           0,
					}
					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:                   ctime,
						Remark:                  remark,
						OrgId:                   adminUserInfo.CurrentOrgId,
						Mtime:                   time.Now().Unix(),
						Type:                    types,
						Manufacturer:            manufacturer_id,
						Dealer:                  dealer_id,
						IsSys:                   is_sys,
						SysRecordTime:           sys_record_time,
					}
					upDateWarehouseOutInfos = append(upDateWarehouseOutInfos, warehouseOutInfo)
				}
			}
		}
	}
	var errs error
	if len(warehousingOutInfo) > 0 {
		errs = service.CreateWarehousingOutInfo(warehousingOutInfo)
	}

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

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

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

}

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

	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(),
		Dealer:       dealer_id,
		Manufacturer: manufacturer_id,
		Type:         types,
	}
	service.AddSigleCancelStock(&cancelStock)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	var cancelStockInfos []*models.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["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)

				cancelStockInfo := &models.CancelStockInfo{
					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_id,
					Dealer:        dealer_id,
				}
				cancelStockInfos = append(cancelStockInfos, cancelStockInfo)

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

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

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

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

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

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

	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)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"list":  returnList,
			"total": total,
		})
	} 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, ",")
	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
	}

	err := service.UpDateCancleStockStatus(id)
	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)
	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()

	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(),
		Manufacturer: manufacturer_id,
		Dealer:       dealer_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

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

				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(),
						Type:          types,
						Manufacturer:  manufacturer_id,
						Dealer:        dealer_id,
					}
					cancelStockInfos = append(cancelStockInfos, cancelStockInfo)

				} 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(),
						Type:          types,
						Manufacturer:  manufacturer_id,
						Dealer:        dealer_id,
					}
					upDateCancelStockInfos = append(upDateCancelStockInfos, cancelStockInfo)
				}
			}
		}
	}
	var errs error
	if len(cancelStockInfos) > 0 {
		errs = service.CreateCancelStockInfo(cancelStockInfos)
	}

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

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

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

}
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.FindAllGoodInfo(adminUserInfo.CurrentOrgId)

	c.ServeSuccessJSON(map[string]interface{}{
		"manufacturer": manufacturer,
		"dealer":       dealer,
		"goodType":     goodType,
		"goodInfo":     goodInfo,
	})
}
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)

	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

	if types == 1 {
		list, total, err = service.FindStockInDetailList(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, keywords, manufacturer, order_type, dealer)
		_, total_price = service.GetStockInDetailTotal(adminUserInfo.CurrentOrgId, startTime, endTime, keywords, manufacturer, order_type, dealer)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"list":        list,
				"total":       total,
				"total_price": total_price,
			})
		} 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)
		_, total_price = service.GetStockOutDetailTotal(adminUserInfo.CurrentOrgId, startTime, endTime, keywords, manufacturer, order_type, dealer)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"list":        list1,
				"total":       total,
				"total_price": total_price,
			})
		} 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,
			})
		} 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)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"list":  list3,
				"total": total,
			})
		} 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
		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,
			}

			//查询同种耗材名称同种类型同种规格的耗材是否存在
			_, 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

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

		dose := goodNameM["dose"].(float64)
		if 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

		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

		delivery_way := goodNameM["delivery_way"].(string)
		if len(delivery_way) == 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.DeliveryWay = delivery_way

		execution_frequency := goodNameM["execution_frequency"].(string)
		if len(execution_frequency) == 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.ExecutionFrequency = execution_frequency

		drug_day := goodNameM["drug_day"].(string)
		if len(drug_day) == 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.DrugDay = drug_day

		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

		medical_insurance_level := goodNameM["medical_insurance_level"].(string)
		var medical_insurance_level_id int64
		if len(medical_insurance_level) == 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 medicalInsuranceName = "医保等级"
		medicalInsuranceConfig, _ := service.GetDrugDataConfig(0, medicalInsuranceName)
		if len(medical_insurance_level) != 0 {
			_, errcodemedical := service.IsExistDicConfig(medicalInsuranceConfig.ID, medical_insurance_level, orgId)
			if errcodemedical == gorm.ErrRecordNotFound {
				medConfig, _ := service.GetLastDicConfig(medicalInsuranceConfig.ID, orgId)
				dataconfig := models.DictDataconfig{
					ParentId:       medicalInsuranceConfig.ID,
					Module:         "system",
					OrgId:          orgId,
					Name:           medical_insurance_level,
					FieldName:      "",
					Value:          medConfig.Value + 1,
					CreatedTime:    "",
					UpdatedTime:    "",
					CreateUserId:   adminUser.AdminUser.Id,
					Status:         1,
					Remark:         "",
					DeleteIdSystem: 0,
					Title:          "",
					Content:        "",
					Order:          0,
					Code:           "",
				}
				service.CreatedDicConfig(&dataconfig)
			}
		}

		medicalInsuranceList, _ := service.GetParentDataConfig(medicalInsuranceConfig.ID, orgId)
		for _, it := range medicalInsuranceList {
			if medical_insurance_level == it.Name {
				medical_insurance_level_id = int64(it.Value)
			}
		}
		drug.MedicalInsuranceLevel = medical_insurance_level_id

		unit_matrixing := goodNameM["unit_matrixing"].(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.UnitMatrixing = unit_matrixing
		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

		packing_prices := goodNameM["packing_price"].(string)
		packing_price, _ := strconv.ParseFloat(packing_prices, 64)

		if packing_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_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
		}

		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

		drug.DrugClassify = strconv.FormatInt(drug_classify_id, 10)

		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

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

		drug.LmtUsedFlag = lmt_used_flags

		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

		number := goodNameM["number"].(string)
		drug.Number = number
		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

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

		var drugControl = "开药控制"
		var drug_control_id int64

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

		drugContorlList, _ := service.GetParentDataConfig(drugContorlConfig.ID, orgId)
		for _, it := range drugContorlList {
			if drug_control == it.Name {
				drug_control_id = int64(it.Value)
			}
		}
		drug.DrugControl = drug_control_id

		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 {

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

			//查询同种药品同种规格是否存在
			_, drugerror := service.IsExistDrugByNameOne(item.DrugName, item.Dose, item.MaxUnit, 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
	list, _ := service.GetSearchGoodList(keyword, orgId)
	manufacturerList, _ := service.GetAllManufacturerList(orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"list":             list,
		"manufacturerList": manufacturerList,
	})
}