his_project_service.go 21KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570
  1. package service
  2. import (
  3. "XT_New/models"
  4. "github.com/jinzhu/gorm"
  5. "time"
  6. )
  7. func GetHisProjectIsExist(projectName string, orgid int64) (*models.XtHisProject, error) {
  8. var project models.XtHisProject
  9. var err error
  10. err = XTReadDB().Model(&project).Where("project_name = ? and user_org_id = ? and status = 1", projectName, orgid).Find(&project).Error
  11. if err == gorm.ErrRecordNotFound {
  12. return nil, err
  13. }
  14. if err != nil {
  15. return nil, err
  16. }
  17. return &project, nil
  18. }
  19. func CreateHisProject(project *models.XtHisProject) error {
  20. err := XTWriteDB().Model(&project).Create(&project).Error
  21. return err
  22. }
  23. func GetHisProjectList(orgid int64, limit int64, page int64, charge int64, start int64, keyword string) (hisproject []*models.XtHisProject, total int64, err error) {
  24. offset := (page - 1) * limit
  25. likeKey := "%" + keyword + "%"
  26. db := XTReadDB().Table("xt_his_project as x").Where("x.status = 1")
  27. if orgid > 0 {
  28. db = db.Where("x.user_org_id = ?", orgid)
  29. }
  30. if start > 0 {
  31. db = db.Where("x.medical_status = ?", start)
  32. }
  33. if charge > 0 {
  34. db = db.Where("x.is_estimate = ? ", charge)
  35. }
  36. if len(keyword) > 0 {
  37. db = db.Where("x.project_name like ?", likeKey)
  38. }
  39. err = db.Select("x.id,x.project_name,x.pinyin,x.wubi,x.price,x.unit,x.cost_classify,x.executive_section,x.medical_coverage,x.statistical_classification,x.disease_directory,x.is_record,x.medical_code,x.tube_color,x.medical_status,x.remark,x.sign,x.default_number,x.is_default,x.is_charge,x.is_estimate,x.is_workload,x.sort,x.doctor_advice,x.user_org_id,x.status,x.created_time").Count(&total).Offset(offset).Limit(limit).Find(&hisproject).Error
  40. return hisproject, total, err
  41. }
  42. func GetProjectDetail(id int64) (models.XtHisProject, error) {
  43. project := models.XtHisProject{}
  44. err := XTReadDB().Model(&project).Where("id=? and status = 1", id).Find(&project).Error
  45. return project, err
  46. }
  47. func UpdatedProject(id int64, pro *models.XtHisProject) error {
  48. err := XTWriteDB().Model(&pro).Where("id=?", id).Updates(map[string]interface{}{"project_name": pro.ProjectName, "pinyin": pro.Pinyin, "wubi": pro.Pinyin, "price": pro.Price, "unit": pro.Unit, "cost_classify": pro.CostClassify, "executive_section": pro.ExecutiveSection, "medical_coverage": pro.MedicalCoverage, "statistical_classification": pro.MedicalCoverage, "disease_directory": pro.DiseaseDirectory, "is_record": pro.DiseaseDirectory, "medical_code": pro.MedicalCode, "tube_color": pro.TubeColor, "medical_status": pro.MedicalStatus, "remark": pro.Remark, "sign": pro.Sign, "default_number": pro.DefaultNumber, "is_default": pro.IsDefault, "is_charge": pro.IsCharge, "is_estimate": pro.IsEstimate, "is_workload": pro.IsWorkload, "sort": pro.Sort, "doctor_advice": pro.DoctorAdvice, "single_dose": pro.SingleDose, "execution_frequency": pro.ExecutionFrequency, "delivery_way": pro.ExecutionFrequency, "number_days": pro.ExecutionFrequency, "total": pro.Total, "updated_time": pro.UpdatedTime}).Error
  49. return err
  50. }
  51. func DeleteHisProject(id int64) error {
  52. project := models.XtHisProject{}
  53. err := XTWriteDB().Model(&project).Where("id=?", id).Updates(map[string]interface{}{"status": 0}).Error
  54. return err
  55. }
  56. func GetHisProjectByNameOne(projectName string, orgid int64) (*models.XtHisProjectTeam, error) {
  57. projectTeam := models.XtHisProjectTeam{}
  58. err := XTReadDB().Model(&projectTeam).Where("project_team = ? and user_org_id = ? and status = 1", projectName, orgid).Find(&projectTeam).Error
  59. if err != nil {
  60. if err == gorm.ErrRecordNotFound {
  61. return nil, err
  62. } else {
  63. return nil, err
  64. }
  65. }
  66. return &projectTeam, nil
  67. }
  68. func CreatedProjectTeam(team *models.XtHisProjectTeam) error {
  69. err := XTWriteDB().Model(&team).Create(&team).Error
  70. return err
  71. }
  72. func GetProjectTeamList(limit int64, page int64, orgid int64, keyword string) (projectTeam []*models.XtHisProjectTeam, total int64, err error) {
  73. offset := (page - 1) * limit
  74. likeKey := "%" + keyword + "%"
  75. db := XTReadDB().Model(&projectTeam)
  76. if len(keyword) > 0 {
  77. db = db.Where("project_team like ?", likeKey)
  78. }
  79. err = db.Where("user_org_id = ? and status = 1", orgid).Count(&total).Offset(offset).Limit(limit).Order("created_time desc").Find(&projectTeam).Error
  80. return projectTeam, total, err
  81. }
  82. func GetProjectTeamDetail(id int64) (models.XtHisProjectTeam, error) {
  83. projectTeam := models.XtHisProjectTeam{}
  84. err := XTReadDB().Model(&projectTeam).Where("id= ? and status = 1", id).Find(&projectTeam).Error
  85. return projectTeam, err
  86. }
  87. func UpdatedProjectTeam(id int64, team *models.XtHisProjectTeam) error {
  88. err := XTWriteDB().Model(&team).Where("id=? and status = 1", id).Updates(map[string]interface{}{"project_team": team.ProjectTeam, "price": team.Price, "pinyin": team.Pinyin, "wubi": team.Wubi, "tube_color": team.TubeColor, "team_type": team.TeamType, "remark": team.Remark, "project_id": team.ProjectId}).Error
  89. return err
  90. }
  91. func DeleteProjectTeam(id int64) error {
  92. team := models.XtHisProjectTeam{}
  93. err := XTWriteDB().Model(&team).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"status": 0}).Error
  94. return err
  95. }
  96. func CreateDePartment(department *models.XtHisDepartment) error {
  97. err := XTWriteDB().Model(&department).Create(&department).Error
  98. return err
  99. }
  100. func GetDepartMentList(limit int64, page int64, orgid int64) (departMent []*models.XtHisDepartment, total int64, err error) {
  101. offset := (page - 1) * limit
  102. err = XTReadDB().Model(&departMent).Where("user_org_id = ? and status = 1", orgid).Count(&total).Offset(offset).Limit(limit).Order("created_time desc").Find(&departMent).Error
  103. return departMent, total, err
  104. }
  105. func GetDepartMentDetail(id int64) (models.XtHisDepartment, error) {
  106. department := models.XtHisDepartment{}
  107. err := XTReadDB().Model(&department).Where("id=? and status = 1", id).Find(&department).Error
  108. return department, err
  109. }
  110. func UpdatedDepartment(id int64, department *models.XtHisDepartment) error {
  111. err := XTWriteDB().Model(&department).Where("id=? and status = 1", id).Updates(map[string]interface{}{"name": department.Name, "number": department.Number, "updated_time": time.Now().Unix()}).Error
  112. return err
  113. }
  114. func DeleteDepartment(id int64) error {
  115. department := models.XtHisDepartment{}
  116. err := XTReadDB().Model(&department).Where("id=? and status = 1", id).Updates(map[string]interface{}{"status": 0}).Error
  117. return err
  118. }
  119. func GetBloodPatientList(orgid int64, startime int64) (schedule []*models.SchedulesVm, err error) {
  120. db := XTReadDB().Table("xt_schedule as x").Where("x.status = 1")
  121. if orgid > 0 {
  122. db = db.Where("x.user_org_id = ?", orgid)
  123. }
  124. if startime > 0 {
  125. db = db.Where("x.schedule_date = ?", startime)
  126. }
  127. err = db.Select("x.id,x.user_org_id,x.patient_id,x.schedule_date,x.schedule_type,x.schedule_week,x.mode_id,p.name,p.id_card_no").Joins("left join xt_patients as p on p.id = x.patient_id").Scan(&schedule).Error
  128. return schedule, err
  129. }
  130. func GetHisPatient(orgid int64, recorddate int64) (paitent []*models.HisPatient, err error) {
  131. err = XTReadDB().Model(&paitent).Where("user_org_id = ? and record_date = ? and status = 1", orgid, recorddate).Find(&paitent).Error
  132. return paitent, err
  133. }
  134. func GetHisPrescriptionOther(orgid int64, recorddate int64) (prescription []*models.HisPrescriptionVm, err error) {
  135. db := XTReadDB().Table("his_prescription as x").Where("x.status = 1")
  136. if orgid > 0 {
  137. db = db.Where("x.user_org_id = ?", orgid)
  138. }
  139. if recorddate > 0 {
  140. db = db.Where("x.record_date = ? ", recorddate)
  141. }
  142. err = db.Select("x.id,x.user_org_id,x.record_date,x.patient_id,x.his_patient_id,x.number,x.type,x.doctor,x.creator,x.modifier,t.name").Joins("left join his_patient as t on t.id = x.his_patient_id").Scan(&prescription).Error
  143. return prescription, err
  144. }
  145. func GetHisPrescriptionByPatientId(id int64, recordate int64) (prescription []*models.HisPrescription, err error) {
  146. err = XTReadDB().Model(&prescription).Where("his_patient_id = ? and record_date = ? and status= 1", id, recordate).Find(&prescription).Error
  147. return prescription, err
  148. }
  149. func CreateAdditionalCharge(charge *models.HisAdditionalCharge) error {
  150. err = XTWriteDB().Model(&charge).Create(&charge).Error
  151. return err
  152. }
  153. func GetTreatmentList(id int64, startime int64) (prescription []*models.HisPrescription, err error) {
  154. err = XTReadDB().Model(&prescription).Where("id = ? and record_date = ? and status = 1", id, startime).Find(&prescription).Error
  155. return prescription, err
  156. }
  157. //func GetAllProjectList(orgid int64) (project []*models.XtHisProject, err error) {
  158. //
  159. // err = XTReadDB().Model(&project).Where("user_org_id = ? and status = 1", orgid).Find(&project).Error
  160. // return project, err
  161. //}
  162. func CreateProjectList(list *models.XtHisProjectList) error {
  163. err := XTWriteDB().Model(&list).Create(&list).Error
  164. return err
  165. }
  166. func GetHisProjectListByOrgId(orgid int64) (projectlist []*models.HisProjectListVm, err error) {
  167. db := XTReadDB().Table("xt_his_project_list as x").Where("x.status = 1")
  168. if orgid > 0 {
  169. db = db.Where("x.user_org_id = ? ", orgid)
  170. }
  171. err = db.Select("x.id,x.number,x.user_org_id,x.project_id,t.price,t.unit,t.cost_classify,t.project_name").Joins("left join xt_his_project as t on t.id = x.project_id").Scan(&projectlist).Error
  172. return projectlist, err
  173. }
  174. func GetHisPatientInformation(id int64) (models.HisPatient, error) {
  175. patient := models.HisPatient{}
  176. err := XTReadDB().Model(&patient).Where("id= ? and status = 1", id).Find(&patient).Error
  177. return patient, err
  178. }
  179. func DeleteProjectList(id int64) error {
  180. list := models.XtHisProjectList{}
  181. err := XTWriteDB().Model(&list).Where("id=? and status = 1", id).Updates(map[string]interface{}{"status": 0}).Error
  182. return err
  183. }
  184. func GetHisProject(orgid int64) (project []*models.XtHisProject, err error) {
  185. err = XTReadDB().Model(&project).Where("user_org_id = ? and status =1", orgid).Find(&project).Error
  186. return project, err
  187. }
  188. func GetProjectTeam(ids []string, orgid int64) (project []*models.XtHisProject, err error) {
  189. err = XTReadDB().Model(&project).Where("user_org_id = ? and id in (?)", orgid, ids).Find(&project).Error
  190. return project, err
  191. }
  192. func GetAllDepartMent(orgid int64) (department []*models.XtHisDepartment, err error) {
  193. err = XTReadDB().Model(&department).Where("user_org_id = ? and status =1", orgid).Find(&department).Error
  194. return department, err
  195. }
  196. func CreateHisPatient(patient *models.XtHisPatient) error {
  197. err := XTReadDB().Model(&patient).Create(&patient).Error
  198. return err
  199. }
  200. func GetBloodPatientByIdCard(idcard string, orgid int64) (*models.XtPatients, error) {
  201. var patients models.XtPatients
  202. var err error
  203. err = XTReadDB().Model(&patients).Where("id_card_no = ? and user_org_id = ? and status = 1", idcard, orgid).Find(&patients).Error
  204. if err != nil {
  205. if err == gorm.ErrRecordNotFound {
  206. return nil, err
  207. } else {
  208. return nil, err
  209. }
  210. }
  211. return &patients, nil
  212. }
  213. func GetAllProjectTeam(orgid int64) (project []*models.XtHisProjectTeam, err error) {
  214. err = XTReadDB().Model(&project).Where("user_org_id = ? and status = 1", orgid).Find(&project).Error
  215. return project, err
  216. }
  217. func GetProjectListById(orgid int64, ids []string) (project []*models.XtHisProject, err error) {
  218. err = XTReadDB().Model(&project).Where("user_org_id = ? and id in (?)", orgid, ids).Find(&project).Error
  219. return project, err
  220. }
  221. func GetHisPatientHistory(keyword string, startime int64, endtime int64, registtype int64, limit int64, page int64, orgid int64) (hisPatient []*models.XtHisPatient, total int64, err error) {
  222. offset := (page - 1) * limit
  223. likeKey := "%" + keyword + "%"
  224. db := XTReadDB().Table("his_patient as x").Where("x.status = 1")
  225. if len(keyword) > 0 {
  226. db = db.Where("x.name like ?", likeKey)
  227. }
  228. if startime > 0 {
  229. db = db.Where("x.record_date >= ?", startime)
  230. }
  231. if endtime > 0 {
  232. db = db.Where("x.record_date<=?", endtime)
  233. }
  234. if registtype > 0 {
  235. db = db.Where("x.register_type = ?", registtype)
  236. }
  237. if orgid > 0 {
  238. db = db.Where("x.user_org_id = ?", orgid)
  239. }
  240. err = db.Select("x.id,x.balance_accounts_type,x.medical_insurance_number,x.name,x.gender,x.id_type,x.medical_treatment_type,x.birthday,x.record_date,x.age,x.phone_number,x.id_card_no,x.register_type,x.admin_user_id,x.departments,x.is_need_cost_of_production,x.register_cost,x.treatment_cost,x.cost_of_production,x.total,x.user_org_id,x.patient_id,x.number,x.is_return,x.doctor,x.ctime").Count(&total).Offset(offset).Limit(limit).Order("x.id desc").Find(&hisPatient).Error
  241. return hisPatient, total, err
  242. }
  243. func ChangePatient(id int64) error {
  244. patient := models.XtHisPatient{}
  245. err := XTWriteDB().Model(&patient).Where("id = ?", id).Updates(map[string]interface{}{"is_return": 2}).Error
  246. return err
  247. }
  248. func GetHisPrescriptionTwo(patientid int64, orgid int64, recorddate int64) (*models.HisPrescription, error) {
  249. prescription := models.HisPrescription{}
  250. err := XTReadDB().Model(&prescription).Where("his_patient_id = ? and user_org_id = ? and record_date = ? and status = 1", patientid, orgid, recorddate).Find(&prescription).Error
  251. if err != nil {
  252. if err == gorm.ErrRecordNotFound {
  253. return nil, err
  254. } else {
  255. return nil, err
  256. }
  257. }
  258. return &prescription, nil
  259. }
  260. func UpdatedHisPatient(hispatientid int64, orgid int64, recorddate int64) error {
  261. hisPatient := models.HisPatient{}
  262. err := XTWriteDB().Model(&hisPatient).Where("id = ? and user_org_id = ? and record_date = ?", hispatientid, orgid, recorddate).Updates(map[string]interface{}{"is_return": 3}).Error
  263. return err
  264. }
  265. func GetBloodPatientInfoById(patientid int64) (models.XtPatients, error) {
  266. patients := models.XtPatients{}
  267. err := XTReadDB().Model(&patients).Where("id = ? and status = 1", patientid).Find(&patients).Error
  268. return patients, err
  269. }
  270. func GetPatientCaseHistory(patientid int64) (models.HisPatientCaseHistory, error) {
  271. history := models.HisPatientCaseHistory{}
  272. err := XTReadDB().Model(&history).Where("patient_id = ? and status = 1", patientid).Find(&history).Error
  273. return history, err
  274. }
  275. func GetBloodPatientByPatient(id int64) (models.XtPatients, error) {
  276. patients := models.XtPatients{}
  277. err := XTReadDB().Model(&patients).Where("id = ? and status = 1", id).Find(&patients).Error
  278. return patients, err
  279. }
  280. func GetHisPatientById(patientid int64) (models.HisPatient, error) {
  281. patient := models.HisPatient{}
  282. err := XTReadDB().Model(&patient).Where("patient_id = ? and status = 1", patientid).Find(&patient).Error
  283. return patient, err
  284. }
  285. func GetTemplateDetail(id int64) (models.HisCaseHistoryTemplate, error) {
  286. template := models.HisCaseHistoryTemplate{}
  287. err := XTReadDB().Model(&template).Where("id= ? and status = 1", id).Find(&template).Error
  288. return template, err
  289. }
  290. func UpdateCaseHistoryTemplate(tem *models.HisCaseHistoryTemplate, id int64) error {
  291. err := XTWriteDB().Model(&tem).Where("id = ? ", id).Updates(map[string]interface{}{"history_of_present_illness": tem.HistoryOfPresentIllness, "past_history": tem.PastHistory, "chief_conplaint": tem.ChiefConplaint, "personal_history": tem.PersonalHistory, "family_history": tem.FamilyHistory, "diagnostic": tem.Diagnostic, "template_name": tem.TemplateName, "template_remark": tem.TemplateRemark, "modifier": tem.Modifier}).Error
  292. return err
  293. }
  294. func GetHistPatient(orgid int64, keyword string) (hisPatient []*models.HisPatient, err error) {
  295. likeKey := "%" + keyword + "%"
  296. err = XTReadDB().Model(&hisPatient).Where("user_org_id = ? and name like ?", orgid, likeKey).Find(&hisPatient).Error
  297. return hisPatient, err
  298. }
  299. func GetDoctorAdvicePrint(his_patient_id int64, recorddate int64) (prescription []*models.HisDoctorAdviceInfo, err error) {
  300. err = XTReadDB().Model(&prescription).Where("patient_id = ? and status = 1 and advice_date = ?", his_patient_id, recorddate).Find(&prescription).Error
  301. return prescription, err
  302. }
  303. func GetProjectPrint(his_patient_id int64) (models.HisPrescriptionProject, error) {
  304. project := models.HisPrescriptionProject{}
  305. err := XTReadDB().Model(&project).Where("his_patient_id = ? and status = 1", his_patient_id).Find(&project).Error
  306. return project, err
  307. }
  308. func GetHisTemplateId(templateid int64, orgid int64) (*models.XtHisTemplate, error) {
  309. template := models.XtHisTemplate{}
  310. err := XTReadDB().Model(&template).Where("template_id = ? and user_org_id = ? and status = 1", templateid, orgid).Find(&template).Error
  311. if err != nil {
  312. if err == gorm.ErrRecordNotFound {
  313. return nil, err
  314. } else {
  315. return nil, err
  316. }
  317. }
  318. return &template, nil
  319. }
  320. func CreateHisTemplate(template *models.XtHisTemplate) error {
  321. err := XTWriteDB().Create(&template).Error
  322. return err
  323. }
  324. func UpdateHisTemplate(template *models.XtHisTemplate) error {
  325. err := XTWriteDB().Save(&template).Error
  326. return err
  327. }
  328. func GetHisPrintTemplate(orgid int64) (models.XtHisTemplate, error) {
  329. template := models.XtHisTemplate{}
  330. err := XTReadDB().Model(&template).Where("user_org_id = ? and status = 1", orgid).Find(&template).Error
  331. return template, err
  332. }
  333. func GetPrescriptionTemplate(templateid int64, orgid int64) (*models.XtHisAdviceTemplate, error) {
  334. template := models.XtHisAdviceTemplate{}
  335. err := XTReadDB().Model(&template).Where("template_id = ? and user_org_id = ? and status = 1", templateid, orgid).Find(&template).Error
  336. if err != nil {
  337. if err == gorm.ErrRecordNotFound {
  338. return nil, err
  339. } else {
  340. return nil, err
  341. }
  342. }
  343. return &template, nil
  344. }
  345. func CreatePrescriptionTemplate(template *models.XtHisAdviceTemplate) error {
  346. err = XTWriteDB().Create(&template).Error
  347. return err
  348. }
  349. func UpdatePrescriptionTemplate(template *models.XtHisAdviceTemplate) error {
  350. err := XTWriteDB().Save(&template).Error
  351. return err
  352. }
  353. func GetPrescriptionTemplateById(orgid int64) (models.XtHisAdviceTemplate, error) {
  354. template := models.XtHisAdviceTemplate{}
  355. err := XTReadDB().Model(&template).Where("user_org_id = ? and status = 1", orgid).Find(&template).Error
  356. return template, err
  357. }
  358. func GetTreatPrintTemplate(templateid int64, orgid int64) (*models.XtHisTreatmentTemplate, error) {
  359. template := models.XtHisTreatmentTemplate{}
  360. err := XTReadDB().Model(&template).Where("template_id = ? and user_org_id = ? and status = 1", templateid, orgid).Find(&template).Error
  361. if err != nil {
  362. if err == gorm.ErrRecordNotFound {
  363. return nil, err
  364. } else {
  365. return nil, err
  366. }
  367. }
  368. return &template, nil
  369. }
  370. func CreateTreatPrintTemplate(template *models.XtHisTreatmentTemplate) error {
  371. err := XTWriteDB().Create(&template).Error
  372. return err
  373. }
  374. func UpdatedTreateTemplate(template *models.XtHisTreatmentTemplate) error {
  375. err := XTWriteDB().Save(&template).Error
  376. return err
  377. }
  378. func GetTreatTtreatPrintTemplate(orgid int64) (models.XtHisTreatmentTemplate, error) {
  379. template := models.XtHisTreatmentTemplate{}
  380. err := XTReadDB().Where("user_org_id = ? and status =1", orgid).Find(&template).Error
  381. return template, err
  382. }
  383. func GetChargeTemplate(templateid int64, orgid int64) (*models.XtHisChargeTemplate, error) {
  384. template := models.XtHisChargeTemplate{}
  385. err := XTReadDB().Model(&template).Where("template_id = ? and user_org_id = ? and status = 1", templateid, orgid).Find(&template).Error
  386. if err != nil {
  387. if err == gorm.ErrRecordNotFound {
  388. return nil, err
  389. } else {
  390. return nil, err
  391. }
  392. }
  393. return &template, nil
  394. }
  395. func CreateChargePrintTemplate(template *models.XtHisChargeTemplate) error {
  396. err := XTWriteDB().Create(&template).Error
  397. return err
  398. }
  399. func UpdateChargePrintTemplate(template *models.XtHisChargeTemplate) error {
  400. err := XTWriteDB().Save(&template).Error
  401. return err
  402. }
  403. func GetChargePrintTemplate(orgid int64) (models.XtHisChargeTemplate, error) {
  404. template := models.XtHisChargeTemplate{}
  405. err := XTReadDB().Model(&template).Where("user_org_id = ? and status = 1", orgid).Find(&template).Error
  406. return template, err
  407. }
  408. func GetDoctorProjectItem(patientid int64, record_date int64) (models.HisPrescriptionProject, error) {
  409. project := models.HisPrescriptionProject{}
  410. err := XTReadDB().Model(&project).Where("patient_id = ? and record_date = ? and status = 1", patientid, record_date).Error
  411. return project, err
  412. }
  413. func GetChargePrint(record int64, patient_id int64, user_org_id int64) (order XtHisOrder, err error) {
  414. err = readDb.Model(&HisOrder{}).Where("status = 1 AND user_org_id = ? AND patient_id = ? AND settle_accounts_date=?", user_org_id, patient_id, record).
  415. Preload("HisOrderInfo", "status = 1 AND user_org_id = ?", user_org_id).
  416. Preload("HisPatient", "status = 1 AND user_org_id = ?", user_org_id).
  417. Preload("HisPrescriptionInfo", "status = 1 AND user_org_id = ?", user_org_id).
  418. Order("ctime desc").
  419. Find(&order).Error
  420. return
  421. }
  422. func GetLastPatient(orgid int64) (models.HisPatient, error) {
  423. patient := models.HisPatient{}
  424. err := XTReadDB().Model(&patient).Where("user_org_id = ? and status = 1", orgid).Last(&patient).Error
  425. return patient, err
  426. }
  427. func UpdateHisPatient(id int64, patient models.HisPatient) error {
  428. err := XTWriteDB().Model(&patient).Where("id = ? and status = 1", id).Update(map[string]interface{}{"number": patient.Number}).Error
  429. return err
  430. }
  431. func GetTodaySchedulePatient(orgid int64, scheduledata int64) (schedule []*models.Schedules, err error) {
  432. db := XTReadDB().Table("xt_schedule as x").Where("x.status = 1")
  433. if orgid > 0 {
  434. db = db.Where("x.user_org_id = ?", orgid)
  435. }
  436. if scheduledata > 0 {
  437. db = db.Where("x.schedule_date = ?", scheduledata)
  438. }
  439. err = db.Select("x.id,x.patient_id,x.schedule_date,t.name").Joins("left join xt_patients as t on t.id = x.patient_id").Scan(&schedule).Error
  440. return schedule, err
  441. }