XT_New/service/self_drug_service.go

package service

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

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 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                  float64  `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"`
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return drugName, err

}

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

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

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

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

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

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

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

	return selfoutstock, total, err
}

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

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

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

	info := models.XtDrugWarehouseOutInfo{}

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

	return info, err
}

func PostSearchDrugWarehouseList(keyword string, orgid int64, storehouse_id int64) (info []*models.BloodDrugWarehouseInfo, err error) {
	db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1")
	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) (info []*models.XtDrugWarehouseInfo, err error) {

	err = XTReadDB().Model(&info).Where("drug_id=? and status = 1 and storehouse_id = ?", 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,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").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
	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,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").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.ctime desc").Offset(offset).Limit(limit).Scan(&list).Error
	return list, total, err
}

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

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

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

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

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

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

func CreateDrugWarehouseInfo(info models.DrugWarehouseInfo) error {

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

func CreateDrugWarehouseOutInfo(info models.DrugWarehouseOutInfo) error {

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

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

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

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

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

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

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