package service

import (
	"errors"
	"fmt"
	"github.com/astaxie/beego/orm"
	"rtzh_elec_temperature/enum"
	"rtzh_elec_temperature/logger"
	"rtzh_elec_temperature/models/bo"
	"rtzh_elec_temperature/rtelec_app_public_lib/models"
	"rtzh_elec_temperature/rtelec_app_public_lib/models/vo"
	"sync"
)

// 绝对值告警缓存
var abslist = sync.Map{}

// 升温告警缓存
var riselist = sync.Map{}

// 温度不平衡告警缓存
var unbalancelist = sync.Map{}

// 告警明细缓存
var alarmMpList = sync.Map{}

type AlarmTactics struct {
	BaseService
}

// 绝对值告警设置-获取列表数据
func (t *AlarmTactics) GetAbsList() []orm.Params {
	key := "abslist"
	if info, ok := abslist.Load(key); ok {
		return info.([]orm.Params)
	}
	db := orm.NewOrm()
	var sqlCommandText = "select id,strategy_name,alarm_level,mod_name,mod_id,operation_symbol,threshold from t_base_absolute_alarm"
	lst := []orm.Params{}
	_, err := db.Raw(sqlCommandText).Values(&lst)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error SQL:%s.", sqlCommandText))
		return nil
	}
	// 数据量小可以循环读取每一个记录的明细测点
	sqlCommandText = "select mod_id,mod_name,attrname from t_base_alarm_mplist where alarm_type=1 and fk_id=?"
	for _, row := range lst {
		mplst := []orm.Params{}
		_, err = db.Raw(sqlCommandText, row["id"]).Values(&mplst)
		if err != nil {
			logger.Logger.Error(err)
			logger.Logger.Println(fmt.Sprintf("Error SQL:%s.", sqlCommandText))
			return nil
		}
		row["mplist"] = mplst
	}
	abslist.Store(key, lst)
	return lst
}

// 绝对值告警设置-保存绝对值告警信息
func (t *AlarmTactics) SaveAbsAlarmTactics(info vo.AlarmTacticsAbsInfo) int64 {
	db := orm.NewOrm()
	var sqlCommandText = "insert into t_base_absolute_alarm (strategy_name,alarm_level,mod_name,mod_id,operation_symbol,threshold) values (?,?,?,?,?,?)"
	var paramValues = []interface{}{info.Strategy_name, info.Alarm_level, info.Mod_name, info.Mod_id, info.Operation_symbol, info.Threshold}
	db.Begin()
	res, err := db.Raw(sqlCommandText, paramValues).Exec()
	id, _ := res.LastInsertId()
	if err != nil {
		db.Rollback()
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error SQL:%s.\nParam is:%s", sqlCommandText, paramValues))
		return 0
	}
	sqlCommandText = "insert into t_base_alarm_mplist (fk_id,alarm_type,mod_id,mod_name,attrname)values"
	mplist := info.MpIdNameList
	var parms = []interface{}{}
	if len(mplist) > 0 {
		for index, row := range mplist {
			if index == len(mplist)-1 {
				sqlCommandText += "(?,?,?,?,?)"
			} else {
				sqlCommandText += "(?,?,?,?,?),"
			}
			parms = append(parms, id, 1, info.Mod_id, info.Mod_name, row["attrname"])
		}
		_, err := db.Raw(sqlCommandText, parms).Exec()
		if err != nil {
			db.Rollback()
			logger.Logger.Error(err)
			logger.Logger.Println(fmt.Sprintf("Error SQL:%s.\nParam is:%s", sqlCommandText, parms))
			return 0
		}
	}
	err = db.Commit()
	if err != nil {
		new(bo.SystemLog).Fail(enum.Abs_Alarm_tactics,
			enum.LogType_Insert,
			enum.OptEventType_Bus,
			enum.OptEventLevel_Hight,
			fmt.Sprintf("保存绝对值告警信息失败:%s", err.Error()),
			map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
		)
	}
	key := "abslist"
	abslist.Delete(key)
	new(bo.SystemLog).Success(enum.Abs_Alarm_tactics,
		enum.LogType_Insert,
		enum.OptEventType_Bus,
		enum.OptEventLevel_Hight,
		fmt.Sprintf("保存绝对值告警信息成功！"),
		map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
	)
	return id
}

// 绝对值告警设置-更新绝对值告警设置
func (t *AlarmTactics) UpdateAbsAlarmTactics(info vo.AlarmTacticsAbsInfo) (int64, error) {
	//obj := new(models.T_base_absolute_alarm)
	obj := models.T_base_absolute_alarm{Id: info.Id}
	if info.Id == 0 {
		return 0, errors.New("记录id不能为空!")
	}
	obj.Strategy_name = info.Strategy_name
	obj.Alarm_level = info.Alarm_level
	obj.Mod_name = info.Mod_name
	obj.Mod_id = info.Mod_id
	obj.Operation_symbol = info.Operation_symbol
	obj.Threshold = info.Threshold
	db := orm.NewOrm()
	num, err := db.Update(&obj)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Update Error:%s", err.Error()))
		return 0, err
	}
	// 先删除原有节点信息,再添加新的信息
	var sqlCommandText = "delete from t_base_alarm_mplist where alarm_type=1 and fk_id=?"
	_, err = db.Raw(sqlCommandText, info.Id).Exec()
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error SQL:%s.\nParam is:%s", sqlCommandText, info.Id))
		return 0, err
	}
	sqlCommandText = "insert into t_base_alarm_mplist (fk_id,alarm_type,mod_id,mod_name,attrname)values"
	mplist := info.MpIdNameList
	var parms = []interface{}{}
	if len(mplist) > 0 {
		for index, row := range mplist {
			if index == len(mplist)-1 {
				sqlCommandText += "(?,?,?,?,?)"
			} else {
				sqlCommandText += "(?,?,?,?,?),"
			}
			parms = append(parms, info.Id, 1, info.Mod_id, info.Mod_name, row["attrname"])
		}
		_, err := db.Raw(sqlCommandText, parms).Exec()
		if err != nil {
			logger.Logger.Error(err)
			logger.Logger.Println(fmt.Sprintf("Error SQL:%s.\nParam is:%s", sqlCommandText, parms))
			return 0, err
		}
	}
	key := "abslist"
	abslist.Delete(key)
	new(bo.SystemLog).Success(enum.Abs_Alarm_tactics,
		enum.LogType_Update,
		enum.OptEventType_Bus,
		enum.OptEventLevel_Hight,
		fmt.Sprintf("更新绝对值告警信息成功！"),
		map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
	)
	return num, nil
}

// 绝对值告警设置-删除绝对值告警信息
func (t *AlarmTactics) DelAbsAlarmTactics(fkId int64) bool {
	db := orm.NewOrm()
	db.Begin()
	var sqlCommandText = "DELETE from t_base_absolute_alarm where id = ?"
	_, err := db.Raw(sqlCommandText, fkId).Exec()
	if err != nil {
		db.Rollback()
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error SQL:%s.\nParam is:%s", sqlCommandText, fkId))
		return false
	}
	sqlCommandText = "DELETE from t_base_alarm_mplist where alarm_type=1 and fk_id=?"
	_, err = db.Raw(sqlCommandText, fkId).Exec()
	if err != nil {
		db.Rollback()
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error SQL:%s.\nParam is:%s", sqlCommandText, fkId))
		return false
	}
	err = db.Commit()
	if err != nil {
		new(bo.SystemLog).Fail(enum.Abs_Alarm_tactics,
			enum.LogType_Insert,
			enum.OptEventType_Bus,
			enum.OptEventLevel_Hight,
			fmt.Sprintf("删除绝对值告警信息失败:%s", err.Error()),
			map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
		)
	}
	key := "abslist"
	abslist.Delete(key)
	new(bo.SystemLog).Success(enum.Abs_Alarm_tactics,
		enum.LogType_Delete,
		enum.OptEventType_Bus,
		enum.OptEventLevel_Hight,
		fmt.Sprintf("删除绝对值告警信息成功！"),
		map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
	)
	return true
}

// 升温告警设置-获取列表数据
func (t *AlarmTactics) GetRiseList() []orm.Params {
	key := "riselist"
	if info, ok := riselist.Load(key); ok {
		return info.([]orm.Params)
	}
	db := orm.NewOrm()
	var sqlCommandText = "select id,strategy_name,alarm_level,mod_name,mod_id,upcycle,scope from t_base_rise_alarm"
	lst := []orm.Params{}
	_, err := db.Raw(sqlCommandText).Values(&lst)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error SQL:%s.", sqlCommandText))
		return nil
	}
	// 数据量小可以循环读取每一个记录的明细测点
	sqlCommandText = "select mod_id,mod_name,attrname from t_base_alarm_mplist where alarm_type=2 and fk_id=?"
	for _, row := range lst {
		mplst := []orm.Params{}
		_, err = db.Raw(sqlCommandText, row["id"]).Values(&mplst)
		if err != nil {
			logger.Logger.Error(err)
			logger.Logger.Println(fmt.Sprintf("Error SQL:%s.", sqlCommandText))
			return nil
		}
		row["mplist"] = mplst
	}
	riselist.Store(key, lst)
	return lst
}

// 升温告警设置-保存升温告警信息
func (t *AlarmTactics) SaveRiseAlarmTactics(info vo.AlarmTacticsRiseInfo) int64 {
	db := orm.NewOrm()
	var sqlCommandText = "insert into t_base_rise_alarm (strategy_name,alarm_level,mod_name,mod_id,upcycle,scope) values (?,?,?,?,?,?)"
	var paramValues = []interface{}{info.Strategy_name, info.Alarm_level, info.Mod_name, info.Mod_id, info.Upcycle, info.Scope}
	db.Begin()
	res, err := db.Raw(sqlCommandText, paramValues).Exec()
	id, _ := res.LastInsertId()
	if err != nil {
		db.Rollback()
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error SQL:%s.\nParam is:%s", sqlCommandText, paramValues))
		return 0
	}
	sqlCommandText = "insert into t_base_alarm_mplist (fk_id,alarm_type,mod_id,mod_name,attrname)values"
	mplist := info.MpIdNameList
	var parms = []interface{}{}
	if len(mplist) > 0 {
		for index, row := range mplist {
			if index == len(mplist)-1 {
				sqlCommandText += "(?,?,?,?,?)"
			} else {
				sqlCommandText += "(?,?,?,?,?),"
			}
			parms = append(parms, id, 2, info.Mod_id, info.Mod_name, row["attrname"])
		}
		_, err := db.Raw(sqlCommandText, parms).Exec()
		if err != nil {
			db.Rollback()
			logger.Logger.Error(err)
			logger.Logger.Println(fmt.Sprintf("Error SQL:%s.\nParam is:%s", sqlCommandText, parms))
			return 0
		}
	}
	err = db.Commit()
	if err != nil {
		new(bo.SystemLog).Fail(enum.Rise_Alarm_tactics,
			enum.LogType_Insert,
			enum.OptEventType_Bus,
			enum.OptEventLevel_Hight,
			fmt.Sprintf("保存升温告警信息失败:%s", err.Error()),
			map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
		)
	}
	key := "riselist"
	riselist.Delete(key)
	new(bo.SystemLog).Success(enum.Rise_Alarm_tactics,
		enum.LogType_Insert,
		enum.OptEventType_Bus,
		enum.OptEventLevel_Hight,
		fmt.Sprintf("保存升温告警信息成功！"),
		map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
	)
	return id
}

// 升温告警设置-更新升温告警信息
func (t *AlarmTactics) UpdateRiseAlarmTactics(info vo.AlarmTacticsRiseInfo) (int64, error) {
	obj := models.T_base_rise_alarm{Id: info.Id}
	if info.Id == 0 {
		return 0, errors.New("记录id不能为空!")
	}
	obj.Strategy_name = info.Strategy_name
	obj.Alarm_level = info.Alarm_level
	obj.Mod_name = info.Mod_name
	obj.Mod_id = info.Mod_id
	obj.Upcycle = info.Upcycle
	obj.Scope = info.Scope
	db := orm.NewOrm()
	num, err := db.Update(&obj)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Update Error:%s", err.Error()))
		return 0, err
	}
	// 先删除原有节点信息,再添加新的信息
	var sqlCommandText = "delete from t_base_alarm_mplist where alarm_type=2 and fk_id=?"
	_, err = db.Raw(sqlCommandText, info.Id).Exec()
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error SQL:%s.\nParam is:%s", sqlCommandText, info.Id))
		return 0, err
	}
	sqlCommandText = "insert into t_base_alarm_mplist (fk_id,alarm_type,mod_id,mod_name,attrname) values"
	mplist := info.MpIdNameList
	var parms = []interface{}{}
	if len(mplist) > 0 {
		for index, row := range mplist {
			if index == len(mplist)-1 {
				sqlCommandText += "(?,?,?,?,?)"
			} else {
				sqlCommandText += "(?,?,?,?,?),"
			}
			parms = append(parms, info.Id, 2, info.Mod_id, info.Mod_name, row["attrname"])
		}
		_, err := db.Raw(sqlCommandText, parms).Exec()
		if err != nil {
			logger.Logger.Error(err)
			logger.Logger.Println(fmt.Sprintf("Error SQL:%s.\nParam is:%s", sqlCommandText, parms))
			return 0, err
		}
	}
	key := "riselist"
	riselist.Delete(key)
	new(bo.SystemLog).Success(enum.Rise_Alarm_tactics,
		enum.LogType_Update,
		enum.OptEventType_Bus,
		enum.OptEventLevel_Hight,
		fmt.Sprintf("更新升温告警信息成功！"),
		map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
	)
	return num, nil
}

// 升温告警设置-删除升温告警信息
func (t *AlarmTactics) DelRiseAlarmTactics(fkId int64) (bool, error) {
	db := orm.NewOrm()
	db.Begin()
	var sqlCommandText = "DELETE from t_base_rise_alarm where id = ?"
	_, err := db.Raw(sqlCommandText, fkId).Exec()
	if err != nil {
		db.Rollback()
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error SQL:%s.\nParam is:%s", sqlCommandText, fkId))
		return false, err
	}
	sqlCommandText = "DELETE from t_base_alarm_mplist where alarm_type=2 and fk_id=?"
	_, err = db.Raw(sqlCommandText, fkId).Exec()
	if err != nil {
		db.Rollback()
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error SQL:%s.\nParam is:%s", sqlCommandText, fkId))
		return false, err
	}
	err = db.Commit()
	if err != nil {
		new(bo.SystemLog).Fail(enum.Rise_Alarm_tactics,
			enum.LogType_Delete,
			enum.OptEventType_Bus,
			enum.OptEventLevel_Hight,
			fmt.Sprintf("删除升温告警信息失败:%s", err.Error()),
			map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
		)
	}
	key := "riselist"
	riselist.Delete(key)
	new(bo.SystemLog).Success(enum.Rise_Alarm_tactics,
		enum.LogType_Delete,
		enum.OptEventType_Bus,
		enum.OptEventLevel_Hight,
		fmt.Sprintf("删除升温告警信息成功！"),
		map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
	)
	return true, nil
}

// 温度不平衡告警设置-获取列表数据
func (t *AlarmTactics) GetUnbalanceList() []orm.Params {
	key := "unbalancelist"
	if info, ok := unbalancelist.Load(key); ok {
		return info.([]orm.Params)
	}
	db := orm.NewOrm()
	var sqlCommandText = "select id,strategy_name,alarm_level,operation_symbol,threshold from t_base_unbalance_alarm"
	lst := []orm.Params{}
	_, err := db.Raw(sqlCommandText).Values(&lst)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error SQL:%s.", sqlCommandText))
		return nil
	}
	unbalancelist.Store(key, lst)
	return lst
}

// 温度不平衡告警设置-保存温度不平衡告警设置
func (t *AlarmTactics) SaveUnbalanceAlarmTactics(info vo.AlarmTacticsUnbalanceInfo) (int64, error) {
	db := orm.NewOrm()
	var sqlCommandText = "insert into t_base_unbalance_alarm (strategy_name,alarm_level,operation_symbol,threshold) values (?,?,?,?)"
	var paramValues = []interface{}{info.Strategy_name, info.Alarm_level, info.Operation_symbol, info.Threshold}
	res, err := db.Raw(sqlCommandText, paramValues).Exec()
	id, _ := res.LastInsertId()
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error SQL:%s.\nParam is:%s", sqlCommandText, paramValues))
		return 0, err
	}
	key := "unbalancelist"
	unbalancelist.Delete(key)
	new(bo.SystemLog).Success(enum.Unbalance_Alarm_tactics,
		enum.LogType_Insert,
		enum.OptEventType_Bus,
		enum.OptEventLevel_Hight,
		fmt.Sprintf("保存温度不平衡告警信息成功！"),
		map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
	)
	return id, nil
}

// 温度不平衡告警设置-更新温度不平衡告警设置
func (t *AlarmTactics) UpdateUnbalanceAlarmTactics(info vo.AlarmTacticsUnbalanceInfo) (int64, error) {
	obj := models.T_base_unbalance_alarm{}
	if info.Id == 0 {
		return 0, errors.New("记录id不能为空!")
	}
	obj.Id = info.Id
	obj.Strategy_name = info.Strategy_name
	obj.Alarm_level = info.Alarm_level
	obj.Operation_symbol = info.Operation_symbol
	obj.Threshold = info.Threshold
	db := orm.NewOrm()
	num, err := db.Update(&obj)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Update Error:%s", err.Error()))
		return 0, err
	}
	key := "unbalancelist"
	unbalancelist.Delete(key)
	new(bo.SystemLog).Success(enum.Unbalance_Alarm_tactics,
		enum.LogType_Update,
		enum.OptEventType_Bus,
		enum.OptEventLevel_Hight,
		fmt.Sprintf("更新温度不平衡告警信息成功！"),
		map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
	)
	return num, nil
}

// 温度不平衡告警设置-删除温度不平衡告警设置
func (t *AlarmTactics) DelUnbalanceAlarmTactics(fkId int64) (bool, error) {
	db := orm.NewOrm()
	var sqlCommandText = "DELETE from t_base_unbalance_alarm where id = ?"
	_, err := db.Raw(sqlCommandText, fkId).Exec()
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error SQL:%s.\nParam is:%s", sqlCommandText, fkId))
		return false, err
	}
	key := "unbalancelist"
	unbalancelist.Delete(key)
	new(bo.SystemLog).Success(enum.Unbalance_Alarm_tactics,
		enum.LogType_Delete,
		enum.OptEventType_Bus,
		enum.OptEventLevel_Hight,
		fmt.Sprintf("删除温度不平衡告警信息成功！"),
		map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
	)
	return true, nil
}

// 根据测点属性名返回该测点对应的绝对值规则
func (t *AlarmTactics) GetAttrAbs(attrName string) []orm.Params {
	abs, ok := abslist.Load("abslist")
	if !ok {
		abs = t.GetAbsList()
	}
	lst := []orm.Params{}
	absAlarmList := abs.([]orm.Params)
	for _, item := range absAlarmList {
		mplst := item["mplist"].([]orm.Params)
		for _, row := range mplst {
			a := fmt.Sprint(row["attrname"])
			if a == attrName {
				lst = append(lst, item)
				continue
			}
		}
	}
	return lst
}

// 根据测点返回该测点的升温规则
func (t *AlarmTactics) GetAttrRise(attrName string) []orm.Params {
	rise, ok := riselist.Load("riselist")
	if !ok {
		rise = t.GetRiseList()
	}
	lst := []orm.Params{}
	riseAlarmList := rise.([]orm.Params)
	for _, item := range riseAlarmList {
		mplst := item["mplist"].([]orm.Params)
		for _, row := range mplst {
			a := fmt.Sprint(row["attrname"])
			if a == attrName {
				lst = append(lst, item)
				continue
			}
		}
	}
	return lst
}

// 读取独立配置的绝对值告警规则
func (t *AlarmTactics) GetAloneAttrAbs(deviceid int64, mpid int64) []orm.Params {
	db := orm.NewOrm()
	var sql = "SELECT t.deviceid,t.mpid,t.alarm_id,t.attrname,t.mpname,t.upcycle,t.threshold,t.alarm_type,a.strategy_name,a.operation_symbol,a.alarm_level FROM t_base_alone_alarm t,t_base_absolute_alarm a WHERE a.id = t.alarm_id and t.alarm_type=1 and deviceid=? and mpid=?"
	lst := []orm.Params{}
	_, err := db.Raw(sql, deviceid, mpid).Values(&lst)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error is:%s.", err.Error()))
		return nil
	}
	return lst
}

// 读取独立配置的升温告警规则
func (t *AlarmTactics) GetAloneAttrRise(deviceid int64, mpid int64) []orm.Params {
	db := orm.NewOrm()
	var sql = "SELECT t.deviceid,t.mpid,t.alarm_id,t.attrname,t.mpname,t.upcycle,t.threshold,t.alarm_type,a.strategy_name,a.upcycle,a.alarm_level FROM t_base_alone_alarm t,t_base_rise_alarm a WHERE a.id = t.alarm_id and t.alarm_type=2 and deviceid=? and mpid=?"
	lst := []orm.Params{}
	_, err := db.Raw(sql, deviceid, mpid).Values(&lst)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error is:%s.", err.Error()))
		return nil
	}
	return lst
}

//// 读取独立配置的温度不平衡告警规则
//func (t *AlarmTactics) GetAloneAttrUnbalance(deviceid int64, mpid int64) []orm.Params {
//	db := orm.NewOrm()
//	var sql = "SELECT t.deviceid,t.mpid,t.alarm_id,t.attrname,t.mpname,t.upcycle,t.threshold,t.alarm_type,a.strategy_name,a.operation_symbol,a.alarm_level FROM t_base_alone_alarm t,t_base_unbalance_alarm a WHERE a.id = t.alarm_id and t.alarm_type=3 and deviceid=? and mpid=?"
//	lst := []orm.Params{}
//	_, err := db.Raw(sql, deviceid, mpid).Values(&lst)
//	if err != nil {
//		logger.Logger.Error(err)
//		logger.Logger.Println(fmt.Sprintf("Error is:%s.", err.Error()))
//		return nil
//	}
//	return lst
//}