XT_New/controllers/his_api_controller.go

package controllers

import (
	"XT_New/enums"
	"XT_New/models"
	"XT_New/service"
	"XT_New/utils"
	"encoding/json"
	"fmt"
	"github.com/astaxie/beego"
	"github.com/jinzhu/gorm"
	"math/rand"
	"reflect"
	"strconv"
	"strings"
	"syscall"
	"time"
	"unsafe"
)

type HisApiController struct {
	BaseAuthAPIController
}

func HisManagerApiRegistRouters() {

	beego.Router("/api/hispatient/list", &HisApiController{}, "get:GetHisPatientList")
	beego.Router("/api/hispatient/get", &HisApiController{}, "get:GetHisPatientInfo")
	beego.Router("/api/hisprescription/config", &HisApiController{}, "get:GetHisPrescriptionConfig")

	beego.Router("/api/hisprescription/delete", &HisApiController{}, "post:DeletePrescription")
	beego.Router("/api/advice/delete", &HisApiController{}, "post:DeleteDoctorAdvice")
	beego.Router("/api/project/delete", &HisApiController{}, "post:DeleteProject")
	beego.Router("/api/addition_charge/delete", &HisApiController{}, "post:DeleteAddition")

	beego.Router("/api/hisprescription/list", &HisApiController{}, "get:GetHisPrescriptionList")
	beego.Router("/api/hisprescription/info", &HisApiController{}, "get:GetHisPrescriptionInfo")

	beego.Router("/api/hisprescription/create", &HisApiController{}, "post:CreateHisPrescription")
	beego.Router("/api/hisprescription/edit", &HisApiController{}, "post:EditHisPrescription")

	beego.Router("/api/doctorworkstation/casehistory/list", &HisApiController{}, "get:GetHisPatientCaseHistoryList")
	beego.Router("/api/doctorworkstation/casehistory/get", &HisApiController{}, "get:GetHisPatientCaseHistory")
	beego.Router("/api/doctorworkstation/casehistory/create", &HisApiController{}, "get:CreateHisPatientCaseHistory")
	beego.Router("/api/doctorworkstation/casehistorytemplate/create", &HisApiController{}, "get:CreateCaseHistoryTemplate")
	beego.Router("/api/doctorworkstation/casehistorytemplate/get", &HisApiController{}, "get:GetCaseHistoryTemplate")

	beego.Router("/api/hisorder/list", &HisApiController{}, "get:GetHisOrderList")
	beego.Router("/api/hisorder/get", &HisApiController{}, "get:GetHisOrder")

	beego.Router("/api/register/get", &HisApiController{}, "get:GetRegisterInfo")
	beego.Router("/api/upload/get", &HisApiController{}, "get:GetUploadInfo")

	beego.Router("/api/refund/post", &HisApiController{}, "post:Refund")

	beego.Router("/api/medicalinsurance/config", &HisApiController{}, "get:GetMedicalInsuranceConfig")

	beego.Router("/api/doctor/list", &HisApiController{}, "get:GetAdminUsers")

	//beego.Router("/api/medicalinsurance/config", &HisApiController{}, "get:GetMedicalInsuranceConfig")

	//新增附加费用
	//beego.Router("/api/his/additionalcharge", &HisApiController{}, "Post:AdditionalCharge")

	//beego.Router("/api/additionalcharge/get", &HisApiController{}, "Get:GetAdditionalcharge")

	beego.Router("/api/hisprescription/get", &DialysisApiController{}, "Get:GetLastOrNextHisPrescription")

	beego.Router("/api/callhisprescription/get", &DialysisApiController{}, "Get:GetCallHisPrescription")

	beego.Router("/api/dayprescription/get", &HisApiController{}, "get:GetHisDayPrescription")

	beego.Router("/api/charge/list", &HisApiController{}, "get:GetHisChargePatientList")
	beego.Router("/api/charge/info", &HisApiController{}, "get:GetHisChargePatientInfo")

	beego.Router("/api/unregister/list", &HisApiController{}, "get:GetHisUnRegisterPatientList")

	beego.Router("/api/orderdetail/get", &HisApiController{}, "get:GetAllOrderDetail")
	beego.Router("/api/orderdetaicollect/get", &HisApiController{}, "get:GetAllOrderDetailCollect")

}

func (c *HisApiController) Sscard() {
	//r := CardInit()
	//if r == 0 {
	//	GetBaseInfo()
	//}
	//c.ServeSuccessJSON(map[string]interface{}{
	//	"list": "11",
	//})

}

func GetBaseInfo() error {
	//handle := syscall.MustLoadDLL("SSCard.dll")
	//ReadCardBas := handle.MustFindProc("ReadCardBas")
	//
	//str := make([]byte, 256)
	//str1 := make([]byte, 256)
	//r, _, ferr := ReadCardBas.Call((uintptr)(unsafe.Pointer(&str[0])), IntPtr(1024), (uintptr)(unsafe.Pointer(&str1[0])), IntPtr(1024))
	//if ferr != nil {
	//	fmt.Println("ReadCardBas 报错", ferr.Error())
	//	return ferr
	//}
	//
	//fmt.Println(string(str))
	//
	//fmt.Println(r)
	return nil
}

func CardInit() int {
	//DllTestDef := syscall.MustLoadDLL("SSCard.dll")
	//add := DllTestDef.MustFindProc("Init")
	//ret, _, err := add.Call(StrPtr("http://igb.hsa.gdgov.cn/gdyb_inf/poc/api/card/initDll"), StrPtr("440200"))
	//if err != nil {
	//	fmt.Println("SSCard的运算结果为:", ret)
	//}
	//result := int(ret)
	return 0
}

func IntPtr(n int) uintptr {
	return uintptr(n)
}

func StrPtr(s string) uintptr {
	return uintptr(unsafe.Pointer(syscall.StringBytePtr(s)))
}

func (c *HisApiController) GetHisPatientList() {
	types, _ := c.GetInt64("type", 0)
	record_date := c.GetString("record_date")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")

	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	recordDateTime := theTime.Unix()
	adminInfo := c.GetAdminUserInfo()
	patients, _ := service.GetScheduleHisPatientList(adminInfo.CurrentOrgId, "", recordDateTime)
	patients_two, _ := service.GetHisPatientList(adminInfo.CurrentOrgId, "", recordDateTime)
	patients = append(patients, patients_two...)
	patients = RemoveRepeatedPatient(patients)

	var total_one int64
	var total_two int64

	//获取当前用户的信息
	adminUserInfo, _ := service.GetAdminUserInfoByID(adminInfo.CurrentOrgId, adminInfo.AdminUser.Id)
	doctors, _ := service.GetHisAdminUserDoctors(adminInfo.CurrentOrgId)
	//获取所有科室信息
	department, _ := service.GetAllDepartMent(adminInfo.CurrentOrgId)

	for _, item := range patients {

		if item.HisPrescription == nil || len(item.HisPrescription) <= 0 {
			total_one = total_one + 1
		}
		if item.HisPrescription != nil && len(item.HisPrescription) > 0 {
			total_two = total_two + 1
		}
	}

	if types == 0 {
		c.ServeSuccessJSON(map[string]interface{}{
			"list":       patients,
			"total_one":  total_one,
			"total_two":  total_two,
			"info":       adminUserInfo,
			"doctors":    doctors,
			"department": department,
		})

	} else if types == 1 { //未就诊
		var patientsOne []*service.Patients
		for _, item := range patients {
			if item.HisPrescription == nil || len(item.HisPrescription) <= 0 {
				patientsOne = append(patientsOne, item)
			}
		}
		c.ServeSuccessJSON(map[string]interface{}{
			"list":       patientsOne,
			"total_one":  total_one,
			"total_two":  total_two,
			"info":       adminUserInfo,
			"doctors":    doctors,
			"department": department,
		})

	} else if types == 2 { //已就诊
		var patientsTwo []*service.Patients
		for _, item := range patients {

			if item.HisPrescription != nil && len(item.HisPrescription) > 0 {
				patientsTwo = append(patientsTwo, item)
			}
		}
		c.ServeSuccessJSON(map[string]interface{}{
			"list":       patientsTwo,
			"total_one":  total_one,
			"total_two":  total_two,
			"info":       adminUserInfo,
			"doctors":    doctors,
			"department": department,
		})
	}

}
func (c *HisApiController) GetHisPatientInfo() {
	patient_id, _ := c.GetInt64("patient_id")
	record_date := c.GetString("record_date")
	number := c.GetString("number")

	start_time := c.GetString("start_time")
	end_time := c.GetString("end_time")

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	recordDateTime := theTime.Unix()

	startTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
	if err != nil {

	}
	startRecordDateTime := startTime.Unix()

	endTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
	if err != nil {

	}
	endRecordDateTime := endTime.Unix()

	admin := c.GetAdminUserInfo()
	his_patient_info, _ := service.GetHisPatientInfo(admin.CurrentOrgId, patient_id, recordDateTime)
	xt_patient_info, _ := service.GetXTPatientInfo(admin.CurrentOrgId, patient_id)
	prescriptions, _ := service.GetHisPrescription(admin.CurrentOrgId, patient_id, recordDateTime)
	monthPrescriptions, _ := service.GetMonthHisPrescriptionTwo(admin.CurrentOrgId, patient_id, startRecordDateTime, endRecordDateTime)
	case_history, _ := service.GetHisPatientCaseHistoryInfo(admin.CurrentOrgId, patient_id, recordDateTime)
	patientPrescriptionInfo, _ := service.FindPatientPrescriptionInfo(admin.CurrentOrgId, patient_id, recordDateTime)
	order, _ := service.GetHisOrder(admin.CurrentOrgId, number, patient_id)

	doctors, _ := service.GetHisAdminUserDoctors(admin.CurrentOrgId)
	//获取所有科室信息
	department, _ := service.GetAllDepartMent(admin.CurrentOrgId)

	c.ServeSuccessJSON(map[string]interface{}{
		"his_info":            his_patient_info,
		"xt_info":             xt_patient_info,
		"prescription":        prescriptions,
		"case_history":        case_history,
		"info":                patientPrescriptionInfo,
		"month_prescriptions": monthPrescriptions,
		"order":               order,
		"doctors":             doctors,
		"department":          department,
	})
	return

}
func (c *HisApiController) GetHisPrescriptionConfig() {
	adminInfo := c.GetAdminUserInfo()
	//获取医嘱模版
	advices, _ := service.FindAllHisAdviceTemplate(adminInfo.CurrentOrgId)
	//获取所有基础药
	drugs, _ := service.GetAllDrugLibList(adminInfo.CurrentOrgId)
	drugways, _, _ := service.GetDrugWayDics(adminInfo.CurrentOrgId)
	efs, _, _ := service.GetExecutionFrequencyDics(adminInfo.CurrentOrgId)
	doctors, _ := service.GetHisAdminUserDoctors(adminInfo.CurrentOrgId)
	//获取所有科室信息
	department, _ := service.GetAllDepartMent(adminInfo.CurrentOrgId)

	//获取诊断信息

	sick, _ := service.FindAllSick(adminInfo.CurrentOrgId)

	diagnose, _ := service.FindAllDiagnose(adminInfo.CurrentOrgId)

	additions, _ := service.FindAllAddition(adminInfo.CurrentOrgId)

	c.ServeSuccessJSON(map[string]interface{}{
		"drugs":            drugs,
		"advices_template": advices,
		"drugways":         drugways,
		"efs":              efs,
		"doctors":          doctors,
		"department":       department,
		"sick":             sick,
		"additions":        additions,
		"diagnose":         diagnose,
	})
}
func (c *HisApiController) CreateHisPrescription() {
	record_date := c.GetString("record_date")
	patient_id, _ := c.GetInt64("patient_id")
	reg_type, _ := c.GetInt64("reg_type")
	diagnose, _ := c.GetInt64("diagnose")
	sick_type, _ := c.GetInt64("sick_type")
	sick_history := c.GetString("sick_history")
	doctor_id, _ := c.GetInt64("doctor", 0)
	department, _ := c.GetInt64("department", 0)
	his_patient_id, _ := c.GetInt64("his_patient_id")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	adminInfo := c.GetAdminUserInfo()
	recordDateTime := theTime.Unix()

	role, _ := service.GetAdminUserInfoByID(adminInfo.CurrentOrgId, doctor_id)

	info, _ := service.FindPatientPrescriptionInfo(adminInfo.CurrentOrgId, patient_id, recordDateTime)
	var hpInfo models.HisPrescriptionInfo
	if info.ID == 0 {
		var randNum int
		randNum = rand.Intn(10000) + 1000
		timestamp := time.Now().Unix()
		tempTime := time.Unix(timestamp, 0)
		timeFormat := tempTime.Format("20060102150405")
		p_number := timeFormat + strconv.FormatInt(int64(randNum), 10) + strconv.FormatInt(int64(adminInfo.CurrentOrgId), 10) + strconv.FormatInt(int64(patient_id), 10)

		hpInfo = models.HisPrescriptionInfo{
			UserOrgId:          adminInfo.CurrentOrgId,
			RecordDate:         theTime.Unix(),
			PatientId:          patient_id,
			Status:             1,
			Ctime:              time.Now().Unix(),
			Mtime:              time.Now().Unix(),
			Creator:            adminInfo.AdminUser.Id,
			Modifier:           adminInfo.AdminUser.Id,
			Diagnosis:          diagnose,
			SickHistory:        sick_history,
			Departments:        department,
			RegisterType:       reg_type,
			PrescriptionNumber: p_number,
			PrescriptionStatus: 1,
			Doctor:             role.UserName,
			DoctorId:           doctor_id,
			SickType:           sick_type,
		}
		service.SavePatientPrescriptionInfo(hpInfo)

	} else {
		hpInfo = models.HisPrescriptionInfo{
			ID:                 info.ID,
			UserOrgId:          adminInfo.CurrentOrgId,
			RecordDate:         info.RecordDate,
			PatientId:          info.PatientId,
			Status:             1,
			Ctime:              info.Ctime,
			Mtime:              time.Now().Unix(),
			Creator:            info.Creator,
			Modifier:           adminInfo.AdminUser.Id,
			Diagnosis:          diagnose,
			SickHistory:        sick_history,
			Departments:        department,
			RegisterType:       reg_type,
			PrescriptionNumber: info.PrescriptionNumber,
			Doctor:             role.UserName,
			PrescriptionStatus: info.PrescriptionStatus,
			DoctorId:           doctor_id,
			SickType:           sick_type,
		}
		service.SavePatientPrescriptionInfo(hpInfo)
	}

	if dataBody["prescriptions"] != nil && reflect.TypeOf(dataBody["prescriptions"]).String() == "[]interface {}" {
		prescriptions, _ := dataBody["prescriptions"].([]interface{})

		if len(prescriptions) > 0 {
			for _, item := range prescriptions {
				items := item.(map[string]interface{})
				if items["id"] == nil || reflect.TypeOf(items["id"]).String() != "float64" {
					utils.ErrorLog("id")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				id := int64(items["id"].(float64))

				if items["type"] == nil || reflect.TypeOf(items["type"]).String() != "float64" {
					utils.ErrorLog("type")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				types := int64(items["type"].(float64))

				if items["pre_time"] == nil || reflect.TypeOf(items["pre_time"]).String() != "string" {
					utils.ErrorLog("pre_time")
				}
				preTime, _ := items["pre_time"].(string)
				timeLayout := "2006-01-02"
				loc, _ := time.LoadLocation("Local")
				theTime2, err := time.ParseInLocation(timeLayout+" 15:04", preTime, loc)
				if err != nil {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				pTime := theTime2.Unix()

				ctime := time.Now().Unix()
				prescription := &models.HisPrescription{
					ID:                 id,
					PatientId:          patient_id,
					UserOrgId:          adminInfo.CurrentOrgId,
					RecordDate:         recordDateTime,
					Ctime:              ctime,
					Mtime:              ctime,
					Type:               types,
					Modifier:           adminInfo.AdminUser.Id,
					Creator:            adminInfo.AdminUser.Id,
					Status:             1,
					Doctor:             role.UserName,
					HisPatientId:       his_patient_id,
					OrderStatus:        1,
					BatchNumber:        "",
					PrescriptionNumber: hpInfo.PrescriptionNumber,
					PreTime:            pTime,
				}
				service.SaveHisPrescription(prescription)

				//更改患者挂号状态
				_, err2 := service.UpdateHisPatientIsReturn(patient_id, recordDateTime, adminInfo.CurrentOrgId)
				fmt.Println("更改失败", err2)
				if items["advices"] != nil && reflect.TypeOf(items["advices"]).String() == "[]interface {}" {
					advices := items["advices"].([]interface{})
					//group := service.GetMaxAdviceGroupID(adminInfo.CurrentOrgId)
					groupNo := int64(0)
					ctime := time.Now().Unix()
					mtime := ctime
					if len(advices) > 0 {
						for _, advice := range advices {
							var s models.HisDoctorAdviceInfo
							s.PrescriptionId = prescription.ID
							s.AdviceType = 2
							s.AdviceDoctor = adminInfo.AdminUser.Id
							s.StopState = 2
							s.ExecutionState = 2
							s.AdviceDate = recordDateTime
							s.Status = 1
							s.UserOrgId = adminInfo.CurrentOrgId
							s.RecordDate = recordDateTime
							s.StartTime = prescription.PreTime
							s.Groupno = groupNo
							s.CreatedTime = ctime
							s.UpdatedTime = mtime
							s.PatientId = patient_id
							s.HisPatientId = his_patient_id
							errcode := c.setAdviceWithJSON(&s, advice.(map[string]interface{}))
							if errcode > 0 {
								c.ServeFailJSONWithSGJErrorCode(errcode)
								return
							}
							service.CreateHisDoctorAdvice(&s)
							var randNum int
							randNum = rand.Intn(10000) + 1000
							timestamp := time.Now().Unix()
							tempTime := time.Unix(timestamp, 0)
							timeFormat := tempTime.Format("20060102150405")
							s.FeedetlSn = timeFormat + strconv.FormatInt(int64(randNum), 10) + "-" + "1" + "-" + strconv.FormatInt(s.ID, 10)
							service.CreateHisDoctorAdvice(&s)

						}
					}
				}
				if items["project"] != nil && reflect.TypeOf(items["project"]).String() == "[]interface {}" {
					projects := items["project"].([]interface{})
					if len(projects) > 0 {
						for _, project := range projects {
							var p models.HisPrescriptionProject
							p.PrescriptionId = prescription.ID
							p.Ctime = time.Now().Unix()
							p.Mtime = time.Now().Unix()
							p.PatientId = patient_id
							p.RecordDate = recordDateTime
							p.UserOrgId = adminInfo.CurrentOrgId
							p.HisPatientId = his_patient_id
							p.Status = 1
							errcode := c.setProjectWithJSON(&p, project.(map[string]interface{}))
							if errcode > 0 {
								c.ServeFailJSONWithSGJErrorCode(errcode)
								return
							}
							service.CreateHisProjectTwo(&p)
							var randNum int
							randNum = rand.Intn(10000) + 1000
							timestamp := time.Now().Unix()
							tempTime := time.Unix(timestamp, 0)
							timeFormat := tempTime.Format("20060102150405")
							p.FeedetlSn = timeFormat + strconv.FormatInt(int64(randNum), 10) + "-" + "2" + "-" + strconv.FormatInt(p.ID, 10)
							service.SaveHisProjectTwo(&p)

						}
					}
				}
				if items["addition"] != nil && reflect.TypeOf(items["addition"]).String() == "[]interface {}" {
					addition := items["addition"].([]interface{})
					//group := service.GetMaxAdviceGroupID(adminInfo.CurrentOrgId)
					ctime := time.Now().Unix()
					mtime := ctime
					if len(addition) > 0 {
						for _, item := range addition {
							var s models.HisAdditionalCharge
							s.PrescriptionId = prescription.ID
							s.Status = 1
							s.UserOrgId = adminInfo.CurrentOrgId
							s.RecordDate = recordDateTime
							s.CreatedTime = ctime
							s.UpdatedTime = mtime
							s.PatientId = patient_id
							s.HisPatientId = his_patient_id
							errcode := c.setAddtionWithJSON(&s, item.(map[string]interface{}), adminInfo.CurrentOrgId)
							if errcode > 0 {
								c.ServeFailJSONWithSGJErrorCode(errcode)
								return
							}
							service.CreateAdditionalCharge(&s)
							var randNum int
							randNum = rand.Intn(10000) + 1000
							timestamp := time.Now().Unix()
							tempTime := time.Unix(timestamp, 0)
							timeFormat := tempTime.Format("20060102150405")
							s.FeedetlSn = timeFormat + strconv.FormatInt(int64(randNum), 10) + "-" + "3" + "-" + strconv.FormatInt(s.ID, 10)
							service.CreateAdditionalCharge(&s)

						}
					}
				}

			}
		}
	}
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"msg": "保存成功",
		})
		return

	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}
}
func (c *HisApiController) EditHisPrescription() {
	record_date := c.GetString("record_date")
	patient_id, _ := c.GetInt64("patient_id")
	reg_type, _ := c.GetInt64("reg_type")
	diagnose, _ := c.GetInt64("diagnose")
	sick_type, _ := c.GetInt64("sick_type")
	sick_history := c.GetString("sick_history")
	doctor_id, _ := c.GetInt64("doctor", 0)
	department, _ := c.GetInt64("department", 0)
	his_patient_id, _ := c.GetInt64("his_patient_id")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	adminInfo := c.GetAdminUserInfo()
	recordDateTime := theTime.Unix()

	role, _ := service.GetAdminUserInfoByID(adminInfo.CurrentOrgId, doctor_id)

	info, _ := service.FindPatientPrescriptionInfo(adminInfo.CurrentOrgId, patient_id, recordDateTime)
	var hpInfo models.HisPrescriptionInfo
	if info.ID == 0 {
		var randNum int
		randNum = rand.Intn(10000) + 1000
		timestamp := time.Now().Unix()
		tempTime := time.Unix(timestamp, 0)
		timeFormat := tempTime.Format("20060102150405")
		p_number := timeFormat + strconv.FormatInt(int64(randNum), 10) + strconv.FormatInt(int64(adminInfo.CurrentOrgId), 10) + strconv.FormatInt(int64(patient_id), 10)

		hpInfo = models.HisPrescriptionInfo{
			UserOrgId:          adminInfo.CurrentOrgId,
			RecordDate:         theTime.Unix(),
			PatientId:          patient_id,
			Status:             1,
			Ctime:              time.Now().Unix(),
			Mtime:              time.Now().Unix(),
			Creator:            adminInfo.AdminUser.Id,
			Modifier:           adminInfo.AdminUser.Id,
			Diagnosis:          diagnose,
			SickHistory:        sick_history,
			Departments:        department,
			RegisterType:       reg_type,
			PrescriptionNumber: p_number,
			PrescriptionStatus: 1,
			Doctor:             role.UserName,
			DoctorId:           doctor_id,
			SickType:           sick_type,
		}
		service.SavePatientPrescriptionInfo(hpInfo)

	} else {
		hpInfo = models.HisPrescriptionInfo{
			ID:                 info.ID,
			UserOrgId:          adminInfo.CurrentOrgId,
			RecordDate:         info.RecordDate,
			PatientId:          info.PatientId,
			Status:             1,
			Ctime:              info.Ctime,
			Mtime:              time.Now().Unix(),
			Creator:            info.Creator,
			Modifier:           adminInfo.AdminUser.Id,
			Diagnosis:          diagnose,
			SickHistory:        sick_history,
			Departments:        department,
			RegisterType:       reg_type,
			PrescriptionNumber: info.PrescriptionNumber,
			Doctor:             role.UserName,
			PrescriptionStatus: info.PrescriptionStatus,
			DoctorId:           doctor_id,
			SickType:           sick_type,
		}
		service.SavePatientPrescriptionInfo(hpInfo)
	}

	if dataBody["prescriptions"] != nil && reflect.TypeOf(dataBody["prescriptions"]).String() == "[]interface {}" {
		prescriptions, _ := dataBody["prescriptions"].([]interface{})

		if len(prescriptions) > 0 {
			for _, item := range prescriptions {
				items := item.(map[string]interface{})
				if items["id"] == nil || reflect.TypeOf(items["id"]).String() != "float64" {
					utils.ErrorLog("id")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				id := int64(items["id"].(float64))

				if items["type"] == nil || reflect.TypeOf(items["type"]).String() != "float64" {
					utils.ErrorLog("type")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				types := int64(items["type"].(float64))

				historyPrescription, _ := service.GetHisPrescriptionByID(adminInfo.CurrentOrgId, id)

				ctime := time.Now().Unix()

				prescription := &models.HisPrescription{
					ID:                 id,
					PatientId:          patient_id,
					UserOrgId:          adminInfo.CurrentOrgId,
					RecordDate:         recordDateTime,
					Ctime:              ctime,
					Mtime:              ctime,
					Type:               types,
					Modifier:           adminInfo.AdminUser.Id,
					Creator:            adminInfo.AdminUser.Id,
					Status:             1,
					Doctor:             role.UserName,
					HisPatientId:       his_patient_id,
					OrderStatus:        1,
					BatchNumber:        "",
					PrescriptionNumber: hpInfo.PrescriptionNumber,
				}

				if historyPrescription.ID > 0 {
					prescription.PreTime = historyPrescription.PreTime
				}

				service.SaveHisPrescription(prescription)

				if items["advices"] != nil && reflect.TypeOf(items["advices"]).String() == "[]interface {}" {
					advices := items["advices"].([]interface{})
					//group := service.GetMaxAdviceGroupID(adminInfo.CurrentOrgId)
					groupNo := int64(0)
					ctime := time.Now().Unix()
					mtime := ctime
					if len(advices) > 0 {
						for _, advice := range advices {
							var s models.HisDoctorAdviceInfo
							s.PrescriptionId = prescription.ID
							s.AdviceType = 2
							s.AdviceDoctor = adminInfo.AdminUser.Id
							s.StopState = 2
							s.ExecutionState = 2
							s.AdviceDate = recordDateTime
							s.Status = 1
							s.UserOrgId = adminInfo.CurrentOrgId
							s.RecordDate = recordDateTime
							s.StartTime = prescription.PreTime
							s.Groupno = groupNo
							s.CreatedTime = ctime
							s.UpdatedTime = mtime
							s.PatientId = patient_id
							s.HisPatientId = his_patient_id
							errcode := c.setAdviceWithJSONTwo(&s, advice.(map[string]interface{}))
							if errcode > 0 {
								c.ServeFailJSONWithSGJErrorCode(errcode)
								return
							}
							service.CreateHisDoctorAdvice(&s)

						}
					}
				}
				if items["project"] != nil && reflect.TypeOf(items["project"]).String() == "[]interface {}" {
					projects := items["project"].([]interface{})
					if len(projects) > 0 {
						for _, project := range projects {
							var p models.HisPrescriptionProject
							p.PrescriptionId = prescription.ID
							p.Ctime = time.Now().Unix()
							p.Mtime = time.Now().Unix()
							p.PatientId = patient_id
							p.RecordDate = recordDateTime
							p.UserOrgId = adminInfo.CurrentOrgId
							p.HisPatientId = his_patient_id
							p.Status = 1
							errcode := c.setProjectWithJSONTwo(&p, project.(map[string]interface{}))
							if errcode > 0 {
								c.ServeFailJSONWithSGJErrorCode(errcode)
								return
							}
							service.CreateHisProjectTwo(&p)

						}
					}
				}
				if items["addition"] != nil && reflect.TypeOf(items["addition"]).String() == "[]interface {}" {
					addition := items["addition"].([]interface{})
					//group := service.GetMaxAdviceGroupID(adminInfo.CurrentOrgId)
					ctime := time.Now().Unix()
					mtime := ctime
					if len(addition) > 0 {
						for _, item := range addition {
							var s models.HisAdditionalCharge
							s.PrescriptionId = prescription.ID
							s.Status = 1
							s.UserOrgId = adminInfo.CurrentOrgId
							s.RecordDate = recordDateTime
							s.CreatedTime = ctime
							s.UpdatedTime = mtime
							s.PatientId = patient_id
							s.HisPatientId = his_patient_id
							errcode := c.setAddtionWithJSONTwo(&s, item.(map[string]interface{}), adminInfo.CurrentOrgId)
							if errcode > 0 {
								c.ServeFailJSONWithSGJErrorCode(errcode)
								return
							}
							service.CreateAdditionalCharge(&s)
						}
					}
				}

			}
		}
	}
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"msg": "保存成功",
		})
		return

	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}
}

func (c *HisApiController) DeletePrescription() {
	prescription_id, _ := c.GetInt64("id")
	//TODO 需要判断是否已经结算
	err := service.DelelteHisPrescription(prescription_id, c.GetAdminUserInfo().CurrentOrgId)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"msg": "删除成功",
		})
		return
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}
}

func (c *HisApiController) DeleteDoctorAdvice() {
	id, _ := c.GetInt64("id")
	//TODO 需要判断是否已经结算
	err := service.DelelteDoctorAdvice(id, c.GetAdminUserInfo().CurrentOrgId)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"msg": "删除成功",
		})
		return
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}
}

func (c *HisApiController) DeleteProject() {
	id, _ := c.GetInt64("id")
	//TODO 需要判断是否已经结算
	err := service.DelelteProject(id, c.GetAdminUserInfo().CurrentOrgId)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"msg": "删除成功",
		})
		return
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}
}

func (c *HisApiController) CreateHisAdditionalCharge() {
	his_patient_id, _ := c.GetInt64("his_patient_id")
	patient_id, _ := c.GetInt64("patient_id")
	record_date := c.GetString("record_date")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	adminInfo := c.GetAdminUserInfo()
	recordDateTime := theTime.Unix()
	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
	}

	var additions []*models.HisAdditionalCharge
	if dataBody["addition"] != nil && reflect.TypeOf(dataBody["addition"]).String() == "[]interface {}" {
		additions, _ := dataBody["addition"].([]interface{})
		if len(additions) > 0 {
			for _, item := range additions {
				items := item.(map[string]interface{})

				if items["item_id"] == nil || reflect.TypeOf(items["item_id"]).String() != "float64" {
					utils.ErrorLog("item_id")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				item_id := int64(items["item_id"].(float64))

				if items["item_name"] == nil || reflect.TypeOf(items["item_name"]).String() != "string" {
					utils.ErrorLog("item_name")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				item_name := items["item_name"].(string)

				if items["price"] == nil || reflect.TypeOf(items["price"]).String() != "string" {
					utils.ErrorLog("price")
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				price, _ := strconv.ParseFloat(items["price"].(string), 64)

				ctime := time.Now().Unix()
				additional := &models.HisAdditionalCharge{
					PatientId:    patient_id,
					HisPatientId: his_patient_id,
					UserOrgId:    adminInfo.CurrentOrgId,
					RecordDate:   recordDateTime,
					CreatedTime:  ctime,
					UpdatedTime:  ctime,
					Modifier:     adminInfo.AdminUser.Id,
					Creator:      adminInfo.AdminUser.Id,
					Price:        price,
					ItemName:     item_name,
					ItemId:       item_id,
					Status:       1,
				}
				additions = append(additions, additional)
			}
		}
	}
	for _, item := range additions {
		service.CreateAddtionalCharge(item)
	}
	c.ServeSuccessJSON(map[string]interface{}{
		"msg": "创建成功",
	})
}

func (c *HisApiController) CreateHisPatientCaseHistory() {

	blood_fat := c.GetString("blood_fat")
	bloodfatfloat, _ := strconv.ParseFloat(blood_fat, 64)
	//fmt.Println("33333333", bloodfatfloat)
	blood_sugar := c.GetString("blood_sugar")
	bloodsugarfloat, _ := strconv.ParseFloat(blood_sugar, 64)
	fmt.Println(bloodsugarfloat)
	chief_conplaint := c.GetString("chief_conplaint")

	dbp := c.GetString("dbp")
	dbpfloat, _ := strconv.ParseFloat(dbp, 64)
	delivery_way, _ := c.GetInt64("delivery_way")
	diagnostic := c.GetString("diagnostic")
	fmt.Println("diagnostic", diagnostic)
	family_history := c.GetString("family_history")
	fmt.Println(family_history)
	height := c.GetString("height")
	history_of_present_illness := c.GetString("history_of_present_illness")
	is_infect, _ := c.GetInt64("is_infect")
	fmt.Println("is", is_infect)
	past_history := c.GetString("past_history")
	patient_id, _ := c.GetInt64("patient_id")
	his_patient_id, _ := c.GetInt64("his_patient_id")
	fmt.Println("patient_id", patient_id)
	personal_history := c.GetString("personal_history")
	pulse := c.GetString("pulse")
	pulsefloat, _ := strconv.ParseFloat(pulse, 64)
	sbp := c.GetString("sbp")
	sbpfloat, _ := strconv.ParseFloat(sbp, 64)
	heightfloat, _ := strconv.ParseFloat(height, 64)
	sicktype := c.GetString("sick_type")
	fmt.Println("sicketype", sicktype)
	sick_type, _ := strconv.ParseInt(sicktype, 10, 64)
	symptom := c.GetString("symptom")
	sick_date := c.GetString("sick_date")
	temperatures := c.GetString("temperature")
	fmt.Println("temperatures", temperatures)
	temperature, _ := strconv.ParseFloat(temperatures, 64)
	record_date := c.GetString("record_date")
	breathing := c.GetString("breathing")
	doctor_advice := c.GetString("doctor_advice")
	remark := c.GetString("remark")
	breathingfloat, _ := strconv.ParseFloat(breathing, 64)
	fmt.Println("breathingfloat", breathingfloat)
	sick, _ := c.GetInt64("sick")
	diagnose, _ := c.GetInt64("diagnose")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	recordDateTime := theTime.Unix()
	fmt.Println("recordDataTime", recordDateTime)
	sickTime, err := time.ParseInLocation(timeLayout+" 15:04:05", sick_date+" 00:00:00", loc)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	sickTimes := sickTime.Unix()
	ctime := time.Now().Unix()
	caseHistory := models.HisPatientCaseHistory{
		HisPatientId:            his_patient_id,
		PatientId:               patient_id,
		Temperature:             temperature,
		BloodSugar:              bloodsugarfloat,
		Pulse:                   pulsefloat,
		Sbp:                     sbpfloat,
		Dbp:                     dbpfloat,
		Height:                  heightfloat,
		BloodFat:                bloodfatfloat,
		SickType:                sick_type,
		Symptom:                 symptom,
		SickDate:                sickTimes,
		IsInfect:                is_infect,
		HistoryOfPresentIllness: history_of_present_illness,
		PastHistory:             past_history,
		Doctor:                  c.GetAdminUserInfo().AdminUser.Id,
		ChiefConplaint:          chief_conplaint,
		PersonalHistory:         personal_history,
		FamilyHistory:           family_history,
		Diagnostic:              diagnostic,
		UserOrgId:               c.GetAdminUserInfo().CurrentOrgId,
		Status:                  1,
		Ctime:                   ctime,
		Mtime:                   ctime,
		RecordDate:              recordDateTime,
		DeliveryWay:             delivery_way,
		Breathing:               breathingfloat,
		DoctorAdvice:            doctor_advice,
		Remark:                  remark,
		Sick:                    sick,
		Diagnose:                diagnose,
	}

	err = service.SaveHisPatientCaseHistory(&caseHistory)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateConfig)
		return
	}
	c.ServeSuccessJSON(map[string]interface{}{
		"caseHistory": caseHistory,
	})
	return

	//查询该患者是否有病历
	//_, errcode := service.GetHisPatientCaseHistoryById(his_patient_id)
	//if errcode == gorm.ErrRecordNotFound {
	//	err = service.SaveHisPatientCaseHistory(caseHistory)
	//	if err != nil {
	//		c.ServeSuccessJSON(map[string]interface{}{
	//			"msg": "保存成功",
	//		})
	//	}
	//} else if errcode == nil {
	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateConfig)
	//	return
	//}

}
func (c *HisApiController) GetHisPatientCaseHistoryList() {
	patient_id, _ := c.GetInt64("patient_id", 0)
	adminUser := c.GetAdminUserInfo()
	caseHistorys, _ := service.GetHisPatientCaseHistoryList(adminUser.CurrentOrgId, patient_id)
	c.ServeSuccessJSON(map[string]interface{}{
		"list": caseHistorys,
	})

}
func (c *HisApiController) GetHisPatientCaseHistory() {
	record_date, _ := c.GetInt64("record_date", 0)
	patient_id, _ := c.GetInt64("patient_id", 0)
	admin := c.GetAdminUserInfo()
	info, _ := service.GetHisPatientInfo(admin.CurrentOrgId, patient_id, record_date)
	case_history, _ := service.GetHisPatientCaseHistoryInfo(admin.CurrentOrgId, patient_id, record_date)
	c.ServeSuccessJSON(map[string]interface{}{
		"info":         info,
		"case_history": case_history,
	})

}
func (c *HisApiController) CreateCaseHistoryTemplate() {
	template_name := c.GetString("template_name")
	fmt.Println("template_name22222222222222", template_name)
	template_remark := c.GetString("template_remark")
	doctor := c.GetAdminUserInfo().AdminUser.Id
	diagnostic := c.GetString("diagnostic")
	chief_conplaint := c.GetString("chief_conplain")
	history_of_present_illness := c.GetString("history_of_present_illness")
	past_history := c.GetString("past_history")
	personal_history := c.GetString("personal_history")
	family_history := c.GetString("family_history")
	user_name := c.GetString("user_name")
	doctor_advice := c.GetString("doctor_advice")
	remark := c.GetString("remark")
	//record_date := c.GetString("record_date")
	//fmt.Println("record_date--------",record_date)
	//timeLayout := "2006-01-02"
	//loc, _ := time.LoadLocation("Local")
	//
	//theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	//if err != nil {
	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
	//	return
	//}
	//recordDateTime := theTime.Unix()

	ctime := time.Now().Unix()

	template := models.HisCaseHistoryTemplate{
		HistoryOfPresentIllness: history_of_present_illness,
		PastHistory:             past_history,
		ChiefConplaint:          chief_conplaint,
		PersonalHistory:         personal_history,
		FamilyHistory:           family_history,
		Diagnostic:              diagnostic,
		UserOrgId:               c.GetAdminUserInfo().CurrentOrgId,
		Status:                  1,
		Ctime:                   ctime,
		Mtime:                   ctime,
		RecordDate:              time.Now().Unix(),
		TemplateName:            template_name,
		TemplateRemark:          template_remark,
		Creator:                 doctor,
		Modifier:                doctor,
		UserName:                user_name,
		DoctorAdvice:            doctor_advice,
		Remark:                  remark,
	}

	err := service.SaveHisPatientCaseHistoryTemplate(template)

	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"msg": "保存成功",
		})

	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}

}
func (c *HisApiController) GetCaseHistoryTemplate() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	keyword := c.GetString("keyword")
	start_time := c.GetString("start_time")
	end_time := c.GetString("end_time")
	startTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
	endTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
	admin := c.GetAdminUserInfo()
	template, _ := service.GetHisPatientCaseHistoryTemplate(admin.CurrentOrgId, startTime.Unix(), endTime.Unix(), keyword)
	//history, _ := service.GetHisPatientCaseHistory(admin.CurrentOrgId)
	c.ServeSuccessJSON(map[string]interface{}{
		"template": template,
		//"history":  history,
	})

}

func (c *HisApiController) setAdviceWithJSONTwo(advice *models.HisDoctorAdviceInfo, json map[string]interface{}) int {

	if json["drug_name"] == nil || reflect.TypeOf(json["drug_name"]).String() != "string" {
		utils.ErrorLog("drug_name")
		return enums.ErrorCodeParamWrong
	}
	adviceName, _ := json["drug_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["id"] == nil {
		advice.DrugId = 0
	} else {
		if json["id"] != nil || reflect.TypeOf(json["id"]).String() == "float64" {
			drug_id := int64(json["id"].(float64))
			advice.DrugId = drug_id
		}
	}
	if json["advice_id"] != nil && reflect.TypeOf(json["advice_id"]).String() == "float64" {
		advice_id := int64(json["advice_id"].(float64))
		advice.ID = advice_id
		if advice.ID > 0 {
			hisAdvice, err := service.GetHisDoctorAdvicesById(advice.ID)
			if err == nil {
				if hisAdvice.ID > 0 {
					advice.ExecutionTime = hisAdvice.ExecutionTime
					advice.ExecutionStaff = hisAdvice.ExecutionStaff
					advice.ExecutionState = hisAdvice.ExecutionState
					advice.CheckTime = hisAdvice.CheckTime
					advice.Checker = hisAdvice.Checker
					advice.CheckState = hisAdvice.CheckState
					advice.StartTime = hisAdvice.StartTime
					advice.FeedetlSn = hisAdvice.FeedetlSn

				}
			}
		}
	}

	//
	//if json["execution_time"] != nil && reflect.TypeOf(json["execution_time"]).String() == "string" {
	//	execution_time, _ := strconv.ParseInt(json["execution_time"].(string), 10,64)
	//	advice.ExecutionTime = execution_time
	//}
	//
	//
	//
	//if json["execution_staff"] != nil && reflect.TypeOf(json["execution_staff"]).String() == "string" {
	//	execution_staff, _ := strconv.ParseInt(json["execution_staff"].(string), 10,64)
	//	advice.ExecutionStaff = execution_staff
	//}
	//
	//
	//
	//if json["execution_state"] != nil && reflect.TypeOf(json["execution_state"]).String() == "string" {
	//	execution_state, _ := strconv.ParseInt(json["execution_state"].(string), 10,64)
	//	advice.ExecutionState = execution_state
	//}
	//
	//
	//if json["check_time"] != nil && reflect.TypeOf(json["check_time"]).String() == "string" {
	//	check_time, _ := strconv.ParseInt(json["check_time"].(string), 10,64)
	//	advice.CheckTime = check_time
	//}
	//
	//
	//if json["check_state"] != nil && reflect.TypeOf(json["check_state"]).String() == "string" {
	//	check_state, _ := strconv.ParseInt(json["check_state"].(string), 10,64)
	//	advice.CheckState = check_state
	//}
	//
	//
	//if json["checker"] != nil && reflect.TypeOf(json["checker"]).String() == "string" {
	//	checker, _ := strconv.ParseInt(json["checker"].(string), 10,64)
	//	advice.Checker = checker
	//}
	//
	//if json["start_time"] != nil && reflect.TypeOf(json["start_time"]).String() == "string" {
	//	start_time, _ := strconv.ParseInt(json["start_time"].(string), 10,64)
	//	advice.StartTime = start_time
	//}

	if json["min_unit"] != nil && reflect.TypeOf(json["min_unit"]).String() == "string" {
		drugSpecUnit, _ := json["min_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
	}

	if json["retail_price"] != nil || reflect.TypeOf(json["retail_price"]).String() == "string" {
		price, _ := strconv.ParseFloat(json["retail_price"].(string), 64)
		advice.Price = price
	}
	if json["medical_insurance_number"] != nil || reflect.TypeOf(json["medical_insurance_number"]).String() == "string" {
		med_list_codg, _ := json["medical_insurance_number"].(string)
		advice.MedListCodg = med_list_codg
	}
	if json["day"] != nil || reflect.TypeOf(json["day"]).String() == "float64" {
		day := int64(json["day"].(float64))
		advice.Day = day
	}
	return 0
}

func (c *HisApiController) setProjectWithJSONTwo(project *models.HisPrescriptionProject, json map[string]interface{}) int {
	if json["id"] != nil || reflect.TypeOf(json["id"]).String() == "float64" {
		id := int64(json["id"].(float64))
		project.ID = id
		historyProject, _ := service.GetHisProjectByID(id)
		project.FeedetlSn = historyProject.FeedetlSn

	}
	if json["project_id"] != nil || reflect.TypeOf(json["project_id"]).String() == "float64" {
		project_id := int64(json["project_id"].(float64))
		project.ProjectId = project_id

	}
	// if json["price"] != nil || reflect.TypeOf(json["price"]).String() == "float64" {
	// 	price := int64(json["price"].(float64))
	// 	formatInt_price := strconv.FormatInt(price, 10)
	// 	float_price, _ := strconv.ParseFloat(formatInt_price, 64)
	// 	project.Price = float_price
	// }
	if json["price"] != nil || reflect.TypeOf(json["price"]).String() == "string" {
		price, _ := strconv.ParseFloat(json["price"].(string), 64)
		project.Price = price
	}

	if json["total"] != nil && reflect.TypeOf(json["total"]).String() == "string" {
		total, _ := json["total"].(string)
		totals, _ := strconv.ParseInt(total, 10, 64)
		project.Count = totals
	}

	if json["medical_code"] != nil && reflect.TypeOf(json["medical_code"]).String() == "string" {
		medical_code, _ := json["medical_code"].(string)
		project.MedListCodg = medical_code
	}
	if json["single_dose"] != nil && reflect.TypeOf(json["single_dose"]).String() == "string" {
		single_dose, _ := json["single_dose"].(string)
		project.SingleDose = single_dose
	}

	if json["delivery_way"] != nil && reflect.TypeOf(json["delivery_way"]).String() == "string" {
		delivery_way, _ := json["delivery_way"].(string)
		project.DeliveryWay = delivery_way
	}
	if json["execution_frequency"] != nil && reflect.TypeOf(json["execution_frequency"]).String() == "string" {
		execution_frequency, _ := json["execution_frequency"].(string)
		project.ExecutionFrequency = execution_frequency
	}
	if json["remark"] != nil && reflect.TypeOf(json["remark"]).String() == "string" {
		remark, _ := json["remark"].(string)
		project.Remark = remark
	}
	if json["number_days"] != nil && reflect.TypeOf(json["number_days"]).String() == "string" {
		day, _ := json["number_days"].(string)
		project.Day = day
	}

	if json["unit"] != nil && reflect.TypeOf(json["unit"]).String() == "string" {
		unit, _ := json["unit"].(string)
		project.Unit = unit
	}
	return 0
}

func (c *HisApiController) setAddtionWithJSONTwo(additionalCharge *models.HisAdditionalCharge, json map[string]interface{}, org_id int64) int {
	if json["id"] != nil || reflect.TypeOf(json["id"]).String() == "float64" {
		id := int64(json["id"].(float64))
		historyAddtions, _ := service.GetHisAdditionByID(id)
		additionalCharge.ID = id
		additionalCharge.FeedetlSn = historyAddtions.FeedetlSn
	}
	if json["item_id"] != nil || reflect.TypeOf(json["item_id"]).String() == "float64" {
		item_id := int64(json["item_id"].(float64))
		additionalCharge.ItemId = item_id
		config, _ := service.GetAdditionChargeByID(org_id, item_id)
		if config.ID > 0 {
			if len(config.Code) > 0 {
				additionalCharge.MedListCodg = config.Code
			}
		}
	}
	// if json["price"] != nil || reflect.TypeOf(json["price"]).String() == "float64" {
	// 	price := int64(json["price"].(float64))
	// 	formatInt_price := strconv.FormatInt(price, 10)
	// 	float_price, _ := strconv.ParseFloat(formatInt_price, 64)
	// 	additionalCharge.Price = float_price
	// }

	//if json["price"] != nil || reflect.TypeOf(json["price"]).String() == "float64" {
	//	price := int64(json["price"].(float64))
	//	formatInt_price := strconv.FormatInt(price, 10)
	//	float_price, _ := strconv.ParseFloat(formatInt_price, 64)
	//	additionalCharge.Price = float_price
	//}

	if json["price"] != nil || reflect.TypeOf(json["price"]).String() == "string" {
		price, _ := strconv.ParseFloat(json["price"].(string), 64)
		additionalCharge.Price = price
	}
	if json["count"] != nil && reflect.TypeOf(json["count"]).String() == "string" {
		count, _ := json["count"].(string)
		counts, _ := strconv.ParseInt(count, 10, 64)
		additionalCharge.Count = counts
	}
	if json["item_name"] != nil && reflect.TypeOf(json["item_name"]).String() == "string" {
		item_name, _ := json["item_name"].(string)
		additionalCharge.ItemName = item_name
	}

	return 0
}

func (c *HisApiController) setAdviceWithJSON(advice *models.HisDoctorAdviceInfo, json map[string]interface{}) int {

	if json["drug_name"] == nil || reflect.TypeOf(json["drug_name"]).String() != "string" {
		utils.ErrorLog("drug_name")
		return enums.ErrorCodeParamWrong
	}
	adviceName, _ := json["drug_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["id"] == nil {
		advice.DrugId = 0
	} else {
		if json["id"] != nil || reflect.TypeOf(json["id"]).String() == "float64" {
			drug_id := int64(json["id"].(float64))
			advice.DrugId = drug_id
		}
	}
	if json["advice_id"] != nil && reflect.TypeOf(json["advice_id"]).String() == "float64" {
		advice_id := int64(json["advice_id"].(float64))
		advice.ID = advice_id
		if advice.ID > 0 {
			hisAdvice, err := service.GetHisDoctorAdvicesById(advice.ID)
			if err == nil {
				if hisAdvice.ID > 0 {
					advice.ExecutionTime = hisAdvice.ExecutionTime
					advice.ExecutionStaff = hisAdvice.ExecutionStaff
					advice.ExecutionState = hisAdvice.ExecutionState
					advice.CheckTime = hisAdvice.CheckTime
					advice.Checker = hisAdvice.Checker
					advice.CheckState = hisAdvice.CheckState
					advice.StartTime = hisAdvice.StartTime

				}
			}
		}
	}

	//
	//if json["execution_time"] != nil && reflect.TypeOf(json["execution_time"]).String() == "string" {
	//	execution_time, _ := strconv.ParseInt(json["execution_time"].(string), 10,64)
	//	advice.ExecutionTime = execution_time
	//}
	//
	//
	//
	//if json["execution_staff"] != nil && reflect.TypeOf(json["execution_staff"]).String() == "string" {
	//	execution_staff, _ := strconv.ParseInt(json["execution_staff"].(string), 10,64)
	//	advice.ExecutionStaff = execution_staff
	//}
	//
	//
	//
	//if json["execution_state"] != nil && reflect.TypeOf(json["execution_state"]).String() == "string" {
	//	execution_state, _ := strconv.ParseInt(json["execution_state"].(string), 10,64)
	//	advice.ExecutionState = execution_state
	//}
	//
	//
	//if json["check_time"] != nil && reflect.TypeOf(json["check_time"]).String() == "string" {
	//	check_time, _ := strconv.ParseInt(json["check_time"].(string), 10,64)
	//	advice.CheckTime = check_time
	//}
	//
	//
	//if json["check_state"] != nil && reflect.TypeOf(json["check_state"]).String() == "string" {
	//	check_state, _ := strconv.ParseInt(json["check_state"].(string), 10,64)
	//	advice.CheckState = check_state
	//}
	//
	//
	//if json["checker"] != nil && reflect.TypeOf(json["checker"]).String() == "string" {
	//	checker, _ := strconv.ParseInt(json["checker"].(string), 10,64)
	//	advice.Checker = checker
	//}
	//
	//if json["start_time"] != nil && reflect.TypeOf(json["start_time"]).String() == "string" {
	//	start_time, _ := strconv.ParseInt(json["start_time"].(string), 10,64)
	//	advice.StartTime = start_time
	//}

	if json["min_unit"] != nil && reflect.TypeOf(json["min_unit"]).String() == "string" {
		drugSpecUnit, _ := json["min_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
	}

	if json["retail_price"] != nil || reflect.TypeOf(json["retail_price"]).String() == "string" {
		price, _ := strconv.ParseFloat(json["retail_price"].(string), 64)
		advice.Price = price
	}
	if json["medical_insurance_number"] != nil || reflect.TypeOf(json["medical_insurance_number"]).String() == "string" {
		med_list_codg, _ := json["medical_insurance_number"].(string)
		advice.MedListCodg = med_list_codg
	}
	if json["day"] != nil || reflect.TypeOf(json["day"]).String() == "float64" {
		day := int64(json["day"].(float64))
		advice.Day = day
	}
	return 0
}

func (c *HisApiController) setProjectWithJSON(project *models.HisPrescriptionProject, json map[string]interface{}) int {
	if json["id"] != nil || reflect.TypeOf(json["id"]).String() == "float64" {
		id := int64(json["id"].(float64))
		project.ID = id
	}
	if json["project_id"] != nil || reflect.TypeOf(json["project_id"]).String() == "float64" {
		project_id := int64(json["project_id"].(float64))
		project.ProjectId = project_id
		fmt.Println(project_id)
		fmt.Println(project.ProjectId)
	}
	// if json["price"] != nil || reflect.TypeOf(json["price"]).String() == "float64" {
	// 	price := int64(json["price"].(float64))
	// 	formatInt_price := strconv.FormatInt(price, 10)
	// 	float_price, _ := strconv.ParseFloat(formatInt_price, 64)
	// 	project.Price = float_price
	// }
	if json["price"] != nil || reflect.TypeOf(json["price"]).String() == "string" {
		price, _ := strconv.ParseFloat(json["price"].(string), 64)
		project.Price = price
	}

	if json["total"] != nil && reflect.TypeOf(json["total"]).String() == "string" {
		total, _ := json["total"].(string)
		totals, _ := strconv.ParseInt(total, 10, 64)
		project.Count = totals
	}

	if json["medical_code"] != nil && reflect.TypeOf(json["medical_code"]).String() == "string" {
		medical_code, _ := json["medical_code"].(string)
		project.MedListCodg = medical_code
	}
	if json["single_dose"] != nil && reflect.TypeOf(json["single_dose"]).String() == "string" {
		single_dose, _ := json["single_dose"].(string)
		project.SingleDose = single_dose
	}

	if json["delivery_way"] != nil && reflect.TypeOf(json["delivery_way"]).String() == "string" {
		delivery_way, _ := json["delivery_way"].(string)
		project.DeliveryWay = delivery_way
	}
	if json["execution_frequency"] != nil && reflect.TypeOf(json["execution_frequency"]).String() == "string" {
		execution_frequency, _ := json["execution_frequency"].(string)
		project.ExecutionFrequency = execution_frequency
	}
	if json["remark"] != nil && reflect.TypeOf(json["remark"]).String() == "string" {
		remark, _ := json["remark"].(string)
		project.Remark = remark
	}
	if json["number_days"] != nil && reflect.TypeOf(json["number_days"]).String() == "string" {
		day, _ := json["number_days"].(string)
		project.Day = day
	}

	if json["unit"] != nil && reflect.TypeOf(json["unit"]).String() == "string" {
		unit, _ := json["unit"].(string)
		project.Unit = unit
	}
	return 0
}

func (c *HisApiController) setAddtionWithJSON(additionalCharge *models.HisAdditionalCharge, json map[string]interface{}, org_id int64) int {
	if json["id"] != nil || reflect.TypeOf(json["id"]).String() == "float64" {
		id := int64(json["id"].(float64))
		additionalCharge.ID = id
	}
	if json["item_id"] != nil || reflect.TypeOf(json["item_id"]).String() == "float64" {
		item_id := int64(json["item_id"].(float64))
		additionalCharge.ItemId = item_id
		config, _ := service.GetAdditionChargeByID(org_id, item_id)
		if config.ID > 0 {
			if len(config.Code) > 0 {
				additionalCharge.MedListCodg = config.Code
			}
		}
	}
	// if json["price"] != nil || reflect.TypeOf(json["price"]).String() == "float64" {
	// 	price := int64(json["price"].(float64))
	// 	formatInt_price := strconv.FormatInt(price, 10)
	// 	float_price, _ := strconv.ParseFloat(formatInt_price, 64)
	// 	additionalCharge.Price = float_price
	// }

	//if json["price"] != nil || reflect.TypeOf(json["price"]).String() == "float64" {
	//	price := int64(json["price"].(float64))
	//	formatInt_price := strconv.FormatInt(price, 10)
	//	float_price, _ := strconv.ParseFloat(formatInt_price, 64)
	//	additionalCharge.Price = float_price
	//}

	if json["price"] != nil || reflect.TypeOf(json["price"]).String() == "string" {
		price, _ := strconv.ParseFloat(json["price"].(string), 64)
		additionalCharge.Price = price
	}
	if json["count"] != nil && reflect.TypeOf(json["count"]).String() == "string" {
		count, _ := json["count"].(string)
		counts, _ := strconv.ParseInt(count, 10, 64)
		additionalCharge.Count = counts
	}
	if json["item_name"] != nil && reflect.TypeOf(json["item_name"]).String() == "string" {
		item_name, _ := json["item_name"].(string)
		additionalCharge.ItemName = item_name
	}

	return 0
}

func (c *HisApiController) GetHisOrderList() {
	page, _ := c.GetInt64("page", -1)
	limit, _ := c.GetInt64("limit", -1)
	start_time := c.GetString("start_time")
	end_time := c.GetString("end_time")
	types, _ := c.GetInt64("type", 0)
	keywords := c.GetString("keywords")

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			fmt.Println(err)
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}

	adminUser := c.GetAdminUserInfo()
	org_id := adminUser.CurrentOrgId
	order, err, total := service.GetHisOrderList(org_id, page, limit, startTime, endTime, types, keywords)

	for _, item := range order {
		info, _ := service.GetHisPrescriptionByPatientID(item.PatientId, item.UserOrgId)
		item.DoctorName = info.Doctor
		item.DepartmentName = info.XtHisDepartment.Name
	}

	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"order": order,
			"total": total,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
}

func (c *HisApiController) GetHisOrder() {
	patient_id, _ := c.GetInt64("patient_id", 0)
	number := c.GetString("number")
	adminInfo := c.GetAdminUserInfo()
	order, err := service.GetHisOrder(adminInfo.CurrentOrgId, number, patient_id)
	prescriptions, _ := service.GetHisPrescriptionThree(adminInfo.CurrentOrgId, patient_id, order.Number)

	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"order":        order,
			"prescription": prescriptions,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

}

func (c *HisApiController) GetHisPrescriptionList() {
	record_date := c.GetString("record_date")
	keywords := c.GetString("keywords")
	page, _ := c.GetInt64("page")
	limit, _ := c.GetInt64("limit")

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	recordDateTime := theTime.Unix()
	adminInfo := c.GetAdminUserInfo()
	prescriptionOrder, err, total := service.GetHisPatientPrescriptionList(adminInfo.CurrentOrgId, keywords, recordDateTime, page, limit)

	//adminInfo := c.GetAdminUserInfo()
	//prescriptionOrder, err := service.GetHisPrescriptionOrderList(adminInfo.CurrentOrgId)
	//fmt.Println(prescriptionOrder)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"order": prescriptionOrder,
			"total": total,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
}

func (c *HisApiController) GetHisPrescriptionInfo() {
	id, _ := c.GetInt64("id")
	adminInfo := c.GetAdminUserInfo()
	prescriptionOrder, err := service.GetHisPrescriptionOrderInfo(id, adminInfo.CurrentOrgId)
	prescription, err := service.GetHisPrescriptionFour(adminInfo.CurrentOrgId, prescriptionOrder.PatientId, prescriptionOrder.RecordDate, prescriptionOrder.PrescriptionNumber)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"order":        prescriptionOrder,
			"prescription": prescription,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
}

func (c *HisApiController) GetMedicalInsuranceConfig() {
	adminUser := c.GetAdminUserInfo()
	config, _ := service.GetMedicalInsuranceConfig(adminUser.CurrentOrgId)
	c.ServeSuccessJSON(map[string]interface{}{
		"config": config,
	})

}

type ResultTwo struct {
	ErrMsg      interface{} `json:"err_msg"`
	InfRefmsgid string      `json:"inf_refmsgid"`
	Infcode     int64       `json:"infcode"`
	Output      struct {
		Baseinfo struct {
			Age         float64 `json:"age"`
			Brdy        string  `json:"brdy"`
			Certno      string  `json:"certno"`
			Gend        string  `json:"gend"`
			Naty        string  `json:"naty"`
			PsnCertType string  `json:"psn_cert_type"`
			PsnName     string  `json:"psn_name"`
			PsnNo       string  `json:"psn_no"`
		} `json:"baseinfo"`
		Idetinfo []interface{} `json:"idetinfo"`
		Iinfo    []struct {
			Balc                   int64       `json:"balc"`
			CvlservFlag            string      `json:"cvlserv_flag"`
			EmpName                string      `json:"emp_name"`
			InsuplcAdmdvs          string      `json:"insuplc_admdvs"`
			Insutype               string      `json:"insutype"`
			PausInsuDansuplcAdmdvs string      `json:"paus_insu_dansuplc_admdvs"`
			PausInsuDate           interface{} `json:"paus_insu_date"`
			PsnInsuDate            string      `json:"psn_insu_date"`
			PsnInsuStas            string      `json:"psn_insu_stas"`
			PsnType                string      `json:"psn_type"`
		} `json:"insuinfo"`
	} `json:"output"`
	RefmsgTime  string      `json:"refmsg_time"`
	RespondTime string      `json:"respond_time"`
	Signtype    interface{} `json:"signtype"`
	WarnInfo    interface{} `json:"warn_info"`
}
type ResultThree struct {
	Cainfo      interface{} `json:"cainfo"`
	ErrMsg      interface{} `json:"err_msg"`
	InfRefmsgid string      `json:"inf_refmsgid"`
	Infcode     int64       `json:"infcode"`
	Output      struct {
		Data struct {
			IptOtpNo string `json:"ipt_otp_no"`
			MdtrtID  string `json:"mdtrt_id"`
			PsnNo    string `json:"psn_no"`
		} `json:"data"`
	} `json:"output"`
	RefmsgTime  string      `json:"refmsg_time"`
	RespondTime string      `json:"respond_time"`
	Signtype    interface{} `json:"signtype"`
	WarnMsg     interface{} `json:"warn_msg"`
}
type ResultFour struct {
	Cainfo      string `json:"cainfo"`
	ErrMsg      string `json:"err_msg"`
	InfRefmsgid string `json:"inf_refmsgid"`
	Infcode     int64  `json:"infcode"`
	Output      struct {
		Result []struct {
			BasMednFlag      string  `json:"bas_medn_flag"`
			ChldMedcFlag     string  `json:"chld_medc_flag"`
			ChrgitmLv        string  `json:"chrgitm_lv"`
			Cnt              float64 `json:"cnt"`
			DetItemFeeSumamt float64 `json:"det_item_fee_sumamt"`
			DrtReimFlag      string  `json:"drt_reim_flag"`
			FeedetlSn        string  `json:"feedetl_sn"`
			FulamtOwnpayAmt  float64 `json:"fulamt_ownpay_amt"`
			HiNegoDrugFlag   string  `json:"hi_nego_drug_flag"`
			InscpScpAmt      float64 `json:"inscp_scp_amt"`
			ListSpItemFlag   string  `json:"list_sp_item_flag"`
			LmtUsedFlag      string  `json:"lmt_used_flag"`
			MedChrgitmType   string  `json:"med_chrgitm_type"`
			Memo             string  `json:"memo"`
			OverlmtAmt       float64 `json:"overlmt_amt"`
			PreselfpayAmt    float64 `json:"preselfpay_amt"`
			Pric             float64 `json:"pric"`
			PricUplmtAmt     float64 `json:"pric_uplmt_amt"`
			SelfpayProp      float64 `json:"selfpay_prop"`
		} `json:"result"`
	} `json:"output"`
	RefmsgTime  string `json:"refmsg_time"`
	RespondTime string `json:"respond_time"`
	Signtype    string `json:"signtype"`
	WarnMsg     string `json:"warn_msg"`
}
type ResultFive struct {
	Insutype string `json:"insutype"`
}
type ResultSix struct {
	Cainfo      interface{} `json:"cainfo"`
	ErrMsg      interface{} `json:"err_msg"`
	InfRefmsgid string      `json:"inf_refmsgid"`
	Infcode     int64       `json:"infcode"`
	Output      struct {
	} `json:"output"`
	RefmsgTime  string      `json:"refmsg_time"`
	RespondTime string      `json:"respond_time"`
	Signtype    interface{} `json:"signtype"`
	WarnMsg     interface{} `json:"warn_msg"`
}
type ResultSeven struct {
	Cainfo      string `json:"cainfo"`
	ErrMsg      string `json:"err_msg"`
	InfRefmsgid string `json:"inf_refmsgid"`
	Infcode     int64  `json:"infcode"`
	Output      struct {
		Setldetail []interface{} `json:"setldetail"`
		Setlinfo   struct {
			AcctMulaidPay   float64 `json:"acct_mulaid_pay"`
			AcctPay         float64 `json:"acct_pay"`
			ActPayDedc      float64 `json:"act_pay_dedc"`
			Age             float64 `json:"age"`
			Balc            float64 `json:"balc"`
			Brdy            string  `json:"brdy"`
			Certno          string  `json:"certno"`
			ClrOptins       string  `json:"clr_optins"`
			ClrType         string  `json:"clr_type"`
			ClrWay          string  `json:"clr_way"`
			CvlservFlag     string  `json:"cvlserv_flag"`
			CvlservPay      float64 `json:"cvlserv_pay"`
			FulamtOwnpayAmt float64 `json:"fulamt_ownpay_amt"`
			FundPaySumamt   float64 `json:"fund_pay_sumamt"`
			Gend            string  `json:"gend"`
			HifesPay        float64 `json:"hifes_pay"`
			HifmiPay        float64 `json:"hifmi_pay"`
			HifobPay        float64 `json:"hifob_pay"`
			HifpPay         float64 `json:"hifp_pay"`
			HospPartAmt     float64 `json:"hosp_part_amt"`
			InscpScpAmt     float64 `json:"inscp_scp_amt"`
			Insutype        string  `json:"insutype"`
			MafPay          float64 `json:"maf_pay"`
			MdtrtCertType   string  `json:"mdtrt_cert_type"`
			MdtrtID         string  `json:"mdtrt_id"`
			MedType         string  `json:"med_type"`
			MedfeeSumamt    float64 `json:"medfee_sumamt"`
			MedinsSetlID    string  `json:"medins_setl_id"`
			Naty            string  `json:"naty"`
			OthPay          float64 `json:"oth_pay"`
			OverlmtSelfpay  float64 `json:"overlmt_selfpay"`
			PoolPropSelfpay float64 `json:"pool_prop_selfpay"`
			PreselfpayAmt   float64 `json:"preselfpay_amt"`
			PsnCashPay      float64 `json:"psn_cash_pay"`
			PsnCertType     string  `json:"psn_cert_type"`
			PsnName         string  `json:"psn_name"`
			PsnNo           string  `json:"psn_no"`
			PsnPartAmt      float64 `json:"psn_part_amt"`
			PsnType         string  `json:"psn_type"`
			SetlID          string  `json:"setl_id"`
			SetlTime        string  `json:"setl_time"`
		} `json:"setlinfo"`
	} `json:"output"`
	RefmsgTime  string      `json:"refmsg_time"`
	RespondTime string      `json:"respond_time"`
	Signtype    interface{} `json:"signtype"`
	WarnMsg     interface{} `json:"warn_msg"`
}

type ResultEight struct {
	Cainfo      string `json:"cainfo"`
	ErrMsg      string `json:"err_msg"`
	InfRefmsgid string `json:"inf_refmsgid"`
	Infcode     int64  `json:"infcode"`
	Output      struct {
		Stmtinfo struct {
			SetlOptins   string `json:"setl_optins"`
			StmtRslt     string `json:"stmt_rslt"`
			StmtRsltDscr string `json:"stmt_rslt_dscr"`
		} `json:"stmtinfo"`
	} `json:"output"`
	RefmsgTime  string      `json:"refmsg_time"`
	RespondTime string      `json:"respond_time"`
	Signtype    interface{} `json:"signtype"`
	WarnMsg     interface{} `json:"warn_msg"`
}

type ResultNine struct {
	Cainfo      string `json:"cainfo"`
	ErrMsg      string `json:"err_msg"`
	InfRefmsgid string `json:"inf_refmsgid"`
	Infcode     int64  `json:"infcode"`
	Output      struct {
		FileQuryNo string `json:"file_qury_no"`
	} `json:"output"`
	RefmsgTime  string      `json:"refmsg_time"`
	RespondTime string      `json:"respond_time"`
	Signtype    interface{} `json:"signtype"`
	WarnMsg     interface{} `json:"warn_msg"`
}

type ResultTen struct {
	Cainfo      string `json:"cainfo"`
	ErrMsg      string `json:"err_msg"`
	InfRefmsgid string `json:"inf_refmsgid"`
	Infcode     int64  `json:"infcode"`
	Output      struct {
		DldEndtime string `json:"dld_endtime"`
		FileQuryNo string `json:"file_qury_no"`
		Filename   string `json:"filename"`
	} `json:"output"`
	RefmsgTime  string      `json:"refmsg_time"`
	RespondTime string      `json:"respond_time"`
	Signtype    interface{} `json:"signtype"`
	WarnMsg     interface{} `json:"warn_msg"`
}

type ResultEleven struct {
	Cainfo      string `json:"cainfo"`
	ErrMsg      string `json:"err_msg"`
	InfRefmsgid string `json:"inf_refmsgid"`
	Infcode     int64  `json:"infcode"`
	Output      struct {
		Setlinfo struct {
			FixmedinsName   string  `json:"fixmedins_name"`
			FixmedinsCode   string  `json:"fixmedins_code"`
			PsnNo           string  `json:"psn_no"`
			PsnName         string  `json:"psn_name"`
			HifobPay        float64 `json:"hifob_pay"`
			Gend            string  `json:"gend"`
			Brdy            string  `json:"brdy"`
			PsnCertType     string  `json:"psn_cert_type"`
			PsnType         string  `json:"psn_type"`
			EmpName         string  `json:"emp_name"`
			Certno          string  `json:"certno"`
			Insutype        string  `json:"insutype"`
			MedfeeSumamt    float64 `json:"medfee_sumamt"`
			FulamtOwnpayAmt float64 `json:"fulamt_ownpay_amt"`
			OverlmtSelfpay  float64 `json:"overlmt_selfpay"`
			PreselfpayAmt   float64 `json:"preselfpay_amt"`
			InscpScpAmt     float64 `json:"inscp_scp_amt"`
			ActPayDedc      float64 `json:"act_pay_dedc"`
			HifpPay         float64 `json:"hifp_pay"`
			PoolPropSelfpay float64 `json:"pool_prop_selfpay"`
			CvlservPay      float64 `json:"cvlserv_pay"`
			HifesPay        float64 `json:"hifes_pay"`
			HifmiPay        float64 `json:"hifmi_pay"`
			MafPay          float64 `json:"maf_pay"`
			OthPay          float64 `json:"oth_pay"`
			FundPaySumamt   float64 `json:"fund_pay_sumamt"`
			PsnPay          float64 `json:"psn_pay"`
			AcctPay         float64 `json:"acct_pay"`
			CashPayamt      float64 `json:"cash_payamt"`
			Balc            float64 `json:"balc"`
			AcctMulaidPay   float64 `json:"acct_mulaid_pay"`
			MedinsSetlId    string  `json:"medins_setl_id"`
			RefdSetlFlag    string  `json:"refd_setl_flag"`
			SetlTime        string  `json:"setl_time"`
			MedType         string  `json:"med_type"`
		} `json:"setlinfo"`
	} `json:"output"`
	RefmsgTime  string      `json:"refmsg_time"`
	RespondTime string      `json:"respond_time"`
	Signtype    interface{} `json:"signtype"`
	WarnMsg     interface{} `json:"warn_msg"`
}

type Custom struct {
	DetItemFeeSumamt string
	Cut              string
	FeedetlSn        string
	Price            string
	MedListCodg      string
	Type             int64
	AdviceId         int64
	ProjectId        int64
	ItemId           int64
}

//获取个人信息----挂号-----上传就诊信息
func (c *HisApiController) GetRegisterInfo() {
	id, _ := c.GetInt64("id")
	record_time := c.GetString("record_time")
	settlementValue, _ := c.GetInt64("settlement_value")
	medical_insurance_card := c.GetString("medical_insurance_card")
	name := c.GetString("name")
	id_card_type, _ := c.GetInt64("id_card_type")
	certificates, _ := c.GetInt64("certificates")
	medical_care, _ := c.GetInt64("medical_care")
	birthday := c.GetString("birthday")
	age, _ := c.GetInt64("age")
	id_card := c.GetString("id_card")
	register_type, _ := c.GetInt64("register")
	doctor, _ := c.GetInt64("doctor")
	department, _ := c.GetInt64("department")
	gender, _ := c.GetInt64("sex")
	phone := c.GetString("phone")
	registration_fee, _ := c.GetFloat("registration_fee")
	medical_expenses, _ := c.GetFloat("medical_expenses")
	social_type, _ := c.GetInt64("social_type")

	diagnosis_id, _ := c.GetInt64("diagnosis")
	sick_type, _ := c.GetInt64("sick_type")
	reg_type := c.GetString("p_type")

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	birthdays, _ := time.ParseInLocation(timeLayout+" 15:04:05", birthday+" 00:00:00", loc)
	birthUnix := birthdays.Unix()

	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_time+" 00:00:00", loc)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	recordDateTime := theTime.Unix()

	adminInfo := c.GetAdminUserInfo()
	tempPatient, _ := service.GetPatientByIDCardAndName(id_card, adminInfo.CurrentOrgId, name)
	if tempPatient.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeNoBloodPatientException)
		return
	}
	var patient service.Patients
	if id == 0 {
		patient, _ = service.GetPatientByIDCard(id_card, adminInfo.CurrentOrgId)

	} else {
		patient, _ = service.GetPatientByIDTwo(adminInfo.CurrentOrgId, id)

	}

	if patient.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}
	if len(patient.IdCardNo) == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeIDCartNo)
		return
	}

	timeStr := time.Now().Format("2006-01-02")
	timeArr := strings.Split(timeStr, "-")
	var str = timeArr[0] + timeArr[1] + timeArr[2] + strconv.FormatInt(patient.ID, 10)

	his, err := service.GetHisPatientInfo(adminInfo.CurrentOrgId, patient.ID, recordDateTime)

	var hisPatient models.XtHisPatient
	if err == gorm.ErrRecordNotFound || his.ID == 0 {
		hisPatient = models.XtHisPatient{
			Name:                   name,
			Age:                    age,
			Gender:                 gender,
			Birthday:               birthUnix,
			Phone:                  phone,
			MedicalTreatmentType:   medical_care,
			IdType:                 certificates,
			IdCardNo:               id_card,
			BalanceAccountsType:    settlementValue,
			SocialType:             social_type,
			MedicalInsuranceNumber: medical_insurance_card,
			RegisterType:           register_type,
			RegisterCost:           registration_fee,
			TreatmentCost:          medical_expenses,
			AdminUserId:            adminInfo.AdminUser.Id,
			UserOrgId:              adminInfo.CurrentOrgId,
			Status:                 1,
			RecordDate:             recordDateTime,
			IsReturn:               1,
			PatientId:              patient.ID,
			Ctime:                  time.Now().Unix(),
			Mtime:                  time.Now().Unix(),
			Number:                 str,
			IdCardType:             id_card_type,
			Departments:            department,
			Doctor:                 doctor,
			PType:                  reg_type,
			Diagnosis:              diagnosis_id,
			SickType:               sick_type,
		}
		service.CreateHisPatient(&hisPatient)
		c.ServeSuccessJSON(map[string]interface{}{
			"his_info": hisPatient,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeHisRegisterException)
		return
	}
}

//上传明细----结算
func (c *HisApiController) GetUploadInfo() {
	id, _ := c.GetInt64("id")
	record_time := c.GetString("record_time")
	pay_way, _ := c.GetInt64("pay_way")
	pay_price, _ := c.GetFloat("pay_price")
	pay_card_no := c.GetString("pay_card_no")
	discount_price, _ := c.GetFloat("discount_price")
	preferential_price, _ := c.GetFloat("preferential_price")
	reality_price, _ := c.GetFloat("reality_price")
	found_price, _ := c.GetFloat("found_price")
	medical_insurance_price, _ := c.GetFloat("medical_insurance_price")
	private_price, _ := c.GetFloat("private_price")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	settle_accounts_type, _ := c.GetInt64("settle_accounts_type")

	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_time+" 00:00:00", loc)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	recordDateTime := theTime.Unix()
	adminUser := c.GetAdminUserInfo()
	var prescriptions []*models.HisPrescription
	var start_time int64
	var end_time int64

	if settle_accounts_type == 1 { //日结

		prescriptions, _ = service.GetSettleHisPrescription(adminUser.CurrentOrgId, id, recordDateTime)

	} else { //月结
		start_time_str := c.GetString("start_time")
		end_time_str := c.GetString("end_time")
		timeLayout := "2006-01-02"
		loc, _ := time.LoadLocation("Local")
		theStartTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time_str+" 00:00:00", loc)
		if err != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		recordStartTime := theStartTime.Unix()
		start_time = recordStartTime
		theEndTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time_str+" 00:00:00", loc)
		if err != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		recordEndTime := theEndTime.Unix()
		end_time = recordEndTime
		prescriptions, _ = service.GetMonthHisPrescription(adminUser.CurrentOrgId, id, recordStartTime, recordEndTime)
	}

	his, _ := service.GetVMHisPatientInfo(adminUser.CurrentOrgId, id, recordDateTime)
	timestamp := time.Now().Unix()
	tempTime := time.Unix(timestamp, 0)
	timeFormat := tempTime.Format("20060102150405")
	chrgBchno := rand.Intn(100000) + 10000
	chrg_bchno := timeFormat + strconv.FormatInt(int64(chrgBchno), 10) + strconv.FormatInt(his.PatientId, 10)
	strconv.FormatInt(his.PatientId, 10)

	var ids []int64

	for _, item := range prescriptions {
		ids = append(ids, item.ID)
	}

	var total float64
	for _, item := range prescriptions {
		if item.Type == 1 { //药品
			for _, subItem := range item.HisDoctorAdviceInfo {
				total = total + (subItem.Price * subItem.PrescribingNumber)
			}
		}
		if item.Type == 2 { //项目
			for _, subItem := range item.HisPrescriptionProject {
				total = total + (subItem.Price * float64(subItem.Count))
			}
		}

		for _, subItem := range item.HisAdditionalCharge {
			total = total + (subItem.Price * float64(subItem.Count))
		}
	}

	allTotal := fmt.Sprintf("%.2f", total)
	totals, _ := strconv.ParseFloat(allTotal, 64)
	order := &models.HisOrder{
		UserOrgId:             adminUser.CurrentOrgId,
		HisPatientId:          his.ID,
		PatientId:             id,
		SettleAccountsDate:    recordDateTime,
		Ctime:                 time.Now().Unix(),
		Mtime:                 time.Now().Unix(),
		Status:                1,
		OrderStatus:           2,
		Number:                chrg_bchno,
		MedfeeSumamt:          totals,
		PayWay:                pay_way,
		PayPrice:              pay_price,
		PayCardNo:             pay_card_no,
		DiscountPrice:         discount_price,
		PreferentialPrice:     preferential_price,
		RealityPrice:          reality_price,
		FoundPrice:            found_price,
		MedicalInsurancePrice: medical_insurance_price,
		PrivatePrice:          private_price,
		SettleEndTime:         end_time,
		SettleStartTime:       start_time,
		SettleType:            settle_accounts_type,
	}
	err = service.CreateOrder(order)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateOrderException)
		return
	}

	var customs []*Custom
	for _, item := range prescriptions {

		if item.Type == 1 { //药品
			for _, subItem := range item.HisDoctorAdviceInfo {
				cus := &Custom{
					AdviceId:         subItem.ID,
					ProjectId:        0,
					DetItemFeeSumamt: fmt.Sprintf("%.2f", subItem.Price*subItem.PrescribingNumber),
					Cut:              fmt.Sprintf("%.2f", subItem.PrescribingNumber),
					FeedetlSn:        subItem.FeedetlSn,
					Price:            fmt.Sprintf("%.2f", subItem.Price),
					MedListCodg:      subItem.MedListCodg,
					Type:             1,
				}
				customs = append(customs, cus)
			}
		}

		if item.Type == 2 { //项目
			for _, subItem := range item.HisPrescriptionProject {

				cus := &Custom{
					AdviceId:         0,
					ProjectId:        subItem.ID,
					DetItemFeeSumamt: fmt.Sprintf("%.2f", subItem.Price*float64(subItem.Count)),
					Cut:              fmt.Sprintf("%.2f", float64(subItem.Count)),
					FeedetlSn:        subItem.FeedetlSn,
					Price:            fmt.Sprintf("%.2f", float64(subItem.Price)),
					MedListCodg:      subItem.MedListCodg,
					Type:             2,
				}

				customs = append(customs, cus)
			}
		}

		for _, item := range item.HisAdditionalCharge {
			cus := &Custom{
				ItemId:           item.ID,
				AdviceId:         0,
				ProjectId:        0,
				DetItemFeeSumamt: fmt.Sprintf("%.2f", item.Price),
				Cut:              fmt.Sprintf("%.2f", float64(item.Count)),
				FeedetlSn:        item.FeedetlSn,
				Price:            fmt.Sprintf("%.2f", float64(item.Price)),
				MedListCodg:      item.XtHisAddtionConfig.Code,
				Type:             3,
			}

			customs = append(customs, cus)
		}

	}

	for _, item := range customs {
		var advice_id int64 = 0
		var project_id int64 = 0
		var item_id int64 = 0

		var types int64 = 0

		if item.Type == 1 {
			advice_id = item.AdviceId
			project_id = 0
			item_id = 0
		} else if item.Type == 2 {
			advice_id = 0
			item_id = 0

			project_id = item.ProjectId
		} else if item.Type == 3 {
			advice_id = 0
			item_id = item.ItemId
			project_id = 0
		}

		detItemFeeSumamt, _ := strconv.ParseFloat(item.DetItemFeeSumamt, 32)
		cut, _ := strconv.ParseFloat(item.Cut, 32)
		pric, _ := strconv.ParseFloat(item.Price, 32)

		info := &models.HisOrderInfo{
			OrderNumber:      order.Number,
			UploadDate:       time.Now().Unix(),
			AdviceId:         advice_id,
			DetItemFeeSumamt: detItemFeeSumamt,
			Cnt:              cut,
			Pric:             pric,
			PatientId:        id,
			Status:           1,
			Mtime:            time.Now().Unix(),
			Ctime:            time.Now().Unix(),
			UserOrgId:        adminUser.CurrentOrgId,
			HisPatientId:     his.ID,
			OrderId:          order.ID,
			ProjectId:        project_id,
			Type:             types,
			ItemId:           item_id,
		}
		service.CreateOrderInfo(info)
	}
	err = service.UpDatePrescriptionNumber(adminUser.CurrentOrgId, ids, chrg_bchno)
	err = service.UpDatePrescriptionInfoNumber(adminUser.CurrentOrgId, id, chrg_bchno, recordDateTime)
	err = service.UpdataOrderStatusTwo(chrg_bchno, adminUser.CurrentOrgId)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"msg": "结算成功",
		})
	}
}

//退款
func (c *HisApiController) Refund() {
	order_id, _ := c.GetInt64("order_id")
	number := c.GetString("number")

	adminUser := c.GetAdminUserInfo()
	config, _ := service.GetMedicalInsuranceConfig(adminUser.CurrentOrgId)
	if config.IsOpen == 1 { //对接了医保，走医保流程

	} else {
		err := service.UpdataOrderStatus(order_id, number, adminUser.CurrentOrgId)
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"msg": "退费成功",
			})
		} else {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
			return
		}

	}

}

func (this *HisApiController) AdditionalCharge() {

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println(err)
	his_patient_id := int64(dataBody["his_patient_id"].(float64))
	patient_id := int64(dataBody["patient_id"].(float64))
	medicineData, _ := dataBody["medicineData"].([]interface{})
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	admin_user_id := adminUserInfo.AdminUser.Id
	timeStr := time.Now().Format("2006-01-02")
	timeLayout := "2006-01-02 15:04:05"
	timeStringToTime, _ := utils.ParseTimeStringToTime(timeLayout, timeStr+" 00:00:00")
	timenow := timeStringToTime.Unix()
	var additionalCharges []*models.HisAdditionalCharge
	for _, item := range medicineData {

		var randNum int
		randNum = rand.Intn(10000) + 1000
		timestamp := time.Now().Unix()
		tempTime := time.Unix(timestamp, 0)
		timeFormat := tempTime.Format("20060102150405")
		p_number := timeFormat + strconv.FormatInt(int64(randNum), 10) + strconv.FormatInt(int64(adminUserInfo.CurrentOrgId), 10) + strconv.FormatInt(int64(patient_id), 10)

		items := item.(map[string]interface{})
		money := items["price"].(string)
		item_id_str := items["item_id"].(string)
		name := items["name"].(string)
		id_str := items["id"].(string)
		moneys, _ := strconv.ParseInt(money, 10, 64)
		monStr := strconv.FormatInt(moneys, 10)
		monneyStr, _ := strconv.ParseFloat(monStr, 64)
		item_id, _ := strconv.ParseInt(item_id_str, 10, 64)
		id, _ := strconv.ParseInt(id_str, 10, 64)
		additionalCharge := &models.HisAdditionalCharge{
			ID:                 id,
			HisPatientId:       his_patient_id,
			UserOrgId:          orgId,
			PatientId:          patient_id,
			RecordDate:         timenow,
			Price:              monneyStr,
			Status:             1,
			ItemName:           name,
			ItemId:             item_id,
			AdminUserId:        admin_user_id,
			CreatedTime:        time.Now().Unix(),
			OrderStatus:        0,
			PrescriptionNumber: "",
			BatchNumber:        "",
			FeedetlSn:          p_number,
		}
		service.CreateAdditionalCharge(additionalCharge)

		additionalCharges = append(additionalCharges, additionalCharge)
	}

	this.ServeSuccessJSON(map[string]interface{}{
		"msg":                "添加成功",
		"additional_charges": additionalCharges,
	})
}

func (this *HisApiController) DeleteAddition() {
	id, _ := this.GetInt64("id")
	//TODO 需要判断是否已经结算
	err := service.DelelteAddition(id, this.GetAdminUserInfo().CurrentOrgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"msg": "删除成功",
		})
		return
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}

}

func (this *HisApiController) GetAdminUsers() {
	adminUser := this.GetAdminUserInfo()
	doctors, _ := service.GetAllHisDoctor(adminUser.CurrentOrgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"doctors": doctors,
	})
}

func (this *DialysisApiController) GetLastOrNextHisPrescription() {
	change_type, _ := this.GetInt64("type", 0)
	record_date := this.GetString("record_time")
	patient_id, _ := this.GetInt64("patient_id", 0)

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theAdviceRecordTime, _ := time.ParseInLocation(timeLayout, record_date, loc)
	record_time := theAdviceRecordTime.Unix()
	adminUserInfo := this.GetAdminUserInfo()
	prescriptions, err := service.GetHisPrescriptionByType(change_type, record_time, adminUserInfo.CurrentOrgId, patient_id)
	if err == nil {
		if len(prescriptions) == 0 {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceEmpty)
			return
		} else {
			this.ServeSuccessJSON(map[string]interface{}{
				"prescriptions": prescriptions,
			})
			return
		}
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}
}

func (this *DialysisApiController) GetCallHisPrescription() {
	patient_id, _ := this.GetInt64("patient_id", 0)
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")
	startime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
	end_time := this.GetString("end_time")
	endtime, _ := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
	adminUserInfo := this.GetAdminUserInfo()
	prescriptions, err := service.GetCallHisPrescriptions(startime.Unix(), endtime.Unix(), adminUserInfo.CurrentOrgId, patient_id)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"prescriptions": prescriptions,
		})
		return
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}
}

func (this *HisApiController) GetHisDayPrescription() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")
	patient_id, _ := this.GetInt64("patient_id", 0)
	startime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
	end_time := this.GetString("end_time")
	endtime, _ := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
	adminUserInfo := this.GetAdminUserInfo()
	dayHisPrescription, err := service.GetMonthHisPrescriptionThree(adminUserInfo.CurrentOrgId, patient_id, startime.Unix(), endtime.Unix())
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"day_prescription": dayHisPrescription,
		})
		return
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}
}

func (c *HisApiController) GetHisChargePatientList() {
	record_date := c.GetString("record_date")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	recordDateTime := theTime.Unix()
	adminInfo := c.GetAdminUserInfo()
	tempPatients, _ := service.GetAllChargeHisPatientList(adminInfo.CurrentOrgId, "", recordDateTime)
	var patients []*service.Patients
	var patients_two []*service.Patients

	for _, item := range tempPatients {
		//过滤掉没挂号的和没开处方的
		if item.HisPatient.ID > 0 || len(item.HisPrescription) > 0 {
			patients = append(patients, item)
		}
		//过滤掉没挂号的
		if item.HisPatient.ID > 0 {
			patients_two = append(patients_two, item)
		}
	}
	c.ServeSuccessJSON(map[string]interface{}{
		"list":     patients,
		"list_two": patients_two,
	})
}

func (c *HisApiController) GetHisUnRegisterPatientList() {
	record_date := c.GetString("record_date")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	recordDateTime := theTime.Unix()
	adminUser := c.GetAdminUserInfo()

	tempPatients, _ := service.GetHisPatientList(adminUser.CurrentOrgId, "", recordDateTime)

	var patients []*service.Patients
	for _, item := range tempPatients {
		if item.HisPatient.ID == 0 {
			patients = append(patients, item)
		}
	}

	c.ServeSuccessJSON(map[string]interface{}{
		"list": patients,
		//"list_two":	patients_two,
	})

}

func RemoveRepeatedPatient(patient []*service.Patients) (newArr []*service.Patients) {
	newArr = make([]*service.Patients, 0)
	for i := 0; i < len(patient); i++ {
		repeat := false
		for j := i + 1; j < len(patient); j++ {
			if patient[i].ID == patient[j].ID {
				repeat = true
				break
			}
		}
		if !repeat {
			newArr = append(newArr, patient[i])
		}
	}
	return
}

func (c *HisApiController) GetHisChargePatientInfo() {
	patient_id, _ := c.GetInt64("patient_id")
	record_date := c.GetString("record_date")
	number := c.GetString("number")

	start_time := c.GetString("start_time")
	end_time := c.GetString("end_time")

	order_status, _ := c.GetInt64("type", 0)

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	recordDateTime := theTime.Unix()

	startTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
	if err != nil {

	}
	startRecordDateTime := startTime.Unix()

	endTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
	if err != nil {

	}
	endRecordDateTime := endTime.Unix()

	admin := c.GetAdminUserInfo()
	his_patient_info, _ := service.GetHisPatientInfo(admin.CurrentOrgId, patient_id, recordDateTime)
	xt_patient_info, _ := service.GetXTPatientInfo(admin.CurrentOrgId, patient_id)

	var prescriptions []*models.HisPrescription

	if order_status == 1 || order_status == 0 {
		prescriptions, _ = service.GetUnChargeHisPrescriptionFive(admin.CurrentOrgId, patient_id, recordDateTime)
	} else if order_status == 2 {
		prescriptions, _ = service.GetChargeHisPrescriptionFive(admin.CurrentOrgId, patient_id, recordDateTime)
	}

	var monthPrescriptions []*models.HisPrescription

	if order_status == 1 || order_status == 0 {
		monthPrescriptions, _ = service.GetUnChargeMonthHisPrescriptionThree(admin.CurrentOrgId, patient_id, startRecordDateTime, endRecordDateTime)
	} else if order_status == 2 {
		monthPrescriptions, _ = service.GetChargeMonthHisPrescriptionFour(admin.CurrentOrgId, patient_id, startRecordDateTime, endRecordDateTime)

	}

	case_history, _ := service.GetHisPatientCaseHistoryInfo(admin.CurrentOrgId, patient_id, recordDateTime)
	patientPrescriptionInfo, _ := service.FindPatientPrescriptionInfo(admin.CurrentOrgId, patient_id, recordDateTime)
	order, _ := service.GetHisOrder(admin.CurrentOrgId, number, patient_id)

	doctors, _ := service.GetHisAdminUserDoctors(admin.CurrentOrgId)
	//获取所有科室信息
	department, _ := service.GetAllDepartMent(admin.CurrentOrgId)

	c.ServeSuccessJSON(map[string]interface{}{
		"his_info":            his_patient_info,
		"xt_info":             xt_patient_info,
		"prescription":        prescriptions,
		"case_history":        case_history,
		"info":                patientPrescriptionInfo,
		"month_prescriptions": monthPrescriptions,
		"order":               order,
		"doctors":             doctors,
		"department":          department,
	})
	return

}

func (c *HisApiController) GetAllOrderDetail() {
	order_id, _ := c.GetInt64("order_id", 0)
	order, _ := service.GetHisOrderByID(order_id)
	if order.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeOrderParamWrong)
		return
	}
	order_info, _ := service.GetHisOrderInfoByNumber(order.Number)

	c.ServeSuccessJSON(map[string]interface{}{
		"order":      order,
		"order_info": order_info,
	})
	return

}

func (c *HisApiController) GetAllOrderDetailCollect() {
	order_id, _ := c.GetInt64("order_id", 0)
	order, _ := service.GetHisOrderByID(order_id)
	if order.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeOrderParamWrong)
		return
	}
	order_info, _ := service.GetHisOrderInfoByNumber(order.Number)

	c.ServeSuccessJSON(map[string]interface{}{
		"order":      order,
		"order_info": order_info,
	})
	return
}