xcx_mobile_api_service.go 6.7KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247
  1. package service
  2. import (
  3. "Xcx_New/models"
  4. "crypto/aes"
  5. "crypto/cipher"
  6. "encoding/base64"
  7. "encoding/json"
  8. "errors"
  9. "fmt"
  10. "github.com/jinzhu/gorm"
  11. "time"
  12. )
  13. func GetXcxMobileInformation(mobile string) (*models.XcxAdminUserRole, error) {
  14. role := models.XcxAdminUserRole{}
  15. err := UserReadDB().Model(&role).Where("mobile = ? and status = 1", mobile).Find(&role).Error
  16. if err == gorm.ErrRecordNotFound {
  17. return nil, err
  18. }
  19. if err != nil {
  20. return nil, err
  21. }
  22. return &role, nil
  23. }
  24. func CreateXcxAdminUser(role models.XcxAdminUserRole) error {
  25. err := UserReadDB().Create(&role).Error
  26. return err
  27. }
  28. func GetLoginInfor(mobile string) (models.XcxAdminUserRole, error) {
  29. role := models.XcxAdminUserRole{}
  30. err := UserReadDB().Model(&role).Where("mobile = ? and status = 1", mobile).Find(&role).Error
  31. return role, err
  32. }
  33. func GetMobilePatientInfo(mobile string) (models.XcxPatients, error) {
  34. patients := models.XcxPatients{}
  35. err := XTReadDB().Model(&patients).Where("(phone = ? or home_telephone = ? ) and status = 1", mobile, mobile).Find(&patients).Error
  36. return patients, err
  37. }
  38. func GetPatientListByPatientId(id int64) (models.XcxPatients, error) {
  39. patients := models.XcxPatients{}
  40. err := XTReadDB().Model(&patients).Where("id = ? and status = 1", id).Find(&patients).Error
  41. return patients, err
  42. }
  43. func DecryptData(app_id, session_key, iv, encrypted_data string) (map[string]interface{}, error) {
  44. aesKey, err := base64.StdEncoding.DecodeString(session_key)
  45. if err != nil {
  46. return nil, err
  47. }
  48. ivKey, err := base64.StdEncoding.DecodeString(iv)
  49. if err != nil {
  50. return nil, err
  51. }
  52. decodeData, err := base64.StdEncoding.DecodeString(encrypted_data)
  53. if err != nil {
  54. return nil, err
  55. }
  56. dataBytes, err := AesDecrypt(decodeData, aesKey, ivKey)
  57. if err != nil {
  58. return nil, err
  59. }
  60. var result map[string]interface{}
  61. err = json.Unmarshal(dataBytes, &result)
  62. watermark := result["watermark"].(map[string]interface{})
  63. if watermark["appid"] != app_id {
  64. return nil, errors.New("Invalid appid data!")
  65. }
  66. return result, err
  67. }
  68. func AesDecrypt(crypted, key, iv []byte) ([]byte, error) {
  69. block, err := aes.NewCipher(key)
  70. fmt.Println("w2222", err)
  71. if err != nil {
  72. return nil, err
  73. }
  74. blockMode := cipher.NewCBCDecrypter(block, iv)
  75. origData := make([]byte, len(crypted))
  76. blockMode.CryptBlocks(origData, crypted)
  77. // 去除填充
  78. length := len(origData)
  79. unp := int(origData[length-1])
  80. return origData[:(length - unp)], nil
  81. }
  82. func GetFirstDateOfWeek() (weekMonday string) {
  83. now := time.Now()
  84. offset := int(time.Monday - now.Weekday())
  85. if offset > 0 {
  86. offset = -6
  87. }
  88. weekStartDate := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.Local).AddDate(0, 0, offset)
  89. weekMonday = weekStartDate.Format("2006-01-02")
  90. return
  91. }
  92. func GetWeekDayOfWeek() (weekMonday string) {
  93. now := time.Now()
  94. offset := int(time.Monday - now.Weekday())
  95. if offset > 0 {
  96. offset = -6
  97. }
  98. weekStartDate := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.Local).AddDate(0, 0, offset)
  99. weekMonday = weekStartDate.Format("2006-01-02")
  100. return
  101. }
  102. func GetMobilePatient(mobile string) (*models.XcxPatients, error) {
  103. patient := models.XcxPatients{}
  104. err := XTReadDB().Model(&patient).Where("id_card_no = ? and status = 1", mobile).Find(&patient).Error
  105. if err == gorm.ErrRecordNotFound {
  106. return nil, err
  107. }
  108. if err != nil {
  109. return nil, err
  110. }
  111. return &patient, nil
  112. }
  113. func Dncrypt(rawData, key, iv string) (string, error) {
  114. data, err := base64.StdEncoding.DecodeString(rawData)
  115. key_b, err_1 := base64.StdEncoding.DecodeString(key)
  116. iv_b, _ := base64.StdEncoding.DecodeString(iv)
  117. if err != nil {
  118. return "", err
  119. }
  120. if err_1 != nil {
  121. return "", err_1
  122. }
  123. dnData, err := AesCBCDncrypt(data, key_b, iv_b)
  124. if err != nil {
  125. return "", err
  126. }
  127. return string(dnData), nil
  128. }
  129. // 解密
  130. func AesCBCDncrypt(encryptData, key, iv []byte) ([]byte, error) {
  131. block, err := aes.NewCipher(key)
  132. if err != nil {
  133. panic(err)
  134. }
  135. blockSize := block.BlockSize()
  136. if len(encryptData) < blockSize {
  137. panic("ciphertext too short")
  138. }
  139. if len(encryptData)%blockSize != 0 {
  140. panic("ciphertext is not a multiple of the block size")
  141. }
  142. mode := cipher.NewCBCDecrypter(block, iv)
  143. mode.CryptBlocks(encryptData, encryptData)
  144. // 解填充
  145. encryptData = PKCS7UnPadding(encryptData)
  146. return encryptData, nil
  147. }
  148. //去除填充
  149. func PKCS7UnPadding(origData []byte) []byte {
  150. length := len(origData)
  151. unpadding := int(origData[length-1])
  152. if length-unpadding < 0 {
  153. return origData[:0]
  154. }
  155. fmt.Println("changdu", length)
  156. fmt.Println("data", unpadding)
  157. return origData[:(length - unpadding)]
  158. }
  159. func GetScheduleInfo(startime int64, endtime int64, patient_id int64) (schedule []*models.VmBloodSchedule, err error) {
  160. db := XTReadDB().Table("xt_schedule as x").Where("x.status = 1")
  161. table := XTReadDB().Table("xt_patients as t").Where("t.status = 1")
  162. fmt.Println(table)
  163. if startime > 0 {
  164. db = db.Where("x.schedule_date >=?", startime)
  165. }
  166. if endtime > 0 {
  167. db = db.Where("x.schedule_date <=?", endtime)
  168. }
  169. if patient_id > 0 {
  170. db = db.Where("x.patient_id = ?", patient_id)
  171. }
  172. err = db.Select("x.schedule_date,x.schedule_type,x.schedule_week,x.mode_id,t.name").Joins("left join xt_patients as t on t.id = x.patient_id").Scan(&schedule).Error
  173. return schedule, err
  174. }
  175. func GetTodayDialysis(recordDate int64, patient_id int64) (models.XcXDialysisOrder, error) {
  176. order := models.XcXDialysisOrder{}
  177. err := XTReadDB().Model(&order).Where("dialysis_date = ? and patient_id = ? and status = 1", recordDate, patient_id).Find(&order).Error
  178. return order, err
  179. }
  180. func GetNextPatientSchedule(patient_id int64, dialysis_date int64) (models.BloodSchedule, error) {
  181. schedule := models.BloodSchedule{}
  182. //err := XTReadDB().Model(&schedule).Where("patient_id = ? and status = 1 and schedule_date>?", patient_id, dialysis_date).Order("schedule_date asc").First(&schedule).Error
  183. //return schedule, err
  184. db := XTReadDB().Table("xt_schedule as x").Where("x.status = 1")
  185. table := XTReadDB().Table("xt_device_zone as z").Where("z.status =1")
  186. tables := XTReadDB().Table("xt_device_number as n").Where("n.status =1")
  187. fmt.Println(table, tables)
  188. if patient_id > 0 {
  189. db = db.Where("x.patient_id = ?", patient_id)
  190. }
  191. if dialysis_date > 0 {
  192. db = db.Where("x.schedule_date >?", dialysis_date)
  193. }
  194. err := db.Select("x.patient_id,x.schedule_type,x.schedule_date,x.mode_id,z.name,n.number").Joins("left join xt_device_zone as z on z.id = x.partition_id").Joins("left join xt_device_number as n on n.id = x.bed_id").Order("x.schedule_date asc").Limit(1).Scan(&schedule).Error
  195. return schedule, err
  196. }
  197. func GetXcxPatientInfo(patient_id int64) (models.XcxPatients, error) {
  198. patients := models.XcxPatients{}
  199. err := XTReadDB().Model(&patients).Where("id = ? and status = 1", patient_id).Find(&patients).Error
  200. return patients, err
  201. }