def post(self, *args, **kwargs):
name = self.get_argument('name')
pwd = self.get_argument('password')
new_user = User(name=name,password=pwd)
session.add(new_user)
session.commit()
self.write('新增用户成功~')
def changePw(inData):
'''
:param inData:
:return: {1:'success', '4':'fail', '3':'username repeat'}
'''
#print('cccccccccccccc', inData)
if(('id' in inData) and ('newUsername' in inData) and ('newPasswd' in inData)):
userData=User.select(inData)
if(len(userData['pureData'])==1):
curUser=userData['pureData'][0]
if(inData['newUsername']==curUser.username):
curUser.passwd=User.getMd5Pw(inData['newUsername'], inData['newPasswd'])
session.commit()
return 1
else:
antUserData=User.select({'username': inData['newUsername']})
if(len(antUserData['pureData'])!=0):
return 3
else:
curUser.username=inData['newUsername']
curUser.passwd=User.getMd5Pw(inData['newUsername'], inData['newPasswd'])
session.commit()
return 1
else:
return 4
else:
return 4
def updateOutip(Name_DICT={}):
'''
:param Name_DICT:
:return: {1:'success', 2:'name is empty', 3:'failed'}
'''
try:
if (Name_DICT is None):
return 3
for name in Name_DICT.keys():
ret = 1
ret = Outip.check(name)
if (ret == 1):
Outip.add(name, Name_DICT[name])
continue
elif (ret == 2):
curCount = session.query(
Outip.count).filter(Outip.name == name).first()
if (curCount is None):
continue
else:
count = int(curCount[0]) + Name_DICT[name]
session.query(Outip).filter(Outip.name == name).update(
{
'count': count,
'ltime': datetime.now()
})
session.commit()
else:
continue
except BaseException:
session.rollback()
finally:
session.close()
return 1
def updateSensor(inData):
'''
:param: inData
:return: {1:'success', 2:'permission denied', 3:'no sensor', 4:'wrong param', 5:'mac repeat', 6:'station id does not exist'}
'''
from auth import Auth
if(('UserId' in inData) and ('SensorId' in inData) and (('Name' in inData) or ('Mac' in inData) or ('Ip' in inData) or ('Number' in inData) or ('StationId' in inData))):
updateUser = session.query(Auth).filter(Auth.userId == inData['UserId'], Auth.sensorId == inData['SensorId'], Auth.valid == 1).first()
if(updateUser == None):
return 2
tmpSensor = session.query(Sensor).filter(Sensor.id == inData['SensorId'], Sensor.valid == 1).first()
if(tmpSensor == None):
return 3
if('Name' in inData and inData['Name'] != ''):
session.query(Sensor).filter(Sensor.id == inData['SensorId'], Sensor.valid == 1).update({'name':inData['Name'], 'time':datetime.now()})
if('Mac' in inData and inData['Mac'] != ''):
tmpSensorMac = session.query(Sensor).filter(Sensor.valid == 1, Sensor.mac == inData['Mac']).first()
if(tmpSensorMac != None):
return 5
session.query(Sensor).filter(Sensor.id == inData['SensorId'], Sensor.valid == 1).update({'mac':inData['Mac'], 'time':datetime.now()})
if('Ip' in inData and inData['Ip'] != ''):
session.query(Sensor).filter(Sensor.id == inData['SensorId'], Sensor.valid == 1).update({'ip':inData['Ip'], 'time':datetime.now()})
if('Number' in inData and inData['Number'] != ''):
session.query(Sensor).filter(Sensor.id == inData['SensorId'], Sensor.valid == 1).update({'number':inData['Number'], 'time':datetime.now()})
if('StationId' in inData and inData['StationId'] != ''):
tmpStation = session.query(Station).filter(Station.id == inData['StationId'], Station.valid == 1).first()
if(tmpStation == None):
return 6
session.query(Sensor).filter(Sensor.id == inData['SensorId'], Sensor.valid == 1).update({'stationId':inData['StationId'], 'time':datetime.now()})
session.commit()
return 1
else:
return 4
def delSensor(inData):
'''
:param: inData
:return: {1:'success', 2:'permission denied', 3:'no sensor', 4:'wrong param', 5:''}
'''
from auth import Auth
from eqp import Eqp
if (('UserId' in inData) and ('SensorId' in inData)):
updateUser = session.query(Auth).filter(
Auth.userId == inData['UserId'],
Auth.sensorId == inData['SensorId'], Auth.valid == 1).first()
if (updateUser == None):
updateUserLevel = session.query(User.level).filter(
User.id == inData['UserId'], User.valid == 1).first()
if (updateUserLevel == None or int(updateUserLevel[0]) != 0):
return 2
tmpSensor = session.query(Sensor).filter(
Sensor.id == inData['SensorId'], Sensor.valid == 1).first()
if (tmpSensor == None):
return 3
session.query(Sensor).filter(Sensor.id == inData['SensorId'],
Sensor.valid == 1).update({
'valid':
0,
'time':
datetime.now()
})
Auth.delAuth({'SensorId': inData['SensorId']})
Eqp.delEqp({'SensorId': inData['SensorId']})
session.commit()
return 1
else:
return 4
def delAuth(inData):
'''
:param inData:
:return:{1:'success', 2:'wrong param'}
'''
if (('UserId' in inData) or ('SensorId' in inData)):
if (('UserId' in inData) and ('SensorId' in inData)):
session.query(Auth).filter(
Auth.userId == inData['UserId'],
Auth.sensorId == inData['SensorId']).update({
'valid':
0,
'time':
datetime.now()
})
elif ('UserId' in inData):
session.query(Auth).filter(
Auth.userId == inData['UserId']).update({
'valid':
0,
'time':
datetime.now()
})
else:
session.query(Auth).filter(
Auth.sensorId == inData['SensorId']).update({
'valid':
0,
'time':
datetime.now()
})
session.commit()
else:
return 2
return 1
def delete_station2(inData):
'''
:param inData:
:return:{
2:'there is no id in inData',
3:'there is no such id'
}
'''
ret=0
if(not inData.has_key('id')):
ret=2
return ret
query=session.query(Station)
tmpStation=query.filter(Station.id==inData['id']).first()
if(tmpStation==None):
ret=3
return ret
else:
from sensor import Sensor
tmpAllSensor=Sensor.select({'stationId': tmpStation.id})
for tmpSensor in tmpAllSensor['pureData']:
tmpSensor.stationId=0
session.delete(tmpStation)
session.commit()
ret=1
return ret
def updateStation(inData):
'''
:param: inData
:return: {1:'success', 2:'name repeat', 3:'permission denied', 4:'param wrong', 5:'number repeat'}
'''
from user import User
if(('UserId' in inData) and ('StationId' in inData) and (('Name' in inData) or ('Number' in inData) or ('Supervisor' in inData) or ('Phone' in inData))):
updateUserLevel = session.query(User.level).filter(User.id == inData['UserId'], User.valid == 1).first()
if(updateUserLevel == None or int(updateUserLevel[0] != 0)):
return 3
else:
if('Name' in inData and inData['Name'] != ''):
tmpStation=session.query(Station).filter(Station.name==inData['Name'], Station.valid == 1).first()
if(tmpStation != None):
return 2
session.query(Station).filter(Station.id == inData['StationId'], Station.valid == 1).update({'name':inData['Name'], 'time':datetime.now()})
if('Number' in inData and inData['Number'] != ''):
tmpStation=session.query(Station).filter(Station.number==inData['Number'], Station.valid == 1).first()
if(tmpStation != None):
return 5
session.query(Station).filter(Station.id == inData['StationId'], Station.valid == 1).update({'number':inData['Number'], 'time':datetime.now()})
if('Supervisor' in inData and inData['Supervisor'] != ''):
session.query(Station).filter(Station.id == inData['StationId'], Station.valid == 1).update({'supervisor':inData['Supervisor'], 'time':datetime.now()})
if('Phone' in inData and inData['Phone'] != ''):
session.query(Station).filter(Station.id == inData['StationId'], Station.valid == 1).update({'phone':inData['Phone'], 'time':datetime.now()})
session.commit()
return 1
else:
return 4
def update_sensor2(inData):
'''
:param inData:
:return: {0:'errror', 1:'success', 2:'no this id', 3:'iData has no key id', 21:''}
'''
ret=1
if(not inData.has_key('id')):
ret=3
return ret
query=session.query(Sensor)
tmpSensor=query.filter(Sensor.id==inData['id']).first()
if(tmpSensor==None):
ret=2
return ret
if(inData.has_key('name')):
tmpSensor.name=inData['name']
if(inData.has_key('number')):
tmpSensor.number=inData['number']
if(inData.has_key('ip')):
tmpSensor.ip=inData['ip']
if(inData.has_key('mac')):
tmpSensor.mac=inData['mac']
if(inData.has_key('stationId')):
if(int(inData['stationId'])!=0):
stationQuery=session.query(Station)
tmpStation=stationQuery.filter(Station.id==inData['stationId']).first()
if(tmpStation==None):
ret=21
return ret
else:
tmpSensor.stationId=tmpStation.id
else:
tmpSensor.stationId=0
session.commit()
return ret
def updateUser(inData):
'''
:param inData:
:return: {1:'update success', 2:'no user', 3:'permission denied', 4:'username repeat', 5:'failed(wrong param)'}
'''
if(('updateId' in inData) and ('id' in inData) and (('newUsername' in inData) or ('newPasswd' in inData) or ('newLevel' in inData))):
updateUserLevel = session.query(User.level).filter(User.id == inData['updateId'], User.valid == 1).first()
if(updateUserLevel == None or int(updateUserLevel[0]) != 0):
return 3
else:
chgUser = session.query(User).filter(User.id == inData['id'], User.valid == 1).first()
if(chgUser == None):
return 2
if('newUsername' in inData and inData['newUsername'] != ''):
tmp = User.check(inData['newUsername'])
if(tmp == 1):
session.query(User).filter(User.id == inData['id']).update({'username':inData['newUsername'], 'time':datetime.now()})
else:
return 4
if('newPasswd' in inData and inData['newPasswd'] != ''):
userName = session.query(User.username).filter(User.id == inData['id']).first()
md5Passwd = User.getMd5Pw(userName[0], inData['newPasswd'])
session.query(User).filter(User.id == inData['id']).update({'passwd':md5Passwd, 'time':datetime.now()})
if('newLevel' in inData and inData['newLevel'] != ''):
session.query(User).filter(User.id == inData['id']).update({'level':inData['newLevel'], 'time':datetime.now()})
session.commit()
return 1
else:
return 5
def add(atkId, atkTime, sensorMac, atkType, srcIp, srcPort, srcLng, srcLat,
dstIp, dstPort, dstLng, dstLat, cmProtocal, trails, refer, infos):
curAtkinfo = Atkinfo(atkId, atkTime, sensorMac, atkType, srcIp,
srcPort, srcLng, srcLat, dstIp, dstPort, dstLng,
dstLat, cmProtocal, trails, refer, infos)
session.add(curAtkinfo)
session.commit()
def delStation(inData):
'''
:param: inData
:return: {1:'success', 2:'failed', 3:'permission denied', 4:'param wrong'}
'''
from user import User
from sensor import Sensor
if(('UserId' in inData) and ('StationId' in inData)):
updateUserLevel = session.query(
User.level).filter(
User.id == inData['UserId'],
User.valid == 1).first()
if(updateUserLevel is None or int(updateUserLevel[0] != 0)):
return 3
else:
session.query(Station).filter(Station.id == inData['StationId'], Station.valid == 1).update(
{'valid': 0, 'time': datetime.now()})
delSensorId = session.query(
Sensor.id).filter(
Sensor.stationId == inData['StationId'],
Sensor.valid == 1).all()
for sensorId in delSensorId:
Sensor.delSensor(
{'UserId': inData['UserId'], 'SensorId': int(sensorId[0])})
session.commit()
return 1
else:
return 4
def update_eqp(ip, mac, name, sensorId):
'''
:param ip:
:param mac:
'''
#ret = 1
#ret = Eqp.check(name, 1, ip, mac, sensorId)
#if(ret != 1):
# return ret
query = session.query(Eqp.ftime)
tmpEqp = query.filter(and_(Eqp.ip == ip, Eqp.mac == mac)).first()
if (tmpEqp == None):
session.query(Eqp).filter(Eqp.ip == ip, Eqp.mac == mac).update({
'ftime':
datetime.now(),
'ltime':
datetime.now(),
'sensorId':
sensorId,
'name':
name
})
session.commit()
else:
session.query(Eqp).filter(Eqp.ip == ip, Eqp.mac == mac).update({
'ltime':
datetime.now(),
'sensorId':
sensorId,
'name':
name
})
session.commit()
return
def delete_station2(inData):
'''
:param inData:
:return:{
2:'there is no id in inData',
3:'there is no such id'
}
'''
ret = 0
if('id' not in inData):
ret = 2
return ret
query = session.query(Station)
tmpStation = query.filter(Station.id == inData['id']).first()
if(tmpStation is None):
ret = 3
return ret
else:
from sensor import Sensor
tmpAllSensor = Sensor.select({'stationId': tmpStation.id})
for tmpSensor in tmpAllSensor['pureData']:
tmpSensor.stationId = 0
session.delete(tmpStation)
session.commit()
ret = 1
return ret
def deleteUser(inData):
'''
:param inData:
:return: {1:'success', 2:'no user', 3:'permission denied', 4:'failed'}
'''
from auth import Auth
if (('updateId' in inData) and ('delId' in inData)):
updateUserLevel = session.query(User.level).filter(
User.id == inData['updateId'], User.valid == 1).first()
if (updateUserLevel is None or int(updateUserLevel[0]) != 0):
return 3
else:
chgUser = session.query(User).filter(
User.id == inData['delId'], User.valid == 1).first()
if (chgUser is None):
return 2
else:
session.query(User).filter(
User.id == inData['delId']).update({
'valid':
0,
'time':
datetime.now()
})
session.commit()
Auth.delAuth({'UserId': inData['delId']})
return 1
else:
return 4
def changePw(inData):
'''
:param inData:
:return: {1:'success', '4':'fail', '3':'username repeat'}
'''
#print('cccccccccccccc', inData)
if (('id' in inData) and ('newUsername' in inData)
and ('newPasswd' in inData)):
userData = User.select(inData)
if (len(userData['pureData']) == 1):
curUser = userData['pureData'][0]
if (inData['newUsername'] == curUser.username):
curUser.passwd = User.getMd5Pw(inData['newUsername'],
inData['newPasswd'])
session.commit()
return 1
else:
antUserData = User.select(
{'username': inData['newUsername']})
if (len(antUserData['pureData']) != 0):
return 3
else:
curUser.username = inData['newUsername']
curUser.passwd = User.getMd5Pw(inData['newUsername'],
inData['newPasswd'])
session.commit()
return 1
else:
return 4
else:
return 4
def updateHost(Name_DICT = {}):
'''
:param Name_DICT:
:return: {1:'success', 2:'name is empty', 3:'failed'}
'''
try:
if(Name_DICT == None):
return 3
for name in Name_DICT.keys():
#print("add name: %s" %name)
ret = 1
ret = Host.check(name)
if(ret == 1):
Host.add(name,Name_DICT[name])
continue
elif(ret == 2):
curCount = session.query(Host.count).filter(Host.name == name).first()
if(curCount == None):
continue
else:
count = int(curCount[0]) + Name_DICT[name]
session.query(Host).filter(Host.name == name).update({'count':count, 'ltime':datetime.now()})
session.commit()
else:
continue
except:
session.rollback()
finally:
session.close()
return 1;
def post(self, *args, **kwargs):
user_id = self.get_argument('id')
delete_user = session.query(User).filter(User.id==user_id).delete()
if delete_user:
session.commit()
self.write('删除用户成功')
else:
self.write('没有该用户，无需删除!')
def add_user():
person = User(name='chenyanqi',password='******')
#session.add(person)
session.add_all(
[User(name='shuaiqi',password='******'),
User(name='shuaiqishuaiqi',password='******')]
)
session.commit() #提交
def add(userId, sensorId):
ret = 1
ret = Auth.check(userId, sensorId)
if (ret != 1):
return ret
curAuth = Auth(userId, sensorId, datetime.now())
session.add(curAuth)
session.commit()
return ret
def update_data(self,datas,id):
try:
datas.pop("id")
print(datas)
session.query(ProductModel).filter(ProductModel.id == id).update(datas)
session.commit()
return True
except:
session.rollback()
def change_authority(id, isAuth):
query = session.query(Eqp)
tmpEqp = query.filter(Eqp.id == id).first()
ret = 0
if (tmpEqp != None):
tmpEqp.authority = isAuth
session.commit()
ret = 1
return ret
def add_user():
#person = User(username = '******',password='******')
#session.add(person) #增加一条数据
session.add_all([ #增加多条数据
User(username='******', password='******'),
User(username='******', password='******'),
User(username='******', password='******'),
])
session.commit() #提交
def change_authority(id, isAuth):
query=session.query(Eqp);
tmpEqp=query.filter(Eqp.id==id).first()
ret=0
if(tmpEqp!=None):
tmpEqp.authority=isAuth
session.commit()
ret=1
return ret
def delete_data(self,id):
try:
"""删除数据，默认开始事务"""
rows = session.query(ProductModel).filter(ProductModel.id == id).first()
session.delete(rows)
session.commit()
return True
except:
session.rollback()
def add(userId, sensorId):
ret=1
ret=Auth.check(userId, sensorId)
if(ret!=1):
return ret
curAuth=Auth(userId, sensorId, datetime.now())
session.add(curAuth)
session.commit()
return ret
def add2(inData):
ret=Sensor.check2(inData)
if(ret!=1):
return ret
curSensor=Sensor(inData['name'], inData['number'], inData['ip'], inData['mac'], inData['stationId'], datetime.now())
session.add(curSensor)
session.commit()
return ret
def add_user_many(data_li):
"""
[User(username='******', password='******'),]
"""
try:
session.add_all(data_li)
session.commit()
except Exception as e:
session.rollback()
raise e
def add2(inData):
ret = Sensor.check2(inData)
if (ret != 1):
return ret
curSensor = Sensor(inData['name'], inData['number'], inData['ip'],
inData['mac'], inData['stationId'], datetime.now())
session.add(curSensor)
session.commit()
return ret
def add_user_one(data):
model_obj = User(**data)
try:
session.add(model_obj)
session.commit()
return inspect(model_obj).identity[0]
except Exception as e:
session.rollback()
raise e
def delete_user(*args,**kwargs):
""""
query>User.username=='cainiao'
"""
try:
rows = session.query(User).filter(*args).filter_by(**kwargs)[0]
session.delete(rows)
session.commit()
except Exception as e:
session.rollback()
raise e
def update_user(data,*args,**kwargs):
"""
query> User.username=='cainiao'
data> {User.password:1}
"""
try:
rows = session.query(User).filter(*args).filter_by(**kwargs).update(data)
session.commit()
except Exception as e:
session.rollback()
raise e
def add_user():
person = User(name='cherish002', password='******')
session.add(person) #增加单个
# session.add_all(
# [
# User(name='memeda',password='******'),
# User(name='lalala',password='******'),
# User(name='hahaha',password='******'),
# ]
# ) #增加多个
session.commit() #提交
print(person, '增加成功~')
def init():
Base.metadata.create_all(engine)
old = Hardware.get_all_hardware()
if old:
print '[i] delete old data in hardware table...'
for item in old:
session.delete(item)
session.commit()
hardware_info_csv = 'hardware_info.csv'
Hardware.read_hardware_info(hardware_info_csv)
print '[i] complete initing the hardware table...'
def update_user2(inData):
'''
:param inData:
:return: {
1:'success',
12:'no id',
13:'id not exist',
14:'username is none',
15:'level is illegal',
16:'passwd is too short',
17:'already has user'
}
'''
ret = 1
if ('id' not in inData):
ret = 12
return ret
query = session.query(User)
tmpUser = query.filter(User.id == inData['id']).first()
if (tmpUser is None):
ret = 13
return ret
if ('username' in inData):
tmpUser2 = query.filter(
User.username == inData['username']).first()
if (tmpUser2 is not None):
ret = 17
return ret
if (inData['username'] != ''):
tmpUser.username = inData['username']
else:
ret = 14
return ret
if ('level' in inData):
inData['level'] = int(inData['level'])
if ((inData['level'] == 0) or (inData['level'] == 1)
or (inData['level'] == 2)):
tmpUser.level = inData['level']
else:
ret = 15
return ret
if ('passwd' in inData):
if (len(inData['passwd']) < 6):
ret = 16
return ret
else:
tmpUser.passwd = User.getMd5Pw(tmpUser.username,
inData['passwd'])
session.commit()
return ret
def read_hardware_info(csv_name):
import codecs
info_csv = codecs.open(csv_name, 'r', 'gbk')
start = info_csv.readlines()
data = start[2:-1] # filte export_time, column name
for each in data:
start = each.split(',')
new_hardware = Hardware(start[0], start[1], start[2], start[3],
start[4], start[5], start[6], start[7],
start[8], start[9], start[10], start[11],
start[12], start[13], start[17])
session.add(new_hardware)
session.commit()
'''
def add_user():
person = User(username='******', password='******')
# 往表中插入一条数据
session.add(person)
# 往表中插入多条数据
# session.add_all(
# [
# User(username='******', password='******'),
# User(username='******', password='******'),
# User(username='******', password='******'),
# ]
# )
#
session.commit()
def updateAuth(inData):
'''
:param: inData
:return: {1:'success', 2:'wrong param', 3:'no eqp id'}
'''
if('EqpId' in inData):
if('Auth' in inData and inData['Auth'] != ''):
session.query(Eqp).filter(Eqp.id == inData['Eqpid'], Eqp.valid == 1).update({'authority':inData['Auth']})
if('Number' in inData and inData['Number'] != ''):
session.query(Eqp).filter(Eqp.id == inData['Eqpid'], Eqp.valid == 1).update({'number':inData['Number']})
session.commit()
return 1
else:
return 2
def add(name, number, ip, mac, stationId):
'''
1: success
2: username repeat
'''
ret = 1
ret = Sensor.check(name, number, ip, mac, stationId)
if (ret != 1):
return ret
curSensor = Sensor(name, number, ip, mac, stationId, datetime.now())
session.add(curSensor)
session.commit()
return ret
def add(name, number, ip, mac, ftime, ltime, authority, sensorMac):
'''
1: success
2: username repeat
'''
ret=1
ret=Eqp.check(name, number, ip, mac)
if(ret!=1):
return ret
curEqp=Eqp(name, number, ip, mac, ftime, ltime, authority, sensorMac)
session.add(curEqp)
session.commit()
return ret
def delEqp(inData):
'''
:param: inData
:return: {1:'success', 2:'wrong param'}
'''
if('SensorId' in inData):
session.query(Eqp).filter(Eqp.sensorId == inData['SensorId'], Eqp.valid == 1).update({'valid':0})
session.commit()
return 1
elif('EqpId' in inData):
session.query(Eqp).filter(Eqp.id == inData['EqpId'], Eqp.valid == 1).update({'valid':0})
session.commit()
return 1
else:
return 2
def add(username, passwd, level):
'''
1: success
2: out:two passwd are not same
3: username repeat
'''
ret=1
tmp=User.check(username)
if(tmp==1):
curUser=User(username, passwd, level)
session.add(curUser)
session.commit()
else:
ret=tmp
return ret
def add(username, passwd, level):
'''
1: success
2: out:two passwd are not same
3: username repeat
'''
ret = 1
tmp = User.check(username)
if (tmp == 1):
curUser = User(username, passwd, level)
session.add(curUser)
session.commit()
else:
ret = tmp
return ret
def update_eqp2(inData, level, userId):
'''
:param inData:
:return: {0:'errror', 1:'success', 12:'no this id', 13:'iData has no key id'}
'''
ret=1
if(not inData.has_key('id')):
ret=3
return ret
query=session.query(Eqp)
tmpEqp=query.filter(Eqp.id==inData['id']).first()
if(tmpEqp==None):
ret=2
return ret
if(level==1):
from auth import Auth
authQuery=session.query(Auth)
from sensor import Sensor
sensorQuery=session.query(Sensor)
tmpSensor=sensorQuery.filter(Sensor.mac==tmpEqp.sensorMac).first()
if(tmpSensor==None):
ret=2
return ret
tmpAuth=authQuery.filter(Auth.userId==userId, Auth.sensorId==tmpSensor.id).first()
if(tmpAuth==None):
ret=2
return ret
if(inData.has_key('name')):
tmpEqp.name=inData['name']
if(inData.has_key('number')):
tmpEqp.number=inData['number']
if(inData.has_key('ip')):
tmpEqp.ip=inData['ip']
if(inData.has_key('mac')):
tmpEqp.mac=inData['mac']
if(inData.has_key('authority')):
tmpEqp.authority=inData['authority']
if(inData.has_key('valid')):
tmpEqp.valid=inData['valid']
session.commit()
return ret
def update_user2(inData):
'''
:param inData:
:return: {
1:'success',
12:'no id',
13:'id not exist',
14:'username is none',
15:'level is illegal',
16:'passwd is too short',
17:'already has user'
}
'''
ret=1
if(not inData.has_key('id')):
ret=12
return ret
query=session.query(User)
tmpUser=query.filter(User.id==inData['id']).first()
if(tmpUser==None):
ret=13
return ret
if(inData.has_key('username')):
tmpUser2=query.filter(User.username==inData['username']).first()
if(tmpUser2!=None):
ret=17
return ret
if(inData['username']!=''):
tmpUser.username=inData['username']
else:
ret=14
return ret
if(inData.has_key('level')):
inData['level']=int(inData['level'])
if( (inData['level']==0) or (inData['level']==1) or (inData['level']==2)):
tmpUser.level=inData['level']
else:
ret=15
return ret
if(inData.has_key('passwd')):
if(len(inData['passwd'])<6):
ret=16
return ret
else:
tmpUser.passwd=User.getMd5Pw(tmpUser.username, inData['passwd'])
session.commit()
return ret
def add(name, number, ip, mac, stationId):
'''
1: success
2: username repeat
'''
ret=1
ret=Sensor.check(name, number, ip, mac, stationId)
if(ret!=1):
return ret
curSensor=Sensor(name,number, ip, mac, stationId, datetime.now())
session.add(curSensor)
session.commit()
return ret
def delAuth(inData):
'''
:param inData:
:return:{1:'success', 2:'wrong param'}
'''
if(('UserId' in inData) or ('SensorId' in inData)):
if(('UserId' in inData) and ('SensorId' in inData)):
session.query(Auth).filter(Auth.userId == inData['UserId'], Auth.sensorId == inData['SensorId']).update({'valid':0, 'time':datetime.now()})
elif('UserId' in inData):
session.query(Auth).filter(Auth.userId == inData['UserId']).update({'valid':0, 'time':datetime.now()})
else:
session.query(Auth).filter(Auth.sensorId == inData['SensorId']).update({'valid':0, 'time':datetime.now()})
session.commit()
else:
return 2
return 1
def update_eqp(ip, mac, name, sensorId):
'''
:param ip:
:param mac:
'''
#ret = 1
#ret = Eqp.check(name, 1, ip, mac, sensorId)
#if(ret != 1):
# return ret
query = session.query(Eqp.ftime)
tmpEqp = query.filter(and_(Eqp.ip == ip, Eqp.mac == mac)).first()
if(tmpEqp == None):
session.query(Eqp).filter(Eqp.ip == ip, Eqp.mac == mac).update({'ftime':datetime.now(), 'ltime':datetime.now(), 'sensorId':sensorId, 'name':name})
session.commit()
else:
session.query(Eqp).filter(Eqp.ip == ip, Eqp.mac == mac).update({'ltime':datetime.now(), 'sensorId':sensorId, 'name':name})
session.commit()
return
def delete_auth2(inData):
'''
:param inData:
:return: {2:'there is no id', 3:'this is so such record'}
'''
ret=1
if(inData.has_key('id')):
query=session.query(Auth)
tmpAuth=query.filter(Auth.id==inData['id']).first()
if(tmpAuth!=None):
session.delete(tmpAuth)
session.commit()
ret=1
else:
ret=3
else:
ret=2
return ret
def delStation(inData):
'''
:param: inData
:return: {1:'success', 2:'failed', 3:'permission denied', 4:'param wrong'}
'''
from user import User
from sensor import Sensor
if(('UserId' in inData) and ('StationId' in inData)):
updateUserLevel = session.query(User.level).filter(User.id == inData['UserId'], User.valid == 1).first()
if(updateUserLevel == None or int(updateUserLevel[0] != 0)):
return 3
else:
session.query(Station).filter(Station.id == inData['StationId'], Station.valid == 1).update({'valid':0, 'time':datetime.now()})
delSensorId = session.query(Sensor.id).filter(Sensor.stationId == inData['StationId'], Sensor.valid == 1).all()
for sensorId in delSensorId:
Sensor.delSensor({'UserId':inData['UserId'], 'SensorId':int(sensorId[0])})
session.commit()
return 1
else:
return 4
def deleteUser(inData):
'''
:param inData:
:return: {1:'success', 2:'no user', 3:'permission denied', 4:'failed'}
'''
from auth import Auth
if(('updateId' in inData) and ('delId' in inData)):
updateUserLevel = session.query(User.level).filter(User.id == inData['updateId'], User.valid == 1).first()
if(updateUserLevel == None or int(updateUserLevel[0]) != 0):
return 3
else:
chgUser = session.query(User).filter(User.id == inData['delId'], User.valid == 1).first()
if(chgUser == None):
return 2
else:
session.query(User).filter(User.id == inData['delId']).update({'valid':0, 'time':datetime.now()})
session.commit()
Auth.delAuth({'UserId':inData['delId']})
return 1
else:
return 4
def update_station2(inData):
'''
:param inData:
:return: {0:'errror', 1:'success', 2:'no this id', 3:'iData has no key id', 4:'name input is none', 5:'number is none', 6:'supervisor is none'},
7:'phone is none'}
'''
ret=1
if(not inData.has_key('id')):
ret=3
return ret
query=session.query(Station)
tmpStation=query.filter(Station.id==inData['id']).first()
if(tmpStation==None):
ret=2
return ret
if(inData.has_key('name')):
if(inData['name']!=''):
tmpStation.name=inData['name']
else:
ret=4
if(inData.has_key('number')):
if(inData['number']!=''):
tmpStation.number=inData['number']
else:
ret=5
if(inData.has_key('supervisor')):
tmpStation.supervisor=inData['supervisor']
# if(inData['supervisor']!=''):
# tmpStation.supervisor=inData['supervisor']
# else:
# ret=6
if(inData.has_key('phone')):
tmpStation.phone=inData['phone']
# if(inData['phone']!=''):
# tmpStation.phone=inData['phone']
# else:
# ret=7
session.commit()
return ret
def retData(timeSpan, inType):
if(inType=='py'):
query=session.query(Atkinfo)
nowTime=time.time()
limitTime=nowTime-timeSpan
delInfos=query.filter(Atkinfo.atkTime<=limitTime)
allInfos=query.filter(and_(Atkinfo.atkTime>limitTime))
ret=[]
for tmpInfo in delInfos:
session.delete(tmpInfo)
for tmpInfo in allInfos:
tmp={}
tmp['attackId']=tmpInfo.atkId
tmp['time']=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(tmpInfo.atkTime))
tmp['sensorId']=tmpInfo.sensorNumber
tmp['src']={}
tmp['src']['ip']=tmpInfo.srcIp
tmp['src']['port']=tmpInfo.srcPort
tmp['src']['lng']=float(tmpInfo.srcLng)
tmp['src']['lat']=float(tmpInfo.srcLat)
tmp['src']['name']=''
tmp['dst']={}
tmp['dst']['ip']=tmpInfo.dstIp
tmp['dst']['port']=tmpInfo.dstPort
tmp['dst']['lng']=float(tmpInfo.dstLng)
tmp['dst']['lat']=float(tmpInfo.dstLat)
tmp['dst']['name']=''
tmp['protocalA']=tmpInfo.cmProtocal
tmp['trails']=tmpInfo.trails
tmp['references']=tmpInfo.refer
tmp['infos']=tmpInfo.infos
ret.append(tmp)
session.delete(tmpInfo)
session.commit()
return ret
else:
return {}
def add(name, number, supervisor, phone):
'''
:param name:
:param number:
:param supervisor:
:param phont:
:return: {1:'success', 2:'name repeat', 3:'number repeat', 4:'name is empty', 5:'number is empty'}
'''
ret=1
if(name==''):
ret=4
return ret
if(number==''):
ret=5
return ret
ret=Station.check(name, number)
if(ret!=1):
return ret
curStation=Station(name, number, supervisor, phone, datetime.now())
session.add(curStation)
session.commit()
return ret
def delSensor(inData):
'''
:param: inData
:return: {1:'success', 2:'permission denied', 3:'no sensor', 4:'wrong param', 5:''}
'''
from auth import Auth
from eqp import Eqp
if(('UserId' in inData) and ('SensorId' in inData)):
updateUser = session.query(Auth).filter(Auth.userId == inData['UserId'], Auth.sensorId == inData['SensorId'], Auth.valid == 1).first()
if(updateUser == None):
updateUserLevel = session.query(User.level).filter(User.id == inData['UserId'], User.valid == 1).first()
if(updateUserLevel == None or int(updateUserLevel[0]) != 0):
return 2
tmpSensor = session.query(Sensor).filter(Sensor.id == inData['SensorId'], Sensor.valid == 1).first()
if(tmpSensor == None):
return 3
session.query(Sensor).filter(Sensor.id == inData['SensorId'], Sensor.valid == 1).update({'valid':0, 'time':datetime.now()})
Auth.delAuth({'SensorId':inData['SensorId']})
Eqp.delEqp({'SensorId':inData['SensorId']})
session.commit()
return 1
else:
return 4
def del_user2(inData):
'''
:param inData:
:return{0: error, 2: no id in inData, 3: no such id in userv2, }:
'''
ret=0
if(not inData.has_key('id')):
ret=2
return ret
query=session.query(User)
tmpUser=query.filter(User.id==inData['id']).first()
if(tmpUser==None):
ret=3
return ret
else:
from user_old import User_old
User_old.add(tmpUser)
from auth import Auth
authQuery=session.query(Auth)
authQuery.filter(Auth.userId==tmpUser.id).delete()
session.delete(tmpUser)
session.commit()
ret=1
return ret
def add(inData):
tmpUser=User_old(inData.username, inData.passwd, inData.level)
session.add(tmpUser)
session.commit()
def add(atkId, atkTime, sensorNumber, atkType, srcIp, srcPort, srcLng, srcLat, dstIp, dstPort, dstLng, dstLat, cmProtocal, trails, refer, infos):
curAtkinfo=Atkinfo2(atkId, atkTime, sensorNumber, atkType, srcIp, srcPort, srcLng, srcLat, dstIp, dstPort, dstLng, dstLat, cmProtocal, trails, refer, infos)
session.add(curAtkinfo)
session.commit()
axs[2].plot(t, odors, lw=2)
axs[2].set_ylim(ODOR_YLIM)
axs[2].set_xlabel('t (s)')
axs[2].set_ylabel('odor (a.u.)')
# plot speed and distance to wall overlaid
axs[3].plot(t, spd, c='b', lw=2)
axs[3].set_ylim(0, 0.6)
axs[3].set_xlabel('t (s)')
axs[3].set_ylabel('speed (m/s)', color='b')
[tl.set_color('b') for tl in axs[3].get_yticklabels()]
axs[3].twin.plot(t, dist, c='r', lw=2)
axs[3].twin.set_ylabel('dist from wall (m)', color='r')
[tl.set_color('r') for tl in axs[3].twin.get_yticklabels()]
plt.draw()
command = raw_input('command [s=save, n=next odor state]: ')
if command == 's':
sample_trajectory = models.SampleTrajectory(sample_group=sample_group,
experiment_id=EXPERIMENT_ID,
odor_state=odor_state,
trajectory=traj)
session.add(sample_trajectory)
session.commit()
print('Trajectory "{}" saved in sample database.'.format(traj.id))
elif command == 'n':
print('Moving on to next odor state...')
break
