def delete(self):
group_id_hex = hexlify(self.id).decode()
group_key = ConstDB.group + group_id_hex
"""
group_devs = db0.keys(ConstDB.group_dev + group_id_hex + ':*')
"""
group_devs_list = self._get_device_list()
group_devs = [
(ConstDB.group_dev + group_id_hex + ':' + i_group_list).encode()
for i_group_list in group_devs_list
]
statistics_down = db0.keys(ConstDB.statistics_down + group_key + ':*')
msg_down = db0.keys(ConstDB.msg_down + group_key + ':*')
pipe = db0.pipeline()
for key in group_devs:
pipe.delete(key)
for key in msg_down:
pipe.delete(key)
for key in statistics_down:
pipe.delete(key)
pipe.srem(ConstDB.app_groups + hexlify(self.app_eui).decode(), self.id)
pipe.delete(ConstDB.que_down + group_key)
pipe.delete(ConstDB.addr + hexlify(self.addr).decode())
pipe.delete(group_key)
pipe.execute()
AddrManger.recycle_addr(self.addr)
def count_in_daily(self):
"""
一天为单位计数
:return:返回30天前的上行数据
"""
res = {}
cur_time = datetime.now()
for x in range(0, 30):
date = cur_time - timedelta(29 - x)
date_str = date.strftime("%Y-%m-%d")
keys = db0.keys(self.key + date_str + ':*')
for key in keys:
data = db0.hgetall(key)
for freq, value in data.items():
freq = float(freq)
if freq not in res.keys():
res[freq] = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
res[freq][x] += int(value)
new_res = []
for freq, num_list in res.items():
new_res.append({'name': freq, 'data': num_list})
return new_res
def all(cls, type=None, eui=None, start_ts=0, end_ts=-1):
"""
:param app_eui: bytes
:param dev_eui: bytes
:param group_id: bytes
:param start_ts: int
:param end_ts: int
:return:
"""
assert type == 'GROUP' or type == 'DEV', 'MSG_DOWN TYPE ERROR'
if end_ts == -1:
end_ts = int(time.time())
if eui is None:
eui = '*'
else:
eui = hexlify(eui).decode()
if type is None:
type = '*'
keys = db0.keys(ConstDB.msg_down + type + ':' + eui + ':*')
# logger.debug('WHY NO MSG SHOW' + 'KEYS LENGTH: %d' % len(keys))
msgs = []
for key in keys:
key = key.decode()
ts = int(key.split(':')[3])
if start_ts < ts < end_ts:
msg = cls.get(key)
msgs.append(msg)
else:
logger.debug('WHY NO MSG SHOW' +
'MSGS BE FILTERED: %s' % key)
return msgs
def all(cls, dev_eui=None, gateway_id=None):
"""
:param dev_eui: bytes
:return:
"""
list_trans_params = []
if dev_eui is not None:
keys = db0.keys(pattern=ConstDB.trans_params +
hexlify(dev_eui).decode() + ':*')
for key in keys:
trans_params = cls.get(
dev_eui, unhexlify(key.decode().split(':')[2]))
list_trans_params.append(trans_params)
elif gateway_id is not None:
keys = db0.keys(pattern=ConstDB.trans_params + '*:' +
hexlify(gateway_id).decode())
for key in keys:
trans_params = cls.get(
unhexlify(key.decode().split(':')[1]), gateway_id)
list_trans_params.append(trans_params)
return list_trans_params
def delete(self):
db_sql.session.delete(self)
db_sql.session.commit()
# delete from sql
id = hexlify(self.id).decode()
gateway_trans = db0.keys(pattern=ConstDB.trans_params + '*' + id)
pipe = db0.pipeline()
for key in gateway_trans:
key = key.decode()
pipe.delete(key)
dev_eui = key.split(":")[1]
pipe.zrem(ConstDB.dev_gateways + dev_eui, self.id)
pipe.delete(ConstDB.gateway + id)
pipe.delete(ConstDB.gateway_pull + id)
pipe.execute()
def all(cls, group_id=None):
"""
:param app_eui: bytes
:return:
"""
devices = []
keys = []
if group_id is not None:
keys = db0.keys(ConstDB.group_dev +
hexlify(group_id).decode() + ':*')
keys = [unhexlify(key.decode().split(':')[2]) for key in keys]
for key in keys:
device = Device.query.get(key)
devices.append(device)
return devices
def delete(self):
db_sql.session.delete(self)
db_sql.session.flush()
if self.active_at is not None:
app_eui = hexlify(self.app_eui).decode()
dev_eui = hexlify(self.dev_eui).decode()
addr = hexlify(db0.hget(ConstDB.dev + dev_eui,
FieldDevice.addr)).decode()
msgs_up = db0.keys(ConstDB.msg_up + app_eui + ':' + dev_eui + ':*')
msgs_down = db0.keys(ConstDB.msg_down + ConstDB.dev + dev_eui +
':*')
mac_cmds = db0.keys(ConstDB.mac_cmd + dev_eui + ':*')
trans_params = db0.keys(ConstDB.trans_params + dev_eui + ':*')
# groups = db0.keys(ConstDB.group_dev + '*:' + dev_eui)
dbsession = DBSession()
query = dbsession.query(GroupDevice.group_id).filter(
GroupDevice.dev_id == dev_eui).all()
dbsession.close()
group_devs_list = [i_query[0] for i_query in query]
groups = [
(ConstDB.group_dev + i_group_list + ':' + dev_eui).encode()
for i_group_list in group_devs_list
]
statistics_up = db0.keys(ConstDB.statistics_up + dev_eui + ':*')
statistics_down = db0.keys(ConstDB.statistics_down + ConstDB.dev +
dev_eui + ':*')
pipe = db0.pipeline()
pipe.delete(ConstDB.dev_ack + dev_eui)
pipe.delete(ConstDB.dev + dev_eui)
pipe.srem(ConstDB.app_devs + app_eui, self.dev_eui)
for key in groups:
pipe.delete(key)
pipe.delete(ConstDB.addr + addr)
pipe.delete(ConstDB.dev_gateways + dev_eui)
for key in mac_cmds:
pipe.delete(key)
for key in msgs_up:
pipe.delete(key)
for key in msgs_down:
pipe.delete(key)
pipe.delete(ConstDB.que_down + ConstDB.dev + dev_eui)
pipe.delete(ConstDB.mac_cmd_que + dev_eui)
for key in trans_params:
pipe.delete(key)
for key in statistics_down:
pipe.delete(key)
for key in statistics_up:
pipe.delete(key)
pipe.execute()
AddrManger.recycle_addr(unhexlify(addr))
db_sql.session.commit()
def all(cls, app_eui=None):
"""
:param app_eui: 8 bytes
:return:
"""
groups = []
if app_eui is not None:
keys = db0.smembers(ConstDB.app_groups +
hexlify(app_eui).decode())
for key in keys:
group = cls.get(key)
groups.append(group)
else:
keys = db0.keys(ConstDB.group + '*')
for key in keys:
group = cls.get(unhexlify(key.decode().split(':')[1]))
groups.append(group)
return groups
def all(cls,
app_eui,
dev_eui=None,
start_ts=0,
end_ts=-1,
cur_cnt=None):
"""
:param app_eui: bytes
:param dev_eui: bytes
:param start_ts: int
:param end_ts: int
:param cur_cnt: int
:return:
"""
if dev_eui is None:
dev_eui = '*'
else:
dev_eui = hexlify(dev_eui).decode()
app_eui = hexlify(app_eui).decode()
keys = db0.keys(ConstDB.msg_up + app_eui + ':' + dev_eui + ':*')
# logger.debug('WHY NO MSG SHOW' + 'KEYS LENGTH: %d' % len(keys))
msgs = []
filted_keys = []
for key in keys:
key = key.decode()
ts = int(key.split(':')[3])
if start_ts < ts and ((end_ts < 0) or (ts < end_ts)):
filted_keys.append(key)
# else:
# logger.debug('WHY NO MSG SHOW' + 'MSGS BE FILTERED: %s' % key)
filted_keys.sort(key=lambda x: x.split(':')[3], reverse=True)
if cur_cnt and cur_cnt < len(filted_keys):
print(cur_cnt)
filted_keys = filted_keys[0:cur_cnt]
for key in filted_keys:
msg = MsgUp.objects.get(key)
if msg:
msgs.append(msg)
return msgs
def delete(self):
db_sql.session.delete(self)
db_sql.session.flush()
if self.active_at is not None:
app_eui = hexlify(self.app_eui).decode()
dev_eui = hexlify(self.dev_eui).decode()
addr = hexlify(db0.hget(ConstDB.dev + dev_eui,
FieldDevice.addr)).decode()
msgs_up = db0.keys(ConstDB.msg_up + app_eui + ':' + dev_eui + ':*')
msgs_down = db0.keys(ConstDB.msg_down + ConstDB.dev + dev_eui +
':*')
mac_cmds = db0.keys(ConstDB.mac_cmd + dev_eui + ':*')
trans_params = db0.keys(ConstDB.trans_params + dev_eui + ':*')
groups = db0.keys(ConstDB.group_dev + '*:' + dev_eui)
statistics_up = db0.keys(ConstDB.statistics_up + dev_eui + ':*')
statistics_down = db0.keys(ConstDB.statistics_down + ConstDB.dev +
dev_eui + ':*')
pipe = db0.pipeline()
pipe.delete(ConstDB.dev_ack + dev_eui)
pipe.delete(ConstDB.dev + dev_eui)
pipe.srem(ConstDB.app_devs + app_eui, self.dev_eui)
for key in groups:
pipe.delete(key)
pipe.delete(ConstDB.addr + addr)
pipe.delete(ConstDB.dev_gateways + dev_eui)
for key in mac_cmds:
pipe.delete(key)
for key in msgs_up:
pipe.delete(key)
for key in msgs_down:
pipe.delete(key)
pipe.delete(ConstDB.que_down + ConstDB.dev + dev_eui)
pipe.delete(ConstDB.mac_cmd_que + dev_eui)
for key in trans_params:
pipe.delete(key)
for key in statistics_down:
pipe.delete(key)
for key in statistics_up:
pipe.delete(key)
pipe.execute()
AddrManger.recycle_addr(unhexlify(addr))
db_sql.session.commit()
from database.db0 import db0, ConstDB
keys = db0.keys(ConstDB.msg_up + '*')
print(keys)
for key in keys:
key_split = key.decode().split(':')
db0.sadd(ConstDB.mset + key_split[2], key_split[3])
# app_eui = 'ffffffffffffffff'
# dev_eui = 'aa000000000000a1'
# list = db0.sort(ConstDB.mset + dev_eui, by='MSG_UP:' + app_eui + ':' + dev_eui + ':*->rssi')
# for tmst in list:
# rssi = db0.hgetall(ConstDB.msg_up + app_eui + ':' + dev_eui + ':' + tmst.decode())
# print(rssi)
dbsession = DBSession()
gateway_init = GatewayLocation(gateway_id=gateway_id, latitude=latitude, longitude=longitude, altitude=altitude,
code_province=code_province, code_city=code_city, code_area=code_area)
dbsession.add(gateway_init)
dbsession.commit()
dbsession.close()
def create_db():
Base.metadata.create_all(bind=engine)
def drop_db():
Base.metadata.drop_all(bind=engine)
if __name__ == '__main__':
# create_db()
from database.db0 import db0, ConstDB
key_list = db0.keys(pattern=ConstDB.gateway + '*')
for i_key in key_list:
gateway_id = i_key.decode().split(':')[1]
location = db0.hget(i_key, 'location')
data = location.decode().split(',')
lng = float(data[0])
lat = float(data[1])
alt = int(data[2])
# print('id=%s lat=%s lng=%s' % (gateway_id, str(lat), str(lng)))
GatewayLocation.insert(gateway_id=gateway_id, latitude=lat, longitude=lng, altitude=alt)
