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"
	"github.com/shopspring/decimal"
	"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/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", &HisApiController{}, "Get:GetLastOrNextHisPrescription")
	beego.Router("/api/callhisprescription/get", &HisApiController{}, "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")
	beego.Router("/api/cost/compare", &HisApiController{}, "get:GetMedicalInsuranceCostCompareList")
	beego.Router("/api/record/list", &HisApiController{}, "get:GetPutOnRecordList")

	beego.Router("/api/comparedata/get", &HisApiController{}, "get:GetCompareData")
	beego.Router("/api/fapiao/get", &HisApiController{}, "get:GetFaPiaoData")

	beego.Router("/api/incomestatistics/get", &HisApiController{}, "get:GetIncomeStatisticsData")

	beego.Router("/api/postprojectinformation", &HisApiController{}, "post:PostProjectInformation")
}

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() {
	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.GetNewHisPatientList(adminInfo.CurrentOrgId, recordDateTime)
	patients_two, _ := service.GetScheduleHisPatientList(adminInfo.CurrentOrgId, "", recordDateTime, 0)
	//获取当前用户的信息
	adminUserInfo, _ := service.GetAdminUserInfoByID(adminInfo.CurrentOrgId, adminInfo.AdminUser.Id)
	doctors, _ := service.GetHisAdminUserDoctors(adminInfo.CurrentOrgId)
	//获取所有科室信息
	department, _ := service.GetAllDepartMent(adminInfo.CurrentOrgId)
	c.ServeSuccessJSON(map[string]interface{}{
		"list":       patients,
		"list_two":   patients_two,
		"info":       adminUserInfo,
		"doctors":    doctors,
		"department": department,
	})

}
func (c *HisApiController) GetHisPatientInfo() {
	patient_id, _ := c.GetInt64("patient_id")
	his_patient_id, _ := c.GetInt64("his_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.GetNewHisPatientInfoTwo(admin.CurrentOrgId, his_patient_id, recordDateTime)
	xt_patient_info, _ := service.GetXTPatientInfo(admin.CurrentOrgId, patient_id)
	prescriptions, _ := service.GetNewHisPrescription(admin.CurrentOrgId, patient_id, his_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{})

		var tempPrescription *models.HisPrescription
		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))

				new_prescription, _ := service.GetPrescriptionById(id, adminInfo.CurrentOrgId)
				tempPrescription = &new_prescription
				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["order_status"] == nil || reflect.TypeOf(items["order_status"]).String() != "float64" {
					utils.ErrorLog("order_status")
				}
				order_status := int64(items["order_status"].(float64))

				if order_status == 0 {
					order_status = 1
				}

				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()

				if tempPrescription.ID == 0 {
					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:        order_status,
						BatchNumber:        "",
						PrescriptionNumber: hpInfo.PrescriptionNumber,
						PreTime:            pTime,
					}
					tempPrescription = prescription
					service.SaveHisPrescription(tempPrescription)

				} else {
					tempPrescription.Type = types
					tempPrescription.Modifier = adminInfo.AdminUser.Id
					tempPrescription.Mtime = time.Now().Unix()
					tempPrescription.Doctor = role.UserName
					tempPrescription.OrderStatus = order_status
					tempPrescription.PreTime = pTime
					service.SaveHisPrescription(tempPrescription)

				}

				//更改患者挂号状态
				_, 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 = tempPrescription.ID
							s.AdviceType = 2
							s.AdviceDoctor = doctor_id
							s.StopState = 2
							s.ExecutionState = 2
							s.AdviceDate = recordDateTime
							s.Status = 1
							s.UserOrgId = adminInfo.CurrentOrgId
							s.RecordDate = recordDateTime
							s.StartTime = tempPrescription.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 = tempPrescription.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 = tempPrescription.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)

	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")

	family_history := c.GetString("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)

	sick, _ := c.GetInt64("sick")
	diagnose, _ := c.GetInt64("diagnose")
	id, _ := c.GetInt64("id")

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	allergic_history := c.GetString("allergic_history")
	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,
		AllergicHistory:         allergic_history,
	}
	//查询该患者是否有病历
	_, errcodes := service.GetHisPatientCaseHistoryById(id)
	if errcodes == gorm.ErrRecordNotFound {
		err = service.SaveHisPatientCaseHistory(&caseHistory)
		if err != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateConfig)
			return
		}
		c.ServeSuccessJSON(map[string]interface{}{
			"caseHistory": caseHistory,
		})
		return
	} else if errcodes == nil {
		err := service.UpdatePatientCaseHistory(id, &caseHistory)
		if err != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateConfig)
			return
		}
		c.ServeSuccessJSON(map[string]interface{}{
			"caseHistory": caseHistory,
		})
	}

	//查询该患者是否有病历
	//_, 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                   float64     `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
	}

	his, _ := service.GetHisPatientInfoTwo(adminInfo.CurrentOrgId, patient.ID, recordDateTime)
	if len(his) >= 1 {
		order, _ := service.GetNewHisOrderTwo(adminInfo.CurrentOrgId, his[len(his)-1].Number, his[len(his)-1].PatientId, recordDateTime)
		if len(his) >= 1 && order.ID == 0 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeHisPatientParamWrong)
			return
		}
	}

	timeStr := time.Now().Format("2006-01-02 15:04:05")
	fmt.Println(timeStr)
	timeArr := strings.Split(timeStr, " ")
	fmt.Println(timeArr)

	timeArrTwo := strings.Split(timeArr[0], "-")
	timeArrThree := strings.Split(timeArr[1], ":")
	var str = timeArrTwo[0] + timeArrTwo[1] + timeArrTwo[2] + timeArrThree[0] + timeArrThree[1] + timeArrThree[2] + strconv.FormatInt(patient.ID, 10)

	lists, _ := service.GetHisPatientInfoList(adminInfo.CurrentOrgId, patient.ID, recordDateTime)

	if len(lists) == 0 {
		var hisPatient models.XtHisPatient
		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)

		service.UpdateHisPrescriptionHisID(hisPatient.ID, patient.ID, recordDateTime, adminInfo.CurrentOrgId)

		c.ServeSuccessJSON(map[string]interface{}{
			"his_info": hisPatient,
		})

	} else {

		//chrgBchno := rand.Intn(1000000) + 10000
		var hisPatient models.XtHisPatient
		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,
		})

	}

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

}

//上传明细----结算
func (c *HisApiController) GetUploadInfo() {
	id, _ := c.GetInt64("id")
	record_time := c.GetString("record_time")
	his_patient_id, _ := c.GetInt64("his_patient_id")

	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, his_patient_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, his_patient_id, recordDateTime)

	fmt.Println("~~~~~~~~~")
	fmt.Println(his.Number)
	fmt.Println("~~~~~~~~~")

	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,
		MdtrtId:               his.Number,
		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 *HisApiController) 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 *HisApiController) 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)
	tempPatients, _ := service.GetNewAllChargeHisPatientList(adminInfo.CurrentOrgId, "", recordDateTime)

	var patients []*service.NewTempPatients
	var patients_two []*service.NewTempPatients

	for _, item := range tempPatients {
		//过滤掉没挂号的和没开处方的
		if len(item.HisPatient) > 0 || len(item.HisPrescription) > 0 {
			patients = append(patients, item)
		}

		//过滤掉没挂号的
		if len(item.HisPatient) > 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")
	his_patient_id, _ := c.GetInt64("his_patient_id")
	record_date := c.GetString("record_date")
	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.GetNewHisPatientInfo(his_patient_id)
	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, his_patient_id, recordDateTime)
	} else if order_status == 2 {
		prescriptions, _ = service.GetChargeHisPrescriptionFive(admin.CurrentOrgId, patient_id, his_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.GetNewHisOrder(admin.CurrentOrgId, his_patient_info.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("id", 0)
	order, _ := service.GetHisOrderByID(order_id)
	if order.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeOrderParamWrong)
		return
	}
	org_id := c.GetAdminUserInfo().CurrentOrgId
	adminInfo, _ := service.GetAdminUserInfoByID(org_id, order.Creator)
	patient, _ := service.GetPatientByID(org_id, order.PatientId)
	order_info, _ := service.GetHisOrderDetailByNumber(order.Number, org_id)
	c.ServeSuccessJSON(map[string]interface{}{
		"order":      order,
		"order_info": order_info,
		"patient":    patient,
		"admin_info": adminInfo,
	})
	return

}

func (c *HisApiController) GetAllOrderDetailCollect() {
	order_id, _ := c.GetInt64("id", 0)
	order, _ := service.GetHisOrderByID(order_id)
	if order.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeOrderParamWrong)
		return
	}
	org_id := c.GetAdminUserInfo().CurrentOrgId
	adminInfo, _ := service.GetAdminUserInfoByID(org_id, order.Creator)
	order_info, _ := service.GetHisOrderDetailByNumber(order.Number, org_id)
	patient, _ := service.GetPatientByID(org_id, order.PatientId)
	c.ServeSuccessJSON(map[string]interface{}{
		"order":      order,
		"order_info": order_info,
		"patient":    patient,
		"admin_info": adminInfo,
	})
	return
}

func (c *HisApiController) GetMedicalInsuranceCostCompareList() {
	page, _ := c.GetInt64("page")
	limit, _ := c.GetInt64("limit")
	keywords := c.GetString("keywords")
	start_time := c.GetString("start_time")
	end_time := c.GetString("end_time")
	//clr_type := c.GetString("clr_type")
	insutype := c.GetString("insutype")

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")

	var theStartTIme int64
	if len(start_time) > 0 {
		theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		theStartTIme = theTime.Unix()
	}
	var theEndtTIme int64
	if len(end_time) > 0 {
		theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		theEndtTIme = theTime.Unix()
	}

	if page <= 0 {
		page = 1
	}
	if limit <= 0 {
		limit = 10
	}
	list, total, _ := service.GetMedicalInsuranceCostCompareList(c.GetAdminUserInfo().CurrentOrgId, page, limit, keywords, insutype, theStartTIme, theEndtTIme)
	c.ServeSuccessJSON(map[string]interface{}{
		"total": total,
		"list":  list,
	})
	return

}

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

	if page <= 0 {
		page = 1
	}
	if limit <= 0 {
		limit = 10
	}
	list, total, _ := service.GetGdybPsnNcdsRecordList(c.GetAdminUserInfo().CurrentOrgId, page, limit, keywords, is_put_on_record)
	c.ServeSuccessJSON(map[string]interface{}{
		"total": total,
		"list":  list,
	})
	return

}

func (c *HisApiController) GetCompareData() {
	start_time := c.GetString("start_time")
	end_time := c.GetString("end_time")
	insutype := c.GetString("insutype")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	var theStartTIme int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			theStartTIme = 0
		}
		theStartTIme = theTime.Unix()
	}
	var theEndtTIme int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			theEndtTIme = 0
		}
		theEndtTIme = theTime.Unix()
	}
	formData, err := service.GetCheckAccountFormData(theStartTIme, theEndtTIme, c.GetAdminUserInfo().CurrentOrgId, insutype)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"list": formData,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return

	}
}

func (c *HisApiController) GetFaPiaoData() {
	order_id, _ := c.GetInt64("order_id")
	patient_id, _ := c.GetInt64("patient_id")

	adminUser := c.GetAdminUserInfo()
	order, _ := service.GetHisOrderByID(order_id)
	orderInfos, _ := service.GetHisOrderInfoByNumber(order.Number)

	patientPrescription, _ := service.FindLastPatientPrescriptionInfo(adminUser.CurrentOrgId, patient_id, order.SettleAccountsDate)

	department, _ := service.GetDepartMentDetail(patientPrescription.Departments)

	his, _ := service.GetHisPatientInfo(adminUser.CurrentOrgId, patient_id, order.SettleAccountsDate)

	var bedCostTotal float64 = 0         //床位总费
	var bedCostSelfTotal float64 = 0     //床位自费
	var bedCostPartSelfTotal float64 = 0 //床位部分项目自费

	var operationCostTotal float64 = 0         //手术费
	var operationCostSelfTotal float64 = 0     //手术费
	var operationCostPartSelfTotal float64 = 0 //手术费

	var otherCostTotal float64 = 0         //其他费用
	var otherCostSelfTotal float64 = 0     //其他费用
	var otherCostPartSelfTotal float64 = 0 //其他费用

	var materialCostTotal float64 = 0         //材料费
	var materialCostSelfTotal float64 = 0     //材料费
	var materialCostPartSelfTotal float64 = 0 //材料费

	var westernMedicineCostTotal float64 = 0         //西药费
	var westernMedicineCostSelfTotal float64 = 0     //西药费
	var westernMedicineCostPartSelfTotal float64 = 0 //西药费

	var chineseTraditionalMedicineCostTotal float64 = 0         //中成药
	var chineseTraditionalMedicineCostSelfTotal float64 = 0     //中成药
	var chineseTraditionalMedicineCostPartSelfTotal float64 = 0 //中成药

	var checkCostTotal float64 = 0         //检查费
	var checkCostSelfTotal float64 = 0     //检查费
	var checkCostPartSelfTotal float64 = 0 //检查费

	var laboratoryCostTotal float64 = 0         //化验费
	var laboratoryCostSelfTotal float64 = 0     //化验费
	var laboratoryCostPartSelfTotal float64 = 0 //化验费

	var treatCostTotal float64 = 0         //治疗费用
	var treatCostSelfTotal float64 = 0     //治疗费用
	var treatCostPartSelfTotal float64 = 0 //治疗费用

	decimal.DivisionPrecision = 2

	for _, item := range orderInfos {
		if item.MedChrgitmType == "01" { //床位费
			bedCostTotal, _ = decimal.NewFromFloat(bedCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			bedCostSelfTotal, _ = decimal.NewFromFloat(bedCostSelfTotal).Add(decimal.NewFromFloat(item.OverlmtAmt)).Float64()
			bedCostPartSelfTotal, _ = decimal.NewFromFloat(bedCostPartSelfTotal).Add(decimal.NewFromFloat(item.PreselfpayAmt)).Float64()
		}

		if item.MedChrgitmType == "03" { //检查费
			checkCostTotal, _ = decimal.NewFromFloat(checkCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			checkCostSelfTotal, _ = decimal.NewFromFloat(checkCostSelfTotal).Add(decimal.NewFromFloat(item.OverlmtAmt)).Float64()
			checkCostPartSelfTotal, _ = decimal.NewFromFloat(checkCostPartSelfTotal).Add(decimal.NewFromFloat(item.PreselfpayAmt)).Float64()
		}

		if item.MedChrgitmType == "04" { //化验费
			laboratoryCostTotal, _ = decimal.NewFromFloat(laboratoryCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			laboratoryCostSelfTotal, _ = decimal.NewFromFloat(laboratoryCostSelfTotal).Add(decimal.NewFromFloat(item.OverlmtAmt)).Float64()
			laboratoryCostPartSelfTotal, _ = decimal.NewFromFloat(laboratoryCostPartSelfTotal).Add(decimal.NewFromFloat(item.PreselfpayAmt)).Float64()
		}

		if item.MedChrgitmType == "05" { //治疗费
			treatCostTotal, _ = decimal.NewFromFloat(treatCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			treatCostSelfTotal, _ = decimal.NewFromFloat(treatCostSelfTotal).Add(decimal.NewFromFloat(item.OverlmtAmt)).Float64()
			treatCostPartSelfTotal, _ = decimal.NewFromFloat(treatCostPartSelfTotal).Add(decimal.NewFromFloat(item.PreselfpayAmt)).Float64()
		}

		if item.MedChrgitmType == "06" { //手术费
			operationCostTotal, _ = decimal.NewFromFloat(operationCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			operationCostSelfTotal, _ = decimal.NewFromFloat(operationCostSelfTotal).Add(decimal.NewFromFloat(item.OverlmtAmt)).Float64()
			operationCostPartSelfTotal, _ = decimal.NewFromFloat(operationCostPartSelfTotal).Add(decimal.NewFromFloat(item.PreselfpayAmt)).Float64()
		}

		if item.MedChrgitmType == "08" { //材料费
			materialCostTotal, _ = decimal.NewFromFloat(materialCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			materialCostSelfTotal, _ = decimal.NewFromFloat(materialCostSelfTotal).Add(decimal.NewFromFloat(item.OverlmtAmt)).Float64()
			materialCostPartSelfTotal, _ = decimal.NewFromFloat(materialCostPartSelfTotal).Add(decimal.NewFromFloat(item.PreselfpayAmt)).Float64()
		}

		if item.MedChrgitmType == "09" { //西药费
			westernMedicineCostTotal, _ = decimal.NewFromFloat(westernMedicineCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			westernMedicineCostSelfTotal, _ = decimal.NewFromFloat(westernMedicineCostSelfTotal).Add(decimal.NewFromFloat(item.OverlmtAmt)).Float64()
			westernMedicineCostPartSelfTotal, _ = decimal.NewFromFloat(westernMedicineCostPartSelfTotal).Add(decimal.NewFromFloat(item.PreselfpayAmt)).Float64()
		}

		if item.MedChrgitmType == "11" { //中成费
			chineseTraditionalMedicineCostTotal, _ = decimal.NewFromFloat(chineseTraditionalMedicineCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			chineseTraditionalMedicineCostSelfTotal, _ = decimal.NewFromFloat(chineseTraditionalMedicineCostSelfTotal).Add(decimal.NewFromFloat(item.OverlmtAmt)).Float64()
			chineseTraditionalMedicineCostPartSelfTotal, _ = decimal.NewFromFloat(chineseTraditionalMedicineCostPartSelfTotal).Add(decimal.NewFromFloat(item.PreselfpayAmt)).Float64()
		}

		if item.MedChrgitmType == "14" { //其他费
			otherCostTotal, _ = decimal.NewFromFloat(otherCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			otherCostSelfTotal, _ = decimal.NewFromFloat(otherCostSelfTotal).Add(decimal.NewFromFloat(item.OverlmtAmt)).Float64()
			otherCostPartSelfTotal, _ = decimal.NewFromFloat(otherCostPartSelfTotal).Add(decimal.NewFromFloat(item.PreselfpayAmt)).Float64()
		}

	}

	admin, _ := service.GetAdminUserInfoByID(adminUser.CurrentOrgId, adminUser.AdminUser.Id)

	c.ServeSuccessJSON(map[string]interface{}{
		"order_number":    order.Number,             //业务流水号
		"id_card_no":      his.IdCardNo,             //社会保障号
		"department_name": department.Name,          //科室
		"number":          his.Number,               //门诊号
		"date":            order.SettleAccountsDate, //结算日期
		"name":            order.PsnName,            //姓名
		"gender":          order.Gend,               //性别
		"psn_cash_money":  order.PsnCashPay,         //个人支付
		"pay_way":         "门诊",                     //结算方式
		"medfee_sumamt":   order.MedfeeSumamt,       //总费用
		"admin_user_name": admin.UserName,           //收款员

		"bedCostTotal":                                bedCostTotal,
		"bedCostSelfTotal":                            bedCostSelfTotal,
		"bedCostPartSelfTotal":                        bedCostPartSelfTotal,
		"operationCostTotal":                          operationCostTotal,
		"operationCostSelfTotal":                      operationCostSelfTotal,
		"operationCostPartSelfTotal":                  operationCostPartSelfTotal,
		"otherCostTotal":                              otherCostTotal,
		"otherCostSelfTotal":                          otherCostSelfTotal,
		"otherCostPartSelfTotal":                      otherCostPartSelfTotal,
		"materialCostTotal":                           materialCostTotal,
		"materialCostSelfTotal":                       materialCostSelfTotal,
		"materialCostPartSelfTotal":                   materialCostPartSelfTotal,
		"westernMedicineCostTotal":                    westernMedicineCostTotal,
		"westernMedicineCostSelfTotal":                westernMedicineCostSelfTotal,
		"westernMedicineCostPartSelfTotal":            westernMedicineCostPartSelfTotal,
		"chineseTraditionalMedicineCostTotal":         chineseTraditionalMedicineCostTotal,
		"chineseTraditionalMedicineCostSelfTotal":     chineseTraditionalMedicineCostSelfTotal,
		"chineseTraditionalMedicineCostPartSelfTotal": chineseTraditionalMedicineCostPartSelfTotal,
		"checkCostTotal":                              checkCostTotal,
		"checkCostSelfTotal":                          checkCostSelfTotal,
		"checkCostPartSelfTotal":                      checkCostPartSelfTotal,
		"laboratoryCostTotal":                         laboratoryCostTotal,
		"laboratoryCostSelfTotal":                     laboratoryCostSelfTotal,
		"laboratoryCostPartSelfTotal":                 laboratoryCostPartSelfTotal,
		"treatCostTotal":                              treatCostTotal,
		"treatCostSelfTotal":                          treatCostSelfTotal,
		"treatCostPartSelfTotal":                      treatCostPartSelfTotal,
	})

}

func (this *HisApiController) GetIncomeStatisticsData() {
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	key_words := this.GetString("key_words")
	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")

	if page <= 0 {
		page = 1
	}
	if limit <= 0 {
		limit = 10
	}
	statistics_type, _ := this.GetInt64("statistics_type")
	admin := this.GetAdminUserInfo()
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	var theStartTIme int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			theStartTIme = 0
		}
		theStartTIme = theTime.Unix()
	}
	var theEndtTIme int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			theEndtTIme = 0
		}
		theEndtTIme = theTime.Unix()
	}

	if statistics_type == 1 {
		list, total, _ := service.GetDayIncomeStatisticsData(admin.CurrentOrgId, key_words, theStartTIme, theEndtTIme, page, limit)
		this.ServeSuccessJSON(map[string]interface{}{
			"list":  list,
			"total": total,
		})
	} else {
		list, total, _ := service.GetDayIncomeDetailStatisticsData(admin.CurrentOrgId, key_words, theStartTIme, theEndtTIme, page, limit)
		this.ServeSuccessJSON(map[string]interface{}{
			"list":  list,
			"total": total,
		})

	}

}

func (c *HisApiController) PostProjectInformation() {
	adminUser := c.GetAdminUserInfo()
	orgId := adminUser.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		return
	}
	utils.ErrorLog("%v", dataBody)
	var projectList []*models.HisProject
	var total_goods []interface{}
	tempProjects := dataBody["projects"].([]interface{})
	fmt.Println("666666666666", tempProjects)
	total_goods = tempProjects
	for index, projectMap := range tempProjects {

		projectM := projectMap.(map[string]interface{})

		var project models.HisProject
		if projectM["project_name"] == nil || reflect.TypeOf(projectM["project_name"]).String() != "string" {
			utils.ErrorLog("project_name")
			return
		}

		project_name, _ := projectM["project_name"].(string)
		if len(project_name) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    6,
				UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的项目名称不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		project.ProjectName = project_name

		prices := projectM["price"].(string)

		price, _ := strconv.ParseFloat(prices, 64)
		if price <= 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    6,
				UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的零价不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		project.Price = price

		if projectM["unit"] == nil || reflect.TypeOf(projectM["unit"]).String() != "string" {
			utils.ErrorLog("unit_id")
			return
		}

		unit := projectM["unit"].(string)
		if len(unit) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    6,
				UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的单位不能为空或内容与系统不匹配",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}
		project.Unit = unit

		cost_classify := projectM["cost_classify"].(string)
		if len(cost_classify) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    6,
				UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的费用类别不能为空或内容与系统不匹配",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}
		var costClassify = "费用类别"
		var cost_classify_id int64

		costClassifyConfig, _ := service.GetDrugDataConfig(0, costClassify)

		if len(cost_classify) != 0 {
			_, errcode := service.IsExistDicConfig(costClassifyConfig.ID, cost_classify, orgId)
			if errcode == gorm.ErrRecordNotFound {
				dataconfig := models.DictDataconfig{
					ParentId:       costClassifyConfig.ID,
					Module:         "system",
					OrgId:          orgId,
					Name:           cost_classify,
					FieldName:      "",
					Value:          index + 50,
					CreatedTime:    "",
					UpdatedTime:    "",
					CreateUserId:   adminUser.AdminUser.Id,
					Status:         1,
					Remark:         "",
					DeleteIdSystem: 0,
					Title:          "",
					Content:        "",
					Order:          0,
					Code:           "",
				}
				service.CreatedDicConfig(&dataconfig)
			}
		}

		costClassList, _ := service.GetParentDataConfig(costClassifyConfig.ID, orgId)

		for _, it := range costClassList {
			if cost_classify == it.Name {
				cost_classify_id = int64(it.Value)
			}
		}
		project.CostClassify = cost_classify_id

		executive_section := projectM["executive_section"].(string)
		if len(executive_section) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    6,
				UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的费用类别不能为空或内容与系统不匹配",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		if len(executive_section) != 0 {
			//查找科室是否有内容
			_, errcodedepart := service.GetDepartMentByName(executive_section, orgId)
			if errcodedepart == gorm.ErrRecordNotFound {
				department := models.XtHisDepartment{
					Name:        executive_section,
					Status:      1,
					UserOrgId:   adminUser.CurrentOrgId,
					CreatedTime: time.Now().Unix(),
				}
				service.CreateDePartment(&department)
			}
		}
		var executive_section_id int64
		departMentList, _ := service.GetAllDepartMent(orgId)
		for _, it := range departMentList {
			if executive_section == it.Name {
				executive_section_id = it.ID
			}
		}
		project.ExecutiveSection = executive_section_id

		medical_coverage := projectM["medical_coverage"].(string)
		fmt.Println("3333333333333", medical_coverage)
		if len(medical_coverage) == 0 { //名字为空则生成一条导入错误日志
			err_log := models.ExportErrLog{
				LogType:    6,
				UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
				ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的费用类别不能为空",
				Status:     1,
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: time.Now().Unix(),
			}
			service.CreateExportErrLog(&err_log)
			continue
		}

		var medicalCoverage = "医保等级"
		var medical_coverage_id int64

		medicalCoverageConfig, _ := service.GetDrugDataConfig(0, medicalCoverage)
		if len(medical_coverage) != 0 {

			_, errormedicalcoverage := service.IsExistDicConfig(medicalCoverageConfig.ID, medical_coverage, orgId)
			if errormedicalcoverage == gorm.ErrRecordNotFound {
				dataconfig := models.DictDataconfig{
					ParentId:       medicalCoverageConfig.ID,
					Module:         "system",
					OrgId:          orgId,
					Name:           medical_coverage,
					FieldName:      "",
					Value:          index + 50,
					CreatedTime:    "",
					UpdatedTime:    "",
					CreateUserId:   adminUser.AdminUser.Id,
					Status:         1,
					Remark:         "",
					DeleteIdSystem: 0,
					Title:          "",
					Content:        "",
					Order:          0,
					Code:           "",
				}
				service.CreatedDicConfig(&dataconfig)
			}
		}
		medicalCoverageList, _ := service.GetParentDataConfig(medicalCoverageConfig.ID, orgId)
		for _, it := range medicalCoverageList {
			if medical_coverage == it.Name {
				medical_coverage_id = int64(it.Value)
			}
		}
		project.MedicalCoverage = medical_coverage_id

		pinyin := projectM["pinyin"].(string)
		project.Pinyin = pinyin

		wubi := projectM["wubi"].(string)
		fmt.Println("五笔333333333333333333333333333333", wubi)
		project.Wubi = wubi

		statistical_classification := projectM["statistical_classification"].(string)

		var statisticalClassification = "统计分类"
		var statistical_classification_id int64
		classiFication, _ := service.GetDrugDataConfig(0, statisticalClassification)
		if len(statistical_classification) != 0 {

			_, classificationerrcodes := service.IsExistDicConfig(classiFication.ID, statistical_classification, orgId)

			if classificationerrcodes == gorm.ErrRecordNotFound {
				dataconfig := models.DictDataconfig{
					ParentId:       classiFication.ID,
					Module:         "system",
					OrgId:          orgId,
					Name:           statistical_classification,
					FieldName:      "",
					Value:          index + 50,
					CreatedTime:    "",
					UpdatedTime:    "",
					CreateUserId:   adminUser.AdminUser.Id,
					Status:         1,
					Remark:         "",
					DeleteIdSystem: 0,
					Title:          "",
					Content:        "",
					Order:          0,
					Code:           "",
				}
				service.CreatedDicConfig(&dataconfig)
			}

		}
		classiFicationList, _ := service.GetParentDataConfig(classiFication.ID, orgId)

		for _, it := range classiFicationList {
			if statistical_classification == it.Name {

				statistical_classification_id = int64(it.Value)
			}
		}

		project.StatisticalClassification = statistical_classification_id

		disease_directory := int64(projectM["disease_directory"].(float64))
		project.DiseaseDirectory = disease_directory

		is_record := int64(projectM["is_record"].(float64))
		project.IsRecord = is_record

		medical_code := projectM["medical_code"].(string)
		project.MedicalCode = medical_code

		tube_color := projectM["tube_color"].(string)

		var tubeColor = "试管颜色"
		var tube_color_id int64
		tubeColorConfig, _ := service.GetDrugDataConfig(0, tubeColor)
		if len(tube_color) != 0 {
			_, errcodetube := service.IsExistDicConfig(tubeColorConfig.ID, tube_color, orgId)
			if errcodetube == gorm.ErrRecordNotFound {
				dataconfig := models.DictDataconfig{
					ParentId:       tubeColorConfig.ID,
					Module:         "system",
					OrgId:          orgId,
					Name:           tube_color,
					FieldName:      "",
					Value:          index + 50,
					CreatedTime:    "",
					UpdatedTime:    "",
					CreateUserId:   adminUser.AdminUser.Id,
					Status:         1,
					Remark:         "",
					DeleteIdSystem: 0,
					Title:          "",
					Content:        "",
					Order:          0,
					Code:           "",
				}
				service.CreatedDicConfig(&dataconfig)
			}

		}

		tubeColorList, _ := service.GetParentDataConfig(tubeColorConfig.ID, orgId)
		for _, it := range tubeColorList {
			if tube_color == it.Name {
				tube_color_id = int64(it.Value)
			}
		}

		project.TubeColor = tube_color_id

		single_dose := projectM["single_dose"].(string)
		project.SingleDose = single_dose
		execution_frequency := projectM["execution_frequency"].(string)
		project.ExecutionFrequency = execution_frequency

		delivery_way := projectM["delivery_way"].(string)
		project.DeliveryWay = delivery_way

		number_days := projectM["number_days"].(string)
		project.NumberDays = number_days

		total := projectM["total"].(string)
		project.Total = total

		medical_status := int64(projectM["medical_status"].(float64))
		project.MedicalStatus = medical_status

		category := int64(projectM["category"].(float64))
		project.Category = category

		specail_project := int64(projectM["specail_project"].(float64))
		project.SpecailProject = specail_project

		social_security_directory_code := projectM["social_security_directory_code"].(string)
		fmt.Println("社保目录编码22222222222", social_security_directory_code)
		project.SocialSecurityDirectoryCode = social_security_directory_code

		remark := projectM["remark"].(string)
		project.Remark = remark

		record_date := projectM["record_date"].(string)
		fmt.Println("日期222222222", record_date)
		timeLayout := "2006-01-02"
		loc, _ := time.LoadLocation("Local")

		theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
		project.RecordDate = theTime.Unix()
		projectList = append(projectList, &project)
	}

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

	errLogs, _ := service.FindPatientExportLog(c.GetAdminUserInfo().CurrentOrgId, export_time)
	if len(projectList) > 0 {
		for _, item := range projectList {
			project := models.HisProject{
				ProjectName:      item.ProjectName,
				Price:            item.Price,
				Unit:             item.Unit,
				CostClassify:     item.CostClassify,
				ExecutiveSection: item.ExecutiveSection,
				MedicalCoverage:  item.MedicalCoverage,
				UserOrgId:        orgId,
				Status:           1,
				CreatedTime:      time.Now().Unix(),
				Pinyin:           item.Pinyin,
				Wubi:             item.Wubi,
				StatisticalClassification: item.StatisticalClassification,
				DiseaseDirectory:          item.DiseaseDirectory,
				IsRecord:                  item.IsRecord,
				MedicalCode:               item.MedicalCode,
				TubeColor:                 item.TubeColor,
				SingleDose:                item.SingleDose,
				DeliveryWay:               item.DeliveryWay,
				NumberDays:                item.NumberDays,
				Total:                     item.Total,
				Category:                  item.Category,
				MedicalStatus:             item.MedicalStatus,
				SpecailProject:            item.SpecailProject,
				RecordDate:                item.RecordDate,
				Remark:                    item.Remark,
				SocialSecurityDirectoryCode: item.SocialSecurityDirectoryCode,
				ExecutionFrequency:          item.ExecutionFrequency,
			}

			_, errcodeproject := service.GetProjectByNameIsExsit(item.ProjectName, orgId)
			if errcodeproject == gorm.ErrRecordNotFound {
				service.CreateProjectInfomation(&project)
			} else if errcodeproject == nil {
				service.UpdateProjectByName(&project, item.ProjectName, orgId)
			}

			log := models.ExportLog{
				LogType:    6,
				UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
				TotalNum:   int64(len(total_goods)),
				FailNum:    int64(len(errLogs)),
				SuccessNum: int64(len(projectList)),
				CreateTime: time.Now().Unix(),
				UpdateTime: time.Now().Unix(),
				ExportTime: export_time,
				Status:     1,
			}
			service.CreateExportLog(&log)
			c.ServeSuccessJSON(map[string]interface{}{
				"msg":         "导入成功",
				"total_num":   len(total_goods),
				"success_num": len(projectList),
				"fail_num":    int64(len(errLogs)),
			})
		}
	} else {
		log := models.ExportLog{
			LogType:    6,
			UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
			TotalNum:   int64(len(total_goods)),
			FailNum:    int64(len(errLogs)),
			SuccessNum: int64(len(projectList)),
			CreateTime: time.Now().Unix(),
			UpdateTime: time.Now().Unix(),
			ExportTime: export_time,
			Status:     1,
		}
		service.CreateExportLog(&log)

		c.ServeSuccessJSON(map[string]interface{}{
			"msg":         "导入成功",
			"total_num":   len(total_goods),
			"success_num": len(projectList),
			"fail_num":    int64(len(errLogs)),
		})
	}
}