XT_New/service/common_service.go

package service

import (
	"fmt"
	"strconv"
	"time"

	"XT_New/models"
	"github.com/jinzhu/gorm"
)

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 = ? and x.is_status = 1", 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,x.is_status").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 GetDefaultBloodPressure(orgid int64) (standard []*models.XtQualityControlStandard, err error) {
	err = XTReadDB().Model(&standard).Where("user_org_id = ? and status = 1 and is_status = 0", orgid).Find(&standard).Error
	return standard, 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 = ? and x.is_status =1", 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,x.is_status").
		Joins("left join xt_inspection_reference as s on s.item_id = x.inspection_minor and s.project_id = x.inspection_major").Where("s.org_id = ? and s.status = 1", orgid).Count(&total).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 GetAllChekcListTwo(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 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").Where("r.org_id = ? and r.status = 1", orgid).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,lapsetotype int64,sourcetype 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 GetDialysiTotal(startime int64, endtime int64, orgid int64, lapsetotype int64, sourcetype int64) (models.PatientPrescriptionCountStruct, error) {
	counts := models.PatientPrescriptionCountStruct{}

	db := XTReadDB().Table("xt_dialysis_order as x").Select("count(x.id) as count").Joins("Join xt_dialysis_prescription as prescription On x.dialysis_date = prescription.record_date AND x.patient_id = prescription.patient_id  AND prescription.status = 1 AND prescription.mode_id > 0").Where("x.dialysis_date >= ? and x.dialysis_date<=? and x.user_org_id = ? AND x.status = 1", startime, endtime, orgid)

	if lapsetotype > 0 {
		err = db.Where("x.user_org_id = ? and s.lapseto = ?", startime, endtime, orgid, lapsetotype).Joins("left join xt_patients as s on s.id= x.patient_id").Scan(&counts).Error
	}
	if lapsetotype == 0 {
		err = db.Joins("left join xt_patients as s on s.id= x.patient_id").Scan(&counts).Error
	}

	if sourcetype > 0 {
		err = db.Where("x.user_org_id = ? and s.source = ?", startime, endtime, orgid, sourcetype).Joins("left join xt_patients as s on s.id= x.patient_id").Scan(&counts).Error
	}

	if sourcetype == 0 {
		err = db.Joins("left join xt_patients as s on s.id= x.patient_id").Scan(&counts).Error
	}

	return counts, err
}

func GetDialysisCountMode(starttime int64, endtime int64, orgid int64, lapsetotype int64, sourcetype int64) (counts []*models.PatientPrescriptionCountStruct, err error) {
	db := readDb.Table("xt_dialysis_order as o").Where("o.status = 1")
	if starttime > 0 {
		db = db.Where("o.dialysis_date >=?", starttime)
	}
	if endtime > 0 {
		db = db.Where("o.dialysis_date<=?", endtime)
	}
	if orgid > 0 {
		db = db.Where("o.user_org_id = ?", orgid)
	}
	if lapsetotype > 0 {
		db = db.Where("p.lapseto = ?", lapsetotype)
	}
	if sourcetype > 0 {
		db = db.Where("p.source = ?", sourcetype)
	}
	err = db.Select("s.mode_id,count(s.mode_id) as count").Joins("join xt_dialysis_prescription as s on s.patient_id = o.patient_id and s.record_date = o.dialysis_date and s.status= 1 AND s.record_date >= ? AND s.record_date <= ? AND  s.mode_id > 0 ", starttime, endtime).Joins("left join xt_patients as  p on o.patient_id = p.id").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, lapsetotype int64, sourcetype int64) (patients []*models.XtPatients, err error) {

	db := XTReadDB().Table("xt_patients as x")

	if sourcetype == 0 {
		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
	}
	if sourcetype > 0 {
		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 and x.source = ?", startime, endtime, orgid, sourcetype).Scan(&patients).Error
	}
	return patients, err
}

func GetTotalRollOutPatientsTwo(orgid int64, startime int64, endtime int64, lapsetotype int64, sourcetype int64) (patients []*models.XtPatients, err error) {
	db := XTReadDB().Table("xt_patients as x")
	if sourcetype == 0 {

		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

	}
	if sourcetype > 0 {

		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 and x.source = ?", startime, endtime, orgid, sourcetype).Scan(&patients).Error
	}
	return patients, err
}

func GetPatientTotalCount(orgID int64, lapsetotype int64, sourcetype int64) (total int64) {
	db := readDb.Table("xt_patients as x")
	//if lapsetotype > 0 {
	// db = db.Where("x.lapseto = ?", lapsetotype)
	//}
	//if sourcetype > 0 {
	// db = db.Where("x.source = ?", sourcetype)
	//}
	db.Where("x.user_org_id=? and x.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, lapsetotype int64, sourcetype int64) (patients []*models.XtPatients, total int64, err error) {

	db := XTReadDB().Table("xt_patients as x").Where("x.status  = 1")
	if lapsetotype > 0 {
		db = db.Where("x.lapseto = ?", lapsetotype)
	}
	if sourcetype > 0 {
		db = db.Where("x.source = ?", sourcetype)
	}
	err = db.Where("x.user_org_id = ? and x.status = 1 and x.gender = 1", orgid).Count(&total).Find(&patients).Error
	return patients, total, err
}

func GetWoManPatientTotal(orgid int64, lapsetotype int64, sourcetype int64) (patients []*models.XtPatients, total int64, err error) {
	db := XTReadDB().Table("xt_patients as x").Where("x.status  = 1")
	if lapsetotype > 0 {
		db = db.Where("x.lapseto = ?", lapsetotype)
	}
	if sourcetype > 0 {
		db = db.Where("x.source = ?", sourcetype)
	}
	err = db.Where("x.user_org_id = ? and x.status = 1 and x.gender = 2", 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, lapsetotype int64, sourcetype int64) (counts []*models.PatientContagionsCountStruct, err error) {

	if lapsetotype == 0 {
		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
	}
	if sourcetype == 0 {
		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
	}

	if lapsetotype > 0 {
		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<=? and s.lapseto = ?", orgid, startime, endtime, lapsetotype).Select("x.disease_id,count(x.disease_id) as count").Group("x.disease_id").Scan(&counts).Error
	}

	if sourcetype > 0 {
		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<=? and s.source = ?", orgid, startime, endtime, sourcetype).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, lapsetotype int64, sourcetype int64) (counts []*models.PatientAgeCountStruct, err error) {

	if lapsetotype == 0 || sourcetype == 0 {
		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)

	}

	if lapsetotype > 0 {
		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 and s.lapseto = ?
	 )a GROUP BY nnd`, orgid, lapsetotype).Scan(&counts)

	}

	if sourcetype > 0 {
		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 and s.source = ?
	 )a GROUP BY nnd`, orgid, sourcetype).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, lapsetotype int64, sourcetype int64) (counts []*models.DialysisAgePieDataStruct, err error) {

	if lapsetotype == 0 || sourcetype == 0 {
		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)
	}

	if lapsetotype > 0 {
		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 and p.lapseto = ?)a GROUP BY nnd`, orgID, lapsetotype).Scan(&counts)
	}

	if sourcetype > 0 {
		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 and p.source = ?)a GROUP BY nnd`, orgID, sourcetype).Scan(&counts)
	}

	return
}

func GetCurentOrgPatients(orgid int64) (patients []*models.BloodXtPatients, 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")

	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("join xt_dialysis_prescription as s on s.patient_id = o.patient_id AND s.record_date = o.dialysis_date AND s.mode_id > 0").Joins("join  xt_patients as p on p.id = o.patient_id").Where("s.status = 1").Count(&total).Offset(offset).Limit(limit).Scan(&order).Error
	return order, total, err

}

func GetDialysisScheduleList(startime int64, endtime int64, page int64, limit int64, orgid int64) (order []*models.BloodDialysisOrderSchedule, err error) {

	db := XTReadDB().Table("xt_schedule as o").Where("o.status = 1")

	if orgid > 0 {
		db = db.Where("o.user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("o.schedule_date>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("o.schedule_date<=?", endtime)
	}
	err = db.Group("o.patient_id,o.mode_id").Select("o.mode_id,o.patient_id,p.name,p.id_card_no,p.dialysis_no,p.total_dialysis,p.user_sys_before_count").Joins("join  xt_patients as p on p.id = o.patient_id").Where("o.status = 1").Scan(&order).Error
	return order, err
}

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

	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("join xt_dialysis_prescription as s on s.patient_id = o.patient_id AND s.record_date = o.dialysis_date AND s.mode_id > 0").Joins("join xt_patients as p on p.id = o.patient_id").Where("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) {

	db := XTReadDB().Table("xt_dialysis_order as o").Where("o.status = 1")
	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("join xt_dialysis_prescription as s on s.patient_id = o.patient_id AND s.record_date = o.dialysis_date AND s.mode_id > 0 AND s.status =1").Joins("join  xt_patients as p on p.id = o.patient_id").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 and is_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")
	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)
	}
	err = db.Group("o.dialysis_date").Select(sql).Joins("join xt_dialysis_prescription as s on s.patient_id = o.patient_id AND s.record_date = o.dialysis_date AND s.mode_id > 0").Joins("left join xt_patients as p on p.id = o.patient_id").Where("s.record_date = o.dialysis_date and s.status =1").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 ")
	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("join xt_dialysis_prescription as s on s.patient_id = o.patient_id and s.record_date = o.dialysis_date and s.mode_id > 0").Joins("left join xt_patients as p on p.id = o.patient_id").Where("s.record_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("join xt_dialysis_prescription as s on o.patient_id = s.patient_id AND o.dialysis_date = s.record_date AND s.mode_id > 0")
	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").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")
	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 = ? and x.is_status = 1", 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,x.is_status").
		Joins("left join xt_inspection_reference as s on (s.item_id = x.inspection_minor AND s.org_id > 0) OR (s.id = x.inspection_minor AND s.org_id = 0)").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 = ? and x.is_status = 1", 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.item_id = x.inspection_minor AND s.org_id > 0) OR (s.id = x.inspection_minor AND s.org_id = 0)").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, origin int64) (inspection []*models.VmPatientInspectionTwo, err error) {

	db := XTReadDB().Table("xt_inspection as x ").Where("x.status = 1")
	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 = ? and q.is_status = 1", 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 && origin > 0 {
		db = db.Joins("inner join xt_patients as p on p.id = x.patient_id AND p.lapseto = ? AND p.source = ?", lapseto, origin)
	}
	if lapseto > 0 && origin == 0 {
		db = db.Joins("inner join xt_patients as p on p.id = x.patient_id AND p.lapseto = ?", lapseto)
	}

	if lapseto == 0 && origin > 0 {
		db = db.Joins("inner join xt_patients as p on p.id = x.patient_id AND p.source = ?", origin)
	}
	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_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, origin int64) (inspection []*models.VmPatientInspectionTwo, err error) {
	db := XTReadDB().Table("xt_inspection as x ").Where("x.status = 1")
	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 q.is_status = 1 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 && origin > 0 {
		db = db.Joins("inner join xt_patients as p on p.id = x.patient_id AND p.lapseto = ? AND p.source = ?", lapseto, origin)
	}
	if lapseto > 0 && origin == 0 {
		db = db.Joins("inner join xt_patients as p on p.id = x.patient_id AND p.lapseto = ?", lapseto)
	}

	if lapseto == 0 && origin > 0 {
		db = db.Joins("inner join xt_patients as p on p.id = x.patient_id AND p.source = ?", origin)
	}
	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_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 = ? and x.inspect_value <> ''", 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_quality_control_standard as r on x.item_id = r.inspection_minor ").Where("r.user_org_id = ? and r.status = 1 and r.is_status = 1", orgid).Group("x.patient_id").Count(&total).Offset(offset).Limit(limit).Scan(&inspection).Error

	return inspection, total, err
}

//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").Where("d.min_range<>''and d.user_org_id = ? and d.is_status =1 and NOT EXISTS(SELECT 1 FROM xt_inspection AS x2 WHERE x2.patient_id = x.patient_id AND x2.org_id = ? AND x2.item_id = x.item_id AND x2.inspect_date > x.inspect_date)", orgid, orgid).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 and s.is_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 and s.is_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 and s.is_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").Where("d.range_value <>''and d.user_org_id = ? and d.is_status = 1", orgid).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
}

func GetBloodPressureDetail(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 UpdateBloodPressure(st *models.XtQualityControlStandard, id int64) error {

	err := XTWriteDB().Model(&st).Where("id=?", id).Update(map[string]interface{}{"inspection_major": st.InspectionMajor, "inspection_minor": st.InspectionMinor, "min_range": st.MinRange, "large_range": st.LargeRange, "sort": st.Sort, "updated_time": st.UpdatedTime}).Error
	return err

}

func GetSystolicBloodPressure(orgid int64, startime int64, endtime int64) (record []*models.VmMonitoringRecord, total int64, err error) {

	db := XTReadDB().Table("xt_monitoring_record as x")
	err = db.Select("x.id,x.systolic_blood_pressure").Where("x.user_org_id = ? and x.monitoring_date >=? and x.monitoring_date<=? and x.status = 1 and x.systolic_blood_pressure <> 0", orgid, startime, endtime).Group("x.monitoring_date,x.patient_id").Count(&total).Scan(&record).Error
	return record, total, err
}

func GetSystolicBloodPressureTwo(orgid int64, startime int64, endtime int64, lapseto int64, origin int64) (record []*models.VmMonitoringRecord, total int64, err error) {

	db := XTReadDB().Table("xt_monitoring_record as x")
	if lapseto > 0 && origin > 0 {
		db = db.Joins("inner join xt_patients as p on p.id = x.patient_id AND p.lapseto = ? AND p.source = ?", lapseto, origin)
	}
	if lapseto > 0 && origin == 0 {
		db = db.Joins("inner join xt_patients as p on p.id = x.patient_id AND p.lapseto = ?", lapseto)
	}

	if lapseto == 0 && origin > 0 {
		db = db.Joins("inner join xt_patients as p on p.id = x.patient_id AND p.source = ?", origin)
	}
	err = db.Select("x.id,x.systolic_blood_pressure").Where("x.user_org_id = ? and x.monitoring_date >=? and x.monitoring_date<=? and x.status = 1 and x.systolic_blood_pressure <> 0", orgid, startime, endtime).Group("x.monitoring_date,x.patient_id").Count(&total).Scan(&record).Error
	return record, total, err
}

func GetStandSystolicBloodPressure(orgid int64, startime int64, endtime int64, lapseto int64, origin int64) (record []*models.XTMonitoringRecord, total int64, err error) {

	db := XTReadDB().Table("xt_monitoring_record as x").Where("x.status = 1")
	err = db.Select("x.id,s.sort").Joins("left join xt_quality_control_standard as s on s.user_org_id = x.user_org_id").Where("s.status = 1 and s.is_status = 0 and s.user_org_id = ? and x.user_org_id =? and x.monitoring_date>=? and x.monitoring_date <=? and s.inspection_minor = -1 and s.inspection_major = 0 and x.systolic_blood_pressure <> 0 and x.systolic_blood_pressure +0 >= s.min_range +0 and x.systolic_blood_pressure +0 <= s.large_range +0", orgid, orgid, startime, endtime).Group("x.monitoring_date,x.patient_id").Count(&total).Scan(&record).Error
	return record, total, err
}

func GetDiastolicBloodPressure(orgid int64, startime int64, endtime int64) (record []*models.VmMonitoringRecord, total int64, err error) {

	db := XTReadDB().Table("xt_monitoring_record as x")
	err = db.Select("x.id,x.diastolic_blood_pressure").Where("x.user_org_id = ? and x.monitoring_date >=? and x.monitoring_date<=? and x.status = 1 and x.diastolic_blood_pressure <> 0", orgid, startime, endtime).Group("x.monitoring_date,x.patient_id").Count(&total).Scan(&record).Error
	return record, total, err
}

func GetDiastolicBloodPressureTwo(orgid int64, startime int64, endtime int64, lapseto int64, origin int64) (record []*models.VmMonitoringRecord, total int64, err error) {
	db := XTReadDB().Table("xt_monitoring_record as x")
	if lapseto > 0 && origin > 0 {
		db = db.Joins("inner join xt_patients as p on p.id = x.patient_id AND p.lapseto = ? AND p.source = ?", lapseto, origin)
	}
	if lapseto > 0 && origin == 0 {
		db = db.Joins("inner join xt_patients as p on p.id = x.patient_id AND p.lapseto = ?", lapseto)
	}

	if lapseto == 0 && origin > 0 {
		db = db.Joins("inner join xt_patients as p on p.id = x.patient_id AND p.source = ?", origin)
	}
	err = db.Select("x.id,x.diastolic_blood_pressure").Where("x.user_org_id = ? and x.monitoring_date >=? and x.monitoring_date<=? and x.status = 1 and x.diastolic_blood_pressure <> 0", orgid, startime, endtime).Group("x.monitoring_date,x.patient_id").Count(&total).Scan(&record).Error
	return record, total, err
}

func GetDiastolicStandPressure(orgid int64, startime int64, endtime int64) (record []*models.XTMonitoringRecord, total int64, err error) {
	db := XTReadDB().Table("xt_monitoring_record as x").Where("x.status = 1")
	err = db.Select("x.id,s.sort").Joins("left join xt_quality_control_standard as s on s.user_org_id = x.user_org_id").Where("s.status = 1 and s.is_status = 0 and s.user_org_id = ? and x.user_org_id =? and x.monitoring_date>=? and x.monitoring_date <=? and s.inspection_minor = -2 and s.inspection_major = 0 and x.diastolic_blood_pressure <> 0 and x.diastolic_blood_pressure +0 >= s.min_range +0 and x.diastolic_blood_pressure +0 <= s.large_range +0", orgid, orgid, startime, endtime).Group("x.monitoring_date,x.patient_id").Count(&total).Scan(&record).Error
	return record, total, err
}

func GetQuarterTargeStand(orgid int64, firststart int64, firstend int64, sencondstart int64, sencondend int64, threestart int64, threeend int64, fourstart int64, fourend int64) (inspection []*models.ProjectCountTwo, err error) {

	db := readDb.Table("xt_inspection as x ").Where("x.status=1")
	countSQL := "SELECT nnd AS 'name',COUNT(*) AS 'count' FROM(" +
		"SELECT " +
		"CASE " +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '1'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '2'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '3'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '4'" +
		" ELSE '其他'" +
		"END AS nnd FROM xt_inspection as x 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<>0 and x.status = 1  and x.inspect_type = 1 and s.is_status = 1 and s.status = 1 and x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.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)

		db = db.Where("x.inspect_date>=?", firststart)
		countSQL += " AND x.inspect_date>=?"
		countParams = append(countParams, firststart)

		db = db.Where("x.inspect_date<=?", fourend)
		countSQL += " AND x.inspect_date<=?"
		countParams = append(countParams, fourend)

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

func GetQuarterTargeNoStand(orgid int64, firststart int64, firstend int64, sencondstart int64, sencondend int64, threestart int64, threeend int64, fourstart int64, fourend int64) (inspection []*models.ProjectCountTwo, err error) {

	db := readDb.Table("xt_inspection as x ").Where("x.status=1")
	countSQL := "SELECT nnd AS 'name',COUNT(*) AS 'count' FROM(" +
		"SELECT " +
		"CASE " +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '1'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '2'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '3'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '4'" +
		" ELSE '其他'" +
		"END AS nnd FROM xt_inspection as x 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<>0 and x.status = 1  and x.inspect_type = 1 and s.is_status = 1 and s.status = 1 and (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.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)

		db = db.Where("x.inspect_date>=?", firststart)
		countSQL += " AND x.inspect_date>=?"
		countParams = append(countParams, firststart)

		db = db.Where("x.inspect_date<=?", fourend)
		countSQL += " AND x.inspect_date<=?"
		countParams = append(countParams, fourend)

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

func GetContagionQuarterTargeStand(orgid int64, firststart int64, firstend int64, sencondstart int64, sencondend int64, threestart int64, threeend int64, fourstart int64, fourend int64) (inspection []*models.ProjectCountTwo, err error) {

	db := readDb.Table("xt_inspection as x ").Where("x.status=1")
	countSQL := "SELECT nnd AS 'name',COUNT(*) AS 'count' FROM(" +
		"SELECT " +
		"CASE " +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value = s.range_value THEN '1'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value = s.range_value  THEN '2'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value = s.range_value THEN '3'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value = s.range_value THEN '4'" +
		" ELSE '其他'" +
		"END AS nnd FROM xt_inspection as x 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<>'' and x.status = 1  and x.inspect_type = 2 and s.is_status = 1 and s.status = 1 and  x.inspect_value = s.range_value"
	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)

		db = db.Where("x.inspect_date>=?", firststart)
		countSQL += " AND x.inspect_date>=?"
		countParams = append(countParams, firststart)

		db = db.Where("x.inspect_date<=?", fourend)
		countSQL += " AND x.inspect_date<=?"
		countParams = append(countParams, fourend)

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

func GetContagionTargeNoStand(orgid int64, firststart int64, firstend int64, sencondstart int64, sencondend int64, threestart int64, threeend int64, fourstart int64, fourend int64) (inspection []*models.ProjectCountTwo, err error) {

	db := readDb.Table("xt_inspection as x ").Where("x.status=1")
	countSQL := "SELECT nnd AS 'name',COUNT(*) AS 'count' FROM(" +
		"SELECT " +
		"CASE " +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value <> s.range_value THEN '1'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value <> s.range_value  THEN '2'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value <> s.range_value THEN '3'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND x.inspect_value <> s.range_value THEN '4'" +
		" ELSE '其他'" +
		"END AS nnd FROM xt_inspection as x 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<>'' and x.status = 1  and x.inspect_type = 2 and s.is_status = 1 and s.status = 1 and  x.inspect_value <> s.range_value"
	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)

		db = db.Where("x.inspect_date>=?", firststart)
		countSQL += " AND x.inspect_date>=?"
		countParams = append(countParams, firststart)

		db = db.Where("x.inspect_date<=?", fourend)
		countSQL += " AND x.inspect_date<=?"
		countParams = append(countParams, fourend)

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

func GetMonthTargetStand(orgId, 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.ProjectCountTwo, err error) {

	db := readDb.Table("xt_inspection as x ").Where("x.status=1")
	countSQL := "SELECT nnd AS 'name',COUNT(*) AS 'count' FROM(" +
		"SELECT " +
		"CASE " +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '1'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '2'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '3'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '4'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '5'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '6'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '7'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '8'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '9'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '10'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '11'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.large_range + 0 THEN '12'" +
		" ELSE '其他'" +
		"END AS nnd FROM xt_inspection as x 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<>0 and x.status = 1  and x.inspect_type = 1 and s.is_status = 1 and s.status = 1 and x.inspect_value + 0 >= s.min_range + 0 AND x.inspect_value + 0 <= s.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)

		db = db.Where("x.inspect_date>=?", januaryStartStrUnix)
		countSQL += " AND x.inspect_date>=?"
		countParams = append(countParams, januaryStartStrUnix)

		db = db.Where("x.inspect_date<=?", decStartStrUnix)
		countSQL += " AND x.inspect_date<=?"
		countParams = append(countParams, decEndStrsUnix)

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

func GetMonthTargetNoStand(orgId, 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.ProjectCountTwo, err error) {

	db := readDb.Table("xt_inspection as x ").Where("x.status=1")
	countSQL := "SELECT nnd AS 'name',COUNT(*) AS 'count' FROM(" +
		"SELECT " +
		"CASE " +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '1'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '2'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '3'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '4'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '5'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '6'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '7'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '8'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '9'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '10'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '11'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.large_range + 0) THEN '12'" +
		" ELSE '其他'" +
		"END AS nnd FROM xt_inspection as x 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<>0 and x.status = 1  and x.inspect_type = 1 and s.is_status = 1 and s.status = 1 and  (x.inspect_value + 0 < s.min_range + 0 or x.inspect_value + 0 > s.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)

		db = db.Where("x.inspect_date>=?", januaryStartStrUnix)
		countSQL += " AND x.inspect_date>=?"
		countParams = append(countParams, januaryStartStrUnix)

		db = db.Where("x.inspect_date<=?", decStartStrUnix)
		countSQL += " AND x.inspect_date<=?"
		countParams = append(countParams, decEndStrsUnix)

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

func GetMonthcontagionTargeStand(orgId, 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.ProjectCountTwo, err error) {

	db := readDb.Table("xt_inspection as x ").Where("x.status=1")
	countSQL := "SELECT nnd AS 'name',COUNT(*) AS 'count' FROM(" +
		"SELECT " +
		"CASE " +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value = s.range_value THEN '1'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value = s.range_value THEN '2'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value = s.range_value THEN '3'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value = s.range_value THEN '4'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value = s.range_value THEN '5'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value = s.range_value THEN '6'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value = s.range_value THEN '7'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value = s.range_value THEN '8'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value = s.range_value THEN '9'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value = s.range_value THEN '10'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value = s.range_value THEN '11'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value = s.range_value THEN '12'" +
		" ELSE '其他'" +
		"END AS nnd FROM xt_inspection as x 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<>'' and x.status = 1  and x.inspect_type = 2 and s.is_status = 1 and s.status = 1 and  x.inspect_value = s.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)

		db = db.Where("x.inspect_date>=?", januaryStartStrUnix)
		countSQL += " AND x.inspect_date>=?"
		countParams = append(countParams, januaryStartStrUnix)

		db = db.Where("x.inspect_date<=?", decStartStrUnix)
		countSQL += " AND x.inspect_date<=?"
		countParams = append(countParams, decEndStrsUnix)

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

func GetMonthcontagionTargeNoStand(orgId, 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.ProjectCountTwo, err error) {

	db := readDb.Table("xt_inspection as x ").Where("x.status=1")
	countSQL := "SELECT nnd AS 'name',COUNT(*) AS 'count' FROM(" +
		"SELECT " +
		"CASE " +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value <> s.range_value THEN '1'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value <> s.range_value THEN '2'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value <> s.range_value THEN '3'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value <> s.range_value THEN '4'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value <> s.range_value THEN '5'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value <> s.range_value THEN '6'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value <> s.range_value THEN '7'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value <> s.range_value THEN '8'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value <> s.range_value THEN '9'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value <> s.range_value THEN '10'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value <> s.range_value THEN '11'" +
		" WHEN x.inspect_date>=? AND  x.inspect_date<=? AND  x.inspect_value <> s.range_value THEN '12'" +
		" ELSE '其他'" +
		"END AS nnd FROM xt_inspection as x 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<>'' and x.status = 1  and x.inspect_type = 2 and s.is_status = 1 and s.status = 1 and  x.inspect_value <> s.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)

		db = db.Where("x.inspect_date>=?", januaryStartStrUnix)
		countSQL += " AND x.inspect_date>=?"
		countParams = append(countParams, januaryStartStrUnix)

		db = db.Where("x.inspect_date<=?", decStartStrUnix)
		countSQL += " AND x.inspect_date<=?"
		countParams = append(countParams, decEndStrsUnix)

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

func GetQuarterBloodList(orgid int64, januaryStartStrUnix int64, januaryEndStrUnix int64) (record []*models.VmMonitoringRecord, err error) {

	db := XTReadDB().Table("xt_monitoring_record as x")
	err = db.Select("x.id,x.systolic_blood_pressure,x.diastolic_blood_pressure,x.monitoring_date,x.patient_id,x.user_org_id").Where("x.user_org_id = ? and x.monitoring_date >=? and x.monitoring_date<=? and x.status = 1 and x.systolic_blood_pressure <> 0 and x.diastolic_blood_pressure <> 0", orgid, januaryStartStrUnix, januaryEndStrUnix).Group("x.monitoring_date,x.patient_id").Scan(&record).Error
	return record, err
}

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

	db := XTReadDB().Table("xt_inspection as x")
	err = db.Select("x.id,x.patient_id,x.item_id,x.item_name,x.inspect_value,x.inspect_date,s.name,d.sort,d.min_range,d.large_range,d.range_value,d.range_type,x.inspect_type,x.org_id").Joins("left join xt_patients AS s ON s.id = x.patient_id").Joins("RIGHT JOIN xt_quality_control_standard AS d ON d.inspection_minor = x.item_id AND d.inspection_major = x.project_id AND x.org_id = d.user_org_id").Where("x.status = 1	and x.inspect_type = 1 and x.org_id = ? and x.inspect_value + 0 <> 0 and x.inspect_date >=? and x.inspect_date<=? and d.user_org_id = ? and d.is_status=1 and d.status = 1 and (x.inspect_value+0 < d.min_range+0  or x.inspect_value+0 > d.large_range + 0)", orgid, startime, endtime, orgid).Group("x.id").Order("x.inspect_date DESC").Scan(&inspection).Error
	return inspection, err
}

func GetConfigurationNoStandDetail(orgid int64, startime int64, endtime int64) (inspection []*models.XtPatientsInspection, err error) {
	db := XTReadDB().Table("xt_inspection as x")
	err = db.Select("x.id,x.patient_id,x.item_id,x.item_name,x.inspect_value,x.inspect_date,s.name,d.sort,d.min_range,d.large_range,d.range_value,d.range_type,x.inspect_type,x.org_id").Joins("left join xt_patients AS s ON s.id = x.patient_id").Joins("RIGHT JOIN xt_quality_control_standard AS d ON d.inspection_minor = x.item_id AND d.inspection_major = x.project_id AND x.org_id = d.user_org_id").Where("x.status = 1	and x.inspect_type = 2 and x.org_id = ? and x.inspect_value  <> '' and x.inspect_date >=? and x.inspect_date<=? and d.user_org_id = ? and d.is_status=1 and d.status = 1 and (x.inspect_value <> d.range_value)", orgid, startime, endtime, orgid).Group("x.id").Order("x.inspect_date DESC").Scan(&inspection).Error
	return inspection, err
}

func GetInspectNoStandList(orgid int64, startime int64, endtime int64, limit int64, page int64) (inspection []*models.XtPatientsInspection, err error) {

	db := XTReadDB().Table("xt_inspection as x")
	offset := (page - 1) * limit
	err = db.Select("x.id,x.patient_id,x.item_id,x.item_name,x.inspect_value,x.inspect_date,s.name,d.sort,d.min_range,d.large_range,d.range_value,d.range_type,x.inspect_type,x.org_id").Joins("left join xt_patients AS s ON s.id = x.patient_id").Joins("RIGHT JOIN xt_quality_control_standard AS d ON d.inspection_minor = x.item_id AND d.inspection_major = x.project_id AND x.org_id = d.user_org_id").Where("x.status = 1	and x.inspect_type = 1 and x.org_id = ? and x.inspect_value + 0 <> 0 and x.inspect_date >=? and x.inspect_date<=? and d.user_org_id = ? and d.is_status=1 and d.status = 1 and (x.inspect_value+0 < d.min_range+0  or x.inspect_value+0 > d.large_range + 0)", orgid, startime, endtime, orgid).Group("x.id").Offset(offset).Limit(limit).Order("x.inspect_date DESC").Scan(&inspection).Error
	return inspection, err
}

func GetTargetStandDetail(orgid int64, startime int64, endtime int64) (inspection []*models.XtPatientsInspection, err error) {
	db := XTReadDB().Table("xt_inspection as x")
	err = db.Select("x.id,x.patient_id,x.item_id,x.item_name,x.inspect_value,x.inspect_date,s.name,d.sort,d.min_range,d.large_range,d.range_value,d.range_type,x.inspect_type,x.org_id").Joins("left join xt_patients AS s ON s.id = x.patient_id").Joins("RIGHT JOIN xt_quality_control_standard AS d ON d.inspection_minor = x.item_id AND d.inspection_major = x.project_id AND x.org_id = d.user_org_id").Where("x.status = 1	and x.inspect_type = 1 and x.org_id = ? and x.inspect_value + 0 <> 0 and x.inspect_date >=? and x.inspect_date<=? and d.user_org_id = ? and d.is_status=1 and d.status = 1 and x.inspect_value+0 >=d.min_range+0  and x.inspect_value+0 <= d.large_range + 0", orgid, startime, endtime, orgid).Group("x.id").Order("x.inspect_date DESC").Scan(&inspection).Error
	return inspection, err
}

func GetConfigurationStandDetail(orgid int64, startime int64, endtime int64) (inspection []*models.XtPatientsInspection, err error) {
	db := XTReadDB().Table("xt_inspection as x")
	err = db.Select("x.id,x.patient_id,x.item_id,x.item_name,x.inspect_value,x.inspect_date,s.name,d.sort,d.min_range,d.large_range,d.range_value,d.range_type,x.inspect_type,x.org_id").Joins("left join xt_patients AS s ON s.id = x.patient_id").Joins("RIGHT JOIN xt_quality_control_standard AS d ON d.inspection_minor = x.item_id AND d.inspection_major = x.project_id AND x.org_id = d.user_org_id").Where("x.status = 1	and x.inspect_type = 2 and x.org_id = ? and x.inspect_value  <> '' and x.inspect_date >=? and x.inspect_date<=? and d.user_org_id = ? and d.is_status=1 and d.status = 1 and (x.inspect_value = d.range_value)", orgid, startime, endtime, orgid).Group("x.id").Order("x.inspect_date DESC").Scan(&inspection).Error
	return inspection, err
}

func GetStandList(orgid int64, startime int64, endtime int64, limit int64, page int64) (inspection []*models.XtPatientsInspection, err error) {
	db := XTReadDB().Table("xt_inspection as x")
	offset := (page - 1) * limit
	err = db.Select("x.id,x.patient_id,x.item_id,x.item_name,x.inspect_value,x.inspect_date,s.name,d.sort,d.min_range,d.large_range,d.range_value,d.range_type,x.inspect_type,x.org_id").Joins("left join xt_patients AS s ON s.id = x.patient_id").Joins("RIGHT JOIN xt_quality_control_standard AS d ON d.inspection_minor = x.item_id AND d.inspection_major = x.project_id AND x.org_id = d.user_org_id").Where("x.status = 1	and x.inspect_type = 1 and x.org_id = ? and x.inspect_value + 0 <> 0 and x.inspect_date >=? and x.inspect_date<=? and d.user_org_id = ? and d.is_status=1 and d.status = 1 and x.inspect_value+0 >=d.min_range+0  and x.inspect_value+0 <= d.large_range + 0", orgid, startime, endtime, orgid).Group("x.id").Offset(offset).Limit(limit).Order("x.inspect_date DESC").Scan(&inspection).Error

	return inspection, err
}

func GetDiastolicStand(orgid int64, startime int64, endtime int64, page int64, limit int64) (record []*models.XTMonitoringRecords, err error) {

	db := XTReadDB().Table("xt_monitoring_record as x")
	offset := (page - 1) * limit
	err = db.Select("x.id,x.systolic_blood_pressure,x.diastolic_blood_pressure,x.patient_id,x.monitoring_date,s.name").Joins("left join xt_patients as s on s.id = x.patient_id").Where("x.user_org_id = ? and x.monitoring_date >=? and x.monitoring_date<=? and x.status = 1 and x.systolic_blood_pressure <> 0 and x.diastolic_blood_pressure <> 0)", orgid, startime, endtime).Offset(offset).Limit(limit).Group("x.monitoring_date,x.patient_id").Scan(&record).Error
	return record, err
}

func GetInspectionMoninList(id int64, orgid int64, patientid int64) (models.XtInspection, error) {
	inspection := models.XtInspection{}
	err = XTReadDB().Model(&inspection).Where("item_id=? and org_id = ? and status = 1 and patient_id = ?", id, orgid, patientid).Last(&inspection).Error
	return inspection, err
}

func TotalSysStandCountTwo(orgid int64, startime int64, endtime int64, sysmin int64, syslarge int64, diamin int64, dialarge int64) (record []*models.XTMonitoringRecords, err error) {

	db := XTReadDB().Table("xt_monitoring_record as x").Where("x.status = 1")
	if orgid > 0 {
		db = db.Where("x.user_org_id = ? and x.systolic_blood_pressure<>0 and x.diastolic_blood_pressure<>0 ", orgid)
	}
	if startime > 0 {
		db = db.Where("x.monitoring_date>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.monitoring_date<=?", endtime)
	}
	if sysmin > 0 {
		db = db.Where(" x.systolic_blood_pressure>=?", sysmin)
	}
	if syslarge > 0 {
		db = db.Where("x.systolic_blood_pressure<=?", syslarge)
	}
	if diamin > 0 {
		db = db.Where(" x.diastolic_blood_pressure>=?", diamin)
	}
	if dialarge > 0 {
		db = db.Where("x.diastolic_blood_pressure<=?", dialarge)
	}
	err = db.Select("x.id,x.user_org_id,x.systolic_blood_pressure,x.diastolic_blood_pressure,x.patient_id,x.monitoring_date,s.name").Joins("left join xt_patients as s on s.id = x.patient_id").Where("s.status = 1").Group("x.monitoring_date,x.patient_id").Order("x.monitoring_date desc").Scan(&record).Error
	return record, err
}

func TotalSysStandCount(orgid int64, startime int64, endtime int64, sysmin int64, syslarge int64, diamin int64, dialarge int64, page int64, limit int64) (record []*models.XTMonitoringRecords, err error) {

	db := XTReadDB().Table("xt_monitoring_record as x").Where("x.status = 1")
	if orgid > 0 {
		db = db.Where("x.user_org_id = ? and x.systolic_blood_pressure<>0 and x.diastolic_blood_pressure<>0 ", orgid)
	}
	if startime > 0 {
		db = db.Where("x.monitoring_date>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.monitoring_date<=?", endtime)
	}
	if sysmin > 0 {
		db = db.Where(" x.systolic_blood_pressure>=?", sysmin)
	}
	if syslarge > 0 {
		db = db.Where("x.systolic_blood_pressure<=?", syslarge)
	}
	if diamin > 0 {
		db = db.Where(" x.diastolic_blood_pressure>=?", diamin)
	}
	if dialarge > 0 {
		db = db.Where("x.diastolic_blood_pressure<=?", dialarge)
	}
	offset := (page - 1) * limit
	err = db.Select("x.id,x.user_org_id,x.systolic_blood_pressure,x.diastolic_blood_pressure,x.patient_id,x.monitoring_date,s.name").Joins("left join xt_patients as s on s.id = x.patient_id").Where("s.status = 1").Group("x.monitoring_date,x.patient_id").Offset(offset).Limit(limit).Order("x.monitoring_date desc").Scan(&record).Error
	return record, err
}

func TotalSysNoStandCountTwo(orgid int64, startime int64, endtime int64, sysmin int64, syslarge int64, diamin int64, dialarge int64) (record []*models.XTMonitoringRecords, err error) {

	db := XTReadDB().Table("xt_monitoring_record as x").Where("x.status = 1")
	if orgid > 0 {
		db = db.Where("x.user_org_id = ? and x.systolic_blood_pressure<>0 and x.diastolic_blood_pressure<>0 ", orgid)
	}
	if startime > 0 {
		db = db.Where("x.monitoring_date>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.monitoring_date<=?", endtime)
	}
	err = db.Select("x.id,x.user_org_id,x.systolic_blood_pressure,x.diastolic_blood_pressure,x.patient_id,x.monitoring_date,s.name").Joins("left join xt_patients as s on s.id = x.patient_id").Where("s.status = 1 and(x.systolic_blood_pressure<=? or x.systolic_blood_pressure>=?) or (x.diastolic_blood_pressure<=? or x.diastolic_blood_pressure>=?)", sysmin, syslarge, diamin, dialarge).Group("x.monitoring_date,x.patient_id").Order("x.monitoring_date desc").Scan(&record).Error
	return record, err
}

func TotalSysNoStandCount(orgid int64, startime int64, endtime int64, sysmin int64, syslarge int64, diamin int64, dialarge int64, page int64, limit int64) (record []*models.XTMonitoringRecords, err error) {

	db := XTReadDB().Table("xt_monitoring_record as x").Where("x.status = 1")
	if orgid > 0 {
		db = db.Where("x.user_org_id = ? and x.systolic_blood_pressure<>0 and x.diastolic_blood_pressure<>0 ", orgid)
	}
	if startime > 0 {
		db = db.Where("x.monitoring_date>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.monitoring_date<=?", endtime)
	}
	offset := (page - 1) * limit
	err = db.Select("x.id,x.user_org_id,x.systolic_blood_pressure,x.diastolic_blood_pressure,x.patient_id,x.monitoring_date,s.name").Joins("left join xt_patients as s on s.id = x.patient_id").Where("s.status = 1 and(x.systolic_blood_pressure<=? or x.systolic_blood_pressure>=?) or (x.diastolic_blood_pressure<=? or x.diastolic_blood_pressure>=?)", sysmin, syslarge, diamin, dialarge).Group("x.monitoring_date,x.patient_id").Offset(offset).Limit(limit).Order("x.monitoring_date desc").Scan(&record).Error
	return record, err
}

func GetModeIdCount(startime int64, endtime int64, orgid int64, page int64, limit int64) (order []*models.BloodDialysisModeIdCount, err error) {

	table := XTReadDB().Table("xt_schedule as s")
	fmt.Println("table", table)
	db := XTReadDB().Table("xt_dialysis_order as o")
	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,	s.patient_id,	count(o.id) as count").Joins("left join xt_schedule as s on s.patient_id = o.patient_id").Where("s.schedule_date = o.dialysis_date and s.status =1 ").Scan(&order).Error
	return order, err
}

func GetScheduleModeIdCount(startime int64, endtime int64, orgid int64, page int64, limit int64) (order []*models.BloodDialysisModeIdCount, err error) {

	db := XTReadDB().Table("xt_schedule as s").Where("s.status = 1")
	if orgid > 0 {
		db = db.Where("s.user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("s.schedule_date>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("s.schedule_date<=?", endtime)
	}
	err = db.Group(" s.patient_id,s.mode_id").Select("s.mode_id,s.patient_id,count(s.id) as count").Scan(&order).Error
	return order, err
}

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

	table := XTReadDB().Table("xt_schedule as s")
	fmt.Println("table", table)
	db := XTReadDB().Table("xt_dialysis_order as o")
	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.mode_id").Select("s.mode_id,	s.patient_id").Joins("left join xt_schedule as s on s.patient_id = o.patient_id").Where("s.schedule_date = o.dialysis_date and s.status =1 ").Scan(&order).Error
	return order, err

}

func GetCountModeId(startime int64, endtime int64, modeid int64, orgid int64) (order []*models.BloodTreateModeIdCount, err error) {

	table := XTReadDB().Table("xt_schedule as s")
	fmt.Println("table", table)
	db := XTReadDB().Table("xt_dialysis_order as o")
	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("o.dialysis_date,s.mode_id").Select("s.mode_id,	count(s.mode_id) as count,o.dialysis_date").Joins("left join xt_schedule as s on s.patient_id = o.patient_id").Where("s.schedule_date = o.dialysis_date and s.status =1 and s.mode_id = ? and o.dialysis_date <> ''", modeid).Scan(&order).Error
	return order, err

}

func GetCountRollout(orgid int64, startime int64, endtime int64, lapsetotype int64, sourcetype int64) (lapseto []*models.BloodLapsetoCount, err error) {

	table := XTReadDB().Table("xt_patients as s")
	fmt.Println(table)
	db := XTReadDB().Table("xt_patient_lapseto as x").Where("x.status = 1")
	if startime > 0 {
		db = db.Where("x.lapseto_time >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.lapseto_time<=?", endtime)
	}
	if lapsetotype == 0 || sourcetype == 0 {
		err = db.Group("x.lapseto_time,x.lapseto_type").Select("count(x.id) as count,x.lapseto_type,x.lapseto_time").Joins("left join xt_patients as s  on s.id = x.patient_id").Where("s.user_org_id = ?", orgid).Scan(&lapseto).Error
	}

	if lapsetotype > 0 {
		err = db.Group("x.lapseto_time,x.lapseto_type").Select("count(x.id) as count,x.lapseto_type,x.lapseto_time").Joins("left join xt_patients as s  on s.id = x.patient_id").Where("s.user_org_id = ? and s.lapseto = ?", orgid, lapsetotype).Scan(&lapseto).Error
	}
	if sourcetype > 0 {
		err = db.Group("x.lapseto_time,x.lapseto_type").Select("count(x.id) as count,x.lapseto_type,x.lapseto_time").Joins("left join xt_patients as s  on s.id = x.patient_id").Where("s.user_org_id = ? and s.source = ?", orgid, sourcetype).Scan(&lapseto).Error
	}
	return lapseto, err
}

func GetCheckExaminePercent(start_time int64, end_time int64, org_id int64, name_type int64) (total int64) {

	switch name_type {
	case 1:
		key := "%" + "血常规" + "%"
		readDb.Model(&models.Inspection{}).Where("inspect_date >= ? AND inspect_date <= ? AND user_org_id = ? AND status = 1 AND (item_name Like ? Or project_name Like ?)", start_time, end_time, org_id, key).Group("patient_id").Count(&total)

		break
	case 2:
		//key := "%" + "肝功能" + "%"
		//key1 := "%" + "肾功能" + "%"
		//key2 := "%" + "电解质" + "%"
		//key3 := "%" + "血脂" + "%"
		//readDb.Model(&models.Inspection{}).Where("inspect_date >= ? AND inspect_date <= ? AND user_org_id = ? AND status = 1 AND ((item_name Like ? Or project_name Like ?) Or (item_name Like ? Or project_name Like ?) Or (item_name Like ? Or project_name Like ?) Or (item_name Like ? Or project_name Like ?))", start_time, end_time, org_id, key, key, key1, key1, key2, key2, key3, key3).Group("patient_id").Count(&total)

		break
	case 3:
		//key := "%" + "肝功能" + "%"
		//readDb.Model(&models.Inspection{}).Where("inspect_date >= ? AND inspect_date <= ? AND user_org_id = ? AND status = 1 AND ((item_name Like ? Or project_name Like ?) Or (item_name Like ? Or project_name Like ?) Or (item_name Like ? Or project_name Like ?) Or (item_name Like ? Or project_name Like ?))", start_time, end_time, org_id, key, key, key1, key1, key2, key2, key3, key3).Group("patient_id").Count(&total)

		break
	case 4:
		break
	case 5:
		break
	case 6:
		break

	}

	return
}

func GetAllPatientCount(orgid int64) (total int64, err error) {
	err = XTReadDB().Where("user_org_id = ? and status = 1", orgid).Count(&total).Error
	return
}

func GetPatientInspectionList(user_org_id int64) (inspection []*models.XtInspection, err error) {

	err = XTReadDB().Where("inspect_date>=? and inspect_date<=? and org_id = ? and status=1", 1704038400, 1711814400, user_org_id).Group("patient_id").Find(&inspection).Error

	return inspection, err
}