Merge branch '20211122' of http://git.shengws.com/csx/XT_New into 20211122

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/getallsupply", &SupplyOrderApiController{}, "get:GetAllSupply")
 	beego.Router("/api/supply/getallpurchaseorderlist", &SupplyOrderApiController{}, "get:GetAllPurchaseOrderList")
 	beego.Router("/api/supply/updatepurchaseorder", &SupplyOrderApiController{}, "Post:UpdatePurchaseOrder")
+	beego.Router("/api/supply/checkpurchaseorder", &SupplyOrderApiController{}, "get:UpdateSupplyWaresing")
+	beego.Router("/api/supply/getpurchaseorderdetail", &SupplyOrderApiController{}, "get:GetPurchaseOrderDetail")
+	beego.Router("/api/supply/addgoodorder", &SupplyOrderApiController{}, "post:AddGoodOrder")
 }
 
 func (this *SupplyOrderApiController) GetInitOrder() {
 			for _, item := range thisStockIn {
 				items := item.(map[string]interface{})
 
-				if items["id"] == nil || reflect.TypeOf(items["id"]).String() != "float64" {
-					utils.ErrorLog("id")
+				if items["project_id"] == nil || reflect.TypeOf(items["project_id"]).String() != "float64" {
+					utils.ErrorLog("project_id")
 					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 					return
 				}
-				id := int64(items["id"].(float64))
+				project_id := int64(items["project_id"].(float64))
 
 				if items["supply_count"] == nil || reflect.TypeOf(items["supply_count"]).String() != "float64" {
 					utils.ErrorLog("supply_count")
 
 				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,
 					Status:                  1,
 					Mtime:                   0,
 					WarehousingId:           warehouseInfo.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)
 	discount_amount_float, _ := strconv.ParseFloat(discount_amount, 64)
 	warehousing_id, _ := this.GetInt64("id")
 	number := this.GetString("number")
-	fmt.Println("supplier_id23323232323232", supplier_id, startTime, endTime, rate_of_concession, rate_of_concession_float, discount_amount, discount_amount_float)
+	//fmt.Println("supplier_id23323232323232", supplier_id, startTime, endTime, rate_of_concession, rate_of_concession_float, discount_amount, discount_amount_float)
 	orgId := this.GetAdminUserInfo().CurrentOrgId
 	info := models.SupplierWarehouseInfo{
 		RateOfConcession: rate_of_concession_float,
 				supply_total_price := items["supply_total_price"].(string)
 
 				supply_total_price_float, _ := strconv.ParseFloat(supply_total_price, 64)
-				if items["is_source"] == nil || reflect.TypeOf(items["is_source"]).String() != "float64" {
-					utils.ErrorLog("is_source")
+				if items["type"] == nil || reflect.TypeOf(items["type"]).String() != "float64" {
+					utils.ErrorLog("type")
 					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 					return
 				}
-				is_source := int64(items["is_source"].(float64))
+				is_source := int64(items["type"].(float64))
 
 				if items["supply_type"] == nil || reflect.TypeOf(items["supply_type"]).String() != "string" {
 					utils.ErrorLog("supply_type")
 
 				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)
 				}
 
 	}
 }
+
+func (this *SupplyOrderApiController) UpdateSupplyWaresing() {
+
+	id, _ := this.GetInt64("id")
+	recordDateStr := time.Now().Format("2006-01-02")
+	recordDate, _ := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
+
+	record_date := recordDate.Unix()
+	checker := this.GetAdminUserInfo().AdminUser.Id
+	info := models.SupplierWarehouseInfo{
+		Mtime:     time.Now().Unix(),
+		Status:    1,
+		IsCheck:   1,
+		Checker:   checker,
+		CheckTime: record_date,
+	}
+	parseDateErr := service.UpdateSupplyWaresing(id, info)
+	if parseDateErr == nil {
+		this.ServeSuccessJSON(map[string]interface{}{
+			"info": info,
+		})
+	} else {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+	}
+}
+
+func (this *SupplyOrderApiController) GetPurchaseOrderDetail() {
+
+	id, _ := this.GetInt64("id")
+	info, _ := service.GetPurchaseOrderDetail(id)
+	//查询
+	orderInfo, err := service.GetSupplyWarehousingOrderInfo(id)
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+	supplyList, _ := service.GetSupplierList(orgId)
+	//获取药品库数据
+	baseList, _ := service.GetSupplyDrugList(orgId)
+
+	goodList, _ := service.GetSupplyGoodList(orgId)
+	if err == nil {
+		this.ServeSuccessJSON(map[string]interface{}{
+			"info":       info,
+			"orderInfo":  orderInfo,
+			"supplyList": supplyList,
+			"baseList":   baseList,
+			"goodList":   goodList,
+		})
+	} else {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+	}
+}
+
+func (this *SupplyOrderApiController) AddGoodOrder() {
+
+	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/gobal_config_service.go

 		db = db.Where("x.warehouse_out_id = ?", id)
 	}
 
-	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,sum(x.count) as count,x.count_unit,x.price,x.total_price,x.product_date,x.expiry_date,x.remark,x.is_cancel,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,x.is_sys,x.sys_record_time,x.retail_price,x.retail_total_price,t.drug_name,t.drug_type,t.max_unit,t.min_unit,t.min_number,x.number,x.batch_number,t.dose,t.dose_unit,t.last_price,t.min_price,t.medical_insurance_number,x.warehouse_info_id").Joins("left join xt_base_drug as t on t.id = x.drug_id").Group("x.drug_id").Scan(&info).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,sum(x.count) as count,x.count_unit,x.price,x.product_date,x.expiry_date,x.remark,x.is_cancel,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,x.is_sys,x.sys_record_time,x.retail_price as total_price,x.retail_total_price,t.drug_name,t.drug_type,t.max_unit,t.min_unit,t.min_number,x.number,x.batch_number,t.dose,t.dose_unit,t.last_price,t.min_price,t.medical_insurance_number,t.retail_price ,x.warehouse_info_id").Joins("left join xt_base_drug as t on t.id = x.drug_id").Group("x.drug_id").Scan(&info).Error
 	return info, err
 }
 

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

 package service
 
-import "XT_New/models"
+import (
+	"XT_New/models"
+	"time"
+)
 
 func GetSupplyDrugList(orgid int64) (drug []*models.SpBaseDrug, err error) {
 
 
 func ModefySupplyWarehouseInfo(id int64, info models.SupplierWarehouseInfo) error {
 
-	err := XTWriteDB().Where("id = ? and status = 1", id).Updates(map[string]interface{}{"rate_of_concession": info.RateOfConcession, "discount_amount": info.DiscountAmount, "document_date": info.DocumentDate, "delivery_date": info.DeliveryDate, "supplier_id": info.SupplierId}).Error
+	err := XTWriteDB().Model(&models.SupplierWarehouseInfo{}).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"rate_of_concession": info.RateOfConcession, "discount_amount": info.DiscountAmount, "document_date": info.DocumentDate, "delivery_date": info.DeliveryDate, "supplier_id": info.SupplierId}).Error
 	return err
 }
 
 func ModifySupplyWarehouseOrder(order *models.SupplierWarehousingInfoOrder) error {
 
-	err := XTWriteDB().Model(&order).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
 }
+
+func UpdateSupplyWaresing(id int64, info models.SupplierWarehouseInfo) error {
+
+	err := XTWriteDB().Model(&models.SupplierWarehouseInfo{}).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"is_check": info.IsCheck, "checker": info.Checker, "check_time": info.CheckTime, "mtime": time.Now().Unix()}).Error
+	return err
+}
+
+func GetPurchaseOrderDetail(id int64) (models.SupplierWarehouseInfo, error) {
+
+	info := models.SupplierWarehouseInfo{}
+	err := XTReadDB().Model(&info).Where("id =? and status =1", id).Find(&info).Error
+	return info, err
+}