package mobile_api_controllers
import (
"XT_New/enums"
"XT_New/models"
"XT_New/service"
"XT_New/utils"
"encoding/json"
"fmt"
"github.com/jinzhu/gorm"
"math"
"strings"
// "fmt"
"reflect"
"strconv"
"time"
)
type PatientApiController struct {
MobileBaseAPIAuthController
}
func (c *PatientApiController) GetPatientInfoWithDiseases() {
id, _ := c.GetInt64("patient", 0)
if id <= 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
adminUserInfo := c.GetMobileAdminUserInfo()
patient, _ := service.FindPatientByIdWithDiseases(adminUserInfo.Org.Id, id)
if patient.ID == 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
return
}
Registrars, err := service.GetAdminUser(adminUserInfo.Org.Id, adminUserInfo.App.Id, patient.RegistrarsId)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
return
}
if Registrars != nil {
patient.Registrars = Registrars.Name
}
c.ServeSuccessJSON(map[string]interface{}{
"patient": patient,
})
return
}
func (c *PatientApiController) CreateDialysisSolution() {
id, _ := c.GetInt64("patient", 0)
if id <= 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
adminUserInfo := c.GetMobileAdminUserInfo()
patient, _ := service.FindPatientById(adminUserInfo.Org.Id, id)
if patient.ID == 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
return
}
//根据路由来做权限
//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)
//template, _ := service.GetOrgInfoTemplate(adminUserInfo.Org.Id)
//if template.TemplateId == 2 || template.TemplateId == 6 {
// if appRole.UserType == 3 {
// headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.Org.Id, adminUserInfo.App.Id, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
// if getPermissionErr != nil {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
// return
// } else if headNursePermission == nil {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
// return
// }
// }
//}
var solution models.DialysisSolution
code := defaultSolutionFormData(&solution, c.Ctx.Input.RequestBody, "create")
if code > 0 {
c.ServeFailJSONWithSGJErrorCode(code)
return
}
solution.RegistrarsId = adminUserInfo.AdminUser.Id
solution.Doctor = adminUserInfo.AdminUser.Id
solution.Status = 1
solution.PatientId = id
solution.CreatedTime = time.Now().Unix()
solution.UserOrgId = adminUserInfo.Org.Id
solution.UpdatedTime = time.Now().Unix()
solution.SubName = ""
solution.ParentId = 0
err := service.CreatePatientDialysisSolution(&solution)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisSolutionCreate)
return
}
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
"solution": solution,
})
return
}
func (c *PatientApiController) EditDialysisSolution() {
id, _ := c.GetInt64("id", 0)
if id <= 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
adminUserInfo := c.GetMobileAdminUserInfo()
solution, _ := service.FindPatientDialysisSolution(adminUserInfo.Org.Id, id)
if solution.ID == 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisSolutionNotExist)
return
}
//if solution.Doctor != adminUserInfo.AdminUser.Id {
// headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.Org.Id, adminUserInfo.App.Id, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
// if getPermissionErr != nil {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
// return
// } else if headNursePermission == nil {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
// return
// }
//}
code := defaultSolutionFormData(&solution, c.Ctx.Input.RequestBody, "update")
if code > 0 {
c.ServeFailJSONWithSGJErrorCode(code)
return
}
// solution.RegistrarsId = adminUserInfo.AdminUser.Id
solution.Doctor = adminUserInfo.AdminUser.Id
solution.Status = 1
// solution.PatientId = id
// solution.CreatedTime = time.Now().Unix()
// solution.UserOrgId = adminUserInfo.Org.Id
solution.UpdatedTime = time.Now().Unix()
// solution.SubName = ""
// solution.ParentId = 0
err := service.UpdatePatientDialysisSolution(&solution)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisSolutionUpdate)
return
}
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
"solution": solution,
})
return
}
func (c *PatientApiController) CreateDoctorAdvice() {
patient, _ := c.GetInt64("id", 0)
if patient <= 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
adminUserInfo := c.GetMobileAdminUserInfo()
patientInfo, _ := service.FindPatientById(adminUserInfo.Org.Id, patient)
if patientInfo.ID == 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
return
}
//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)
//if appRole.UserType == 3{
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdvicePermissionDeniedModify)
// return
//}
//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)
//
//if appRole.UserType == 3 {
// headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.Org.Id, adminUserInfo.App.Id, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
// if getPermissionErr != nil {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
// return
// } else if headNursePermission == nil {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
// return
// }
//}
var advice models.DoctorAdvice
code := adviceFormData(&advice, c.Ctx.Input.RequestBody, "create")
if code > 0 {
c.ServeFailJSONWithSGJErrorCode(code)
return
}
if advice.ParentId > 0 {
old, _ := service.FindDoctorAdvice(adminUserInfo.Org.Id, advice.ParentId)
if old.ID == 0 || old.PatientId != patient {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParentAdviceNotExist)
return
}
if old.StopState == 1 || old.ExecutionState == 1 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceStoped)
return
}
if old.ParentId > 0 {
advice.ParentId = old.ParentId
}
advice.StartTime = old.StartTime
advice.AdviceDoctor = old.AdviceDoctor
advice.DeliveryWay = old.DeliveryWay
advice.ExecutionFrequency = old.ExecutionFrequency
advice.GroupNo = old.GroupNo
}
advice.Status = 1
advice.CreatedTime = time.Now().Unix()
advice.UpdatedTime = time.Now().Unix()
advice.StopState = 2
advice.ExecutionState = 2
advice.UserOrgId = adminUserInfo.Org.Id
advice.PatientId = patient
advice.AdviceDoctor = adminUserInfo.AdminUser.Id
err := service.CreateDoctorAdvice(&advice)
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
redis := service.RedisClient()
defer redis.Close()
redis.Set(key, "", time.Second)
keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
redis.Set(keyOne, "", time.Second)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateDoctorAdviceFail)
return
}
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
"advice": advice,
})
return
}
func (c *PatientApiController) EditDoctorAdvice() {
id, _ := c.GetInt64("id", 0)
patient_id, _ := c.GetInt64("patient_id")
doc_advice_date, _ := c.GetInt64("advice_date")
if id <= 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
redis := service.RedisClient()
adminUserInfo := c.GetMobileAdminUserInfo()
//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)
//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)
//
//if appRole.UserType == 3 {
// headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.Org.Id, adminUserInfo.App.Id, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
// if getPermissionErr != nil {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
// return
// } else if headNursePermission == nil {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
// return
// }
//}
advice, _ := service.FindDoctorAdvice(adminUserInfo.Org.Id, id)
if advice.ID == 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
return
}
code := adviceFormData(&advice, c.Ctx.Input.RequestBody, "update")
if code > 0 {
c.ServeFailJSONWithSGJErrorCode(code)
return
}
advice.Status = 1
advice.UpdatedTime = time.Now().Unix()
advice.UserOrgId = adminUserInfo.Org.Id
advice.Modifier = adminUserInfo.AdminUser.Id
//处理修改医嘱开始时间逻辑(不包括子医嘱)
//1.一组医嘱内只有一条医嘱(不包括子医嘱)的情况下，只需要直接修改医嘱开始时间，不需要重新分配组号
//2.一组医嘱内有多条医嘱(不包括子医嘱)的情况下,需要为修改的那条医嘱重新分配组号，并修改医嘱开始时间
var err error
var isChangeGroup bool
if advice.ParentId == 0 {
adviceSlice, _ := service.FindAdviceByGoroupNo(adminUserInfo.Org.Id, advice.GroupNo)
sourceAdvice, _ := service.FindOldDoctorAdvice(adminUserInfo.Org.Id, advice.ID)
if len(adviceSlice) == 1 {
//判断前端上传上来的开始时间和数据库中想要修改的那条医嘱的开始时间是否相同，如果不同，需要修改子医嘱的开始时间，如果相同直接修改，不需要修改子医嘱的开始时间
if advice.StartTime == sourceAdvice.StartTime {
err = service.UpdateDoctorAdvice(&advice)
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"
defer redis.Close()
redis.Set(key, "", time.Second)
keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + ":advice_list_all"
redis.Set(keyOne, "", time.Second)
isChangeGroup = false
} else {
err = service.UpdateDoctorAdviceAndSubAdvice(&advice)
isChangeGroup = false
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"
defer redis.Close()
redis.Set(key, "", time.Second)
keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":advice_list_all"
redis.Set(keyOne, "", time.Second)
}
} else if len(adviceSlice) > 1 {
//判断前端上传上来的开始时间和数据库中想要修改的那条医嘱的开始时间是否相同，如果不同，需要重新分配组，如果相同直接修改，不需要分配组
if advice.StartTime == sourceAdvice.StartTime {
err = service.UpdateDoctorAdvice(&advice)
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"
defer redis.Close()
redis.Set(key, "", time.Second)
keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":advice_list_all"
redis.Set(keyOne, "", time.Second)
isChangeGroup = false
} else {
gruopNo := service.GetMaxAdviceGroupID(adminUserInfo.Org.Id)
gruopNo = gruopNo + 1
advice.GroupNo = gruopNo
err = service.UpdateDoctorAdviceAndSubAdvice(&advice)
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"
defer redis.Close()
redis.Set(key, "", time.Second)
keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":advice_list_all"
redis.Set(keyOne, "", time.Second)
isChangeGroup = true
}
}
} else {
isChangeGroup = false
err = service.UpdateDoctorAdvice(&advice)
redis := service.RedisClient()
defer redis.Close()
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":advice_list_all"
redis.Set(key, "", time.Second)
keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"
redis.Set(keyOne, "", time.Second)
}
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateDoctorAdviceFail)
return
}
if !isChangeGroup {
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
"advice": advice,
"isChange": isChangeGroup, //方便前端处理数据
})
} else {
newGroupAdvice, err := service.FindAllDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, advice.GroupNo)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
return
}
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
"advice": newGroupAdvice,
"isChange": isChangeGroup, //方便前端处理数据
})
}
return
}
func (c *PatientApiController) StopDoctorAdvice() {
id, _ := c.GetInt64("id", 0)
if id <= 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
adminUserInfo := c.GetMobileAdminUserInfo()
advice, _ := service.FindDoctorAdvice(adminUserInfo.Org.Id, id)
if advice.ID == 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
return
}
//if advice.AdviceDoctor != adminUserInfo.AdminUser.Id {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
// return
//}
//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)
//
//if appRole.UserType == 3 {
// headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.Org.Id, adminUserInfo.App.Id, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
// if getPermissionErr != nil {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
// return
// } else if headNursePermission == nil {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
// return
// }
//}
if advice.StopState == 1 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceStoped)
return
}
dataBody := make(map[string]interface{}, 0)
err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
timeLayout := "2006-01-02"
loc, _ := time.LoadLocation("Local")
if dataBody["stop_time"] == nil || reflect.TypeOf(dataBody["stop_time"]).String() != "string" {
utils.ErrorLog("stop_time")
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
stopTime, _ := dataBody["stop_time"].(string)
if len(stopTime) == 0 {
utils.ErrorLog("len(stop_time) == 0")
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", stopTime, loc)
if err != nil {
utils.ErrorLog(err.Error())
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
advice.StopTime = theTime.Unix()
if dataBody["stop_reason"] == nil || reflect.TypeOf(dataBody["stop_reason"]).String() != "string" {
utils.ErrorLog("stop_reason")
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
stopReason, _ := dataBody["stop_reason"].(string)
if len(stopReason) == 0 {
utils.ErrorLog("len(stop_reason) == 0")
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
advice.StopReason = stopReason
advice.Status = 1
advice.UpdatedTime = time.Now().Unix()
advice.StopDoctor = adminUserInfo.AdminUser.Id
advice.StopState = 1
advice.StopTime = time.Now().Unix()
advice.Modifier = adminUserInfo.AdminUser.Id
err = service.StopDoctorAdvice(&advice)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeStopAdviceFail)
return
}
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
"advice": advice,
})
return
}
func (c *PatientApiController) DeleteDoctorAdvice() {
id, _ := c.GetInt64("id", 0)
if id <= 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
adminUserInfo := c.GetMobileAdminUserInfo()
advice, _ := service.FindDoctorAdvice(adminUserInfo.Org.Id, id)
if advice.ID == 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
return
}
//if !adminUserInfo.AdminUser.IsSuperAdmin && advice.AdviceDoctor != adminUserInfo.AdminUser.Id {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
// return
//}
//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)
//
//if appRole.UserType == 3 {
// headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.Org.Id, adminUserInfo.App.Id, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
// if getPermissionErr != nil {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
// return
// } else if headNursePermission == nil {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
// return
// }
//}
advice.UpdatedTime = time.Now().Unix()
advice.Status = 0
advice.Modifier = adminUserInfo.AdminUser.Id
err := service.DeleteDoctorAdvice(&advice)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteAdviceFail)
return
}
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
})
return
}
func (c *PatientApiController) ExecDoctorAdvice() {
execution_time := c.GetString("execution_time")
origin, _ := c.GetInt64("origin", 0)
groupno, _ := c.GetInt64("groupno", -1)
if origin != 2 {
adminUserInfo := c.GetMobileAdminUserInfo()
execution_staff := adminUserInfo.AdminUser.Id
var ids []string
advice_ids := c.GetString("advice_id")
if groupno == 0 {
ids = strings.Split(advice_ids, ",")
}
if groupno < 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
if len(execution_time) <= 0 {
utils.ErrorLog("execution_time")
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
timeLayout2 := "2006-01-02 15:04:05"
loc, _ := time.LoadLocation("Local")
theTime, errs := time.ParseInLocation(timeLayout2, execution_time, loc)
if errs != nil {
utils.ErrorLog(errs.Error())
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
var advice models.DoctorAdvice
if groupno > 0 {
advices, _ := service.FindAllDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, groupno)
for _, item := range advices {
if item.ExecutionState == 2 {
advice = item
}
}
} else {
advices, _ := service.FindDoctorAdviceByIds(adminUserInfo.Org.Id, ids)
for _, item := range advices {
if item.ExecutionState == 2 {
advice = item
}
}
}
if advice.ExecutionState == 1 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExced)
return
}
if advice.Checker >= 0 && advice.Checker == adminUserInfo.AdminUser.Id {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeExceAndCheckNotOneUser)
return
}
if advice.StartTime > theTime.Unix() {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExceBeforeStart)
return
}
advices := models.DoctorAdvice{
ExecutionStaff: execution_staff,
ExecutionTime: theTime.Unix(),
UpdatedTime: time.Now().Unix(),
}
var err error
if groupno > 0 {
err = service.ExceDoctorAdviceByGroupNo(&advices, groupno, adminUserInfo.Org.Id)
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
redis := service.RedisClient()
//清空key 值
redis.Set(key, "", time.Second)
keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
redis.Set(keyTwo, "", time.Second)
keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_doctor_advice"
redis.Set(keyThree, "", time.Second)
toTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04:05", execution_time)
theTime := toTime.Format("2006-01-02")
fmt.Println("theTIME", theTime)
keyFour := "scheduals_" + theTime + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
redis.Set(keyFour, "", time.Second)
keyFive := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_advices_list_all"
redis.Set(keyFive, "", time.Second)
defer redis.Close()
} else {
err = service.BatchExceOldDoctorAdvice(&advices, ids)
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
redis := service.RedisClient()
keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
redis.Set(keyTwo, "", time.Second)
keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_doctor_advice"
redis.Set(keyThree, "", time.Second)
toTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04:05", execution_time)
theTime := toTime.Format("2006-01-02")
fmt.Println("theTIME", theTime)
keyFour := "scheduals_" + theTime + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
redis.Set(keyFour, "", time.Second)
keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_advices_list_all"
redis.Set(keySix, "", time.Second)
defer redis.Close()
//清空key 值
redis.Set(key, "", time.Second)
}
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateDoctorAdviceFail)
return
}
advice.ExecutionStaff = execution_staff
advice.ExecutionTime = theTime.Unix()
advice.ExecutionState = 1
advice.Modifier = adminUserInfo.AdminUser.Id
//处理出库相关逻辑
//1.判断是否启用药品管理和自备药出库功能
//药品管理信息
_, drugStockConfig := service.FindDrugStockAutomaticReduceRecordByOrgId(adminUserInfo.Org.Id)
//自备药信息
privateDrugConfig, _ := service.GetDrugSetByUserOrgId(adminUserInfo.Org.Id)
storeHouseConfig, _ := service.GetAllStoreHouseConfig(adminUserInfo.Org.Id)
fmt.Println("drugStockConfig.IsOpen32232323232", drugStockConfig.IsOpen)
if drugStockConfig.IsOpen == 1 {
if groupno > 0 {
advices, _ := service.FindAllDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, groupno)
isHasWay := false //用来判断是否包含来自药品库的医嘱
for _, item := range advices {
if item.Way == 1 {
isHasWay = true
}
}
if isHasWay {
var total int64
var prescribing_number_total int64
fmt.Println("advicesssssssssssssssss", len(advices))
for _, item := range advices {
if item.Way == 1 {
houseConfig, _ := service.GetAllStoreHouseConfig(item.UserOrgId)
//查询该药品的剩余库存
list, _ := service.GetDrugTotalCount(item.DrugId, item.UserOrgId, houseConfig.DrugStorehouseOut)
//查询改药品信息
medical, _ := service.GetBaseDrugMedical(item.DrugId)
//判断单位是否相等
if medical.MaxUnit == item.PrescribingNumberUnit {
prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
//转化为最小单位
total = list.Count * medical.MinNumber
prescribing_number_total = count * medical.MinNumber
}
if medical.MinUnit == item.PrescribingNumberUnit {
prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
total = list.Count*medical.MinNumber + list.StockMinNumber
prescribing_number_total = count
}
if medical.IsUse == 1 {
c.ServeSuccessJSON(map[string]interface{}{
"msg": "1",
"advice": advice,
"ids": ids,
})
return
}
if medical.IsUse != 1 {
if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
c.ServeSuccessJSON(map[string]interface{}{
"msg": "3",
"advice": advice,
"ids": ids,
})
return
}
if prescribing_number_total > total {
c.ServeSuccessJSON(map[string]interface{}{
"msg": "2",
"advice": advice,
"ids": ids,
})
return
}
}
if prescribing_number_total <= total {
//查询是否出库按钮开启
adviceSetting, _ := service.FindAdviceSettingById(item.UserOrgId)
if adviceSetting.IsAdviceOpen == 1 {
//查询是否出库按钮开启
prescriptionConfig, _ := service.FindPrescriptionConfigById(item.UserOrgId)
pharmacyConfig, _ := service.FindPharmacyConfig(item.UserOrgId)
if prescriptionConfig.IsOpen == 1 {
if medical.IsUse == 2 {
if pharmacyConfig.IsOpen == 1 && medical.IsPharmacy == 0 {
service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, &item)
}
if pharmacyConfig.IsOpen != 1 {
service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, &item)
}
//更新字典里面的库存
stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
var sum_count int64
for _, its := range stockInfo {
if its.MaxUnit == medical.MaxUnit {
its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
}
sum_count += its.StockMaxNumber + its.StockMinNumber
}
service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.UserOrgId)
//剩余库存
service.UpdateDrugStockCount(item.DrugId, item.UserOrgId, storeHouseConfig.DrugStorehouseOut, sum_count)
}
}
} else {
pharmacyConfig, _ := service.FindPharmacyConfig(item.UserOrgId)
if medical.IsUse == 2 {
if pharmacyConfig.IsOpen == 1 && medical.IsPharmacy == 0 {
service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, &item)
}
if pharmacyConfig.IsOpen != 1 {
service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, &item)
}
stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
var sum_count int64
for _, its := range stockInfo {
if its.MaxUnit == medical.MaxUnit {
its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
}
sum_count += its.StockMaxNumber + its.StockMinNumber
}
service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.UserOrgId)
//剩余库存
service.UpdateDrugStockCount(item.DrugId, item.UserOrgId, storeHouseConfig.DrugStorehouseOut, sum_count)
}
}
}
}
}
}
} else {
advices, _ := service.FindDoctorAdviceByIds(adminUserInfo.Org.Id, ids)
isHasWay := false //用来判断是否包含来自药品库的医嘱
for _, item := range advices {
if item.Way == 1 {
isHasWay = true
}
}
if isHasWay {
var total int64
var prescribing_number_total int64
for _, item := range advices {
if item.Way == 1 {
houseConfig, _ := service.GetAllStoreHouseConfig(item.UserOrgId)
//查询该药品的剩余库存
list, _ := service.GetDrugTotalCount(item.DrugId, item.UserOrgId, houseConfig.DrugStorehouseOut)
//查询改药品信息
medical, _ := service.GetBaseDrugMedical(item.DrugId)
//判断单位是否相等
if medical.MaxUnit == item.PrescribingNumberUnit {
prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
//转化为最小单位
total = list.Count*medical.MinNumber + list.StockMinNumber
prescribing_number_total = count * medical.MinNumber
}
if medical.MinUnit == item.PrescribingNumberUnit {
prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
total = list.Count*medical.MinNumber + list.StockMinNumber
prescribing_number_total = count
}
if medical.IsUse == 1 {
c.ServeSuccessJSON(map[string]interface{}{
"msg": "1",
"advice": advice,
"ids": ids,
})
return
}
if medical.IsUse != 1 {
if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
c.ServeSuccessJSON(map[string]interface{}{
"msg": "3",
"advice": advice,
"ids": ids,
})
return
}
if prescribing_number_total > total {
c.ServeSuccessJSON(map[string]interface{}{
"msg": "2",
"advice": advice,
"ids": ids,
})
return
}
}
if prescribing_number_total <= total {
pharmacyConfig, _ := service.FindPharmacyConfig(item.UserOrgId)
if medical.IsUse == 2 {
if pharmacyConfig.IsOpen == 1 && medical.IsPharmacy == 0 {
service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, &item)
}
if pharmacyConfig.IsOpen != 1 {
service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, &item)
}
//更新字典里面的库存
stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
var sum_count int64
for _, its := range stockInfo {
baseDrug, _ := service.GetBaseDrugMedical(its.DrugId)
if its.MaxUnit == baseDrug.MaxUnit {
its.StockMaxNumber = its.StockMaxNumber * baseDrug.MinNumber
}
sum_count += its.StockMaxNumber + its.StockMinNumber
}
service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.UserOrgId)
//剩余库存
service.UpdateDrugStockCount(item.DrugId, item.UserOrgId, storeHouseConfig.DrugStorehouseOut, sum_count)
}
if medical.IsUse == 1 {
c.ServeSuccessJSON(map[string]interface{}{
"msg": "1",
"advice": advice,
"ids": ids,
})
return
}
}
}
}
}
}
c.ServeSuccessJSON(map[string]interface{}{
"msg": "1",
"advice": advice,
"ids": ids,
})
return
}
if privateDrugConfig != nil && privateDrugConfig.DrugStart == 1 {
if groupno > 0 {
advices, _ := service.FindAllDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, groupno)
for _, item := range advices {
if item.ExecutionState == 1 && item.Way == 2 {
prescribingNumber := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
count, _ := strconv.ParseInt(prescribingNumber, 10, 64)
timeStr := time.Now().Format("2006-01-02")
timeArr := strings.Split(timeStr, "-")
total, _ := service.FindAllDrugWarehouseOut(adminUserInfo.Org.Id)
total = total + 1
warehousing_out_order := strconv.FormatInt(adminUserInfo.Org.Id, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
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,
DrugNameId: item.DrugNameId,
DrugSpec: item.AdviceDesc,
OutstoreNumber: count,
AdminUserId: adminUserInfo.AdminUser.Id,
StorckTime: item.AdviceDate,
UserOrgId: adminUserInfo.Org.Id,
CreatedTime: time.Now().Unix(),
Status: 1,
PatientId: item.PatientId,
ExitMode: 2,
MedicId: item.DrugId,
StockOutNumber: warehousing_out_order,
}
//查询 该患者是否已出库
out, errcode := service.GetSelfOutStock(adminUserInfo.Org.Id, item.AdviceDate, item.PatientId, item.AdviceName, item.AdviceDesc)
if errcode == gorm.ErrRecordNotFound {
service.CreateOutStock(&outStock)
} else if errcode == nil {
err := service.UpdatedSelfOutSatock(out.ID, &outStock)
fmt.Println("err", err)
}
}
}
} else {
advices, _ := service.FindDoctorAdviceByIds(adminUserInfo.Org.Id, ids)
for _, item := range advices {
if item.ExecutionState == 1 && item.Way == 2 {
prescribingNumber := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
count, _ := strconv.ParseInt(prescribingNumber, 10, 64)
timeStr := time.Now().Format("2006-01-02")
timeArr := strings.Split(timeStr, "-")
total, _ := service.FindAllDrugWarehouseOut(adminUserInfo.Org.Id)
total = total + 1
warehousing_out_order := strconv.FormatInt(adminUserInfo.Org.Id, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
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,
DrugNameId: item.DrugNameId,
DrugSpec: item.AdviceDesc,
OutstoreNumber: count,
AdminUserId: adminUserInfo.AdminUser.Id,
StorckTime: item.AdviceDate,
UserOrgId: adminUserInfo.Org.Id,
CreatedTime: time.Now().Unix(),
Status: 1,
PatientId: item.PatientId,
ExitMode: 2,
MedicId: item.DrugId,
StockOutNumber: warehousing_out_order,
}
//查询 该患者是否已出库
out, errcode := service.GetSelfOutStock(adminUserInfo.Org.Id, item.AdviceDate, item.PatientId, item.AdviceName, item.AdviceDesc)
if errcode == gorm.ErrRecordNotFound {
service.CreateOutStock(&outStock)
} else if errcode == nil {
err := service.UpdatedSelfOutSatock(out.ID, &outStock)
fmt.Println("err", err)
}
}
}
c.ServeSuccessJSON(map[string]interface{}{
"msg": "1",
"advice": advice,
"ids": ids,
})
return
}
}
c.ServeSuccessJSON(map[string]interface{}{
"msg": "1",
"advice": advice,
"ids": ids,
})
return
} else if origin == 2 {
adminInfo := c.GetMobileAdminUserInfo()
creater := c.GetMobileAdminUserInfo().AdminUser.Id
var ids []string
advice_ids := c.GetString("advice_id")
ids = strings.Split(advice_ids, ",")
if len(execution_time) <= 0 {
utils.ErrorLog("execution_time")
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
timeLayout2 := "2006-01-02 15:04:05"
loc, _ := time.LoadLocation("Local")
theTime, errs := time.ParseInLocation(timeLayout2, execution_time, loc)
if errs != nil {
utils.ErrorLog(errs.Error())
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
advices, _ := service.FindHisDoctorAdviceByIds(adminInfo.Org.Id, ids)
var err error
for _, item := range advices {
if item.ExecutionState == 1 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExced)
return
}
if item.Checker >= 0 && item.Checker == adminInfo.AdminUser.Id {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeExceAndCheckNotOneUser)
return
}
if item.StartTime > theTime.Unix() {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExceBeforeStart)
return
}
item.ExecutionState = 1
item.ExecutionStaff = adminInfo.AdminUser.Id
item.ExecutionTime = theTime.Unix()
err = service.SaveHisDoctorAdvice(item)
key := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.PatientId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":doctor_advices"
redis := service.RedisClient()
//清空key 值
redis.Set(key, "", time.Second)
keyTwo := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":advice_list_all"
redis.Set(keyTwo, "", time.Second)
keyThree := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.PatientId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":his_doctor_advice"
redis.Set(keyThree, "", time.Second)
recordDate := theTime.Format("2006-01-02")
keyFour := "scheduals_" + recordDate + "_" + strconv.FormatInt(adminInfo.Org.Id, 10)
redis.Set(keyFour, "", time.Second)
keyFive := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":his_advices_list_all"
redis.Set(keyFive, "", time.Second)
defer redis.Close()
}
if err == nil {
//药品管理信息
_, drugStockConfig := service.FindDrugStockAutomaticReduceRecordByOrgId(adminInfo.Org.Id)
storeHouseConfig, _ := service.GetAllStoreHouseConfig(adminInfo.Org.Id)
if drugStockConfig.IsOpen == 1 {
for _, item := range advices {
//查询改药品信息
medical, _ := service.GetBaseDrugMedical(item.DrugId)
//查询这个患者这个患者这个药已经出库的所有数量
advicelist, _ := service.GetAllHisDoctorAdviceById(item.DrugId, item.PatientId, item.AdviceDate, item.UserOrgId)
drugoutlist, _ := service.GetAllDrugFlowById(item.DrugId, item.PatientId, item.AdviceDate, item.UserOrgId)
var total_count int64
var drug_count int64
for _, it := range advicelist {
if it.PrescribingNumberUnit == medical.MaxUnit {
prescribingNumber_temp := strconv.FormatFloat(math.Abs(it.PrescribingNumber), 'f', 0, 64)
prenumber, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
total_count += prenumber * medical.MinNumber
}
if it.PrescribingNumberUnit == medical.MinUnit {
prescribingNumber_temp := strconv.FormatFloat(math.Abs(it.PrescribingNumber), 'f', 0, 64)
prenumber, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
total_count += prenumber
}
}
for _, its := range drugoutlist {
if its.CountUnit == medical.MaxUnit {
drug_count += its.Count * medical.MinNumber
}
if its.CountUnit == medical.MinUnit {
drug_count += its.Count
}
}
if total_count == drug_count {
advice, _ := service.FindHisDoctorAdviceById(adminInfo.Org.Id, item.ID)
c.ServeSuccessJSON(map[string]interface{}{
"msg": "1",
"advice": advice,
"ids": ids,
})
return
}
advice, _ := service.FindHisDoctorAdviceById(adminInfo.Org.Id, item.ID)
var total int64
var prescribing_number_total int64
config, _ := service.GetDrugOpenConfigOne(adminInfo.Org.Id)
if config.IsOpen != 1 {
//查询该药品是否有库存
houseConfig, _ := service.GetAllStoreHouseConfig(advice.UserOrgId)
list, _ := service.GetDrugTotalCount(advice.DrugId, advice.UserOrgId, houseConfig.DrugStorehouseOut)
//判断单位是否相等
if medical.MaxUnit == advice.PrescribingNumberUnit {
prescribingNumber_temp := strconv.FormatFloat(math.Abs(advice.PrescribingNumber), 'f', 0, 64)
count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
//转化为最小单位
total = list.Count*medical.MinNumber + list.StockMinNumber
prescribing_number_total = count * medical.MinNumber
}
//fmt.Println("医嘱开的数量", total)
if medical.MinUnit == advice.PrescribingNumberUnit {
prescribingNumber_temp := strconv.FormatFloat(math.Abs(advice.PrescribingNumber), 'f', 0, 64)
count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
total = list.Count*medical.MinNumber + list.StockMinNumber
prescribing_number_total = count
}
if medical.IsUse == 1 {
if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
c.ServeSuccessJSON(map[string]interface{}{
"msg": "1",
"advice": advice,
"ids": ids,
})
return
}
}
if medical.IsUse != 1 {
if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
c.ServeSuccessJSON(map[string]interface{}{
"msg": "3",
"advice": advice,
"ids": ids,
})
return
}
if prescribing_number_total > total {
c.ServeSuccessJSON(map[string]interface{}{
"msg": "2",
"advice": advice,
"ids": ids,
})
return
}
}
if prescribing_number_total <= total {
pharmacyConfig, _ := service.FindPharmacyConfig(advice.UserOrgId)
//判断药品是否零用
if medical.IsUse == 2 {
if config.IsOpen != 1 {
if pharmacyConfig.IsOpen == 1 && medical.IsPharmacy == 0 {
service.HisDrugsDelivery(adminInfo.Org.Id, creater, &advice)
}
if pharmacyConfig.IsOpen != 1 {
service.HisDrugsDelivery(adminInfo.Org.Id, creater, &advice)
}
//更新字典里面的库存
stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
var sum_count int64
for _, its := range stockInfo {
if its.MaxUnit == medical.MaxUnit {
its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
}
sum_count += its.StockMaxNumber + its.StockMinNumber
}
service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.UserOrgId)
//剩余库存
service.UpdateDrugStockCount(item.DrugId, item.UserOrgId, storeHouseConfig.DrugStorehouseOut, sum_count)
}
}
}
}
//
//if config.IsOpen == 1 && item.UserOrgId == 10088 {
//
// service.HisDrugsDelivery(adminInfo.Org.Id, creater, &advice)
// //更新字典里面的库存
// stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
// var sum_count int64
// for _, its := range stockInfo {
// if its.MaxUnit == medical.MaxUnit {
// its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
// }
// sum_count += its.StockMaxNumber + its.StockMinNumber
// }
// service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.UserOrgId)
// //剩余库存
// service.UpdateDrugStockCount(item.DrugId, item.UserOrgId, storeHouseConfig.DrugStorehouseOut, sum_count)
//}
}
}
for _, item := range advices {
advice, _ := service.FindHisDoctorAdviceById(adminInfo.Org.Id, item.ID)
c.ServeSuccessJSON(map[string]interface{}{
"msg": "1",
"advice": advice,
"ids": ids,
})
}
} else {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
}
}
}
func (c *PatientApiController) ModifyExecDoctorAdvice() {
execution_time := c.GetString("execution_time")
fmt.Println("execution_time", execution_time)
groupno, _ := c.GetInt64("groupno", -1)
//patient_id, _ := c.GetInt64("patient_id")
advice_date, _ := c.GetInt64("advice_date")
var ids []string
if groupno == 0 {
advice_ids := c.GetString("advice_id")
ids = strings.Split(advice_ids, ",")
}
if groupno < 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
if len(execution_time) <= 0 {
utils.ErrorLog("execution_time")
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
timeLayout2 := "2006-01-02 15:04:05"
loc, _ := time.LoadLocation("Local")
theTime, errs := time.ParseInLocation(timeLayout2, execution_time, loc)
if errs != nil {
utils.ErrorLog(errs.Error())
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
adminUserInfo := c.GetMobileAdminUserInfo()
var advice models.DoctorAdvice
if groupno > 0 {
advices, _ := service.FindAllDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, groupno)
for _, item := range advices {
if item.ExecutionState == 1 {
advice = item
}
}
} else {
advices, _ := service.FindDoctorAdviceByIds(adminUserInfo.Org.Id, ids)
for _, item := range advices {
if item.ExecutionState == 1 {
advice = item
}
}
}
//if advice.ExecutionStaff != adminUserInfo.AdminUser.Id {
// headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.Org.Id, adminUserInfo.App.Id, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
// if getPermissionErr != nil {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
// return
// } else if headNursePermission == nil {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
// return
// }
//}
if advice.StartTime > theTime.Unix() {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExceBeforeStart)
return
}
advices := models.DoctorAdvice{
ExecutionTime: theTime.Unix(),
UpdatedTime: time.Now().Unix(),
}
var err error
if groupno > 0 {
err = service.ModifyExceDoctorAdviceByGroupNo(&advices, groupno, adminUserInfo.Org.Id)
redis := service.RedisClient()
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
redis.Set(key, "", time.Second)
keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
redis.Set(keyOne, "", time.Second)
defer redis.Close()
} else {
err = service.BatchModifyExceOldDoctorAdvice(&advices, ids)
err = service.ModifyExceDoctorAdviceByGroupNoOne(&advices, ids)
redis := service.RedisClient()
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
redis.Set(key, "", time.Second)
keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice_date, 10) + ":advice_list_all"
redis.Set(keyOne, "", time.Second)
defer redis.Close()
}
//判断是否开启his
errs, config := service.FindXTHisRecordByOrgId(adminUserInfo.Org.Id)
//如果开启去修改执行时间
if config.IsOpen == 1 {
advicesinfo := models.HisDoctorAdviceInfo{
ExecutionTime: theTime.Unix(),
UpdatedTime: time.Now().Unix(),
}
var advicehis models.HisDoctorAdviceInfo
service.ModifyExceDoctorAdviceById(&advicesinfo, ids)
his_advices, _ := service.FindHisDoctorAdviceByIdOne(adminUserInfo.Org.Id, ids)
for _, item := range his_advices {
if item.ExecutionState == 1 {
advicehis = item
}
}
redis := service.RedisClient()
keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advicehis.PatientId, 10) + ":" + strconv.FormatInt(advicehis.AdviceDate, 10) + ":his_doctor_advice"
redis.Set(keyThree, "", time.Second)
recordDate := theTime.Format("2006-01-02")
keyFour := "scheduals_" + recordDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
redis.Set(keyFour, "", time.Second)
keyFive := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advicehis.AdviceDate, 10) + ":his_advices_list_all"
redis.Set(keyFive, "", time.Second)
defer redis.Close()
project := models.HisPrescriptionProject{
ExecutionTime: theTime.Unix(),
Mtime: time.Now().Unix(),
}
service.ModifyHisPrescriptionProject(&project, ids)
keyEnd := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advicesinfo.PatientId, 10) + ":" + strconv.FormatInt(advicesinfo.AdviceDate, 10) + ":his_doctor_advice"
redis.Set(keyEnd, "", time.Second)
keyFours := "scheduals_" + recordDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
redis.Set(keyFours, "", time.Second)
keyFives := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advicesinfo.AdviceDate, 10) + ":his_advices_list_all"
redis.Set(keyFives, "", time.Second)
defer redis.Close()
}
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateDoctorAdviceFail)
return
}
advice.ExecutionTime = theTime.Unix()
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
"advice": advice,
"ids": ids,
})
return
}
func (c *PatientApiController) CheckDoctorAdvice() {
origin, _ := c.GetInt64("origin", 0)
if origin != 2 {
groupno, _ := c.GetInt64("groupno", -1)
var ids []string
if groupno == 0 {
advice_ids := c.GetString("advice_id")
if advice_ids == "" {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
} else {
ids = strings.Split(advice_ids, ",")
if len(ids) <= 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
}
}
if groupno < 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
adminUserInfo := c.GetMobileAdminUserInfo()
var advice models.DoctorAdvice
if groupno > 0 {
advices, _ := service.FindAllDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, groupno)
for _, item := range advices {
if item.CheckState == 0 {
advice = item
}
}
if advice.CheckState == 1 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceChecked)
return
}
if advice.ExecutionStaff >= 0 && advice.ExecutionStaff == adminUserInfo.AdminUser.Id {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeExceAndCheckNotOneUser)
return
}
} else {
advices, _ := service.FindDoctorAdviceByIds(adminUserInfo.Org.Id, ids)
for _, item := range advices {
if item.CheckState == 0 {
advice = item
}
}
if advice.CheckState == 1 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceChecked)
return
}
if advice.ExecutionStaff >= 0 && advice.ExecutionStaff == adminUserInfo.AdminUser.Id {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeExceAndCheckNotOneUser)
return
}
}
checker := adminUserInfo.AdminUser.Id
theTime := time.Now()
advices := models.DoctorAdvice{
CheckTime: theTime.Unix(),
Checker: checker,
UpdatedTime: time.Now().Unix(),
}
var err error
if groupno > 0 {
err = service.CheckDoctorAdviceByGroupNo(&advices, groupno, adminUserInfo.Org.Id)
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
redis := service.RedisClient()
//清空key 值
redis.Set(key, "", time.Second)
keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
redis.Set(keyTwo, "", time.Second)
keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_doctor_advice"
redis.Set(keyThree, "", time.Second)
recordDate := theTime.Format("2006-01-02")
keyFour := "scheduals_" + recordDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
redis.Set(keyFour, "", time.Second)
keyFive := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_advices_list_all"
redis.Set(keyFive, "", time.Second)
defer redis.Close()
} else {
if len(ids[0]) <= 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateDoctorAdviceFail)
return
} else {
//t := time.Now().Format("2006-01-02")/**/
//timeLayout2 := "2006-01-02"
//loc, _ := time.LoadLocation("Local")
//theTime, _ := time.ParseInLocation(timeLayout2, t, loc)
err = service.BatchCheckOldDoctorAdvice(&advices, ids, adminUserInfo.Org.Id, advice.AdviceDate)
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
redis := service.RedisClient()
//清空key 值
redis.Set(key, "", time.Second)
keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
redis.Set(keyTwo, "", time.Second)
keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_doctor_advice"
redis.Set(keyThree, "", time.Second)
recordDate := theTime.Format("2006-01-02")
keyFour := "scheduals_" + recordDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
redis.Set(keyFour, "", time.Second)
keyFive := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_advices_list_all"
redis.Set(keyFive, "", time.Second)
defer redis.Close()
}
}
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateDoctorAdviceFail)
return
}
advice.Checker = checker
advice.CheckTime = theTime.Unix()
advice.CheckState = 1
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
"advice": advice,
})
} else if origin == 2 {
adminInfo := c.GetMobileAdminUserInfo()
var ids []string
advice_ids := c.GetString("advice_id")
ids = strings.Split(advice_ids, ",")
advices, _ := service.FindHisDoctorAdviceByIds(adminInfo.Org.Id, ids)
var err error
for _, item := range advices {
if item.CheckState == 1 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceChecked)
return
}
if item.ExecutionStaff >= 0 && item.ExecutionStaff == adminInfo.AdminUser.Id {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeExceAndCheckNotOneUser)
return
}
item.Checker = adminInfo.AdminUser.Id
item.CheckTime = time.Now().Unix()
item.CheckState = 1
err = service.SaveHisDoctorAdvice(item)
redis := service.RedisClient()
key := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.PatientId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":doctor_advices"
//清空key 值
redis.Set(key, "", time.Second)
keyTwo := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":advice_list_all"
redis.Set(keyTwo, "", time.Second)
keyThree := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.PatientId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":his_doctor_advice"
redis.Set(keyThree, "", time.Second)
theTime := time.Now()
recordDate := theTime.Format("2006-01-02")
keyFour := "scheduals_" + recordDate + "_" + strconv.FormatInt(adminInfo.Org.Id, 10)
redis.Set(keyFour, "", time.Second)
keyFive := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":his_advices_list_all"
redis.Set(keyFive, "", time.Second)
defer redis.Close()
}
if err == nil {
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
"advice": advices,
})
} else {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
return
}
}
return
}
func (c *PatientApiController) EditAssessmentBeforeDislysis() {
id, _ := c.GetInt64("patient", 0)
assessmentDate := c.GetString("assessment_date", "")
if id <= 0 || len(assessmentDate) != 10 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
timeLayout := "2006-01-02"
loc, _ := time.LoadLocation("Local")
theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", assessmentDate+" 00:00:00", loc)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
theAssessmentDateTime := theTime.Unix()
adminUserInfo := c.GetMobileAdminUserInfo()
patient, _ := service.FindPatientById(adminUserInfo.Org.Id, id)
if patient.ID == 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
return
}
theEvaluation, getPEErr := service.MobileGetPredialysisEvaluationSeven(adminUserInfo.Org.Id, id, theAssessmentDateTime)
if getPEErr != nil {
c.ErrorLog("获取透前评估失败:%v", getPEErr)
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
return
}
template, _ := service.GetOrgInfoTemplate(adminUserInfo.Org.Id)
//templateInfo,_ := service.GetOrgInfoTemplate(adminUserInfo.Org.Id)
appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)
var evaluation models.PredialysisEvaluation
if theEvaluation != nil {
evaluation = *theEvaluation
}
code := predialysisEvaluationFormData(&evaluation, c.Ctx.Input.RequestBody)
if code > 0 {
c.ServeFailJSONWithSGJErrorCode(code)
return
}
if theEvaluation == nil {
evaluation.CreatedTime = time.Now().Unix()
evaluation.Status = 1
evaluation.AssessmentDate = theAssessmentDateTime
evaluation.PatientId = id
evaluation.UserOrgId = adminUserInfo.Org.Id
if appRole.UserType == 2 || appRole.UserType == 1 {
evaluation.AssessmentDoctor = adminUserInfo.AdminUser.Id
evaluation.AssessmentTime = time.Now().Unix()
} else {
evaluation.Creater = adminUserInfo.AdminUser.Id
}
} else {
evaluation.UpdatedTime = time.Now().Unix()
evaluation.Evaluator = adminUserInfo.AdminUser.Id
if appRole.UserType == 2 || appRole.UserType == 1 {
evaluation.AssessmentDoctor = adminUserInfo.AdminUser.Id
evaluation.AssessmentTime = time.Now().Unix()
} else {
evaluation.Modifier = adminUserInfo.AdminUser.Id
if evaluation.Creater == 0 {
evaluation.Creater = adminUserInfo.AdminUser.Id
}
}
}
//新增逻辑
var dewater_amount float64
dewater_amount = 0
if evaluation.DryWeight > 0 {
dewater_amount = evaluation.WeightBefore - evaluation.DryWeight - evaluation.AdditionalWeight
if template.TemplateId == 17 || template.TemplateId == 22 || template.TemplateId == 21 || template.TemplateId == 26 || template.TemplateId == 34 || template.TemplateId == 32 || adminUserInfo.Org.Id == 10469 || adminUserInfo.Org.Id == 3877 {
dewater_amount = dewater_amount * 1000
}
if dewater_amount <= 0 {
dewater_amount = 0
}
} else {
dewater_amount = 0
}
// 计算透析处方的相关超滤量
schedual, _ := service.MobileGetSchedualDetailSix(adminUserInfo.Org.Id, patient.ID, theAssessmentDateTime)
lastDialysisPrescription, _ := service.MobileGetLastDialysisPrescription(patient.ID, adminUserInfo.Org.Id)
var lastDialysisPrescribe *models.DialysisPrescription
var dialysisSolution *models.DialysisSolution
var dialysisPrescribe *models.DialysisPrescription
var system_dialysisPrescribe *models.SystemPrescription
var mode_id int64
dialysisPrescribe, _ = service.MobileGetDialysisPrescribe(adminUserInfo.Org.Id, id, theAssessmentDateTime)
lastDialysisPrescribe, _ = service.MobileGetLastDialysisPrescribeByModeIdSix(adminUserInfo.Org.Id, id, schedual.ModeId)
if schedual != nil {
// 获取透析模版
dialysisSolution, _ = service.MobileGetDialysisSolutionByModeIdSix(adminUserInfo.Org.Id, id, schedual.ModeId)
system_dialysisPrescribe, _ = service.MobileGetSystemDialysisPrescribeByModeIdSix(adminUserInfo.Org.Id, schedual.ModeId)
mode_id = schedual.ModeId
} else {
// 获取透析模版
dialysisSolution, _ = service.MobileGetDialysisSolution(adminUserInfo.Org.Id, id)
if dialysisPrescribe == nil && dialysisSolution != nil {
mode_id = dialysisSolution.ModeId
}
if dialysisPrescribe == nil && dialysisSolution == nil {
mode_id = 0
}
}
// 插入透析处方
if dialysisPrescribe == nil && dialysisSolution != nil {
var newprescribe models.DialysisPrescription
newprescribe.UserOrgId = dialysisSolution.UserOrgId
newprescribe.PatientId = dialysisSolution.PatientId
newprescribe.Anticoagulant = dialysisSolution.Anticoagulant
newprescribe.AnticoagulantShouji = dialysisSolution.AnticoagulantShouji
newprescribe.AnticoagulantWeichi = dialysisSolution.AnticoagulantWeichi
newprescribe.AnticoagulantZongliang = dialysisSolution.AnticoagulantZongliang
newprescribe.AnticoagulantGaimingcheng = dialysisSolution.AnticoagulantGaimingcheng
newprescribe.AnticoagulantGaijiliang = dialysisSolution.AnticoagulantGaijiliang
newprescribe.ModeId = dialysisSolution.ModeId
newprescribe.DialysisDuration = dialysisSolution.DialysisDuration
newprescribe.ReplacementWay = dialysisSolution.ReplacementWay
newprescribe.HemodialysisMachine = dialysisSolution.HemodialysisMachine
newprescribe.BloodFilter = dialysisSolution.BloodFilter
newprescribe.PerfusionApparatus = dialysisSolution.PerfusionApparatus
newprescribe.BloodFlowVolume = dialysisSolution.BloodFlowVolume
newprescribe.DisplaceLiqui = dialysisSolution.DisplaceLiqui
newprescribe.Glucose = dialysisSolution.Glucose
newprescribe.DialysateFlow = dialysisSolution.DialysateFlow
newprescribe.Kalium = dialysisSolution.Kalium
newprescribe.Sodium = dialysisSolution.Sodium
newprescribe.Calcium = dialysisSolution.Calcium
newprescribe.Bicarbonate = dialysisSolution.Bicarbonate
newprescribe.DialysateTemperature = dialysisSolution.DialysateTemperature
newprescribe.Conductivity = dialysisSolution.Conductivity
newprescribe.BodyFluid = dialysisSolution.BodyFluid
newprescribe.SpecialMedicine = dialysisSolution.SpecialMedicine
newprescribe.SpecialMedicineOther = dialysisSolution.SpecialMedicineOther
newprescribe.DisplaceLiquiPart = dialysisSolution.DisplaceLiquiPart
newprescribe.DisplaceLiquiValue = dialysisSolution.DisplaceLiquiValue
newprescribe.BloodAccess = dialysisSolution.BloodAccess
newprescribe.Ultrafiltration = dialysisSolution.Ultrafiltration
newprescribe.DialysisDurationHour = dialysisSolution.DialysisDurationHour
newprescribe.DialysisDurationMinute = dialysisSolution.DialysisDurationMinute
newprescribe.TargetUltrafiltration = dialysisSolution.TargetUltrafiltration
newprescribe.DialysateFormulation = dialysisSolution.DialysateFormulation
newprescribe.Dialyzer = dialysisSolution.Dialyzer
newprescribe.ReplacementTotal = dialysisSolution.ReplacementTotal
newprescribe.DialyzerPerfusionApparatus = dialysisSolution.DialyzerPerfusionApparatus
newprescribe.BodyFluidOther = dialysisSolution.BodyFluidOther
newprescribe.TargetKtv = dialysisSolution.TargetKtv
newprescribe.CreatedTime = time.Now().Unix()
newprescribe.UpdatedTime = time.Now().Unix()
newprescribe.RecordDate = theAssessmentDateTime
newprescribe.DewaterAmount = dewater_amount
newprescribe.TargetUltrafiltration = dewater_amount
newprescribe.Status = 1
newprescribe.DialysisDialyszers = dialysisSolution.DialysisDialyszers
newprescribe.DialysisIrrigation = dialysisSolution.DialysisIrrigation
newprescribe.Remark = lastDialysisPrescription.Remark
_, dialysisPrescription := service.FindDialysisPrescriptionByReordDate(id, theAssessmentDateTime, adminUserInfo.Org.Id)
newprescribe.ID = dialysisPrescription.ID
if dialysisPrescription.ID == 0 {
if adminUserInfo.Org.Id == 10340 {
newprescribe.Sodium = 138
newprescribe.Bicarbonate = 31.1
newprescribe.DialysateFlow = 500
}
err := service.AddSigleRecord(&newprescribe)
//获取key,清空redis
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
redis := service.RedisClient()
//清空key 值
redis.Set(key, "", time.Second)
keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
//清空key 值
redis.Set(keyOne, "", time.Second)
keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
//清空key 值
redis.Set(keyTwo, "", time.Second)
keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
redis.Set(keySix, "", time.Second)
keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
redis.Set(keySeven, "", time.Second)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
}
} else {
if adminUserInfo.Org.Id == 10340 {
newprescribe.Sodium = 138
newprescribe.Bicarbonate = 31.1
newprescribe.DialysateFlow = 500
}
err := service.UpDateDialysisPrescription(&newprescribe)
//获取key,清空redis
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
redis := service.RedisClient()
//清空key 值
redis.Set(key, "", time.Second)
keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
//清空key 值
redis.Set(keyOne, "", time.Second)
keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
//清空key 值
redis.Set(keyTwo, "", time.Second)
keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
redis.Set(keySix, "", time.Second)
keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
redis.Set(keySeven, "", time.Second)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
}
}
}
if dialysisPrescribe == nil && dialysisSolution == nil {
if lastDialysisPrescribe != nil {
var newprescribe models.DialysisPrescription
newprescribe.UserOrgId = lastDialysisPrescribe.UserOrgId
newprescribe.PatientId = lastDialysisPrescribe.PatientId
newprescribe.Anticoagulant = lastDialysisPrescribe.Anticoagulant
newprescribe.AnticoagulantShouji = lastDialysisPrescribe.AnticoagulantShouji
newprescribe.AnticoagulantWeichi = lastDialysisPrescribe.AnticoagulantWeichi
newprescribe.AnticoagulantZongliang = lastDialysisPrescribe.AnticoagulantZongliang
newprescribe.AnticoagulantGaimingcheng = lastDialysisPrescribe.AnticoagulantGaimingcheng
newprescribe.AnticoagulantGaijiliang = lastDialysisPrescribe.AnticoagulantGaijiliang
newprescribe.ModeId = lastDialysisPrescribe.ModeId
newprescribe.DialysisDuration = lastDialysisPrescribe.DialysisDuration
newprescribe.ReplacementWay = lastDialysisPrescribe.ReplacementWay
newprescribe.HemodialysisMachine = lastDialysisPrescribe.HemodialysisMachine
newprescribe.BloodFilter = lastDialysisPrescribe.BloodFilter
newprescribe.PerfusionApparatus = lastDialysisPrescribe.PerfusionApparatus
newprescribe.BloodFlowVolume = lastDialysisPrescribe.BloodFlowVolume
newprescribe.DisplaceLiqui = lastDialysisPrescribe.DisplaceLiqui
newprescribe.Glucose = lastDialysisPrescribe.Glucose
newprescribe.DialysateFlow = lastDialysisPrescribe.DialysateFlow
newprescribe.Kalium = lastDialysisPrescribe.Kalium
newprescribe.Sodium = lastDialysisPrescribe.Sodium
newprescribe.Calcium = lastDialysisPrescribe.Calcium
newprescribe.Bicarbonate = lastDialysisPrescribe.Bicarbonate
newprescribe.DialysateTemperature = lastDialysisPrescribe.DialysateTemperature
newprescribe.Conductivity = lastDialysisPrescribe.Conductivity
newprescribe.BodyFluid = lastDialysisPrescribe.BodyFluid
newprescribe.SpecialMedicine = lastDialysisPrescribe.SpecialMedicine
newprescribe.SpecialMedicineOther = lastDialysisPrescribe.SpecialMedicineOther
newprescribe.DisplaceLiquiPart = lastDialysisPrescribe.DisplaceLiquiPart
newprescribe.DisplaceLiquiValue = lastDialysisPrescribe.DisplaceLiquiValue
newprescribe.BloodAccess = lastDialysisPrescribe.BloodAccess
newprescribe.Ultrafiltration = lastDialysisPrescribe.Ultrafiltration
newprescribe.DialysisDurationHour = lastDialysisPrescribe.DialysisDurationHour
newprescribe.DialysisDurationMinute = lastDialysisPrescribe.DialysisDurationMinute
newprescribe.DialysateFormulation = lastDialysisPrescribe.DialysateFormulation
newprescribe.Dialyzer = lastDialysisPrescribe.Dialyzer
newprescribe.ReplacementTotal = lastDialysisPrescribe.ReplacementTotal
newprescribe.DialyzerPerfusionApparatus = lastDialysisPrescribe.DialyzerPerfusionApparatus
newprescribe.BodyFluidOther = lastDialysisPrescribe.BodyFluidOther
newprescribe.TargetKtv = lastDialysisPrescribe.TargetKtv
newprescribe.CreatedTime = time.Now().Unix()
newprescribe.UpdatedTime = time.Now().Unix()
newprescribe.RecordDate = theAssessmentDateTime
newprescribe.DewaterAmount = dewater_amount
newprescribe.TargetUltrafiltration = dewater_amount
newprescribe.Status = 1
newprescribe.DialysisIrrigation = lastDialysisPrescribe.DialysisIrrigation
newprescribe.DialysisDialyszers = lastDialysisPrescribe.DialysisDialyszers
newprescribe.Remark = lastDialysisPrescription.Remark
_, dialysisPrescription := service.FindDialysisPrescriptionByReordDate(id, theAssessmentDateTime, adminUserInfo.Org.Id)
newprescribe.ID = dialysisPrescription.ID
if dialysisPrescription.ID == 0 {
if adminUserInfo.Org.Id == 10340 {
newprescribe.Sodium = 138
newprescribe.Bicarbonate = 31.1
newprescribe.DialysateFlow = 500
}
err := service.AddSigleRecord(&newprescribe)
//获取key,清空redis
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
redis := service.RedisClient()
//清空key 值
redis.Set(key, "", time.Second)
keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
//清空key 值
redis.Set(keyOne, "", time.Second)
keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
//清空key 值
redis.Set(keyTwo, "", time.Second)
keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
redis.Set(keySix, "", time.Second)
keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
redis.Set(keySeven, "", time.Second)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
}
} else {
err := service.UpDateDialysisPrescription(&newprescribe)
//获取key,清空redis
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
redis := service.RedisClient()
//清空key 值
redis.Set(key, "", time.Second)
keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
//清空key 值
redis.Set(keyOne, "", time.Second)
keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
//清空key 值
redis.Set(keyTwo, "", time.Second)
keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
redis.Set(keySix, "", time.Second)
keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
redis.Set(keySeven, "", time.Second)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
}
}
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
}
} else if system_dialysisPrescribe != nil {
var newprescribe models.DialysisPrescription
newprescribe.UserOrgId = system_dialysisPrescribe.UserOrgId
newprescribe.PatientId = id
newprescribe.Anticoagulant = system_dialysisPrescribe.Anticoagulant
newprescribe.AnticoagulantShouji = system_dialysisPrescribe.AnticoagulantShouji
newprescribe.AnticoagulantWeichi = system_dialysisPrescribe.AnticoagulantWeichi
newprescribe.AnticoagulantZongliang = system_dialysisPrescribe.AnticoagulantZongliang
newprescribe.AnticoagulantGaimingcheng = system_dialysisPrescribe.AnticoagulantGaimingcheng
newprescribe.AnticoagulantGaijiliang = system_dialysisPrescribe.AnticoagulantGaijiliang
newprescribe.ModeId = system_dialysisPrescribe.ModeId
newprescribe.DialysisDuration = system_dialysisPrescribe.DialysisDuration
newprescribe.ReplacementWay = system_dialysisPrescribe.ReplacementWay
newprescribe.HemodialysisMachine = system_dialysisPrescribe.HemodialysisMachine
newprescribe.BloodFilter = system_dialysisPrescribe.BloodFilter
newprescribe.PerfusionApparatus = system_dialysisPrescribe.PerfusionApparatus
newprescribe.BloodFlowVolume = system_dialysisPrescribe.BloodFlowVolume
newprescribe.DisplaceLiqui = system_dialysisPrescribe.DisplaceLiqui
newprescribe.Glucose = system_dialysisPrescribe.Glucose
newprescribe.DialysateFlow = system_dialysisPrescribe.DialysateFlow
newprescribe.Kalium = system_dialysisPrescribe.Kalium
newprescribe.Sodium = system_dialysisPrescribe.Sodium
newprescribe.Calcium = system_dialysisPrescribe.Calcium
newprescribe.Bicarbonate = system_dialysisPrescribe.Bicarbonate
newprescribe.DialysateTemperature = system_dialysisPrescribe.DialysateTemperature
newprescribe.Conductivity = system_dialysisPrescribe.Conductivity
newprescribe.BodyFluid = system_dialysisPrescribe.BodyFluid
newprescribe.SpecialMedicine = system_dialysisPrescribe.SpecialMedicine
newprescribe.SpecialMedicineOther = system_dialysisPrescribe.SpecialMedicineOther
newprescribe.DisplaceLiquiPart = system_dialysisPrescribe.DisplaceLiquiPart
newprescribe.DisplaceLiquiValue = system_dialysisPrescribe.DisplaceLiquiValue
newprescribe.BloodAccess = system_dialysisPrescribe.BloodAccess
newprescribe.Ultrafiltration = system_dialysisPrescribe.Ultrafiltration
newprescribe.DialysisDurationHour = system_dialysisPrescribe.DialysisDurationHour
newprescribe.DialysisDurationMinute = system_dialysisPrescribe.DialysisDurationMinute
newprescribe.DialysateFormulation = system_dialysisPrescribe.DialysateFormulation
newprescribe.Dialyzer = system_dialysisPrescribe.Dialyzer
newprescribe.ReplacementTotal = system_dialysisPrescribe.ReplacementTotal
newprescribe.DialyzerPerfusionApparatus = system_dialysisPrescribe.DialyzerPerfusionApparatus
newprescribe.BodyFluidOther = system_dialysisPrescribe.BodyFluidOther
newprescribe.TargetKtv = system_dialysisPrescribe.TargetKtv
newprescribe.CreatedTime = time.Now().Unix()
newprescribe.UpdatedTime = time.Now().Unix()
newprescribe.RecordDate = theAssessmentDateTime
newprescribe.DewaterAmount = dewater_amount
newprescribe.TargetUltrafiltration = dewater_amount
newprescribe.Status = 1
newprescribe.DialysisDialyszers = system_dialysisPrescribe.DialysisDialyszers
newprescribe.DialysisIrrigation = system_dialysisPrescribe.DialysisIrrigation
newprescribe.Remark = lastDialysisPrescription.Remark
_, dialysisPrescription := service.FindDialysisPrescriptionByReordDate(id, theAssessmentDateTime, adminUserInfo.Org.Id)
newprescribe.ID = dialysisPrescription.ID
if dialysisPrescription.ID == 0 {
if adminUserInfo.Org.Id == 10340 {
newprescribe.Sodium = 138
newprescribe.Bicarbonate = 31.1
newprescribe.DialysateFlow = 500
}
err := service.AddSigleRecord(&newprescribe)
//获取key,清空redis
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
redis := service.RedisClient()
//清空key 值
redis.Set(key, "", time.Second)
keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
//清空key 值
redis.Set(keyOne, "", time.Second)
keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
//清空key 值
redis.Set(keyTwo, "", time.Second)
keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
redis.Set(keySix, "", time.Second)
keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
redis.Set(keySeven, "", time.Second)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
}
} else {
if adminUserInfo.Org.Id == 10340 {
newprescribe.Sodium = 138
newprescribe.Bicarbonate = 31.1
newprescribe.DialysateFlow = 500
}
err := service.UpDateDialysisPrescription(&newprescribe)
//获取key,清空redis
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
redis := service.RedisClient()
//清空key 值
redis.Set(key, "", time.Second)
keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
//清空key 值
redis.Set(keyOne, "", time.Second)
keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
//清空key 值
redis.Set(keyTwo, "", time.Second)
keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
redis.Set(keySix, "", time.Second)
keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
redis.Set(keySeven, "", time.Second)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
}
}
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
}
} else {
var newprescribe models.DialysisPrescription
newprescribe.UserOrgId = adminUserInfo.Org.Id
newprescribe.PatientId = id
newprescribe.ModeId = mode_id
newprescribe.CreatedTime = time.Now().Unix()
newprescribe.UpdatedTime = time.Now().Unix()
newprescribe.RecordDate = theAssessmentDateTime
newprescribe.DewaterAmount = dewater_amount
newprescribe.TargetUltrafiltration = dewater_amount
newprescribe.Status = 1
_, dialysisPrescription := service.FindDialysisPrescriptionByReordDate(id, theAssessmentDateTime, adminUserInfo.Org.Id)
newprescribe.ID = dialysisPrescription.ID
if dialysisPrescription.ID == 0 {
if adminUserInfo.Org.Id == 10340 {
newprescribe.Sodium = 138
newprescribe.Bicarbonate = 31.1
newprescribe.DialysateFlow = 500
}
err := service.AddSigleRecord(&newprescribe)
//获取key,清空redis
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
redis := service.RedisClient()
//清空key 值
redis.Set(key, "", time.Second)
keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
//清空key 值
redis.Set(keyOne, "", time.Second)
keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
//清空key 值
redis.Set(keyTwo, "", time.Second)
keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
redis.Set(keySix, "", time.Second)
keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
redis.Set(keySeven, "", time.Second)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
}
} else {
if adminUserInfo.Org.Id == 10340 {
newprescribe.Sodium = 138
newprescribe.Bicarbonate = 31.1
newprescribe.DialysateFlow = 500
}
err := service.UpDateDialysisPrescription(&newprescribe)
//获取key,清空redis
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
redis := service.RedisClient()
//清空key 值
redis.Set(key, "", time.Second)
keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
//清空key 值
redis.Set(keyOne, "", time.Second)
keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
//清空key 值
redis.Set(keyTwo, "", time.Second)
keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
redis.Set(keySix, "", time.Second)
keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
redis.Set(keySeven, "", time.Second)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
}
}
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
}
}
}
// 手动修改透前评估的时候，如果透析处方已经存在，则不修改对应的透析处方
// if dialysisPrescribe != nil {
// dialysisPrescribe.UpdatedTime = time.Now().Unix()
// dialysisPrescribe.RecordDate = theAssessmentDateTime
// dialysisPrescribe.DewaterAmount = dewater_amount
// dialysisPrescribe.TargetUltrafiltration = dewater_amount
// dialysisPrescribe.Status = 1
// updateErr := service.UpDateDialysisPrescription(dialysisPrescribe)
// if updateErr != nil {
// c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
// }
// }
err = service.UpadatePredialysisEvaluation(&evaluation)
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":assessment_before_dislysis"
redis := service.RedisClient()
defer redis.Close()
//清空key 值
redis.Set(key, "", time.Second)
keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":assessment_befores_list_all"
redis.Set(keyOne, "", time.Second)
keyTwo := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
redis.Set(keyTwo, "", time.Second)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDBUpdate)
return
}
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
"evaluation": evaluation,
})
return
}
func defaultSolutionFormData(solution *models.DialysisSolution, data []byte, method string) (code int) {
dataBody := make(map[string]interface{}, 0)
err := json.Unmarshal(data, &dataBody)
utils.InfoLog(string(data))
if err != nil {
utils.ErrorLog(err.Error())
code = enums.ErrorCodeParamWrong
return
}
// if method == "create" {
if dataBody["mode"] == nil || reflect.TypeOf(dataBody["mode"]).String() != "float64" {
utils.ErrorLog("mode")
code = enums.ErrorCodeParamWrong
return
}
mode := int64(dataBody["mode"].(float64))
if mode <= 0 {
utils.ErrorLog("mode <= 0")
code = enums.ErrorCodeParamWrong
return
}
solution.ModeId = mode
if dataBody["mode_name"] == nil || reflect.TypeOf(dataBody["mode_name"]).String() != "string" {
utils.ErrorLog("mode_name")
code = enums.ErrorCodeParamWrong
return
}
modeName, _ := dataBody["mode_name"].(string)
if len(modeName) == 0 {
utils.ErrorLog("len(mode_name) == 0")
code = enums.ErrorCodeParamWrong
return
}
solution.ModeName = modeName
solution.Name = modeName
// }
if dataBody["dialysis_duration"] != nil && reflect.TypeOf(dataBody["dialysis_duration"]).String() == "string" {
dialysisDuration, _ := strconv.ParseFloat(dataBody["dialysis_duration"].(string), 64)
solution.DialysisDuration = dialysisDuration
}
if dataBody["dialysis_duration"] != nil {
if reflect.TypeOf(dataBody["dialysis_duration"]).String() == "string" {
dialysisDuration, _ := strconv.ParseFloat(dataBody["dialysis_duration"].(string), 64)
solution.DialysisDuration = dialysisDuration
} else if reflect.TypeOf(dataBody["dialysis_duration"]).String() == "float64" {
dialysisDuration := dataBody["dialysis_duration"].(float64)
solution.DialysisDuration = dialysisDuration
}
}
if dataBody["dialyzer"] != nil && reflect.TypeOf(dataBody["dialyzer"]).String() == "float64" {
dialyzer := int64(dataBody["dialyzer"].(float64))
solution.Dialyzer = dialyzer
}
if dataBody["perfusion_apparatus"] != nil && reflect.TypeOf(dataBody["perfusion_apparatus"]).String() == "float64" {
perfusionApparatus := int64(dataBody["perfusion_apparatus"].(float64))
solution.PerfusionApparatus = perfusionApparatus
}
if dataBody["blood_flow_volume"] != nil {
if reflect.TypeOf(dataBody["blood_flow_volume"]).String() == "string" {
bloodFlowVolume, _ := strconv.ParseFloat(dataBody["blood_flow_volume"].(string), 64)
solution.BloodFlowVolume = bloodFlowVolume
} else if reflect.TypeOf(dataBody["blood_flow_volume"]).String() == "float64" {
bloodFlowVolume := dataBody["blood_flow_volume"].(float64)
solution.BloodFlowVolume = bloodFlowVolume
}
}
if dataBody["hemodialysis_machine"] != nil && reflect.TypeOf(dataBody["hemodialysis_machine"]).String() == "float64" {
hemodialysisMachine := int64(dataBody["hemodialysis_machine"].(float64))
solution.HemodialysisMachine = hemodialysisMachine
}
if dataBody["dewater"] != nil {
if reflect.TypeOf(dataBody["dewater"]).String() == "string" {
dewater, _ := strconv.ParseFloat(dataBody["dewater"].(string), 64)
solution.Dewater = dewater
} else if reflect.TypeOf(dataBody["dewater"]).String() == "float64" {
dewater := dataBody["dewater"].(float64)
solution.Dewater = dewater
}
}
if dataBody["replacement_total"] != nil {
if reflect.TypeOf(dataBody["replacement_total"]).String() == "string" {
replacementTotal, _ := strconv.ParseFloat(dataBody["replacement_total"].(string), 64)
solution.ReplacementTotal = replacementTotal
} else if reflect.TypeOf(dataBody["replacement_total"]).String() == "float64" {
replacementTotal := dataBody["replacement_total"].(float64)
solution.ReplacementTotal = replacementTotal
}
}
if dataBody["displace_liqui"] != nil {
if reflect.TypeOf(dataBody["displace_liqui"]).String() == "string" {
displaceLiqui, _ := strconv.ParseFloat(dataBody["displace_liqui"].(string), 64)
solution.DisplaceLiqui = displaceLiqui
} else if reflect.TypeOf(dataBody["displace_liqui"]).String() == "float64" {
displaceLiqui := dataBody["displace_liqui"].(float64)
solution.DisplaceLiqui = displaceLiqui
}
}
if dataBody["replacement_way"] != nil && reflect.TypeOf(dataBody["replacement_way"]).String() == "float64" {
replacementWay := int64(dataBody["replacement_way"].(float64))
solution.ReplacementWay = replacementWay
}
if dataBody["anticoagulant"] != nil && reflect.TypeOf(dataBody["anticoagulant"]).String() == "float64" {
anticoagulant := int64(dataBody["anticoagulant"].(float64))
solution.Anticoagulant = anticoagulant
}
if dataBody["anticoagulant_shouji"] != nil {
if reflect.TypeOf(dataBody["anticoagulant_shouji"]).String() == "string" {
anticoagulantShouji, _ := strconv.ParseFloat(dataBody["anticoagulant_shouji"].(string), 64)
solution.AnticoagulantShouji = anticoagulantShouji
} else if reflect.TypeOf(dataBody["anticoagulant_shouji"]).String() == "float64" {
anticoagulantShouji := dataBody["anticoagulant_shouji"].(float64)
solution.AnticoagulantShouji = anticoagulantShouji
}
}
if dataBody["anticoagulant_weichi"] != nil {
if reflect.TypeOf(dataBody["anticoagulant_weichi"]).String() == "string" {
anticoagulantWeichi, _ := strconv.ParseFloat(dataBody["anticoagulant_weichi"].(string), 64)
solution.AnticoagulantWeichi = anticoagulantWeichi
} else if reflect.TypeOf(dataBody["anticoagulant_weichi"]).String() == "float64" {
anticoagulantWeichi := dataBody["anticoagulant_weichi"].(float64)
solution.AnticoagulantWeichi = anticoagulantWeichi
}
}
if dataBody["anticoagulant_zongliang"] != nil {
if reflect.TypeOf(dataBody["anticoagulant_zongliang"]).String() == "string" {
anticoagulantZongliang, _ := strconv.ParseFloat(dataBody["anticoagulant_zongliang"].(string), 64)
solution.AnticoagulantZongliang = anticoagulantZongliang
} else if reflect.TypeOf(dataBody["anticoagulant_zongliang"]).String() == "float64" {
anticoagulantZongliang := dataBody["anticoagulant_zongliang"].(float64)
solution.AnticoagulantZongliang = anticoagulantZongliang
}
}
if dataBody["anticoagulant_gaimingcheng"] != nil && reflect.TypeOf(dataBody["anticoagulant_gaimingcheng"]).String() == "string" {
anticoagulantGaimingcheng, _ := dataBody["anticoagulant_gaimingcheng"].(string)
solution.AnticoagulantGaimingcheng = anticoagulantGaimingcheng
}
if dataBody["anticoagulant_gaijiliang"] != nil && reflect.TypeOf(dataBody["anticoagulant_gaijiliang"]).String() == "string" {
anticoagulantGaijiliang, _ := dataBody["anticoagulant_gaijiliang"].(string)
solution.AnticoagulantGaijiliang = anticoagulantGaijiliang
}
if dataBody["kalium"] != nil {
if reflect.TypeOf(dataBody["kalium"]).String() == "string" {
kalium, _ := strconv.ParseFloat(dataBody["kalium"].(string), 64)
solution.Kalium = kalium
} else if reflect.TypeOf(dataBody["kalium"]).String() == "float64" {
kalium := dataBody["kalium"].(float64)
solution.Kalium = kalium
}
}
if dataBody["sodium"] != nil {
if reflect.TypeOf(dataBody["sodium"]).String() == "string" {
sodium, _ := strconv.ParseFloat(dataBody["sodium"].(string), 64)
solution.Sodium = sodium
} else if reflect.TypeOf(dataBody["sodium"]).String() == "float64" {
sodium := dataBody["sodium"].(float64)
solution.Sodium = sodium
}
}
if dataBody["calcium"] != nil && reflect.TypeOf(dataBody["calcium"]).String() == "string" {
if reflect.TypeOf(dataBody["calcium"]).String() == "string" {
calcium, _ := strconv.ParseFloat(dataBody["calcium"].(string), 64)
solution.Calcium = calcium
} else if reflect.TypeOf(dataBody["calcium"]).String() == "float64" {
calcium := dataBody["calcium"].(float64)
solution.Calcium = calcium
}
}
if dataBody["bicarbonate"] != nil {
if reflect.TypeOf(dataBody["bicarbonate"]).String() == "string" {
bicarbonate, _ := strconv.ParseFloat(dataBody["bicarbonate"].(string), 64)
solution.Bicarbonate = bicarbonate
} else if reflect.TypeOf(dataBody["bicarbonate"]).String() == "float64" {
bicarbonate := dataBody["bicarbonate"].(float64)
solution.Bicarbonate = bicarbonate
}
}
if dataBody["glucose"] != nil {
if reflect.TypeOf(dataBody["glucose"]).String() == "string" {
glucose, _ := strconv.ParseFloat(dataBody["glucose"].(string), 64)
solution.Glucose = glucose
} else if reflect.TypeOf(dataBody["glucose"]).String() == "float64" {
glucose := dataBody["glucose"].(float64)
solution.Glucose = glucose
}
}
// if dataBody["dry_weight"] != nil {
// if reflect.TypeOf(dataBody["dry_weight"]).String() == "string" {
// dryWeight, _ := strconv.ParseFloat(dataBody["dry_weight"].(string), 64)
// solution.DryWeight = dryWeight
// } else if reflect.TypeOf(dataBody["dry_weight"]).String() == "float64" {
// dryWeight := dataBody["dry_weight"].(float64)
// solution.DryWeight = dryWeight
// }
// }
if dataBody["dialysate_flow"] != nil {
if reflect.TypeOf(dataBody["dialysate_flow"]).String() == "string" {
dialysateFlow, _ := strconv.ParseFloat(dataBody["dialysate_flow"].(string), 64)
solution.DialysateFlow = dialysateFlow
} else if reflect.TypeOf(dataBody["dialysate_flow"]).String() == "float64" {
dialysateFlow := dataBody["dialysate_flow"].(float64)
solution.DialysateFlow = dialysateFlow
}
}
if dataBody["dialysate_temperature"] != nil {
if reflect.TypeOf(dataBody["dialysate_temperature"]).String() == "string" {
dialysateTemperature, _ := strconv.ParseFloat(dataBody["dialysate_temperature"].(string), 64)
solution.DialysateTemperature = dialysateTemperature
} else if reflect.TypeOf(dataBody["dialysate_temperature"]).String() == "float64" {
dialysateTemperature := dataBody["dialysate_temperature"].(float64)
solution.DialysateTemperature = dialysateTemperature
}
}
if dataBody["conductivity"] != nil {
if reflect.TypeOf(dataBody["conductivity"]).String() == "string" {
conductivity, _ := strconv.ParseFloat(dataBody["conductivity"].(string), 64)
solution.Conductivity = conductivity
} else if reflect.TypeOf(dataBody["conductivity"]).String() == "float64" {
conductivity := dataBody["conductivity"].(float64)
solution.Conductivity = conductivity
}
}
if dataBody["remark"] != nil && reflect.TypeOf(dataBody["remark"]).String() == "string" {
remark := dataBody["remark"].(string)
solution.Remark = remark
}
if dataBody["dialysis_duration_hour"] != nil {
if reflect.TypeOf(dataBody["dialysis_duration_hour"]).String() == "string" {
dialysisDurationHour, _ := strconv.ParseInt(dataBody["dialysis_duration_hour"].(string), 10, 64)
solution.DialysisDurationHour = dialysisDurationHour
} else if reflect.TypeOf(dataBody["dialysis_duration_hour"]).String() == "float64" {
dialysisDurationHour := dataBody["dialysis_duration_hour"].(float64)
solution.DialysisDurationHour = int64(dialysisDurationHour)
}
}
if dataBody["dialysis_duration_minute"] != nil {
if reflect.TypeOf(dataBody["dialysis_duration_minute"]).String() == "string" {
dialysisDurationMinute, _ := strconv.ParseInt(dataBody["dialysis_duration_minute"].(string), 10, 64)
solution.DialysisDurationMinute = dialysisDurationMinute
} else if reflect.TypeOf(dataBody["dialysis_duration_minute"]).String() == "float64" {
dialysisDurationMinute := dataBody["dialysis_duration_minute"].(float64)
solution.DialysisDurationMinute = int64(dialysisDurationMinute)
}
}
if dataBody["target_ultrafiltration"] != nil {
if reflect.TypeOf(dataBody["target_ultrafiltration"]).String() == "string" {
targetUltrafiltration, _ := strconv.ParseFloat(dataBody["target_ultrafiltration"].(string), 64)
solution.TargetUltrafiltration = targetUltrafiltration
} else if reflect.TypeOf(dataBody["target_ultrafiltration"]).String() == "float64" {
targetUltrafiltration := dataBody["target_ultrafiltration"].(float64)
solution.TargetUltrafiltration = targetUltrafiltration
}
}
if dataBody["dialysate_formulation"] != nil {
if reflect.TypeOf(dataBody["dialysate_formulation"]).String() == "string" {
dialysateFormulation, _ := strconv.ParseInt(dataBody["dialysate_formulation"].(string), 10, 64)
solution.DialysateFormulation = dialysateFormulation
} else if reflect.TypeOf(dataBody["dialysate_formulation"]).String() == "float64" {
dialysateFormulation := dataBody["dialysate_formulation"].(float64)
solution.DialysateFormulation = int64(dialysateFormulation)
}
}
return
}
func predialysisEvaluationFormData(evaluation *models.PredialysisEvaluation, data []byte) (code int) {
dataBody := make(map[string]interface{}, 0)
err := json.Unmarshal(data, &dataBody)
utils.InfoLog(string(data))
if err != nil {
utils.ErrorLog(err.Error())
code = enums.ErrorCodeParamWrong
return
}
if dataBody["weight_before"] != nil && reflect.TypeOf(dataBody["weight_before"]).String() == "string" {
weightVefore, _ := strconv.ParseFloat(dataBody["weight_before"].(string), 64)
evaluation.WeightBefore = weightVefore
}
// fmt.Println(dataBody["dry_weight"])
// fmt.Println(reflect.TypeOf(dataBody["dry_weight"]).String())
if dataBody["dry_weight"] != nil && reflect.TypeOf(dataBody["dry_weight"]).String() == "string" {
additionalWeight, _ := strconv.ParseFloat(dataBody["dry_weight"].(string), 64)
fmt.Println(additionalWeight)
evaluation.DryWeight = additionalWeight
}
if dataBody["additional_weight"] != nil && reflect.TypeOf(dataBody["additional_weight"]).String() == "string" {
additionalWeight, _ := strconv.ParseFloat(dataBody["additional_weight"].(string), 64)
fmt.Println(additionalWeight)
evaluation.AdditionalWeight = additionalWeight
}
if dataBody["temperature"] != nil && reflect.TypeOf(dataBody["temperature"]).String() == "string" {
Temperature, _ := strconv.ParseFloat(dataBody["temperature"].(string), 64)
evaluation.Temperature = Temperature
}
if dataBody["systolic_blood_pressure"] != nil && reflect.TypeOf(dataBody["systolic_blood_pressure"]).String() == "string" {
systolicBloodPressure, _ := strconv.ParseFloat(dataBody["systolic_blood_pressure"].(string), 64)
evaluation.SystolicBloodPressure = systolicBloodPressure
}
if dataBody["diastolic_blood_pressure"] != nil && reflect.TypeOf(dataBody["diastolic_blood_pressure"]).String() == "string" {
diastolicBloodPressure, _ := strconv.ParseFloat(dataBody["diastolic_blood_pressure"].(string), 64)
evaluation.DiastolicBloodPressure = diastolicBloodPressure
}
if dataBody["pulse_frequency"] != nil && reflect.TypeOf(dataBody["pulse_frequency"]).String() == "string" {
pulseFrequency, _ := strconv.ParseFloat(dataBody["pulse_frequency"].(string), 64)
evaluation.PulseFrequency = pulseFrequency
}
if dataBody["breathing_rate"] != nil && reflect.TypeOf(dataBody["breathing_rate"]).String() == "string" {
breathingRate := dataBody["breathing_rate"].(string)
evaluation.BreathingRate = breathingRate
}
if dataBody["last_post_dialysis"] != nil && reflect.TypeOf(dataBody["last_post_dialysis"]).String() == "string" {
lastPostDialysis, _ := dataBody["last_post_dialysis"].(string)
evaluation.LastPostDialysis = lastPostDialysis
}
if dataBody["dialysis_interphase"] != nil && reflect.TypeOf(dataBody["dialysis_interphase"]).String() == "string" {
dialysisInterphase, _ := dataBody["dialysis_interphase"].(string)
evaluation.DialysisInterphase = dialysisInterphase
}
if dataBody["symptom_before_dialysis"] != nil && reflect.TypeOf(dataBody["symptom_before_dialysis"]).String() == "string" {
symptomBeforeDialysis, _ := dataBody["symptom_before_dialysis"].(string)
evaluation.SymptomBeforeDialysis = symptomBeforeDialysis
}
if dataBody["catheter"] != nil && reflect.TypeOf(dataBody["catheter"]).String() == "string" {
catheter, _ := dataBody["catheter"].(string)
evaluation.Catheter = catheter
}
if dataBody["catheter_bend"] != nil && reflect.TypeOf(dataBody["catheter_bend"]).String() == "float64" {
catheter_bend := int(dataBody["catheter_bend"].(float64))
evaluation.CatheterBend = catheter_bend
}
if dataBody["complication"] != nil && reflect.TypeOf(dataBody["complication"]).String() == "string" {
Complication, _ := dataBody["complication"].(string)
evaluation.Complication = Complication
}
if dataBody["remark"] != nil && reflect.TypeOf(dataBody["remark"]).String() == "string" {
remark := dataBody["remark"].(string)
evaluation.Remark = remark
}
if dataBody["machine_type"] != nil && reflect.TypeOf(dataBody["machine_type"]).String() == "string" {
machine_type := dataBody["machine_type"].(string)
evaluation.MachineType = machine_type
}
if dataBody["blood_access_part_id"] != nil && reflect.TypeOf(dataBody["blood_access_part_id"]).String() == "string" {
blood_access_part_id := dataBody["blood_access_part_id"].(string)
evaluation.BloodAccessPartId = blood_access_part_id
}
//if dataBody["blood_access_part_id"] != nil && reflect.TypeOf(dataBody["blood_access_part_id"]).String() == "float64" {
// blood_access_part_id := int64(dataBody["blood_access_part_id"].(float64))
// evaluation.BloodAccessPartId = blood_access_part_id
//}
if dataBody["blood_access_part_opera_id"] != nil && reflect.TypeOf(dataBody["blood_access_part_opera_id"]).String() == "float64" {
blood_access_part_opera_id := int64(dataBody["blood_access_part_opera_id"].(float64))
evaluation.BloodAccessPartOperaId = blood_access_part_opera_id
}
if dataBody["internal_fistula"] != nil && reflect.TypeOf(dataBody["internal_fistula"]).String() == "string" {
internal_fistula, _ := dataBody["internal_fistula"].(string)
evaluation.InternalFistula = internal_fistula
}
if dataBody["internal_fistula_skin"] != nil && reflect.TypeOf(dataBody["internal_fistula_skin"]).String() == "string" {
internal_fistula_skin := dataBody["internal_fistula_skin"].(string)
evaluation.InternalFistulaSkin = internal_fistula_skin
}
if dataBody["is_hemorrhage"] != nil && reflect.TypeOf(dataBody["is_hemorrhage"]).String() == "string" {
ishemorrhage, _ := dataBody["is_hemorrhage"].(string)
is_hemorrhage, _ := strconv.ParseInt(ishemorrhage, 10, 64)
evaluation.IsHemorrhage = is_hemorrhage
//if dataBody["is_hemorrhage"] != nil && reflect.TypeOf(dataBody["is_hemorrhage"]).String() == "float64" {
// is_hemorrhage := int64(dataBody["is_hemorrhage"].(float64))
// fmt.Println("is_hemorrhage2222222222222222",is_hemorrhage)
if is_hemorrhage != 1 && is_hemorrhage != 2 {
is_hemorrhage = 0
}
evaluation.IsHemorrhage = is_hemorrhage
if is_hemorrhage == 1 {
if dataBody["hemorrhage"] != nil && reflect.TypeOf(dataBody["hemorrhage"]).String() == "string" {
hemorrhage, _ := dataBody["hemorrhage"].(string)
evaluation.Hemorrhage = hemorrhage
}
if dataBody["hemorrhage_other"] != nil && reflect.TypeOf(dataBody["hemorrhage_other"]).String() == "string" {
hemorrhage_other, _ := dataBody["hemorrhage_other"].(string)
evaluation.HemorrhageOther = hemorrhage_other
}
}
} else {
evaluation.IsHemorrhage = 0
}
if dataBody["blood_access_internal_fistula"] != nil && reflect.TypeOf(dataBody["blood_access_internal_fistula"]).String() == "string" {
blood_access_internal_fistula, _ := dataBody["blood_access_internal_fistula"].(string)
evaluation.BloodAccessInternalFistula = blood_access_internal_fistula
}
if dataBody["internal_fistula_other"] != nil && reflect.TypeOf(dataBody["internal_fistula_other"]).String() == "string" {
internal_fistula_other, _ := dataBody["internal_fistula_other"].(string)
evaluation.InternalFistulaOther = internal_fistula_other
}
if dataBody["blood_access_noise"] != nil && reflect.TypeOf(dataBody["blood_access_noise"]).String() == "float64" {
blood_access_noise := int64(dataBody["blood_access_noise"].(float64))
evaluation.BloodAccessNoise = blood_access_noise
}
if dataBody["puncture_way"] != nil && reflect.TypeOf(dataBody["puncture_way"]).String() == "string" {
//puncture_way := int64(dataBody["puncture_way"].(float64))
puncture_way := dataBody["puncture_way"].(string)
evaluation.PunctureWay = puncture_way
}
if dataBody["venous_catheterization"] != nil && reflect.TypeOf(dataBody["venous_catheterization"]).String() == "float64" {
venous_catheterization := int64(dataBody["venous_catheterization"].(float64))
evaluation.VenousCatheterization = venous_catheterization
}
if dataBody["venous_catheterization_part"] != nil && reflect.TypeOf(dataBody["venous_catheterization_part"]).String() == "float64" {
venous_catheterization_part := int64(dataBody["venous_catheterization_part"].(float64))
evaluation.VenousCatheterizationPart = venous_catheterization_part
}
if dataBody["venous_catheterization_part_other"] != nil && reflect.TypeOf(dataBody["venous_catheterization_part_other"]).String() == "string" {
venous_catheterization_part_other, _ := dataBody["venous_catheterization_part_other"].(string)
evaluation.VenousCatheterizationPartOther = venous_catheterization_part_other
}
if dataBody["ductus_arantii"] != nil && reflect.TypeOf(dataBody["ductus_arantii"]).String() == "string" {
ductus_arantii, _ := dataBody["ductus_arantii"].(string)
evaluation.DuctusArantii = ductus_arantii
}
if dataBody["emergency_treatment"] != nil && reflect.TypeOf(dataBody["emergency_treatment"]).String() == "float64" {
emergency_treatment := int64(dataBody["emergency_treatment"].(float64))
evaluation.EmergencyTreatment = emergency_treatment
}
if dataBody["emergency_treatment_other"] != nil && reflect.TypeOf(dataBody["emergency_treatment_other"]).String() == "string" {
emergency_treatment_other, _ := dataBody["emergency_treatment_other"].(string)
evaluation.EmergencyTreatmentOther = emergency_treatment_other
}
if dataBody["dialysis_count"] != nil && reflect.TypeOf(dataBody["dialysis_count"]).String() == "string" {
dialysis_count, _ := dataBody["dialysis_count"].(string)
//count, _ := strconv.ParseInt(dialysis_count, 10, 64)
evaluation.DialysisCount = dialysis_count
}
if dataBody["is_infect"] != nil && reflect.TypeOf(dataBody["is_infect"]).String() == "string" {
is_infect, _ := dataBody["is_infect"].(string)
infect, _ := strconv.ParseInt(is_infect, 10, 64)
evaluation.IsInfect = infect
}
if dataBody["exposed"] != nil && reflect.TypeOf(dataBody["exposed"]).String() == "string" {
exposed, _ := strconv.ParseFloat(dataBody["exposed"].(string), 64)
evaluation.Exposed = exposed
}
if dataBody["skin"] != nil && reflect.TypeOf(dataBody["skin"]).String() == "string" {
skin, _ := dataBody["skin"].(string)
//skins, _ := strconv.ParseInt(skin, 10, 64)
evaluation.Skin = skin
}
if dataBody["skin_other"] != nil && reflect.TypeOf(dataBody["skin_other"]).String() == "string" {
skin_other, _ := dataBody["skin_other"].(string)
evaluation.SkinOther = skin_other
}
if dataBody["infect_other"] != nil && reflect.TypeOf(dataBody["infect_other"]).String() == "string" {
infect_other, _ := dataBody["infect_other"].(string)
evaluation.InfectOther = infect_other
}
if dataBody["ductus_arantii_other"] != nil && reflect.TypeOf(dataBody["ductus_arantii_other"]).String() == "string" {
ductus_arantii_other, _ := dataBody["ductus_arantii_other"].(string)
evaluation.DuctusArantiiOther = ductus_arantii_other
}
if dataBody["puncture_needle"] != nil && reflect.TypeOf(dataBody["puncture_needle"]).String() == "string" {
punctureNeedle, _ := dataBody["puncture_needle"].(string)
evaluation.PunctureNeedle = punctureNeedle
}
if dataBody["humor_excessive_symptom"] != nil && reflect.TypeOf(dataBody["humor_excessive_symptom"]).String() == "string" {
humor_excessive_symptom, _ := dataBody["humor_excessive_symptom"].(string)
evaluation.HumorExcessiveSymptom = humor_excessive_symptom
}
if dataBody["pinholing"] != nil && reflect.TypeOf(dataBody["pinholing"]).String() == "string" {
pinholing := dataBody["pinholing"].(string)
evaluation.Phinholing = pinholing
}
if dataBody["catheter_suture"] != nil && reflect.TypeOf(dataBody["catheter_suture"]).String() == "string" {
catheter_suture := dataBody["catheter_suture"].(string)
evaluation.CatheterSuture = catheter_suture
}
if dataBody["catheter_suture_other"] != nil && reflect.TypeOf(dataBody["catheter_suture_other"]).String() == "string" {
catheter_suture_other := dataBody["catheter_suture_other"].(string)
evaluation.CatheterSutureOther = catheter_suture_other
}
if dataBody["urine_volume"] != nil && reflect.TypeOf(dataBody["urine_volume"]).String() == "string" {
urine_volume, _ := strconv.ParseFloat(dataBody["urine_volume"].(string), 64)
evaluation.UrineVolume = urine_volume
}
if dataBody["edema"] != nil && reflect.TypeOf(dataBody["edema"]).String() == "string" {
edema := dataBody["edema"].(string)
evaluation.Edema = edema
}
if dataBody["special_treatment"] != nil && reflect.TypeOf(dataBody["special_treatment"]).String() == "string" {
specialTreatment := dataBody["special_treatment"].(string)
evaluation.SpecialTreatment = specialTreatment
}
if dataBody["catheter_maintenance"] != nil && reflect.TypeOf(dataBody["catheter_maintenance"]).String() == "string" {
catheter_maintenance := dataBody["catheter_maintenance"].(string)
evaluation.CatheterMaintenance = catheter_maintenance
}
if dataBody["thromubus_type"] != nil && reflect.TypeOf(dataBody["thromubus_type"]).String() == "float64" {
thromubusType := int64(dataBody["thromubus_type"].(float64))
evaluation.ThromubusType = thromubusType
}
if dataBody["thrombus_av"] != nil && reflect.TypeOf(dataBody["thrombus_av"]).String() == "string" {
thrombus_av := dataBody["thrombus_av"].(string)
evaluation.ThrombusAv = thrombus_av
}
if dataBody["thromubus_a"] != nil && reflect.TypeOf(dataBody["thromubus_a"]).String() == "string" {
thromubus_a := dataBody["thromubus_a"].(string)
evaluation.ThromubusA = thromubus_a
}
if dataBody["thromubus_v"] != nil && reflect.TypeOf(dataBody["thromubus_v"]).String() == "string" {
thromubus_v := dataBody["thromubus_v"].(string)
evaluation.ThromubusV = thromubus_v
}
if dataBody["dehydration"] != nil && reflect.TypeOf(dataBody["dehydration"]).String() == "string" {
dehydration := dataBody["dehydration"].(string)
evaluation.Dehydration = dehydration
}
if dataBody["period"] != nil && reflect.TypeOf(dataBody["period"]).String() == "float64" {
period := int64(dataBody["period"].(float64))
evaluation.Period = period
}
if dataBody["estimated_food_intake"] != nil && reflect.TypeOf(dataBody["estimated_food_intake"]).String() == "string" {
estimated_food_intake := dataBody["estimated_food_intake"].(string)
evaluation.EstimatedFoodIntake = estimated_food_intake
}
if dataBody["blood_pressure_during_dialysis"] != nil && reflect.TypeOf(dataBody["blood_pressure_during_dialysis"]).String() == "string" {
blood_pressure_during_dialysis := dataBody["blood_pressure_during_dialysis"].(string)
evaluation.BloodPressureDuringDialysis = blood_pressure_during_dialysis
}
if dataBody["pre_dialysis_drugs"] != nil && reflect.TypeOf(dataBody["pre_dialysis_drugs"]).String() == "string" {
pre_dialysis_drugs := dataBody["pre_dialysis_drugs"].(string)
evaluation.PreDialysisDrugs = pre_dialysis_drugs
}
if dataBody["urea_befor"] != nil && reflect.TypeOf(dataBody["urea_befor"]).String() == "string" {
urea_befor := dataBody["urea_befor"].(string)
evaluation.UreaBefor = urea_befor
}
if dataBody["suction"] != nil && reflect.TypeOf(dataBody["suction"]).String() == "string" {
suction := dataBody["suction"].(string)
evaluation.Suction = suction
}
if dataBody["weight_befor_remake"] != nil && reflect.TypeOf(dataBody["weight_befor_remake"]).String() == "string" {
weight_befor_remake := dataBody["weight_befor_remake"].(string)
evaluation.WeightBeforRemake = weight_befor_remake
}
if dataBody["height"] != nil && reflect.TypeOf(dataBody["height"]).String() == "string" {
height := dataBody["height"].(string)
evaluation.Height = height
}
if dataBody["age"] != nil && reflect.TypeOf(dataBody["age"]).String() == "string" {
age := dataBody["age"].(string)
evaluation.Age = age
}
if dataBody["his_department"] != nil && reflect.TypeOf(dataBody["his_department"]).String() == "string" {
his_department := dataBody["his_department"].(string)
evaluation.HisDepartment = his_department
}
if dataBody["his_bed"] != nil && reflect.TypeOf(dataBody["his_bed"]).String() == "string" {
his_bed := dataBody["his_bed"].(string)
evaluation.HisBed = his_bed
}
return
}
func adviceFormData(advice *models.DoctorAdvice, data []byte, action string) (code int) {
dataBody := make(map[string]interface{}, 0)
err := json.Unmarshal(data, &dataBody)
if err != nil {
utils.ErrorLog(err.Error())
code = enums.ErrorCodeParamWrong
return
}
timeLayout := "2006-01-02"
loc, _ := time.LoadLocation("Local")
isChild := false
if action == "create" {
if dataBody["advice_type"] == nil || reflect.TypeOf(dataBody["advice_type"]).String() != "float64" {
utils.ErrorLog("advice_type")
code = enums.ErrorCodeParamWrong
return
}
adviceType := int64(dataBody["advice_type"].(float64))
if adviceType != 1 && adviceType != 2 {
utils.ErrorLog("advice_type != 1&&2")
code = enums.ErrorCodeParamWrong
return
}
advice.AdviceType = adviceType
if dataBody["advice_date"] == nil || reflect.TypeOf(dataBody["advice_date"]).String() != "string" {
utils.ErrorLog("advice_date")
code = enums.ErrorCodeParamWrong
return
}
adviceDate, _ := dataBody["advice_date"].(string)
if len(adviceDate) == 0 {
utils.ErrorLog("len(adviceDate) == 0")
code = enums.ErrorCodeParamWrong
return
}
theTime, err := time.ParseInLocation(timeLayout, adviceDate, loc)
if err != nil {
utils.ErrorLog(err.Error())
code = enums.ErrorCodeParamWrong
return
}
advice.AdviceDate = theTime.Unix()
advice.RecordDate = theTime.Unix()
if dataBody["parent_id"] != nil && reflect.TypeOf(dataBody["parent_id"]).String() == "float64" {
parentId := int64(dataBody["parent_id"].(float64))
advice.ParentId = parentId
if parentId > 0 {
isChild = true
}
}
} else {
isChild = advice.ParentId > 0
}
if !isChild {
if dataBody["start_time"] == nil || reflect.TypeOf(dataBody["start_time"]).String() != "string" {
utils.ErrorLog("start_time")
code = enums.ErrorCodeParamWrong
return
}
startTime, _ := dataBody["start_time"].(string)
if len(startTime) == 0 {
utils.ErrorLog("len(start_time) == 0")
code = enums.ErrorCodeParamWrong
return
}
theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", startTime, loc)
if err != nil {
utils.ErrorLog(err.Error())
code = enums.ErrorCodeParamWrong
return
}
advice.StartTime = theTime.Unix()
if dataBody["delivery_way"] != nil && reflect.TypeOf(dataBody["delivery_way"]).String() == "string" {
deliveryWay, _ := dataBody["delivery_way"].(string)
advice.DeliveryWay = deliveryWay
}
if dataBody["execution_frequency"] != nil && reflect.TypeOf(dataBody["execution_frequency"]).String() == "string" {
executionFrequency, _ := dataBody["execution_frequency"].(string)
advice.ExecutionFrequency = executionFrequency
}
}
if dataBody["delivery_way"] != nil && reflect.TypeOf(dataBody["delivery_way"]).String() == "string" {
deliveryWay, _ := dataBody["delivery_way"].(string)
advice.DeliveryWay = deliveryWay
}
if dataBody["execution_frequency"] != nil && reflect.TypeOf(dataBody["execution_frequency"]).String() == "string" {
executionFrequency, _ := dataBody["execution_frequency"].(string)
advice.ExecutionFrequency = executionFrequency
}
if dataBody["advice_name"] == nil || reflect.TypeOf(dataBody["advice_name"]).String() != "string" {
utils.ErrorLog("advice_name")
code = enums.ErrorCodeParamWrong
return
}
adviceName, _ := dataBody["advice_name"].(string)
if len(adviceName) == 0 {
utils.ErrorLog("len(advice_name) == 0")
code = enums.ErrorCodeParamWrong
return
}
advice.AdviceName = adviceName
if dataBody["advice_desc"] != nil && reflect.TypeOf(dataBody["advice_desc"]).String() == "string" {
adviceDsc, _ := dataBody["advice_desc"].(string)
advice.AdviceDesc = adviceDsc
}
if dataBody["way"] == nil {
advice.Way = 0
} else {
if dataBody["way"] != nil || reflect.TypeOf(dataBody["way"]).String() == "float64" {
way := int64(dataBody["way"].(float64))
advice.Way = way
}
}
if dataBody["drug_id"] == nil {
advice.DrugId = 0
} else {
if dataBody["drug_id"] != nil || reflect.TypeOf(dataBody["drug_id"]).String() == "float64" {
drug_id := int64(dataBody["drug_id"].(float64))
advice.DrugId = drug_id
}
}
if dataBody["drug_name_id"] == nil {
advice.DrugNameId = 0
} else {
if dataBody["drug_name_id"] != nil || reflect.TypeOf(dataBody["drug_name_id"]).String() == "float64" {
drug_name_id := int64(dataBody["drug_name_id"].(float64))
advice.DrugNameId = drug_name_id
}
}
if dataBody["single_dose"] != nil && reflect.TypeOf(dataBody["single_dose"]).String() == "string" {
singleDose, _ := strconv.ParseFloat(dataBody["single_dose"].(string), 64)
advice.SingleDose = singleDose
}
if dataBody["single_dose_unit"] != nil && reflect.TypeOf(dataBody["single_dose_unit"]).String() == "string" {
singleDoseUnit, _ := dataBody["single_dose_unit"].(string)
advice.SingleDoseUnit = singleDoseUnit
}
if dataBody["drug_spec"] != nil && reflect.TypeOf(dataBody["drug_spec"]).String() == "string" {
drugSpec, _ := strconv.ParseFloat(dataBody["drug_spec"].(string), 64)
advice.DrugSpec = drugSpec
}
if dataBody["drug_spec_unit"] != nil && reflect.TypeOf(dataBody["drug_spec_unit"]).String() == "string" {
drugSpecUnit, _ := dataBody["drug_spec_unit"].(string)
advice.DrugSpecUnit = drugSpecUnit
}
if dataBody["prescribing_number"] != nil && reflect.TypeOf(dataBody["prescribing_number"]).String() == "string" {
prescribingNumber, _ := strconv.ParseFloat(dataBody["prescribing_number"].(string), 64)
advice.PrescribingNumber = prescribingNumber
}
if dataBody["prescribing_number_unit"] != nil && reflect.TypeOf(dataBody["prescribing_number_unit"]).String() == "string" {
prescribingNumberUnit, _ := dataBody["prescribing_number_unit"].(string)
advice.PrescribingNumberUnit = prescribingNumberUnit
}
if dataBody["remark"] != nil && reflect.TypeOf(dataBody["remark"]).String() == "string" {
remark, _ := dataBody["remark"].(string)
advice.Remark = remark
}
return
}
func (c *PatientApiController) GetPatientEducation() {
patientID, _ := c.GetInt64("patient_id", 0)
page, _ := c.GetInt64("page", 0)
limit, _ := c.GetInt64("limit", 0)
startTime := c.GetString("start_time", "")
endTime := c.GetString("end_time", "")
if page <= 0 {
page = 1
}
if limit <= 0 {
limit = 10
}
if patientID <= 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
timeLayout := "2006-01-02"
loc, _ := time.LoadLocation("Local")
var theStartTIme int64
if len(startTime) > 0 {
theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", startTime+" 00:00:00", loc)
if err != nil {
theStartTIme = 0
}
theStartTIme = theTime.Unix()
}
var theEndtTIme int64
if len(endTime) > 0 {
theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", endTime+" 23:59:59", loc)
if err != nil {
theEndtTIme = 0
}
theEndtTIme = theTime.Unix()
}
adminUserInfo := c.GetMobileAdminUserInfo()
edus, total, _ := service.GetPatientTreatmentSummaryList(adminUserInfo.Org.Id, patientID, page, limit, theStartTIme, theEndtTIme)
c.ServeSuccessJSON(map[string]interface{}{
"total": total,
"edus": edus,
})
return
}
func (c *PatientApiController) GetPatientSchedulesList() {
patientID, _ := c.GetInt64("patient_id", 0)
page, _ := c.GetInt64("page", 0)
limit, _ := c.GetInt64("limit", 0)
if patientID <= 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
adminUserInfo := c.GetMobileAdminUserInfo()
todayTime := time.Now().Format("2006-01-02")
timeLayout := "2006-01-02 15:04:05"
loc, _ := time.LoadLocation("Local")
var theStartTime int64
theTime, _ := time.ParseInLocation(timeLayout, todayTime+" 00:00:00", loc)
theStartTime = theTime.Unix()
schedules, _ := service.GetPatientScheduleList(adminUserInfo.Org.Id, patientID, page, limit, theStartTime)
if len(schedules) > 0 {
for index, item := range schedules {
_, week := time.Unix(item.ScheduleDate, 0).ISOWeek()
schedules[index].Week = int64(week)
}
}
c.ServeSuccessJSON(map[string]interface{}{
"schedules": schedules,
})
return
}
func (c *PatientApiController) GetRecords() {
patientID, _ := c.GetInt64("patient_id", 0)
page, _ := c.GetInt64("page", 0)
limit, _ := c.GetInt64("limit", 0)
startTime := c.GetString("start_time", "")
endTime := c.GetString("end_time", "")
mode_id, _ := c.GetInt64("mode_id", 0)
if page <= 0 {
page = 1
}
if limit <= 0 {
limit = 10
}
if patientID <= 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
timeLayout := "2006-01-02"
loc, _ := time.LoadLocation("Local")
var theStartTIme int64
if len(startTime) > 0 {
theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", startTime+" 00:00:00", loc)
if err != nil {
theStartTIme = 0
}
theStartTIme = theTime.Unix()
}
var theEndtTIme int64
if len(endTime) > 0 {
theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", endTime+" 23:59:59", loc)
if err != nil {
theEndtTIme = 0
}
theEndtTIme = theTime.Unix()
}
adminUserInfo := c.GetMobileAdminUserInfo()
records, total, _ := service.GetPatientDialysisRecord(adminUserInfo.Org.Id, patientID, page, limit, theStartTIme, theEndtTIme, mode_id)
c.ServeSuccessJSON(map[string]interface{}{
"total": total,
"records": records,
})
return
}
func (c *PatientApiController) GetPatientMonitor() {
partition, _ := c.GetInt64("partition")
monitorDate := c.GetString("date")
patient_id, _ := c.GetInt64("patient_id")
timeLayout := "2006-01-02"
loc, _ := time.LoadLocation("Local")
var theStartTime int64
if len(monitorDate) > 0 {
theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", monitorDate+" 00:00:00", loc)
if err != nil {
theStartTime = 0
}
theStartTime = theTime.Unix()
}
adminInfo := c.GetMobileAdminUserInfo()
orgID := adminInfo.Org.Id
monitor, err := service.GetMonitorRecord(orgID, theStartTime, partition, patient_id)
if err != nil {
c.ErrorLog("获取排班信息失败:%v", err)
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
} else {
if len(monitor) > 0 {
//获取所有床位
numberList, _ := service.GetAllDeviceNumberByList(orgID)
//获取所有分区
zoneList, _ := service.GetAllZoneByList(orgID)
//获取透析处方
prescriptions, _ := service.GetAllPrescriptionByListSix(orgID, theStartTime)
//获取透前评估
assessmentBefores, _ := service.GetAllAssessmentBeforesByListOne(orgID, theStartTime)
//获取上机
dialysisOrders, _ := service.GetAllDialysisOrdersByListSix(orgID, theStartTime)
//获取透后
AssessmentAfterDislysis, _ := service.GetAllAssessmentAfterDislysisByListSix(orgID, theStartTime)
//获取透后监测
monitorlist, _ := service.GetAllMonitorList(orgID, theStartTime)
//获取所有的患者
patients, _ := service.GetAllPatientListByListOne(orgID)
//获取所有透析模式
treatments, _ := service.GetAllTreatModeByList(orgID)
for key, item := range monitor {
// 获取床位信息
for _, it := range numberList {
if item.BedId == it.ID {
monitor[key].DeviceNumber = it
break
}
}
//获取分区信息
for _, it := range zoneList {
if item.PartitionId == it.ID {
monitor[key].DeviceZone = it
}
}
for _, prescription := range prescriptions {
if item.PatientId == prescription.PatientId {
monitor[key].Prescription = prescription
break
}
}
// 透前评估
for _, assessmentBefore := range assessmentBefores {
if item.PatientId == assessmentBefore.PatientId {
monitor[key].AssessmentBeforeDislysis = assessmentBefore
break
}
}
// 透析上下机
for _, dialysisOrder := range dialysisOrders {
if item.PatientId == dialysisOrder.PatientId {
monitor[key].DialysisOrder = dialysisOrder
break
}
}
// 治疗小节
for _, afterDislysis := range AssessmentAfterDislysis {
if item.PatientId == afterDislysis.PatientId {
monitor[key].AssessmentAfterDislysis = afterDislysis
break
}
}
for _, it := range monitorlist {
if item.PatientId == it.PatientId {
monitor[key].MonitoringRecord = append(monitor[key].MonitoringRecord, it)
}
}
for _, patient := range patients {
if item.PatientId == patient.ID {
monitor[key].MonitorPatients = patient
break
}
}
for _, treatment := range treatments {
if item.ModeId == treatment.ID {
monitor[key].TreatmentMode = treatment
break
}
}
}
}
}
//获取患者的透析次数
count, err := service.GetDialysisCount(orgID, partition)
patients, err := service.GetAllpatientThirty(orgID)
if err == nil {
c.ServeSuccessJSON(map[string]interface{}{
"monitor": monitor,
"patientCount": count,
"patients": patients,
})
} else {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
}
}
// /m/api/monitor/patient [get] 搜索病人的测量记录
// @param keyword:string 病人姓名或透析号
// @param page:int
func (this *PatientApiController) SearchMonitorPatient() {
keyword := this.GetString("keyword")
page, _ := this.GetInt("page")
if page <= 0 {
page = 1
}
if len(keyword) == 0 {
this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
adminUserInfo := this.GetMobileAdminUserInfo()
monitors, getMonitorErr := service.MobileGetMonitorsWithPatient(adminUserInfo.Org.Id, keyword, page)
if getMonitorErr != nil {
this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
return
} else {
this.ServeSuccessJSON(map[string]interface{}{
"monitor": monitors,
})
}
}
func (c *PatientApiController) GetPatientDialysisSolutionList() {
id, _ := c.GetInt64("id", 0)
page, _ := c.GetInt64("page", 0)
limit, _ := c.GetInt64("limit", 0)
if id <= 0 {
c.ServeSuccessJSON(map[string]interface{}{
"solutions": nil,
})
return
}
if page <= 0 {
page = 1
}
if limit <= 0 {
limit = 10
}
adminInfo := c.GetMobileAdminUserInfo()
solutions, total, _ := service.GetPatientDialysisSolutionList(adminInfo.Org.Id, id, page, limit)
c.ServeSuccessJSON(map[string]interface{}{
"solutions": solutions,
"total": total,
})
return
}
// GetDoctorAdvices 医嘱列表
func (c *PatientApiController) GetDoctorAdvices() {
id, _ := c.GetInt64("id", 0)
adviceType, _ := c.GetInt64("advice_type", 0)
stopType, _ := c.GetInt64("stop_state", 0)
startTime := c.GetString("start_time", "")
endTime := c.GetString("end_time", "")
keywords := c.GetString("keywords", "")
need, _ := c.GetInt64("need_doctor", 0)
adminUserInfo := c.GetMobileAdminUserInfo()
timeLayout := "2006-01-02"
loc, _ := time.LoadLocation("Local")
var theStartTIme int64
if len(startTime) > 0 {
theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", startTime+" 00:00:00", loc)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
theStartTIme = theTime.Unix()
}
var theEndtTIme int64
if len(endTime) > 0 {
theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", endTime+" 23:59:59", loc)
if err != nil {
utils.ErrorLog(err.Error())
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
theEndtTIme = theTime.Unix()
}
advices, total, _ := service.GetDoctorAdviceList(adminUserInfo.Org.Id, id, adviceType, stopType, theStartTIme, theEndtTIme, keywords)
if need == 1 {
users, _ := service.GetAllAdminUsers(adminUserInfo.Org.Id, adminUserInfo.App.Id)
c.ServeSuccessJSON(map[string]interface{}{
"advices": advices,
"total": total,
"users": users,
})
} else {
c.ServeSuccessJSON(map[string]interface{}{
"advices": advices,
"total": total,
"users": []string{},
})
}
return
}
func (c *PatientApiController) GetPrintDialysisOrder() {
xtno := c.GetString("xtno")
xtdate := c.GetString("xtdate")
timeLayout := "2006-01-02"
loc, _ := time.LoadLocation("Local")
theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", xtdate+" 00:00:00", loc)
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
xttime := theTime.Unix()
//获取当前日期月份的第一天
firstmonth := service.GetFirstDateOfMonth(theTime)
firstMonthDate := firstmonth.Unix()
operatorIDs := make([]int64, 0)
adminUserInfo := c.GetMobileAdminUserInfo()
adminUser, _ := service.GetAllAdminUsers(adminUserInfo.Org.Id, adminUserInfo.App.Id)
patientInfo, _ := service.FindPatientWithDeviceByNo(adminUserInfo.Org.Id, xtno, xttime)
//透析单
dialysisOrder, _ := service.MobileGetSchedualDialysisRecord(adminUserInfo.Org.Id, patientInfo.ID, xttime)
if dialysisOrder != nil {
if dialysisOrder.FinishNurse > 0 {
operatorIDs = append(operatorIDs, dialysisOrder.FinishNurse)
}
if dialysisOrder.StartNurse > 0 {
operatorIDs = append(operatorIDs, dialysisOrder.StartNurse)
}
}
last_order, _ := service.GetLastTimeOrder(adminUserInfo.Org.Id, patientInfo.ID, xttime)
//透前评估
PredialysisEvaluation, _ := service.FindPredialysisEvaluationById(adminUserInfo.Org.Id, patientInfo.ID, xttime)
//透后评估
AssessmentAfterDislysis, _ := service.FindAssessmentAfterDislysisById(adminUserInfo.Org.Id, patientInfo.ID, xttime)
if AssessmentAfterDislysis.Modifier > 0 {
operatorIDs = append(operatorIDs, AssessmentAfterDislysis.Modifier)
}
//透析处方
dialysisPrescription, _ := service.FindPatientPrescribeWidyDevideById(adminUserInfo.Org.Id, patientInfo.ID, xttime)
if dialysisPrescription.PrescriptionDoctor > 0 {
operatorIDs = append(operatorIDs, dialysisPrescription.PrescriptionDoctor)
}
dialysis_count, _ := service.GetDialysisOrderCount(adminUserInfo.Org.Id, patientInfo.ID, xttime)
patientInfo.TotalDialysis = dialysis_count
//临时医嘱
DoctorAdvice, _ := service.FindDoctorAdviceOrderById(adminUserInfo.Org.Id, patientInfo.ID, xttime)
fmt.Println("DoctorAdvice3223323323232323223323323223332232332wode", DoctorAdvice)
hisAdvice, err := service.GetHisDoctorPatientById(adminUserInfo.Org.Id, patientInfo.ID, xttime)
config, err := service.GetHisDoctorConfig(adminUserInfo.Org.Id)
project_config, _ := service.GetHisProjectConfig(adminUserInfo.Org.Id)
projects, _ := service.FindAllHisProjectById(adminUserInfo.Org.Id, patientInfo.ID, xttime)
if config.IsOpen == 1 && project_config.IsOpen == 1 && len(projects) > 0 {
for _, item := range projects {
cnt, _ := strconv.ParseFloat(item.Count, 64)
var advice models.HisDoctorAdviceInfo
advice.ID = item.ID
advice.Checker = item.Checker
advice.CheckTime = item.CheckTime
advice.CheckState = item.CheckState
advice.ExecutionState = item.ExecutionState
advice.ExecutionStaff = item.ExecutionStaff
//advice.PrescribingNumber = float64(item.Count)
advice.PrescribingNumber = cnt
advice.PrescribingNumberUnit = item.Unit
advice.AdviceDoctor = item.Doctor
if item.Type == 3 {
advice.AdviceName = item.GoodInfo.GoodName
advice.PrescribingNumberUnit = item.GoodInfo.PackingUnit
} else if item.Type == 2 {
advice.AdviceName = item.HisProject.ProjectName
}
advice.StartTime = item.StartTime
hisAdvice = append(hisAdvice, &advice)
}
}
if len(DoctorAdvice) > 0 {
for _, item := range DoctorAdvice {
if item.AdviceDoctor > 0 {
operatorIDs = append(operatorIDs, item.AdviceDoctor)
}
if item.ExecutionStaff > 0 {
operatorIDs = append(operatorIDs, item.ExecutionStaff)
}
if item.Checker > 0 {
operatorIDs = append(operatorIDs, item.Checker)
}
}
}
//DoctorAdvice, _ := service.FindDoctorAdviceOrderById(adminUserInfo.Org.Id, patientInfo.ID, xttime)
//透析监测
Record, _ := service.FindAllMonitorRecord(adminUserInfo.Org.Id, patientInfo.ID, xttime)
//透析小结
TreatmentSummary, _ := service.FindTreatmentSummaryById(adminUserInfo.Org.Id, patientInfo.ID, xttime)
//接诊评估
receiverTreatmentAccess, _ := service.FindReceiverTreatmentAccessRecordById(adminUserInfo.Org.Id, patientInfo.ID, xttime)
//相关操作对应的操作人
//operators, _ := service.GetAdminUserES(adminUserInfo.Org.Id, adminUserInfo.App.Id, operatorIDs)
operators, err := service.GetAllStarfEs(adminUserInfo.Org.Id)
templateInfo, _ := service.GetOrgInfoTemplate(adminUserInfo.Org.Id)
check, _ := service.FindDoubleCheckById(adminUserInfo.Org.Id, patientInfo.ID, xttime)
dialysiscount, err := service.GetDialysisCountByPatientId(firstMonthDate, xttime, patientInfo.ID, adminUserInfo.Org.Id)
lastWeight, _ := service.MobileGetLast(adminUserInfo.Org.Id, patientInfo.ID, xttime)
if config.IsOpen == 1 {
c.ServeSuccessJSON(map[string]interface{}{
"users": adminUser,
"patientInfo": patientInfo,
"PredialysisEvaluation": PredialysisEvaluation,
"AssessmentAfterDislysis": AssessmentAfterDislysis,
"dialysisPrescription": dialysisPrescription,
"advices": hisAdvice,
"monitors": Record,
"summary": TreatmentSummary,
"receiverTreatmentAccess": receiverTreatmentAccess,
"dialysisOrder": dialysisOrder,
"operators": operators,
"org_template_info": templateInfo,
"check": check,
"dialysiscount": dialysiscount,
"last_order": last_order,
"projects": projects,
"project_config": project_config,
"lastWeight": lastWeight,
})
}
if config.IsOpen == 0 || config.IsOpen == 2 {
c.ServeSuccessJSON(map[string]interface{}{
"users": adminUser,
"patientInfo": patientInfo,
"PredialysisEvaluation": PredialysisEvaluation,
"AssessmentAfterDislysis": AssessmentAfterDislysis,
"dialysisPrescription": dialysisPrescription,
"advices": DoctorAdvice,
"monitors": Record,
"summary": TreatmentSummary,
"receiverTreatmentAccess": receiverTreatmentAccess,
"dialysisOrder": dialysisOrder,
"operators": operators,
"org_template_info": templateInfo,
"check": check,
"dialysiscount": dialysiscount,
"last_order": last_order,
"projects": projects,
"project_config": project_config,
"lastWeight": lastWeight,
})
}
}
func (c *PatientApiController) CreateGroupAdvice() {
is_child, _ := c.GetInt64("is_child", 0)
if is_child == 1 {
patient, _ := c.GetInt64("id", 0)
if patient <= 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
adminUserInfo := c.GetMobileAdminUserInfo()
patientInfo, _ := service.FindPatientById(adminUserInfo.Org.Id, patient)
if patientInfo.ID == 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
return
}
group_no, _ := c.GetInt64("group_no")
if group_no <= 0 {
group_no = 0
}
dataBody := make(map[string]interface{}, 0)
err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
if err != nil {
utils.ErrorLog(err.Error())
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
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
}
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
}
AdviceDate := advicedateunix
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)
theTimeOne, _ := time.ParseInLocation("2006-01-02 15:04:05", startTime2+" 00:00:00", loc)
if err != nil {
utils.ErrorLog(err.Error())
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
StartTime := theTime.Unix()
Remark := ""
if dataBody["remark"] != nil && reflect.TypeOf(dataBody["remark"]).String() == "string" {
remark, _ := dataBody["remark"].(string)
Remark = remark
}
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)
return
}
adviceNames := dataBody["adviceNames"].([]interface{})
for _, adviceNameMap := range adviceNames {
adviceNameM := adviceNameMap.(map[string]interface{})
var advice models.GroupAdvice
advice.Remark = Remark
advice.AdviceType = adviceType
advice.StartTime = StartTime
if adminUserInfo.Org.Id == 10340 {
advice.AdviceDate = AdviceDate
advice.RecordDate = RecordDate
}
if adminUserInfo.Org.Id != 10340 {
advice.AdviceDate = theTimeOne.Unix()
advice.RecordDate = theTimeOne.Unix()
}
advice.Status = 1
advice.CreatedTime = time.Now().Unix()
advice.UpdatedTime = time.Now().Unix()
advice.StopState = 2
advice.ExecutionState = 2
advice.UserOrgId = adminUserInfo.Org.Id
advice.PatientId = patientInfo.ID
advice.AdviceDoctor = adminUserInfo.AdminUser.Id
advice.IsSettle = 2
//入口
errcode := c.setAdviceWithJSON(&advice, adviceNameM)
if errcode > 0 {
c.ServeFailJSONWithSGJErrorCode(errcode)
return
}
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.GroupAdvice
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.UserOrgId = adminUserInfo.Org.Id
s.PatientId = patientInfo.ID
s.AdviceDoctor = adminUserInfo.AdminUser.Id
s.IsSettle = 2
errcode := c.setAdviceWithJSON(&s, subdrug.(map[string]interface{}))
if errcode > 0 {
c.ServeFailJSONWithSGJErrorCode(errcode)
return
}
advice.Children = append(advice.Children, &s)
}
}
}
//长沙南雅
if adminUserInfo.Org.Id == 3877 || adminUserInfo.Org.Id == 10340 || adminUserInfo.Org.Id == 9671 {
//查询该患者今日有没有双人核对
check, _ := service.MobileGetDoubleCheckSix(adminUserInfo.Org.Id, patientInfo.ID, RecordDate)
if check.ID > 0 {
advice.Checker = check.Modifier
advice.CheckState = 1
advice.CheckTime = time.Now().Unix()
}
}
advices = append(advices, &advice)
}
newAdvices, createErr := service.CreateMGroupAdvice(adminUserInfo.Org.Id, advices, group_no)
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(AdviceDate, 10) + ":doctor_advices"
redis := service.RedisClient()
//清空key 值
redis.Set(key, "", time.Second)
keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(AdviceDate, 10) + ":advice_list_all"
redis.Set(keyOne, "", time.Second)
defer redis.Close()
if createErr != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateDoctorAdviceFail)
return
}
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
"advices": newAdvices,
})
return
} else if is_child == 2 {
patient, _ := c.GetInt64("id", 0)
if patient <= 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
adminUserInfo := c.GetMobileAdminUserInfo()
patientInfo, _ := service.FindPatientById(adminUserInfo.Org.Id, patient)
if patientInfo.ID == 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
return
}
var advice models.DoctorAdvice
code := adviceFormData(&advice, c.Ctx.Input.RequestBody, "create")
if code > 0 {
c.ServeFailJSONWithSGJErrorCode(code)
return
}
if advice.ParentId > 0 {
old, _ := service.FindDoctorAdvice(adminUserInfo.Org.Id, advice.ParentId)
if old.ID == 0 || old.PatientId != patient {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParentAdviceNotExist)
return
}
if old.StopState == 1 || old.ExecutionState == 1 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceStoped)
return
}
if old.ParentId > 0 {
advice.ParentId = old.ParentId
}
advice.StartTime = old.StartTime
advice.AdviceDoctor = old.AdviceDoctor
advice.DeliveryWay = old.DeliveryWay
advice.ExecutionFrequency = old.ExecutionFrequency
advice.GroupNo = old.GroupNo
}
advice.Status = 1
advice.CreatedTime = time.Now().Unix()
advice.UpdatedTime = time.Now().Unix()
advice.StopState = 2
advice.ExecutionState = 2
advice.UserOrgId = adminUserInfo.Org.Id
advice.PatientId = patient
advice.AdviceDoctor = adminUserInfo.AdminUser.Id
advice.IsSettle = 2
if adminUserInfo.Org.Id == 3877 || adminUserInfo.Org.Id == 10340 || adminUserInfo.Org.Id == 9671 {
if advice.PrescribingNumber == 0 {
advice.PrescribingNumber = 1
}
//查询该患者今日有没有双人核对
check, _ := service.MobileGetDoubleCheckSix(adminUserInfo.Org.Id, patientInfo.ID, advice.AdviceDate)
if check.ID > 0 {
advice.Checker = check.Modifier
advice.CheckState = 1
advice.CheckTime = time.Now().Unix()
}
}
err := service.CreateDoctorAdvice(&advice)
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
redis := service.RedisClient()
//清空key 值
redis.Set(key, "", time.Second)
keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
redis.Set(keyOne, "", time.Second)
defer redis.Close()
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateDoctorAdviceFail)
return
}
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
"advice": advice,
})
return
}
}
func (c *PatientApiController) setAdviceWithJSON(advice *models.GroupAdvice, json map[string]interface{}) int {
if json["advice_name"] == nil || reflect.TypeOf(json["advice_name"]).String() != "string" {
utils.ErrorLog("advice_name")
return enums.ErrorCodeParamWrong
}
adviceName, _ := json["advice_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 {
advice.DrugId = 0
} else {
if json["drug_id"] != nil || reflect.TypeOf(json["drug_id"]).String() == "float64" {
drug_id := int64(json["drug_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)
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)
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)
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
}
return 0
}
func (c *PatientApiController) DelDoctorAdvice() {
groupno, _ := c.GetInt64("groupno", -1)
is_sub, _ := c.GetInt64("is_sub", -1) //是否子药
patient_id, _ := c.GetInt64("patient_id")
doc_advice_date, _ := c.GetInt64("advice_date")
redis := service.RedisClient()
if is_sub == 1 { //是
advice_id, _ := c.GetInt64("advice_id")
adminUserInfo := c.GetMobileAdminUserInfo()
advice, _ := service.FindOldDoctorAdvice(adminUserInfo.Org.Id, advice_id)
if advice.ID == 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
return
}
advice.Status = 0
advice.UpdatedTime = time.Now().Unix()
advice.Modifier = adminUserInfo.AdminUser.Id
err := service.DeleteDoctorAdvice(&advice)
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"
redis.Set(key, "", time.Second)
keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":advice_list_all"
redis.Set(keyTwo, "", time.Second)
keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":his_doctor_advice"
redis.Set(keyThree, "", time.Second)
redis.Close()
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteAdviceFail)
return
}
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
})
return
} else { //
var ids []string
if groupno == 0 {
advice_id := c.GetString("advice_id")
ids = strings.Split(advice_id, ",")
if len(ids) <= 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
}
if groupno < 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
adminUserInfo := c.GetMobileAdminUserInfo()
var advice models.DoctorAdvice
if groupno > 0 {
advice, _ = service.FindDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, groupno)
if advice.ID == 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
return
}
} else {
advices, _ := service.FindDoctorAdviceByIds(adminUserInfo.Org.Id, ids)
for _, item := range advices {
if item.ID == 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
return
}
}
}
advice.UpdatedTime = time.Now().Unix()
advice.Status = 0
advice.GroupNo = groupno
advice.Modifier = adminUserInfo.AdminUser.Id
var err error
if groupno > 0 {
err = service.DeleteDoctorAdviceByGroupNo(&advice)
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"
redis.Set(key, "", time.Second)
keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":advice_list_all"
redis.Set(keyTwo, "", time.Second)
keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":his_doctor_advice"
redis.Set(keyThree, "", time.Second)
} else {
err = service.BatchDeleteDoctorAdvice(ids, adminUserInfo.AdminUser.Id)
key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"
redis.Set(key, "", time.Second)
keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":advice_list_all"
redis.Set(keyTwo, "", time.Second)
keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":his_doctor_advice"
redis.Set(keyThree, "", time.Second)
redis.Close()
}
if err != nil {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteAdviceFail)
return
}
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
})
return
}
}
// /m/api/advice/group/modify_starttime [post]
// @param group_no:int
// @param start_time:string yyyy-MM-dd hh:mm:ss
func (this *PatientApiController) ModifyAdviceGroupStartTime() {
group_no, _ := this.GetInt64("group_no")
start_time_str := this.GetString("start_time")
if group_no <= 0 || len(start_time_str) == 0 {
this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
startTime, parseTimeErr := utils.ParseTimeStringToTime("2006-01-02 15:04:05", start_time_str)
if parseTimeErr != nil {
this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamFormatWrong)
return
}
adminUserInfo := this.GetMobileAdminUserInfo()
updateStartTimeErr := service.UpdateAdviceGroupStartTime(adminUserInfo.Org.Id, group_no, startTime.Unix(), adminUserInfo.AdminUser.Id)
if updateStartTimeErr != nil {
utils.ErrorLog("修改医嘱分组的开始时间失败：%v", updateStartTimeErr)
this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
return
}
this.ServeSuccessJSON(map[string]interface{}{
"start_time": startTime.Unix(),
})
}
func (this *PatientApiController) DelSubDoctorAdvice() {
advice_id, _ := this.GetInt64("advice_id")
adminUserInfo := this.GetMobileAdminUserInfo()
advice, _ := service.FindOldDoctorAdvice(adminUserInfo.Org.Id, advice_id)
if advice.ID == 0 {
this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
return
}
//if !adminUserInfo.AdminUser.IsSuperAdmin && advice.AdviceDoctor != adminUserInfo.AdminUser.Id {
// this.ServeFailJSONWithSGJErrorCode(enums. bh)
// return
//}
advice.Status = 0
advice.UpdatedTime = time.Now().Unix()
advice.Modifier = adminUserInfo.AdminUser.Id
err := service.DeleteDoctorAdvice(&advice)
if err != nil {
this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteAdviceFail)
return
}
this.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
})
return
}
func (this *PatientApiController) GetAdviceUnReadMessage() {
//adminUserInfo := this.GetMobileAdminUserInfo()
//service.FindUnReadDoctorAdviceMessage()
}
func (this *PatientApiController) GetPatientsByKeyWord() {
keyWord := this.GetString("keyword")
adminUserInfo := this.GetMobileAdminUserInfo()
today := utils.ZeroHourTimeOfDay(time.Now())
patient, err := service.GetSchedualPatientByKeyWord(adminUserInfo.Org.Id, keyWord, today.Unix())
if err != nil {
utils.ErrorLog(err.Error())
this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
return
}
this.ServeSuccessJSON(map[string]interface{}{
"patient": patient,
})
}
func (this *PatientApiController) GetSearchPatient() {
keyWord := this.GetString("keyword")
adminUserInfo := this.GetMobileAdminUserInfo()
patient, err := service.GetPatientsByKey(adminUserInfo.Org.Id, keyWord)
if err != nil {
utils.ErrorLog(err.Error())
this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
return
}
this.ServeSuccessJSON(map[string]interface{}{
"patient": patient,
})
}
func (c *PatientApiController) ExecProject() {
execution_time := c.GetString("execution_time")
project_id, _ := c.GetInt64("project_id")
team_id, _ := c.GetInt64("team_id")
is_check_team, _ := c.GetInt64("is_check_team")
if len(execution_time) <= 0 {
utils.ErrorLog("execution_time")
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
timeLayout2 := "2006-01-02 15:04:05"
loc, _ := time.LoadLocation("Local")
theTime, errs := time.ParseInLocation(timeLayout2, execution_time, loc)
if errs != nil {
utils.ErrorLog(errs.Error())
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
return
}
adminInfo := c.GetMobileAdminUserInfo()
project, _ := service.FindHisProjectById(adminInfo.Org.Id, project_id)
if project.Type == 3 {
good, _ := service.GetGoodInformationByGoodId(project.ProjectId)
if good.IsUser != 1 {
//查询开关是否开启
stockSetting, _ := service.FindStockSettingById(adminInfo.Org.Id)
//开关已经开启
if stockSetting.IsType == 1 {
theTime, _ := time.ParseInLocation(timeLayout2, execution_time, loc)
scheduleDateStart := theTime.Format("2006-01-02")
timeLayout3 := "2006-01-02"
loc, _ := time.LoadLocation("Local")
execuTime, _ := time.ParseInLocation(timeLayout3, scheduleDateStart, loc)
//查询该耗材是否已经出库
auto, _ := service.GetAutoWarehouseOutList(project.ProjectId, execuTime.Unix(), adminInfo.Org.Id, project.PatientId)
if auto.ID == 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeStockExced)
return
}
}
}
if good.IsUser == 1 && good.IsWarehouse == 1 {
//查询开关是否开启
stockSetting, _ := service.FindStockSettingById(adminInfo.Org.Id)
//开关已经开启
if stockSetting.IsType == 1 {
theTime, _ := time.ParseInLocation(timeLayout2, execution_time, loc)
scheduleDateStart := theTime.Format("2006-01-02")
timeLayout3 := "2006-01-02"
loc, _ := time.LoadLocation("Local")
execuTime, _ := time.ParseInLocation(timeLayout3, scheduleDateStart, loc)
//查询该耗材是否已经出库
auto, _ := service.GetAutoWarehouseOutList(project.ProjectId, execuTime.Unix(), adminInfo.Org.Id, project.PatientId)
if auto.ID == 0 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeStockExced)
return
}
}
}
}
if project.ExecutionState == 1 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExced)
return
}
if project.Checker >= 0 && project.Checker == adminInfo.AdminUser.Id {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeExceAndCheckNotOneUser)
return
}
project.ExecutionState = 1
project.ExecutionStaff = adminInfo.AdminUser.Id
project.ExecutionTime = theTime.Unix()
if team_id == 0 {
err := service.SaveHisProject(&project)
if err == nil {
c.ServeSuccessJSON(map[string]interface{}{
"project": project,
})
} else {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
return
}
} else {
if is_check_team == 2 { //虽然是组套数据，但不是检验项目
err := service.SaveHisProject(&project)
if err == nil {
c.ServeSuccessJSON(map[string]interface{}{
"project": project,
})
} else {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
return
}
} else {
ps, _ := service.GetCheckTeamProject(team_id, project.PatientId, project.RecordDate, project.UserOrgId)
var ids []int64
for _, items := range ps {
ids = append(ids, items.ID)
}
err := service.UpdateTeamProjectExceStatus(ids, adminInfo.AdminUser.Id, theTime.Unix())
if err == nil {
c.ServeSuccessJSON(map[string]interface{}{
"project": project,
})
} else {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
return
}
}
}
}
func (c *PatientApiController) CheckProject() {
adminInfo := c.GetMobileAdminUserInfo()
project_id, _ := c.GetInt64("project_id")
team_id, _ := c.GetInt64("team_id")
is_check_team, _ := c.GetInt64("is_check_team")
project, _ := service.FindHisProjectById(adminInfo.Org.Id, project_id)
if project.CheckState == 1 {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceChecked)
return
}
if project.ExecutionStaff >= 0 && project.ExecutionStaff == adminInfo.AdminUser.Id {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeExceAndCheckNotOneUser)
return
}
project.Checker = adminInfo.AdminUser.Id
project.CheckTime = time.Now().Unix()
project.CheckState = 1
if team_id == 0 {
err := service.SaveHisProject(&project)
if err == nil {
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
"project": project,
})
} else {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
return
}
} else {
if is_check_team == 2 { //虽然是组套数据，但不是检验项目
err := service.SaveHisProject(&project)
if err == nil {
c.ServeSuccessJSON(map[string]interface{}{
"msg": "ok",
"project": project,
})
} else {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
return
}
} else {
ps, _ := service.GetCheckTeamProject(team_id, project.PatientId, project.RecordDate, project.UserOrgId)
var ids []int64
for _, items := range ps {
ids = append(ids, items.ID)
}
err := service.UpdateTeamProjectCheckStatus(ids, project.PatientId, project.RecordDate, project.UserOrgId, adminInfo.AdminUser.Id, time.Now().Unix())
if err == nil {
c.ServeSuccessJSON(map[string]interface{}{
"project": project,
})
} else {
c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
return
}
}
}
}