11月8日库存管理

conf/app.conf

 appname = 血透
-httpport = 9529
+httpport = 9531
 runmode = dev
 
 #

controllers/gobal_config_api_controller.go

 	beego.Router("/api/drug/getcancelstockdetail", &GobalConfigApiController{}, "Get:GetCancelStockDetail")
 
 	beego.Router("/api/changestocksetting/isopen", &GobalConfigApiController{}, "Get:ChangeStockSetting")
+
+	beego.Router("/api/changeadviceconfig", &GobalConfigApiController{}, "Get:ChangeAdviceConfig")
 }
 
 //provinces, _ := service.GetDistrictsByUpid(0)21
 	_, project_config := service.FindXTHisProjectByOrgIdOne(adminUserInfo.CurrentOrgId)
 
 	stockSetting, _ := service.FindStockSettingById(adminUserInfo.CurrentOrgId)
+	adviceSetting, _ := service.FindAdviceSettingById(adminUserInfo.CurrentOrgId)
 	c.ServeSuccessJSON(map[string]interface{}{
 		"is_open_xt_his":         config.IsOpen,
 		"is_open_xt_his_project": project_config.IsOpen,
 		"is_open_stock":          stockSetting.IsType,
+		"is_open_advice":         adviceSetting.IsAdviceOpen,
 	})
 
 }
 		})
 	}
 }
+
+func (c *GobalConfigApiController) ChangeAdviceConfig() {
+
+	is_advice_open, _ := c.GetInt64("is_advice_open")
+	orgId := c.GetAdminUserInfo().CurrentOrgId
+	setting := models.XtAdviceSetting{
+		IsAdviceOpen: is_advice_open,
+		UserOrgId:    orgId,
+		Status:       1,
+		Ctime:        time.Now().Unix(),
+		Mtime:        0,
+	}
+
+	//查询是否存在
+	_, errcode := service.GetAdviceConfig(orgId)
+	if errcode == gorm.ErrRecordNotFound {
+		service.CreateAdviceSetting(setting)
+		c.ServeSuccessJSON(map[string]interface{}{
+			"msg": 1,
+		})
+	} else if errcode == nil {
+		service.UpdateAdviceSetting(orgId, setting)
+		c.ServeSuccessJSON(map[string]interface{}{
+			"msg": 1,
+		})
+	}
+
+}

controllers/his_api_controller.go

 
 	sick, _ := c.GetInt64("sick")
 	diagnose, _ := c.GetInt64("diagnose")
-	id, _ := c.GetInt64("id")
-
+	//id, _ := c.GetInt64("id")
 	timeLayout := "2006-01-02"
 	loc, _ := time.LoadLocation("Local")
 	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
 	}
 	sickTimes := sickTime.Unix()
 	ctime := time.Now().Unix()
+
+	primary_disease := c.GetString("primary_disease")
+	confirm_failure_date := c.GetString("confirm_failure_date")
+	confirm_failure_date_time, _ := time.ParseInLocation(timeLayout+" 15:04:05", confirm_failure_date+" 00:00:00", loc)
+	drug_allergy_history := c.GetString("drug_allergy_history")
+	physical_examination := c.GetString("physical_examination")
+	special_inspection := c.GetString("special_inspection")
+	lab_apparatus := c.GetString("lab_apparatus")
 	caseHistory := models.HisPatientCaseHistory{
 		HisPatientId:            his_patient_id,
 		PatientId:               patient_id,
 		Sick:                    sick,
 		Diagnose:                diagnose,
 		AllergicHistory:         allergic_history,
+		PrimaryDisease:          primary_disease,
+		ConfirmFailureDate:      confirm_failure_date_time.Unix(),
+		DrugAllergyHistory:      drug_allergy_history,
+		PhysicalExamination:     physical_examination,
+		SpecialInspection:       special_inspection,
+		LabApparatus:            lab_apparatus,
 	}
 	//查询该患者是否有病历
-	_, errcodes := service.GetHisPatientCaseHistoryById(id)
+	_, errcodes := service.GetHisPatientCaseHistoryById(patient_id, recordDateTime, c.GetAdminUserInfo().CurrentOrgId)
 	if errcodes == gorm.ErrRecordNotFound {
 		err = service.SaveHisPatientCaseHistory(&caseHistory)
+		historyInfo, _ := service.GetLastHisPatientCaseHistoryById(patient_id)
 		if err != nil {
 			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateConfig)
 			return
 		}
 		c.ServeSuccessJSON(map[string]interface{}{
 			"caseHistory": caseHistory,
+			"historyInfo": historyInfo,
 		})
 		return
 	} else if errcodes == nil {
-		err := service.UpdatePatientCaseHistory(id, &caseHistory)
+		err := service.UpdatePatientCaseHistory(patient_id, recordDateTime, c.GetAdminUserInfo().CurrentOrgId, &caseHistory)
+		historyInfo, _ := service.GetLastHisPatientCaseHistoryById(patient_id)
 		if err != nil {
 			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateConfig)
 			return
 		}
 		c.ServeSuccessJSON(map[string]interface{}{
 			"caseHistory": caseHistory,
+			"historyInfo": historyInfo,
 		})
 	}
 

controllers/mobile_api_controllers/dialysis_api_controller.go

 	schedual, _ := service.MobileGetSchedualDetailOne(adminInfo.Org.Id, patientID, date.Unix())
 	go func() {
 		patient, _ = service.FindPatientByIdWithDiseases(adminInfo.Org.Id, patientID)
+		fmt.Println("patient23333223322323", patient.TrobleShoot)
 		ch <- struct{}{}
 	}()
 

controllers/mobile_api_controllers/mobile_api_base_controller.go

 func (this *MobileBaseAPIAuthController) Prepare() {
 	token := this.Ctx.GetCookie("token_cookie")
 	logout_cookie := this.Ctx.GetCookie("logout_cookie")
-
+	fmt.Println("token232232232323232332232332323322332232323", token)
+	fmt.Println("login232232232323232332232332323322332232323", logout_cookie)
 	//if len(token) == 0{
 	//	this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeNotLogin)
 	//	this.StopRun()

controllers/patient_api_controller.go

 
 	err = service.EditPatientLapseto(&patient, &lapseto)
 
-	if lapseto.LapsetoType == 3 {
+	if lapseto.LapsetoType == 3 || lapseto.LapsetoType == 2 {
 		service.UpdateScheduleByDeathTime(id, lapsetoTimeUnix.Unix())
 		service.UpdateScheduleItemByPatientId(id)
 	}

controllers/schedule_api_controller.go

 			if err == nil {
 				for _, item := range schedules {
 					if item.ScheduleDate > clear_schedule_date {
-						//查询已经存在的所有排班
+						//查询该患者是否转出获取死亡
 
 						//查找当天日期是否存在
 						_, errcode := service.GetTodayScheduleIsExistOne(item.PatientId, item.ScheduleDate, item.UserOrgId)

models/his_models.go

 	UserName                string `gorm:"column:user_name" json:"user_name" form:"user_name"`
 	DoctorAdvice            string `gorm:"column:doctor_advice" json:"doctor_advice" form:"doctor_advice"`
 	Remark                  string `gorm:"column:remark" json:"remark" form:"remark"`
+	Sick                    int64  `gorm:"column:sick" json:"sick" form:"sick"`
+	Diagnose                int64  `gorm:"column:diagnose" json:"diagnose" form:"diagnose"`
+	AllergicHistory         string `gorm:"column:allergic_history" json:"allergic_history" form:"allergic_history"`
+	PrimaryDisease          string `gorm:"column:primary_disease" json:"primary_disease" form:"primary_disease"`
+	ConfirmFailureDate      int64  `gorm:"column:confirm_failure_date" json:"confirm_failure_date" form:"confirm_failure_date"`
+	DrugAllergyHistory      string `gorm:"column:drug_allergy_history" json:"drug_allergy_history" form:"drug_allergy_history"`
+	PhysicalExamination     string `gorm:"column:physical_examination" json:"physical_examination" form:"physical_examination"`
+	SpecialInspection       string `gorm:"column:special_inspection" json:"special_inspection" form:"special_inspection"`
+	LabApparatus            string `gorm:"column:lab_apparatus" json:"lab_apparatus" form:"lab_apparatus"`
 }
 
 func (HisCaseHistoryTemplate) TableName() string {
 	Sick                    int64   `gorm:"column:sick" json:"sick" form:"sick"`
 	Diagnose                int64   `gorm:"column:diagnose" json:"diagnose" form:"diagnose"`
 	AllergicHistory         string  `gorm:"column:allergic_history" json:"allergic_history" form:"allergic_history"`
+	PrimaryDisease          string  `gorm:"column:primary_disease" json:"primary_disease" form:"primary_disease"`
+	ConfirmFailureDate      int64   `gorm:"column:confirm_failure_date" json:"confirm_failure_date" form:"confirm_failure_date"`
+	DrugAllergyHistory      string  `gorm:"column:drug_allergy_history" json:"drug_allergy_history" form:"drug_allergy_history"`
+	PhysicalExamination     string  `gorm:"column:physical_examination" json:"physical_examination" form:"physical_examination"`
+	SpecialInspection       string  `gorm:"column:special_inspection" json:"special_inspection" form:"special_inspection"`
+	LabApparatus            string  `gorm:"column:lab_apparatus" json:"lab_apparatus" form:"lab_apparatus"`
 }
 
 func (HisPatientCaseHistory) TableName() string {

models/stock_models.go

 func (XtStockSetting) TableName() string {
 	return "xt_stock_setting"
 }
+
+type XtAdviceSetting struct {
+	ID           int64 `gorm:"column:id" json:"id" form:"id"`
+	IsAdviceOpen int64 `gorm:"column:is_advice_open" json:"is_advice_open" form:"is_advice_open"`
+	UserOrgId    int64 `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	Status       int64 `gorm:"column:status" json:"status" form:"status"`
+	Ctime        int64 `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime        int64 `gorm:"column:mtime" json:"mtime" form:"mtime"`
+}
+
+func (XtAdviceSetting) TableName() string {
+	return "xt_advice_setting"
+}

service/his_service.go

 }
 
 func GetHisPatientCaseHistoryInfo(org_id int64, patient_id int64, record_date int64) (info models.HisPatientCaseHistory, err error) {
-	err = readDb.Model(&models.HisPatientCaseHistory{}).Where("user_org_id = ? AND status = 1 AND record_date = ? AND patient_id = ?", org_id, record_date, patient_id).First(&info).Error
+	err = readDb.Model(&models.HisPatientCaseHistory{}).Where("user_org_id = ? AND status = 1 AND record_date = ? AND patient_id = ?", org_id, record_date, patient_id).Last(&info).Error
 	return
 }
 
 	return
 }
 
-func GetHisPatientCaseHistoryById(id int64) (*models.HisPatientCaseHistory, error) {
+func GetHisPatientCaseHistoryById(patient_id int64, record_date int64, user_org_id int64) (*models.HisPatientCaseHistory, error) {
 	history := models.HisPatientCaseHistory{}
-	err := XTReadDB().Model(&history).Where("id = ? and status = 1", id).Find(&history).Error
+	err := XTReadDB().Model(&history).Where("patient_id = ? and status = 1 and user_org_id = ? and record_date = ?", patient_id, user_org_id, record_date).Find(&history).Error
 	if err != nil {
 		if err == gorm.ErrRecordNotFound {
 			return nil, err
 	return &history, nil
 }
 
+func GetLastHisPatientCaseHistoryById(patient_id int64) (models.HisPatientCaseHistory, error) {
+	history := models.HisPatientCaseHistory{}
+	err := XTReadDB().Model(&history).Where("patient_id = ? and status = 1", patient_id).Last(&history).Error
+	return history, err
+}
+
 func SaveHisPatientCaseHistory(caseHistory *models.HisPatientCaseHistory) error {
 	err := writeDb.Create(&caseHistory).Error
 	return err
 }
 
-func UpdatePatientCaseHistory(id int64, his *models.HisPatientCaseHistory) error {
+func UpdatePatientCaseHistory(patient_id int64, record_date int64, user_org_id int64, his *models.HisPatientCaseHistory) error {
+
+	err := XTWriteDB().Model(&his).Where("patient_id = ? and record_date = ? and user_org_id = ? and status  =1", patient_id, record_date, user_org_id).Updates(map[string]interface{}{"temperature": his.Temperature, "blood_sugar": his.BloodSugar, "pulse": his.Pulse, "allergic_history": his.AllergicHistory, "diagnose": his.AllergicHistory, "sick": his.Sick, "remark": his.Remark, "doctor_advice": his.DoctorAdvice, "breathing": his.Breathing, "delivery_way": his.DeliveryWay, "diagnostic": his.Diagnostic, "family_history": his.FamilyHistory, "personal_history": his.PersonalHistory, "chief_conplaint": his.ChiefConplaint, "doctor": his.Doctor, "past_history": his.PastHistory, "history_of_present_illness": his.HistoryOfPresentIllness, "is_infect": his.IsInfect, "sick_date": his.SickDate, "symptom": his.Symptom, "sick_type": his.SickType, "blood_fat": his.BloodFat, "sbp": his.Sbp, "dbp": his.Dbp, "primary_disease": his.PrimaryDisease, "confirm_failure_date": his.ConfirmFailureDate, "drug_allergy_history": his.DrugAllergyHistory, "physical_examination": his.PhysicalExamination, "special_inspection": his.SpecialInspection, "lab_apparatus": his.LabApparatus}).Error
 
-	err := XTWriteDB().Model(&his).Where("id = ? and status  =1", id).Updates(map[string]interface{}{"temperature": his.Temperature, "blood_sugar": his.BloodSugar, "pulse": his.Pulse, "allergic_history": his.AllergicHistory, "diagnose": his.AllergicHistory, "sick": his.Sick, "remark": his.Remark, "doctor_advice": his.DoctorAdvice, "breathing": his.Breathing, "delivery_way": his.DeliveryWay, "diagnostic": his.Diagnostic, "family_history": his.FamilyHistory, "personal_history": his.PersonalHistory, "chief_conplaint": his.ChiefConplaint, "doctor": his.Doctor, "past_history": his.PastHistory, "history_of_present_illness": his.HistoryOfPresentIllness, "is_infect": his.IsInfect, "sick_date": his.SickDate, "symptom": his.Symptom, "sick_type": his.SickType, "blood_fat": his.BloodFat, "sbp": his.Sbp, "dbp": his.Dbp}).Error
 	return err
 }
 

service/patient_service.go

 	key := strconv.FormatInt(orgID, 10) + ":" + strconv.FormatInt(id, 10) + ":patient_info"
 
 	patient_info_str, _ := redis.Get(key).Result()
-
+	fmt.Println("patient_info_stre223322323232323323223", patient_info_str)
 	if len(patient_info_str) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
 		err = readDb.Model(&models.Patients{}).Preload("Contagions", "status = 1").Preload("Diseases", "status = 1").Where("id = ? and user_org_id=? and status=1", id, orgID).First(&patient).Error
 		if err != nil {

service/stock_service.go

 	if org_id > 0 {
 		db = db.Where("x.org_id = ?", org_id)
 	}
-	err = db.Select("x.id,x.warehousing_id,x.drug_id,x.number,x.product_date,x.expiry_date,x.warehousing_count,x.warehouseing_unit,x.stock_max_number,x.stock_min_number,x.price,x.remark,x.batch_number,x.batch_number,t.manufacturer,t.dealer,t.drug_name,t.last_price,t.dose_unit,t.dose,t.min_number,t.min_unit,t.max_unit,t.drug_type").Joins("left join xt_base_drug as t on t.id = x.drug_id").Scan(&list).Error
+	err = db.Select("x.id,x.warehousing_id,x.drug_id,x.number,x.product_date,x.expiry_date,x.warehousing_count,x.warehouseing_unit,x.stock_max_number,x.stock_min_number,x.price,x.remark,x.batch_number,x.batch_number,x.manufacturer,x.dealer,t.drug_name,t.last_price,t.dose_unit,t.dose,t.min_number,t.min_unit,t.max_unit,t.drug_type").Joins("left join xt_base_drug as t on t.id = x.drug_id").Scan(&list).Error
 	return list, err
 }
 
 
 	if len(keyword) > 0 {
 		likeKey := "%" + keyword + "%"
-		db = db.Select("x.patient_id,x.user_org_id,x.id,x.advice_date,x.advice_date,x.prescribing_number_unit,x.drug_id").Joins("left join sgj_xt.xt_base_drug as d on d.id = x.drug_id").Where("d.drug_name like ?", likeKey)
+		db = db.Select("x.patient_id,x.user_org_id,x.id,x.advice_date,x.advice_date,x.prescribing_number_unit,x.drug_id,x.prescribing_number").Joins("left join sgj_xt.xt_base_drug as d on d.id = x.drug_id").Where("d.drug_name like ?", likeKey)
 	}
 
 	offset := (page - 1) * limit
 
 	if len(keyword) > 0 {
 		likeKey := "%" + keyword + "%"
-		db = db.Select("x.patient_id,x.user_org_id,x.id,x.advice_date,x.advice_date,x.prescribing_number_unit,x.drug_id").Joins("left join sgj_xt.xt_base_drug as d on d.id = x.drug_id").Where("d.drug_name like ?", likeKey)
+		db = db.Select("x.patient_id,x.user_org_id,x.id,x.advice_date,x.advice_date,x.prescribing_number_unit,x.drug_id,x.prescribing_number").Joins("left join sgj_xt.xt_base_drug as d on d.id = x.drug_id").Where("d.drug_name like ?", likeKey)
 	}
 
 	err = db.Order("x.created_time desc").Scan(&adviceinfo).Error
 
 	if len(keyword) > 0 {
 		likeKey := "%" + keyword + "%"
-		db = db.Select("x.id,x.project_id,x.user_org_id,x.patient_id,x.record_date").Joins("left join xt_good_information as d on d.id = x.project_id").Where("d.good_name like ?", likeKey).Group("d.id")
+		db = db.Select("x.id,x.project_id,x.user_org_id,x.patient_id,x.record_date,x.count").Joins("left join xt_good_information as d on d.id = x.project_id").Where("d.good_name like ?", likeKey).Group("d.id")
 	}
 
 	offset := (page - 1) * limit
 
 	if len(keyword) > 0 {
 		likeKey := "%" + keyword + "%"
-		db = db.Select("x.id,x.project_id,x.user_org_id,x.patient_id,x.record_date").Joins("left join xt_good_information as d on d.id = x.project_id").Where("d.good_name like ? ", likeKey).Group("d.id")
+		db = db.Select("x.id,x.project_id,x.user_org_id,x.patient_id,x.record_date,x.count").Joins("left join xt_good_information as d on d.id = x.project_id").Where("d.good_name like ? ", likeKey).Group("d.id")
 	}
 
 	err = db.Order("x.ctime desc").Group("x.id").Scan(&project).Error
 	err := XTReadDB().Where("good_id = ? and record_time = ? and org_id = ? and status = 1 and patient_id = ?", good_id, record_date, orgid, patient_id).Find(&detail).Error
 	return detail, err
 }
+
+func GetAdviceConfig(orgid int64) (*models.XtAdviceSetting, error) {
+
+	setting := models.XtAdviceSetting{}
+	err := XTReadDB().Where("user_org_id = ? and status = 1", orgid).Find(&setting).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &setting, nil
+}
+
+func CreateAdviceSetting(setting models.XtAdviceSetting) error {
+
+	err := XTWriteDB().Create(&setting).Error
+	return err
+}
+
+func UpdateAdviceSetting(orgid int64, setting models.XtAdviceSetting) error {
+
+	err := XTWriteDB().Model(&setting).Where("user_org_id = ? and status = 1", orgid).Update(map[string]interface{}{"is_advice_open": setting.IsAdviceOpen, "mtime": time.Now().Unix()}).Error
+	return err
+}
+
+func FindAdviceSettingById(orgid int64) (models.XtAdviceSetting, error) {
+	setting := models.XtAdviceSetting{}
+	err := XTReadDB().Where("user_org_id = ? and status = 1", orgid).Find(&setting).Error
+	return setting, err
+}