XT_New/service/self_drug_service.go

package service

import (
	"fmt"
	"strconv"
	"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 GetLastDrugWarehouseInfoList(drug_id int64) (info []*models.XtDrugWarehouseInfo, err error) {

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

	return info, 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 GetDrugWarehosueInfoById(drug_id int64, org_id int64) (drugInfo []*models.XtDrugWarehouseInfo, err error) {

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

	return drugInfo, err
}

func GetBaseDrugMedicalOne(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
}

func GetAllBaseDrugLibListTwo(org_id int64) (drugs []*Drugs, err error) {

	err = readDb.Model(&models.BaseDrugLib{}).Where("org_id = ?  AND status = 1", org_id).Find(&drugs).Error

	return drugs, err
}

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

	if orgid == 10653 {
		db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1 and (x.warehousing_count>0) and (x.stock_max_number>0 or x.stock_min_number>0)")
		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,t.sum_count,x.max_unit as max_unit_one,x.min_unit as min_unit_one").Joins("left join xt_base_drug as t on t.id = x.drug_id").Group("x.drug_id,x.id").Scan(&info).Error
		return info, err
	} else {
		db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1 and (x.warehousing_count>0)")
		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,t.sum_count,x.max_unit as max_unit_one,x.min_unit as min_unit_one").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 GetDrugNameBywordOne(orgid int64, keyword string) (list []*models.XtBaseDrug, err error) {
	likeKey := "%" + keyword + "%"
	db := XTReadDB().Model(&list).Where("status = 1 and is_self_drug =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 and x.is_self_drug!=1")
	if good_type == 2 {
		db = db.Where("x.sum_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("x.drug_name like ? or x.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, "sum_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 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, query_type 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 query_type == 2 {
		db = db.Where("sum_count<=stock_warn_count")
	}
	if query_type == 3 {
		db = db.Where("sum_count = 0")
	}

	if query_type == 4 {
		db = db.Where("sum_count > 0")
	}
	//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, query_type int64) (goodinfo []*models.GoodInfoTwenty, total int64, err error) {

	db := XTReadDB().Model(&goodinfo).Where("status = 1")
	if orgid == 10697 || orgid == 10644 {
		db = db.Where("find_in_set('停用',good_status) = 0")
	}
	offset := (page - 1) * limit
	likeKey := "%" + keyword + "%"
	if good_type > 0 {
		db = db.Where("good_type_id = ?", good_type)
	}

	if query_type == 2 {
		db = db.Where("sum_count<=stock_warn_count")
	}
	if query_type == 3 {
		db = db.Where("sum_count = 0")
	}

	if query_type == 4 {
		db = db.Where("sum_count > 0")
	}

	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 GetGoodWarehosueInfo(id int64) (models.WarehousingInfo, error) {

	info := models.WarehousingInfo{}

	err := XTReadDB().Where("id = ? and status=1", id).Find(&info).Error

	return info, err
}

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

	db := XTReadDB().Model(&druginfo).Where("status = 1 and is_self_drug!=1")
	offset := (page - 1) * limit
	likeKey := "%" + keyword + "%"
	if good_type > 0 {
		db = db.Where("drug_type = ?", good_type)
	}
	if orgid == 10697 || orgid == 10644 {
		db = db.Where("find_in_set('停用',drug_status) = 0")
	}

	if query_type == 2 {
		db = db.Where("sum_count<=drug_stock_limit_count")
	}
	if query_type == 3 {
		db = db.Where("sum_count = 0")
	}

	if query_type == 4 {
		db = db.Where("sum_count > 0")
	}

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

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

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

	return druginfo, total, err
}

func GetDrugPurchaseQueryList(good_type int64, page int64, limit int64, drug_id int64, orgId int64, startTime int64, endTime int64) (druginfo []*models.VmBaseDrugThrity, total int64, err error) {

	db := XTReadDB().Model(&druginfo).Where("status = 1 and is_self_drug!=1")
	offset := (page - 1) * limit
	if good_type > 0 {
		db = db.Where("drug_type = ?", good_type)
	}
	if orgId == 10697 || orgId == 10644 {
		db = db.Where("find_in_set('停用',drug_status) = 0")
	}

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

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

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

	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 GetInitOutBanceTenty(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=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 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,ctime").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
}

func UpdateBaseDrugById(id int64, drug_str string) (models.XtBaseDrug, error) {

	baseDrug := models.XtBaseDrug{}

	err := XTWriteDB().Model(&baseDrug).Where("id = ? and status =1", id).Updates(map[string]interface{}{"drug_spec": drug_str}).Error

	return baseDrug, err
}

func UpdateDosageFormListById(drug_dosage_form_name string, drug_id int64) (models.XtBaseDrug, error) {

	drug := models.XtBaseDrug{}

	err := XTWriteDB().Model(&drug).Where("id = ? and status =1", drug_id).Updates(map[string]interface{}{"drug_dosage_form_name": drug_dosage_form_name}).Error

	return drug, err
}

func GetDosageFormListById(id int64, orgId int64) (str string) {

	var drugDosageForm = "药品剂型"
	drugDosageFormParent, _ := GetDrugDataConfig(0, drugDosageForm)
	drugDosageFormList, _ := GetParentDataConfig(drugDosageFormParent.ID, orgId)

	for _, item := range drugDosageFormList {
		if id == int64(item.Value) {
			str = item.Name
		}
	}
	return str
}

func GetDrugAllInfo(org_id int64) (warehouseInfo []*models.DrugWarehouseInfo, err error) {

	err = XTReadDB().Where("org_id = ? and status= 1 and ctime>=1640966400 and ctime<=1703952000", org_id).Find(&warehouseInfo).Error

	return warehouseInfo, err
}

func GetDrugOutAllInfo(org_id int64) (warehouseInfo []*models.DrugWarehouseOutInfo, err error) {

	err = XTReadDB().Where("org_id = ? and status= 1 and ctime>=1672502400 and ctime<=1704038399", org_id).Find(&warehouseInfo).Error

	return warehouseInfo, err
}

func UpdateDealerManufacturer(id int64, dealer_name string, manufactruer string) (err error) {

	warehouseInfo := models.DrugWarehouseInfo{}
	err = XTWriteDB().Model(&warehouseInfo).Where("id = ? and status =1", id).Updates(map[string]interface{}{"manafacturer_name": manufactruer, "dealer_name": dealer_name}).Error

	return err
}

func UpdateDealerManufacturerOne(id int64, manufactruer string) (err error) {

	warehouseInfo := models.DrugWarehouseOutInfo{}
	err = XTWriteDB().Model(&warehouseInfo).Where("id = ? and status =1", id).Updates(map[string]interface{}{"manafacturer_name": manufactruer}).Error

	return err
}

func GetDrugWarehouseInfoByItemId(drug_id int64) (list []*models.XtDrugWarehouseInfo, err error) {

	err = XTReadDB().Where("drug_id = ? and status=1 and is_check=1 and ctime<1704038399", drug_id).Find(&list).Error

	return list, err
}

func GetDrugWarehosueOutInfoByItemId(drug_id int64) (list []*models.XtDrugWarehouseOutInfo, err error) {

	err = XTReadDB().Where("drug_id = ? and status=1 and is_check=1 and ctime<1704038399", drug_id).Find(&list).Error

	return list, err
}

func UpdateBaseDrugByIdCount(drug_id int64, flush_count int64) (models.XtBaseDrug, error) {

	drug := models.XtBaseDrug{}
	err := XTWriteDB().Model(&drug).Model(&drug).Where("id = ? and status=1", drug_id).Updates(map[string]interface{}{"total_count_one": flush_count}).Error
	return drug, err
}

func UpdateBaseDrugByIdCountTwo(drug_id int64, flush_count int64) (models.XtBaseDrug, error) {

	drug := models.XtBaseDrug{}
	err := XTWriteDB().Model(&drug).Model(&drug).Where("id = ? and status=1", drug_id).Updates(map[string]interface{}{"total_count_two": flush_count}).Error
	return drug, err
}

func GetAllWareHouseInforByUserOrg(org_id int64) (info []*models.WarehousingInfo, err error) {

	err = XTReadDB().Where("org_id =? and status =1 and is_check=1 and ctime>=1672502400 and ctime<=1703952000", org_id).Find(&info).Error

	return info, err
}

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

	err = XTReadDB().Where("org_id =? and status =1 and is_check=1 and ctime>=1672502400 and ctime<=1703952000", org_id).Find(&info).Error

	return info, err
}

func UpdateGoodInfoByUserOrgId(id int64, dealer_name string, manufactruer string) (err error) {

	warehousingInfo := models.WarehousingInfo{}
	err = XTWriteDB().Model(&warehousingInfo).Where("id = ? and status =1", id).Updates(map[string]interface{}{"dealer_name": dealer_name, "manafacturer_name": manufactruer}).Error
	return err
}

func UpdateGoodInfoByUserOrgIdTwo(id int64, dealer_name string) (err error) {

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

func GetAllWarehouseSumInCount(org_id int64) (infor []*models.WarehousingInfo, err error) {

	err = XTReadDB().Where("id = ? and status =1 and is_check =1 and ctime<1704038399", org_id).Find(&infor).Error

	return infor, err
}

func GetAllWarehouseSumOutCount(org_id int64) (infor []*models.WarehouseOutInfo, err error) {

	err = XTReadDB().Where("id = ? and status =1 and is_check =1 and ctime<1704038399", org_id).Find(&infor).Error

	return infor, err
}

func UpdateGoodInfoById(id int64, total_count_one int64) error {

	err := XTWriteDB().Model(&models.GoodInfoSevenThirty{}).Where("id = ? and status =1", id).Updates(map[string]interface{}{"total_count_one": total_count_one}).Error

	return err
}

func UpdateGoodInfoByIdOne(id int64, total_count_one int64) error {

	err := XTWriteDB().Model(&models.GoodInfoSevenThirty{}).Where("id = ? and status =1", id).Updates(map[string]interface{}{"total_count_two": total_count_one}).Error

	return err
}

func GetAllSelfDrugInfoList(org_id int64) (base []*models.BaseDrugLibThrity, err error) {

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

	return base, err
}

func GetAllPatientListByUserOrg(org_id int64) (patient []*models.XtPatients, err error) {

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

	return patient, err
}

func PostSearchSelfDrugList(keywords string, user_org_id int64) (drug []*models.BaseDrugLibThrity, err error) {

	db := XTReadDB().Model(&drug).Where("org_id=? and status=1 and is_self_drug=1", user_org_id)

	if len(keywords) > 0 {
		likekey := "%" + keywords + "%"
		err = db.Where("(drug_name LIKE ?)", likekey).Preload("LastDrugWarehouseInfo", "org_id=? and status = 1 and (stock_max_number > 0 or stock_min_number>0) and storehouse_id = ?", user_org_id).Preload("DrugWarehouseInfo", func(db *gorm.DB) *gorm.DB {
			return XTReadDB().Where("org_id=? and status = 1 and warehousing_count <> 0", user_org_id).Group("id")
		}).Find(&drug).Error
	} else {
		err = db.Preload("LastDrugWarehouseInfo", "org_id=? and status = 1 and (stock_max_number > 0 or stock_min_number>0)", user_org_id).Preload("DrugWarehouseInfo", func(db *gorm.DB) *gorm.DB {
			return XTReadDB().Where("org_id=? and status = 1 and warehousing_count <> 0 ", user_org_id).Group("id")
		}).Find(&drug).Error
	}
	return
}

func FindAllSelfDrugList(org_id int64, patient_id int64) (total int64, err error) {
	err = readDb.Model(&models.XtSelfDrugWarehouseInfo{}).Where("org_id = ? and patient_id", org_id, patient_id).Count(&total).Error
	return total, err
}

func CreatedSlefWarehouseing(info *models.XtSelfDrugWarehouseInfo, tx *gorm.DB) {

	err := tx.Create(&info).Error
	if err != nil {
		tx.Rollback()
		return
	}
	return
}

func UpdateSelfWarehouseing(info *models.XtSelfDrugWarehouseInfo, tx *gorm.DB) error {

	err := tx.Save(&info).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func FindSelfDrugWarehouseInfoListById(id int64, org_id int64, patient_id int64, tx *gorm.DB) (info []*models.XtSelfDrugWarehouseInfo, err error) {

	err = tx.Where("warehousing_id = ? and org_id = ? and patient_id = ? and status=1", id, org_id, patient_id).Preload("BaseDrugLib", "status=1").Find(&info).Error

	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return info, err

		}
	}
	return info, err
}

func GetAllBaseDrugListByKeyWord(keyword string, org_id int64) (base []*models.BaseDrugLibSeven, err error) {

	likeKey := "%" + keyword + "%"

	db := XTReadDB().Model(&base).Where("status=1 and is_self_drug = 1")
	if len(keyword) > 0 {
		db = db.Where("drug_name like ?", likeKey)
	}
	if org_id > 0 {
		db = db.Where("org_id = ?", org_id)
	}
	err = db.Find(&base).Error

	return base, err

}

func GetAllSelfDrugWarehouseInfoList(ids []int64, org_id int64, patient_id int64) (info []*models.XtSelfDrugWarehouseInfo, err error) {

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

	if len(ids) > 0 {
		db = db.Where("drug_id in(?)", ids)
	}
	if org_id > 0 {
		db = db.Where("org_id = ?", org_id)
	}
	if patient_id > 0 {
		db = db.Where("patient_id = ?", patient_id)
	}

	err = db.Preload("BaseDrugLib", "status =1").Find(&info).Error

	return info, err
}

func AddSelfDrugWarehouse(warehouse *models.XtSelfDrugWarehouse, tx *gorm.DB) error {

	err := tx.Create(&warehouse).Error

	if err != nil {
		tx.Rollback()
		return err
	}

	return err
}

func GetSelfDrugWarehouseByWaresingId(patient_id int64, record_time int64, org_id int64, tx *gorm.DB) (models.XtSelfDrugWarehouse, error) {

	warehouse := models.XtSelfDrugWarehouse{}
	err := tx.Where("patient_id = ? and warehousing_time = ? and org_id = ? and is_sys=1 and status=1", patient_id, record_time, org_id).Find(&warehouse).Error

	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return warehouse, err
		}
	}
	return warehouse, err
}

func UpdateSelfDrugWarehouse(warehouse *models.XtSelfDrugWarehouse, tx *gorm.DB) error {

	err := tx.Save(&warehouse).Error

	if err != nil {
		tx.Rollback()
		return err
	}

	return err

}

func FindSelfAllWarehouseTotal(org_id int64, tx *gorm.DB) (total int64, err2 error) {

	err = tx.Model(&models.XtSelfDrugWarehouse{}).Where("org_id = ?", org_id).Count(&total).Error
	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return total, err
		}
	}
	return total, err
}

func FindLastSelfWarehousing(user_org_id int64, patient_id int64, tx *gorm.DB) (models.XtSelfDrugWarehouse, error) {

	selfDrugWarehouse := models.XtSelfDrugWarehouse{}
	err := tx.Where("org_id=? and patient_id =?", user_org_id, patient_id).Last(&selfDrugWarehouse).Error

	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return selfDrugWarehouse, err
		}
	}
	return selfDrugWarehouse, err
}

func GetSelfDrugWarehouseInfoByID(id int64) (models.XtSelfDrugWarehouseInfo, error) {

	selfDrugWarehouseInfo := models.XtSelfDrugWarehouseInfo{}

	err := XTReadDB().Where("warehousing_id = ? and status=1", id).Preload("BaseDrugLib", "status=1").Find(&selfDrugWarehouseInfo).Error

	return selfDrugWarehouseInfo, err
}

func GetSelfDrugWarehouseInfoByIDOne(id int64) (selfDrugWarehouseInfo []*models.XtSelfDrugWarehouseInfo, err error) {

	err = XTReadDB().Where("warehousing_id = ? and status=1", id).Preload("BaseDrugLib", "status=1").Find(&selfDrugWarehouseInfo).Error

	return selfDrugWarehouseInfo, err
}

func GetSelfDrugWarehouseInfo(id int64) (models.XtSelfDrugWarehouse, error) {

	warehouse := models.XtSelfDrugWarehouse{}

	err := XTReadDB().Where("id = ? and status=1", id).Find(&warehouse).Error

	return warehouse, err
}

func DeleteSelfDrugWarehouse(id int64, tx *gorm.DB) error {

	info := models.XtSelfDrugWarehouseInfo{}

	err := tx.Model(&info).Where("id = ? and status=1", id).Updates(map[string]interface{}{"status": 0}).Error

	if err != nil {
		tx.Rollback()
		return err
	}

	return err
}

func GetSelfWarehouseInfoByWarehouseInfo(id int64, patient_id int64, org_id int64, tx *gorm.DB) (info []*models.XtSelfDrugWarehouseInfo, err error) {

	err = tx.Where("warehousing_id =? and patient_id =? and status=1 and org_id =?", id, patient_id, org_id).Find(&info).Error

	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return info, err
		}
	}
	return info, err
}

func AddSelfDrugWarehouseStockMaxNumber(count int64, id int64, tx *gorm.DB) error {

	err := tx.Model(&models.XtSelfDrugWarehouseInfo{}).Where("id = ? and status = 1", id).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number + ?", count)).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	err = tx.Model(&models.XtSelfDrugWarehouseInfo{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"is_check": 1}).Error
	if err != nil {
		tx.Rollback()
		return err
	}

	return err
}

func AddSelfDrugWarehouseStockMinNumber(count int64, id int64, tx *gorm.DB) error {

	err := tx.Model(&models.XtSelfDrugWarehouseInfo{}).Where("id = ? and status = 1", id).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number + ?", count)).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	err = tx.Model(&models.XtSelfDrugWarehouseInfo{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"is_check": 1}).Error
	if err != nil {
		tx.Rollback()
		return err
	}

	return err
}

func GetDrugSumCountByPatient(patient_id int64, org_id int64, drug_id int64, tx *gorm.DB) (info []*models.XtSelfDrugWarehouseInfo, err error) {

	err = tx.Where("patient_id = ? and org_id = ? and drug_id = ? and status =1", patient_id, org_id, drug_id).Find(&info).Error

	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return info, err
		}
	}

	return info, err
}

func CreateSelfDrugFlow(flow *models.XtSelfDrugFlow, tx *gorm.DB) error {

	err := tx.Create(&flow).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func GetSelfDrugSumCountByStorehouseId(patient_id int64, orgid int64, drug_id int64, tx *gorm.DB) (info []*models.XtSelfDrugWarehouseInfo, err error) {

	err = tx.Where("patient_id = ? and org_id = ? and status = 1  and drug_id =? and is_check = 1", patient_id, orgid, drug_id).Find(&info).Error
	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return info, err
		}
	}
	return info, err
}

func CreateSelfDrugStockSum(drug models.XtSelfDrugStockCount, tx *gorm.DB) error {

	err := tx.Create(&drug).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func GetSelfDrugWarehouseOutListById(warehouse_out_id int64, orgId int64, tx *gorm.DB) (info []*models.XtSelfDrugWarehouseOutInfo, err error) {

	err = tx.Where("warehouse_out_id = ? and org_id  =? and status = 1", warehouse_out_id, orgId).Preload("BaseDrugLib", "status=1").Find(&info).Error

	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return info, err
		}
	}
	return info, err
}

func GetAllSelfDrugWarehouseOutList(ids []int64, patient_id int64, start_time int64, end_time int64, org_id int64) (outInfo []*models.XtSelfDrugWarehouseOutInfo, err error) {

	db := XTReadDB().Model(&outInfo).Where("status =1")
	if len(ids) > 0 {
		db = db.Where("drug_id in(?)", ids)
	}
	if patient_id > 0 {
		db = db.Where("patient_id = ?", patient_id)
	}

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

	if end_time > 0 {
		db = db.Where("sys_record_time <=?", end_time)
	}

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

	err = db.Preload("BaseDrugLib", "status=1 and org_id = ?", org_id).Find(&outInfo).Error

	return outInfo, err

}

func DeleteSelfWarehouseOut(id int64) (models.XtSelfDrugWarehouseOutInfo, error) {

	outInfo := models.XtSelfDrugWarehouseOutInfo{}
	err := XTWriteDB().Model(&outInfo).Where("id = ? and status=1", id).Updates(map[string]interface{}{"status": 0}).Error

	return outInfo, err
}

func GetSelfDrugWarehouseOutById(id int64) (outInfo []*models.XtSelfDrugWarehouseOutInfo, err error) {

	err = XTReadDB().Where("warehouse_out_id = ? and status =1", id).Preload("BaseDrugLib", "status=1").Find(&outInfo).Error

	return outInfo, err
}

func GetSelfDrugWarehouseOutOne(id int64) (models.XtSelfDrugWarehouseOut, error) {

	out := models.XtSelfDrugWarehouseOut{}
	err = XTReadDB().Where("id = ? and status =1", id).Find(&out).Error

	return out, err
}

func GetSelfDrugQuery(user_org_id int64, ids []int64) (drug []*models.XtSelfDrugStockCount, total int64, err error) {

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

	if len(ids) > 0 {
		db = db.Where("drug_id in(?)", ids)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id = ?", user_org_id)
	}

	err = db.Preload("BaseDrugLib", "org_id = ? and status =1", user_org_id).Find(&drug).Error

	return drug, total, err
}

func GetSelfDrugWarehouseOutListByIdOne(warehouse_out_id int64, orgId int64, tx *gorm.DB) (info []*models.XtSelfDrugWarehouseOutInfo, err error) {

	err = tx.Where("warehouse_out_id = ? and org_id  =? and status = 1", warehouse_out_id, orgId).Preload("BaseDrugLib", "status=1").Find(&info).Error
	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return
		}
	}
	return info, err
}

func GetSelfDrugWarehouseOutByLastId(id int64, tx *gorm.DB) (models.XtSelfDrugWarehouseOut, error) {
	out := models.XtSelfDrugWarehouseOut{}
	err := tx.Where("id = ? and status = 1", id).Find(&out).Error

	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return out, err
		}
	}
	return out, err
}

func GetSelfDrugAllStockInfo(patient_id int64, orgid int64, drugid int64, tx *gorm.DB) (info []*models.XtSelfDrugWarehouseInfo, err error) {

	err = tx.Where("patient_id  = ? and org_id = ? and status = 1 and drug_id = ? and is_check = 1", patient_id, orgid, drugid).Find(&info).Error
	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return info, err
		}
	}
	return info, err
}

func FindSelfBaseDrugLibRecord(org_id int64, id int64, tx *gorm.DB) (lib models.BaseDrugLib, err error) {
	err = tx.Model(&models.BaseDrugLib{}).Where("id = ? AND org_id = ?  AND status = 1", id, org_id).First(&lib).Error

	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return lib, err
		}
	}
	return lib, err
}

func FindNewSelfBaseDrugLibRecord(org_id int64, id int64) (lib models.BaseDrugLib, err error) {

	err = XTReadDB().Model(&models.BaseDrugLib{}).Where("id = ? AND org_id = ?  AND status = 1", id, org_id).First(&lib).Error

	return lib, err
}

func GetSelfBaseDrugMedical(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 AddSelfDrugCount(drug_id int64, org_id int64, patient_id int64, out_count int64, tx *gorm.DB) error {

	err := tx.Model(&models.XtSelfDrugStockCount{}).Where("patient_id = ? and status = 1 and user_org_id = ? and drug_id = ?", patient_id, org_id, drug_id).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count + ?", out_count)).Error
	if err != nil {
		tx.Rollback()
		return err
	}

	err = tx.Model(&models.XtSelfDrugStockCount{}).Where("patient_id = ? and status = 1 and user_org_id = ? and drug_id = ?", patient_id, org_id, drug_id).UpdateColumn("sum_act_out_count", gorm.Expr("sum_act_out_count + ?", out_count)).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func UpdateSelfCheckDrugOut(out models.XtSelfDrugWarehouseOut, id int64, tx *gorm.DB) error {

	err := tx.Model(&models.XtSelfDrugWarehouseOut{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"is_check": out.IsCheck}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	err = tx.Model(&models.XtSelfDrugWarehouseOutInfo{}).Where("warehouse_out_id = ? and status = 1", id).Update(map[string]interface{}{"is_check": 1}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func FindSelfLastDrugWarehousingInfoByID(drug_id int64, patient_id int64, tx *gorm.DB) (info models.XtSelfDrugWarehouseInfo, err error) {
	err = tx.Model(&models.XtSelfDrugWarehouseInfo{}).Where("drug_id = ? AND status = 1 AND (stock_max_number > 0 or stock_min_number > 0) and patient_id = ? and is_check = 1", drug_id, patient_id).Order("ctime").First(&info).Error
	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return info, err
		}
	}
	return info, err
}

func ChangeSelfMaxNumber(id int64, count int64, tx *gorm.DB) error {

	err = tx.Model(&models.XtSelfDrugWarehouseInfo{}).Where("id = ? and status = 1 and is_check = 1", id).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number + ?", count)).Error

	if err != nil {
		tx.Rollback()
		return err
	}
	return err

}

func UpdateSelfMinNumber(id int64, count int64, tx *gorm.DB) error {

	err := tx.Model(&models.XtSelfDrugWarehouseInfo{}).Where("id = ? and status = 1 and is_check = 1", id).Update(map[string]interface{}{"stock_min_number": count}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func ChangeSelfMaxNumberOne(id int64, count int64, tx *gorm.DB) error {

	err = tx.Model(&models.DrugWarehouseInfo{}).Where("id = ? and status = 1 and is_check = 1", id).Updates(map[string]interface{}{"stock_max_number": count, "stock_min_number": 0}).Error

	if err != nil {
		tx.Rollback()
		return err
	}
	return err

}

func UpDateSelfDrugWarehouseInfoByStock(info *models.XtSelfDrugWarehouseInfo, tx *gorm.DB) (err error) {

	err = tx.Save(&info).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func FindSelfDrugWarehouseInfoFlushCount(drug_id int64, orgid int64, tx *gorm.DB) (info []*models.XtSelfDrugWarehouseInfo, err error) {

	err = tx.Where("drug_id = ? and org_id = ? and status = 1 and is_check = 1", drug_id, orgid).Find(&info).Error

	if err != nil {
		tx.Rollback()
		return info, err
	}
	return info, err
}

func GetSelfLastWarehouseOutInfoById(drugid int64, tx *gorm.DB) (models.XtSelfDrugWarehouseOutInfo, error) {

	flow := models.XtSelfDrugWarehouseOutInfo{}
	err := tx.Where("drug_id = ? and status = 1", drugid).Last(&flow).Error

	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return flow, err
		}
	}
	return flow, err
}

func UpdateSelfDrugWarehouseOutInfo(id int64, warehouse_info_id int64, org_id int64, over_count int64, drug_price float64, tx *gorm.DB) error {

	err = tx.Model(&models.XtSelfDrugWarehouseOutInfo{}).Where("id = ? and org_id = ? and status = 1", id, org_id).Update(map[string]interface{}{"warehouse_info_id": warehouse_info_id, "over_count": over_count, "price": drug_price, "retail_price": drug_price}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func UpdateSelfCheckDrugOutInfoList(info models.XtSelfDrugWarehouseOutInfo, warehouse_out_id int64, tx *gorm.DB) error {

	err := tx.Model(&models.XtSelfDrugWarehouseOutInfo{}).Where("warehouse_out_id = ?  and status = 1", warehouse_out_id).Update(map[string]interface{}{"is_check": 2}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func UpdateSelfDrugMaxNumber(count int64, id int64, tx *gorm.DB) error {
	err := tx.Model(&models.XtSelfDrugWarehouseInfo{}).Where("id = ? and status = 1", id).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number + ?", count)).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func UpdateSelfDrugMinNumber(count int64, id int64, tx *gorm.DB) error {

	err := tx.Model(&models.XtSelfDrugWarehouseInfo{}).Where("id = ? and status = 1", id).UpdateColumn("stock_min_number", gorm.Expr("stock_min_number + ?", count)).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func ModifySelfReduceDrugInformation(id int64, count int64, orgid int64, tx *gorm.DB) error {

	err = tx.Model(&models.BaseDrugLib{}).Where("id = ? and status = 1 and org_id = ?", id, orgid).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count - ?", count)).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func DeleteSelfDrugOutFlow(id int64, orgid int64, tx *gorm.DB) error {

	err := tx.Model(models.XtSelfDrugFlow{}).Where("warehouse_out_detail_id = ? and user_org_id = ? and status = 1", id, orgid).Update(map[string]interface{}{"status": 0}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func ReduceSelfDrugCount(drug_id int64, org_id int64, patient_id int64, out_count int64, tx *gorm.DB) error {

	err := tx.Model(&models.XtSelfDrugStockCount{}).Where("patient_id = ? and status = 1 and user_org_id = ? and drug_id = ?", patient_id, org_id, drug_id).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count - ?", out_count)).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	err = tx.Model(&models.XtSelfDrugStockCount{}).Where("patient_id = ? and status = 1 and user_org_id = ? and drug_id = ?", patient_id, org_id, drug_id).UpdateColumn("sum_act_out_count", gorm.Expr("sum_act_out_count - ?", out_count)).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func UpdateSelfDrugStockCount(drug_id int64, org_id int64, patient_id int64, flush_count int64, tx *gorm.DB) error {

	drug := models.XtSelfDrugStockCount{}

	err := tx.Model(&drug).Where("drug_id = ? and user_org_id = ? and patient_id = ? and status = 1", drug_id, org_id, patient_id).Update(map[string]interface{}{"flush_count": flush_count}).Error
	if err != nil {
		tx.Rollback()
		return err
	}

	return err
}

func FindSelfDrugWarehouseInfoFlushCountByStorehouse(drug_id int64, orgid int64, patient_id int64, tx *gorm.DB) (info []*models.XtSelfDrugWarehouseInfo, err error) {

	err = tx.Where("drug_id = ? and org_id = ? and status = 1 and is_check = 1 and patient_id =?", drug_id, orgid, patient_id).Find(&info).Error

	if err != nil {
		tx.Rollback()
		return info, err
	}

	return info, err
}

func GetSelfWarehousingInfoByList(id int64, orgid int64, tx *gorm.DB) (info []*models.XtSelfDrugWarehouseInfo, err error) {

	err = tx.Where("warehousing_id = ? and org_id = ? and status = 1", id, orgid).Find(&info).Error

	if err != nil {
		tx.Rollback()
		return info, err
	}
	return info, err
}

func GetSelfDrugWarehouseOutByWarehouseInfoId(warehouse_info_id int64, drug_id int64, orgid int64, tx *gorm.DB) (outInfo []*models.XtSelfDrugWarehouseOutInfo, err error) {

	err = tx.Where("warehouse_info_id = ? and drug_id = ? and org_id = ? and is_check = 1 and status = 1", warehouse_info_id, drug_id, orgid).Find(&outInfo).Error
	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return outInfo, err
		}
	}
	return outInfo, err
}

func UpdateSelfWarehousingInfoFlow(id int64, orgid int64, tx *gorm.DB) error {

	err := tx.Model(&models.XtSelfDrugFlow{}).Where("warehousing_id = ? and user_org_id = ? and status = 1", id, orgid).Update(map[string]interface{}{"status": 0}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func AddSelfDrugReturnWarehouseStockMaxNumber(count int64, id int64, tx *gorm.DB) error {

	err := tx.Model(&models.XtSelfDrugWarehouseInfo{}).Where("id = ? and status = 1", id).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number - ?", count)).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	err = tx.Model(&models.XtSelfDrugWarehouseInfo{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"is_check": 2}).Error
	if err != nil {
		tx.Rollback()
		return err
	}

	return err
}

func AddSelfDrugReturnWarehouseStockMinNumber(count int64, id int64, tx *gorm.DB) error {

	err := tx.Model(&models.XtSelfDrugWarehouseInfo{}).Where("id = ? and status = 1", id).UpdateColumn("stock_min_number", gorm.Expr("stock_min_number - ?", count)).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	err = tx.Model(&models.XtSelfDrugWarehouseInfo{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"is_check": 2}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func ReduceSelfDrugStockCount(patient_id int64, drug_id int64, user_org_id int64, waresing_count int64, over_count int64, tx *gorm.DB) error {

	err = tx.Model(&models.XtSelfDrugStockCount{}).Where("user_org_id = ? and patient_id  = ? and drug_id = ? and status = 1", user_org_id, patient_id, drug_id).UpdateColumn("sum_in_count", gorm.Expr("sum_in_count - ?", waresing_count)).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	err = tx.Model(&models.XtSelfDrugStockCount{}).Where("user_org_id = ? and patient_id = ? and drug_id = ? and status = 1", user_org_id, patient_id, drug_id).Update(map[string]interface{}{"flush_count": over_count}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func ReturnSelfCheckWarehouseingInfo(id int64, orgid int64, tx *gorm.DB) error {

	err := tx.Model(&models.XtSelfDrugWarehouse{}).Where("id = ? and status = 1 and org_id = ?", id, orgid).Update(map[string]interface{}{"is_check": 2}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	err = tx.Model(&models.XtSelfDrugWarehouseInfo{}).Where("warehousing_id = ? and status = 1 and org_id = ?", id, orgid).Update(map[string]interface{}{"is_check": 2}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func CheckSelfWarehousingInfo(id int64, orgid int64, checker int64, tx *gorm.DB) error {

	err := tx.Model(&models.XtSelfDrugWarehouse{}).Where("id = ? and org_id = ? and status = 1", id, orgid).Update(map[string]interface{}{"is_check": 1, "checker": checker}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func GetSelfDrugFlow(drug_id int64, start_time int64, end_time int64, user_org_id int64, page int64, limit int64, patient_id int64) (flow []*models.XtSelfDrugFlow, total int64, err error) {

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

	if drug_id > 0 {
		db = db.Where("drug_id =?", drug_id)
	}
	if patient_id > 0 {
		db = db.Where("patient_id = ?", patient_id)
	}
	if start_time > 0 {
		db = db.Where("ctime>=?", start_time)
	}
	if end_time > 0 {
		db = db.Where("etime <=?", end_time)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id =?", user_org_id)
	}

	offset := (page - 1) * limit

	err = db.Count(&total).Offset(offset).Limit(limit).Preload("BaseDrugLib", "status=1 and org_id = ?", user_org_id).Order("id desc").Find(&flow).Error

	return flow, total, err
}

func GetSelfBasedrugByIdOne(drug_id int64, user_org_id int64) (models.BaseDrugLib, error) {

	lib := models.BaseDrugLib{}

	err := XTReadDB().Where("id = ? and org_id =? and status=1", drug_id, user_org_id).Find(&lib).Error

	return lib, err
}

func GetSelfDrugStockCountByPatientId(drug_id int64, patient_id int64, user_org_id int64) (models.XtSelfDrugStockCount, error) {

	selfDrugStockCount := models.XtSelfDrugStockCount{}
	err := XTReadDB().Where("drug_id = ? and patient_id = ? and user_org_id = ? and status =1", drug_id, patient_id, user_org_id).Find(&selfDrugStockCount).Error
	return selfDrugStockCount, err
}

func GetSelfBasedrugById(drug_id int64, user_org_id int64, tx *gorm.DB) (models.BaseDrugLib, error) {

	lib := models.BaseDrugLib{}

	err := tx.Where("id = ? and org_id =? and status=1", drug_id, user_org_id).Find(&lib).Error

	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return lib, err
		}
	}

	return lib, err
}

func GetSelfDrugBatchNumberList(drug_id int64, start_time int64, end_time int64, user_org_id int64, page int64, limit int64, patient_id int64) (flow []*models.XtSelfDrugFlow, total int64, 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 start_time > 0 {
		db = db.Where("ctime>=?", start_time)
	}
	if end_time > 0 {
		db = db.Where("etime <=?", end_time)
	}
	if user_org_id > 0 {
		db = db.Where("user_org_id =?", user_org_id)
	}
	if patient_id > 0 {
		db = db.Where("patient_id = ?", patient_id)
	}

	offset := (page - 1) * limit

	err = db.Count(&total).Offset(offset).Limit(limit).Find(&flow).Error

	return flow, total, err
}

func GetAllSelfDrugWarehouse(keyword string, start_time int64, end_time int64, check_type int64, orgId int64, page int64, limit int64, patient_id int64) (warehouse []*models.XtSelfDrugWarehouse, total int64, err error) {

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

	likeKey := "%" + keyword + "%"

	if len(keyword) > 0 {
		db = db.Where("warehousing_order like ?", likeKey)
	}

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

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

	offset := (page - 1) * limit

	err = db.Count(&total).Offset(offset).Limit(limit).Order("operation_time desc").Find(&warehouse).Error

	return warehouse, total, err
}

func DeleteSelfWarehouse(id int64) error {

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

	err = XTWriteDB().Model(&models.XtSelfDrugWarehouseInfo{}).Where("warehousing_id = ? and status=1", id).Updates(map[string]interface{}{"status": 0}).Error

	return err
}

func GetAllSelfDrugWarehouseOut(start_time int64, end_time int64, org_id int64, page int64, limit int64, patient_id int64, keyword string, check_type int64) (out []*models.XtSelfDrugWarehouseOut, total int64, err error) {

	db := XTReadDB().Model(&out).Where("status=1")
	offset := (page - 1) * limit

	likeKey := "%" + keyword + "%"

	if len(keyword) > 0 {
		db = db.Where("warehouse_out_order_number like ?", likeKey)
	}
	if start_time > 0 {
		db = db.Where("operation_time>=?", start_time)
	}

	if end_time > 0 {
		db = db.Where("operation_time<=?", end_time)
	}

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

	if patient_id > 0 {
		db = db.Where("patient_id = ?", patient_id)
	}
	if check_type > 0 {
		db = db.Where("is_check=?", check_type)
	}

	err = db.Count(&total).Offset(offset).Limit(limit).Order("operation_time desc").Find(&out).Error

	return out, total, err
}

func DeleteSelfWarehouseOutList(id int64) (models.XtSelfDrugWarehouseOut, error) {

	warehouseOut := models.XtSelfDrugWarehouseOut{}

	err := XTWriteDB().Model(&warehouseOut).Where("id = ? and status=1", id).Updates(map[string]interface{}{"status": 0}).Error

	err = XTWriteDB().Model(&models.XtSelfDrugWarehouseOutInfo{}).Where("warehouse_out_id = ? and status=1", id).Updates(map[string]interface{}{"status": 0}).Error

	return warehouseOut, err
}

func FindSelfDrugWarehouseInfoList(drugid int64, orgid int64, tx *gorm.DB) (info []*models.XtSelfDrugWarehouseInfo, err error) {

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

	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return info, err
		}
	}
	return info, err
}

func GetSelfDrugWarehouseInfoByInfo(advice_id int64, patient_id int64, advice_date int64, user_org_id int64, drug_id int64, tx *gorm.DB) (info []*models.XtSelfDrugWarehouseInfo, err error) {

	err = tx.Where("advice_id = ? and patient_id = ? and record_date = ? and org_id = ? and status=1 and drug_id = ?", advice_id, patient_id, advice_date, user_org_id, drug_id).Find(&info).Error

	return info, err
}

func CreateSelfDrugWarehouseInfo(info *models.XtSelfDrugWarehouseInfo, tx *gorm.DB) error {

	err := tx.Create(&info).Error

	if err != nil {
		tx.Rollback()
		return err
	}

	return err
}

func GetLastSelfDrugWarehouseInfoById(org_id int64, tx *gorm.DB) (models.XtSelfDrugWarehouseInfo, error) {

	info := models.XtSelfDrugWarehouseInfo{}

	err := tx.Where("org_id = ? and status =1", org_id).Last(&info).Error

	return info, err
}

func GetSelfDrugWarehouseOutDrugFlow(patient_id int64, drug_id int64, user_org_id int64, advice_id int64, tx *gorm.DB) (flow []*models.XtSelfDrugFlow, err error) {

	err = tx.Where("patient_id = ? and drug_id = ? and user_org_id =? and status=1 and consumable_type =20 and advice_id =?", patient_id, drug_id, user_org_id, advice_id).Find(&flow).Error

	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return
		}
	}
	return flow, err
}

func GetSelfDrugLastWarehouseOutTwety(orgid int64, record_date int64, tx *gorm.DB, is_sys int64) (models.XtSelfDrugWarehouseOut, error) {
	out := models.XtSelfDrugWarehouseOut{}
	err := tx.Where("org_id = ? and status = 1 and warehouse_out_time = ? and is_sys =?", orgid, record_date, is_sys).Find(&out).Error
	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return out, err
		}

	}
	return out, err
}

func GetSelfHisPrescriptionAdviceByID(id int64, tx *gorm.DB) (advices []*models.HisDoctorAdviceInfo, err error) {
	err = tx.Model(&models.HisDoctorAdviceInfo{}).Where("prescription_id = ? AND status = 1", id).Find(&advices).Error

	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return advices, err
		}
	}
	return
}

func GetSelfNewDrugWarehouseOutInfoSix(drugid int64, patient_id int64, record_date int64, org_id int64, advice_id int64, warehouse_info_id int64, tx *gorm.DB) (models.DrugWarehouseOutInfo, error) {

	info := models.DrugWarehouseOutInfo{}
	var err error
	err = tx.Where("drug_id = ? and patient_id = ? and sys_record_time = ? and org_id = ? and status = 1 and advice_id = ? and warehouse_info_id = ?", drugid, patient_id, record_date, org_id, advice_id, warehouse_info_id).Find(&info).Error

	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return info, err
		}
	}

	return info, err
}

func UpdateSelfDrugWarehouseOutInfoTen(patient_id int64, sys_record_time int64, advice_id int64, tx *gorm.DB) error {

	err := tx.Model(&models.DrugWarehouseOutInfo{}).Where("patient_id = ? and sys_record_time  = ? and status=1 and advice_id = ?", patient_id, sys_record_time, advice_id).Updates(map[string]interface{}{"status": 0}).Error

	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func GetSelfWarehouseInfoByWarehouseInfoTwo(drug_id int64, patient_id int64, org_id int64, tx *gorm.DB) (info []*models.XtSelfDrugWarehouseInfo, err error) {

	err = tx.Where("drug_id =? and patient_id =? and status=1 and org_id =? and is_check=1", drug_id, patient_id, org_id).Find(&info).Error

	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return info, err
		}
	}
	return info, err
}

func GetSelfDrugWarehouseOutDetailByPatientId(patient_id int64, page int64, limit int64, user_org_id int64) (out []*models.XtSelfDrugStockCount, total int64, err error) {

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

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

	offset := (page - 1) * limit

	err = db.Count(&total).Offset(offset).Limit(limit).Preload("BaseDrugLib", "status=1 and org_id = ?", user_org_id).Find(&out).Error

	return out, total, err
}

func GetSelfBasedrugByIdTwo(drug_id int64, user_org_id int64) (models.BaseDrugLib, error) {

	lib := models.BaseDrugLib{}

	err := XTReadDB().Where("id = ? and org_id =? and status=1", drug_id, user_org_id).Find(&lib).Error

	return lib, err
}

//自动退库分装方法

func SelfDrugAutoAddCancelInfo(advice *models.HisDoctorAdviceInfo, creater int64) error {

	//查询该批次病人该药品出库数据
	info, _ := GetSelfDrugAutoWarehouseOutEight(advice.PatientId, advice.AdviceDate, advice.DrugId, advice.ID)
	list, _ := GetSelfDrugAutoWarehouseOutNight(advice.PatientId, advice.AdviceDate, advice.DrugId, advice.ID)

	//退库
	drug, _ := FindBaseDrugLibRecord(advice.UserOrgId, advice.DrugId)

	//如果剩余数量 + 退库数量 < 总入库数量
	if len(list) > 0 {
		for _, its := range list {
			//查询该批次病人该药品出库数据
			infos, _ := GetSelfDrugAutoWarehouseOutTen(advice.PatientId, advice.AdviceDate, advice.DrugId, advice.ID, its.WarehouseInfoId)

			//查询该药品出库批次总入库数量
			druginfo, _ := GetSelfDrugInfoSix(its.WarehouseInfoId, infos.OrgId)

			var out_count int64  //该批次出库库存
			var sum_count int64  //该批次总库存
			var over_count int64 //剩余数量

			if druginfo.MaxUnit != druginfo.MinUnit {
				over_count = druginfo.StockMaxNumber*drug.MinNumber + druginfo.StockMinNumber
			}
			if druginfo.MaxUnit == druginfo.MinUnit {
				over_count = druginfo.StockMaxNumber + druginfo.StockMinNumber
			}

			if infos.CountUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
				out_count = infos.Count * drug.MinNumber

			}
			if infos.CountUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
				out_count = infos.Count
			}

			if infos.CountUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
				out_count = infos.Count
			}

			if druginfo.MaxUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
				sum_count = druginfo.WarehousingCount * drug.MinNumber
			}

			if druginfo.MaxUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
				sum_count = druginfo.WarehousingCount
			}

			if druginfo.MaxUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
				sum_count = druginfo.WarehousingCount
			}

			if (over_count + out_count) <= sum_count {
				if its.CountUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
					//退库
					warehouseInfo := models.XtSelfDrugWarehouseInfo{
						StockMinNumber: its.Count,
					}
					UpdateSelfDrugWarehouseOne(its.WarehouseInfoId, warehouseInfo)

					//增加退库数量
					AddSelfCancelSumCountOne(advice.PatientId, advice.DrugId, advice.UserOrgId, its.Count)
					//出库数量减少
					UpdateSelfSumOutDrug(advice.UserOrgId, advice.PatientId, advice.DrugId, its.Count)

				}
				if its.CountUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
					warehouseInfo := models.XtSelfDrugWarehouseInfo{
						StockMaxNumber: its.Count,
					}
					UpdateSelfDrugWarehouseTwo(its.WarehouseInfoId, warehouseInfo)

					//增加退库数量
					AddSelfCancelSumCountOne(advice.PatientId, advice.DrugId, advice.UserOrgId, its.Count*drug.MinNumber)
					//出库数量减少
					UpdateSelfSumOutDrug(advice.UserOrgId, advice.PatientId, advice.DrugId, its.Count*drug.MinNumber)
				}

				if its.CountUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
					warehouseInfo := models.XtSelfDrugWarehouseInfo{
						StockMaxNumber: its.Count,
					}
					UpdateSelfDrugWarehouseTwo(its.WarehouseInfoId, warehouseInfo)
					//增加退库数量
					AddSelfCancelSumCountOne(advice.PatientId, advice.DrugId, advice.UserOrgId, its.Count*drug.MinNumber)
					//出库数量减少
					UpdateSelfSumOutDrug(advice.UserOrgId, advice.PatientId, advice.DrugId, its.Count*drug.MinNumber)
				}

			}
		}

		floatPrescrip := strconv.FormatFloat(advice.PrescribingNumber, 'f', -1, 32)
		prescribingNumber, _ := strconv.ParseInt(floatPrescrip, 10, 64)

		if advice.PrescribingNumberUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {

			//查询剩余库存
			stockInfo, _ := GetSelfDrugAllStockInfoOne(advice.PatientId, advice.UserOrgId, advice.DrugId)
			var sum_count int64
			for _, its := range stockInfo {
				if its.MaxUnit == drug.MaxUnit {
					its.StockMaxNumber = its.StockMaxNumber * drug.MinNumber
				}
				sum_count += its.StockMaxNumber + its.StockMinNumber
			}
			var count_one int64
			if advice.PrescribingNumberUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
				count_one = prescribingNumber * drug.MinNumber
			}
			if advice.PrescribingNumberUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
				count_one = prescribingNumber
			}
			if advice.PrescribingNumberUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
				count_one = prescribingNumber * drug.MinNumber
			}
			flow := models.XtSelfDrugFlow{
				WarehousingId:           info.WarehouseInfoId,
				DrugId:                  info.DrugId,
				Number:                  "",
				BatchNumber:             info.BatchNumber,
				Count:                   count_one,
				UserOrgId:               advice.UserOrgId,
				PatientId:               advice.PatientId,
				SystemTime:              info.SysRecordTime,
				ConsumableType:          7,
				IsSys:                   0,
				WarehousingOrder:        "",
				WarehouseOutId:          0,
				WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
				IsEdit:                  0,
				CancelStockId:           0,
				CancelOrderNumber:       "",
				Manufacturer:            info.Manufacturer,
				Dealer:                  info.Dealer,
				Creator:                 creater,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   info.SysRecordTime,
				Mtime:                   0,
				Price:                   info.Price,
				WarehousingDetailId:     info.WarehouseInfoId,
				WarehouseOutDetailId:    0,
				CancelOutDetailId:       0,
				ExpireDate:              info.ExpiryDate,
				ProductDate:             info.ProductDate,
				MaxUnit:                 drug.MinUnit,
				MinUnit:                 "",
				AdviceId:                info.AdviceId,
				StorehouseId:            0,
				OverCount:               sum_count,
				OperateTime:             time.Now().Unix(),
			}
			CreateSelfDrugFlowTwo(flow)

			//删除出库记录
			UpdateSelfDrugFlowSeven(info.PatientId, info.SysRecordTime, info.DrugId, advice.ID, info.ID)
			//删除流水
			UpdateDrugFlowTensOne(info.PatientId, info.WarehouseOutOrderNumber, info.DrugId, advice.ID)
		}
		if advice.PrescribingNumberUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {

			//查询剩余库存
			stockInfo, _ := GetSelfDrugAllStockInfoOne(advice.PatientId, advice.UserOrgId, advice.DrugId)
			var sum_count int64
			for _, its := range stockInfo {
				if its.MaxUnit == drug.MaxUnit {
					its.StockMaxNumber = its.StockMaxNumber * drug.MinNumber
				}
				sum_count += its.StockMaxNumber + its.StockMinNumber
			}

			var count_one int64
			if advice.PrescribingNumberUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
				count_one = prescribingNumber * drug.MinNumber
			}
			if advice.PrescribingNumberUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
				count_one = prescribingNumber
			}
			if advice.PrescribingNumberUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
				count_one = prescribingNumber * drug.MinNumber
			}

			flow := models.XtSelfDrugFlow{
				WarehousingId:           info.WarehouseInfoId,
				DrugId:                  info.DrugId,
				Number:                  "",
				BatchNumber:             info.BatchNumber,
				Count:                   count_one,
				UserOrgId:               advice.UserOrgId,
				PatientId:               advice.PatientId,
				SystemTime:              info.SysRecordTime,
				ConsumableType:          7,
				IsSys:                   0,
				WarehousingOrder:        "",
				WarehouseOutId:          0,
				WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
				IsEdit:                  0,
				CancelStockId:           0,
				CancelOrderNumber:       "",
				Manufacturer:            info.Manufacturer,
				Dealer:                  info.Dealer,
				Creator:                 creater,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   info.SysRecordTime,
				Mtime:                   0,
				Price:                   info.Price,
				WarehousingDetailId:     info.WarehouseInfoId,
				WarehouseOutDetailId:    0,
				CancelOutDetailId:       0,
				ExpireDate:              info.ExpiryDate,
				ProductDate:             info.ProductDate,
				MaxUnit:                 drug.MinUnit,
				MinUnit:                 "",
				AdviceId:                info.AdviceId,
				StorehouseId:            0,
				OverCount:               sum_count,
				OperateTime:             time.Now().Unix(),
			}

			CreateSelfDrugFlowTwo(flow)
			//删除出库记录
			UpdateSelfDrugFlowSeven(info.PatientId, info.SysRecordTime, info.DrugId, advice.ID, info.ID)
			//删除流水
			UpdateDrugFlowTensOne(info.PatientId, info.WarehouseOutOrderNumber, info.DrugId, advice.ID)
		}

		if advice.PrescribingNumberUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {

			//查询剩余库存
			stockInfo, _ := GetSelfDrugAllStockInfoOne(advice.PatientId, advice.UserOrgId, advice.DrugId)
			var sum_count int64
			for _, its := range stockInfo {
				if its.MaxUnit == drug.MaxUnit {
					its.StockMaxNumber = its.StockMaxNumber * drug.MinNumber
				}
				sum_count += its.StockMaxNumber + its.StockMinNumber
			}

			flow := models.XtSelfDrugFlow{
				WarehousingId:           info.WarehouseInfoId,
				DrugId:                  info.DrugId,
				Number:                  "",
				BatchNumber:             info.BatchNumber,
				Count:                   prescribingNumber,
				UserOrgId:               advice.UserOrgId,
				PatientId:               advice.PatientId,
				SystemTime:              info.SysRecordTime,
				ConsumableType:          7,
				IsSys:                   0,
				WarehousingOrder:        "",
				WarehouseOutId:          0,
				WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
				IsEdit:                  0,
				CancelStockId:           0,
				CancelOrderNumber:       "",
				Manufacturer:            info.Manufacturer,
				Dealer:                  info.Dealer,
				Creator:                 creater,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   info.SysRecordTime,
				Mtime:                   0,
				Price:                   info.Price,
				WarehousingDetailId:     info.WarehouseInfoId,
				WarehouseOutDetailId:    0,
				CancelOutDetailId:       0,
				ExpireDate:              info.ExpiryDate,
				ProductDate:             info.ProductDate,
				MaxUnit:                 advice.PrescribingNumberUnit,
				MinUnit:                 "",
				AdviceId:                info.AdviceId,
				StorehouseId:            0,
				OverCount:               sum_count,
				OperateTime:             time.Now().Unix(),
			}

			CreateSelfDrugFlowTwo(flow)
			//删除出库记录
			UpdateSelfDrugFlowSeven(info.PatientId, info.SysRecordTime, info.DrugId, advice.ID, info.ID)
			//删除流水
			UpdateDrugFlowTensOne(info.PatientId, info.WarehouseOutOrderNumber, info.DrugId, advice.ID)
		}

		//更新字典里面的库存
		stockInfo, _ := GetSelfDrugAllStockInfoOne(advice.PatientId, advice.UserOrgId, advice.DrugId)
		//查询改药品信息
		medical, _ := GetBaseDrugMedical(advice.DrugId)
		var sum_count_one int64
		for _, its := range stockInfo {
			if its.MaxUnit == medical.MaxUnit {
				its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
			}
			sum_count_one += its.StockMaxNumber + its.StockMinNumber
		}

		//更新库存
		UpdateSumDrugTwo(advice.UserOrgId, advice.PatientId, advice.DrugId, sum_count_one)

	}
	return err
}

func SelfDrugAutoAddCancelInfoOne(advice *models.DoctorAdvice, creater int64) error {

	//查询该批次病人该药品出库数据
	info, _ := GetSelfDrugAutoWarehouseOutEight(advice.PatientId, advice.AdviceDate, advice.DrugId, advice.ID)
	list, _ := GetSelfDrugAutoWarehouseOutNight(advice.PatientId, advice.AdviceDate, advice.DrugId, advice.ID)

	//退库
	drug, _ := FindBaseDrugLibRecord(advice.UserOrgId, advice.DrugId)

	//如果剩余数量 + 退库数量 < 总入库数量
	if len(list) > 0 {
		for _, its := range list {
			//查询该批次病人该药品出库数据
			infos, _ := GetSelfDrugAutoWarehouseOutTen(advice.PatientId, advice.AdviceDate, advice.DrugId, advice.ID, its.WarehouseInfoId)

			//查询该药品出库批次总入库数量
			druginfo, _ := GetSelfDrugInfoSix(its.WarehouseInfoId, infos.OrgId)

			var out_count int64  //该批次出库库存
			var sum_count int64  //该批次总库存
			var over_count int64 //剩余数量

			if druginfo.MaxUnit != druginfo.MinUnit {
				over_count = druginfo.StockMaxNumber*drug.MinNumber + druginfo.StockMinNumber
			}
			if druginfo.MaxUnit == druginfo.MinUnit {
				over_count = druginfo.StockMaxNumber + druginfo.StockMinNumber
			}

			if infos.CountUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
				out_count = infos.Count * drug.MinNumber

			}
			if infos.CountUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
				out_count = infos.Count
			}

			if infos.CountUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
				out_count = infos.Count
			}

			if druginfo.MaxUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
				sum_count = druginfo.WarehousingCount * drug.MinNumber
			}

			if druginfo.MaxUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
				sum_count = druginfo.WarehousingCount
			}

			if druginfo.MaxUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
				sum_count = druginfo.WarehousingCount
			}
			fmt.Println("over_count-----------", over_count)
			fmt.Println("out_count-----------", out_count)
			fmt.Println("sum_count-----------", sum_count)
			fmt.Println("its.count-------------", its.CountUnit)
			fmt.Println("drug.MaxUnit-------------", drug.MaxUnit)
			fmt.Println("drug.MinUnit-------------", drug.MinUnit)
			if (over_count + out_count) <= sum_count {
				if its.CountUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
					//退库
					warehouseInfo := models.XtSelfDrugWarehouseInfo{
						StockMinNumber: its.Count,
					}
					UpdateSelfDrugWarehouseOne(its.WarehouseInfoId, warehouseInfo)

					//增加退库数量
					AddSelfCancelSumCountOne(advice.PatientId, advice.DrugId, advice.UserOrgId, its.Count)
					//出库数量减少
					UpdateSelfSumOutDrug(advice.UserOrgId, advice.PatientId, advice.DrugId, its.Count)

				}
				if its.CountUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
					warehouseInfo := models.XtSelfDrugWarehouseInfo{
						StockMaxNumber: its.Count,
					}
					UpdateSelfDrugWarehouseTwo(its.WarehouseInfoId, warehouseInfo)

					//增加退库数量
					AddSelfCancelSumCountOne(advice.PatientId, advice.DrugId, advice.UserOrgId, its.Count*drug.MinNumber)
					//出库数量减少
					UpdateSelfSumOutDrug(advice.UserOrgId, advice.PatientId, advice.DrugId, its.Count*drug.MinNumber)
				}

				if its.CountUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
					warehouseInfo := models.XtSelfDrugWarehouseInfo{
						StockMaxNumber: its.Count,
					}
					UpdateSelfDrugWarehouseTwo(its.WarehouseInfoId, warehouseInfo)
					//增加退库数量
					AddSelfCancelSumCountOne(advice.PatientId, advice.DrugId, advice.UserOrgId, its.Count*drug.MinNumber)
					//出库数量减少
					UpdateSelfSumOutDrug(advice.UserOrgId, advice.PatientId, advice.DrugId, its.Count*drug.MinNumber)
				}

			}
		}

		floatPrescrip := strconv.FormatFloat(advice.PrescribingNumber, 'f', -1, 32)
		prescribingNumber, _ := strconv.ParseInt(floatPrescrip, 10, 64)

		if advice.PrescribingNumberUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {

			//查询剩余库存
			stockInfo, _ := GetSelfDrugAllStockInfoOne(advice.PatientId, advice.UserOrgId, advice.DrugId)
			var sum_count int64
			for _, its := range stockInfo {
				if its.MaxUnit == drug.MaxUnit {
					its.StockMaxNumber = its.StockMaxNumber * drug.MinNumber
				}
				sum_count += its.StockMaxNumber + its.StockMinNumber
			}
			var count_one int64
			if advice.PrescribingNumberUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
				count_one = prescribingNumber * drug.MinNumber
			}
			if advice.PrescribingNumberUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
				count_one = prescribingNumber
			}
			if advice.PrescribingNumberUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
				count_one = prescribingNumber * drug.MinNumber
			}
			flow := models.XtSelfDrugFlow{
				WarehousingId:           info.WarehouseInfoId,
				DrugId:                  info.DrugId,
				Number:                  "",
				BatchNumber:             info.BatchNumber,
				Count:                   count_one,
				UserOrgId:               advice.UserOrgId,
				PatientId:               advice.PatientId,
				SystemTime:              info.SysRecordTime,
				ConsumableType:          7,
				IsSys:                   0,
				WarehousingOrder:        "",
				WarehouseOutId:          0,
				WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
				IsEdit:                  0,
				CancelStockId:           0,
				CancelOrderNumber:       "",
				Manufacturer:            info.Manufacturer,
				Dealer:                  info.Dealer,
				Creator:                 creater,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   info.SysRecordTime,
				Mtime:                   0,
				Price:                   info.Price,
				WarehousingDetailId:     info.WarehouseInfoId,
				WarehouseOutDetailId:    0,
				CancelOutDetailId:       0,
				ExpireDate:              info.ExpiryDate,
				ProductDate:             info.ProductDate,
				MaxUnit:                 drug.MinUnit,
				MinUnit:                 "",
				AdviceId:                info.AdviceId,
				StorehouseId:            0,
				OverCount:               sum_count,
				OperateTime:             time.Now().Unix(),
			}
			CreateSelfDrugFlowTwo(flow)

			//删除出库记录
			UpdateSelfDrugFlowSeven(info.PatientId, info.SysRecordTime, info.DrugId, advice.ID, info.ID)
			//删除流水
			UpdateDrugFlowTensOne(info.PatientId, info.WarehouseOutOrderNumber, info.DrugId, advice.ID)
		}
		if advice.PrescribingNumberUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {

			//查询剩余库存
			stockInfo, _ := GetSelfDrugAllStockInfoOne(advice.PatientId, advice.UserOrgId, advice.DrugId)
			var sum_count int64
			for _, its := range stockInfo {
				if its.MaxUnit == drug.MaxUnit {
					its.StockMaxNumber = its.StockMaxNumber * drug.MinNumber
				}
				sum_count += its.StockMaxNumber + its.StockMinNumber
			}

			var count_one int64
			if advice.PrescribingNumberUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
				count_one = prescribingNumber * drug.MinNumber
			}
			if advice.PrescribingNumberUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
				count_one = prescribingNumber
			}
			if advice.PrescribingNumberUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
				count_one = prescribingNumber * drug.MinNumber
			}

			flow := models.XtSelfDrugFlow{
				WarehousingId:           info.WarehouseInfoId,
				DrugId:                  info.DrugId,
				Number:                  "",
				BatchNumber:             info.BatchNumber,
				Count:                   count_one,
				UserOrgId:               advice.UserOrgId,
				PatientId:               advice.PatientId,
				SystemTime:              info.SysRecordTime,
				ConsumableType:          7,
				IsSys:                   0,
				WarehousingOrder:        "",
				WarehouseOutId:          0,
				WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
				IsEdit:                  0,
				CancelStockId:           0,
				CancelOrderNumber:       "",
				Manufacturer:            info.Manufacturer,
				Dealer:                  info.Dealer,
				Creator:                 creater,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   info.SysRecordTime,
				Mtime:                   0,
				Price:                   info.Price,
				WarehousingDetailId:     info.WarehouseInfoId,
				WarehouseOutDetailId:    0,
				CancelOutDetailId:       0,
				ExpireDate:              info.ExpiryDate,
				ProductDate:             info.ProductDate,
				MaxUnit:                 drug.MinUnit,
				MinUnit:                 "",
				AdviceId:                info.AdviceId,
				StorehouseId:            0,
				OverCount:               sum_count,
				OperateTime:             time.Now().Unix(),
			}

			CreateSelfDrugFlowTwo(flow)
			//删除出库记录
			UpdateSelfDrugFlowSeven(info.PatientId, info.SysRecordTime, info.DrugId, advice.ID, info.ID)
			//删除流水
			UpdateDrugFlowTensOne(info.PatientId, info.WarehouseOutOrderNumber, info.DrugId, advice.ID)
		}

		if advice.PrescribingNumberUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {

			//查询剩余库存
			stockInfo, _ := GetSelfDrugAllStockInfoOne(advice.PatientId, advice.UserOrgId, advice.DrugId)
			var sum_count int64
			for _, its := range stockInfo {
				if its.MaxUnit == drug.MaxUnit {
					its.StockMaxNumber = its.StockMaxNumber * drug.MinNumber
				}
				sum_count += its.StockMaxNumber + its.StockMinNumber
			}

			flow := models.XtSelfDrugFlow{
				WarehousingId:           info.WarehouseInfoId,
				DrugId:                  info.DrugId,
				Number:                  "",
				BatchNumber:             info.BatchNumber,
				Count:                   prescribingNumber,
				UserOrgId:               advice.UserOrgId,
				PatientId:               advice.PatientId,
				SystemTime:              info.SysRecordTime,
				ConsumableType:          7,
				IsSys:                   0,
				WarehousingOrder:        "",
				WarehouseOutId:          0,
				WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
				IsEdit:                  0,
				CancelStockId:           0,
				CancelOrderNumber:       "",
				Manufacturer:            info.Manufacturer,
				Dealer:                  info.Dealer,
				Creator:                 creater,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   info.SysRecordTime,
				Mtime:                   0,
				Price:                   info.Price,
				WarehousingDetailId:     info.WarehouseInfoId,
				WarehouseOutDetailId:    0,
				CancelOutDetailId:       0,
				ExpireDate:              info.ExpiryDate,
				ProductDate:             info.ProductDate,
				MaxUnit:                 advice.PrescribingNumberUnit,
				MinUnit:                 "",
				AdviceId:                info.AdviceId,
				StorehouseId:            0,
				OverCount:               sum_count,
				OperateTime:             time.Now().Unix(),
			}

			CreateSelfDrugFlowTwo(flow)
			//删除出库记录
			UpdateSelfDrugFlowSeven(info.PatientId, info.SysRecordTime, info.DrugId, advice.ID, info.ID)
			//删除流水
			UpdateDrugFlowTensOne(info.PatientId, info.WarehouseOutOrderNumber, info.DrugId, advice.ID)
		}

		//更新字典里面的库存
		stockInfo, _ := GetSelfDrugAllStockInfoOne(advice.PatientId, advice.UserOrgId, advice.DrugId)
		//查询改药品信息
		medical, _ := GetBaseDrugMedical(advice.DrugId)
		var sum_count_one int64
		for _, its := range stockInfo {
			if its.MaxUnit == medical.MaxUnit {
				its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
			}
			sum_count_one += its.StockMaxNumber + its.StockMinNumber
		}

		//更新库存
		UpdateSumDrugTwo(advice.UserOrgId, advice.PatientId, advice.DrugId, sum_count_one)

	}
	return err
}

func GetDrugInventoryRecordList(limit int64, page int64, keyword string, storehouse_id int64, startTime int64, endTime int64, orgId int64) (list []*models.XtDrugStockInventoryList, total int64, err error) {

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

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

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

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

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

	if endTime > 0 {
		db = db.Where("record_date<=?", endTime)
	}

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

	err = db.Count(&total).Offset(offset).Limit(limit).Order("record_date desc").Find(&list).Error

	return list, total, err

}

func GetDrugInventoryRecordPrintList(limit int64, page int64, keyword string, storehouse_id int64, orgId int64, startTime int64, endTime int64, idSplit []string) (list []*models.XtDrugStockInventoryList, total int64, err error) {

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

	db := XTReadDB().Model(&list).Where("status =1")
	if len(keyword) > 0 {
		db = db.Where("drug_name like ?", likeKey)
	}

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

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

	if startTime > 0 {
		db = db.Where("record_date>=?", startTime)
	}
	if endTime > 0 {
		db = db.Where("record_date<=?", endTime)
	}

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

	err = db.Count(&total).Offset(offset).Limit(limit).Order("record_date desc").Find(&list).Error

	return list, total, err

}

func GetDrugWarehosueInfoList(org_id int64, start_time int64, end_time int64) (flow []*models.XtDrugFlowList, err error) {

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

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

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

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

	err = db.Find(&flow).Error

	return flow, err
}

func GetDrugWarhouseHouseOutInfo(org_id int64, start_time int64, end_time int64) (flow []*models.XtDrugFlowList, err error) {

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

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

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

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

	err = db.Find(&flow).Error

	return flow, err

}

func GetDrugWarehouseCancelOutInfo(org_id int64, start_time int64, end_time int64) (flow []*models.XtDrugFlowList, err error) {

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

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

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

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

	err = db.Find(&flow).Error

	return flow, err
}

func GetDrugMonthWarehouseInfo(org_id int64, start_time int64) (flow []*models.XtDrugFlowList, err error) {

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

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

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

	err = db.Find(&flow).Error

	return flow, err
}

func GetDrugMonthWarehouseOutInfo(org_id int64, start_time int64) (flow []*models.XtDrugFlowList, err error) {

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

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

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

	err = db.Find(&flow).Error

	return flow, err
}

func GetDrugMonthCancelOutInfo(org_id int64, start_time int64) (flow []*models.XtDrugFlowList, err error) {

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

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

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

	err = db.Find(&flow).Error

	return flow, err
}

func ModifyDrugCodeWarehosueInfo(id int64, drug_code string) (models.XtDrugWarehouseInfo, error) {

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

	return drugWarehouseInfo, err
}

func GetAllDrugInfoList(drug_id int64, user_org_id int64) (info []*models.XtDrugWarehouseInfo, err error) {

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

	return info, err
}

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

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

	return info, err
}

func GetSelfDrugWarhouseInfoByPatient(drug_id int64, patient_id int64, user_org_id int64) (info []*models.XtSelfDrugWarehouseInfo, err error) {

	err = XTReadDB().Where("drug_id = ? and patient_id = ? and org_id = ? and status=1 and is_check=1", drug_id, patient_id, user_org_id).Order("ctime desc").Find(&info).Error

	return info, err
}

func GetDrugWarehouseInfoByStartTime(drug_id int64, org_id int64, ctime int64) (drugInfo []*models.TsDrugWarehouseInfo, err error) {

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

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

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

	if ctime > 0 {
		db = db.Where("ctime < ?", ctime)
	}
	err = db.Find(&drugInfo).Error

	return drugInfo, err
}

func GetBaseDrugById(id int64) (models.LyBaseDrug, error) {

	baseDrug := models.LyBaseDrug{}
	err := XTReadDB().Where("id = ?", id).Find(&baseDrug).Error
	return baseDrug, err
}

func GetProfitDrugFlow(drug_id int64, user_org_id int64, ctime int64) (flow []*models.LyDrugFlow, 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.Find(&flow).Error

	return flow, err
}

func GetReduceDrugFlow(drug_id int64, user_org_id int64, ctime int64) (flow []*models.LyDrugFlow, 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.Find(&flow).Error
	return flow, err
}

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

	db := XTReadDB().Model(&flow).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 ctime > 0 {
		db = db.Where("ctime<?", ctime)
	}
	err = db.Find(&flow).Error
	return flow, err

}

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

	db := XTReadDB().Model(&flow).Where("status=1 and consumable_type = 3")
	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.Find(&flow).Error
	return flow, err

}

func GetInitAddDrugFlow(drug_id int64, org_id int64, start_time int64, end_time int64) (info []*models.TsDrugWarehouseInfo, err error) {

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

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

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

func GetInitOutDrugFlow(drug_id int64, org_id int64, start_time int64, end_time int64) (flow []*models.LyDrugFlow, err error) {

	db := XTReadDB().Model(&flow).Where("status=1 and consumable_type = 3")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if org_id > 0 {
		db = db.Where("user_org_id = ?", org_id)
	}

	if start_time > 0 {
		db = db.Where("ctime>=?", start_time)
	}
	if end_time > 0 {
		db = db.Where("ctime<=?", end_time)
	}
	err = db.Find(&flow).Error

	return flow, err
}

func GetInitReturnDrugFlow(drug_id int64, org_id int64, start_time int64, end_time int64) (flow []*models.LyDrugFlow, err error) {

	db := XTReadDB().Model(&flow).Where("status=1 and consumable_type = 7")
	if drug_id > 0 {
		db = db.Where("drug_id = ?", drug_id)
	}
	if org_id > 0 {
		db = db.Where("user_org_id = ?", org_id)
	}

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

func GetInitProfitDrugFlow(drug_id int64, org_id int64, start_time int64, end_time int64) (flow []*models.LyDrugFlow, 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 org_id > 0 {
		db = db.Where("user_org_id = ?", org_id)
	}

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

func GetInitReduceDrugFlow(drug_id int64, org_id int64, start_time int64, end_time int64) (flow []*models.LyDrugFlow, 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 org_id > 0 {
		db = db.Where("user_org_id = ?", org_id)
	}

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