2024/6/17

conf/app.conf

 appname = 血透
 httpport = 9531
-runmode = dev
+runmode = prod
 #dev/prod
 
 #

controllers/base_api_controller.go

 		userAdmin.ModifyTime = 1530786071
 		var subscibe models.ServeSubscibe
 		subscibe.ID = 11
-		subscibe.OrgId = 9675 //机构id
+		subscibe.OrgId = 10697 //机构id
 		subscibe.PeriodStart = 1547447814
 		subscibe.PeriodEnd = 1550039814
 		subscibe.State = 1
 		subscibes := make(map[int64]*models.ServeSubscibe, 0)
 		subscibes[4] = &subscibe
 		var adminUserInfo service.AdminUserInfo
-		adminUserInfo.CurrentOrgId = 9675  //机构id小英9675或4
-		adminUserInfo.CurrentAppId = 17876 //4
+		adminUserInfo.CurrentOrgId = 10697 //机构id小英9675或4
+		adminUserInfo.CurrentAppId = 18217 //4
 		adminUserInfo.AdminUser = &userAdmin
 		adminUserInfo.Subscibes = subscibes
 		this.SetSession("admin_user_info", &adminUserInfo)
 		userAdmin.ModifyTime = 1530786071
 		var subscibe models.ServeSubscibe
 		subscibe.ID = 11
-		subscibe.OrgId = 9675 //机构id小英9675或4
+		subscibe.OrgId = 10697 //机构id小英9675或4
 		subscibe.PeriodStart = 1538035409
 		subscibe.PeriodEnd = 1569571409
 		subscibe.State = 1
 		subscibes := make(map[int64]*models.ServeSubscibe, 0)
 		subscibes[4] = &subscibe
 		var adminUserInfo service.AdminUserInfo
-		adminUserInfo.CurrentOrgId = 9675  //机构id小英9675或4
-		adminUserInfo.CurrentAppId = 17876 //4
+		adminUserInfo.CurrentOrgId = 10697 //机构id小英9675或4
+		adminUserInfo.CurrentAppId = 18217 //4
 		adminUserInfo.AdminUser = &userAdmin
 		adminUserInfo.Subscibes = subscibes
 		this.SetSession("admin_user_info", &adminUserInfo)

controllers/drug_stock_api_contorller.go

 				}
 				retail_price, _ := strconv.ParseFloat(items["retail_price"].(string), 64)
 
+				drug_code := items["drug_code"].(string)
+
 				warehouseInfo := &models.DrugWarehouseInfo{
 					ID:               id,
 					WarehousingOrder: info.WarehousingOrder,
 					StorehouseId:     storehouse_id,
 					IsCheck:          2,
 					StockMinNumber:   0,
+					DrugCode:         drug_code,
 				}
 				warehousingInfo = append(warehousingInfo, warehouseInfo)
 			}
 
 				dealer := int64(items["dealer"].(float64))
 
+				drug_code, _ := items["drug_code"].(string)
 				medical, _ := service.GetBaseDrugMedical(drug_id)
 				if id == 0 {
 					warehouseInfo := &models.DrugWarehouseInfo{
 						StockMaxNumber:   0,
 						StorehouseId:     storehouse_id,
 						StockMinNumber:   0,
+						DrugCode:         drug_code,
 					}
 
 					warehousingInfo = append(warehousingInfo, warehouseInfo)
 						MinUnit:          min_unit,
 						BatchNumber:      batch_number,
 						StorehouseId:     storehouse_id,
+						DrugCode:         drug_code,
 					}
 					if medical.MaxUnit == medical.MinUnit {
 						warehouseInfo.StockMaxNumber = warehousing_count
 						IsSys:               0,
 						WarehousingDetailId: id,
 						StorehouseId:        storehouse_id,
+						DrugCode:            drug_code,
 					}
 
 					if max_unit == min_unit {
 			StorehouseId:            item.StorehouseId,
 			OverCount:               sum_count,
 			OperateTime:             time.Now().Unix(),
+			DrugCode:                item.DrugCode,
 		}
 		service.CreateDrugFlowTwo(flow)
 		//更新基础库剩余库存

controllers/mobile_api_controllers/dialysis_api_controller.go

 		"advice": advice,
 	})
 }
+
+func (c *DialysisAPIController) SaveLongAdviceTemplate() {
+
+	dataBody := make(map[string]interface{}, 0)
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
+	if err != nil {
+		utils.ErrorLog(err.Error())
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+		return
+	}
+	if dataBody["start_time"] == nil || reflect.TypeOf(dataBody["start_time"]).String() != "string" {
+		utils.ErrorLog("start_time")
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+		return
+	}
+
+	startTime2, _ := dataBody["start_time"].(string)
+	time_arr := strings.Split(startTime2, " ")
+	if len(time_arr) > 0 {
+		startTime2 = time_arr[0]
+	}
+	if dataBody["advice_date"] == nil || reflect.TypeOf(dataBody["advice_date"]).String() != "string" {
+		utils.ErrorLog("advice_date")
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+		return
+	}
+	advice_date, _ := dataBody["advice_date"].(string)
+
+	var advicedateunix int64
+	if len(advice_date) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", advice_date+" 00:00:00", loc)
+		if err != nil {
+			fmt.Println(err)
+			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		advicedateunix = theTime.Unix()
+	}
+
+	adviceDate := startTime2
+	if len(adviceDate) == 0 {
+		utils.ErrorLog("len(adviceDate) == 0")
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+		return
+	}
+	theTime, err := time.ParseInLocation(timeLayout, adviceDate, loc)
+	if err != nil {
+		utils.ErrorLog(err.Error())
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+		return
+	}
+	RecordDate := advicedateunix
+
+	if dataBody["start_time"] == nil || reflect.TypeOf(dataBody["start_time"]).String() != "string" {
+		utils.ErrorLog("start_time")
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+		return
+	}
+	startTime, _ := dataBody["start_time"].(string)
+
+	if len(startTime) == 0 {
+		utils.ErrorLog("len(start_time) == 0")
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+		return
+	}
+	theTime, err = time.ParseInLocation(timeLayout+" 15:04:05", startTime, loc)
+
+	if err != nil {
+		utils.ErrorLog(err.Error())
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+		return
+	}
+	StartTime := theTime.Unix()
+
+	patient_id := int64(dataBody["patient_id"].(float64))
+
+	group_no := int64(dataBody["group_no"].(float64))
+
+	org_id := c.GetMobileAdminUserInfo().Org.Id
+
+	advice_doctor := c.GetMobileAdminUserInfo().AdminUser.Id
+
+	if dataBody["advices"] == nil || reflect.TypeOf(dataBody["advices"]).String() != "[]interface {}" {
+		utils.ErrorLog("advices")
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+		return
+	}
+	adviceNames := dataBody["advices"].([]interface{})
+
+	var advices []*models.GroupAdvice
+	for _, adviceNameMap := range adviceNames {
+		var advice models.GroupAdvice
+		adviceNameM := adviceNameMap.(map[string]interface{})
+		if adviceNameM["advice_name"] == nil || reflect.TypeOf(adviceNameM["advice_name"]).String() != "string" {
+			utils.ErrorLog("advice_name")
+			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		adviceName, _ := adviceNameM["advice_name"].(string)
+
+		if len(adviceName) == 0 {
+			utils.ErrorLog("len(advice_name) == 0")
+			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		advice.AdviceName = adviceName
+
+		if adviceNameM["drug_spec"] != nil && reflect.TypeOf(adviceNameM["drug_spec"]).String() == "string" {
+			drugSpec, _ := strconv.ParseFloat(adviceNameM["drug_spec"].(string), 64)
+			advice.DrugSpec = drugSpec
+		}
+
+		if adviceNameM["advice_desc"] != nil && reflect.TypeOf(adviceNameM["advice_desc"]).String() == "string" {
+			adviceDesc, _ := adviceNameM["advice_desc"].(string)
+			advice.AdviceDesc = adviceDesc
+		}
+
+		if adviceNameM["drug_spec_unit"] != nil && reflect.TypeOf(adviceNameM["drug_spec_unit"]).String() == "string" {
+			drugSpecUnit, _ := adviceNameM["drug_spec_unit"].(string)
+			advice.DrugSpecUnit = drugSpecUnit
+		}
+
+		if adviceNameM["single_dose"] != nil && reflect.TypeOf(adviceNameM["single_dose"]).String() == "string" {
+			singleDose, _ := strconv.ParseFloat(adviceNameM["single_dose"].(string), 64)
+			advice.SingleDose = singleDose
+		}
+		if adviceNameM["single_dose"] != nil && reflect.TypeOf(adviceNameM["single_dose"]).String() == "float64" {
+			singleDose := adviceNameM["single_dose"].(float64)
+			advice.SingleDose = singleDose
+		}
+
+		if adviceNameM["single_dose_unit"] != nil && reflect.TypeOf(adviceNameM["single_dose_unit"]).String() == "string" {
+			singleDoseUnit, _ := adviceNameM["single_dose_unit"].(string)
+			advice.SingleDoseUnit = singleDoseUnit
+		}
+		if adviceNameM["single_dose_unit"] != nil && reflect.TypeOf(adviceNameM["single_dose_unit"]).String() == "float64" {
+			tmp := adviceNameM["single_dose_unit"].(float64)
+			singleDoseUnit := service.TypeConversion(tmp)
+			advice.SingleDoseUnit = singleDoseUnit
+		}
+
+		if adviceNameM["prescribing_number"] != nil && reflect.TypeOf(adviceNameM["prescribing_number"]).String() == "string" {
+			prescribingNumber, _ := strconv.ParseFloat(adviceNameM["prescribing_number"].(string), 64)
+			advice.PrescribingNumber = prescribingNumber
+		}
+		if adviceNameM["prescribing_number"] != nil && reflect.TypeOf(adviceNameM["prescribing_number"]).String() == "float64" {
+			prescribingNumber := adviceNameM["prescribing_number"].(float64)
+			advice.PrescribingNumber = prescribingNumber
+		}
+
+		if adviceNameM["prescribing_number_unit"] != nil && reflect.TypeOf(adviceNameM["prescribing_number_unit"]).String() == "string" {
+			prescribingNumberUnit, _ := adviceNameM["prescribing_number_unit"].(string)
+			advice.PrescribingNumberUnit = prescribingNumberUnit
+		}
+		if adviceNameM["delivery_way"] != nil && reflect.TypeOf(adviceNameM["delivery_way"]).String() == "string" {
+			deliveryWay, _ := adviceNameM["delivery_way"].(string)
+			advice.DeliveryWay = deliveryWay
+		}
+
+		if adviceNameM["execution_frequency"] != nil && reflect.TypeOf(adviceNameM["execution_frequency"]).String() == "string" {
+			executionFrequency, _ := adviceNameM["execution_frequency"].(string)
+			advice.ExecutionFrequency = executionFrequency
+		}
+
+		remark, _ := adviceNameM["remark"].(string)
+
+		advice.Remark = remark
+
+		advice.AdviceType = 1
+
+		advice.StartTime = StartTime
+		advice.RecordDate = RecordDate
+
+		advice.PatientId = patient_id
+
+		advice.UserOrgId = org_id
+
+		advice.AdviceDoctor = advice_doctor
+
+		advices = append(advices, &advice)
+	}
+
+	newAdvices, _ := service.CreateMobileMGroupAdvice(org_id, advices, group_no)
+
+	c.ServeSuccessJSON(map[string]interface{}{
+		"advice": newAdvices,
+	})
+}

controllers/mobile_api_controllers/mobile_api_router_register.go

 	beego.Router("/m/api/updatelongmobileadvice", &DialysisAPIController{}, "Post:UpdateLongMobileAdvice")
 
 	beego.Router("/m/api/updateeditdrugorder", &DialysisAPIController{}, "Post:UpdateEditDrugOrder")
+
+	beego.Router("/m/api/savelongadvicetemplate", &DialysisAPIController{}, "Post:SaveLongAdviceTemplate")
 }

controllers/mobile_api_controllers/patient_api_controller.go

 		Startdate := int64(dataBody["record_date"].(float64))
 
 		var advices []*models.GroupAdvice
-		// utils.TraceLog("%+v", dataBody["adviceNames"])
 		if dataBody["adviceNames"] == nil || reflect.TypeOf(dataBody["adviceNames"]).String() != "[]interface {}" {
 			utils.ErrorLog("adviceNames")
 			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)

controllers/self_drug_api_congtroller.go

 
 	list, total, _ := service.GetAllSelfDrugWarehouse(keyword, startTime, endTime, check_type, orgId, page, limit, patient_id)
 
-	doctorList, _ := service.GetAllDoctorList(orgId, appId)
+	doctorList, _ := service.GetAllDoctorListSix(orgId, appId)
 
 	c.ServeSuccessJSON(map[string]interface{}{
 		"list":       list,
 	}
 
 	list, total, _ := service.GetAllSelfDrugWarehouseOut(startTime, endTime, orgId, page, limit, patient_id, keyword, check_type)
-	doctorList, _ := service.GetAllDoctorList(orgId, appId)
+	doctorList, _ := service.GetAllDoctorListSix(orgId, appId)
 	c.ServeSuccessJSON(map[string]interface{}{
 		"list":       list,
 		"total":      total,

models/drug_stock.go

 	IsCheck                   int64   `gorm:"column:is_check" json:"is_check" form:"is_check"`
 	ManafacturerName          string  `gorm:"column:manafacturer_name" json:"manafacturer_name" form:"manafacturer_name"`
 	DealerName                string  `gorm:"column:dealer_name" json:"dealer_name" form:"dealer_name"`
+	DrugCode                  string  `gorm:"column:drug_code" json:"drug_code" form:"drug_code"`
 }
 
 func (DrugWarehouseInfo) TableName() string {
 	Remark                    string                 `gorm:"column:remark" json:"remark" form:"remark"`
 	OperateTime               int64                  `gorm:"column:operate_time" json:"operate_time" form:"operate_time"`
 	SaleDate                  string                 `gorm:"column:sale_date" json:"sale_date" form:"sale_date"`
+	DrugCode                  string                 `gorm:"column:drug_code" json:"drug_code" form:"drug_code"`
 }
 
 func (DrugFlow) TableName() string {
 	StorehouseId              int64                        `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
 	SecondWarehouseInfoId     int64                        `gorm:"column:second_warehouse_info_id" json:"second_warehouse_info_id" form:"second_warehouse_info_id"`
 	IsCheck                   int64                        `gorm:"column:is_check" json:"is_check" form:"is_check"`
+	DrugCode                  string                       `gorm:"column:drug_code" json:"drug_code" form:"drug_code"`
 	BaseDrugLib               BaseDrugLib                  `gorm:"ForeignKey:ID;AssociationForeignKey:DrugId"json:"drug" `
-	DrugWarehouseOutInfoTenty []*DrugWarehouseOutInfoTenty `gorm:"ForeignKey:WarehouseOutId;AssociationForeignKey:ID"json:"xt_drug_warehouse_out_info" `
+	DrugWarehouseOutInfoTenty []*DrugWarehouseOutInfoTenty `gorm:"ForeignKey:WarehouseOutId;AssociationForeignKey:ID"json:"xt_drug_warehouse_out_info" 
+    `
 }
 
 func (DrugWarehouseInfoTwenty) TableName() string {

models/self_drug_models.go

 	IsCheck                   int64      `gorm:"column:is_check" json:"is_check" form:"is_check"`
 	ManafacturerName          string     `gorm:"column:manafacturer_name" json:"manafacturer_name" form:"manafacturer_name"`
 	DealerName                string     `gorm:"column:dealer_name" json:"dealer_name" form:"dealer_name"`
+	DrugCode                  string     `gorm:"column:drug_code" json:"drug_code" form:"drug_code"`
 }
 
 func (XtDrugWarehouseInfo) TableName() string {

service/dialysis_service.go

 
 func UpdateMobileDoctorAdviceById(id int64, advice models.XtDoctorAdviceOne) error {
 
-	err := XTWriteDB().Where("id = ? and status=1", id).Updates(map[string]interface{}{"advice_name": advice.AdviceName, "advice_date": advice.AdviceDate, "start_time": advice.StartTime, "advice_desc": advice.AdviceDesc, "single_dose": advice.SingleDose, "single_dose_unit": advice.SingleDoseUnit, "prescribing_number": advice.PrescribingNumber, "prescribing_number_unit": advice.PrescribingNumberUnit, "delivery_way": advice.DeliveryWay, "execution_frequency": advice.ExecutionFrequency, "remark": advice.Remark}).Error
+	err := XTWriteDB().Model(&models.XtDoctorAdviceOne{}).Where("id = ? and status=1", id).Updates(map[string]interface{}{"advice_name": advice.AdviceName, "advice_date": advice.AdviceDate, "start_time": advice.StartTime, "advice_desc": advice.AdviceDesc, "single_dose": advice.SingleDose, "single_dose_unit": advice.SingleDoseUnit, "prescribing_number": advice.PrescribingNumber, "prescribing_number_unit": advice.PrescribingNumberUnit, "delivery_way": advice.DeliveryWay, "execution_frequency": advice.ExecutionFrequency, "remark": advice.Remark}).Error
 	return err
 }
 
 func UpdateMobileDoctorAdviceByIdOne(id int64, advice models.XtDoctorAdviceOne) error {
 
-	err := XTWriteDB().Where("id = ? and status=1", id).Updates(map[string]interface{}{"advice_name": advice.AdviceName, "advice_date": advice.AdviceDate, "start_time": advice.StartTime, "advice_desc": advice.AdviceDesc, "single_dose": advice.SingleDose, "single_dose_unit": advice.SingleDoseUnit, "prescribing_number": advice.PrescribingNumber, "prescribing_number_unit": advice.PrescribingNumberUnit, "delivery_way": advice.DeliveryWay, "execution_frequency": advice.ExecutionFrequency, "remark": advice.Remark, "frequency_type": advice.FrequencyType, "week_day": advice.WeekDay, "day_count": advice.DayCount}).Error
+	err := XTWriteDB().Model(&models.XtDoctorAdviceOne{}).Where("id = ? and status=1", id).Updates(map[string]interface{}{"advice_name": advice.AdviceName, "advice_date": advice.AdviceDate, "start_time": advice.StartTime, "advice_desc": advice.AdviceDesc, "single_dose": advice.SingleDose, "single_dose_unit": advice.SingleDoseUnit, "prescribing_number": advice.PrescribingNumber, "prescribing_number_unit": advice.PrescribingNumberUnit, "delivery_way": advice.DeliveryWay, "execution_frequency": advice.ExecutionFrequency, "remark": advice.Remark, "frequency_type": advice.FrequencyType, "week_day": advice.WeekDay, "day_count": advice.DayCount}).Error
 	return err
 }
+
+func CreateMobileMGroupAdvice(orgId int64, advices []*models.GroupAdvice, groupNo int64) (list []*models.GroupAdvice, err error) {
+	if groupNo <= 0 {
+		group := GetMaxAdviceGroupID(orgId)
+		groupNo = group + 1
+	}
+
+	tx := writeDb.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+	for _, advice := range advices {
+		advice.GroupNo = groupNo
+		advice.Status = 1
+		template_id := strconv.FormatInt(groupNo, 10)
+		advice.TemplateId = "M" + template_id
+		if err = tx.Create(advice).Error; err != nil {
+			tx.Rollback()
+			return
+		}
+		list = append(list, advice)
+		if len(advice.Children) > 0 {
+			for _, child := range advice.Children {
+				child.GroupNo = groupNo
+				child.ParentId = advice.ID
+				fmt.Println(child)
+				if err = tx.Create(&child).Error; err != nil {
+					tx.Rollback()
+					return
+				}
+				list = append(list, child)
+			}
+		}
+
+	}
+	tx.Commit()
+	return
+}

service/stock_service.go

 	SupplyWarehouseId         int64   `gorm:"column:supply_warehouse_id" json:"supply_warehouse_id" form:"supply_warehouse_id"`
 	SupplyWarehouseDetailInfo int64   `gorm:"column:supply_warehouse_detail_info" json:"supply_warehouse_detail_info" form:"supply_warehouse_detail_info"`
 	StorehouseId              int64   `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
+	DrugCode                  string  `gorm:"column:drug_code" json:"drug_code" form:"drug_code"`
 }
 
 func (VMDrugWarehouseInfo) TableName() string {
 
 func UpdateDrugWarehouseInfoTwenty(id int64, info *models.DrugWarehouseInfo) error {
 
-	err := XTWriteDB().Model(&models.DrugWarehouseInfo{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"drug_id": info.DrugId, "number": info.Number, "product_date": info.ProductDate, "expiry_date": info.ExpiryDate, "warehousing_count": info.WarehousingCount, "price": info.Price, "total_price": info.TotalPrice, "dealer": info.Dealer, "manufacturer": info.Manufacturer, "remark": info.Remark, "retail_price": info.RetailPrice, "max_unit": info.MaxUnit, "min_unit": info.MinUnit}).Error
+	err := XTWriteDB().Model(&models.DrugWarehouseInfo{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"drug_id": info.DrugId, "number": info.Number, "product_date": info.ProductDate, "expiry_date": info.ExpiryDate, "warehousing_count": info.WarehousingCount, "price": info.Price, "total_price": info.TotalPrice, "dealer": info.Dealer, "manufacturer": info.Manufacturer, "remark": info.Remark, "retail_price": info.RetailPrice, "max_unit": info.MaxUnit, "min_unit": info.MinUnit, "drug_code": info.DrugCode}).Error
 	return err
 }