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

 	"XT_New/service"
 	"XT_New/utils"
 	"encoding/json"
+	"fmt"
 	"github.com/astaxie/beego"
 	"reflect"
 	"strconv"
 	efs, _, _ := service.GetExecutionFrequencyDics(adminInfo.CurrentOrgId)
 
 	doctors, _ := service.GetHisAdminUserDoctors(adminInfo.CurrentOrgId)
-
+	//获取所有科室信息
+	department, _ := service.GetAllDepartMent(adminInfo.CurrentOrgId)
 	c.ServeSuccessJSON(map[string]interface{}{
 		"drugs":            drugs,
 		"advices_template": advices,
 		"drugways":         drugways,
 		"efs":              efs,
 		"doctors":          doctors,
+		"department":       department,
 	})
 }
 func (c *HisApiController) CreateHisPrescription() {
 	record_date := c.GetString("record_date")
+	fmt.Println("record_date", record_date)
 	patient_id, _ := c.GetInt64("patient_id")
 	//diagnose := c.GetString("diagnose")
 	//sick_history := c.GetString("sick_history")
 	doctor, _ := c.GetInt64("doctor")
 	//departm/**/ent, _ := c.GetInt64("department")
-
+	his_patient_id, _ := c.GetInt64("his_patient_id")
 	dataBody := make(map[string]interface{}, 0)
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
 	if err != nil {
 
 				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,
+					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,
+					HisPatientId: his_patient_id,
 				}
 				service.SaveHisPrescription(prescription)
 
 							s.CreatedTime = ctime
 							s.UpdatedTime = mtime
 							s.PatientId = patient_id
-
+							s.HisPatientId = his_patient_id
 							errcode := c.setAdviceWithJSON(&s, advice.(map[string]interface{}))
 							if errcode > 0 {
 								c.ServeFailJSONWithSGJErrorCode(errcode)
 						}
 					}
 				}
-
+				if items["project"] != nil && reflect.TypeOf(items["project"]).String() == "[]interface {}" {
+					projects := items["project"].([]interface{})
+					if len(projects) > 0 {
+						for _, project := range projects {
+							var p models.HisPrescriptionProject
+							p.PrescriptionId = prescription.ID
+							p.Ctime = time.Now().Unix()
+							p.Mtime = time.Now().Unix()
+							p.PatientId = patient_id
+							p.RecordDate = recordDateTime
+							p.UserOrgId = adminInfo.CurrentOrgId
+							p.HisPatientId = his_patient_id
+							errcode := c.setProjectWithJSON(&p, project.(map[string]interface{}))
+							if errcode > 0 {
+								c.ServeFailJSONWithSGJErrorCode(errcode)
+								return
+							}
+							service.CreateHisProjectTwo(&p)
+						}
+					}
+				}
 			}
 		}
+
+		//查询患者今日处方信息
+		//_, errcode := service.GetHisPrescriptionTwo(his_patient_id, adminInfo.CurrentOrgId, recordDateTime)
+		//if errcode == nil{
+		//    //改变患者信息状态
+		//   service.UpdatedHisPatient(his_patient_id, adminInfo.CurrentOrgId, recordDateTime)
+		//
+		//}
 	}
 
 	if err == nil {
 	}
 	return 0
 }
+
+func (c *HisApiController) setProjectWithJSON(project *models.HisPrescriptionProject, json map[string]interface{}) int {
+
+	if json["id"] != nil || reflect.TypeOf(json["id"]).String() == "float64" {
+		project_id := int64(json["id"].(float64))
+		project.ProjectId = project_id
+	}
+
+	if json["price"] != nil || reflect.TypeOf(json["price"]).String() == "float64" {
+		price := int64(json["price"].(float64))
+		formatInt_price := strconv.FormatInt(price, 10)
+		float_price, _ := strconv.ParseFloat(formatInt_price, 64)
+		project.Price = float_price
+	}
+
+	return 0
+
+}

controllers/his_project_api_controller.go

 	beego.Router("/api/hist/getallprojecteam", &HisProjectApiController{}, "Get:GetAllProjectTeam")
 	beego.Router("/api/his/getprojectlistbyid", &HisProjectApiController{}, "Get:GetProjectListById")
 	beego.Router("/api/his/gethispatienthistory", &HisProjectApiController{}, "Get:GetHisPatientHistory")
+	beego.Router("/api/patient/changepatient", &HisProjectApiController{}, "Get:ChangePatient")
 }
 
 func (this *HisProjectApiController) SaveProject() {
 	timeLayout := "2006-01-02"
 	loc, _ := time.LoadLocation("Local")
 	age, _ := this.GetInt64("age")
-
 	birthday := this.GetString("birthDay")
 	birthdays, _ := time.ParseInLocation(timeLayout+" 15:04:05", birthday+" 00:00:00", loc)
 	birthUnix := birthdays.Unix()
 	totals_float, _ := strconv.ParseFloat(totals, 64)
 	adminUserInfo := this.GetAdminUserInfo()
 	orgId := adminUserInfo.CurrentOrgId
-	timeStr := time.Now().Format("2006-01-02")
-	fmt.Println("timeStr:", timeStr)
-	timeStringToTime, _ := utils.ParseTimeStringToTime(timeLayout, timeStr+" 00:00:00")
+	recordDateStr := time.Now().Format("2006-01-02")
+	recordDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
+	fmt.Println("parseDateErr", parseDateErr)
+	nowtime := recordDate.Unix()
 
 	bloodPatient, errcode := service.GetBloodPatientByIdCard(idcard, orgId)
 	if errcode == gorm.ErrRecordNotFound {
 			IdType:                 certificates,
 			CostOfProduction:       cost_float,
 			Departments:            department,
-			AdminUserId:            doctor,
+			Doctor:                 doctor,
+			AdminUserId:            adminUserInfo.AdminUser.Id,
 			MedicalTreatmentType:   medicalcare,
 			IdCardNo:               idcard,
 			IsNeedCostOfProduction: cost_checked,
 			Total:                  totals_float,
 			UserOrgId:              orgId,
 			Status:                 1,
-			RecordDate:             timeStringToTime.Unix(),
+			RecordDate:             nowtime,
+			IsReturn:               1,
 		}
 		err := service.CreateHisPatient(&patient)
 		if err != nil {
 	adminUserInfo := this.GetAdminUserInfo()
 	orgId := adminUserInfo.CurrentOrgId
 	history, total, err := service.GetHisPatientHistory(keyword, startTime.Unix(), endTime.Unix(), register_type, limit, page, orgId)
+
 	department, err := service.GetAllDepartMent(orgId)
+	appId := adminUserInfo.CurrentAppId
+	doctor, err := service.GetAllDoctor(orgId, appId)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateConfig)
 		return
 		"history":    history,
 		"total":      total,
 		"department": department,
+		"doctor":     doctor,
 	})
 }
+
+func (this *HisProjectApiController) ChangePatient() {
+
+	id, _ := this.GetInt64("id")
+	//查询该患者今日是否已经就诊
+	recordDateStr := time.Now().Format("2006-01-02")
+	recordDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
+	fmt.Println("parseDateErr", parseDateErr)
+	nowtime := recordDate.Unix()
+	adminUserInfo := this.GetAdminUserInfo()
+	orgId := adminUserInfo.CurrentOrgId
+	_, errcode := service.GetHisPrescriptionTwo(id, orgId, nowtime)
+	if errcode == gorm.ErrRecordNotFound {
+		err := service.ChangePatient(id)
+		if err != nil {
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateConfig)
+			return
+		}
+		returnData := make(map[string]interface{}, 0)
+		returnData["msg"] = "ok"
+		this.ServeSuccessJSON(returnData)
+		return
+	} else if errcode == nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateConfig)
+		return
+	}
+
+}

controllers/mobile_api_controllers/check_weight_api_controller.go

 		var system_dialysisPrescribe *models.SystemPrescription
 
 		var mode_id int64
-		weightfirst, err := service.FindLastDryWeightAdjust(adminUserInfo.Org.Id, id)
+		weightfirst, _ := service.FindLastDryWeightAdjust(adminUserInfo.Org.Id, id)
 		if weightfirst.DryWeight > weighing_before {
 			return
 		}

controllers/mobile_api_controllers/dialysis_api_controller.go

 		UpdatedTime:           time.Now().Unix(),
 	}
 
+	//只针对广慈医院
+	if template.TemplateId == 26 || template.TemplateId == 25 {
+		// 查询病人是否有透前评估数据
+		befor, errcode := service.GetAssessmentBefor(adminUserInfo.Org.Id, patientID, recordDate.Unix())
+		//如果有数据就插入
+		if errcode == nil {
+			record.SystolicBloodPressure = befor.SystolicBloodPressure
+			record.DiastolicBloodPressure = befor.DiastolicBloodPressure
+			record.BreathingRate = befor.BreathingRate
+			record.PulseFrequency = befor.PulseFrequency
+			record.Temperature = befor.Temperature
+		}
+	}
+
 	// 如果当天有插入数据，则不再往透析纪录里插入数据
 	if newdialysisRecord.ID > 0 {
 		err := service.CreateMonitor(&record)

controllers/mobile_api_controllers/patient_api_controller.go

 						MedicId:        item.DrugId,
 						StockOutNumber: warehousing_out_order,
 					}
-					service.CreateOutStock(&outStock)
+					//查询 该患者是否已出库
+					out, errcode := service.GetSelfOutStock(adminUserInfo.Org.Id, item.AdviceDate, item.PatientId, item.AdviceName, item.AdviceDesc)
+					fmt.Println("errcode ------------------22222", errcode)
+					if errcode == gorm.ErrRecordNotFound {
+						service.CreateOutStock(&outStock)
+					} else if errcode == nil {
+						err := service.UpdatedSelfOutSatock(out.ID, &outStock)
+						fmt.Println("err", err)
+					}
 				}
 			}
 		} else {
 					number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
 					number = number + total
 					warehousing_out_order = "CKD" + strconv.FormatInt(number, 10)
+
 					//插入自备药出库单
 					outStock := models.XtSelfOutStock{
 						DrugName:       item.AdviceName,
 						MedicId:        item.DrugId,
 						StockOutNumber: warehousing_out_order,
 					}
-					service.CreateOutStock(&outStock)
+
+					//查询 该患者是否已出库
+					out, errcode := service.GetSelfOutStock(adminUserInfo.Org.Id, item.AdviceDate, item.PatientId, item.AdviceName, item.AdviceDesc)
+					fmt.Println("errcode ------------------", errcode)
+					if errcode == gorm.ErrRecordNotFound {
+						service.CreateOutStock(&outStock)
+					} else if errcode == nil {
+						err := service.UpdatedSelfOutSatock(out.ID, &outStock)
+						fmt.Println("err", err)
+					}
 
 				}
 			}

models/his_models.go

 	Mtime                  int64   `gorm:"column:mtime" json:"mtime" form:"mtime"`
 	PatientId              int64   `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
 	Number                 string  `gorm:"column:number" json:"number" form:"number"`
+	Doctor                 int64   `gorm:"column:doctor" json:"doctor" form:"doctor"`
+	IsReturn               int64   `gorm:"column:is_return" json:"is_return" form:"is_return"`
 }
 
 func (XtHisPatient) TableName() string {

service/his_project_service.go

 	if orgid > 0 {
 		db = db.Where("x.user_org_id = ?", orgid)
 	}
-	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
+	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,x.doctor,x.is_return").Count(&total).Offset(offset).Limit(limit).Find(&hisPatient).Error
 	return hisPatient, total, err
 }
+
+func ChangePatient(id int64) error {
+	patient := models.XtHisPatient{}
+
+	err := XTWriteDB().Model(&patient).Where("id = ?", id).Updates(map[string]interface{}{"is_return": 2}).Error
+	return err
+}
+
+func GetHisPrescriptionTwo(patientid int64, orgid int64, recorddate int64) (*models.HisPrescription, error) {
+	prescription := models.HisPrescription{}
+	err := XTReadDB().Model(&prescription).Where("his_patient_id = ? and user_org_id = ? and record_date = ? and status = 1", patientid, orgid, recorddate).Find(&prescription).Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, err
+		} else {
+			return nil, err
+		}
+	}
+	return &prescription, nil
+}
+
+func UpdatedHisPatient(hispatientid int64, orgid int64, recorddate int64) error {
+	hisPatient := models.HisPatient{}
+	err := XTWriteDB().Model(&hisPatient).Where("id = ? and user_org_id = ? and record_date = ?", hispatientid, orgid, recorddate).Updates(map[string]interface{}{"is_return": 3}).Error
+	return err
+}

service/his_service.go

 	err = writeDb.Create(s).Error
 	return
 }
+
+func CreateHisProjectTwo(project *models.HisPrescriptionProject) (err error) {
+	err = writeDb.Create(project).Error
+	return
+}

service/manage_service.go

 
 func UpdatePlanInfo(id int64, orgid int64, plan models.DevicePlan) error {
 
-	err := writeUserDb.Model(&plan).Where("id = ? AND user_org_id = ?", id, orgid).Updates(map[string]interface{}{"device_type": plan.DeviceType, "disinfec_time": plan.DisinfecTime, "time": plan.Time, "classtime": plan.Classtime, "way": plan.Way, "machine_disinfectant": plan.MachineDisinfectant, "disinfectan_way": plan.MachineDisinfectant, "disinfectant": plan.Disinfectant, "mtime": time.Now().Unix()}).Error
+	err := writeUserDb.Model(&plan).Where("id = ? AND user_org_id = ?", id, orgid).Updates(map[string]interface{}{"device_type": plan.DeviceType, "disinfec_time": plan.DisinfecTime, "time": plan.Time, "classtime": plan.Classtime, "way": plan.Way, "machine_disinfectant": plan.MachineDisinfectant, "disinfectan_way": plan.DisinfectanWay, "disinfectant": plan.Disinfectant, "mtime": time.Now().Unix()}).Error
 	return err
 }
 

service/mobile_dialysis_service.go

 	}
 	return
 }
+
+func GetAssessmentBefor(orgid int64, patientid int64, recorddate int64) (*models.PredialysisEvaluation, error) {
+
+	evaluation := models.PredialysisEvaluation{}
+
+	err := XTReadDB().Model(&evaluation).Where("user_org_id = ? and patient_id = ? and assessment_date = ? and status = 1", orgid, patientid, recorddate).Find(&evaluation).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &evaluation, nil
+}

service/self_drug_service.go

 	"XT_New/models"
 	"fmt"
 	"github.com/jinzhu/gorm"
+	"time"
 )
 
 func GetCurrentPatient(orgid int64) (patients []*models.DrugPatients, err error) {
 	return drugName, err
 
 }
+
+func GetSelfOutStock(orgid int64, advicedate int64, patientid int64, adivicename string, advicedesc string) (*models.XtSelfOutStock, error) {
+	stock := models.XtSelfOutStock{}
+	err = XTReadDB().Model(&stock).Where("user_org_id = ? and storck_time = ? and patient_id = ? and drug_name = ? and drug_spec = ? and status = 1", orgid, advicedate, patientid, adivicename, advicedesc).Find(&stock).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &stock, err
+}
+
+func UpdatedSelfOutSatock(id int64, stock *models.XtSelfOutStock) error {
+
+	err := XTWriteDB().Model(&stock).Where("id = ?", id).Updates(map[string]interface{}{"drug_name": stock.DrugName, "drug_name_id": stock.DrugNameId, "drug_spec": stock.DrugSpec, "outstore_number": stock.OutstoreNumber, "admin_user_id": stock.AdminUserId, "storck_time": stock.StorckTime, "patient_id": stock.PatientId, "stock_out_number": stock.StockOutNumber, "exit_mode": stock.ExitMode, "medic_id": stock.MedicId, "updated_time": time.Now().Unix()}).Error
+	return err
+}