XT_New/service/self_drug_service.go

package service

import (
	"XT_New/models"
	"fmt"
	"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 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(&orgid).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"`
}

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

}