def find_user_in_group(gname, user):
# in active users can access their groups if he is logged in
group_data = Database.find_one(collection=collection,
query={'gname': gname})
if group_data is None:
raise GroupErrors.GroupNotExistsError('Group Not Exists')
group = Database.find_one(collection=collection,
query={
'gname': gname,
'users': user
})
return group
def registerpost(mac):
data = Database.find_one(collection, {'mac': mac})
if data is not None:
return {"message": "Already exists"}
doc = Pretty(mac=mac)
doc.save_to_mongo()
return {"message": "success"}
def delete_group(gname):
group_data = Database.find_one(collection=collection,
query={'gname': gname})
if group_data is None:
raise GroupErrors.GroupNotExistsError('Group Not Exists')
Database.remove(collection=collection, query={'gname': gname})
return True
def create_group(gname):
group_data = Database.find_one(collection=collection,
query={'gname': gname})
if group_data is not None:
raise GroupErrors.GroupAlreadyExistsError("Group Already Exists")
Group(gname).save_to_db()
return True
def create_node(mac):
data = Database.find_one(collection=collection, query={'mac': mac})
if data is not None:
raise NodeErrors.NodeAlreadyExistsError(
'System Already Exists with that name')
Pretty(mac=mac).save_to_mongo()
return True
def find_user_and_node_in_same_group(node, user):
group = Database.find_one(collection=collection,
query={
'nodes': node,
'users': user
})
if group is not None:
return True
def is_mac_valid(mac):
data = Database.find_one(collection=collection, query={'mac': mac})
if data is None:
raise NodeErrors.NodeNotExistsError(
'System Does not Exists with that name')
if data['active'] is False:
raise NodeErrors.NodeInActiveError(
'System is InActive and can not be accessed')
return True
def registerget(mac):
data = Database.find_one(collection, {'mac': mac})
if data is not None:
print(data['mac'])
#randie = data['commands']
# for i in randie:
# print(i)
return {"message": "Exists"}
return {"message": "MAC Doesn't Exists or not registered"}
def change_username(username, new_username):
user_data = Database.find_one(collection, {'username': username})
if user_data is None:
raise UserErrors.UserNotExistsError("Your User doesn't Exist")
Database.update(collection=collection,
query={'username': username},
data={"$set": {
'username': new_username
}})
return True
def change_password(username, new_password):
user_data = Database.find_one(collection, {'username': username})
if user_data is None:
raise UserErrors.UserNotExistsError("Your User doesn't Exist")
Database.update(
collection=collection,
query={'username': username},
data={"$set": {
'password': Utils.hash_password(new_password)
}})
return True
def delete_user(username):
user_data = Database.find_one(collection, {'username': username})
if user_data is None:
raise UserErrors.UserNotExistsError("Your User doesn't Exist")
Database.remove(collection=collection, query={'username': username})
Database.updateMany(collection=group_table,
query={},
data={'$pull': {
'users': username
}})
return True
def make_node_active(mac):
node_data = Database.find_one(collection=collection,
query={'mac': mac})
if node_data['active'] is True:
raise NodeErrors.NodeAlreadyActiveError('Node is Already Active')
Database.update(collection=collection,
query={'mac': mac},
data={"$set": {
'active': True
}})
return True
def remove_node_from_group(gname, node):
group_data = Database.find_one(collection=collection,
query={'gname': gname})
if group_data is None:
raise GroupErrors.GroupNotExistsError('Group Not Exists')
node_data = Database.find_one(collection=node_table,
query={'mac': node})
if node_data is None:
raise NodeErrors.NodeNotExistsError('No Node with name')
group_node_data = Database.find_one(collection=collection,
query={'nodes': node})
if group_node_data is None:
raise GroupErrors.NodeNotExistsInaGroupError(
node + 'Not Exists in a group')
Database.update(collection=collection,
query={'gname': gname},
data={'$pull': {
'nodes': node
}})
return True
def add_node_to_group(gname, node):
group_data = Database.find_one(collection=collection,
query={'gname': gname})
if group_data is None:
raise GroupErrors.GroupNotExistsError('Group Not Exists')
node_data = Database.find_one(collection=node_table,
query={'mac': node})
if node_data is None:
raise NodeErrors.NodeNotExistsError('No Node with that name')
group_node_data = Database.find_one(collection=collection,
query={'nodes': node})
if group_node_data is not None:
raise GroupErrors.NodeExistsInaGroupError(
node + 'Already Exists in a group')
Database.update(collection=collection,
query={'gname': gname},
data={'$push': {
'nodes': node
}})
return True
def delete_node(mac):
data = Database.find_one(collection=collection, query={'mac': mac})
if data is None:
raise NodeErrors.NodeNotExistsError(
'System Does not Exists with that name')
Database.remove(collection=collection, query={'mac': mac})
Database.updateMany(collection=group_table,
query={},
data={'$pull': {
'nodes': mac
}})
return True
def make_group_inactive(gname):
group_data = Database.find_one(collection=collection,
query={'gname': gname})
if group_data['active'] is False:
raise GroupErrors.GroupAlreadyInActiveError(
'Group is Already InActive')
Database.update(collection=collection,
query={'gname': gname},
data={"$set": {
'active': False
}})
return True
def register_user(username, password, **kwargs):
user_data = Database.find_one(collection, {'username': username})
if user_data is not None:
raise UserErrors.UserAlreadyRegisteredError(
"Username Already Exists")
User(username=username,
password=Utils.hash_password(password),
**kwargs).save_to_db()
return True
def make_user_active(username):
user_data = Database.find_one(collection, {'username': username})
if user_data is None:
raise UserErrors.UserNotExistsError("Your User doesn't Exist")
if user_data['active'] is True:
raise UserErrors.UserisAlreadyActiveError("User is Already Active")
Database.update(collection=collection,
query={'username': username},
data={"$set": {
'active': True
}})
return True
def remove_user_from_group(gname, user):
group_data = Database.find_one(collection=collection,
query={'gname': gname})
if group_data is None:
raise GroupErrors.GroupNotExistsError('Group Not Exists')
user_data = Database.find_one(collection=user_table,
query={'username': user})
if user_data is None:
raise UserErrors.UserNotExistsError("No Users with that name")
group_user_data = Database.find_one(collection=collection,
query={
'gname': gname,
'users': user
})
if group_user_data is None:
raise GroupErrors.UserNotExistsInGroupError(
'User Not Exists in this group')
Database.update(collection=collection,
query={'gname': gname},
data={'$pull': {
'users': user
}})
return True
def make_group_active(
gname
): # as there is node in only one group, making group inactive should make nodes under that group also inactive
group_data = Database.find_one(collection=collection,
query={'gname': gname})
if group_data['active'] is True:
raise GroupErrors.GroupAlreadyActiveError(
'Group is Already Active')
Database.update(collection=collection,
query={'gname': gname},
data={"$set": {
'active': True
}})
return True
def is_login_valid(cls, username, password):
user_data = Database.find_one(collection, {'username': username})
if user_data is None:
raise UserErrors.UserNotExistsError("Your User doesn't Exist")
if user_data['active'] is False:
raise UserErrors.UserisNotAuthorised(
"You are not authorised to Log In")
if not Utils.check_hashed_password(password, user_data['password']):
raise UserErrors.IncorrectPasswordError("Your Password was wrong")
return cls(**user_data)
def status(mac):
data = Database.find_one(collection, {'mac': mac})
if data is not None:
print(data['mac'])
print(data['reporte'])
d = data['reporte']
e = datetime.now()
f = e - d
g = int(f.total_seconds())
if g <= lastreach:
return {"message": "Online"}
else:
return {"message": "Offline"}
return {"message": "MAC Doesn't Exists or not registered"}
def stattus(mac):
data = Database.find_one(collection, {'mac': mac})
lastreach = app.config['LASTREACH']
if data is not None:
# print(data['mac'])
# print(data['reporte'])
d = data['reporte']
e = datetime.now()
f = e - d
g = int(f.total_seconds())
if g <= lastreach:
return True
else:
return False
def find_group_by_node(cls, node):
group = Database.find_one(collection=collection, query={'nodes': node})
return cls(**group)
def exec(mac):
request_data = request.get_json()
user = get_jwt_identity()
claims = get_jwt_claims()
if claims['is_admin'] is not True:
try:
if Pretty.is_mac_valid(mac):
pass
except NodeErrors.NodeNotExistsError as e:
return jsonify(message=e.message), 400
except NodeErrors.NodeInActiveError as e:
return jsonify(message=e.message), 400
auth = Group.find_user_and_node_in_same_group(mac, user)
if auth is not True:
return jsonify(
message='You are not Authorised to access this system'), 401
data = Database.find_one(collection, {'mac': mac})
if data is not None:
rand = random.randint(1000, 9999)
print(rand)
statuse = statuss(data)
print(statuse)
if statuse:
josn = Commands(mac=mac,
token=rand,
serve='true',
command=request_data['command'],
tag='false',
response='')
josn.save_to_mongo()
else:
return jsonify({'output': 'router is offline'})
a = datetime.now()
b = timedelta(seconds=timeout)
c = a + b
while datetime.now() < c:
r = Database.find_one(collection, {
'mac': mac,
'commands.token': rand,
'commands.tag': 'true'
})
randie = r['commands']
for i in randie:
if i['token'] == rand and i['tag'] == 'true':
response = i['response']
print('horrible')
print(response)
Database.update(
collection,
query={'mac': mac},
data={'$pull': {
'commands': {
'token': rand
}
}})
return jsonify(response)
Database.update(collection,
query={'mac': mac},
data={'$pull': {
'commands': {
'token': rand
}
}})
print('server timeout for' + str(rand))
return jsonify({'output': 'server time out or server busy'})
return jsonify({'output': 'unable to find with that mac'})
def hello():
request_data = request.get_json()
print(request_data)
data = Database.find_one(collection, {'mac': request_data['mac']})
if data is None:
print(untruce)
untruce.add(request_data['mac'])
return {'message': 'Unknown'}
if data is not None:
Database.update(collection,
query={'mac': request_data['mac']},
data={"$set": {
'reporte': datetime.now()
}})
if 'token' in request_data:
base = Database.find_one(
collection, {
'mac': request_data['mac'],
'commands.token': request_data['token']
})
if base is not None:
Database.update(collection,
query={
'mac': request_data['mac'],
'commands.token': request_data['token']
},
data={
"$set": {
"commands.$.response":
request_data['response']
}
})
Database.update(collection,
query={
'mac': request_data['mac'],
'commands.token': request_data['token']
},
data={"$set": {
"commands.$.tag": 'true'
}})
requeste = {'mac': request_data['mac']}
print(request_data['mac'])
rev = Database.find_one(collection, {
'mac': request_data['mac'],
'commands.serve': 'true'
})
if rev is not None:
randie = rev['commands']
print(randie)
for i in randie:
if i['serve'] == 'true':
rrr = i['token']
jjj = i['command']
print(rrr)
print(jjj)
requeste = {
'mac': rev['mac'],
'token': rrr,
'command': jjj
}
Database.update(
collection,
query={
'mac': rev['mac'],
'commands.token': i['token']
},
data={"$set": {
"commands.$.serve": 'mild'
}})
break
print(requeste)
return jsonify(requeste)
def find_nodes_in_group(cls, gname):
group_data = Database.find_one(collection=collection,
query={'gname': gname})
if group_data is None:
raise GroupErrors.GroupNotExistsError('Group Not Exists')
return cls(**group_data).nodes
