11月8日库存管理

controllers/dialysis_api_controller.go

 	assessment.Consciousness = data.Consciousness
 	assessment.Fallrisk = data.Fallrisk
 	assessment.MachineRun = data.MachineRun
+	assessment.AfterUrea = data.AfterUrea
 	appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.CurrentOrgId, adminUserInfo.AdminUser.Id, adminUserInfo.CurrentAppId)
 
 	if assessment.ID > 0 {
 	period, _ := c.GetInt64("period")
 	estimated_food_intake := c.GetString("estimated_food_intake")
 	blood_pressure_during_dialysis := c.GetString("blood_pressure_during_dialysis")
+	urea_befor := c.GetString("urea_befor")
 	assessmentBeforeDislysis := models.PredialysisEvaluation{
 		DialysisCount:                  dialysis_count,
 		EmergencyTreatment:             emergency_treatment,
 		Period:                         period,
 		EstimatedFoodIntake:            estimated_food_intake,
 		BloodPressureDuringDialysis:    blood_pressure_during_dialysis,
+		UreaBefor:                      urea_befor,
 	}
 
 	appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.CurrentOrgId, adminUserInfo.AdminUser.Id, adminUserInfo.CurrentAppId)

controllers/mobile_api_controllers/dialysis_api_controller.go

 	consciousness, _ := c.GetInt64("consciousness")
 	fallrisk, _ := c.GetInt64("fallrisk")
 	machine_run := c.GetString("machine_run")
+	after_urea := c.GetString("after_urea")
 	if id <= 0 {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		return
 		Consciousness:                consciousness,
 		Fallrisk:                     fallrisk,
 		MachineRun:                   machine_run,
+		AfterUrea:                    after_urea,
 	}
 
 	appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)

controllers/mobile_api_controllers/patient_api_controller.go

 		pre_dialysis_drugs := dataBody["pre_dialysis_drugs"].(string)
 		evaluation.PreDialysisDrugs = pre_dialysis_drugs
 	}
+
+	if dataBody["urea_befor"] != nil && reflect.TypeOf(dataBody["urea_befor"]).String() == "string" {
+		urea_befor := dataBody["urea_befor"].(string)
+		evaluation.UreaBefor = urea_befor
+	}
 	return
 }
 

controllers/stock_in_api_controller.go

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

controllers/supply_order_api_contorller.go

 	beego.Router("/api/supply/updatepurchaseorder", &SupplyOrderApiController{}, "Post:UpdatePurchaseOrder")
 	beego.Router("/api/supply/checkpurchaseorder", &SupplyOrderApiController{}, "get:UpdateSupplyWaresing")
 	beego.Router("/api/supply/getpurchaseorderdetail", &SupplyOrderApiController{}, "get:GetPurchaseOrderDetail")
+	beego.Router("/api/supply/addgoodorder", &SupplyOrderApiController{}, "post:AddGoodOrder")
 }
 
 func (this *SupplyOrderApiController) GetInitOrder() {
 
 				name := items["name"].(string)
 
+				if items["supply_unit"] == nil || reflect.TypeOf(items["supply_unit"]).String() != "string" {
+					utils.ErrorLog("supply_unit")
+					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+					return
+				}
+
+				supply_unit := items["supply_unit"].(string)
+
 				order := models.SupplierWarehousingInfoOrder{
 					OrderNumber:             warehousing_order,
 					IsSource:                is_source,
 					SupplyTotal:             supply_total,
 					SupplyManufacturer:      supply_manufacturer,
 					Name:                    name,
+					SupplyUnit:              supply_unit,
 				}
 
 				warehousingInfo = append(warehousingInfo, &order)
 
 				name := items["name"].(string)
 
+				if items["supply_unit"] == nil || reflect.TypeOf(items["supply_unit"]).String() != "string" {
+					utils.ErrorLog("supply_unit")
+					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+					return
+				}
+
+				supply_unit := items["supply_unit"].(string)
 				if id > 0 {
 					order := models.SupplierWarehousingInfoOrder{
 						ID:                      id,
 						SupplyTotal:             supply_total,
 						SupplyManufacturer:      supply_manufacturer,
 						Name:                    name,
+						SupplyUnit:              supply_unit,
 					}
 
 					updateWarehousingInfo = append(updateWarehousingInfo, &order)
 						Status:                  1,
 						Mtime:                   0,
 						WarehousingId:           warehousing_id,
-						ProjectId:               id,
+						ProjectId:               project_id,
 						SupplyLicenseNumber:     supply_license_number,
 						SupplyType:              supply_type,
 						SupplySpecificationName: supply_specification_name,
 						SupplyTotal:             supply_total,
 						SupplyManufacturer:      supply_manufacturer,
 						Name:                    name,
+						SupplyUnit:              supply_unit,
 					}
 					warehousingInfo = append(warehousingInfo, &order)
 				}
 	orderInfo, err := service.GetSupplyWarehousingOrderInfo(id)
 	orgId := this.GetAdminUserInfo().CurrentOrgId
 	supplyList, _ := service.GetSupplierList(orgId)
+	//获取药品库数据
+	baseList, _ := service.GetSupplyDrugList(orgId)
+
+	goodList, _ := service.GetSupplyGoodList(orgId)
 	if err == nil {
 		this.ServeSuccessJSON(map[string]interface{}{
 			"info":       info,
 			"orderInfo":  orderInfo,
 			"supplyList": supplyList,
+			"baseList":   baseList,
+			"goodList":   goodList,
 		})
 	} else {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 	}
 }
+
+func (this *SupplyOrderApiController) AddGoodOrder() {
+
+	supplier_id, _ := this.GetInt64("supplier_id")
+	start_time := this.GetString("start")
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+	var startTime int64
+	if len(start_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
+		if err != nil {
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		startTime = theTime.Unix()
+	}
+	good_number := this.GetString("good_number")
+	arrerage, _ := this.GetInt64("arrerage")
+	payment, _ := this.GetInt64("payment")
+	warehousing_id, _ := this.GetInt64("warehousing_id")
+	number := this.GetString("number")
+	rate_of_concession, _ := this.GetInt64("rate_of_concession")
+	discount_amount, _ := this.GetInt64("discount_amount")
+	fmt.Println(supplier_id, startTime, good_number, arrerage, payment, warehousing_id, number, rate_of_concession, discount_amount)
+}

models/dialysis.go

 	Period                         int64   `gorm:"column:period" json:"period" form:"period"`
 	EstimatedFoodIntake            string  `gorm:"column:estimated_food_intake" json:"estimated_food_intake" form:"estimated_food_intake"`
 	BloodPressureDuringDialysis    string  `gorm:"column:blood_pressure_during_dialysis" json:"blood_pressure_during_dialysis" form:"blood_pressure_during_dialysis"`
+	UreaBefor                      string  `gorm:"column:urea_befor" json:"urea_befor" form:"urea_befor"`
 }
 
 func (PredialysisEvaluation) TableName() string {
 	Consciousness                   int64   `gorm:"column:consciousness" json:"consciousness" form:"consciousness"`
 	Fallrisk                        int64   `gorm:"column:fallrisk" json:"fallrisk" form:"fallrisk"`
 	MachineRun                      string  `gorm:"column:machine_run" json:"machine_run" form:"machine_run"`
+	AfterUrea                       string  `gorm:"column:after_urea" json:"after_urea" form:"after_urea"`
 }
 
 func (AssessmentAfterDislysis) TableName() string {

models/supply.models.go

 	Manufacturer      int64                  `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
 	OrgId             int64                  `gorm:"column:org_id" json:"org_id" form:"org_id"`
 	Number            string                 `gorm:"column:number" json:"number" form:"number"`
+	LastPrice         float64                `gorm:"column:last_price" json:"last_price" form:"last_price"`
 	DrugWarehouseInfo []*SpDrugWarehouseInfo `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_warehouse_info"`
 }
 
 	Manufacturer      int64              `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
 	OrgId             int64              `gorm:"column:org_id" json:"org_id" form:"org_id"`
 	GoodName          string             `gorm:"column:good_name" json:"good_name" form:"good_name"`
+	PackingUnit       string             `gorm:"column:packing_unit" json:"packing_unit" form:"packing_unit"`
+	BuyPrice          float64            `gorm:"column:buy_price" json:"buy_price" form:"buy_price"`
 	GoodWarehouseInfo []*SpWarehouseInfo `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"good_warehouse_info"`
 }
 
 	SupplyTotal             string  `gorm:"column:supply_total" json:"supply_total" form:"supply_total"`
 	SupplyManufacturer      string  `gorm:"column:supply_manufacturer" json:"supply_manufacturer" form:"supply_manufacturer"`
 	Name                    string  `gorm:"column:name" json:"name" form:"name"`
+	SupplyUnit              string  `gorm:"column:supply_unit" json:"supply_unit" form:"supply_unit"`
 }
 
 func (SupplierWarehousingInfoOrder) TableName() string {

service/stock_service.go

 		db = db.Where("x.org_id = ?", orgid)
 	}
 
-	err = db.Select("x.id,x.warehouse_out_id,x.good_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,t.social_security_directory_code,x.is_sys,x.sys_record_time,x.number,x.remark,x.license_number,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.warehouse_out_id,x.good_id").Order("x.ctime desc").Scan(&out).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.good_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,t.social_security_directory_code,x.is_sys,x.sys_record_time,x.number,x.remark,x.license_number,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit,t.packing_price").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.warehouse_out_id,x.good_id").Order("x.ctime desc").Scan(&out).Error
 	return out, err
 }
 

service/supply_service.go

 
 func ModifySupplyWarehouseOrder(order *models.SupplierWarehousingInfoOrder) error {
 
-	err := XTWriteDB().Model(&models.SupplierWarehousingInfoOrder{}).Where("id = ? and status = 1", order.ID).Updates(map[string]interface{}{}).Updates(map[string]interface{}{"is_source": order.IsSource, "count": order.Count, "price": order.Price, "amount": order.Amount, "remark": order.Remark, "project_id": order.ProjectId, "supply_license_number": order.SupplyLicenseNumber, "supply_type": order.SupplyType, "supply_specification_name": order.SupplySpecificationName, "supply_total": order.SupplyTotal, "supply_manufacturer": order.SupplyManufacturer, "name": order.Name}).Error
+	err := XTWriteDB().Model(&models.SupplierWarehousingInfoOrder{}).Where("id = ? and status = 1", order.ID).Updates(map[string]interface{}{}).Updates(map[string]interface{}{"is_source": order.IsSource, "count": order.Count, "price": order.Price, "amount": order.Amount, "remark": order.Remark, "project_id": order.ProjectId, "supply_license_number": order.SupplyLicenseNumber, "supply_type": order.SupplyType, "supply_specification_name": order.SupplySpecificationName, "supply_total": order.SupplyTotal, "supply_manufacturer": order.SupplyManufacturer, "name": order.Name, "supply_unit": order.SupplyUnit}).Error
 	return err
 }