XT_New/service/self_drug_service.go

package service

import (
	"fmt"
	"time"

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

func GetCurrentPatient(orgid int64) (patients []*models.DrugPatients, err error) {

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

func GetAllDrugName(orgid int64) (baseDrug []*models.XtBaseDrug, err error) {

	err = XTReadDB().Group("drug_name").Where("org_id = ? and status = 1 and find_in_set('停用',drug_status) = 0", orgid).Find(&baseDrug).Error
	return baseDrug, err

}

func GetDrugName(drugname string, orgid int64) (*models.XtDrugName, error) {

	drugName := models.XtDrugName{}
	err := XTReadDB().Model(&drugName).Where("drug_name = ? and user_org_id = ? and status  =1", drugname, orgid).Find(&drugName).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &drugName, nil
}

func SaveDrugName(drugname *models.XtDrugName) error {

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

func GetDrugNameList(orgid int64) (druname []*models.XtDrugName, err error) {

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

func GetRulleName(orgid int64, name string) (baseDrug []*models.XtBaseDrug, err error) {

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

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

func GetRulleList(orgid int64, id int64) (rulleName []*models.XtStandName, err error) {

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

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

func IsExistStandName(drugname string, drugspec string, orgid int64) (*models.XtStandName, error) {
	standName := models.XtStandName{}
	err := XTReadDB().Model(&standName).Where("drug_name = ? and drug_spec = ? and user_org_id = ? and status = 1", drugname, drugspec, orgid).Find(&standName).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &standName, nil
}

func SaveRulleName(rullName *models.XtStandName) error {

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

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

func GetIsExit(drugname string, drugspec string, id int64) (*models.XtStandName, error) {

	standName := models.XtStandName{}
	err := XTReadDB().Model(&standName).Where("drug_name = ? and drug_spec = ? and id <> ? and status = 1", drugname, drugspec, id).Find(&standName).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &standName, nil
}

func UpdatedRullerName(id int64, re *models.XtStandName) error {

	err := XTWriteDB().Model(&re).Where("id=?", id).Update(map[string]interface{}{"drug_spec": re.DrugSpec, "min_unit": re.MinUnit, "price": re.Price, "drug_stock_limit": re.DrugStockLimit, "drug_name": re.DrugName, "drug_name_id": re.DrugNameId, "drug_id": re.DrugId}).Error
	return err
}

//func GetAllDrugNameList(orgid int64) (rullername []*models.XtStandName, err error) {
//
//	err = XTReadDB().Group("drug_name").Model(&rullername).Where("user_org_id = ? and status = 1", orgid).Find(&rullername).Error
//	return rullername, err
//}

func GetAllDrugNameList(orgid int64) (drugName []*models.XtDrugName, err error) {

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

func GetRullerListByDrugName(drugname string, orgid int64) (rullername []*models.XtStandName, err error) {

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

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

func GetNewBaseDrugMedical(id int64, tx *gorm.DB) (models.XtBaseDrug, error) {
	drug := models.XtBaseDrug{}
	err := tx.Model(&drug).Where("id = ? and status = 1", id).Find(&drug).Error
	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return drug, err
		}

	}
	return drug, err
}

func ModifyDrugWarehouseByInfoId(id int64, stock_max_number int64) error {
	info := models.DrugWarehouseInfo{}
	err := XTWriteDB().Model(&info).Where("id = ?", id).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number - ?", stock_max_number)).Error
	return err
}

func ModifyDrugWarehouseByStockMin(id int64, stock_min_number int64) error {
	info := models.DrugWarehouseInfo{}
	err := XTWriteDB().Model(&info).Where("id = ?", id).UpdateColumn("stock_min_number", gorm.Expr("stock_min_number - ?", stock_min_number)).Error
	return err
}

func GetSelfMedicalByDrugName(drugname string, drug_spec string, patientid int64) (*models.XtSelfMedical, error) {
	medical := models.XtSelfMedical{}
	err := XTReadDB().Model(&medical).Where("drug_name = ? and drug_spec = ? and patient_id = ? and status = 1", drugname, drug_spec, patientid).Find(&medical).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &medical, err
}

func CreateSelfMedical(medical *models.XtSelfMedical) error {

	err = XTWriteDB().Model(&medical).Create(&medical).Error
	return err
}

func GetCurrentOrgAllStaff(orgid int64, app int64) (role []*models.SgjUserAdminRole, err error) {

	err = UserReadDB().Model(&role).Where("org_id = ? and app_id = ? and status = 1", orgid, app).Find(&role).Error
	return role, err
}

func CreateStock(stock *models.XtSelfStock) error {

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

func CreateOutStock(stock *models.XtSelfOutStock) error {

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

func GetStandDrugByDrugName(drugname string, orgid int64) (*models.XtStandName, error) {
	standname := models.XtStandName{}
	err := XTReadDB().Model(&standname).Where("drug_name = ? and user_org_id = ? and status = 1", drugname, orgid).Find(&standname).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &standname, nil
}

func DeleteDrugName(id int64) (models.XtDrugName, error) {
	standName := models.XtDrugName{}
	err := XTWriteDB().Model(&standName).Where("id = ?", id).Update(map[string]interface{}{"status": 0}).Error
	return standName, err
}

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

func SaveRadio(drugSet *models.XtDrugSet) error {

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

func UpdateDrugSet(set *models.XtDrugSet, orgid int64) error {

	err := XTWriteDB().Model(&set).Where("user_org_id = ?", orgid).Update(map[string]interface{}{"drug_start": set.DrugStart}).Error
	return err
}

func GetMedicalsByName(orgid int64, drugname string) (*models.XtSelfMedical, error) {

	medical := models.XtSelfMedical{}
	err := XTReadDB().Model(&medical).Where("user_org_id = ? and drug_name = ? and status = 1", orgid, drugname).Find(&medical).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &medical, nil
}

func DeleteDrugStand(id int64) error {

	standName := models.XtStandName{}
	err := XTWriteDB().Model(&standName).Where("id =?", id).Update(map[string]interface{}{"status": 0}).Error
	return err
}

//func GetStockList(patientid int64, startime int64, keyword string) (stock []*models.SelfStocks, err error) {
//	db := XTReadDB().Table("xt_self_stock as x").Where("x.status = 1")
//	likeKey := "%" + keyword + "%"
//	table := XTReadDB().Table("xt_patients as s")
//	fmt.Println(table)
//	if patientid > 0 {
//		db = db.Where("x.patient_id = ?", patientid)
//	}
//	if startime > 0 {
//		db = db.Where("x.storck_time <= ?", startime)
//	}
//	err = db.Group("x.drug_name,x.drug_spec").Select("x.id,x.drug_name,x.drug_name_id,x.drug_spec,x.remarks,x.store_number,x.admin_user_id,x.storck_time,x.user_org_id,x.stock_in_number,x.patient_id,x.min_unit,sum(x.store_number) as total").Joins("left join xt_patients as  s on s.id = x.patient_id").Where("s.name like ? or s.dialysis_no like ?", likeKey, likeKey).Scan(&stock).Error
//	return stock, err
//}

func GetStockList(patientid int64, startime int64, keyword string, orgid int64) (stock []*models.XtSelfMedicals, err error) {
	likeKey := "%" + keyword + "%"
	db := XTReadDB().Table("xt_self_medical as x").Where("x.status = 1")
	if patientid > 0 {
		db = db.Where("x.patient_id = ?", patientid)
	}
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	err = db.Group("x.drug_name,x.drug_spec").Select("x.id,x.drug_name,x.drug_name_id,x.drug_spec,x.min_unit,sum(t.store_number) as total,t.remarks,x.patient_id,t.stock_in_number,t.storck_time,t.admin_user_id,t.medic_id").Joins("left join xt_self_stock as t on t.medic_id = x.id").Where("t.storck_time<=?", startime).Joins("left join xt_patients as s on s.id = x.patient_id").Where("s.name like ? or s.dialysis_no like ?", likeKey, likeKey).Scan(&stock).Error
	return stock, err
}

func GetOutStockList(patientid int64, startime int64, keyword string, orgid int64) (outStock []*models.SelfOutStock, err error) {

	likeKey := "%" + keyword + "%"
	db := XTReadDB().Table("xt_self_medical as x").Where("x.status = 1")
	if patientid > 0 {
		db = db.Where("x.patient_id = ?", patientid)
	}
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	err = db.Group("x.drug_name,x.drug_spec").Select("x.id,x.drug_name,x.drug_name_id,x.drug_spec,x.min_unit,sum(t.outstore_number) as count,t.remarks,x.patient_id,t.stock_out_number,t.storck_time,t.admin_user_id,t.medic_id").Joins("left join xt_self_out_stock as t on t.medic_id = x.id").Where("t.storck_time<=?", startime).Joins("left join xt_patients as s on s.id = x.patient_id").Where("s.name like ? or s.dialysis_no like ?", likeKey, likeKey).Scan(&outStock).Error
	return outStock, err
}

func GetTotalOutStockList(patientid int64, startime int64, keyword string, orgid int64) (outStock []*models.SelfOutStock, err error) {

	likeKey := "%" + keyword + "%"
	db := XTReadDB().Table("xt_self_out_stock as x").Where("x.status = 1")
	if patientid > 0 {
		db = db.Where("x.patient_id = ?", patientid)
	}
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("x.storck_time<=?", startime)
	}

	err = db.Select("x.id,x.drug_name,x.drug_name_id,x.drug_spec,x.remarks,x.outstore_number,x.admin_user_id,x.storck_time,x.user_org_id,x.patient_id,x.exit_mode,x.medic_id").Joins("left join xt_patients as s on s.id = x.patient_id").Where("s.name like ? or s.dialysis_no like ?", likeKey, likeKey).Find(&outStock).Error
	return outStock, err
}

//func GetOutStockList(patientid int64, startime int64, keyword string) (outStock []*models.XtSelfOutStocks, err error) {
//	db := XTReadDB().Table("xt_self_out_stock as x").Where("x.status = 1")
//	likeKey := "%" + keyword + "%"
//	table := XTReadDB().Table("xt_patients as s")
//	fmt.Println(table)
//	if patientid > 0 {
//		db = db.Where("x.patient_id = ?", patientid)
//	}
//	if startime > 0 {
//		db = db.Where("x.storck_time <= ?", startime)
//	}
//	err = db.Group("x.drug_name,x.drug_spec").Select("x.drug_name,x.drug_spec,x.patient_id,x.stock_out_number,sum(x.outstore_number) as count").Joins("left join xt_patients as  s on s.id = x.patient_id").Where("s.name like ? or s.dialysis_no like ?", likeKey, likeKey).Scan(&outStock).Error
//	return outStock, err
//}

func GetMedicalList(patientid int64, orgid int64, keyword string) (medical []*models.XtSelfMedicals, err error) {
	likeKey := "%" + keyword + "%"
	db := XTReadDB().Table("xt_self_medical as x").Where("x.status = 1")
	if patientid > 0 {
		db = db.Where("x.patient_id = ?", patientid)
	}
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	err = db.Select("x.drug_name,x.id,x.drug_spec,x.patient_id,x.min_unit").Joins("left join xt_patients as s on s.id = x.patient_id").Where("s.name like ? or s.dialysis_no like ?", likeKey, likeKey).Group("x.drug_name,x.drug_spec").Scan(&medical).Error
	//err = XTReadDB().Model(&medical).Where("patient_id = ? and user_org_id = ? and status = 1", patientid, orgid).Group("drug_name,drug_spec").Find(&medical).Error
	return medical, err
}

func GetStockOutDetail(durgname string, patientid int64) (stock []*models.XtSelfOutStock, err error) {

	err = XTReadDB().Model(&stock).Where("drug_name = ? and patient_id = ? and status = 1", durgname, patientid).Find(&stock).Error
	return stock, err
}

func DeleteDrugStockNumber(drugname string, patientid int64) (models.XtSelfStock, error) {
	stock := models.XtSelfStock{}
	err := XTWriteDB().Model(&stock).Where("drug_name = ? and patient_id = ?", drugname, patientid).Update(map[string]interface{}{"status": 0}).Error
	return stock, err
}

func GetStockDetail(drugname string, drugspec string, startime int64, endtime int64, patientid int64, orgid int64) (stock []*models.XtSelfStock, err error) {

	err = XTReadDB().Model(&stock).Where("drug_name = ? and drug_spec = ? and patient_id =? and user_org_id = ? and status = 1 and storck_time>=? and storck_time<=?", drugname, drugspec, patientid, orgid, startime, endtime).Order("storck_time asc").Find(&stock).Error
	return stock, err
}

func GetOutStockDetail(drugname string, drugspec string, startime int64, endtime int64, patientid int64, orgid int64) (outStock []*models.XtSelfOutStock, err error) {

	err = XTReadDB().Model(&outStock).Where("drug_name = ? and drug_spec=? and patient_id = ? and user_org_id = ? and status = 1 and storck_time>=? and storck_time<=?", drugname, drugspec, patientid, orgid, startime, endtime).Order("storck_time asc").Find(&outStock).Error
	return outStock, err
}

func GetAllPatientStockList(drug_name string, drug_spec string, startime int64, endtime int64, keyword string, orgid int64) (stocks []*models.SelfStocks, err error) {

	db := XTReadDB().Table("xt_self_stock as x").Where("x.status = 1")
	likeKey := "%" + keyword + "%"
	table := XTReadDB().Table("xt_patients as s")
	fmt.Println(table)
	if len(drug_name) > 0 {
		db = db.Where("x.drug_name = ?", drug_name)
	}
	if len(drug_spec) > 0 {
		db = db.Where("x.drug_spec = ?", drug_spec)
	}
	//if startime > 0 {
	//	db = db.Where("x.storck_time >= ?", startime)
	//}
	//if endtime > 0 {
	//	db = db.Where("x.storck_time <= ?", endtime)
	//}
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	err = db.Group("x.patient_id,x.drug_name,x.drug_spec").Select("t.drug_name,t.drug_spec,x.patient_id,x.store_number,sum(x.store_number) as total,s.name,s.dialysis_no,x.min_unit,x.drug_name_id").Joins("left join xt_patients as  s on s.id = x.patient_id").Joins("left join xt_self_medical as t on t.id = x.medic_id").Where("s.name like ? or s.dialysis_no like ?", likeKey, likeKey).Scan(&stocks).Error
	return stocks, err
}

func GetAllPatientOutStockList(drug_name string, drug_spec string, startime int64, endtime int64, keyword string, orgid int64) (outStock []*models.XtSelfOutStocks, err error) {

	db := XTReadDB().Table("xt_self_out_stock as x").Where("x.status = 1")
	likeKey := "%" + keyword + "%"
	table := XTReadDB().Table("xt_patients as s")
	fmt.Println(table)
	if len(drug_name) > 0 {
		db = db.Where("x.drug_name = ?", drug_name)
	}
	if len(drug_spec) > 0 {
		db = db.Where("x.drug_spec=?", drug_spec)
	}

	if startime > 0 {
		db = db.Where("x.storck_time >= ?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.storck_time<=?", endtime)
	}
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	err = db.Group("x.patient_id,x.drug_name,x.drug_spec").Select("x.drug_name,x.drug_spec,x.patient_id,x.stock_out_number,sum(x.outstore_number) as count,s.name,s.dialysis_no,x.drug_name_id").Joins("left join xt_patients as  s on s.id = x.patient_id").Where("s.name like ? or s.dialysis_no like ?", likeKey, likeKey).Scan(&outStock).Error
	return outStock, err
}

func GetDrugDataByPatientId(patientid int64) (selfMedical []*models.XtSelfMedical, err error) {

	err = XTReadDB().Group("drug_name,drug_spec").Model(&selfMedical).Where("patient_id = ? and status = 1", patientid).Find(&selfMedical).Error
	return selfMedical, err
}

func GetDruckStockConfig(orgid int64) (models.XtDrugStockConfig, error) {

	drugConfig := models.XtDrugStockConfig{}
	err := XTReadDB().Model(&drugConfig).Where("org_id = ? and status = 1", orgid).Find(&drugConfig).Error
	return drugConfig, err
}

func GetSetSelfMedical(orgid int64) (models.XtDrugSet, error) {
	medical := models.XtDrugSet{}
	err := XTReadDB().Model(&medical).Where("user_org_id = ? and status = 1", orgid).Find(&medical).Error
	return medical, err
}

func GetSelfMedicalList(patientid int64) (selfmedical []*models.XtSelfMedical, err error) {

	err = XTReadDB().Group("drug_name").Model(&selfmedical).Where("patient_id = ? and status = 1", patientid).Find(&selfmedical).Error
	return selfmedical, err
}

func GetDrugDescByDrugName(drugname string, patient_id int64, orgid int64) (selfMedical []*models.XtSelfMedical, err error) {

	err = XTReadDB().Model(&selfMedical).Where("drug_name = ? and patient_id = ? and user_org_id = ? and status = 1", drugname, patient_id, orgid).Find(&selfMedical).Error
	return selfMedical, err
}

func GetBaseMedcal(drugname string, orgid int64) (baseDrug []*models.XtBaseDrug, err error) {

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

func GetTotalBaseMedicalCount(drug_id int64, orgid int64) (drugInfo []*models.DrugWarehousingInfo, err error) {

	db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1")
	err = db.Select("x.drug_id,sum(x.warehousing_count) as count").Where("drug_id = ? and org_id = ?", drug_id, orgid).Scan(&drugInfo).Error
	return drugInfo, err
}

func GetTotalBaseMedicalCountOut(drug_id int64, orgid int64) (drugOut []*models.DrugWarehousingInfo, err error) {

	db := XTReadDB().Table("xt_drug_warehouse_out_info as x").Where("x.status = 1")
	err = db.Select("x.drug_id,sum(x.count) as count").Where("drug_id = ? and org_id = ?", drug_id, orgid).Scan(&drugOut).Error
	return drugOut, err
}

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

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

func CreateDrugWarehoue(warehouse *models.XtDrugWarehouse) error {

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

func GetTodayWareHousringOrder(startime int64, orgid int64) (models.XtDrugWarehouseOut, error) {
	warehouse := models.XtDrugWarehouseOut{}
	err := XTReadDB().Model(&warehouse).Where("warehouse_out_time = ? and org_id = ? and status = 1", startime, orgid).Find(&warehouse).Error
	return warehouse, err
}

func CreateDrugWareHouseOut(out *models.XtDrugWarehouseOut) error {

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

func CreateWareHouseOutInfo(info *models.XtDrugWarehouseOutInfo) error {

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

func CreateAotoMaticReduceDetail(detail *models.XtDrugAutomaticReduceDetail) error {

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

func GetDrugStockConfig(orgid int64) (models.XtDrugStockConfig, error) {

	config := models.XtDrugStockConfig{}
	err := XTReadDB().Model(&config).Where("org_id =? and status = 1", orgid).Find(&config).Error
	return config, err
}

func GetDrugSet(orgid int64) (models.XtDrugSet, error) {

	drugSet := models.XtDrugSet{}
	err := XTReadDB().Model(&drugSet).Where("user_org_id =? and status = 1", orgid).Find(&drugSet).Error
	return drugSet, err
}

type Drugs struct {
	ID                    int64    `gorm:"column:id" json:"id" form:"id"`
	DrugName              string   `gorm:"column:drug_name" json:"drug_name" form:"drug_name"`
	Pinyin                string   `gorm:"column:pinyin" json:"pinyin" form:"pinyin"`
	Wubi                  string   `gorm:"column:wubi" json:"wubi" form:"wubi"`
	DrugAlias             string   `gorm:"column:drug_alias" json:"drug_alias" form:"drug_alias"`
	DrugAliasPinyin       string   `gorm:"column:drug_alias_pinyin" json:"drug_alias_pinyin" form:"drug_alias_pinyin"`
	DrugAliasWubi         string   `gorm:"column:drug_alias_wubi" json:"drug_alias_wubi" form:"drug_alias_wubi"`
	DrugCategory          int64    `gorm:"column:drug_category" json:"drug_category" form:"drug_category"`
	DrugSpec              string   `gorm:"column:drug_spec" json:"drug_spec" form:"drug_spec"`
	DrugType              int64    `gorm:"column:drug_type" json:"drug_type" form:"drug_type"`
	DrugStockLimit        string   `gorm:"column:drug_stock_limit" json:"drug_stock_limit" form:"drug_stock_limit"`
	DrugStatus            string   `gorm:"column:drug_status" json:"drug_status" form:"drug_status"`
	DeliveryWay           string   `gorm:"column:delivery_way" json:"delivery_way" form:"delivery_way"`
	ExecutionFrequency    string   `gorm:"column:execution_frequency" json:"execution_frequency" form:"execution_frequency"`
	SingleDose            float64  `gorm:"column:single_dose" json:"single_dose" form:"single_dose"`
	PrescribingNumber     float64  `gorm:"column:prescribing_number" json:"prescribing_number" form:"prescribing_number"`
	Status                int64    `gorm:"column:status" json:"status" form:"status"`
	OrgId                 int64    `gorm:"column:org_id" json:"org_id" form:"org_id"`
	MinUnit               string   `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
	Drugs                 []*Drugs `gorm:"ForeignKey:DrugName;AssociationForeignKey:DrugName" json:"drug_specs"`
	HospApprFlag          int64    `gorm:"column:hosp_appr_flag" json:"hosp_appr_flag" form:"hosp_appr_flag"`
	LmtUsedFlag           int64    `gorm:"column:lmt_used_flag" json:"lmt_used_flag" form:"lmt_used_flag"`
	PrescribingNumberUnit string   `gorm:"column:prescribing_number_unit" json:"prescribing_number_unit" form:"prescribing_number_unit"`
	MinNumber             int64    `gorm:"column:min_number" json:"min_number" form:"min_number"`
	Dose                  string   `gorm:"column:dose" json:"dose" form:"dose"`
	DoseUnit              string   `gorm:"column:dose_unit" json:"dose_unit" form:"dose_unit"`
	MaxUnit               string   `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
	DrugDoseUnit          int64    `grom:"column:drug_dose_unit" json:"drug_dose_unit" form:"drug_dose_unit"`
	FirstLetter           string   `gorm:"column:first_letter" json:"first_letter" form:"first_letter"`
}

func (Drugs) TableName() string {
	return "xt_base_drug"
}

func GetAllBaseDrugLibList(org_id int64) (drugs []*Drugs, err error) {
	db := readDb.Model(&models.BaseDrugLib{}).Preload("Drugs", "status = 1 AND org_id = ? AND find_in_set('停用',drug_status) = 0", org_id).Where("org_id = ?  AND status = 1 AND find_in_set('停用',drug_status) = 0", org_id).Group("drug_name")
	err = db.Find(&drugs).Error
	return
}

type PrivateDrug struct {
	DrugName           string         `gorm:"column:drug_name" json:"drug_name" form:"drug_name"`
	ID                 int64          `gorm:"column:id" json:"id" form:"id"`
	DrugSpec           string         `gorm:"column:drug_spec" json:"drug_spec" form:"drug_spec"`
	PatientId          int64          `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
	DrugNameId         int64          `gorm:"column:drug_name_id" json:"drug_name_id" form:"drug_name_id"`
	Status             int64          `gorm:"column:status" json:"status" form:"status"`
	UserOrgId          int64          `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
	CreatedTime        int64          `gorm:"column:created_time" json:"created_time" form:"created_time"`
	UpdatedTime        int64          `gorm:"column:updated_time" json:"updated_time" form:"updated_time"`
	MinUnit            string         `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
	ExecutionFrequency string         `gorm:"column:execution_frequency" json:"execution_frequency" form:"execution_frequency"`
	PrescribingNumber  float64        `gorm:"column:prescribing_number" json:"prescribing_number" form:"prescribing_number"`
	DeliveryWay        string         `gorm:"column:delivery_way" json:"delivery_way" form:"delivery_way"`
	SingleDose         float64        `gorm:"column:single_dose" json:"single_dose" form:"single_dose"`
	PrivateDrug        []*PrivateDrug `gorm:"ForeignKey:DrugName;AssociationForeignKey:DrugName" json:"drug_specs"`
}

func (PrivateDrug) TableName() string {
	return "xt_self_medical"
}

func GetPrivateDrugList(patient_id int64, org_id int64) (pds []*PrivateDrug, err error) {
	err = XTReadDB().Model(&PrivateDrug{}).Preload("PrivateDrug", "status = 1 AND user_org_id = ? AND patient_id = ? ", org_id, patient_id).Where("patient_id = ? and status = 1 AND user_org_id = ?", patient_id, org_id).Group("drug_name_id").Find(&pds).Error
	return
}

func GetAllMedicalList(orgid int64) (list []*models.XtSelfMedical, err error) {

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

func DeleteDrugNameById(id int64) (models.XtSelfMedical, error) {

	medical := models.XtSelfMedical{}
	err := XTWriteDB().Model(&medical).Where("id = ?", id).Updates(map[string]interface{}{"status": 0}).Error
	return medical, err
}

func GetDrugNameIsExist(drugid int64, orgid int64) (*models.XtDrugName, error) {
	drugName := models.XtDrugName{}
	err := XTReadDB().Model(&drugName).Where("drug_id = ? and user_org_id = ? and status = 1", drugid, orgid).Find(&drugName).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &drugName, nil
}

func UpdatedDrugName(id int64, orgid int64, drugName *models.XtDrugName) error {

	err := XTWriteDB().Model(&drugName).Where("drug_id = ? and user_org_id = ? and status = 1", id, orgid).Update(map[string]interface{}{"drug_name": drugName.DrugName}).Error
	return err
}

func GetStandNameIsExist(id int64, orgid int64) (*models.XtStandName, error) {
	standName := models.XtStandName{}
	err := XTReadDB().Model(&standName).Where("drug_name_id = ? and user_org_id = ? and status = 1", id, orgid).Find(&standName).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &standName, nil
}

func UpdateStandName(id int64, orgid int64, standName *models.XtStandName) error {

	err := XTWriteDB().Model(&standName).Where("drug_name_id = ? and user_org_id = ? and status = 1", id, orgid).Update(map[string]interface{}{"drug_name": standName.DrugName, "drug_spec": standName.DrugSpec, "drug_stock_limit": standName.DrugStockLimit, "min_unit": standName.MinUnit}).Error
	return err
}

func GetSelfMedicalIsExist(id int64, orgid int64) (*models.XtSelfMedical, error) {
	medical := models.XtSelfMedical{}
	err := XTReadDB().Model(&medical).Where("drug_name_id = ? and user_org_id = ? and status =1", id, orgid).Find(&medical).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &medical, nil
}

func UpdateSelfMedical(id int64, orgid int64, medical *models.XtSelfMedical) error {

	err := XTWriteDB().Model(&medical).Where("drug_name_id = ? and user_org_id = ? and status = 1", id, orgid).Update(map[string]interface{}{"drug_name": medical.DrugName, "drug_spec": medical.DrugSpec, "execution_frequency": medical.ExecutionFrequency, "prescribing_number": medical.PrescribingNumber, "delivery_way": medical.DeliveryWay, "single_dose": medical.SingleDose, "min_unit": medical.MinUnit}).Error
	return err
}

func GetDrugNameId(id int64, orgid int64) (models.XtSelfMedical, error) {

	medical := models.XtSelfMedical{}
	err := XTReadDB().Model(&medical).Where("drug_name_id = ? and status = 1 and user_org_id = ?", id, orgid).Find(&medical).Error
	return medical, err
}

func GetSelfStosckIsExist(id int64, orgid int64) (*models.XtSelfStock, error) {

	medical := models.XtSelfStock{}
	err := XTReadDB().Model(&medical).Where("drug_name_id = ? and user_org_id = ? and status  =1", id, orgid).Find(&medical).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &medical, nil
}

func UpdatedSelfStock(stock *models.XtSelfStock, id int64, orgid int64) error {
	err := XTWriteDB().Model(&stock).Where("drug_name_id=? and user_org_id = ? and status = 1", id, orgid).Update(map[string]interface{}{"drug_name": stock.DrugName, "min_unit": stock.MinUnit, "drug_spec": stock.DrugSpec}).Error
	return err
}

func GetOutSelfOutStockIsExist(id int64, orgid int64) (*models.XtSelfOutStock, error) {

	outStock := models.XtSelfOutStock{}
	err := XTReadDB().Model(&outStock).Where("drug_name_id = ? and user_org_id = ? and status = 1", id, orgid).Find(&outStock).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &outStock, nil
}

func UpdatedOutSelfStock(stock *models.XtSelfOutStock, id int64, orgid int64) error {

	err := XTWriteDB().Model(&stock).Where("drug_name_id = ? and user_org_id = ? and status = 1", id, orgid).Update(map[string]interface{}{"drug_name": stock.DrugName, "drug_spec": stock.DrugSpec}).Error
	return err
}

func GetDoctorAdviceIsExist(id int64, orgid int64) (*models.DoctorAdvice, error) {
	advice := models.DoctorAdvice{}
	err := XTReadDB().Model(&advice).Where("drug_id = ? and user_org_id = ? and status = 1", id, orgid).Find(&advice).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &advice, nil
}

func UpdateNoExcuteDoctorAdvice(id int64, orgid int64, advice *models.DoctorAdvice) error {

	err := XTWriteDB().Model(&advice).Where("drug_id = ? and user_org_id = ? and status = 1 and  execution_state = 2", id, orgid).Updates(map[string]interface{}{"advice_name": advice.AdviceName, "advice_desc": advice.AdviceDesc, "single_dose": advice.SingleDose, "single_dose_unit": advice.SingleDoseUnit, "delivery_way": advice.DeliveryWay, "execution_frequency": advice.ExecutionFrequency}).Error
	return err
}

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

func UpdatedDoctorAdviceTemplate(id int64, orgid int64, template *models.DoctorAdviceTemplate) error {

	err := XTWriteDB().Model(&template).Where("drug_id = ? and org_id = ? and status = 1", id, orgid).Updates(map[string]interface{}{"advice_name": template.AdviceName, "advice_desc": template.AdviceDesc, "single_dose": template.SingleDose, "single_dose_unit": template.SingleDoseUnit, "delivery_way": template.DeliveryWay, "execution_frequency": template.ExecutionFrequency}).Error
	return err
}

func ToSeachPatient(keyword string, orgid int64) (patients []*models.Patients, err error) {

	likeKey := "%" + keyword + "%"
	err = XTReadDB().Model(&patients).Where("name like ? and user_org_id = ? and status = 1", likeKey, orgid).Find(&patients).Error
	return patients, err
}

func GetMedicalDrugNameList(orgid int64) (drugName []*models.DrugName, err error) {

	db := XTReadDB().Model(&drugName).Where("user_org_id = ? and status = 1", orgid)

	err = db.Preload("XtStandName", "status =1 and user_org_id = ?", orgid).Find(&drugName).Error

	return drugName, err

}

func GetSelfOutStock(orgid int64, advicedate int64, patientid int64, adivicename string, advicedesc string) (*models.XtSelfOutStock, error) {
	stock := models.XtSelfOutStock{}
	err = XTReadDB().Model(&stock).Where("user_org_id = ? and storck_time = ? and patient_id = ? and drug_name = ? and drug_spec = ? and status = 1", orgid, advicedate, patientid, adivicename, advicedesc).Find(&stock).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &stock, err
}

func UpdatedSelfOutSatock(id int64, stock *models.XtSelfOutStock) error {

	err := XTWriteDB().Model(&stock).Where("id = ?", id).Updates(map[string]interface{}{"drug_name": stock.DrugName, "drug_name_id": stock.DrugNameId, "drug_spec": stock.DrugSpec, "outstore_number": stock.OutstoreNumber, "admin_user_id": stock.AdminUserId, "storck_time": stock.StorckTime, "patient_id": stock.PatientId, "stock_out_number": stock.StockOutNumber, "exit_mode": stock.ExitMode, "medic_id": stock.MedicId, "updated_time": time.Now().Unix()}).Error
	return err
}

func GetSelfStockQuery(typename int64, keywords string, startime int64, endtime int64, orgid int64, limit int64, page int64) (selfoutstock []*models.XtSelfOutStockOne, total int64, err error) {
	offset := (page - 1) * limit
	db := XTReadDB().Table("xt_self_stock as x").Where("x.status = 1")
	likeKey := "%" + keywords + "%"
	if len(keywords) > 0 {
		db = db.Where("x.drug_name like ? ", likeKey)
	}

	if startime > 0 {
		db = db.Where("x.storck_time >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.storck_time<=?", endtime)
	}

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

	if typename > 0 {
		err = db.Select("x.drug_name,x.drug_name_id,x.drug_spec,Sum(store_number) as count,b.drug_type").Joins("left join xt_base_drug as b on b.id = x.drug_name_id and b.org_id = ? and b.status =1 ", orgid).Where("b.drug_type = ?", typename).Group("x.drug_name_id").Count(&total).Offset(offset).Limit(limit).Scan(&selfoutstock).Error
	} else {
		err = db.Select("x.drug_name,x.drug_name_id,x.drug_spec,Sum(store_number) as count,b.drug_type").Joins("left join xt_base_drug as b on b.id = x.drug_name_id and b.org_id = ? and b.status =1", orgid).Group("x.drug_name_id").Count(&total).Offset(offset).Limit(limit).Scan(&selfoutstock).Error
	}

	return selfoutstock, total, err
}

func GetSelfOutStockQuery(startTime int64, endTime int64, orgid int64) (selfoutstock []*models.XtSelfOutStockOne, err error) {

	db := XTReadDB().Table("xt_self_out_stock as x").Where("x.status = 1")
	if startTime > 0 {
		db = db.Where("x.storck_time >?", startTime)
	}
	if endTime > 0 {
		db = db.Where("x.storck_time<=?", endTime)
	}
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	err = db.Select("x.drug_name_id,Sum(x.outstore_number) as count").Group("x.drug_name").Scan(&selfoutstock).Error
	return selfoutstock, err
}

func GetLastDrugWarehouseOutInfo(drugid int64, warehouseOutId int64, orgid int64) (models.XtDrugWarehouseOutInfo, error) {

	info := models.XtDrugWarehouseOutInfo{}

	err = XTReadDB().Model(&info).Where("drug_id = ? and  warehouse_out_id = ? and org_id = ? and status = 1", drugid, warehouseOutId, orgid).Last(&info).Error

	return info, err
}

func PostSearchDrugWarehouseList(keyword string, orgid int64, storehouse_id int64) (info []*models.BloodDrugWarehouseInfo, err error) {
	db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1 and x.is_check = 1 and (x.stock_max_number>0 or x.stock_min_number>0)")
	table := XTReadDB().Table("xt_base_drug as t").Where("t.status")
	fmt.Println(table)
	likeKey := "%" + keyword + "%"
	if orgid > 0 {
		db = db.Where("x.org_id = ?", orgid)
	}
	if storehouse_id > 0 {
		db = db.Where("x.storehouse_id = ?", storehouse_id)
	}
	err = db.Group("x.drug_id").Select("x.id,x.warehousing_id,x.drug_id,t.number,x.product_date,x.expiry_date,x.warehousing_count,x.price,x.total_price,x.dealer,x.remark,x.warehousing_order,x.warehouseing_unit,x.stock_max_number,x.stock_min_number,x.batch_number,x.storehouse_id,t.drug_origin_place,t.drug_name,t.min_unit,x.manufacturer,t.retail_price,t.max_unit,t.min_number,t.dose,t.dose_unit,t.last_price,t.drug_origin_place").Joins("left join xt_base_drug as t on t.id = x.drug_id").Where("t.drug_name like ? and t.org_id = ?", likeKey, orgid).Order("x.ctime desc").Scan(&info).Error
	return info, err

}

func CreateDrugPrice(price models.XtDrugAdjustPrice) error {

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

func GetDrugPriceList(startime int64, endtime int64, orgId int64, keyword string, limit int64, page int64) (adjust []*models.VmDrugAdjustPrice, total int64, err error) {

	likeKey := "%" + keyword + "%"
	offset := (page - 1) * limit
	db := XTReadDB().Table("xt_drug_adjust_price as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_base_drug as t").Where("t.status = 1")
	tab := UserReadDB().Table("sgj_user_admin_role as r").Where("r.status = 1")
	fmt.Println(table, tab)
	if len(keyword) > 0 {
		db = db.Where("x.warehousing_order = ? or r.user_name like ?", keyword, likeKey)
	}
	if orgId > 0 {
		db = db.Where("x.user_org_id = ?", orgId)
	}
	if startime > 0 {
		db = db.Where("x.ctime>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.ctime<=?", endtime)
	}
	err = db.Group("x.id").Select("x.id,x.drug_name,x.specification_name,x.warehousing_unit,x.count,x.last_price,x.retail_price,x.new_price,x.manufacturer,x.dealer,x.remark,x.drug_id,x.warehousing_order,x.start_time,x.creater,x.checker,x.checker_status,x.checker_time,x.number").Joins("left join sgj_users.sgj_user_admin_role as r on r.admin_user_id = x.creater").Joins("left join xt_base_drug as t on t.id =x.drug_id").Count(&total).Offset(offset).Limit(limit).Scan(&adjust).Error
	return adjust, total, err

}

func UpdateDrugAdjuestPrice(ids []string, info models.XtDrugAdjustPrice) error {
	err := XTWriteDB().Model(&info).Where("id in(?)", ids).Updates(map[string]interface{}{"checker": info.Checker, "checker_status": info.CheckerStatus, "checker_time": info.CheckerTime}).Error
	return err
}

func GetDrugAdjuestPrice(ids []string) (info []*models.XtDrugAdjustPrice, err error) {

	err = XTReadDB().Model(&info).Where("id in(?) and status = 1", ids).Find(&info).Error
	return info, err
}

func GetDrugDamage(ids []string) (info []*models.XtDrugDamage, err error) {

	err = XTReadDB().Model(&info).Where("id in(?) and status = 1", ids).Find(&info).Error
	return info, err
}

func CreateDrugDamage(damage models.XtDrugDamage) error {

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

func GetDrugDamageList(startime int64, endtime int64, orgId int64, keyword string, limit int64, page int64, storehouse_id int64) (adjust []*models.VmDrugInventory, total int64, err error) {
	likeKey := "%" + keyword + "%"
	offset := (page - 1) * limit
	db := XTReadDB().Table("xt_drug_inventory as x").Where("x.status = 1 and type = 4")
	table := XTReadDB().Table("xt_base_drug as t").Where("t.status = 1")
	tab := UserReadDB().Table("sgj_user_admin_role as r").Where("r.status = 1")
	fmt.Println(table, tab)
	//if len(keyword) > 0 {
	//	db = db.Where("x.warehousing_order = ? or r.user_name like ?", keyword, likeKey)
	//}
	if len(keyword) > 0 {
		db = db.Where("x.drug_name like ?", likeKey)
	}
	if orgId > 0 {
		db = db.Where("x.user_org_id = ?", orgId)
	}
	if startime > 0 {
		db = db.Where("x.ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.ctime <=?", endtime)
	}
	if storehouse_id > 0 {
		db = db.Where("x.storehouse_id = ?", storehouse_id)
	}
	err = db.Group("x.drug_id").Select("x.id,x.drug_name,x.specification_name,x.warehousing_unit,x.count,x.last_price,x.retail_price,x.new_price,x.manufacturer,x.dealer,x.remark,x.drug_id,x.warehousing_order,x.start_time,x.creater,x.checker,x.checker_status,x.checker_time,x.number,x.drug_origin_place,x.warehouse_info_id,x.batch_number,x.stock_max_number,x.stock_min_number,x.storehouse_id,t.min_number,t.max_unit,t.min_unit,t.min_price").Joins("left join sgj_users.sgj_user_admin_role as r on r.admin_user_id = x.creater").Joins("left join xt_base_drug as t on t.id =x.drug_id").Count(&total).Offset(offset).Limit(limit).Scan(&adjust).Error
	return adjust, total, err
}

func GetDrugDamageByOrgId(orgid int64) (list []*models.XtDrugInventory, err error) {
	err = XTReadDB().Model(&list).Where("user_org_id = ? and type = 4 and status = 1", orgid).Find(&list).Error
	return list, err
}

func UpdateDrugDamage(ids []string, damage models.XtDrugDamage) error {

	err := XTWriteDB().Model(&damage).Where("id in(?)", ids).Updates(map[string]interface{}{"checker": damage.Checker, "checker_status": damage.CheckerStatus, "checker_time": damage.CheckerTime}).Error
	return err
}

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

func ModifyDrugPrice(id int64, adjust models.XtDrugAdjustPrice) error {

	err := XTWriteDB().Model(&adjust).Where("id=? and status = 1", id).Updates(map[string]interface{}{"drug_name": adjust.DrugName, "retail_price": adjust.RetailPrice, "new_price": adjust.NewPrice, "count": adjust.Count, "remark": adjust.Remark, "specification_name": adjust.SpecificationName, "warehousing_unit": adjust.WarehousingUnit, "manufacturer": adjust.Manufacturer, "number": adjust.Number, "drug_id": adjust.DrugId}).Error
	return err
}

func GetModifyPricePrint(ids []string) (info []*models.XtDrugAdjustPrice, err error) {

	err = XTReadDB().Model(&info).Where("id in(?) and status = 1", ids).Find(&info).Error
	return info, err
}

func GetDrugDamageDetail(id int64) (models.XtDrugDamage, error) {

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

func ModifyDrugDamage(id int64, damage models.XtDrugDamage) error {

	err := XTWriteDB().Model(&damage).Where("id=? and status = 1", id).Updates(map[string]interface{}{"drug_name": damage.DrugName, "warehousing_unit": damage.WarehousingUnit, "count": damage.Count, "last_price": damage.LastPrice, "retail_price": damage.RetailPrice, "new_price": damage.NewPrice, "manufacturer": damage.Manufacturer, "remark": damage.Remark, "number": damage.Number, "drug_id": damage.DrugId, "stock_max_number": damage.StockMaxNumber, "stock_min_number": damage.StockMinNumber, "warehousing_info_id": damage.WarehousingInfoId, "drug_origin_place": damage.DrugOriginPlace}).Error
	return err
}

func DeleteDrugDamage(id int64) error {
	damage := models.XtDrugDamage{}
	err := XTWriteDB().Model(&damage).Where("id=? and status = 1").Updates(map[string]interface{}{"status": 0}).Error
	return err
}

func GetDrugDamagePrint(ids []string) (damage []*models.XtDrugDamage, err error) {

	err = XTReadDB().Model(&damage).Where("id in(?) and status = 1", ids).Find(&damage).Error
	return damage, err
}

func GetWarehoseInfoById(id int64, storehouse_id int64, orgid int64) (info []*models.XtDrugWarehouseInfo, err error) {

	if orgid == 10191 {
		err = XTReadDB().Model(&info).Where("drug_id=? and status = 1 and storehouse_id = ? and is_check = 1", id, storehouse_id).Preload("XtBaseDrug", "status= 1").Find(&info).Error
		return info, err
	} else {
		err = XTReadDB().Model(&info).Where("drug_id=? and status = 1 and storehouse_id = ? and is_check = 1 and (stock_max_number>0 or stock_min_number>0)", id, storehouse_id).Preload("XtBaseDrug", "status= 1").Find(&info).Error
		return info, err
	}

}

func CreateDrugInventory(inventory models.XtDrugInventory) error {

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

func GetDrugInventoryList(keyword string, page int64, limit int64, orgid int64, startime int64, endtime int64) (list []*models.VmDrugInventory, total int64, err error) {
	fmt.Println("startdate", limit, page)
	likeKey := "%" + keyword + "%"
	offset := (page - 1) * limit
	db := XTReadDB().Table("xt_drug_inventory as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_base_drug as t").Where("t.status = 1")
	tab := UserReadDB().Table("sgj_user_admin_role as r").Where("r.status = 1")
	fmt.Println(table, tab)
	if len(keyword) > 0 {
		db = db.Where("x.warehousing_order = ? or r.user_name like ?", keyword, likeKey)
	}
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("x.start_time >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("x.start_time<=?", endtime)
	}
	err = db.Select("x.id,x.drug_name,x.specification_name,x.warehousing_unit,x.count,x.last_price,x.retail_price,x.manufacturer,x.dealer,x.remark,x.drug_id,x.warehousing_order,x.number,x.batch_number,x.start_time,x.creater,x.checker,x.checker_status,x.checker_time,x.min_count,x.min_unit,t.dose,t.dose_unit,t.max_unit,t.min_unit").Joins("left join sgj_users.sgj_user_admin_role as r on r.id = x.creater").Joins("left join xt_base_drug as t on t.id =x.drug_id").Count(&total).Order("x.id desc").Offset(offset).Limit(limit).Order("x.ctime desc").Scan(&list).Error
	return list, total, err
}

func UpdateDrugInventory(ids []string, inventory models.XtDrugInventory) error {

	err := XTWriteDB().Model(&inventory).Where("id in(?) and status = 1", ids).Updates(map[string]interface{}{"checker": inventory.Checker, "checker_status": inventory.CheckerStatus, "checker_time": inventory.CheckerTime}).Error
	return err
}

func GetDrugInventoryListByIds(ids []string) (inventory []*models.XtDrugInventory, err error) {

	err = XTReadDB().Model(&inventory).Where("id in(?) and status = 1", ids).Find(&inventory).Error
	return inventory, err
}

func GetDrugDetailByDrugId(drug_id int64) (models.XtBaseDrug, error) {

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

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

func GetDrugWareInfoByIdTwo(id int64) (info []*models.XtDrugWarehouseInfo, err error) {

	err = XTReadDB().Model(&info).Where("(id = ? or warehousing_info_id = ?) and status = 1", id, id).Find(&info).Error
	return info, err
}

func GetLastDrugWarehouse(orgid int64) (models.DrugWarehouse, error) {

	info := models.DrugWarehouse{}
	err := XTReadDB().Model(&info).Where("org_id=? and status = 1", orgid).Last(&info).Error
	return info, err
}

func GetLastDrugWarehouseOut(orgid int64) (models.DrugWarehouseOut, error) {

	info := models.DrugWarehouseOut{}
	err := XTReadDB().Model(&info).Where("org_id=? and status = 1", orgid).Last(&info).Error
	return info, err
}

func GetLastDrugWarehouseInfSix(drugid int64) (models.XtDrugWarehouseInfo, error) {

	info := models.XtDrugWarehouseInfo{}
	err := XTReadDB().Model(&info).Where("drug_id=? and status = 1", drugid).Last(&info).Error
	return info, err
}

func GetFirstDrugWarehouseInfo(drugid int64) (models.XtDrugWarehouseInfo, error) {

	info := models.XtDrugWarehouseInfo{}
	err := XTReadDB().Model(&info).Where("id=? and status = 1", drugid).First(&info).Error
	return info, err
}

func GetDrugInventoryDetail(id int64) (models.XtDrugInventory, error) {

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

func ModifyDrugInventory(id int64, info models.XtDrugInventory) error {

	err := XTWriteDB().Model(&info).Where("id=? and status = 1", id).Updates(map[string]interface{}{"drug_name": info.DrugName, "specification_name": info.SpecificationName, "warehousing_unit": info.WarehousingUnit, "count": info.Count, "last_price": info.LastPrice, "manufacturer": info.Manufacturer, "remark": info.Remark, "drug_id": info.DrugId, "warehousing_order": info.WarehousingOrder, "number": info.Number, "total": info.Number, "drug_origin_place": info.DrugOriginPlace, "stock_max_number": info.StockMaxNumber, "stock_min_number": info.StockMinNumber, "warehouse_info_id": info.WarehouseInfoId, "min_count": info.MinCount, "min_unit": info.MinUnit}).Error
	return err
}

func DeleteDrugInventory(id int64) error {
	inventory := models.XtDrugInventory{}
	err := XTWriteDB().Model(&inventory).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"status": 0}).Error
	return err
}

func GetDrugInventoryPrintList(ids []string) (info []*models.XtDrugInventory, err error) {

	err = XTReadDB().Where("id in(?) and status = 1", ids).Find(&info).Error
	return info, err
}

func GetDrugInventoryDetailList(keyword string, page int64, limit int64, orgid int64, storehouse_id int64) (list []*models.VmDrugInventory, total int64, err error) {
	likeKey := "%" + keyword + "%"
	offset := (page - 1) * limit
	db := XTReadDB().Table("xt_drug_inventory as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_base_drug as t").Where("t.status = 1")
	tab := UserReadDB().Table("sgj_user_admin_role as r").Where("r.status = 1")
	fmt.Println(table, tab)
	if len(keyword) > 0 {
		db = db.Where("x.warehousing_order = ? or r.user_name like ? or t.drug_name like ?", keyword, likeKey, likeKey)
	}
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	if storehouse_id > 0 {
		db = db.Where("x.storehouse_id = ?", storehouse_id)
	}
	err = db.Select("x.id,x.drug_name,x.specification_name,x.warehousing_unit,x.count,x.last_price,x.retail_price,x.manufacturer,x.dealer,x.remark,x.drug_id,x.warehousing_order,x.number,x.batch_number,x.start_time,x.creater,x.checker,x.checker_status,x.checker_time,x.total,x.drug_origin_place,x.expiry_date,x.product_date,x.min_count,x.storehouse_id,x.ctime,x.warehouse_info_id,t.dose,t.dose_unit,t.max_unit,x.min_unit,x.stock_max_number,x.stock_min_number,x.last_stock_max_number,x.last_stock_min_number,x.inventory_type,t.min_number,t.retail_price").Joins("left join sgj_users.sgj_user_admin_role as r on r.id = x.creater").Joins("left join xt_base_drug as t on t.id =x.drug_id").Count(&total).Offset(offset).Limit(limit).Order("x.id desc").Scan(&list).Error
	return list, total, err
}

func GetDrugInventoryDetailMapList(keyword string, page int64, limit int64, orgid int64, storehouse_id int64, ids []string) (list []*models.VmDrugInventory, total int64, err error) {
	likeKey := "%" + keyword + "%"
	offset := (page - 1) * limit
	db := XTReadDB().Table("xt_drug_inventory as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_base_drug as t").Where("t.status = 1")
	tab := UserReadDB().Table("sgj_user_admin_role as r").Where("r.status = 1")
	fmt.Println(table, tab)
	if len(keyword) > 0 {
		db = db.Where("x.warehousing_order = ? or r.user_name like ? or t.drug_name like ?", keyword, likeKey, likeKey)
	}
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	if storehouse_id > 0 {
		db = db.Where("x.storehouse_id = ?", storehouse_id)
	}
	if len(ids) > 0 {
		db = db.Where("x.id in(?)", ids)
	}
	err = db.Select("x.id,x.drug_name,x.specification_name,x.warehousing_unit,x.count,x.last_price,x.retail_price,x.manufacturer,x.dealer,x.remark,x.drug_id,x.warehousing_order,x.number,x.batch_number,x.start_time,x.creater,x.checker,x.checker_status,x.checker_time,x.total,x.drug_origin_place,x.expiry_date,x.product_date,x.min_count,x.storehouse_id,x.warehouse_info_id,t.dose,t.dose_unit,t.max_unit,x.min_unit,x.stock_max_number,x.stock_min_number,x.last_stock_max_number,x.last_stock_min_number,x.inventory_type,t.min_number,t.retail_price").Joins("left join sgj_users.sgj_user_admin_role as r on r.id = x.creater").Joins("left join xt_base_drug as t on t.id =x.drug_id").Count(&total).Offset(offset).Limit(limit).Scan(&list).Error
	return list, total, err
}

func GetDrugInventoryDetailListTwo(keyword string, page int64, limit int64, orgid int64, storehouse_id int64) (list []*models.XtDrugInventory, total int64, err error) {

	db := XTReadDB().Model(&list).Where("status = 1")
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if storehouse_id > 0 {
		db = db.Where("storehouse_id = ?", storehouse_id)
	}
	offset := (page - 1) * limit
	err = db.Preload("BaseDrugLib", "org_id = ? and status = 1", orgid).Preload("DrugWarehouseInfo", "org_id = ? and status = 1", orgid).Count(&total).Offset(offset).Limit(limit).Find(&list).Error
	return list, total, err
}

func UpdateDrugProofInventory(id int64, inventory *models.XtDrugInventory) error {

	err := XTWriteDB().Model(&inventory).Where("id=? and status = 1", id).Updates(map[string]interface{}{"warehouse_info_id": inventory.WarehouseInfoId, "proof_count": inventory.ProofCount, "warehousing_unit": inventory.WarehousingUnit, "remark": inventory.Remark}).Error
	return err
}

func UpdateDrugWarehouseInfoById(id int64, inventory *models.XtDrugWarehouseInfo) error {

	err := XTWriteDB().Model(&inventory).Where("id = ?", id).Updates(map[string]interface{}{"stock_max_number": inventory.StockMaxNumber}).Error
	return err
}

func GetDrugWarehouseInfoTotal(id int64) (list []*models.XtDrugWarehouseInfo, err error) {

	err = XTReadDB().Where("id = ? or warehousing_info_id = ? and status = 1", id, id).Preload("XtBaseDrug", "status = 1").Find(&list).Error
	return list, err
}

func CreateDrugWarehouseInfo(info models.DrugWarehouseInfo) error {

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

func CreateDrugWarehouseOutInfo(info models.DrugWarehouseOutInfo) error {

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

func GetDamageByDrugId(drugid int64, warhousingorder string, drugtype int64) (drug []*models.VmXtDrugInventory, err error) {

	db := XTReadDB().Table("xt_drug_inventory").Where("status = 1")

	if drugid > 0 {
		db = db.Where("drug_id = ?", drugid)
	}
	if len(warhousingorder) > 0 {
		db = db.Where("warehousing_order = ?", warhousingorder)
	}
	if drugtype > 0 {
		db = db.Where("type = ?", drugtype)
	}
	if drugtype == 0 {
		db = db.Where("type = 4")
	}

	err = db.Preload("XtBaseDrug", "status = 1").Find(&drug).Error
	return drug, err
}

func GetInventoryModeList(orgid int64) (info []*models.PatientDrugWarehouseInfo, err error) {

	db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_base_drug as t").Where("t.status = 1")
	fmt.Println(table)
	if orgid > 0 {
		db = db.Where("x.org_id = ?", orgid)
	}
	err = db.Select("x.drug_id,x.number,x.product_date,x.expiry_date,x.stock_max_number,x.stock_min_number,x.batch_number,t.drug_name,t.max_unit,t.min_unit,t.min_number,t.dose,t.dose_unit,x.manufacturer,x.dealer").Joins("left join xt_base_drug as t on t.id = x.drug_id").Group("x.drug_id,x.batch_number").Scan(&info).Error
	return info, err
}

func GetManufacturerListByKeyword(orgid int64, keyword string) (list []*models.BloodManufacturer, err error) {

	likeKey := "%" + keyword + "%"
	db := XTReadDB().Model(&list).Where("status = 1")
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if len(keyword) > 0 {
		db = db.Where("manufacturer_name like ?", likeKey)
	}
	err = db.Find(&list).Error
	return list, err
}

func GetGoodNameByword(orgid int64, keyword string) (list []*models.GoodInfo, err error) {
	likeKey := "%" + keyword + "%"
	db := XTReadDB().Model(&list).Where("status = 1")
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if len(keyword) > 0 {
		db = db.Where("good_name like ?", likeKey)
	}
	err = db.Find(&list).Error
	return list, err
}

func GetDrugNameByword(orgid int64, keyword string) (list []*models.XtBaseDrug, err error) {
	likeKey := "%" + keyword + "%"
	db := XTReadDB().Model(&list).Where("status = 1")
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if len(keyword) > 0 {
		db = db.Where("drug_name like ?", likeKey)
	}
	err = db.Find(&list).Error
	return list, err
}

func GetGoodWarehouseInfoByOrgId(orgid int64, storehouse_id int64) (info []*models.WarehousingInfo, err error) {
	db := XTReadDB().Model(&info).Where("is_check =1 and status =1")
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}

	if storehouse_id > 0 {
		db = db.Where("storehouse_id = ?", storehouse_id)
	}
	err = db.Group("good_id").Find(&info).Error
	return info, err
}

func GetGoodWarehouseInfoByOrgIdTwo(orgid int64) (info []*models.GoodQueryNewWarehousingInfo, err error) {
	db := XTReadDB().Model(&info).Where("is_check =1 and status =1")
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	err = db.Group("good_id").Find(&info).Error
	return info, err
}

func GetGoodNewQuery(orgId int64, storehouse_id int64, good_type int64, keyword string, page int64, limit int64, ids []int64, goodIds []int64, startime int64, endtime int64) (good []*models.NewGoodInformation, total int64, err error) {

	offset := (page - 1) * limit
	likeKey := "%" + keyword + "%"

	db := XTReadDB().Table("xt_good_information as x").Where("x.status = 1 and x.total_count > 0 and x.org_id =?", orgId)

	if good_type == 2 {
		db = db.Where(" x.total_count<=x.stock_warn_count")
	}

	if len(goodIds) > 0 {
		db = db.Where("id in(?)", goodIds)
	}

	if len(keyword) > 0 {
		db = db.Where("good_name like ? or manufacturer in(?)", likeKey, ids)
	}

	err = db.Count(&total).Offset(offset).Limit(limit).Order("x.ctime desc").Find(&good).Error

	return good, total, err
}

func FindGoodWarehouseInfoGroup(good_id int64, orgid int64, storhouse_id int64, startime int64, endtime int64) (info []*models.WarehousingInfo, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and is_check = 1")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if storhouse_id > 0 {
		db = db.Where("storehouse_id = ?", storhouse_id)
	}

	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime<=?", endtime)
	}
	db.Group("storehouse_id").Find(&info)
	return info, err
}

func FindGoodWarehouseInfo(good_id int64, orgid int64, storhouse_id int64, startime int64, endtime int64) (info []*models.WarehousingInfo, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and is_check = 1")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if storhouse_id > 0 {
		db = db.Where("storehouse_id = ?", storhouse_id)
	}

	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime<=?", endtime)
	}
	db.Find(&info)
	return info, err
}

func FindGoodWarehouseOutInfo(good_id int64, orgid int64, storhouse_id int64, startime int64, endtime int64) (out []*models.WarehouseOutInfo, err error) {

	db := XTReadDB().Model(&out).Where("status = 1 and is_check = 1")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if storhouse_id > 0 {
		db = db.Where("storehouse_id = ?", storhouse_id)
	}
	if startime > 0 {
		db = db.Where("ctime>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime<=?", endtime)
	}
	err = db.Find(&out).Error
	return out, err
}

func FindCancelStockInfo(good_id int64, orgid int64, storhouse_id int64, startime int64, endtime int64) (info []*models.CancelStockInfo, err error) {
	db := XTReadDB().Model(&info).Where("status = 1 and is_check = 1")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if storhouse_id > 0 {
		db = db.Where("storehouse_id = ?", storhouse_id)
	}
	if startime > 0 {
		db = db.Where("ctime>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime<=?", endtime)
	}
	err = db.Find(&info).Error
	return info, err
}

func FindGoodStockOutFlow(good_id int64, user_org_id int64, storhouse_id int64, startime int64, endtime int64) (info []*models.VmStockFlow, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and (consumable_type = 2 or consumable_type = 3)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if storhouse_id > 0 {
		db = db.Where("storehouse_id = ?", storhouse_id)
	}
	if startime > 0 {
		db = db.Where("ctime >= ?", storhouse_id)
	}
	if endtime > 0 {
		db = db.Where("ctime <= ?", storhouse_id)
	}
	err = db.Find(&info).Error

	return info, err
}

func FindGoodCancelFlow(good_id int64, user_org_id int64, storhouse_id int64, startime int64, endtime int64) (info []*models.VmStockFlow, err error) {
	db := XTReadDB().Model(&info).Where("status = 1 and (consumable_type = 4 or consumable_type = 7)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if storhouse_id > 0 {
		db = db.Where("storehouse_id = ?", storhouse_id)
	}
	if startime > 0 {
		db = db.Where("ctime >= ?", storhouse_id)
	}
	if endtime > 0 {
		db = db.Where("ctime <= ?", storhouse_id)
	}
	err = db.Find(&info).Error

	return info, err
}

func GetGoodWarehouseOutInfoByIdList(good_id int64, limit int64, page int64, orgid int64, startime int64, endtime int64, storehouse_id int64) (info []*models.WarehouseOutInfo, total int64, err error) {

	db := XTReadDB().Model(&info).Where("status = 1")
	offset := (page - 1) * limit
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("org_id =?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime<=?", endtime)
	}
	if storehouse_id > 0 {
		db = db.Where("storehouse_id = ?", storehouse_id)
	}
	err = db.Count(&total).Offset(offset).Limit(limit).Preload("VmStockFlow", "status = 1 and user_org_id = ?", orgid).Preload("GoodInfo", "status = 1 and org_id = ?", orgid).Order("id desc").Find(&info).Error
	return info, total, err
}

func GetStockFlushByGoodId(good_id int64, org_id int64, startime int64, endtime int64) (flushinfo []*models.XtWarehouseFlushInfo, err error) {

	db := XTReadDB().Model(&models.XtWarehouseFlushInfo{}).Where("status = 1 and type = 1")

	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if org_id > 0 {
		db = db.Where("user_org_id = ?", org_id)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime<=?", endtime)
	}

	err = db.Find(&flushinfo).Error
	return flushinfo, err
}

func GetGoodWarehouseOutInfoByIdListTwenty(good_id int64, limit int64, page int64, orgid int64, startime int64, endtime int64) (info []*models.WarehouseOutInfo, err error) {
	db := XTReadDB().Model(&info).Where("status = 1")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("org_id =?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime<=?", endtime)
	}
	err = db.Find(&info).Error
	return info, err
}

func GetGoodWarehouseInfoByList(goodid int64, orgid int64, startime int64, endtime int64) (info []*models.WarehousingInfo, err error) {

	db := XTReadDB().Model(&info).Where("status= 1 and is_check = 1")
	if goodid > 0 {
		db = db.Where("good_id = ?", goodid)
	}
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	err = db.Find(&info).Error
	return info, err
}

func GetGoodCancelStockInfoByList(goodid int64, orgid int64, startime int64, endtime int64) (info []*models.CancelStockInfo, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and is_check = 1")
	if goodid > 0 {
		db = db.Where("good_id = ?", goodid)
	}
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	err = db.Find(&info).Error
	return info, err
}

func GetGoodPatientList(orgid int64, keyword string) (patient []*models.XtPatients, err error) {

	likeKey := "%" + keyword + "%"
	if len(keyword) > 0 {
		err = XTReadDB().Where("user_org_id = ? and status = 1 and name like ?", orgid, likeKey).Find(&patient).Error
	} else {
		err = XTReadDB().Where("user_org_id = ? and status = 1", orgid).Find(&patient).Error
	}
	return patient, err
}

func GetWarehouseOutDetailByPatientIdOne(orgid int64, patient_id int64, startime int64, endtime int64, limit int64, page int64) (info []*models.WarehouseOutInfo, total int64, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and (is_sys = 1 or is_sys = 5)")
	offset := (page - 1) * limit
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if patient_id > 0 {
		db = db.Where("patient_id = ?", patient_id)
	}
	if startime > 0 {
		db = db.Where("ctime>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime<=?", endtime)
	}
	err = db.Group("good_id").Preload("GoodInfo", "org_id = ? and status = 1", orgid).Count(&total).Offset(offset).Limit(limit).Find(&info).Error
	return info, total, err
}

func GetWarehouseOutDetailByPatientId(orgid int64, patient_id int64, startime int64, endtime int64) (info []*models.WarehouseOutInfo, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and (is_sys = 1 or is_sys =5)")
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if patient_id > 0 {
		db = db.Where("patient_id = ?", patient_id)
	}
	if startime > 0 {
		db = db.Where("ctime>=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime<=?", endtime)
	}
	err = db.Preload("GoodInfo", "org_id = ? and status = 1", orgid).Find(&info).Error
	return info, err
}

func GetGoodExpiryDateQuery(storehouse_id int64, expiry_type int64, keyword string, page int64, limit int64, orgid int64, ids []int64, goodIds []int64, startime int64, endtime int64) (info []*models.WarehousingInfo, total int64, err error) {

	offset := (page - 1) * limit
	db := XTReadDB().Table("xt_warehouse_info as x").Where("x.status = 1 and x.is_check = 1 and x.stock_count >0")

	if storehouse_id > 0 {
		db = db.Where("x.storehouse_id = ?", storehouse_id)
	}
	//已过期
	if expiry_type == 1 {
		db = db.Where("x.expiry_date < ?", startime)
	}

	if expiry_type > 1 {
		db = db.Where("x.expiry_date > ? and x.expiry_date<=?", startime, endtime)
	}

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

	if len(keyword) > 0 {
		db = db.Where("x.manufacturer in(?) or x.good_id in(?)", ids, goodIds)
	}

	err = db.Count(&total).Offset(offset).Limit(limit).Preload("GoodInfo", "org_id = ? and status = 1", orgid).Find(&info).Error
	return info, total, err
}

func GetGoodPurchaseStockQuery(good_type int64, keyword string, page int64, limit int64, orgid int64, ids []int64, goodIds []int64) (goodinfo []*models.GoodInfoTwenty, total int64, err error) {

	db := XTReadDB().Model(&goodinfo).Where("status = 1 and total_count > 0")
	offset := (page - 1) * limit
	likeKey := "%" + keyword + "%"
	if good_type > 0 {
		db = db.Where("good_type_id = ?", good_type)
	}

	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if len(ids) > 0 {
		db = db.Where("id in(?)", goodIds)
	}
	if len(keyword) > 0 {
		db = db.Where("good_name like ? or manufacturer in(?)", likeKey, ids)
	}
	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Find(&goodinfo).Error

	return goodinfo, total, err
}

func GetDrugWarehouseOutDetailByPatientIdOne(patient_id int64, orgid int64, startime int64, endtime int64, page int64, limit int64) (info []*models.DrugWarehouseOutInfo, total int64, err error) {

	db := XTReadDB().Model(&info).Where("status = 1")
	offset := (page - 1) * limit
	if patient_id > 0 {
		db = db.Where("patient_id = ?", patient_id)
	}
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("sys_record_time >= ?", startime)
	}
	if endtime > 0 {
		db = db.Where("sys_record_time <= ?", endtime)
	}

	err = db.Group("drug_id").Count(&total).Offset(offset).Limit(limit).Preload("BaseDrugLib", "status = 1 and org_id = ?", orgid).Find(&info).Error
	return
}

func GetDrugWarehouseOutDetailByPatientId(patient_id int64, orgid int64, startime int64, endtime int64) (info []*models.DrugWarehouseOutInfo, err error) {

	db := XTReadDB().Model(&info).Where("status = 1")
	if patient_id > 0 {
		db = db.Where("patient_id = ?", patient_id)
	}
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("sys_record_time >= ?", startime)
	}
	if endtime > 0 {
		db = db.Where("sys_record_time <= ?", endtime)
	}

	err = db.Preload("BaseDrugLib", "status = 1 and org_id = ?", orgid).Find(&info).Error
	return
}

func GetDrugExpiryDateQuery(storehouse_id int64, expiry_type int64, keyword string, page int64, limit int64, orgid int64, ids []int64, goodIds []int64, startime int64, endtime int64) (info []*models.XtDrugWarehouseInfo, total int64, err error) {

	offset := (page - 1) * limit
	db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1 and x.is_check = 1 and (x.stock_max_number>0 or x.stock_min_number >0)")

	if storehouse_id > 0 {
		db = db.Where("x.storehouse_id = ?", storehouse_id)
	}
	//已过期
	if expiry_type == 1 {
		db = db.Where("x.expiry_date < ?", startime)
	}

	if expiry_type > 1 {
		db = db.Where("x.expiry_date > ? and x.expiry_date<=?", startime, endtime)
	}

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

	if len(keyword) > 0 {
		db = db.Where("x.manufacturer in(?) or x.drug_id in(?)", ids, goodIds)
	}

	err = db.Count(&total).Offset(offset).Limit(limit).Preload("XtBaseDrug", "org_id = ? and status = 1", orgid).Find(&info).Error
	return info, total, err
}

func GetDrugPurchaseStockQuery(good_type int64, keyword string, page int64, limit int64, orgid int64, startime int64, endtime int64, ids []int64, infos []int64) (druginfo []*models.VmBaseDrugTwenty, total int64, err error) {

	db := XTReadDB().Model(&druginfo).Where("status = 1")
	offset := (page - 1) * limit
	likeKey := "%" + keyword + "%"
	if good_type > 0 {
		db = db.Where("drug_type = ?", good_type)
	}

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

	if len(keyword) > 0 {
		db = db.Where("drug_name like ? or manufacturer in(?)", likeKey, ids)
	}
	if len(infos) > 0 {
		db = db.Where("id in(?)", infos)
	}
	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Find(&druginfo).Error

	return druginfo, total, err
}

func GetDrugWarehouseInfoByOrgId(orgid int64, storehouse_id int64) (info []*models.XtDrugWarehouseInfo, err error) {

	db := XTReadDB().Model(&info).Where("is_check = 1 and status = 1")
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if storehouse_id > 0 {
		db = db.Where("storehouse_id = ?", storehouse_id)
	}
	err = db.Group("drug_id").Find(&info).Error
	return info, err
}

func GetDrugWarehouseInfoByOrgIdTwo(orgid int64) (info []*models.XtDrugWarehouseInfo, err error) {

	db := XTReadDB().Model(&info).Where("is_check = 1 and status = 1")
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	err = db.Group("drug_id").Find(&info).Error
	return info, err
}

func GetDrugNewQuery(orgId int64, storehouse_id int64, good_type int64, keyword string, page int64, limit int64, ids []int64, goodIds []int64, startime int64, endtime int64) (drug []*models.VmBaseDrug, total int64, err error) {

	offset := (page - 1) * limit
	likeKey := "%" + keyword + "%"
	db := XTReadDB().Table("xt_base_drug as x").Where("x.status = 1")
	if good_type == 2 {
		db = db.Where("x.total_count<=x.drug_stock_limit")
	}
	if storehouse_id > 0 {
		db = db.Preload("DrugWarehouseInfo", "org_id = ? and status = 1 and storehouse_id = ? and is_check = 1", orgId, storehouse_id)

	} else {
		db = db.Preload("DrugWarehouseInfo", "org_id = ? and status = 1 and is_check = 1", orgId)
	}

	if len(goodIds) > 0 {
		db = db.Where("id in(?)", goodIds)
	}

	if len(keyword) > 0 {
		db = db.Where("drug_name like ? or manufacturer in(?)", likeKey, ids)
	}

	if orgId > 0 {
		db = db.Where("x.org_id = ?", orgId)
	}
	err = db.Count(&total).Offset(offset).Limit(limit).Preload("DrugWarehouse", func(db *gorm.DB) *gorm.DB {
		if startime > 0 {
			db = db.Where("ctime>=?", startime)
		}
		if endtime > 0 {
			db = db.Where("ctime<=?", endtime)
		}
		if storehouse_id > 0 {
			db = db.Where("storehouse_id = ?", storehouse_id)
		}
		return db.Where("status = 1").Group("drug_id,storehouse_id")
	}).Preload("DrugCancelStockInfo", func(db *gorm.DB) *gorm.DB {
		if startime > 0 {
			db = db.Where("ctime>=?", startime)
		}
		if endtime > 0 {
			db = db.Where("ctime<=?", endtime)
		}
		return db.Where("status = 1")
	}).Preload("DrugWarehouseOutInfo", func(db *gorm.DB) *gorm.DB {
		if startime > 0 {
			db = db.Where("ctime>=?", startime)
		}
		if endtime > 0 {
			db = db.Where("ctime<=?", endtime)
		}
		return db.Where("status = 1")
	}).Preload("DrugFlowWarehouseInfo", func(db *gorm.DB) *gorm.DB {
		if startime > 0 {
			db = db.Where("ctime>=?", startime)
		}
		if endtime > 0 {
			db = db.Where("ctime<=?", endtime)
		}
		if storehouse_id > 0 {
			db = db.Where("storehouse_id = ?", storehouse_id)
		}

		return db.Where("status = 1  and (consumable_type = 2 or consumable_type = 3) and user_org_id = ?", orgId)
	}).Preload("DrugActFlowWarehouseInfo", func(db *gorm.DB) *gorm.DB {
		if startime > 0 {
			db = db.Where("ctime>=?", startime)
		}
		if endtime > 0 {
			db = db.Where("ctime<=?", endtime)
		}
		if storehouse_id > 0 {
			db = db.Where("storehouse_id = ?", storehouse_id)
		}

		return db.Where("status = 1  and (consumable_type = 2 or consumable_type = 3) and user_org_id = ?", orgId)
	}).Order("x.ctime desc").Find(&drug).Error

	return drug, total, err
}

func GetDrugStockCountList(orgId int64, storehouse_id int64, good_type int64, keyword string, page int64, limit int64, ids []int64, goodIds []int64, startime int64, endtime int64) (drug []*models.NewBaseDrugOne, total int64, err error) {

	offset := (page - 1) * limit
	likeKey := "%" + keyword + "%"
	db := XTReadDB().Table("xt_base_drug as x").Where("x.status = 1 AND find_in_set('停用',x.drug_status) = 0")
	if good_type == 2 {
		db = db.Where("x.total_count<=x.drug_stock_limit")
	}
	if good_type == 3 {
		db = db.Where("x.sum_count = 0")
	}

	if good_type == 4 {
		db = db.Where("x.sum_count > 0")
	}
	if storehouse_id > 0 {
		db = db.Preload("DrugWarehouseInfo", "org_id = ? and status = 1 and storehouse_id = ? and is_check = 1", orgId, storehouse_id)

	} else {
		db = db.Preload("DrugWarehouseInfo", "org_id = ? and status = 1 and is_check = 1", orgId)
	}

	if len(keyword) > 0 {
		db = db.Where("drug_name like ? or manufacturer in(?)", likeKey, ids)
	}

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

	if orgId == 10489 {
		err = db.Preload("XtDrugStockCount", func(db *gorm.DB) *gorm.DB {
			if storehouse_id > 0 {
				db = db.Where("storehouse_id = ?", storehouse_id)
			}
			return db.Where("status = 1 and user_org_id = ?", orgId)

		}).Preload("DrugStockCount", func(db *gorm.DB) *gorm.DB {
			if storehouse_id > 0 {
				db = db.Where("storehouse_id = ?", storehouse_id)
			}
			return db.Where("status = 1 and user_org_id = ?", orgId).Group("drug_id,storehouse_id")

		}).Count(&total).Offset(offset).Limit(limit).Order("x.sum_count desc").Find(&drug).Error
	} else {
		err = db.Preload("XtDrugStockCount", func(db *gorm.DB) *gorm.DB {
			if storehouse_id > 0 {
				db = db.Where("storehouse_id = ?", storehouse_id)
			}
			return db.Where("status = 1 and user_org_id = ?", orgId)

		}).Preload("DrugStockCount", func(db *gorm.DB) *gorm.DB {
			if storehouse_id > 0 {
				db = db.Where("storehouse_id = ?", storehouse_id)
			}
			return db.Where("status = 1 and user_org_id = ?", orgId).Group("drug_id,storehouse_id")

		}).Count(&total).Offset(offset).Limit(limit).Order("x.ctime desc").Find(&drug).Error
	}

	return drug, total, err
}

func GetDrugWarehouseOutInfoByIdList(good_id int64, limit int64, page int64, orgid int64, startime int64, endtime int64, storehouse_id int64) (info []*models.DrugWarehouseOutInfo, total int64, err error) {

	db := XTReadDB().Model(&info).Where("status = 1")
	offset := (page - 1) * limit
	if good_id > 0 {
		db = db.Where("drug_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("org_id =?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime<=?", endtime)
	}
	if storehouse_id > 0 {
		db = db.Where("storehouse_id = ?", storehouse_id)
	}
	err = db.Count(&total).Offset(offset).Limit(limit).Preload("BaseDrugLib", "status=1 and org_id = ?", orgid).Order("id desc").Find(&info).Error
	return info, total, err
}

func GetAllGoodListSeven(orgid int64) (good []*models.GoodInfoSeven, err error) {

	err = XTReadDB().Where("org_id = ? and status = 1", orgid).Find(&good).Error

	return good, err
}

func GetAllGoodListEight(orgid int64) (good []*models.GoodInfoSeven, err error) {

	err = XTReadDB().Where("org_id = ? and status = 1  AND find_in_set('停用',good_status) = 0", orgid).Find(&good).Error
	return good, err
}

func GetGoodInformationWarehouseInfo(good_id int64, orgid int64) (info []*models.WarehousingInfoTen, err error) {

	err = XTReadDB().Where("good_id = ? and org_id = ? and status = 1 and is_check = 1 and stock_count > 0", good_id, orgid).Find(&info).Error
	return info, err
}

func UpdateGoodInformation(id int64, orgid int64, total_count int64) error {

	err := XTWriteDB().Model(&models.GoodInfoTen{}).Where("id = ? and org_id = ? and status = 1", id, orgid).Update(map[string]interface{}{"total_count": total_count}).Error
	return err
}

func UpdateGoodListCount(user_org_id int64, over_count int64, good_id int64, sotrehouse_id int64) error {

	err := XTWriteDB().Model(&models.XtGoodStockCount{}).Where("status=1 and user_org_id =? and good_id =? and storehouse_id=?", user_org_id, good_id, sotrehouse_id).Update(map[string]interface{}{"stock_out_count": over_count}).Error

	return err

}

func UpdateGoodListCountOne(user_org_id int64, over_count int64, good_id int64, storehouse_id int64) error {

	err = XTWriteDB().Model(&models.XtGoodStockCount{}).Where("status=1 and user_org_id =? and good_id = ? and storehouse_id = ?", user_org_id, good_id, storehouse_id).Update(map[string]interface{}{"stock_act_out_count": over_count}).Error
	return err

}

func GetBaseDrugName(orgid int64) (drug []*models.BaseDrugLibTwenty, err error) {

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

func GetDrugWarehouseInfoName(drugid int64, orgid int64) (info []*models.DrugWarehouseInfoTen, err error) {

	err = XTReadDB().Where("drug_id = ? and org_id = ? and is_check = 1 and (stock_max_number >0 or stock_min_number > 0) and status = 1", drugid, orgid).Find(&info).Error
	return info, err
}

func UpdateDrugById(id int64, orgid int64, limit_count int64, total_count int64) error {

	err := XTWriteDB().Model(&models.BaseDrugLibTen{}).Where("id = ? and org_id = ? and status = 1", id, orgid).Update(map[string]interface{}{"drug_stock_limit_count": limit_count, "total_count": total_count}).Error
	return err
}

func GetDrugFlowFlush(drugid int64, org_id int64, startime int64, endtime int64) (info []*models.XtDrugWarehouseFlushInfo, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and type = 1")
	if drugid > 0 {
		db = db.Where("drug_id = ?", drugid)
	}
	if org_id > 0 {
		db = db.Where("user_org_id = ?", org_id)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}
	err = db.Find(&info).Error
	return info, err
}

func GetDrugFlowFlushOne(drugid int64, org_id int64, startime int64, endtime int64) (info []*models.XtDrugWarehouseFlushInfo, err error) {

	db := XTReadDB().Model(&info).Where("status = 0 and type = 1")
	if drugid > 0 {
		db = db.Where("drug_id = ?", drugid)
	}
	if org_id > 0 {
		db = db.Where("user_org_id = ?", org_id)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}
	err = db.Find(&info).Error
	return info, err
}

func GetStartGoodWarehouseInfoList(good_id int64, orgid int64, startime int64) (info []*models.StartWarehousingInfo, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and is_check =1")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime <?", startime)
	}
	err = db.Find(&info).Error
	return info, err
}

func GetEndGoodWarehouseInfoList(good_id int64, orgid int64, endtime int64) (info []*models.StartWarehousingInfo, err error) {
	db := XTReadDB().Model(&info).Where("status = 1 and is_check =1")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}
	err = db.Find(&info).Error
	return info, err
}

func GetAddGoodWarehouseInfoList(good_id int64, orgid int64, startime int64, endtime int64, storehouse_id int64) (info []*models.StartWarehousingInfo, err error) {
	db := XTReadDB().Model(&info).Where("status = 1 and is_check =1")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}
	if storehouse_id > 0 {
		db = db.Where("storehouse_id = ?", storehouse_id)
	}
	err = db.Find(&info).Error
	return info, err
}

func GetAddGoodWarehouseInfoListTwenty(good_id int64, orgid int64, startime int64, endtime int64) (info []*models.StartWarehousingInfo, err error) {
	db := XTReadDB().Model(&info).Where("status = 1 and is_check =1")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}
	err = db.Find(&info).Error
	return info, err
}

func GetAddStartFlow(good_id int64, orgid int64, startime int64, endtime int64, storehouse_id int64) (info []*models.VmStockFlowTwenty, err error) {
	db := XTReadDB().Model(&info).Where("status = 1 and (consumable_type =1 or consumable_type = 13)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}
	if storehouse_id > 0 {
		db = db.Where("storehouse_id =?", storehouse_id)
	}
	err = db.Find(&info).Error
	return info, err
}

func GetAddStartFlowTwenty(good_id int64, orgid int64, startime int64, endtime int64) (info []*models.VmStockFlowTwenty, err error) {
	db := XTReadDB().Model(&info).Where("status = 1 and (consumable_type =1)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}

	err = db.Find(&info).Error
	return info, err
}

func GetReduceWarehouseInfoList(good_id int64, orgid int64, startime int64, endtime int64, storehouse_id int64) (outinfo []*models.VmStockFlowTwenty, err error) {
	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 2 or consumable_type = 3 or consumable_type= 15)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}
	if storehouse_id > 0 {
		db = db.Where("storehouse_id = ?", storehouse_id)
	}
	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&outinfo).Error
	return outinfo, err
}

func GetReduceWarehouseInfoListTwenty(good_id int64, orgid int64, startime int64, endtime int64) (outinfo []*models.VmStockFlowTwenty, err error) {
	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 2 or consumable_type = 3 or consumable_type= 15)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}
	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&outinfo).Error
	return outinfo, err
}

func GetStartEndCancelFLowInfo(good_id int64, orgid int64, startime int64, endtime int64, storehouse_id int64) (outinfo []*models.VmStockFlowTwenty, err error) {
	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 7)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}
	if storehouse_id > 0 {
		db = db.Where("storehouse_id =?", storehouse_id)
	}
	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&outinfo).Error
	return outinfo, err
}

func GetStartEndCancelFLowInfoTwenty(good_id int64, orgid int64, startime int64, endtime int64) (outinfo []*models.VmStockFlowTwenty, err error) {
	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 7)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}
	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&outinfo).Error
	return outinfo, err
}

func FindeStartFlowInfo(good_id int64, orgid int64, startime int64) (info []*models.VmStockFlowTwenty, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and consumable_type = 1")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime <?", startime)
	}
	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&info).Error
	return info, err
}

func FindeStartFlowOutInfo(good_id int64, orgid int64, startime int64) (info []*models.VmStockFlowTwenty, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and  (consumable_type = 2 or consumable_type = 3)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime <?", startime)
	}
	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&info).Error
	return info, err
}

func FindeStartCancelInfo(good_id int64, orgid int64, startime int64) (info []*models.VmStockFlowTwenty, err error) {
	db := XTReadDB().Model(&info).Where("status = 1 and  (consumable_type = 4 or consumable_type = 7)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime <?", startime)
	}
	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&info).Error
	return info, err
}

func FindEndStartFlowInfo(good_id int64, orgid int64, endtime int64) (info []*models.VmStockFlowTwenty, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and consumable_type = 1")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}
	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&info).Error
	return info, err
}

func FindeEndFLowOutInfo(good_id int64, orgid int64, endtime int64) (info []*models.VmStockFlowTwenty, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and  (consumable_type = 2 or consumable_type = 3)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if endtime > 0 {
		db = db.Where("ctime <?", endtime)
	}
	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&info).Error
	return info, err
}

func FindEndCancelInfo(good_id int64, orgid int64, endtime int64) (info []*models.VmStockFlowTwenty, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and  (consumable_type = 4 or consumable_type = 7)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if endtime > 0 {
		db = db.Where("ctime <?", endtime)
	}
	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&info).Error
	return info, err
}

func FindeWarehouseOutInfo(good_id int64, orgid int64, startime int64, storehouse_id int64) (outinfo []*models.VmStockFlowTwenty, err error) {

	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 2 or consumable_type = 3 or consumable_type = 15)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime <?", startime)
	}
	if storehouse_id > 0 {
		db = db.Where("storehouse_id= ?", storehouse_id)
	}
	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&outinfo).Error
	return outinfo, err
}

func FindeWarehouseOutInfoTwenty(good_id int64, orgid int64, startime int64) (outinfo []*models.VmStockFlowTwenty, err error) {

	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 2 or consumable_type = 3 or consumable_type = 15)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime <?", startime)
	}

	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&outinfo).Error
	return outinfo, err
}

func FindeStartStockInventoryProfit(good_id int64, orgid int64, startime int64) (outinfo []*models.VmStockFlowTwenty, err error) {

	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 10)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime <?", startime)
	}
	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&outinfo).Error
	return outinfo, err
}

func FindeEndStokInventoryProfit(good_id int64, orgid int64, startime int64, endtime int64, storehouse_id int64) (outinfo []*models.VmStockFlowTwenty, err error) {

	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 10)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}
	if storehouse_id > 0 {
		db = db.Where("storehouse_id = ?", storehouse_id)
	}
	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&outinfo).Error
	return outinfo, err
}

func FindeEndStokInventoryProfitTwenty(good_id int64, orgid int64, startime int64, endtime int64) (outinfo []*models.VmStockFlowTwenty, err error) {

	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 10)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}

	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&outinfo).Error
	return outinfo, err
}

func FindeEndStockInventoryLosses(good_id int64, orgid int64, startime int64, endtime int64, storehouse_id int64) (outinfo []*models.VmStockFlowTwenty, err error) {
	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 11)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}
	if storehouse_id > 0 {
		db = db.Where("storehouse_id = ?", storehouse_id)
	}
	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&outinfo).Error
	return outinfo, err
}

func FindeEndStockInventoryLossesTwenty(good_id int64, orgid int64, startime int64, endtime int64) (outinfo []*models.VmStockFlowTwenty, err error) {
	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 11)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}

	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&outinfo).Error
	return outinfo, err
}

func FindStartStockInventoryLosses(good_id int64, orgid int64, startime int64) (outinfo []*models.VmStockFlowTwenty, err error) {

	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 11)")
	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startime > 0 {
		db = db.Where("ctime <?", startime)
	}
	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&outinfo).Error
	return outinfo, err
}

func GetDrugWarehouseInfoStart(drug_id int64, orgid int64, startTime int64) (info []*models.DrugFlowTwenty, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and  consumable_type=1 ")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startTime > 0 {
		db = db.Where("ctime<?", startTime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "org_id =? and status = 1", orgid).Find(&info).Error
	return info, err
}

func DrugWarehouseInfoEnd(drug_id int64, orgid int64, endTime int64) (info []*models.DrugFlowTwenty, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and consumable_type = 1")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if endTime > 0 {
		db = db.Where("ctime<=?", endTime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "org_id =? and status = 1", orgid).Find(&info).Error
	return info, err
}

func DrugWarehouseOutInfoEnd(drug_id int64, orgid int64, endTime int64) (info []*models.DrugFlowTwenty, err error) {

	db := XTReadDB().Model(&info).Where("status = 1 and (consumable_type = 2 or consumable_type= 3 or consumable_type= 15)")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if endTime > 0 {
		db = db.Where("ctime<=?", endTime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "org_id =? and status = 1", orgid).Find(&info).Error
	return info, err
}

func GetEndDrugFlowCancelInfo(drug_id int64, orgid int64, endTime int64) (info []*models.DrugFlowTwenty, err error) {
	db := XTReadDB().Model(&info).Where("status = 1 and (consumable_type = 4 or consumable_type= 7)")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if endTime > 0 {
		db = db.Where("ctime<=?", endTime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "org_id =? and status = 1", orgid).Find(&info).Error
	return info, err
}

func GetDrugWarehouseStartEnd(drug_id int64, orgid int64, startTime int64, endTime int64) (info []*models.DrugFlowTwenty, err error) {
	db := XTReadDB().Model(&info).Where("status = 1 and  consumable_type = 1")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startTime > 0 {
		db = db.Where("ctime>=?", startTime)
	}
	if endTime > 0 {
		db = db.Where("ctime<=?", endTime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "org_id =? and status = 1", orgid).Find(&info).Error
	return info, err
}

func FindeDrugWarehouseOutInfo(drug_id int64, orgid int64, startTime int64, endTime int64) (info []*models.DrugFlowTwenty, err error) {
	db := XTReadDB().Model(&info).Where("status = 1  and (consumable_type = 2 or consumable_type= 3 or consumable_type= 15 )")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startTime > 0 {
		db = db.Where("ctime>=?", startTime)
	}
	if endTime > 0 {
		db = db.Where("ctime<=?", endTime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "status= 1 and org_id = ?", orgid).Find(&info).Error
	return info, err
}

func FindStartEndDrugWarehouseOutInfo(drug_id int64, orgid int64, startTime int64, endTime int64) (info []*models.DrugFlowTwenty, err error) {
	db := XTReadDB().Model(&info).Where("status = 1  and (consumable_type= 7)")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startTime > 0 {
		db = db.Where("ctime>=?", startTime)
	}
	if endTime > 0 {
		db = db.Where("ctime<=?", endTime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "status= 1 and org_id = ?", orgid).Find(&info).Error
	return info, err
}

func FindeDrugWarehouseOutStart(drug_id int64, orgid int64, startTime int64) (info []*models.DrugFlow, err error) {
	db := XTReadDB().Model(&info).Where("status = 1  and (consumable_type = 2 or consumable_type= 3)")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if orgid > 0 {
		db = db.Where("user_org_id = ?", orgid)
	}
	if startTime > 0 {
		db = db.Where("ctime <?", startTime)
	}

	err = db.Preload("DrugWarehouseInfoOne", "status= 1 and org_id = ?", orgid).Find(&info).Error
	return info, err
}

func GetHisPrescriptionProjectByOrgId(orgid int64) (project []*models.HisPrescriptionProject, err error) {

	err = XTReadDB().Where("user_org_id = ? and status = 0 and type = 3", orgid).Find(&project).Error
	return project, err
}

func GetPatientStockFlow(patient_id int64, record_date int64, good_id int64) (models.VmStockFlow, error) {

	flow := models.VmStockFlow{}
	err = XTReadDB().Where("patient_id = ? and system_time = ? and good_id = ?", patient_id, record_date, good_id).Find(&flow).Error
	return flow, err
}

func ModifyPatientStockFlow(id int64, flow models.VmStockFlow) error {

	err = XTReadDB().Model(&models.VmStockFlow{}).Where("id = ?", id).Updates(map[string]interface{}{"count": flow.Count, "status": 1, "is_read": 1}).Error
	return err
}

func GetDrugFlowSart(drug_id int64, user_org_id int64, ctime int64) (flow []*models.DrugFlow, err error) {

	db := XTReadDB().Model(&flow).Where("status = 1 and consumable_type = 1")

	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if ctime > 0 {
		db = db.Where("ctime <?", ctime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "org_id =? and status = 1", user_org_id).Find(&flow).Error
	return flow, err
}

func GetDrugFlowOut(drug_id int64, user_org_id int64, ctime int64) (flow []*models.DrugFlowTwenty, err error) {

	db := XTReadDB().Model(&flow).Where("status = 1  and (consumable_type = 2 or consumable_type= 3 or consumable_type= 15)")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if ctime > 0 {
		db = db.Where("ctime <?", ctime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "org_id =? and status = 1", user_org_id).Find(&flow).Error
	return flow, err
}

func GetStartDrugFlowCancelInfo(drug_id int64, user_org_id int64, ctime int64) (flow []*models.DrugFlowTwenty, err error) {

	db := XTReadDB().Model(&flow).Where("status = 1  and (consumable_type = 4 or consumable_type = 7)")

	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if ctime > 0 {
		db = db.Where("ctime <?", ctime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "org_id =? and status = 1", user_org_id).Find(&flow).Error
	return flow, err
}

func GetDrugFlowStartProfit(drug_id int64, user_org_id int64, ctime int64) (flow []*models.DrugFlowTwenty, err error) {
	db := XTReadDB().Model(&flow).Where("status = 1  and consumable_type = 10")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if ctime > 0 {
		db = db.Where("ctime <?", ctime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "org_id =? and status = 1", user_org_id).Find(&flow).Error
	return flow, err
}

func GetDrugFlowStartLosses(drug_id int64, user_org_id int64, ctime int64) (flow []*models.DrugFlowTwenty, err error) {
	db := XTReadDB().Model(&flow).Where("status = 1  and consumable_type = 11 ")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if ctime > 0 {
		db = db.Where("ctime <?", ctime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "org_id =? and status = 1", user_org_id).Find(&flow).Error
	return flow, err
}

func GetDrugFlowEndProfit(drug_id int64, user_org_id int64, endtime int64) (flow []*models.DrugFlowTwenty, err error) {

	db := XTReadDB().Model(&flow).Where("status = 1 and consumable_type = 10")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "org_id =? and status = 1", user_org_id).Find(&flow).Error
	return flow, err
}

func GetDrugFlowEndLosses(drug_id int64, user_org_id int64, endtime int64) (flow []*models.DrugFlowTwenty, err error) {
	db := XTReadDB().Model(&flow).Where("status = 1  and consumable_type = 11")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if endtime > 0 {
		db = db.Where("ctime <=?", endtime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "org_id =? and status = 1", user_org_id).Find(&flow).Error
	return flow, err
}

func GetDrugFlowStartEndProfit(drug_id int64, user_org_id int64, startime int64, endtime int64) (flow []*models.DrugFlowTwenty, err error) {
	db := XTReadDB().Model(&flow).Where("status = 1  and consumable_type = 10 ")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime<=?", endtime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "org_id =? and status = 1", user_org_id).Find(&flow).Error
	return flow, err
}

func GetDrugFlowStartEndLosses(drug_id int64, user_org_id int64, startime int64, endtime int64) (flow []*models.DrugFlowTwenty, err error) {
	db := XTReadDB().Model(&flow).Where("status = 1  and consumable_type = 11 ")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if startime > 0 {
		db = db.Where("ctime >=?", startime)
	}
	if endtime > 0 {
		db = db.Where("ctime<=?", endtime)
	}
	err = db.Preload("DrugWarehouseInfoOne", "org_id =? and status = 1", user_org_id).Find(&flow).Error
	return flow, err
}

func GetDrugWarehouseInfoStorehouseList(orgid int64) (info []*models.DrugWarehouseInfo, err error) {

	err = XTReadDB().Where("org_id = ? and is_check= 1 and status = 1", orgid).Group("drug_id,storehouse_id").Find(&info).Error
	return info, err
}

func GetDrugStockCout(drug_id int64, storehouse_id int64, user_org_id int64) (models.XtDrugStockCount, error) {

	drugCount := models.XtDrugStockCount{}
	err := XTReadDB().Where("drug_id = ? and storehouse_id = ? and user_org_id = ? and is_check =1 and status = 1", drug_id, storehouse_id, user_org_id).Find(&drugCount).Error
	return drugCount, err
}

func GetDrugWarehouseInfoByStorehouseId(storehouse_id int64, drug_id int64, org_id int64) (info []*models.DrugWarehouseInfo, err error) {

	err = XTReadDB().Where("drug_id = ? and storehouse_id = ? and org_id = ? and status =1 and is_check = 1", drug_id, storehouse_id, org_id).Find(&info).Error
	return info, err
}

func GetDrugFlowStockOutCount(storehouse_id int64, drug_id int64, org_id int64) (flow []*models.DrugFlow, err error) {

	err = XTReadDB().Where("storehouse_id  = ? and drug_id = ? and user_org_id = ? and status = 1 and (consumable_type = 2 or consumable_type =3)", storehouse_id, drug_id, org_id).Find(&flow).Error
	return flow, err
}

func GetDrugFlowStockCancelCount(storehouse_id int64, drug_id int64, org_id int64) (flow []*models.DrugFlow, err error) {
	err = XTReadDB().Where("storehouse_id  = ? and drug_id = ? and user_org_id = ? and status = 1 and consumable_type = 7", storehouse_id, drug_id, org_id).Find(&flow).Error
	return flow, err
}

func CreateDrugStockCount(stockCount models.XtDrugStockCount) error {

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

func GetGoodNewPurchaseStockQuery(good_type int64, keyword string, page int64, limit int64, orgid int64, ids []int64, goodIds []int64) (goodinfo []*models.GoodInfoTwenty, total int64, err error) {

	db := XTReadDB().Model(&goodinfo).Where("status = 1 and total_count > 0")
	offset := (page - 1) * limit
	likeKey := "%" + keyword + "%"
	if good_type > 0 {
		db = db.Where("good_type_id = ?", good_type)
	}

	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if len(ids) > 0 {
		db = db.Where("id in(?)", goodIds)
	}
	if len(keyword) > 0 {
		db = db.Where("good_name like ? or manufacturer in(?)", likeKey, ids)
	}
	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Find(&goodinfo).Error

	return goodinfo, total, err
}

func GetGoodNewPurchaseStockQueryOne(good_type int64, keyword string, page int64, limit int64, orgid int64, ids []int64, goodIds []int64) (goodinfo []*models.GoodInfoTwenty, total int64, err error) {

	db := XTReadDB().Model(&goodinfo).Where("status = 1")
	offset := (page - 1) * limit
	likeKey := "%" + keyword + "%"
	if good_type > 0 {
		db = db.Where("good_type_id = ?", good_type)
	}

	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if len(ids) > 0 {
		db = db.Where("id in(?)", goodIds)
	}
	if len(keyword) > 0 {
		db = db.Where("good_name like ? or manufacturer in(?)", likeKey, ids)
	}
	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Find(&goodinfo).Error

	return goodinfo, total, err
}

func GetStartLastFLow(goodid int64, orgid int64, startime int64, storehouse_id int64) (models.VmStockFlowTwenty, error) {

	flwo := models.VmStockFlowTwenty{}
	err := XTReadDB().Where("good_id = ? and user_org_id = ? and status = 1 and ctime < ? and storehouse_id = ?", goodid, orgid, startime, storehouse_id).Last(&flwo).Error
	return flwo, err
}

func GetStartLastFLowTwenty(goodid int64, orgid int64, startime int64) (models.VmStockFlowTwenty, error) {

	flwo := models.VmStockFlowTwenty{}
	err := XTReadDB().Where("good_id = ? and user_org_id = ? and status = 1 and ctime < ?", goodid, orgid, startime).Order("ctime desc").Last(&flwo).Error
	return flwo, err
}

func GetEndLastFlow(goodid int64, orgid int64, endtime int64, storehouse_id int64) (models.VmStockFlowTwenty, error) {
	flwo := models.VmStockFlowTwenty{}
	err := XTReadDB().Where("good_id = ? and user_org_id = ? and status = 1 and ctime <= ? and storehouse_id= ?", goodid, orgid, endtime, storehouse_id).Order("ctime desc").Last(&flwo).Error
	return flwo, err
}

func GetEndLastFlowTwenty(goodid int64, orgid int64, endtime int64) (models.VmStockFlowTwenty, error) {
	flwo := models.VmStockFlowTwenty{}
	err := XTReadDB().Where("good_id = ? and user_org_id = ? and status = 1 and ctime <= ?", goodid, orgid, endtime).Last(&flwo).Error
	return flwo, err
}

func GetDrugNewPurchaseStockQuery(good_type int64, keyword string, page int64, limit int64, orgid int64, startime int64, endtime int64, ids []int64, infos []int64) (druginfo []*models.VmBaseDrugTwenty, total int64, err error) {

	db := XTReadDB().Model(&druginfo).Where("status = 1")
	offset := (page - 1) * limit
	likeKey := "%" + keyword + "%"
	if good_type > 0 {
		db = db.Where("drug_type = ?", good_type)
	}

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

	if len(keyword) > 0 {
		db = db.Where("drug_name like ? or manufacturer in(?)", likeKey, ids)
	}
	if len(infos) > 0 {
		db = db.Where("id in(?)", infos)
	}
	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Find(&druginfo).Error

	return druginfo, total, err
}

func GetDrugNewPurchaseStockQueryList(good_type int64, keyword string, page int64, limit int64, orgid int64, startime int64, endtime int64, ids []int64, infos []int64) (druginfo []*models.VmBaseDrugTwenty, total int64, err error) {

	db := XTReadDB().Model(&druginfo).Where("status = 1")
	offset := (page - 1) * limit
	likeKey := "%" + keyword + "%"
	if good_type > 0 {
		db = db.Where("drug_type = ?", good_type)
	}

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

	if len(keyword) > 0 {
		db = db.Where("drug_name like ? or manufacturer in(?)", likeKey, ids)
	}
	if len(infos) > 0 {
		db = db.Where("id in(?)", infos)
	}
	err = db.Count(&total).Offset(offset).Limit(limit).Order("drug_alias desc").Find(&druginfo).Error

	return druginfo, total, err
}

func GetDrugStartFlow(drug_id int64, user_org_id int64, startime int64) (models.DrugFlowTwenty, error) {

	flow := models.DrugFlowTwenty{}
	err := XTReadDB().Where("drug_id = ? and user_org_id = ? and ctime<? and status = 1", drug_id, user_org_id, startime).Order("ctime desc").Last(&flow).Error
	return flow, err
}

func GetDrugEndFlow(drug_id int64, user_org_id int64, endtime int64) (models.DrugFlowTwenty, error) {

	flow := models.DrugFlowTwenty{}
	err := XTReadDB().Where("drug_id = ? and user_org_id = ? and ctime<=? and status = 1", drug_id, user_org_id, endtime).Order("ctime desc").Last(&flow).Error
	return flow, err
}

func GetAllStockCount(orgid int64) (stock []*models.XtGoodStockCount, err error) {

	err = XTReadDB().Where("user_org_id = ? and status = 1", orgid).Find(&stock).Error
	return stock, err
}
func GetLastStockFlow(good_id int64) (models.VmStockFlow, error) {

	flow := models.VmStockFlow{}

	err := XTReadDB().Where("good_id = ? and status =1  and ctime<=1667231999", good_id).Last(&flow).Error

	return flow, err
}

func ModifyStockFlowById(id int64, over_count int64) error {

	err := XTWriteDB().Model(&models.VmStockFlow{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"over_count": over_count}).Error
	return err
}

func GetAllDrugCount(user_org_id int64) (drug []*models.XtDrugStockCount, err error) {

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

func GetLastDrugFlow(drug_id int64) (models.DrugFlow, error) {

	flow := models.DrugFlow{}
	err := XTReadDB().Where("drug_id = ? and status =1  and ctime<=1667231999", drug_id).Last(&flow).Error

	return flow, err
}

func ModifyDrugFlowById(id int64, over_count int64) error {

	err := XTWriteDB().Model(&models.DrugFlow{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"over_count": over_count}).Error
	return err
}

func GetDrugInventoryWarehouseInfoList(org_id int64, storehouse_id int64) (info []*models.XtDrugWarehouseInfo, err error) {

	if org_id == 10138 || org_id == 10278 {
		err = XTReadDB().Model(&info).Where("status = 1 and storehouse_id = ? and is_check = 1 and org_id = ?", storehouse_id, org_id).Preload("XtBaseDrug", "status= 1").Order("drug_id").Find(&info).Error
		return info, err
	} else {
		err = XTReadDB().Model(&info).Where("status = 1 and storehouse_id = ? and is_check = 1 and org_id = ? and (stock_max_number >0 or stock_min_number >0)", storehouse_id, org_id).Preload("XtBaseDrug", "status= 1").Order("drug_id").Find(&info).Error
		return info, err
	}

}

func GetGoodStockCountList(user_org_id int64, good_id int64) (stock []*models.XtGoodStockCount, err error) {

	err = XTReadDB().Where("user_org_id =? and status=1 and good_id = ?", user_org_id, good_id).Find(&stock).Error

	return stock, err
}

func GetDrugCountMapList(drug_id int64, user_org_id int64) (drug []*models.XtDrugStockCount, err error) {

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

func UpdateDrugStockInCount(drugId int64, storehouseId int64, over_count int64, user_org_id int64) error {

	err := XTWriteDB().Model(&models.XtDrugStockCount{}).Where("drug_id =? and storehouse_id =? and status=1 and user_org_id =?", drugId, storehouseId, user_org_id).Update(map[string]interface{}{"sum_out_count": over_count}).Error
	return err
}

func UpdateDrugStockInCountOne(drugId int64, storehouseId int64, over_count int64, user_org_id int64) error {

	err := XTWriteDB().Model(&models.XtDrugStockCount{}).Where("drug_id =? and storehouse_id =? and status=1 and user_org_id =?", drugId, storehouseId, user_org_id).Update(map[string]interface{}{"sum_act_out_count": over_count}).Error
	return err
}

func GetPurchaseStockQueryList(good_type int64, keyword string, page int64, limit int64, orgid int64, ids []int64, goodIds []int64) (goodinfo []*models.GoodInfoTwenty, total int64, err error) {

	db := XTReadDB().Model(&goodinfo).Where("status = 1")
	offset := (page - 1) * limit
	likeKey := "%" + keyword + "%"
	if good_type > 0 {
		db = db.Where("good_type_id = ?", good_type)
	}

	if orgid > 0 {
		db = db.Where("org_id = ?", orgid)
	}
	if len(ids) > 0 {
		db = db.Where("id in(?)", goodIds)
	}
	if len(keyword) > 0 {
		db = db.Where("good_name like ? or manufacturer in(?)", likeKey, ids)
	}
	err = db.Count(&total).Offset(offset).Limit(limit).Order("good_number desc").Find(&goodinfo).Error

	return goodinfo, total, err
}

func GetInitBalanceList(good_id int64, user_org_id int64, start_time int64, end_time int64, storehouse_id int64) (list []*models.StWarehousingInfoOne, err error) {

	db := XTReadDB().Model(&list).Where("status=1 and is_check=1")

	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if user_org_id > 0 {
		db = db.Where("org_id = ?", user_org_id)
	}

	if start_time > 0 {
		db = db.Where("ctime<?", start_time)
	}

	if storehouse_id > 0 {
		db = db.Where("storehouse_id = ?", storehouse_id)
	}

	err = db.Find(&list).Error

	return list, err

}

func GetInitOutBanceList(good_id int64, user_org_id int64, start_time int64, end_time int64, storehouse_id int64) (list []*models.WarehouseOutInfoTenty, err error) {

	db := XTReadDB().Model(&list).Where("status=1")

	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if user_org_id > 0 {
		db = db.Where("org_id = ?", user_org_id)
	}

	if start_time > 0 {
		db = db.Where("ctime<?", start_time)
	}

	if storehouse_id > 0 {
		db = db.Where("storehouse_id = ?", storehouse_id)
	}

	err = db.Group("patient_id,good_id,sys_record_time,is_sys").Find(&list).Error

	return list, err
}

func GetInitInfoFlow(good_id int64, user_org_id int64, start_time int64, end_time int64, storehouse_id int64) (list []*models.VmStockFlowTwenty, err error) {

	db := XTReadDB().Model(&list).Where("status=1 and consumable_type =10")

	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}

	if start_time > 0 {
		db = db.Where("ctime<?", start_time)
	}

	if storehouse_id > 0 {
		db = db.Where("storehouse_id = ?", storehouse_id)
	}

	err = db.Find(&list).Error

	return list, err
}

func GetInitOutInfoFlow(good_id int64, user_org_id int64, start_time int64, end_time int64, storehouse_id int64) (list []*models.VmStockFlowTwenty, err error) {

	db := XTReadDB().Model(&list).Where("status=1 and consumable_type =11")

	if good_id > 0 {
		db = db.Where("good_id = ?", good_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}

	if start_time > 0 {
		db = db.Where("ctime<?", start_time)
	}

	if storehouse_id > 0 {
		db = db.Where("storehouse_id = ?", storehouse_id)
	}

	err = db.Find(&list).Error

	return list, err
}

func GetNewDrugFlowInWarehouseInfo(drug_id int64, user_org_id int64, start_time int64) (list []*models.DrugFlowTwenty, err error) {

	db := XTReadDB().Model(&list).Where("status=1 and consumable_type=1")

	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if start_time > 0 {
		db = db.Where("ctime<?", start_time)
	}
	err = db.Find(&list).Error
	return list, err
}

func GetNewDrugFlowPofitWarehouseInfo(drug_id int64, user_org_id int64, start_time int64) (list []*models.DrugFlowTwenty, err error) {

	db := XTReadDB().Model(&list).Where("status=1 and consumable_type=10")

	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if start_time > 0 {
		db = db.Where("ctime<?", start_time)
	}
	err = db.Find(&list).Error
	return list, err
}

func GetNewDrugFlowOutWarehouseInfo(drug_id int64, user_org_id int64, start_time int64) (list []*models.DrugFlowTwenty, err error) {

	db := XTReadDB().Model(&list).Where("status=1 and (consumable_type=3 or consumable_type=2)")

	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if start_time > 0 {
		db = db.Where("ctime<?", start_time)
	}
	err = db.Find(&list).Error
	return list, err
}

func GetNewDrugFlowCacelWarehouseInfo(drug_id int64, user_org_id int64, start_time int64) (list []*models.DrugFlowTwenty, err error) {

	db := XTReadDB().Model(&list).Where("status=1 and consumable_type=7")

	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if start_time > 0 {
		db = db.Where("ctime<?", start_time)
	}
	err = db.Find(&list).Error
	return list, err
}

func GetNewDrugFlowNoPofitWarehouseInfo(drug_id int64, user_org_id int64, start_time int64) (list []*models.DrugFlowTwenty, err error) {

	db := XTReadDB().Model(&list).Where("status=1 and consumable_type=11")

	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}
	if start_time > 0 {
		db = db.Where("ctime<?", start_time)
	}
	err = db.Find(&list).Error
	return list, err
}

func GetHisAdviceGroupList(drug_id int64, user_org_id int64) (advicelist []*models.HisDoctorAdviceInfo, err error) {

	if user_org_id == 10265 {
		err = XTReadDB().Where("drug_id = ? and user_org_id = ? and status=1 and execution_state =1", drug_id, user_org_id).Order("advice_date asc").Find(&advicelist).Error

		return advicelist, err
	} else {
		err = XTReadDB().Where("drug_id = ? and user_org_id = ? and status=1", drug_id, user_org_id).Order("advice_date asc").Find(&advicelist).Error

		return advicelist, err
	}

}

func GetDrugWarehousOutInfo(drug_id int64, org_id int64) (out []*models.XtDrugWarehouseOutInfo, err error) {

	err = XTReadDB().Where("drug_id = ? and status=1 and org_id=? and is_sys=1", drug_id, org_id).Order("sys_record_time asc").Find(&out).Error
	return out, err
}

func GetDrugWarehousOutInfoOne(drug_id int64, org_id int64) (out []*models.XtDrugWarehouseOutInfo, err error) {

	err = XTReadDB().Where("drug_id = ? and status=1 and org_id=? and is_sys=0", drug_id, org_id).Order("sys_record_time asc").Find(&out).Error
	return out, err
}

func GetCheckDrugFlow(drug_id int64, user_org_id int64) (drugflow []*models.DrugFlow, err error) {

	err = XTReadDB().Where("drug_id =? and status=1 and (consumable_type =10 or consumable_type =11) and user_org_id = ?", drug_id, user_org_id).Order("system_time asc").Find(&drugflow).Error
	return drugflow, err
}

func GetCheckGoodBatchList(good_id int64, user_org_id int64) (project []*models.HisPrescriptionProject, err error) {

	err = XTReadDB().Where("project_id = ? and user_org_id = ? and status =1 and type =3", good_id, user_org_id).Order("record_date asc").Find(&project).Error

	return project, err
}

func GetCheckGoodWarehouseList(good_id int64, org_id int64) (info []*models.WarehouseOutInfo, err error) {

	err = XTReadDB().Where("good_id = ? and org_id = ? and status=1 and is_sys=0", good_id, org_id).Order("sys_record_time").Find(&info).Error
	return info, err
}

func GetHisAdviceListBySysRrecordTime(drug_id int64, sys_record_time int64, user_org_id int64) (info []*models.HisDoctorAdviceInfo, err error) {

	err = XTReadDB().Where("drug_id=? and advice_date = ? and user_org_id = ? and status =1", drug_id, sys_record_time, user_org_id).Find(&info).Error

	return info, err
}

func GetDrugWarehouseOutInfoBySysRecordTime(drug_id int64, sys_record_time int64, user_org_id int64) (info []*models.DrugWarehouseOutInfo, err error) {

	err = XTReadDB().Where("drug_id=? and sys_record_time =? and org_id = ? and status =1", drug_id, sys_record_time, user_org_id).Find(&info).Error

	return info, err
}

func GetGoodProjectList(good_id int64, sys_record_time int64, user_org_id int64) (project []*models.HisPrescriptionProject, err error) {

	err = XTReadDB().Where("project_id = ? and status =1 and record_date = ? and user_org_id=? and type =3", good_id, sys_record_time, user_org_id).Find(&project).Error

	return project, err
}

func GetWarehouseOutListBySysrecordTime(good_id int64, sys_record_time int64, user_org_id int64) (out []*models.WarehouseOutInfo, err error) {

	err = XTReadDB().Where("good_id = ? and sys_record_time =? and org_id = ? and status=1 and is_sys=1", good_id, sys_record_time, user_org_id).Find(&out).Error
	return out, err
}