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

controllers/his_api_controller.go

@@ -9,7 +9,6 @@ import (
 	"github.com/astaxie/beego"
 	"reflect"
 	"strconv"
-	"strings"
 	"time"
 )
 
@@ -24,10 +23,6 @@ func HisManagerApiRegistRouters() {
 	beego.Router("/api/hisprescription/config", &HisApiController{}, "get:GetHisPrescriptionConfig")
 
 	beego.Router("/api/hisprescription/create", &HisApiController{}, "post:CreateHisPrescription")
-	beego.Router("/api/hisdoctoradvice/create", &HisApiController{}, "post:CreateHisDoctorAdvice")
-	//beego.Router("/api/hisproject/create", &HisApiController{}, "post:CreateHisProject")
-	//beego.Router("/api/hisorder/create", &HisApiController{}, "post:CreateHisOrder")
-	//beego.Router("/api/hisadditional/create", &HisApiController{}, "post:CreateHisAdditionalCharge")
 
 	beego.Router("/api/doctorworkstation/casehistory/list", &HisApiController{}, "get:GetHisPatientCaseHistoryList")
 	beego.Router("/api/doctorworkstation/casehistory/get", &HisApiController{}, "get:GetHisPatientCaseHistory")
@@ -116,81 +111,29 @@ func (c *HisApiController) GetHisPrescriptionConfig() {
 	advices, _ := service.FindAllHisAdviceTemplate(adminInfo.CurrentOrgId)
 	//获取所有基础药
 	drugs, _ := service.GetAllDrugLibList(adminInfo.CurrentOrgId)
-	//获取所有项目
-	projects, _ := service.GetAllProjectList(adminInfo.CurrentOrgId)
-	//获取所有项目组套
+
+	//drugs, _ := service.GetAllDrugLibList(adminInfo.CurrentOrgId)
+	//drugs, _ := service.GetAllDrugLibList(adminInfo.CurrentOrgId)
+	drugways, _, _ := service.GetDrugWayDics(adminInfo.CurrentOrgId)
+	efs, _, _ := service.GetExecutionFrequencyDics(adminInfo.CurrentOrgId)
+
+	doctors, _ := service.GetHisAdminUserDoctors(adminInfo.CurrentOrgId)
 
 	c.ServeSuccessJSON(map[string]interface{}{
 		"drugs":            drugs,
 		"advices_template": advices,
-		"projects":         projects,
+		"drugways":         drugways,
+		"efs":              efs,
+		"doctors":          doctors,
 	})
 }
 func (c *HisApiController) CreateHisPrescription() {
 	record_date := c.GetString("record_date")
 	patient_id, _ := c.GetInt64("patient_id")
-	his_patient_id, _ := c.GetInt64("his_patient_id")
-	types, _ := c.GetInt64("type")
-	doctor := c.GetAdminUserInfo().AdminUser.Id
-
-	timeLayout := "2006-01-02"
-	loc, _ := time.LoadLocation("Local")
-
-	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
-	if err != nil {
-		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-		return
-	}
-	recordDateTime := theTime.Unix()
-
-	prescription := &models.HisPrescription{
-		UserOrgId:    c.GetAdminUserInfo().CurrentOrgId,
-		RecordDate:   recordDateTime,
-		PatientId:    patient_id,
-		HisPatientId: his_patient_id,
-		Status:       1,
-		Ctime:        time.Now().Unix(),
-		Mtime:        time.Now().Unix(),
-		Type:         types,
-		Doctor:       doctor,
-		Creator:      doctor,
-		Modifier:     doctor,
-	}
-
-	err = service.SaveHisPrescription(prescription)
-	if err == nil {
-		c.ServeSuccessJSON(map[string]interface{}{
-			"msg": "保存成功",
-		})
-		return
-
-	} else {
-		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
-		return
-	}
-}
-func (c *HisApiController) CreateHisDoctorAdvice() {
-	patient_id, _ := c.GetInt64("patient_id")
-	his_patient_id, _ := c.GetInt64("his_patient_id")
-	prescription_id, _ := c.GetInt64("prescription_id")
-
-	//patient, _ := c.GetInt64("id", 0)
-	//if patient <= 0 {
-	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-	//	return
-	//}
-	adminUserInfo := c.GetAdminUserInfo()
-
-	//patientInfo, _ := service.FindPatientById(adminUserInfo.CurrentOrgId, patient)
-	//if patientInfo.ID == 0 {
-	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
-	//	return
-	//}
-
-	group_no, _ := c.GetInt64("group_no")
-	if group_no <= 0 {
-		group_no = 0
-	}
+	//diagnose := c.GetString("diagnose")
+	//sick_history := c.GetString("sick_history")
+	doctor, _ := c.GetInt64("doctor")
+	//departm/**/ent, _ := c.GetInt64("department")
 
 	dataBody := make(map[string]interface{}, 0)
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
@@ -202,155 +145,91 @@ func (c *HisApiController) CreateHisDoctorAdvice() {
 
 	timeLayout := "2006-01-02"
 	loc, _ := time.LoadLocation("Local")
-
-	if dataBody["advice_type"] == nil || reflect.TypeOf(dataBody["advice_type"]).String() != "float64" {
-		utils.ErrorLog("advice_type")
-		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-		return
-	}
-	adviceType := int64(dataBody["advice_type"].(float64))
-	if adviceType != 1 && adviceType != 2 {
-		utils.ErrorLog("advice_type != 1&&2")
-		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
-	}
-	adviceDate := startTime2
-	if len(adviceDate) == 0 {
-		utils.ErrorLog("len(adviceDate) == 0")
-		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-		return
-	}
-	theTime, err := time.ParseInLocation(timeLayout, adviceDate, loc)
+	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
 	if err != nil {
-		utils.ErrorLog(err.Error())
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		return
 	}
-	AdviceDate := theTime.Unix()
-	RecordDate := theTime.Unix()
+	adminInfo := c.GetAdminUserInfo()
+	recordDateTime := theTime.Unix()
 
-	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()
+	if dataBody["prescriptions"] != nil && reflect.TypeOf(dataBody["prescriptions"]).String() == "[]interface {}" {
+		prescriptions, _ := dataBody["prescriptions"].([]interface{})
 
-	Remark := ""
-	if dataBody["remark"] != nil && reflect.TypeOf(dataBody["remark"]).String() == "string" {
-		remark, _ := dataBody["remark"].(string)
-		Remark = remark
-	}
+		if len(prescriptions) > 0 {
+			for _, item := range prescriptions {
+				items := item.(map[string]interface{})
 
-	var advices []*models.HisGroupAdvice
-	// utils.TraceLog("%+v", dataBody["adviceNames"])
-	if dataBody["adviceNames"] == nil || reflect.TypeOf(dataBody["adviceNames"]).String() != "[]interface {}" {
-		utils.ErrorLog("adviceNames")
-		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-		return
-	}
-	adviceNames := dataBody["adviceNames"].([]interface{})
-	for _, adviceNameMap := range adviceNames {
-		adviceNameM := adviceNameMap.(map[string]interface{})
-		var advice models.HisGroupAdvice
-		advice.Remark = Remark
-		advice.AdviceType = adviceType
-		advice.StartTime = StartTime
-		advice.AdviceDate = AdviceDate
-		advice.RecordDate = RecordDate
-		advice.Status = 1
-		advice.CreatedTime = time.Now().Unix()
-		advice.UpdatedTime = time.Now().Unix()
-		advice.StopState = 2
-		advice.ExecutionState = 2
-		advice.UserOrgId = adminUserInfo.CurrentOrgId
-		advice.PatientId = patient_id
-		advice.HisPatientId = his_patient_id
-		advice.AdviceDoctor = adminUserInfo.AdminUser.Id
-		advice.PrescriptionId = prescription_id
-
-		//入口
-		errcode := c.setAdviceWithJSON(&advice, adviceNameM)
-		if errcode > 0 {
-			c.ServeFailJSONWithSGJErrorCode(errcode)
-			return
-		}
+				if items["type"] == nil || reflect.TypeOf(items["type"]).String() != "float64" {
+					utils.ErrorLog("type")
+					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+					return
+				}
+				types := int64(items["type"].(float64))
 
-		if adviceNameM["subdrugs"] != nil && reflect.TypeOf(adviceNameM["subdrugs"]).String() == "[]interface {}" {
-			subdrugs := adviceNameM["subdrugs"].([]interface{})
-			if len(subdrugs) > 0 {
-				for _, subdrug := range subdrugs {
-					var s models.HisGroupAdvice
-					s.Remark = Remark
-					s.AdviceType = adviceType
-					s.StartTime = StartTime
-					s.AdviceDate = AdviceDate
-					s.RecordDate = RecordDate
-					s.Status = 1
-					s.CreatedTime = time.Now().Unix()
-					s.UpdatedTime = time.Now().Unix()
-					s.StopState = 2
-					s.ExecutionState = 2
-					s.HisPatientId = his_patient_id
-					s.UserOrgId = adminUserInfo.CurrentOrgId
-					s.PatientId = patient_id
-					s.AdviceDoctor = adminUserInfo.AdminUser.Id
-
-					errcode := c.setAdviceWithJSON(&s, subdrug.(map[string]interface{}))
-					if errcode > 0 {
-						c.ServeFailJSONWithSGJErrorCode(errcode)
-						return
+				ctime := time.Now().Unix()
+				prescription := &models.HisPrescription{
+					PatientId:  patient_id,
+					UserOrgId:  adminInfo.CurrentOrgId,
+					RecordDate: recordDateTime,
+					Ctime:      ctime,
+					Mtime:      ctime,
+					Type:       types,
+					Modifier:   adminInfo.AdminUser.Id,
+					Creator:    adminInfo.AdminUser.Id,
+					Status:     1,
+					Doctor:     doctor,
+				}
+				service.SaveHisPrescription(prescription)
+
+				if items["advices"] != nil && reflect.TypeOf(items["advices"]).String() == "[]interface {}" {
+					advices := items["advices"].([]interface{})
+					group := service.GetMaxAdviceGroupID(adminInfo.CurrentOrgId)
+					groupNo := group + 1
+					ctime := time.Now().Unix()
+					mtime := ctime
+					if len(advices) > 0 {
+						for _, advice := range advices {
+							var s models.HisDoctorAdviceInfo
+							s.PrescriptionId = prescription.ID
+							s.AdviceType = 2
+							s.AdviceDoctor = adminInfo.AdminUser.Id
+							s.StopState = 2
+							s.ExecutionState = 2
+							s.AdviceDate = recordDateTime
+							s.Status = 1
+							s.UserOrgId = adminInfo.CurrentOrgId
+							s.RecordDate = recordDateTime
+							s.StartTime = recordDateTime
+							s.Groupno = groupNo
+							s.CreatedTime = ctime
+							s.UpdatedTime = mtime
+							s.PatientId = patient_id
+
+							errcode := c.setAdviceWithJSON(&s, advice.(map[string]interface{}))
+							if errcode > 0 {
+								c.ServeFailJSONWithSGJErrorCode(errcode)
+								return
+							}
+							service.CreateHisDoctorAdvice(&s)
+						}
 					}
-
-					advice.Children = append(advice.Children, &s)
 				}
+
 			}
 		}
-
-		advices = append(advices, &advice)
 	}
 
-	newAdvices, createErr := service.CreateHisGroupAdvice(adminUserInfo.CurrentOrgId, advices, group_no)
-	if createErr != nil {
-		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateDoctorAdviceFail)
+	if err == nil {
+		c.ServeSuccessJSON(map[string]interface{}{
+			"msg": "保存成功",
+		})
 		return
-	}
-
-	c.ServeSuccessJSON(map[string]interface{}{
-		"msg":     "ok",
-		"advices": newAdvices,
-	})
-	return
 
+	} else {
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
 }
 
 func (c *HisApiController) CreateHisAdditionalCharge() {
@@ -584,97 +463,76 @@ func (c *HisApiController) GetCaseHistoryTemplate() {
 func (c *HisApiController) GetPrintHisPatientCaseHistory() {
 
 }
-func (c *HisApiController) setAdviceWithJSON(advice *models.HisGroupAdvice, json map[string]interface{}) int {
+func (c *HisApiController) setAdviceWithJSON(advice *models.HisDoctorAdviceInfo, json map[string]interface{}) int {
 
-	if json["advice_name"] == nil || reflect.TypeOf(json["advice_name"]).String() != "string" {
-		utils.ErrorLog("advice_name")
+	if json["drug_name"] == nil || reflect.TypeOf(json["drug_name"]).String() != "string" {
+		utils.ErrorLog("drug_name")
 		return enums.ErrorCodeParamWrong
 	}
-	adviceName, _ := json["advice_name"].(string)
+	adviceName, _ := json["drug_name"].(string)
 	if len(adviceName) == 0 {
 		utils.ErrorLog("len(advice_name) == 0")
 		return enums.ErrorCodeParamWrong
 	}
 	advice.AdviceName = adviceName
-
 	adviceDesc, _ := json["advice_desc"].(string)
 	advice.AdviceDesc = adviceDesc
-
 	if json["drug_spec"] != nil && reflect.TypeOf(json["drug_spec"]).String() == "string" {
 		drugSpec, _ := strconv.ParseFloat(json["drug_spec"].(string), 64)
 		advice.DrugSpec = drugSpec
 	}
-
 	if json["remark"] != nil && reflect.TypeOf(json["remark"]).String() == "string" {
 		remark, _ := json["remark"].(string)
 		advice.Remark = remark
 	}
-
-	//if json["src_type"] != nil || reflect.TypeOf(json["src_type"]).String() == "float64" {
-	//	src_type, _ := strconv.ParseInt(json["src_type"].(string),10)
-	//	advice.Way = src_type
-	//}
-	if json["way"] == nil {
-		advice.Way = 0
-
-	} else {
-		if json["way"] != nil || reflect.TypeOf(json["way"]).String() == "float64" {
-			way := int64(json["way"].(float64))
-			advice.Way = way
-		}
-
-	}
-
-	if json["drug_id"] == nil {
+	if json["id"] == nil {
 		advice.DrugId = 0
 	} else {
-		if json["drug_id"] != nil || reflect.TypeOf(json["drug_id"]).String() == "float64" {
-			drug_id := int64(json["drug_id"].(float64))
+		if json["id"] != nil || reflect.TypeOf(json["id"]).String() == "float64" {
+			drug_id := int64(json["id"].(float64))
 			advice.DrugId = drug_id
 		}
 	}
 
-	if json["drug_name_id"] == nil {
-		advice.DrugNameId = 0
-	} else {
-		if json["drug_name_id"] != nil || reflect.TypeOf(json["drug_name_id"]).String() == "float64" {
-			drug_name_id := int64(json["drug_name_id"].(float64))
-			advice.DrugNameId = drug_name_id
-		}
-	}
-
-	if json["drug_spec_unit"] != nil && reflect.TypeOf(json["drug_spec_unit"]).String() == "string" {
-		drugSpecUnit, _ := json["drug_spec_unit"].(string)
+	if json["min_unit"] != nil && reflect.TypeOf(json["min_unit"]).String() == "string" {
+		drugSpecUnit, _ := json["min_unit"].(string)
 		advice.DrugSpecUnit = drugSpecUnit
 	}
-
 	if json["single_dose"] != nil && reflect.TypeOf(json["single_dose"]).String() == "string" {
 		singleDose, _ := strconv.ParseFloat(json["single_dose"].(string), 64)
 		advice.SingleDose = singleDose
 	}
-
-	if json["single_dose_unit"] != nil && reflect.TypeOf(json["single_dose_unit"]).String() == "string" {
-		singleDoseUnit, _ := json["single_dose_unit"].(string)
+	if json["min_unit"] != nil && reflect.TypeOf(json["min_unit"]).String() == "string" {
+		singleDoseUnit, _ := json["min_unit"].(string)
 		advice.SingleDoseUnit = singleDoseUnit
 	}
-
 	if json["prescribing_number"] != nil && reflect.TypeOf(json["prescribing_number"]).String() == "string" {
 		prescribingNumber, _ := strconv.ParseFloat(json["prescribing_number"].(string), 64)
 		advice.PrescribingNumber = prescribingNumber
 	}
-
-	if json["prescribing_number_unit"] != nil && reflect.TypeOf(json["prescribing_number_unit"]).String() == "string" {
-		prescribingNumberUnit, _ := json["prescribing_number_unit"].(string)
+	if json["min_unit"] != nil && reflect.TypeOf(json["min_unit"]).String() == "string" {
+		prescribingNumberUnit, _ := json["min_unit"].(string)
 		advice.PrescribingNumberUnit = prescribingNumberUnit
 	}
 	if json["delivery_way"] != nil && reflect.TypeOf(json["delivery_way"]).String() == "string" {
 		deliveryWay, _ := json["delivery_way"].(string)
 		advice.DeliveryWay = deliveryWay
 	}
-
 	if json["execution_frequency"] != nil && reflect.TypeOf(json["execution_frequency"]).String() == "string" {
 		executionFrequency, _ := json["execution_frequency"].(string)
 		advice.ExecutionFrequency = executionFrequency
 	}
+	if json["remark"] != nil && reflect.TypeOf(json["remark"]).String() == "string" {
+		remark, _ := json["remark"].(string)
+		advice.Remark = remark
+	}
+	//if json["retail_price"] != nil || reflect.TypeOf(json["retail_price"]).String() == "string" {
+	//	advice.Price = json["retail_price"].(float64)
+	//}
+
+	if json["retail_price"] != nil || reflect.TypeOf(json["retail_price"]).String() == "string" {
+		price, _ := strconv.ParseFloat(json["retail_price"].(string), 64)
+		advice.Price = price
+	}
 	return 0
 }

models/his_models.go

@@ -192,8 +192,6 @@ type HisDoctorAdviceInfo struct {
 	DrugId                int64   `gorm:"column:drug_id" json:"drug_id" form:"drug_id"`
 	Price                 float64 `gorm:"column:price" json:"price" form:"price"`
 	PrescriptionId        int64   `gorm:"column:prescription_id" json:"prescription_id" form:"prescription_id"`
-	Way                   int64   `gorm:"column:way" json:"way" form:"way"`
-	DrugNameId            int64   `gorm:"column:drug_name_id" json:"drug_name_id" form:"drug_name_id"`
 }
 
 func (HisDoctorAdviceInfo) TableName() string {

service/his_service.go

@@ -146,3 +146,13 @@ func FindAllHisAdviceTemplate(org_id int64) (temps []*models.HisDoctorAdvicePare
 	}).Where("org_id = ? AND status=1 ", org_id).Find(&temps).Error
 	return
 }
+
+func GetHisAdminUserDoctors(org_id int64) (doctors []*models.UserAdminRole, err error) {
+	err = readUserDb.Model(&models.UserAdminRole{}).Where("org_id = ? AND status = 1 AND (user_type = 1 OR user_type = 2)", org_id).Find(&doctors).Error
+	return
+}
+
+func CreateHisDoctorAdvice(s *models.HisDoctorAdviceInfo) (err error) {
+	err = writeDb.Create(s).Error
+	return
+}

service/patient_service.go

@@ -547,7 +547,7 @@ func CreateDoctorAdvice(m *models.DoctorAdvice) (err error) {
 }
 func GetMaxAdviceGroupID(orgId int64) (group int64) {
 	var advice models.DoctorAdvice
-	err := readDb.Table("xt_doctor_advice").Where("user_org_id=?", orgId).Select("max(groupno) as groupno").First(&advice).Error
+	err := readDb.Table("his_doctor_advice_info").Where("user_org_id=?", orgId).Select("max(groupno) as groupno").First(&advice).Error
 	if err != nil {
 		fmt.Println(err)
 		group = 0