XT_New/service/common_service.go

package service

import (
	"XT_New/models"
	"fmt"
	"github.com/jinzhu/gorm"
	"strconv"
	"time"
)

func GetInspectionMajor(orgid int64) (inspection []*models.XtInspectionReference, err error) {

	err = XTReadDB().Model(&inspection).Where("org_id = ? and status = 1", orgid).Group("project_name").Order("id asc").Find(&inspection).Error
	return inspection, err
}

func GetInspectionMinor(projectid int64, orgid int64) (inspection []*models.XtInspectionReference, err error) {

	err = XTReadDB().Model(&inspection).Where("project_id = ? and status = 1 and org_id = ?", projectid, orgid).Find(&inspection).Error
	return inspection, err
}

func GetInspectionRange(id int64) (models.XtInspectionReference, error) {
	reference := models.XtInspectionReference{}
	err := XTReadDB().Model(&reference).Where("id=? and status = 1", id).Find(&reference).Error
	return reference, err
}

func GetItemid(id int64) (models.XtInspectionReference, error) {
	reference := models.XtInspectionReference{}
	err = XTReadDB().Model(&reference).Where("id = ? and status = 1", id).Find(&reference).Error
	return reference, err
}

func GetConfigurationById(major int64, moni int64, orgid int64) (*models.XtQualityControlStandard, error) {
	standard := models.XtQualityControlStandard{}
	err := XTReadDB().Model(&standard).Where("inspection_major = ? and inspection_minor = ? and user_org_id = ? and status = 1", major, moni, orgid).Find(&standard).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &standard, nil
}

func GetConfigurationByIdTwo(major int64, moni int64, orgid int64) (standard models.XtQualityControlStandard, err error) {

	err = XTReadDB().Model(&standard).Where("inspection_major = ? and inspection_minor = ? and user_org_id = ? and status = 1", major, moni, orgid).First(&standard).Error
	return standard, err
}

func SaveInspection(standard *models.XtQualityControlStandard) error {

	err := XTWriteDB().Create(&standard).Error
	return err
}

func GetConfigurationlist(orgid int64, limit int64, page int64) (standard []*models.QualityControlStandard, total int64, err error) {

	db := XTReadDB().Table("xt_quality_control_standard as x").Where("x.status =1")
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	table := XTReadDB().Table("xt_inspection_reference as s")
	fmt.Println(table)
	offset := (page - 1) * limit
	err = db.Order("x.sort asc,x.created_time desc").Group("x.id").Select("x.id,x.inspection_major,x.inspection_minor,x.min_range,x.large_range,x.sort,x.user_org_id,x.range_value,x.range_type,s.unit,s.project_name,s.item_name").Count(&total).
		Joins("left join xt_inspection_reference as s on s.id = x.inspection_minor").Offset(offset).Limit(limit).Scan(&standard).Error
	return standard, total, err
}

func GetConfigurationListTwo(orgid int64, limit int64, page int64) (standard []*models.QualityControlStandard, total int64, err error) {
	db := XTReadDB().Table("xt_quality_control_standard as x").Where("x.status =1")
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	table := XTReadDB().Table("xt_inspection_reference as s")
	fmt.Println(table)
	offset := (page - 1) * limit
	err = db.Order("x.sort asc,x.created_time desc").Group("x.id").Select("x.id,x.inspection_major,x.inspection_minor,x.min_range,x.large_range,x.sort,x.user_org_id,x.range_value,x.range_type,s.unit,s.project_name,s.item_name").Count(&total).
		Joins("left join xt_inspection_reference as s on s.item_id = x.inspection_minor").Offset(offset).Limit(limit).Scan(&standard).Error
	return standard, total, err
}

func GetConfigurationDetail(id int64) (models.XtQualityControlStandard, error) {
	standard := models.XtQualityControlStandard{}
	err := XTReadDB().Model(&standard).Where("id=? and status = 1", id).Find(&standard).Error
	return standard, err
}

func GetIdByItemId(itemid int64, orgid int64) (models.XtInspectionReference, error) {
	reference := models.XtInspectionReference{}
	err := XTReadDB().Model(&reference).Where("item_id = ? and org_id = ?", itemid, orgid).Find(&reference).Error
	return reference, err
}

func GetAllInspectionMinor(orgid int64) (standard []*models.XtInspectionReference, err error) {

	err = XTReadDB().Model(&standard).Where("org_id = ? and status = 1", orgid).Find(&standard).Error
	return standard, err
}

func UpdarteConfiguration(st *models.XtQualityControlStandard, id int64) error {

	err := XTWriteDB().Model(&st).Where("id = ?", id).Updates(map[string]interface{}{"inspection_major": st.InspectionMajor, "inspection_minor": st.InspectionMinor, "min_range": st.MinRange, "large_range": st.LargeRange, "sort": st.Sort, "range_value": st.RangeValue, "range_type": st.RangeType, "updated_time": time.Now().Unix()}).Error
	return err
}

func DeleteConfiguration(id int64) (err error) {

	err = XTWriteDB().Model(models.XtQualityControlStandard{}).Where("id=?", id).Updates(map[string]interface{}{"status": 0, "updated_time": time.Now().Unix()}).Error
	return err
}

func GetAllInspectionData(orgid int64) (*models.XtInspectionReference, error) {
	diseases := models.XtInspectionReference{}
	err := XTReadDB().Model(&diseases).Where("org_id = ? and status = 1", orgid).Find(&diseases).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &diseases, nil
}

func GetAllInspectiondatatwo(orgid int64) (reference []*models.XtInspectionReference, err error) {

	err = XTReadDB().Model(&reference).Where("org_id = ? and status = 1", orgid).Group("project_name").Find(&reference).Error
	return reference, err
}

func GetInspectionMajorById(marjor int64, orgid int64) (*models.XtCheckConfiguration, error) {
	configuration := models.XtCheckConfiguration{}
	err := XTReadDB().Model(&configuration).Where("inspection_major = ? and user_org_id = ? and status =1", marjor, orgid).Find(&configuration).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &configuration, nil
}

func GetInspectionMajorByIdTwo(marjor int64, orgid int64) (configuration models.XtCheckConfiguration, err error) {
	err = XTReadDB().Model(&configuration).Where("inspection_major = ? and user_org_id = ? and status =1", marjor, orgid).First(&configuration).Error
	return configuration, err
}

func CreateCheckConfiguration(configuration *models.XtCheckConfiguration) error {
	err := XTWriteDB().Create(&configuration).Error
	return err
}

func GetAllCheckList(orgid int64, page int64, limit int64) (check []*models.CheckConfiguration, total int64, err error) {

	db := XTReadDB().Table("xt_check_configuration as x").Where("x.status =1")
	table := XTReadDB().Table("xt_inspection_reference as r")
	fmt.Println(table)
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	offset := (page - 1) * limit
	err = db.Group("x.id").Order("x.sort asc,x.created_time desc").Select("x.id,x.inspection_major,x.inspection_frequency,x.sort,x.user_org_id,r.project_name").Count(&total).
		Joins("left join xt_inspection_reference as r on r.project_id = x.inspection_major").Offset(offset).Limit(limit).Scan(&check).Error
	return check, total, err
}

func GetCheckDetail(id int64) (models.XtCheckConfiguration, error) {

	configuration := models.XtCheckConfiguration{}
	err := XTReadDB().Model(&configuration).Where("id=? and status =1", id).Find(&configuration).Error
	return configuration, err
}

func UpdateCheck(con *models.XtCheckConfiguration, id int64) error {

	err := XTWriteDB().Model(&con).Where("id=?", id).Updates(map[string]interface{}{"inspection_major": con.InspectionMajor, "inspection_frequency": con.InspectionFrequency, "sort": con.Sort, "updated_time": time.Now().Unix()}).Error
	return err
}

func DeleteCheck(id int64) error {

	err := XTWriteDB().Model(models.XtCheckConfiguration{}).Where("id=?", id).Updates(map[string]interface{}{"status": 0, "updated_time": time.Now().Unix()}).Error
	return err
}

func GetDialysiTotal(startime int64, endtime int64, orgid int64) (order []*models.DialysisOrder, total int64, err error) {
	err = XTReadDB().Model(&order).Where("dialysis_date >= ? and dialysis_date<=? and user_org_id = ?", startime, endtime, orgid).Count(&total).Find(&order).Error
	return order, total, err

}

func GetDialysisCountMode(starttime int64, endtime int64, orgid int64) (counts []*models.PatientPrescriptionCountStruct, err error) {
	//err = readDb.Table("xt_dialysis_prescription as p").Where("p.record_date>= ? and p.record_date<=? and p.user_org_id=?", starttime, endtime, orgid).Select("p.mode_id,count(p.mode_id) as count").Group("p.mode_id").Scan(&counts).Error
	//return counts, err

	err = readDb.Table("xt_dialysis_order as o left join xt_schedule as s on s.patient_id = o.patient_id").Where("s.schedule_date = o.dialysis_date and o.dialysis_date>=? and o.dialysis_date<=? and o.user_org_id = ? and o.status = 1 and s.status = 1", starttime, endtime, orgid).Select("s.mode_id,count(s.mode_id) as count").Group("s.mode_id").Scan(&counts).Error
	return counts, err

}

func GetTotalRollOut(starttime int64, endtime int64, orgid int64) (counts []*models.PatientLapseto, total int64, err error) {

	db := readDb.Table("xt_patient_lapseto as x").Where("x.status = 1")
	table := readDb.Table("xt_dialysis_order as s")
	fmt.Println(table)
	err = db.Select("x.patient_id,x.lapseto_type").Joins("left join xt_dialysis_order as s on s.patient_id = x.patient_id").Where("x.lapseto_time >=? and x.lapseto_time <= ? and x.lapseto_type = 2 and s.user_org_id = ?", starttime, endtime, orgid).Group("x.patient_id").Count(&total).Scan(&counts).Error
	return counts, total, err
}

func GetTotalRollOutPatients(orgid int64, startime int64, endtime int64) (patients []*models.XtPatients, err error) {

	db := XTReadDB().Table("x.patients as x")
	err = db.Raw("select x.id,x.`name`,s.lapseto_type,s.lapseto_time from xt_patients as x left join xt_patient_lapseto AS s ON s.patient_id = x.id where s.lapseto_time >=? and s.lapseto_time <=? and x.user_org_id = ? and s.lapseto_type = 1 and x.status = 1", startime, endtime, orgid).Scan(&patients).Error
	return patients, err
}

func GetTotalRollOutPatientsTwo(orgid int64, startime int64, endtime int64) (patients []*models.XtPatients, err error) {

	db := XTReadDB().Table("x.patients as x")
	err = db.Raw("select x.id,x.`name`,s.lapseto_type,s.lapseto_time from xt_patients as x left join xt_patient_lapseto AS s ON s.patient_id = x.id where s.lapseto_time >=? and s.lapseto_time <=? and x.user_org_id = ? and s.lapseto_type = 2 and x.status = 1", startime, endtime, orgid).Scan(&patients).Error
	return patients, err
}

func GetPatientTotalCount(orgID int64) (total int64) {
	readDb.Model(&models.XtPatients{}).Where("user_org_id=? and status=1", orgID).Count(&total)
	return
}

func GetPatientTotalCountTwo(orgid int64, starttime int64, endtime int64) (dialysisorder []*models.XtDialysisOrder, total int64, err error) {

	err = XTReadDB().Model(&dialysisorder).Group("patient_id").Where("user_org_id = ? and dialysis_date >= ? and dialysis_date <=? and status =1", orgid, starttime, endtime).Count(&total).Find(&dialysisorder).Error
	return dialysisorder, total, err
}

func GetManPatientTotalCount(orgid int64, starttime int64, endtime int64) (dialysisorder []*models.SgjDialysisOrder, total int64, err error) {

	db := XTReadDB().Table("xt_dialysis_order as s").Where("s.status = 1")
	table := XTReadDB().Table("xt_patients as x")
	fmt.Println("table", table)
	err = db.Select("s.dialysis_date,s.prescription_id").Joins("left join xt_patients as x on x.id = s.patient_id").Where("s.dialysis_date>=? and s.dialysis_date<=? and s.user_org_id = ? and s.status = 1 and x.gender = 1", starttime, endtime, orgid).Group("s.patient_id").Count(&total).Scan(&dialysisorder).Error
	return dialysisorder, total, err

}

func GetManPatientTotal(orgid int64) (patients []*models.XtPatients, total int64, err error) {

	err = XTReadDB().Model(&patients).Where("user_org_id = ? and status = 1 and gender = 1", orgid).Count(&total).Find(&patients).Error
	return patients, total, err
}

//func GetPatientInfectiousCount(orgid int64, starttime int64, endtime int64) (counts []*models.PatientContagionsCountStruct, err error) {
//	err = readDb.Table("xt_patients_infectious_diseases as x").Joins("join xt_dialysis_order as o on o.patient_id = x.patient_id").Joins("join xt_patients as s on s.id = x.patient_id").Where("o.user_org_id = ? and o.status =1 and o.dialysis_date>=? and o.dialysis_date <=? and x.status =1 and s.is_infectious = 2", orgid, starttime, endtime).Select("x.disease_id,count(x.disease_id) as count").Group("x.disease_id").Scan(&counts).Error
//	return counts, err
//}

func GetPatientInfectiousCount(orgid int64, startime int64, endtime int64) (counts []*models.PatientContagionsCountStruct, err error) {

	err = readDb.Table("xt_patients_infectious_diseases as x").Joins("join xt_patients as s on s.id = x.patient_id").Where("s.user_org_id = ? and s.status = 1 and x.status = 1 and x.updated_time>=? and x.updated_time<=?", orgid, startime, endtime).Select("x.disease_id,count(x.disease_id) as count").Group("x.disease_id").Scan(&counts).Error
	return counts, err
}

func GetPatientOtherInfectious(orgid int64) (patients []*models.XtPatients, total int64, err error) {

	err = XTReadDB().Model(&patients).Where("user_org_id = ? and status = 1 and is_infectious = 1", orgid).Count(&total).Find(&patients).Error
	return patients, total, err
}

func GetTotalAgeCount(orgid int64) (counts []*models.PatientAgeCountStruct, err error) {

	readDb.Raw(`SELECT nnd AS 'age',COUNT(*) AS 'count' FROM(
	 SELECT
	 CASE
	  WHEN ( substring( now( ), 1, 4 ) - substring( id_card_no, 7, 4 ) ) - ( substring( id_card_no, 11, 4 ) - date_format( now( ), '%m%d' ) > 0 )<=20 THEN '20'
    WHEN ( substring( now( ), 1, 4 ) - substring( id_card_no, 7, 4 ) ) - ( substring( id_card_no, 11, 4 ) - date_format( now( ), '%m%d' ) > 0 )<=40 THEN '40'
    WHEN ( substring( now( ), 1, 4 ) - substring( id_card_no, 7, 4 ) ) - ( substring( id_card_no, 11, 4 ) - date_format( now( ), '%m%d' ) > 0 )<=60 THEN '60'
    WHEN ( substring( now( ), 1, 4 ) - substring( id_card_no, 7, 4 ) ) - ( substring( id_card_no, 11, 4 ) - date_format( now( ), '%m%d' ) > 0 )<=80 THEN '80'
    ELSE '150'
	 END
	 AS nnd FROM xt_patients as s  where s.user_org_id=? and s.status=1
	 )a GROUP BY nnd`, orgid).Scan(&counts)
	return

}

func GetTotalAgeCountTwo(orgid int64, starttime int64, endtime int64) (counts []*models.PatientAgeCountStruct, err error) {
	readDb.Raw(`SELECT nnd AS 'age',COUNT(*) AS 'count' FROM(
	 SELECT
	 CASE
	    when (substring(now(),1,4)-substring(id_card_no,7,4))-(substring(id_card_no,11,4)-date_format(now(),'%m%d')>0) and  (substring(now(),1,4)-substring(id_card_no,7,4))-(substring(id_card_no,11,4)-date_format(now(),'%m%d')<20) THEN '20'
	   END
       AS nnd FROM xt_patients as s  left join xt_dialysis_order as o on o.patient_id = s.id where s.user_org_id=? and s.status=1 and o.dialysis_date>= ? and o.dialysis_date<=?
       )a GROUP BY nnd`, orgid, starttime, endtime).Scan(&counts)
	return
}

func GetTotalDialysisAgeCount(orgid int64) (patients []*models.XtPatients, err error) {

	err = XTReadDB().Where("user_org_id = ? and status =1", orgid).Find(&patients).Error
	return patients, err
}

func GetDialysisAgeData(orgID int64) (counts []*models.DialysisAgePieDataStruct, err error) {

	readDb.Raw(`SELECT nnd AS 'age',COUNT(*) AS 'count' FROM(
	SELECT
	CASE
	WHEN TIMESTAMPDIFF( YEAR, DATE( DATE_ADD( FROM_UNIXTIME( 0 ), INTERVAL p.first_dialysis_date SECOND ) ), curdate( ) ) >= 0 AND TIMESTAMPDIFF( YEAR, DATE( DATE_ADD( FROM_UNIXTIME( 0 ), INTERVAL p.first_dialysis_date SECOND ) ), curdate( ) ) <= 12 THEN '1'
  WHEN TIMESTAMPDIFF( YEAR, DATE( DATE_ADD( FROM_UNIXTIME( 0 ), INTERVAL p.first_dialysis_date SECOND ) ), curdate( ) ) > 12 AND TIMESTAMPDIFF( YEAR, DATE( DATE_ADD( FROM_UNIXTIME( 0 ), INTERVAL p.first_dialysis_date SECOND ) ), curdate( ) ) <= 36 THEN '2'
  WHEN TIMESTAMPDIFF( YEAR, DATE( DATE_ADD( FROM_UNIXTIME( 0 ), INTERVAL p.first_dialysis_date SECOND ) ), curdate( ) ) > 36 AND TIMESTAMPDIFF( YEAR, DATE( DATE_ADD( FROM_UNIXTIME( 0 ), INTERVAL p.first_dialysis_date SECOND ) ), curdate( ) ) <= 60 THEN '3'
  WHEN TIMESTAMPDIFF( YEAR, DATE( DATE_ADD( FROM_UNIXTIME( 0 ), INTERVAL p.first_dialysis_date SECOND ) ), curdate( ) ) > 60 THEN '4'
  END AS nnd FROM xt_patients as p  where p.user_org_id=? and p.status=1 and p.first_dialysis_date <> 0)a GROUP BY nnd`, orgID).Scan(&counts)
	return

}

func GetCurentOrgPatients(orgid int64) (patients []*models.XtPatients, err error) {

	err = XTReadDB().Where("user_org_id = ? and status =1", orgid).Order("created_time desc").Find(&patients).Error
	return patients, err
}

func TotalDialysisCount(startime int64, endtime int64, orgid int64) (order []*models.BloodDialysisOrderCount, err error) {

	db := XTReadDB().Table("xt_dialysis_order as o")

	err = db.Raw("select count(o.id) as count,o.patient_id from xt_dialysis_order as o left join xt_schedule AS x ON x.patient_id = o.patient_id   where o.status = 1 and o.dialysis_date>=? and o.dialysis_date<=? and o.user_org_id = ? and x.schedule_date = o.dialysis_date and x.status = 1", startime, endtime, orgid).Group("o.patient_id").Scan(&order).Error
	return order, err
}

func GetDialysisList(startime int64, endtime int64, page int64, limit int64, orgid int64) (order []*models.BloodDialysisOrder, total int64, err error) {

	db := XTReadDB().Table("xt_dialysis_order as o").Where("o.status = 1")
	table := XTReadDB().Table("xt_schedule as s")
	fmt.Println(table)
	d := XTReadDB().Table("xt_patients as p")
	fmt.Println(d)
	if orgid > 0 {
		db = db.Where("o.user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("o.dialysis_date>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("o.dialysis_date<=?", endtime)
	}
	offset := (page - 1) * limit
	err = db.Group("s.patient_id,s.mode_id").Select("s.mode_id,o.patient_id,p.name,p.id_card_no,p.dialysis_no,p.total_dialysis,p.user_sys_before_count").Joins("left join xt_schedule as s on s.patient_id = o.patient_id").Joins("left join  xt_patients as p on p.id = o.patient_id").Where("s.schedule_date = o.dialysis_date and s.status = 1").Count(&total).Offset(offset).Limit(limit).Scan(&order).Error
	return order, total, err

}

func GetAllDialysisList(startime int64, endtime int64, orgid int64) (order []*models.BloodDialysisOrder, err error) {

	table := XTReadDB().Table("xt_schedule as s")
	fmt.Println(table)
	d := XTReadDB().Table("xt_patients as p")
	fmt.Println(d)
	db := XTReadDB().Table("xt_dialysis_order as o").Where("o.status = 1")
	if orgid > 0 {
		db = db.Where("o.user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("o.dialysis_date>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("o.dialysis_date<=?", endtime)
	}
	err = db.Group("s.patient_id,s.mode_id").Select("s.mode_id,s.patient_id,p.name,p.id_card_no,p.dialysis_no,p.total_dialysis,p.user_sys_before_count").Joins("left join xt_schedule as s on s.patient_id = o.patient_id").Joins("left join xt_patients as p on p.id = o.patient_id").Where("s.schedule_date = o.dialysis_date and s.status = 1 ").Scan(&order).Error
	return order, err
}

func GetDialysisPatientList(startime int64, endtime int64, page int64, limit int64, orgid int64) (order []*models.BloodDialysisOrder, total int64, err error) {

	table := XTReadDB().Table("xt_schedule as s")
	fmt.Println(table)
	d := XTReadDB().Table("xt_patients as p")
	fmt.Println(d)
	db := XTReadDB().Table("xt_dialysis_order as o").Where("o.status = 1")
	if orgid > 0 {
		db = db.Where("o.user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("o.dialysis_date>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("o.dialysis_date<=?", endtime)
	}
	offset := (page - 1) * limit
	err = db.Group("s.patient_id").Select("s.mode_id,o.patient_id,p.name,p.id_card_no,p.dialysis_no,p.total_dialysis,p.user_sys_before_count").Joins("left join xt_schedule as s on s.patient_id = o.patient_id").Joins("left join  xt_patients as p on p.id = o.patient_id").Where("s.schedule_date = o.dialysis_date and s.status =1 ").Count(&total).Offset(offset).Limit(limit).Scan(&order).Error
	return order, total, err
}

func GetLastSort(orgid int64) (models.XtQualityControlStandard, error) {
	standard := models.XtQualityControlStandard{}
	err := XTReadDB().Model(&standard).Where("user_org_id = ? and status =1", orgid).Last(&standard).Error
	return standard, err
}

func GetLastCheckList(orgid int64) (models.XtCheckConfiguration, error) {
	configuration := models.XtCheckConfiguration{}
	err := XTReadDB().Model(&configuration).Where("user_org_id = ? and status =1", orgid).Last(&configuration).Error
	return configuration, err
}

func GetDialysisDetailById(id int64, orgid int64, startime int64, endtime int64, limit int64, page int64) (prescription []*models.BloodDialysisPrescription, total int64, err error) {

	db := XTReadDB().Table("xt_dialysis_prescription as p").Where("p.status =1 ")
	table := XTReadDB().Table("xt_patients as s")
	fmt.Println(table)
	if id > 0 {
		db = db.Where("p.patient_id = ?", id)
	}

	if orgid > 0 {
		db = db.Where("p.user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("p.record_date >= ?", startime)
	}
	if endtime > 0 {
		db = db.Where("p.record_date <=?", endtime)
	}
	offset := (page - 1) * limit
	err = db.Group("p.mode_id").Select("p.mode_id,p.patient_id,s.name,s.id_card_no,s.dialysis_no,s.total_dialysis,s.user_sys_before_count").Joins("left join xt_patients as s on s.id = p.patient_id").Count(&total).Offset(offset).Limit(limit).Scan(&prescription).Error
	return prescription, total, err
}

func GetPrescritionByName(orgid int64, patient_id int64, startime int64, endtime int64, limit int64, page int64) (prescription []*models.BloodDialysisPrescription, total int64, err error) {

	db := XTReadDB().Table("xt_dialysis_prescription as p").Where("p.status =1 ")
	table := XTReadDB().Table("xt_patients as s")
	fmt.Println(table)
	//if len(keywords) > 0 {
	//	likeKey := "%" + keywords + "%"
	//	db = db.Where("s.name LIKE ? OR s.dialysis_no LIKE ?", likeKey, likeKey)
	//}
	if patient_id > 0 {
		db = db.Where("s.id = ?", patient_id)
	}
	if orgid > 0 {
		db = db.Where("p.user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("p.record_date >= ?", startime)
	}
	if endtime > 0 {
		db = db.Where("p.record_date <=?", endtime)
	}
	offset := (page - 1) * limit
	err = db.Group("p.mode_id").Select("p.mode_id,p.patient_id,s.name,s.id_card_no,s.dialysis_no,s.total_dialysis,s.user_sys_before_count").Joins("left join xt_patients as s on s.id = p.patient_id").Count(&total).Offset(offset).Limit(limit).Scan(&prescription).Error
	return prescription, total, err
}

func GetTreateInfo(orgID int64, startime int64, endtime int64, lapseto int64, limit int64, page int64) (blood []*models.TreatDialysisOrder, total int64, err error) {

	db := XTReadDB().Table("xt_dialysis_order as o").Where("o.status =  1")
	table := XTReadDB().Table("xt_schedule as s")
	fmt.Println(table)
	p := XTReadDB().Table("xt_patients as p")
	fmt.Println(p)
	sql := "from_unixtime(o.dialysis_date, '%Y%m%d') AS date"

	if orgID > 0 {
		db = db.Where("o.user_org_id = ?", orgID)
	}
	if startime > 0 {
		db = db.Where("o.dialysis_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("o.dialysis_date<=?", endtime)
	}
	if lapseto == 0 {
		db = db.Where("p.lapseto = 1 or p.lapseto = 2")
	}
	if lapseto > 0 {
		db = db.Where("p.lapseto = ?", lapseto)
	}
	offset := (page - 1) * limit
	err = db.Group("o.dialysis_date").Select(sql).Joins("left join xt_schedule as s on s.patient_id = o.patient_id").Joins("left join xt_patients as p on p.id = o.patient_id").Where("s.schedule_date = o.dialysis_date and s.status =1").Count(&total).Offset(offset).Limit(limit).Scan(&blood).Error
	return blood, total, err

}
func GetTreatList(orgid int64, startime int64, endtime int64, lapseto int64) (ttd []*models.TreatTotalStruct, err error) {
	db := XTReadDB().Table("xt_dialysis_order as o").Where("o.status =  1")
	table := XTReadDB().Table("xt_schedule as s")
	fmt.Println(table)
	p := XTReadDB().Table("xt_patients as p")
	fmt.Println(p)
	if orgid > 0 {
		db = db.Where("o.user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("o.dialysis_date>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("o.dialysis_date<=?", endtime)
	}
	if lapseto == 0 {
		db = db.Where("p.lapseto = 1 or p.lapseto = 2")
	}
	if lapseto > 0 {
		db = db.Where("p.lapseto = ?", lapseto)
	}
	err = db.Select("s.mode_id, count(s.mode_id) as number").Joins("left join xt_schedule as s on s.patient_id = o.patient_id").Joins("left join xt_patients as p on p.id = o.patient_id").Where("s.schedule_date = o.dialysis_date and s.status = 1").Group("s.mode_id").Order("s.mode_id asc").Find(&ttd).Error
	return ttd, err
}

func GetStatistics(orgID int64, startime int64, endtime int64, modeID int64) (dtd []*DialysisTotalDataStruct, ttd []*DialysisTotalDataStruct, err error) {
	db := readDb
	sql := "s.mode_id,from_unixtime(o.dialysis_date, '%Y%m%d') as date, count(o.dialysis_date) as number"
	datesql := " o.dialysis_date as date"
	group := "from_unixtime(o.dialysis_date, '%Y%m%d')"
	db = db.Table(" xt_dialysis_order AS o").Joins("left join xt_schedule as s on o.patient_id = s.patient_id").Where("s.schedule_date = o.dialysis_date and s.status =1")
	if orgID > 0 {
		db = db.Where("o.user_org_id = ?", orgID)
	}
	if modeID > 0 {
		db = db.Where("s.mode_id=?", modeID)
	}
	if startime > 0 {
		db = db.Where("o.dialysis_date>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("o.dialysis_date<=?", endtime)
	}
	db = db.Where("o.status=1")

	err = db.Select("s.mode_id, count(s.mode_id) as number").Group("s.mode_id").Order("s.mode_id asc").Find(&ttd).Error
	if err != nil {
		return
	}

	var ds []*DialysisTotalDataStruct
	err = db.Select(datesql).Group(group).Find(&ds).Error
	if err != nil {
		return
	}

	dates := make([]string, 0)
	if len(ds) > 0 {
		for _, d := range ds {
			dates = append(dates, d.Date)
		}

		db = db.Where("o.dialysis_date IN (?)", dates)

	}

	err = db.Select(sql).Group(group + ", s.mode_id").Order("date asc, s.mode_id").Find(&dtd).Error
	return

}

func GetInspectionTotalCount(orgid int64) (configuration []*models.CheckConfiguration, err error) {
	var count int
	db := XTReadDB().Table("xt_check_configuration as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_inspection_reference as s")
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	fmt.Println(table)
	err = db.Group("x.inspection_major").Select("x.id,x.inspection_major,x.inspection_frequency,x.sort,x.user_org_id,s.project_name").Joins("left join xt_inspection_reference as s on s.project_id = x.inspection_major").Count(&count).Order("x.sort asc").Scan(&configuration).Error
	return configuration, err
}

func GetInspectionProjectCount(orgid int64, startime int64, endtime int64, patientid int64) (projectCounts []*models.UserInspectionProjectCounts, err error) {

	db := XTReadDB().Table("xt_inspection as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_inspection_reference as r")
	fmt.Println(table)
	d := XTReadDB().Table("xt_check_configuration as t").Where("t.status = 1")
	fmt.Println(d)
	if orgid > 0 {
		db = db.Where("x.org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	if patientid > 0 {
		db = db.Where("x.patient_id = ?", patientid)
	}

	err = db.Select("count(distinct x.inspect_date) as count,x.patient_id,x.project_id,r.project_name,t.sort").Joins("left join xt_check_configuration as t on t.inspection_major = x.project_id").Joins("left  join xt_inspection_reference as r on r.project_id = x.project_id").Group("x.project_id,x.patient_id").Scan(&projectCounts).Error
	return
}

func GetInspectionDetailById(id int64, orgid int64, startime int64, endtime int64) (projectCounts []*models.UserInspectionProjectCounts, err error) {
	db := XTReadDB().Table("xt_inspection as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_inspection_reference as r")
	fmt.Println(table)
	d := XTReadDB().Table("xt_check_configuration as t").Where("t.status = 1")
	fmt.Println(d)
	if id > 0 {
		db = db.Where("x.patient_id=?", id)
	}
	if orgid > 0 {
		db = db.Where("x.org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}

	err = db.Select("count(distinct x.inspect_date) as count,x.patient_id,x.project_id,r.project_name,t.inspection_frequency,t.sort").Joins("left join xt_check_configuration as t on t.inspection_major = x.project_id").Joins("left  join xt_inspection_reference as r on r.project_id = x.project_id").Group("project_id,patient_id").Scan(&projectCounts).Error
	return
}

func GetSearchPatientInfo(orgid int64, keywords int64, startime int64, endtime int64) (projectCounts []*models.UserInspectionProjectCounts, err error) {

	db := XTReadDB().Table("xt_inspection as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_inspection_reference as r")
	fmt.Println(table)
	d := XTReadDB().Table("xt_check_configuration as t").Where("t.status = 1")
	fmt.Println(d)
	p := XTReadDB().Table("xt_patients as p")
	fmt.Println(p)
	//if len(keywords) > 0 {
	//	likeKey := "%" + keywords + "%"
	//	db = db.Where("p.name LIKE ? OR p.dialysis_no LIKE ?", likeKey, likeKey)
	//}
	if keywords > 0 {
		db = db.Where("x.patient_id = ?", keywords)
	}
	if orgid > 0 {
		db = db.Where("x.org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}

	err = db.Select("count(distinct x.inspect_date) as count,x.patient_id,x.project_id,r.project_name,t.inspection_frequency").Joins("left join xt_check_configuration as t on t.inspection_major = x.project_id").Joins("left  join xt_inspection_reference as r on r.project_id = x.project_id").Joins("left join xt_patients as p on p.id = x.patient_id").Group("project_id,patient_id").Scan(&projectCounts).Error
	return
}

func GetMajorInspectionByOrgid(orgid int64) (checkconfiguration []*models.CheckConfiguration, err error) {

	db := XTReadDB().Table("xt_check_configuration as x").Where("x.status =1")
	table := XTReadDB().Table("xt_inspection_reference ar r")
	fmt.Println(table)
	err = db.Group("x.inspection_major").Select("x.id,x.inspection_major,x.inspection_frequency,x.sort,x.user_org_id,r.project_name").Where("x.user_org_id = ?", orgid).Joins("left join xt_inspection_reference as r on r.project_id = x.inspection_major").Scan(&checkconfiguration).Error
	return checkconfiguration, err
}

func GetDefaultByOrgId(orgid int64) (checkconfiguration []*models.CheckConfiguration, err error) {

	db := XTReadDB().Table("xt_check_configuration as x").Where("x.status =1")
	table := XTReadDB().Table("xt_inspection_reference ar r")
	fmt.Println(table)
	err = db.Group("x.inspection_major").Select("x.id,x.inspection_major,x.inspection_frequency,x.sort,x.user_org_id,r.project_name").Where("x.user_org_id = ?", orgid).Joins("left join xt_inspection_reference as r on r.project_id = x.inspection_major").Scan(&checkconfiguration).Error
	return checkconfiguration, err
}

func GetPatientListData(orgid int64, startime int64, endtime int64, limit int64, page int64) (inspection []*models.PatientsInspection, total int64, err error) {

	db := XTReadDB().Table("xt_inspection as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_patients as s")
	fmt.Println("table", table)
	if orgid > 0 {
		db = db.Where("x.org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >= ?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	offset := (page - 1) * limit
	err = db.Group("x.patient_id").Select("x.id,x.patient_id,x.project_id,x.project_name,s.name").Joins("left join xt_patients as s on s.id = x.patient_id").Count(&total).Offset(offset).Limit(limit).Scan(&inspection).Error
	return inspection, total, err
}

func GetPatientListInfo(orgid int64, startime int64, endtime int64, limit int64, page int64) (projectCounts []*models.PatientInspectionProjectCount, err error) {

	patients, _, err := GetPatientListData(orgid, startime, endtime, limit, page)

	db := XTReadDB().Table("xt_inspection as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_inspection_reference as r")
	fmt.Println(table)
	d := XTReadDB().Table("xt_check_configuration as t").Where("t.status = 1")
	pa := XTReadDB().Table("xt_patients as s")
	fmt.Println(pa)
	fmt.Println(d)
	if orgid > 0 {
		db = db.Where("x.org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}

	//if len(ds) > 0 {
	//  for _, d := range ds {
	//    dates = append(dates, d.Date)
	//  }
	//
	//  db = db.Where("o.dialysis_date IN (?)", dates)
	//
	////}

	selectContent := "CASE"
	dates := make([]string, 0)
	for _, item := range patients {
		selectContent = selectContent + " WHEN x.patient_id =" + strconv.FormatInt(item.PatientId, 10) + " THEN " + "'" + item.Name + "'"
		dates = append(dates, strconv.FormatInt(item.PatientId, 10))
	}
	db = db.Where("x.patient_id in(?)", dates)
	err = db.Select(selectContent + "ELSE '未知' END AS name,count(distinct x.inspect_date) as count,x.patient_id,x.project_id,r.project_name,s.name").Joins("left join xt_check_configuration as t on t.inspection_major = x.project_id").Joins("left  join xt_inspection_reference as r on r.project_id = x.project_id").Joins("left join xt_patients as s on s.id = x.patient_id").Group("x.project_id,x.patient_id").Scan(&projectCounts).Error
	//err = db.Select("count(distinct x.inspect_date) as count,x.patient_id,x.project_id,r.project_name,s.name").Joins("left join xt_check_configuration as t on t.inspection_major = x.project_id").Joins("left  join xt_inspection_reference as r on r.project_id = x.project_id").Joins("left join xt_patients as s on s.id = x.patient_id").Group("project_id,patient_id").Scan(&projectCounts).Error
	return
}

func GetPatientDetailCheck(id int64, orgid int64, startime int64, endtime int64) (projectCounts []*models.PatientInspectionProjectCount, err error) {

	db := XTReadDB().Table("xt_inspection as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_inspection_reference as r")
	fmt.Println(table)
	d := XTReadDB().Table("xt_check_configuration as t").Where("t.status = 1")
	pa := XTReadDB().Table("xt_patients as s")
	fmt.Println(pa)
	fmt.Println(d)
	if id > 0 {
		db = db.Where("s.id  = ?", id)
	}
	if orgid > 0 {
		db = db.Where("x.org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}

	err = db.Select("count(distinct x.inspect_date) as count,x.patient_id,x.project_id,r.project_name,s.name").Joins("left join xt_check_configuration as t on t.inspection_major = x.project_id").Joins("left  join xt_inspection_reference as r on r.project_id = x.project_id").Joins("left join xt_patients as s on s.id = x.patient_id").Group("project_id,patient_id").Scan(&projectCounts).Error
	return
}

func GetSearchDetailCheck(orgid int64, keywords string, startime int64, endtime int64) (projectCounts []*models.PatientInspectionProjectCount, err error) {
	db := XTReadDB().Table("xt_inspection as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_inspection_reference as r")
	fmt.Println(table)
	d := XTReadDB().Table("xt_check_configuration as t").Where("t.status = 1")
	pa := XTReadDB().Table("xt_patients as s")
	fmt.Println(pa)
	fmt.Println(d)
	if len(keywords) > 0 {
		likeKey := "%" + keywords + "%"
		db = db.Where("s.name LIKE ? OR s.dialysis_no LIKE ?", likeKey, likeKey)
	}
	if orgid > 0 {
		db = db.Where("x.org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}

	err = db.Select("count(distinct x.inspect_date) as count,x.patient_id,x.project_id,r.project_name,s.name").Joins("left join xt_check_configuration as t on t.inspection_major = x.project_id").Joins("left  join xt_inspection_reference as r on r.project_id = x.project_id").Joins("left join xt_patients as s on s.id = x.patient_id").Group("project_id,patient_id").Scan(&projectCounts).Error
	return
}

func GetNormDataByOrgId(orgid int64) (standard []*models.QualityControlStandard, err error) {

	db := XTReadDB().Table("xt_quality_control_standard as x").Where("x.status =1")
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	table := XTReadDB().Table("xt_inspection_reference as s")
	fmt.Println(table)

	err = db.Order("x.sort asc,x.created_time asc").Group("x.id").Select("x.id,x.inspection_major,x.inspection_minor,x.min_range,x.large_range,x.sort,x.user_org_id,s.unit,s.project_name,s.item_name,x.range_value,x.range_type").
		Joins("left join xt_inspection_reference as s on s.id = x.inspection_minor").Scan(&standard).Error
	return standard, err
}

func GetNormData(orgid int64) (standard []*models.QualityControlStandard, err error) {

	db := XTReadDB().Table("xt_quality_control_standard as x").Where("x.status =1")
	if orgid >= 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	table := XTReadDB().Table("xt_inspection_reference as s")
	fmt.Println(table)

	err = db.Order("x.sort asc,x.created_time asc").Group("x.id").Select("x.id,x.inspection_major,x.inspection_minor,x.min_range,x.large_range,x.sort,x.user_org_id,s.unit,s.project_name,s.item_name").
		Joins("left join xt_inspection_reference as s on s.id = x.inspection_minor").Scan(&standard).Error
	return standard, err
}

func GetItemNameGroup(orgid int64, startime int64, endtime int64) (inspection []*models.XtPatientInspection, err error) {
	db := XTReadDB().Table("xt_inspection as x ").Where("x.status = 1")
	table := XTReadDB().Table("xt_inspection_reference as r")
	fmt.Println(table)
	if orgid > 0 {
		db = db.Where("x.org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	err = db.Group("x.item_id").Select("	count(x.item_id ) AS count,x.id,x.patient_id,x.org_id,x.project_id,x.item_id,x.item_name,x.project_name,x.inspect_type,x.inspect_value,x.inspect_date,r.range_min,r.range_max").Joins("left join xt_inspection_reference as r on r.id = x.item_id").Scan(&inspection).Error
	return inspection, err
}

func GetFirstQuarter(orgid int64, startime int64, endtime int64) (inspection []*models.XtPatientInspection, err error) {

	db := XTReadDB().Table("xt_inspection as x ").Where("x.status = 1")
	table := XTReadDB().Table("xt_inspection_reference as r")
	fmt.Println(table)
	if orgid > 0 {
		db = db.Where("x.org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	err = db.Group("x.item_id").Select("count(x.item_id) as count,x.id,x.patient_id,x.org_id,x.project_id,x.item_id,x.item_name,x.project_name,x.inspect_type,x.inspect_value,x.inspect_date,r.range_min,r.range_max").Where("x.inspect_value+0 >= r.range_min+0 and x.inspect_value+0 <= r.range_max+0").Joins("left join xt_inspection_reference as r on r.id = x.item_id").Scan(&inspection).Error
	return inspection, err
}

func GetQuarterTotalCount(orgid int64, startime int64, endtime int64, lapseto int64) (inspection []*models.VmPatientInspectionTwo, err error) {

	db := XTReadDB().Table("xt_inspection as x ").Where("x.status = 1")
	table := XTReadDB().Table("xt_inspection_reference as r")
	fmt.Println(table)
	d := XTReadDB().Table("xt_patients as s")
	fmt.Println(d)
	q := XTReadDB().Table("x.xt_quality_control_standard as q")
	fmt.Println(q)
	if orgid > 0 {
		db = db.Where("x.org_id = ? and x.inspect_value+0 <> 0 and r.range_type = 1 and q.user_org_id = ?", orgid, orgid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	if lapseto == 0 {
		db = db.Where("s.lapseto = 1 or s.lapseto = 2")
	}
	if lapseto > 0 {
		db = db.Where("s.lapseto = ?", lapseto)
	}
	err = db.Group("x.item_id").Select("sum(case when x.inspect_date >=? and x.inspect_date<=? then 1 else 0 end) as total,sum(case when x.inspect_value+0>=q.min_range+0 and x.inspect_value +0 <= q.large_range+0 and x.inspect_date >=? and x.inspect_date <=? then 1 else 0 end) as count,x.item_id,q.sort", startime, endtime, startime, endtime).Joins("left join xt_inspection_reference as r on ( r.item_id = x.item_id AND r.org_id > 0) OR ( x.item_id = r.id AND r.org_id = 0 ) ").Joins("left join xt_patients as  s on s.id = x.patient_id").Joins("left join xt_quality_control_standard as q on q.inspection_minor = x.item_id").Scan(&inspection).Error
	return inspection, err
}

func GetQuarterTotalCountTwo(orgid int64, startime int64, endtime int64, lapseto int64) (inspection []*models.VmPatientInspectionTwo, err error) {

	db := XTReadDB().Table("xt_inspection as x ").Where("x.status = 1")
	table := XTReadDB().Table("xt_inspection_reference as r")
	fmt.Println(table)
	d := XTReadDB().Table("xt_patients as s")
	fmt.Println(d)
	q := XTReadDB().Table("x.xt_quality_control_standard as q")
	fmt.Println(q)
	if orgid > 0 {
		db = db.Where("x.org_id = ?  and r.range_type = 2 and q.user_org_id = ? and x.inspect_value <>''", orgid, orgid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	if lapseto == 0 {
		db = db.Where("s.lapseto = 1 or s.lapseto = 2")
	}
	if lapseto > 0 {
		db = db.Where("s.lapseto = ?", lapseto)
	}
	err = db.Group("x.item_id").Select("sum(case when x.inspect_date >=? and x.inspect_date<=? then 1 else 0 end) as total,sum(case when q.range_value = x.inspect_value and x.inspect_date >=? and x.inspect_date <=? then 1 else 0 end) as count,x.item_id,q.sort", startime, endtime, startime, endtime).Joins("left join xt_inspection_reference as r on ( r.item_id = x.item_id AND r.org_id > 0) OR ( x.item_id = r.id AND r.org_id = 0 ) ").Joins("left join xt_patients as  s on s.id = x.patient_id").Joins("left join xt_quality_control_standard as q on q.inspection_minor = x.item_id").Scan(&inspection).Error
	return inspection, err
}

func GetProjectList(orgid int64, lapseto int64, modetype int64, startime int64, endtime int64, firststart int64, firstend int64, sencondstart int64, sencondend int64, threestart int64, threeend int64, fourstart int64, fourend int64) (inspection []*models.ProjectCountOne, err error) {

	if lapseto == 0 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1")

		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第一季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第二季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第三季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第四季度'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x  left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 1 or s.lapseto = 2) and x.inspect_value <> 0"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, firststart)
		countParams = append(countParams, firstend)
		countParams = append(countParams, sencondstart)
		countParams = append(countParams, sencondend)
		countParams = append(countParams, threestart)
		countParams = append(countParams, threeend)
		countParams = append(countParams, fourstart)
		countParams = append(countParams, fourend)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)

		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if startime > 0 {
			db = db.Where("x.inspect_date >= ?", startime)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, startime)
		}
		if endtime > 0 {
			db = db.Where("x.inspect_date <= ?", endtime)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, endtime)
		}
		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}

	if lapseto == 1 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1")

		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第一季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第二季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第三季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第四季度'" +
			"ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 1)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, firststart)
		countParams = append(countParams, firstend)
		countParams = append(countParams, sencondstart)
		countParams = append(countParams, sencondend)
		countParams = append(countParams, threestart)
		countParams = append(countParams, threeend)
		countParams = append(countParams, fourstart)
		countParams = append(countParams, fourend)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)

		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}

		if startime > 0 {
			db = db.Where("x.inspect_date >= ?", startime)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, startime)
		}
		if endtime > 0 {
			db = db.Where("x.inspect_date <= ?", endtime)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, endtime)
		}

		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}

	if lapseto == 2 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1")

		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第一季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第二季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第三季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第四季度'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 2)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, firststart)
		countParams = append(countParams, firstend)
		countParams = append(countParams, sencondstart)
		countParams = append(countParams, sencondend)
		countParams = append(countParams, threestart)
		countParams = append(countParams, threeend)
		countParams = append(countParams, fourstart)
		countParams = append(countParams, fourend)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)

		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}

		if startime > 0 {
			db = db.Where("x.inspect_date >= ?", startime)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, startime)
		}
		if endtime > 0 {
			db = db.Where("x.inspect_date <= ?", endtime)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, endtime)
		}

		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error

	}
	return
}

func GetProjectStandList(orgid int64, lapseto int64, modetype int64, startime int64, endtime int64, firststart int64, firstend int64, sencondstart int64, sencondend int64, threestart int64, threeend int64, fourstart int64, fourend int64) (inspection []*models.ProjectCount, err error) {

	if lapseto == 0 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 and x.inspect_value<> ''")
		table := XTReadDB().Table("xt_inspection_reference as r")
		q := XTReadDB().Table("xt_quality_control_standard as r")
		fmt.Println("q", q)
		fmt.Println(table)
		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value+0>=r.min_range+0 and x.inspect_value +0 <= r.large_range+0  THEN '第一季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value+0>=r.min_range+0 and x.inspect_value +0 <=  r.large_range+0 THEN '第二季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value+0>=r.min_range+0 and x.inspect_value +0 <= r.large_range+0 THEN '第三季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value+0>=r.min_range+0 and x.inspect_value +0 <= r.large_range+0 THEN '第四季度'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x  left join xt_quality_control_standard as  r on (r.inspection_minor = x.item_id AND r.user_org_id > 0) OR ( x.item_id = r.inspection_minor AND r.user_org_id = 0) left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 1 or s.lapseto = 2) and (x.inspect_value + 0 >= r.min_range + 0 AND x.inspect_value + 0 <= r.large_range+0)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, firststart)
		countParams = append(countParams, firstend)
		countParams = append(countParams, sencondstart)
		countParams = append(countParams, sencondend)
		countParams = append(countParams, threestart)
		countParams = append(countParams, threeend)
		countParams = append(countParams, fourstart)
		countParams = append(countParams, fourend)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)

		}
		if orgid > 0 {
			db = db.Where("r.user_org_id=?", orgid)
			countSQL += " AND r.user_org_id=?"
			countParams = append(countParams, orgid)

		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if startime > 0 {
			db = db.Where("x.inspect_date >= ? ", startime)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, startime)
		}
		if endtime > 0 {
			db = db.Where("x.inspect_date <= ?", endtime)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, endtime)
		}

		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}

	if lapseto == 1 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 and x.inspect_value<> ''")
		table := XTReadDB().Table("xt_inspection_reference as r")
		q := XTReadDB().Table("xt_quality_control_standard as r")
		fmt.Println("q", q)
		fmt.Println(table)
		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value+0>=r.min_range+0 and x.inspect_value +0 <= r.large_range+0  THEN '第一季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value+0>=r.min_range+0 and x.inspect_value +0 <=  r.large_range+0 THEN '第二季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value+0>=r.min_range+0 and x.inspect_value +0 <= r.large_range+0 THEN '第三季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value+0>=r.min_range+0 and x.inspect_value +0 <= r.large_range+0 THEN '第四季度'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x  left join xt_quality_control_standard as  r on (r.inspection_minor = x.item_id AND r.user_org_id > 0) OR ( x.item_id = r.inspection_minor AND r.user_org_id = 0) left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 2) and (x.inspect_value + 0 >= r.min_range + 0 AND x.inspect_value + 0 <= r.large_range+0)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, firststart)
		countParams = append(countParams, firstend)
		countParams = append(countParams, sencondstart)
		countParams = append(countParams, sencondend)
		countParams = append(countParams, threestart)
		countParams = append(countParams, threeend)
		countParams = append(countParams, fourstart)
		countParams = append(countParams, fourend)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)

		}
		if orgid > 0 {
			db = db.Where("r.user_org_id=?", orgid)
			countSQL += " AND r.user_org_id=?"
			countParams = append(countParams, orgid)

		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if startime > 0 {
			db = db.Where("x.inspect_date >= ? ", startime)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, startime)
		}
		if endtime > 0 {
			db = db.Where("x.inspect_date <= ?", endtime)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, endtime)
		}

		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}
	return
}

func GetProjectStandListOne(orgid int64, lapseto int64, modetype int64, startime int64, endtime int64, firststart int64, firstend int64, sencondstart int64, sencondend int64, threestart int64, threeend int64, fourstart int64, fourend int64) (inspection []*models.ProjectCount, err error) {

	if lapseto == 0 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 x.inspect_type = 2")
		table := XTReadDB().Table("xt_inspection_reference as r")
		q := XTReadDB().Table("xt_quality_control_standard as r")
		fmt.Println("q", q)
		fmt.Println(table)
		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value = r.range_value THEN '第一季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value = r.range_value THEN '第二季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value = r.range_value THEN '第三季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value = r.range_value THEN '第四季度'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x  left join xt_quality_control_standard as  r on (r.inspection_minor = x.item_id AND r.user_org_id > 0) OR ( x.item_id = r.inspection_minor AND r.user_org_id = 0) left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 1 or s.lapseto = 2) and (x.inspect_value = r.range_value) and r.status = 1"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, firststart)
		countParams = append(countParams, firstend)
		countParams = append(countParams, sencondstart)
		countParams = append(countParams, sencondend)
		countParams = append(countParams, threestart)
		countParams = append(countParams, threeend)
		countParams = append(countParams, fourstart)
		countParams = append(countParams, fourend)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)

		}
		if orgid > 0 {
			db = db.Where("r.user_org_id=?", orgid)
			countSQL += " AND r.user_org_id=?"
			countParams = append(countParams, orgid)

		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if startime > 0 {
			db = db.Where("x.inspect_date >= ? ", startime)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, startime)
		}
		if endtime > 0 {
			db = db.Where("x.inspect_date <= ?", endtime)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, endtime)
		}

		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}

	if lapseto == 1 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 x.inspect_type = 2")
		table := XTReadDB().Table("xt_inspection_reference as r")
		q := XTReadDB().Table("xt_quality_control_standard as r")
		fmt.Println("q", q)
		fmt.Println(table)
		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value = r.range_value THEN '第一季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value = r.range_value THEN '第二季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value = r.range_value THEN '第三季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value = r.range_value THEN '第四季度'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x  left join xt_quality_control_standard as  r on (r.inspection_minor = x.item_id AND r.user_org_id > 0) OR ( x.item_id = r.inspection_minor AND r.user_org_id = 0) left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 2) and (x.inspect_value = r.range_value) and r.status = 1"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, firststart)
		countParams = append(countParams, firstend)
		countParams = append(countParams, sencondstart)
		countParams = append(countParams, sencondend)
		countParams = append(countParams, threestart)
		countParams = append(countParams, threeend)
		countParams = append(countParams, fourstart)
		countParams = append(countParams, fourend)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)

		}
		if orgid > 0 {
			db = db.Where("r.user_org_id=?", orgid)
			countSQL += " AND r.user_org_id=?"
			countParams = append(countParams, orgid)

		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if startime > 0 {
			db = db.Where("x.inspect_date >= ? ", startime)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, startime)
		}
		if endtime > 0 {
			db = db.Where("x.inspect_date <= ?", endtime)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, endtime)
		}

		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}
	return
}

func GetMonthProjectList(orgid int64, lapseto int64, modetype int64, januaryStartStrUnix int64, januaryEndStrUnix int64, febStartStrStrUnix int64, febEndStrUnix int64, marchStartStrUnix int64, marchEndStrUnix int64, aprStartStrUnix int64, aprEndStrsUnix int64, mayStartStrUnix int64, mayEndStrsUnix int64, junStartStrUnix int64, junEndStrsUnix int64, julStartStrUnix int64, julEndStrsUnix int64, augStartStrUnix int64, augEndStrsUnix int64, sepStartStrUnix int64, sepEndStrsUnix int64, octStartStrUnix int64, octEndStrsUnix int64, novStartStrUnix int64, novEndStrsUnix int64, decStartStrUnix int64, decEndStrsUnix int64) (inspection []*models.ProjectCountOne, err error) {

	if lapseto == 0 {

		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 and x.inspect_value <> 0 and x.inspect_type = 1")

		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '二月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '三月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '四月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '五月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '六月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '七月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '八月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '九月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十二月'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 1 or s.lapseto = 2)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, januaryStartStrUnix)
		countParams = append(countParams, januaryEndStrUnix)
		countParams = append(countParams, febStartStrStrUnix)
		countParams = append(countParams, febEndStrUnix)
		countParams = append(countParams, marchStartStrUnix)
		countParams = append(countParams, marchEndStrUnix)
		countParams = append(countParams, aprStartStrUnix)
		countParams = append(countParams, aprEndStrsUnix)
		countParams = append(countParams, mayStartStrUnix)
		countParams = append(countParams, mayEndStrsUnix)
		countParams = append(countParams, junStartStrUnix)
		countParams = append(countParams, junEndStrsUnix)
		countParams = append(countParams, julStartStrUnix)
		countParams = append(countParams, julEndStrsUnix)
		countParams = append(countParams, augStartStrUnix)
		countParams = append(countParams, augEndStrsUnix)
		countParams = append(countParams, sepStartStrUnix)
		countParams = append(countParams, sepEndStrsUnix)
		countParams = append(countParams, octStartStrUnix)
		countParams = append(countParams, octEndStrsUnix)
		countParams = append(countParams, novStartStrUnix)
		countParams = append(countParams, novEndStrsUnix)
		countParams = append(countParams, decStartStrUnix)
		countParams = append(countParams, decEndStrsUnix)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)
		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if januaryStartStrUnix > 0 {
			db = db.Where("x.inspect_date >= ?", januaryStartStrUnix)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, januaryStartStrUnix)
		}
		if decEndStrsUnix > 0 {
			db = db.Where("x.inspect_date <= ?", decEndStrsUnix)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, decEndStrsUnix)
		}
		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}

	if lapseto == 1 {

		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 and x.inspect_value <> 0 and x.inspect_type = 1 ")

		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '二月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '三月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '四月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '五月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '六月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '七月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '八月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '九月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十二月'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 1)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, januaryStartStrUnix)
		countParams = append(countParams, januaryEndStrUnix)
		countParams = append(countParams, febStartStrStrUnix)
		countParams = append(countParams, febEndStrUnix)
		countParams = append(countParams, marchStartStrUnix)
		countParams = append(countParams, marchEndStrUnix)
		countParams = append(countParams, aprStartStrUnix)
		countParams = append(countParams, aprEndStrsUnix)
		countParams = append(countParams, mayStartStrUnix)
		countParams = append(countParams, mayEndStrsUnix)
		countParams = append(countParams, junStartStrUnix)
		countParams = append(countParams, junEndStrsUnix)
		countParams = append(countParams, julStartStrUnix)
		countParams = append(countParams, julEndStrsUnix)
		countParams = append(countParams, augStartStrUnix)
		countParams = append(countParams, augEndStrsUnix)
		countParams = append(countParams, sepStartStrUnix)
		countParams = append(countParams, sepEndStrsUnix)
		countParams = append(countParams, octStartStrUnix)
		countParams = append(countParams, octEndStrsUnix)
		countParams = append(countParams, novStartStrUnix)
		countParams = append(countParams, novEndStrsUnix)
		countParams = append(countParams, decStartStrUnix)
		countParams = append(countParams, decEndStrsUnix)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)
		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if januaryStartStrUnix > 0 {
			db = db.Where("x.inspect_date >= ?", januaryStartStrUnix)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, januaryStartStrUnix)
		}
		if decEndStrsUnix > 0 {
			db = db.Where("x.inspect_date <= ?", decEndStrsUnix)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, decEndStrsUnix)
		}
		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}

	if lapseto == 2 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 x.inspect_value <> 0 and x.inspect_type = 1")

		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '二月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '三月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '四月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '五月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '六月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '七月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '八月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '九月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十二月'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 2)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, januaryStartStrUnix)
		countParams = append(countParams, januaryEndStrUnix)
		countParams = append(countParams, febStartStrStrUnix)
		countParams = append(countParams, febEndStrUnix)
		countParams = append(countParams, marchStartStrUnix)
		countParams = append(countParams, marchEndStrUnix)
		countParams = append(countParams, aprStartStrUnix)
		countParams = append(countParams, aprEndStrsUnix)
		countParams = append(countParams, mayStartStrUnix)
		countParams = append(countParams, mayEndStrsUnix)
		countParams = append(countParams, junStartStrUnix)
		countParams = append(countParams, junEndStrsUnix)
		countParams = append(countParams, julStartStrUnix)
		countParams = append(countParams, julEndStrsUnix)
		countParams = append(countParams, augStartStrUnix)
		countParams = append(countParams, augEndStrsUnix)
		countParams = append(countParams, sepStartStrUnix)
		countParams = append(countParams, sepEndStrsUnix)
		countParams = append(countParams, octStartStrUnix)
		countParams = append(countParams, octEndStrsUnix)
		countParams = append(countParams, novStartStrUnix)
		countParams = append(countParams, novEndStrsUnix)
		countParams = append(countParams, decStartStrUnix)
		countParams = append(countParams, decEndStrsUnix)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)
		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if januaryStartStrUnix > 0 {
			db = db.Where("x.inspect_date >= ?", januaryStartStrUnix)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, januaryStartStrUnix)
		}
		if decEndStrsUnix > 0 {
			db = db.Where("x.inspect_date <= ?", decEndStrsUnix)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, decEndStrsUnix)
		}
		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}
	return
}

func GetMonthProjectListOne(orgid int64, lapseto int64, modetype int64, januaryStartStrUnix int64, januaryEndStrUnix int64, febStartStrStrUnix int64, febEndStrUnix int64, marchStartStrUnix int64, marchEndStrUnix int64, aprStartStrUnix int64, aprEndStrsUnix int64, mayStartStrUnix int64, mayEndStrsUnix int64, junStartStrUnix int64, junEndStrsUnix int64, julStartStrUnix int64, julEndStrsUnix int64, augStartStrUnix int64, augEndStrsUnix int64, sepStartStrUnix int64, sepEndStrsUnix int64, octStartStrUnix int64, octEndStrsUnix int64, novStartStrUnix int64, novEndStrsUnix int64, decStartStrUnix int64, decEndStrsUnix int64) (inspection []*models.ProjectCountOne, err error) {

	if lapseto == 0 {

		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 and x.inspect_type = 2")

		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '二月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '三月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '四月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '五月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '六月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '七月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '八月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '九月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十二月'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 1 or s.lapseto = 2)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, januaryStartStrUnix)
		countParams = append(countParams, januaryEndStrUnix)
		countParams = append(countParams, febStartStrStrUnix)
		countParams = append(countParams, febEndStrUnix)
		countParams = append(countParams, marchStartStrUnix)
		countParams = append(countParams, marchEndStrUnix)
		countParams = append(countParams, aprStartStrUnix)
		countParams = append(countParams, aprEndStrsUnix)
		countParams = append(countParams, mayStartStrUnix)
		countParams = append(countParams, mayEndStrsUnix)
		countParams = append(countParams, junStartStrUnix)
		countParams = append(countParams, junEndStrsUnix)
		countParams = append(countParams, julStartStrUnix)
		countParams = append(countParams, julEndStrsUnix)
		countParams = append(countParams, augStartStrUnix)
		countParams = append(countParams, augEndStrsUnix)
		countParams = append(countParams, sepStartStrUnix)
		countParams = append(countParams, sepEndStrsUnix)
		countParams = append(countParams, octStartStrUnix)
		countParams = append(countParams, octEndStrsUnix)
		countParams = append(countParams, novStartStrUnix)
		countParams = append(countParams, novEndStrsUnix)
		countParams = append(countParams, decStartStrUnix)
		countParams = append(countParams, decEndStrsUnix)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)
		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if januaryStartStrUnix > 0 {
			db = db.Where("x.inspect_date >= ?", januaryStartStrUnix)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, januaryStartStrUnix)
		}
		if decEndStrsUnix > 0 {
			db = db.Where("x.inspect_date <= ?", decEndStrsUnix)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, decEndStrsUnix)
		}
		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}

	if lapseto == 1 {

		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1  and and x.inspect_type = 2")

		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '二月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '三月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '四月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '五月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '六月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '七月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '八月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '九月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十二月'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 1)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, januaryStartStrUnix)
		countParams = append(countParams, januaryEndStrUnix)
		countParams = append(countParams, febStartStrStrUnix)
		countParams = append(countParams, febEndStrUnix)
		countParams = append(countParams, marchStartStrUnix)
		countParams = append(countParams, marchEndStrUnix)
		countParams = append(countParams, aprStartStrUnix)
		countParams = append(countParams, aprEndStrsUnix)
		countParams = append(countParams, mayStartStrUnix)
		countParams = append(countParams, mayEndStrsUnix)
		countParams = append(countParams, junStartStrUnix)
		countParams = append(countParams, junEndStrsUnix)
		countParams = append(countParams, julStartStrUnix)
		countParams = append(countParams, julEndStrsUnix)
		countParams = append(countParams, augStartStrUnix)
		countParams = append(countParams, augEndStrsUnix)
		countParams = append(countParams, sepStartStrUnix)
		countParams = append(countParams, sepEndStrsUnix)
		countParams = append(countParams, octStartStrUnix)
		countParams = append(countParams, octEndStrsUnix)
		countParams = append(countParams, novStartStrUnix)
		countParams = append(countParams, novEndStrsUnix)
		countParams = append(countParams, decStartStrUnix)
		countParams = append(countParams, decEndStrsUnix)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)
		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if januaryStartStrUnix > 0 {
			db = db.Where("x.inspect_date >= ?", januaryStartStrUnix)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, januaryStartStrUnix)
		}
		if decEndStrsUnix > 0 {
			db = db.Where("x.inspect_date <= ?", decEndStrsUnix)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, decEndStrsUnix)
		}
		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}

	if lapseto == 2 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 and x.inspect_type = 2")

		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '二月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '三月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '四月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '五月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '六月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '七月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '八月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '九月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '十二月'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 2)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, januaryStartStrUnix)
		countParams = append(countParams, januaryEndStrUnix)
		countParams = append(countParams, febStartStrStrUnix)
		countParams = append(countParams, febEndStrUnix)
		countParams = append(countParams, marchStartStrUnix)
		countParams = append(countParams, marchEndStrUnix)
		countParams = append(countParams, aprStartStrUnix)
		countParams = append(countParams, aprEndStrsUnix)
		countParams = append(countParams, mayStartStrUnix)
		countParams = append(countParams, mayEndStrsUnix)
		countParams = append(countParams, junStartStrUnix)
		countParams = append(countParams, junEndStrsUnix)
		countParams = append(countParams, julStartStrUnix)
		countParams = append(countParams, julEndStrsUnix)
		countParams = append(countParams, augStartStrUnix)
		countParams = append(countParams, augEndStrsUnix)
		countParams = append(countParams, sepStartStrUnix)
		countParams = append(countParams, sepEndStrsUnix)
		countParams = append(countParams, octStartStrUnix)
		countParams = append(countParams, octEndStrsUnix)
		countParams = append(countParams, novStartStrUnix)
		countParams = append(countParams, novEndStrsUnix)
		countParams = append(countParams, decStartStrUnix)
		countParams = append(countParams, decEndStrsUnix)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)
		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if januaryStartStrUnix > 0 {
			db = db.Where("x.inspect_date >= ?", januaryStartStrUnix)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, januaryStartStrUnix)
		}
		if decEndStrsUnix > 0 {
			db = db.Where("x.inspect_date <= ?", decEndStrsUnix)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, decEndStrsUnix)
		}
		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}
	return
}

func GetProjectListOne(orgid int64, lapseto int64, modetype int64, startime int64, endtime int64, firststart int64, firstend int64, sencondstart int64, sencondend int64, threestart int64, threeend int64, fourstart int64, fourend int64) (inspection []*models.ProjectCountOne, err error) {

	if lapseto == 0 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 and x.inspect_type = 2")

		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第一季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第二季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第三季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第四季度'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x  left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 1 or s.lapseto = 2)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, firststart)
		countParams = append(countParams, firstend)
		countParams = append(countParams, sencondstart)
		countParams = append(countParams, sencondend)
		countParams = append(countParams, threestart)
		countParams = append(countParams, threeend)
		countParams = append(countParams, fourstart)
		countParams = append(countParams, fourend)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)

		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if startime > 0 {
			db = db.Where("x.inspect_date >= ?", startime)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, startime)
		}
		if endtime > 0 {
			db = db.Where("x.inspect_date <= ?", endtime)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, endtime)
		}
		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}

	if lapseto == 1 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 and x.inspect_type = 2")

		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第一季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第二季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第三季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第四季度'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x  left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 2)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, firststart)
		countParams = append(countParams, firstend)
		countParams = append(countParams, sencondstart)
		countParams = append(countParams, sencondend)
		countParams = append(countParams, threestart)
		countParams = append(countParams, threeend)
		countParams = append(countParams, fourstart)
		countParams = append(countParams, fourend)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)

		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if startime > 0 {
			db = db.Where("x.inspect_date >= ?", startime)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, startime)
		}
		if endtime > 0 {
			db = db.Where("x.inspect_date <= ?", endtime)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, endtime)
		}
		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}

	if lapseto == 2 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1")

		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第一季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第二季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第三季度'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? THEN '第四季度'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 2)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, firststart)
		countParams = append(countParams, firstend)
		countParams = append(countParams, sencondstart)
		countParams = append(countParams, sencondend)
		countParams = append(countParams, threestart)
		countParams = append(countParams, threeend)
		countParams = append(countParams, fourstart)
		countParams = append(countParams, fourend)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)

		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}

		if startime > 0 {
			db = db.Where("x.inspect_date >= ?", startime)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, startime)
		}
		if endtime > 0 {
			db = db.Where("x.inspect_date <= ?", endtime)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, endtime)
		}

		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error

	}
	return
}

func GetMonthProjectListTwo(orgid int64, lapseto int64, modetype int64, januaryStartStrUnix int64, januaryEndStrUnix int64, febStartStrStrUnix int64, febEndStrUnix int64, marchStartStrUnix int64, marchEndStrUnix int64, aprStartStrUnix int64, aprEndStrsUnix int64, mayStartStrUnix int64, mayEndStrsUnix int64, junStartStrUnix int64, junEndStrsUnix int64, julStartStrUnix int64, julEndStrsUnix int64, augStartStrUnix int64, augEndStrsUnix int64, sepStartStrUnix int64, sepEndStrsUnix int64, octStartStrUnix int64, octEndStrsUnix int64, novStartStrUnix int64, novEndStrsUnix int64, decStartStrUnix int64, decEndStrsUnix int64) (inspection []*models.ProjectCount, err error) {
	if lapseto == 0 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 and x.inspect_type = 1")
		table := XTReadDB().Table("xt_quality_control_standard as r")
		fmt.Println(table)
		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0  THEN '一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0  THEN '二月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '三月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '四月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0  THEN '五月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '六月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '七月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '八月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '九月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '十月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0  THEN '十一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '十二月'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x LEFT JOIN xt_quality_control_standard AS r ON r.inspection_minor = x.item_id left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 1 or s.lapseto = 2) and (x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0 )"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, januaryStartStrUnix)
		countParams = append(countParams, januaryEndStrUnix)
		countParams = append(countParams, febStartStrStrUnix)
		countParams = append(countParams, febEndStrUnix)
		countParams = append(countParams, marchStartStrUnix)
		countParams = append(countParams, marchEndStrUnix)
		countParams = append(countParams, aprStartStrUnix)
		countParams = append(countParams, aprEndStrsUnix)
		countParams = append(countParams, mayStartStrUnix)
		countParams = append(countParams, mayEndStrsUnix)
		countParams = append(countParams, junStartStrUnix)
		countParams = append(countParams, junEndStrsUnix)
		countParams = append(countParams, julStartStrUnix)
		countParams = append(countParams, julEndStrsUnix)
		countParams = append(countParams, augStartStrUnix)
		countParams = append(countParams, augEndStrsUnix)
		countParams = append(countParams, sepStartStrUnix)
		countParams = append(countParams, sepEndStrsUnix)
		countParams = append(countParams, octStartStrUnix)
		countParams = append(countParams, octEndStrsUnix)
		countParams = append(countParams, novStartStrUnix)
		countParams = append(countParams, novEndStrsUnix)
		countParams = append(countParams, decStartStrUnix)
		countParams = append(countParams, decEndStrsUnix)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)
		}
		if orgid > 0 {
			db = db.Where("r.user_org_id=?", orgid)
			countSQL += " AND r.user_org_id=?"
			countParams = append(countParams, orgid)
		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if januaryStartStrUnix > 0 {
			db = db.Where("x.inspect_date >= ?", januaryStartStrUnix)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, januaryStartStrUnix)
		}
		if decEndStrsUnix > 0 {
			db = db.Where("x.inspect_date <= ?", decEndStrsUnix)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, decEndStrsUnix)
		}
		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}

	if lapseto == 1 {

		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 and x.inspect_type = 1")
		table := XTReadDB().Table("xt_quality_control_standard as r")
		fmt.Println(table)
		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0  THEN '一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0  THEN '二月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '三月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '四月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0  THEN '五月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '六月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '七月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '八月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '九月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '十月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0  THEN '十一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '十二月'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x LEFT JOIN xt_quality_control_standard AS r ON r.inspection_minor = x.item_id left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 1) and (x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0 )"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, januaryStartStrUnix)
		countParams = append(countParams, januaryEndStrUnix)
		countParams = append(countParams, febStartStrStrUnix)
		countParams = append(countParams, febEndStrUnix)
		countParams = append(countParams, marchStartStrUnix)
		countParams = append(countParams, marchEndStrUnix)
		countParams = append(countParams, aprStartStrUnix)
		countParams = append(countParams, aprEndStrsUnix)
		countParams = append(countParams, mayStartStrUnix)
		countParams = append(countParams, mayEndStrsUnix)
		countParams = append(countParams, junStartStrUnix)
		countParams = append(countParams, junEndStrsUnix)
		countParams = append(countParams, julStartStrUnix)
		countParams = append(countParams, julEndStrsUnix)
		countParams = append(countParams, augStartStrUnix)
		countParams = append(countParams, augEndStrsUnix)
		countParams = append(countParams, sepStartStrUnix)
		countParams = append(countParams, sepEndStrsUnix)
		countParams = append(countParams, octStartStrUnix)
		countParams = append(countParams, octEndStrsUnix)
		countParams = append(countParams, novStartStrUnix)
		countParams = append(countParams, novEndStrsUnix)
		countParams = append(countParams, decStartStrUnix)
		countParams = append(countParams, decEndStrsUnix)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)
		}
		if orgid > 0 {
			db = db.Where("r.user_org_id=?", orgid)
			countSQL += " AND r.user_org_id=?"
			countParams = append(countParams, orgid)
		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if januaryStartStrUnix > 0 {
			db = db.Where("x.inspect_date >= ?", januaryStartStrUnix)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, januaryStartStrUnix)
		}
		if decEndStrsUnix > 0 {
			db = db.Where("x.inspect_date <= ?", decEndStrsUnix)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, decEndStrsUnix)
		}
		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}

	if lapseto == 2 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 and x.inspect_type = 1")
		table := XTReadDB().Table("xt_quality_control_standard as r")
		fmt.Println(table)
		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0  THEN '一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0  THEN '二月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '三月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '四月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0  THEN '五月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '六月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '七月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '八月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '九月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '十月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0  THEN '十一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0   THEN '十二月'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x LEFT JOIN xt_quality_control_standard AS r ON r.inspection_minor = x.item_id left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 2) and (x.inspect_value +0 >= r.min_range +0 and x.inspect_value +0 <= r.large_range +0 )"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, januaryStartStrUnix)
		countParams = append(countParams, januaryEndStrUnix)
		countParams = append(countParams, febStartStrStrUnix)
		countParams = append(countParams, febEndStrUnix)
		countParams = append(countParams, marchStartStrUnix)
		countParams = append(countParams, marchEndStrUnix)
		countParams = append(countParams, aprStartStrUnix)
		countParams = append(countParams, aprEndStrsUnix)
		countParams = append(countParams, mayStartStrUnix)
		countParams = append(countParams, mayEndStrsUnix)
		countParams = append(countParams, junStartStrUnix)
		countParams = append(countParams, junEndStrsUnix)
		countParams = append(countParams, julStartStrUnix)
		countParams = append(countParams, julEndStrsUnix)
		countParams = append(countParams, augStartStrUnix)
		countParams = append(countParams, augEndStrsUnix)
		countParams = append(countParams, sepStartStrUnix)
		countParams = append(countParams, sepEndStrsUnix)
		countParams = append(countParams, octStartStrUnix)
		countParams = append(countParams, octEndStrsUnix)
		countParams = append(countParams, novStartStrUnix)
		countParams = append(countParams, novEndStrsUnix)
		countParams = append(countParams, decStartStrUnix)
		countParams = append(countParams, decEndStrsUnix)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)
		}
		if orgid > 0 {
			db = db.Where("r.user_org_id=?", orgid)
			countSQL += " AND r.user_org_id=?"
			countParams = append(countParams, orgid)
		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if januaryStartStrUnix > 0 {
			db = db.Where("x.inspect_date >= ?", januaryStartStrUnix)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, januaryStartStrUnix)
		}
		if decEndStrsUnix > 0 {
			db = db.Where("x.inspect_date <= ?", decEndStrsUnix)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, decEndStrsUnix)
		}
		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}
	return
}

func GetMonthProjectListThree(orgid int64, lapseto int64, modetype int64, januaryStartStrUnix int64, januaryEndStrUnix int64, febStartStrStrUnix int64, febEndStrUnix int64, marchStartStrUnix int64, marchEndStrUnix int64, aprStartStrUnix int64, aprEndStrsUnix int64, mayStartStrUnix int64, mayEndStrsUnix int64, junStartStrUnix int64, junEndStrsUnix int64, julStartStrUnix int64, julEndStrsUnix int64, augStartStrUnix int64, augEndStrsUnix int64, sepStartStrUnix int64, sepEndStrsUnix int64, octStartStrUnix int64, octEndStrsUnix int64, novStartStrUnix int64, novEndStrsUnix int64, decStartStrUnix int64, decEndStrsUnix int64) (inspection []*models.ProjectCount, err error) {
	if lapseto == 0 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 and x.inspect_type = 2")
		table := XTReadDB().Table("xt_quality_control_standard as r")
		fmt.Println(table)
		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '二月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '三月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '四月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '五月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '六月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '七月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '八月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '九月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '十月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '十一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '十二月'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x LEFT JOIN xt_quality_control_standard AS r ON r.inspection_minor = x.item_id left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 1 or s.lapseto = 2) and (x.inspect_value = r.range_value)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, januaryStartStrUnix)
		countParams = append(countParams, januaryEndStrUnix)
		countParams = append(countParams, febStartStrStrUnix)
		countParams = append(countParams, febEndStrUnix)
		countParams = append(countParams, marchStartStrUnix)
		countParams = append(countParams, marchEndStrUnix)
		countParams = append(countParams, aprStartStrUnix)
		countParams = append(countParams, aprEndStrsUnix)
		countParams = append(countParams, mayStartStrUnix)
		countParams = append(countParams, mayEndStrsUnix)
		countParams = append(countParams, junStartStrUnix)
		countParams = append(countParams, junEndStrsUnix)
		countParams = append(countParams, julStartStrUnix)
		countParams = append(countParams, julEndStrsUnix)
		countParams = append(countParams, augStartStrUnix)
		countParams = append(countParams, augEndStrsUnix)
		countParams = append(countParams, sepStartStrUnix)
		countParams = append(countParams, sepEndStrsUnix)
		countParams = append(countParams, octStartStrUnix)
		countParams = append(countParams, octEndStrsUnix)
		countParams = append(countParams, novStartStrUnix)
		countParams = append(countParams, novEndStrsUnix)
		countParams = append(countParams, decStartStrUnix)
		countParams = append(countParams, decEndStrsUnix)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)
		}
		if orgid > 0 {
			db = db.Where("r.user_org_id=?", orgid)
			countSQL += " AND r.user_org_id=?"
			countParams = append(countParams, orgid)
		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if januaryStartStrUnix > 0 {
			db = db.Where("x.inspect_date >= ?", januaryStartStrUnix)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, januaryStartStrUnix)
		}
		if decEndStrsUnix > 0 {
			db = db.Where("x.inspect_date <= ?", decEndStrsUnix)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, decEndStrsUnix)
		}
		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}

	if lapseto == 1 {

		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 and x.inspect_type = 2")
		table := XTReadDB().Table("xt_quality_control_standard as r")
		fmt.Println(table)
		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '二月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '三月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '四月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '五月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '六月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '七月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '八月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '九月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '十月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '十一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '十二月'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x LEFT JOIN xt_quality_control_standard AS r ON r.inspection_minor = x.item_id left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 1) and (x.inspect_value = r.range_value)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, januaryStartStrUnix)
		countParams = append(countParams, januaryEndStrUnix)
		countParams = append(countParams, febStartStrStrUnix)
		countParams = append(countParams, febEndStrUnix)
		countParams = append(countParams, marchStartStrUnix)
		countParams = append(countParams, marchEndStrUnix)
		countParams = append(countParams, aprStartStrUnix)
		countParams = append(countParams, aprEndStrsUnix)
		countParams = append(countParams, mayStartStrUnix)
		countParams = append(countParams, mayEndStrsUnix)
		countParams = append(countParams, junStartStrUnix)
		countParams = append(countParams, junEndStrsUnix)
		countParams = append(countParams, julStartStrUnix)
		countParams = append(countParams, julEndStrsUnix)
		countParams = append(countParams, augStartStrUnix)
		countParams = append(countParams, augEndStrsUnix)
		countParams = append(countParams, sepStartStrUnix)
		countParams = append(countParams, sepEndStrsUnix)
		countParams = append(countParams, octStartStrUnix)
		countParams = append(countParams, octEndStrsUnix)
		countParams = append(countParams, novStartStrUnix)
		countParams = append(countParams, novEndStrsUnix)
		countParams = append(countParams, decStartStrUnix)
		countParams = append(countParams, decEndStrsUnix)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)
		}
		if orgid > 0 {
			db = db.Where("r.user_org_id=?", orgid)
			countSQL += " AND r.user_org_id=?"
			countParams = append(countParams, orgid)
		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if januaryStartStrUnix > 0 {
			db = db.Where("x.inspect_date >= ?", januaryStartStrUnix)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, januaryStartStrUnix)
		}
		if decEndStrsUnix > 0 {
			db = db.Where("x.inspect_date <= ?", decEndStrsUnix)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, decEndStrsUnix)
		}
		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}

	if lapseto == 2 {
		d := XTReadDB().Table("xt_patients as s")
		fmt.Println("d", d)
		db := readDb.Table("xt_inspection as x ").Where("x.status=1 and x.inspect_type = 2")
		table := XTReadDB().Table("xt_quality_control_standard as r")
		fmt.Println(table)
		countSQL := "SELECT nnd AS 'total',COUNT(*) AS 'count' FROM(" +
			"SELECT " +
			"CASE " +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '二月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '三月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '四月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '五月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '六月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '七月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '八月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '九月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '十月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '十一月'" +
			" WHEN x.inspect_date>=? AND  x.inspect_date<=? and x.inspect_value = r.range_value  THEN '十二月'" +
			" ELSE '其他'" +
			"END AS nnd FROM xt_inspection as x LEFT JOIN xt_quality_control_standard AS r ON r.inspection_minor = x.item_id left join xt_patients as s on s.id = x.patient_id  WHERE x.status=1 and (s.lapseto = 2) and (x.inspect_value = r.range_value)"
		countParams := make([]interface{}, 0)
		countParams = append(countParams, januaryStartStrUnix)
		countParams = append(countParams, januaryEndStrUnix)
		countParams = append(countParams, febStartStrStrUnix)
		countParams = append(countParams, febEndStrUnix)
		countParams = append(countParams, marchStartStrUnix)
		countParams = append(countParams, marchEndStrUnix)
		countParams = append(countParams, aprStartStrUnix)
		countParams = append(countParams, aprEndStrsUnix)
		countParams = append(countParams, mayStartStrUnix)
		countParams = append(countParams, mayEndStrsUnix)
		countParams = append(countParams, junStartStrUnix)
		countParams = append(countParams, junEndStrsUnix)
		countParams = append(countParams, julStartStrUnix)
		countParams = append(countParams, julEndStrsUnix)
		countParams = append(countParams, augStartStrUnix)
		countParams = append(countParams, augEndStrsUnix)
		countParams = append(countParams, sepStartStrUnix)
		countParams = append(countParams, sepEndStrsUnix)
		countParams = append(countParams, octStartStrUnix)
		countParams = append(countParams, octEndStrsUnix)
		countParams = append(countParams, novStartStrUnix)
		countParams = append(countParams, novEndStrsUnix)
		countParams = append(countParams, decStartStrUnix)
		countParams = append(countParams, decEndStrsUnix)
		if orgid > 0 {
			db = db.Where("x.org_id=?", orgid)
			countSQL += " AND x.org_id=?"
			countParams = append(countParams, orgid)
		}
		if orgid > 0 {
			db = db.Where("r.user_org_id=?", orgid)
			countSQL += " AND r.user_org_id=?"
			countParams = append(countParams, orgid)
		}
		if modetype > 0 {
			db = db.Where("x.item_id = ?", modetype)
			countSQL += " AND x.item_id=?"
			countParams = append(countParams, modetype)
		}
		if januaryStartStrUnix > 0 {
			db = db.Where("x.inspect_date >= ?", januaryStartStrUnix)
			countSQL += " AND x.inspect_date >=?"
			countParams = append(countParams, januaryStartStrUnix)
		}
		if decEndStrsUnix > 0 {
			db = db.Where("x.inspect_date <= ?", decEndStrsUnix)
			countSQL += " AND x.inspect_date <=?"
			countParams = append(countParams, decEndStrsUnix)
		}
		countSQL += ")a GROUP BY nnd"
		err = readDb.Raw(countSQL, countParams...).Scan(&inspection).Error
	}
	return
}

func GetPatientsControl(orgid int64, lapstor int64, startime int64, endtime int64, page int64, limit int64) (inspection []*models.PatientInspectionCount, total int64, err error) {

	db := readDb.Table("xt_inspection as x").Where("x.status =1")
	table := readDb.Table("xt_patients as s")
	fmt.Println(table)
	d := readDb.Table(" xt_inspection_reference as r")
	fmt.Println(d)

	if orgid > 0 {
		db = db.Where("x.org_id = ?", orgid)
	}
	if lapstor == 0 {
		table = table.Where("s.lapseto = 1 or s.lapseto = 2")
	}
	if lapstor == 1 {
		db = db.Where("s.lapseto = 1")
	}
	if lapstor == 2 {
		db = db.Where("s.lapseto = 2")
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	offset := (page - 1) * limit
	err = db.Select("x.id,x.patient_id,s.name,s.dialysis_no,x.inspect_date").Joins("left join xt_patients as s on s.id = x.patient_id").Joins("left join xt_inspection_reference as r on r.item_id = x.item_id AND r.org_id > 0 OR ( x.item_id = r.id AND r.org_id = 0 )").Group("x.inspect_date").Count(&total).Offset(offset).Limit(limit).Scan(&inspection).Error

	return inspection, total, err
}

func GetLastPatientsControl(orgid int64, lapstor int64, startime int64, endtime int64) (inspection []*models.PatientInspectionCount, err error) {

	db := readDb.Table("xt_inspection as x").Where("x.status =1")
	table := readDb.Table("xt_patients as s")
	fmt.Println(table)
	d := readDb.Table(" xt_inspection_reference as r")
	fmt.Println(d)
	d2 := readDb.Table("xt_quality_control_standard as d")
	fmt.Println("d2", d2)
	if orgid > 0 {
		db = db.Where("x.org_id = ? and x.inspect_value+0 <> 0 and x.inspect_type = 1", orgid)
	}
	if lapstor == 0 {
		table = table.Where("s.lapseto = 1 or s.lapseto = 2")
	}

	if lapstor == 1 {
		table = table.Where("s.lapseto = 1")
	}
	if lapstor == 2 {
		table = table.Where("s.lapseto = 2")
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	err = db.Group("x.id").Select("x.id,x.patient_id,x.item_id,x.item_name,x.inspect_value,x.inspect_date,s.name,s.dialysis_no,r.range_max,r.range_min,d.sort,d.min_range,d.large_range,d.range_value,d.range_type").Joins("left join xt_patients as s on s.id = x.patient_id").Joins("left join xt_inspection_reference as r on r.item_id = x.item_id AND r.org_id > 0 OR ( x.item_id = r.id AND r.org_id = 0)").Joins("left join xt_quality_control_standard as d on d.inspection_minor = x.item_id").Order("x.inspect_date desc").Scan(&inspection).Error

	return inspection, err
}

func GetTotalPatientsControl(orgid int64, startime int64, endtime int64) (inspection []*models.PatientInspectionCount, total int64, err error) {
	db := readDb.Table("xt_inspection as x").Where("x.status = 1")
	table := readDb.Table("xt_quality_control_standard as s")
	fmt.Println(table)
	if orgid > 0 {
		db = db.Where("x.org_id = ? and x.inspect_value <> ''", orgid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	err = db.Select("x.id").Joins("RIGHT JOIN xt_quality_control_standard as s on x.project_id = s.inspection_major and x.item_id = s.inspection_minor and x.org_id = s.user_org_id ").Where("s.status = 1").Count(&total).Scan(&inspection).Error
	return inspection, total, err
}
func GetStandControl(orgid int64, startime int64, endtime int64) (inspection []*models.PatientInspectionCount, total int64, err error) {
	db := readDb.Table("xt_inspection as x").Where("x.status = 1")
	table := readDb.Table("xt_quality_control_standard as s")
	fmt.Println(table)
	if orgid > 0 {
		db = db.Where("x.org_id = ? and x.inspect_value+0 <> 0 and x.inspect_type = 1 ", orgid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	db = db.Where("s.status = 1")
	err = db.Select("x.id").Joins("RIGHT JOIN xt_quality_control_standard as s on x.project_id = s.inspection_major and x.item_id = s.inspection_minor and x.org_id = s.user_org_id ").Where("x.inspect_value+0 >= s.min_range + 0 and x.inspect_value+0 <= s.large_range + 0 ").Count(&total).Scan(&inspection).Error
	return inspection, total, err
}

func GetStandControlOne(orgid int64, startime int64, endtime int64) (inspection []*models.PatientInspectionCount, total int64, err error) {
	db := readDb.Table("xt_inspection as x").Where("x.status = 1")
	table := readDb.Table("xt_quality_control_standard as s")
	fmt.Println(table)
	if orgid > 0 {
		db = db.Where("x.org_id = ? and x.inspect_value <> '' and x.inspect_type = 2 ", orgid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	db = db.Where("s.status = 1")
	err = db.Select("x.id").Joins("RIGHT JOIN xt_quality_control_standard as s on x.project_id = s.inspection_major and x.item_id = s.inspection_minor and x.org_id = s.user_org_id ").Where("x.inspect_value = s.range_value").Count(&total).Scan(&inspection).Error
	return inspection, total, err
}

func GetInfectiousPatientsControl(orgid int64, lapstor int64, startime int64, endtime int64) (inspection []*models.PatientInspectionCount, err error) {
	db := readDb.Table("xt_inspection as x").Where("x.status =1")
	table := readDb.Table("xt_patients as s")
	fmt.Println(table)
	d := readDb.Table(" xt_inspection_reference as r")
	fmt.Println(d)
	d2 := readDb.Table("xt_quality_control_standard as d")
	fmt.Println("d2", d2)
	if orgid > 0 {
		db = db.Where("x.org_id = ? and x.inspect_value <> '' and x.inspect_type = 2", orgid)
	}
	if lapstor == 0 {
		table = table.Where("s.lapseto = 1 or s.lapseto = 2")
	}

	if lapstor == 1 {
		table = table.Where("s.lapseto = 1")
	}
	if lapstor == 2 {
		table = table.Where("s.lapseto = 2")
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	err = db.Group("x.id").Select("x.id,x.patient_id,x.item_id,x.item_name,x.inspect_value,x.inspect_date,s.name,s.dialysis_no,r.range_max,r.range_min,d.sort,d.min_range,d.large_range,d.range_value,d.range_type").Joins("left join xt_patients as s on s.id = x.patient_id").Joins("left join xt_inspection_reference as r on r.item_id = x.item_id AND r.org_id > 0 OR ( x.item_id = r.id AND r.org_id = 0)").Joins("left join xt_quality_control_standard as d on d.inspection_minor = x.item_id").Order("x.inspect_date desc").Scan(&inspection).Error

	return inspection, err
}

func GetInfectiousControl(orgid int64, lapstor int64, startime int64, endtime int64) (inspection []*models.PatientInspectionCount, err error) {
	db := readDb.Table("xt_inspection as x").Where("x.status =1")
	table := readDb.Table("xt_patients as s")
	fmt.Println(table)
	d := readDb.Table(" xt_inspection_reference as r")
	fmt.Println(d)
	d2 := readDb.Table("xt_quality_control_standard as d")
	fmt.Println("d2", d2)
	if orgid > 0 {
		db = db.Where("x.org_id = ? and x.inspect_value <> '' and x.inspect_type = 2", orgid)
	}
	if lapstor == 0 {
		table = table.Where("s.lapseto = 1 or s.lapseto = 2")
	}

	if lapstor == 1 {
		table = table.Where("s.lapseto = 1")
	}
	if lapstor == 2 {
		table = table.Where("s.lapseto = 2")
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	err = db.Group("x.id").Select("x.id,x.patient_id,x.item_id,x.item_name,x.inspect_value,x.inspect_date,s.name,s.dialysis_no,r.range_max,r.range_min,d.sort,d.min_range,d.large_range,d.range_value,d.range_type").Joins("left join xt_patients as s on s.id = x.patient_id").Joins("left join xt_inspection_reference as r on r.item_id = x.item_id AND r.org_id > 0 OR ( x.item_id = r.id AND r.org_id = 0)").Joins("left join xt_quality_control_standard as d on d.inspection_minor = x.item_id").Order("x.inspect_date desc").Scan(&inspection).Error

	return inspection, err
}

func GetPatientContor(lapstor, orgid int64, keywords string, startime int64, endtime int64) (inspection []*models.PatientInspectionCount, err error) {

	db := readDb.Table("xt_inspection as x").Where("x.status =1")
	table := readDb.Table("xt_patients as s")
	fmt.Println(table)
	d := readDb.Table(" xt_inspection_reference as r")
	fmt.Println(d)
	d2 := readDb.Table("xt_quality_control_standard as d")
	fmt.Println("d2", d2)

	if len(keywords) > 0 {
		db = db.Where("s.name LIKE ? OR s.dialysis_no LIKE ?", keywords, keywords)
	}

	if orgid > 0 {
		db = db.Where("x.org_id = ?", orgid)
	}
	if lapstor == 0 {
		table = table.Where("s.lapseto = 1 or s.lapseto = 2")
	}

	if lapstor == 1 {
		table = table.Where("s.lapseto = 1")
	}
	if lapstor == 2 {
		table = table.Where("s.lapseto = 2")
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	err = db.Group("x.id").Select("x.id,x.patient_id,x.item_id,x.item_name,x.inspect_value,x.inspect_date,s.name,s.dialysis_no,r.range_max,r.range_min,d.sort").Joins("left join xt_patients as s on s.id = x.patient_id").Joins("left join xt_inspection_reference as r on r.id = x.item_id").Joins("left join xt_quality_control_standard as d on d.inspection_minor = x.item_id").Order("x.inspect_date desc").Scan(&inspection).Error

	return inspection, err
}

func GetPatientNames(orgid int64, patientid int64) (models.XtPatients, error) {
	patients := models.XtPatients{}
	err := readDb.Where("user_org_id = ? and id = ? and status = 1", orgid, patientid).Find(&patients).Error
	return patients, err
}

func GetQualityControlById(orgid int64, patientid int64, startime int64, endtime int64, itemid int64, inspectdate int64) (inspection []*models.PatientInspectionCount, err error) {

	db := readDb.Table("xt_inspection as x").Where("x.status =1")
	table := readDb.Table("xt_patients as s")
	fmt.Println(table)
	d := readDb.Table(" xt_inspection_reference as r")
	fmt.Println(d)
	d2 := readDb.Table("xt_quality_control_standard as d")
	fmt.Println("d2", d2)

	if orgid > 0 {
		db = db.Where("x.org_id = ?", orgid)
	}
	if patientid > 0 {
		db = db.Where("x.patient_id = ?", patientid)
	}

	//if startime > 0 {
	//	db = db.Where("x.inspect_date >=?", startime)
	//}
	//if endtime > 0 {
	//	db = db.Where("x.inspect_date <=?", endtime)
	//}
	if itemid > 0 {
		db = db.Where("x.item_id = ?", itemid)
	}
	if inspectdate > 0 {
		db = db.Where("x.inspect_date = ?", inspectdate)
	}
	err = db.Group("x.id").Select("x.id,x.patient_id,x.item_id,x.item_name,x.inspect_value,x.inspect_date,s.name,s.dialysis_no,r.range_max,r.range_min,d.sort,r.unit,d.range_type").Joins("left join xt_patients as s on s.id = x.patient_id").Joins("left join xt_inspection_reference as r on r.id = x.item_id").Joins("left join xt_quality_control_standard as d on d.inspection_minor = x.item_id").Order("x.inspect_date asc").Scan(&inspection).Error

	return inspection, err
}

func GetPatientComplianceDetail(orgid int64, patientid int64, startime int64, endtime int64, itemid int64) (inspection []*models.PatientInspectionCount, err error) {
	db := readDb.Table("xt_inspection as x").Where("x.status =1")
	table := readDb.Table("xt_patients as s")
	fmt.Println(table)
	d := readDb.Table(" xt_inspection_reference as r")
	fmt.Println(d)
	d2 := readDb.Table("xt_quality_control_standard as d")
	fmt.Println("d2", d2)

	if orgid > 0 {
		db = db.Where("x.org_id = ? and (x.inspect_value <> '' or x.inspect_value+0 <> 0)", orgid)
	}
	if patientid > 0 {
		db = db.Where("x.patient_id = ?", patientid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	if itemid > 0 {
		db = db.Where("x.item_id = ?", itemid)
	}

	err = db.Group("x.id").Select("x.id,x.patient_id,x.item_id,x.item_name,x.inspect_value,x.inspect_date,s.name,s.dialysis_no,r.range_max,r.range_min,d.sort,r.unit,d.range_value,d.range_type").Joins("left join xt_patients as s on s.id = x.patient_id").Joins("left join xt_inspection_reference as r on r.id = x.item_id").Joins("left join xt_quality_control_standard as d on d.inspection_minor = x.item_id").Order("x.inspect_date asc").Scan(&inspection).Error

	return inspection, err
}

func GetLastPatientsControlTwo(orgid int64, patientid int64, startime int64, endtime int64) (inspection []*models.PatientInspectionCount, err error) {

	db := readDb.Table("xt_inspection as x").Where("x.status =1")
	table := readDb.Table("xt_patients as s")
	fmt.Println(table)
	d := readDb.Table(" xt_inspection_reference as r")
	fmt.Println(d)
	d2 := readDb.Table("xt_quality_control_standard as d")
	fmt.Println("d2", d2)
	if orgid > 0 {
		db = db.Where("x.org_id = ?", orgid)
	}
	if patientid > 0 {
		db = db.Where("x.patient_id = ?", patientid)
	}
	if startime > 0 {
		db = db.Where("x.inspect_date >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.inspect_date <=?", endtime)
	}
	err = db.Group("x.id").Select("x.id,x.patient_id,x.item_id,x.item_name,x.inspect_value,x.inspect_date,s.name,s.dialysis_no,r.range_max,r.range_min,d.sort,d.large_range,d.min_range,d.range_type").Joins("left join xt_patients as s on s.id = x.patient_id").Joins("left join xt_inspection_reference as r on r.id = x.item_id").Joins("left join xt_quality_control_standard as d on d.inspection_minor = x.item_id").Order("x.inspect_date desc").Scan(&inspection).Error

	return inspection, err
}