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

 	"github.com/astaxie/beego"
 	"reflect"
 	"strconv"
-	"strings"
 	"time"
 )
 
 	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")
 	//drugs, _ := service.GetAllDrugLibList(adminInfo.CurrentOrgId)
 	drugways, _, _ := service.GetDrugWayDics(adminInfo.CurrentOrgId)
 	efs, _, _ := service.GetExecutionFrequencyDics(adminInfo.CurrentOrgId)
-	//获取所有项目
-	projects, _ := service.GetAllProjectList(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")
+	//diagnose := c.GetString("diagnose")
+	//sick_history := c.GetString("sick_history")
 	doctor, _ := c.GetInt64("doctor")
-
-	diagnose := c.GetString("diagnose")
-	special_sick_history := c.GetString("special_sick_history")
+	//departm/**/ent, _ := c.GetInt64("department")
 
 	dataBody := make(map[string]interface{}, 0)
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
 	adminInfo := c.GetAdminUserInfo()
 	recordDateTime := theTime.Unix()
 
-	//types, _ := c.GetInt64("type")
-	var prescriptions []*models.HisPrescription
+	if dataBody["prescriptions"] != nil && reflect.TypeOf(dataBody["prescriptions"]).String() == "[]interface {}" {
+		prescriptions, _ := dataBody["prescriptions"].([]interface{})
 
-	if dataBody["prescription"] != nil && reflect.TypeOf(dataBody["prescription"]).String() == "[]interface {}" {
-		prescriptions, _ := dataBody["prescription"].([]interface{})
 		if len(prescriptions) > 0 {
 			for _, item := range prescriptions {
 				items := item.(map[string]interface{})
 					Status:     1,
 					Doctor:     doctor,
 				}
-				//prescriptions = append(prescriptions, prescription)
 				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
 							}
-							advice.Children = append(advice.Children, &s)
+							service.CreateHisDoctorAdvice(&s)
 						}
 					}
 				}
 }
 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["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
 }

controllers/his_project_api_controller.go

 	"XT_New/models"
 	"XT_New/service"
 	"XT_New/utils"
-	//"encoding/json"
 	"fmt"
 	"github.com/astaxie/beego"
 	"github.com/jinzhu/gorm"
 	beego.Router("/api/his/gettreatlist", &HisProjectApiController{}, "Get:GetTreatmentList")
 	beego.Router("/api/his/getpatientinformation", &HisProjectApiController{}, "Get:GetPatientInformation")
 	beego.Router("/api/hist/getallprojecteam", &HisProjectApiController{}, "Get:GetAllProjectTeam")
+	beego.Router("/api/his/getprojectlistbyid", &HisProjectApiController{}, "Get:GetProjectListById")
+	beego.Router("/api/his/gethispatienthistory", &HisProjectApiController{}, "Get:GetHisPatientHistory")
 }
 
 func (this *HisProjectApiController) SaveProject() {
 
 	adminUserInfo := this.GetAdminUserInfo()
 	orgId := adminUserInfo.CurrentOrgId
+	fmt.Println("aaa")
 	team, err := service.GetAllProjectTeam(orgId)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateConfig)
 		"team": team,
 	})
 }
+
+func (this *HisProjectApiController) GetProjectListById() {
+
+	adminUserInfo := this.GetAdminUserInfo()
+	orgId := adminUserInfo.CurrentOrgId
+	project_id := this.GetString("project_id")
+	idStrs := strings.Split(project_id, ",")
+	project, err := service.GetProjectListById(orgId, idStrs)
+	if err != nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateConfig)
+		return
+	}
+	this.ServeSuccessJSON(map[string]interface{}{
+		"project": project,
+	})
+}
+
+func (this *HisProjectApiController) GetHisPatientHistory() {
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+	keyword := this.GetString("keyword")
+	start_time := this.GetString("start_time")
+	end_time := this.GetString("end_time")
+	register_type, _ := this.GetInt64("register_type")
+	limit, _ := this.GetInt64("limit")
+	page, _ := this.GetInt64("page")
+	fmt.Println(keyword, start_time, end_time, register_type, limit, page)
+	startTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
+	endTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
+	history, total, err := service.GetHisPatientHistory(keyword, startTime.Unix(), endTime.Unix(), register_type, limit, page)
+	if err != nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateConfig)
+		return
+	}
+	this.ServeSuccessJSON(map[string]interface{}{
+		"history": history,
+		"total":   total,
+	})
+}

models/his_models.go

 	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_project_service.go

 	err = XTReadDB().Model(&project).Where("user_org_id = ? and status = 1", orgid).Find(&project).Error
 	return project, err
 }
+
+func GetProjectListById(orgid int64, ids []string) (project []*models.XtHisProject, err error) {
+	err = XTReadDB().Model(&project).Where("user_org_id = ? and id in (?)", orgid, ids).Find(&project).Error
+	return project, err
+}
+
+func GetHisPatientHistory(keyword string, startime int64, endtime int64, registtype int64, limit int64, page int64) (hisPatient []*models.XtHisPatient, total int64, err error) {
+	offset := (page - 1) * limit
+	likeKey := "%" + keyword + "%"
+	db := XTReadDB().Table("his_patient as x").Where("x.status = 1")
+	if len(keyword) > 0 {
+		db = db.Where("x.name like ?", likeKey)
+	}
+	if startime > 0 {
+		db = db.Where("x.record_date >= ?", startime)
+	}
+	if endtime > 0 {
+		db = db.Where("x.record_date<=?", endtime)
+	}
+	if registtype > 0 {
+		db = db.Where("x.register_type = ?", registtype)
+	}
+	err = db.Select("x.id,x.balance_accounts_type,x.medical_insurance_number,x.name,x.gender,x.id_type,x.medical_treatment_type,x.birthday,x.record_date,x.age,x.phone_number,x.id_card_no,x.register_type,x.admin_user_id,x.departments,x.is_need_cost_of_production,x.register_cost,x.treatment_cost,x.cost_of_production,x.total,x.user_org_id,x.patient_id,x.number").Count(&total).Offset(offset).Limit(limit).Find(&hisPatient).Error
+	return hisPatient, total, err
+}

service/his_service.go

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

 }
 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