def put(self, username, task_id):
"""Update an existing task given a username and task id."""
with self.make_session() as session:
profile = yield as_future(
session.query(Profile).filter(
Profile.username == username).first)
if profile:
task = yield as_future(
session.query(Task).filter(
Task.profile == profile).get(task_id))
if task:
self.authenticate_response(profile)
self.send_response({
'username': username,
'task': task.to_dict()
})
else:
self.authenticate_response(profile)
self.send_response({
'username': username,
'task': None
},
status=404)
else:
self.send_response(
{
'error':
'555You do not have permission to access this data.'
},
status=403)
def delete(self, username, task_id):
"""Delete an existing task given a username and task id."""
with self.make_session() as session:
profile = yield as_future(session.query(Profile).filter(Profile.username == username).first)
if profile:
task = yield as_future(session.query(Task).filter(Task.profile == profile).get(task_id))
if task:
session.delete(task)
session.commit()
self.authenticate_response(profile)
self.send_response({'username': username, 'msg': 'Deleted.'})
else:
self.send_response({'error': 'You do not have permission to access this data.'}, status=403)
def post(self):
"""Log a user in."""
try:
needed = ['username', 'password']
if all([key in self.form_data for key in needed]):
with self.make_session() as session:
username = self.form_data['username'][0]
profile = yield as_future(
session.query(Profile).filter(
Profile.username == username).first)
if profile and hasher.verify(self.form_data['password'][0],
profile.password):
self.authenticate_response(profile)
self.send_response(
{'msg': 'Login succeeded. Please proceed.'},
status=201)
else:
self.send_response(
{
'error':
'Incorrect username/password combination.'
},
status=400)
else:
self.send_response({'error': 'Some fields are missing'},
status=400)
except Exception as e:
self.send_response({'error': str(e)}, status=400)
def put(self, username):
"""Handle incoming put request to update a specific profile."""
with self.make_session() as session:
profile = yield as_future(
session.query(Profile).filter(
Profile.username == username).first)
print('Profile name is ' + Profile.username +
' and the username is ' + username)
if profile:
if 'username' in self.form_data:
profile.username = self.form_data['username'][0]
if 'password' in self.form_data and 'password2' in self.form_data and self.form_data['password'] == \
self.form_data['password2'] and self.form_data['password'][0] != '':
profile.password = hasher.hash(
self.form_data['password'][0])
if 'email' in self.form_data:
profile.email = self.form_data['email'][0]
session.add(profile)
session.commit()
self.authenticate_response(profile)
self.send_response(
{
'msg': 'Profile updated.',
'profile': profile.to_dict(),
'username': profile.username
},
status=202)
else:
self.send_response(
{
'error':
'222You do not have permission to access this profile.'
},
status=403)
def post(self):
"""Handle a POST request for user registration."""
needed = ['username', 'email', 'password', 'password2']
if all([key in self.form_data for key in needed]):
username = self.form_data['username'][0]
try:
with self.make_session() as session:
profile = yield as_future(
session.query(Profile).filter(
Profile.username == username).first)
if not profile:
if self.form_data['password'] == self.form_data[
'password2']:
self.build_profile(session)
self.send_response({'msg': 'Profile created'},
status=201)
else:
self.send_response(
{'error': "Passwords don't match"}, status=400)
else:
self.send_response(
{
'error':
"Profiles already exists, please login."
},
status=400)
except Exception as e:
print("Exception occurred: " + str(e))
self.set_status(status_code=500,
reason="Backend server is down!!!")
async def parse_request(cls, session, request_string: str) -> str:
dates, temp_data, hum_data = [], [], []
request_string += ',' * (max(3 - request_string.count(','), 0)) # Preventing unpacking error
module_id, client_id, from_date, until_date = request_string.split(',')
from_date = cls.__parse_date_string(from_date) or datetime(year=2000, month=1, day=1)
until_date = cls.__parse_date_string(until_date) or datetime.now()
query = cls._get_weekly_detailed_query() if (until_date - from_date) <= timedelta(days=7) \
else cls._get_monthly_average_query()
data = await asyncio.wrap_future(as_future(session.execute(query,
{'module_id': module_id, 'client_id': client_id,
'from_date': from_date,
'until_date': until_date + timedelta(days=1)
}).fetchall))
for temp, hum, date in data:
temp_data.append(str(temp))
hum_data.append(str(hum))
dates.append(f'"{date}"')
formatted = """
{{
"labels":[{month_list}],
"datasets":[
{{"label":"temperature","data":[{temp_data}],"borderColor":"rgb(175,92,22)"}},
{{"label":"humidity","data":[{hum_data}],"borderColor":"rgb(50,50,192)"}}
]
}}
""".format(month_list=','.join(dates), temp_data=','.join(temp_data), hum_data=','.join(hum_data))
return formatted
def post(self, username):
"""
Creates a new task
"""
with self.make_session() as session:
user = yield as_future(
session.query(User).filter(User.username == username).first)
if user:
try:
due_date = self.data['due_date'][0]
completed = self.data['completed'][0]
except KeyError:
due_date = None
completed = None
task = Task(
name=self.data['name'][0],
note=self.data['note'][0],
creation_date=datetime.now(),
due_date=datetime.strptime(due_date, '%d/%m/%Y %H:%M:%S')
if due_date else None,
completed=completed if completed else False,
user_id=user.id,
user=user)
session.add(task)
self.send_response(
{
'message': 'Task created',
'Task': task.name
}, status=201)
def get(self):
username = self.get_argument('username', None)
if username:
print('Got request for username <%s>' % username)
# Get key for user or create record in db
with self.make_session() as session:
user = yield as_future(
session.query(User).filter(
User.username == username).first)
if not user:
keys = generate_rsa_pair(rsa_size)
user = User(
username=username,
public_key=keys.get('public_key'),
)
session.add(user)
self.send_response(
{
'username': user.username,
'publick_key': str(user.public_key),
},
status=201,
)
else:
self.send_response('No username provided', status=400)
def post(self):
url = self.get_argument('url')
# Fetch word dictionary with frequency
word_dict = build_word_dict(url)
# Get public key
public_key = get_keys("public_key")
new_dict_array = []
with self.make_session() as session:
# Iterate through all the word in the word_dict , create the word hash and
# check if a word hash exists in the database
for word, quantity in word_dict:
new_dict = {'text': word, 'size': quantity}
new_dict_array.append(new_dict)
salted_hash = get_salted_hash(word)
word_element = yield as_future(
session.query(Word).filter(
Word.word_hash == salted_hash).first)
if not word_element:
# Create a word object and add to session
encrypted_word = encrypt_data(word, public_key)
session.add(
Word(word_hash=salted_hash,
word=encrypted_word,
count=quantity))
else:
# update the word object with the frequency
word_element.count += quantity
session.commit()
self.render("base.html", word_array=json_encode(new_dict_array))
def post(self, username):
"""Create a new task."""
with self.make_session() as session:
profile = yield as_future(session.query(Profile).filter(Profile.username == username).first)
if profile:
due_date = self.form_data['due_date'][0]
try:
task = Task(
name=self.form_data['name'][0],
note=self.form_data['note'][0],
creation_date=datetime.now(),
due_date=datetime.strptime(due_date, '%d/%m/%Y %H:%M:%S') if due_date else None,
completed=self.form_data['completed'][0],
profile_id=profile.id,
profile=profile
)
session.add(task)
session.commit()
self.authenticate_response(profile)
self.send_response({'msg': 'posted'}, status=201)
except KeyError:
self.authenticate_response(profile)
self.send_response({'error': 'Some fields are missing'}, 400)
else:
self.send_response({'error': 'You do not have permission to access this profile.'}, status=404)
def delete(self, username):
"""Delete an existing task from the database."""
with self.make_session() as session:
profile = yield as_future(session.query(Profile).filter(Profile.username == username).first)
session.delete(profile)
session.commit()
self.send_response({}, status=204)
def get(self):
with self.make_session() as session:
session.add(User(username='******'))
session.add(Foo(foo='foo'))
session.add(Bar(bar='bar'))
session.commit()
count = yield as_future(session.query(User).count)
self.write('{} users so far!'.format(count))
def get(self, username):
"""Handle incoming get request for a specific user's profile."""
with self.make_session() as session:
profile = yield as_future(session.query(Profile).filter(Profile.username == username).first)
if profile:
self.authenticate_response(profile)
self.send_response(profile.to_dict())
else:
self.send_response({'error': 'You do not have permission to access this profile.'}, status=403)
def get(self, username):
"""Get all tasks for an existing user."""
with self.make_session() as session:
profile = yield as_future(session.query(Profile).filter(Profile.username == username).first)
if profile:
tasks = [task.to_dict() for task in profile.tasks]
self.send_response({
'username': profile.username,
'tasks': tasks
})
def get(self, username):
"""
Get all tasks for an existing user
"""
with self.make_session() as session:
user = yield as_future(
session.query(User).filter(User.username == username).first)
if user:
tasks = [task.columns_to_dict() for task in user.tasks]
self.send_response({'username': user.username, 'tasks': tasks})
def test_concurrent_requests_using_yield(self):
sessions = [db.sessionmaker() for _ in range(self.session_count)]
for index, session in enumerate(sessions):
session.add(User('User #{}'.format(index)))
session.commit()
yield [as_future(session.query(User).count) for session in sessions]
for session in sessions:
session.close()
def post(self):
"""Handle a POST request for user registration."""
needed = ['username', 'email', 'password', 'password2']
if all([key in self.form_data for key in needed]):
username = self.form_data['username'][0]
with self.make_session() as session:
profile = yield as_future(session.query(Profile).filter(Profile.username == username).first)
if not profile:
if self.form_data['password'] == self.form_data['password2']:
self.build_profile(session)
self.send_response({'msg': 'Profile created'}, status=201)
else:
self.send_response({'error': "Passwords don't match"}, status=400)
def get(self, username):
"""Get all tasks for an existing user."""
with self.make_session() as session:
profile = yield as_future(session.query(Profile).filter(Profile.username == username).first)
if profile:
tasks = [task.to_dict() for task in profile.tasks]
self.authenticate_response(profile)
self.send_response({
'username': profile.username,
'tasks': tasks
})
else:
self.send_response({'error': 'The profile does not exist'}, status=404)
def test_concurrent_requests_using_yield(self):
factory = make_session_factory(postgres_url, pool_size=1)
sessions = [factory.make_session() for _ in range(self.session_count)]
yield [
as_future(lambda: session.execute(
'SELECT pg_sleep(:duration)',
{'duration': self.sleep_duration},
)) for session in sessions
]
for session in sessions:
session.close()
def get(self):
private_key = get_keys("private_key")
words = []
with self.make_session() as session:
# Fetch all the words from the table in order of their frequency and return
# to the front end
word_array = yield as_future(
session.query(Word).order_by(desc(Word.count)).all)
for word_obj in word_array:
word = {}
word["count"] = word_obj.count
# Decrypt the key before sending back to front end
word["word"] = decrypt_data(word_obj.word, private_key)
words.append(word)
self.render("admin.html", words=words)
def post(self, username):
"""Create a new task."""
with self.make_session() as session:
profile = yield as_future(session.query(Profile).filter(Profile.username == username).first)
if profile:
due_date = self.form_data['due_date'][0]
task = Task(
name=self.form_data['name'][0],
note=self.form_data['note'][0],
creation_date=datetime.now(),
due_date=datetime.strptime(
due_date, '%d/%m/%Y %H:%M:%S') if due_date else None,
completed=self.form_data['completed'][0],
profile_id=profile.id,
profile=profile
)
session.add(task)
self.send_response({'msg': 'posted'}, status=201)
def get(self):
with self.make_session() as session:
count = yield as_future(session.query(User).count)
self.write('{} users so far!'.format(count))
def get(h_self):
with h_self.make_session() as session:
count = yield as_future(session.query(User).count)
h_self.write(str(count))
def get_queues_async(session):
return as_future(DeviceType.get_queues(session).all)
def as_future(self, callable):
return tsql.as_future(callable)
async def _get_modules(self, session):
return await asyncio.wrap_future(as_future(session.query(Module).all))
def get_owned_devices_async(self, session):
return as_future(self.get_owned_devices(session).all)
def get_all_ro_urls_async(session):
return as_future(DeviceQueue.get_all_ro_urls(session).all)
