def get(self, user_id=None):
# One
if user_id is not None:
user_doc = users.find_one({'_id': ObjectId(user_id)})
user = convert_user_object_from(user_doc)
return response.success(user)
# Many
cursor = users.find({})
existing_users = []
for user_doc in cursor:
user = convert_user_object_from(user_doc)
existing_users.append(user)
return response.success(existing_users)
def action_update():
content = request.get_json(silent=True)
content = content if content is not None else {}
form = DeviceUpdateForm.from_json(content)
if form.validate():
device = Device.query.get(form.id.data)
if device:
device.name = form.name.data
device.updated_at = datetime.utcnow()
db.session.flush()
db.session.commit()
device = Device.query.get(device.id)
return response.success(data={
'device': device.to_dict('update')
})
else:
return response.not_success('not-found')
else:
return response.from_form(form)
def action_data_out_by_random():
content = request.get_json(silent=True)
content = content if content is not None else {}
form = DeviceDataOutByRandomForm.from_json(content)
if form.validate():
datasets = form.datasets.data
dataset_list = []
for _ in range(datasets):
items = random_int_values(form.amount.data, form.min_value.data, form.max_value.data)
dataset_list.append({
'items': items
})
labels = random_datetime_range(
datetime.now() - timedelta(seconds=form.amount.data - 1),
datetime.now(),
dt_format='%H:%M:%S'
)
return response.success(data={
'labels': labels,
'datasets': dataset_list
})
else:
return response.from_form(form)
def book():
book = request.args.get('collection')
book_page = requests.get(endpoints.pergamum.collection.format(book=book))
return success(message="Livro retornado com sucesso",
book=str(book_page.content))
def action_list():
devices = Device.query.order_by(Device.created_at.desc()).all()
devices = [r.to_dict('list') for r in devices]
return response.success(data={
'list': devices,
})
def action_data_out_by_device():
content = request.get_json(silent=True)
content = content if content is not None else {}
form = DeviceDataOutByDeviceForm.from_json(content)
if form.validate():
device = Device.query.get(form.device_id.data)
if device:
items = DeviceData.query.filter(
DeviceData.device_id == form.device_id.data,
DeviceData.type == form.type.data,
DeviceData.created_at >= form.start_dt.data,
DeviceData.created_at <= form.end_dt.data
).all()
if items:
labels = map(lambda item: item.created_at.strftime(form.format_dt.data), items)
items = map(lambda item: item.value, items)
return response.success(data={
'labels': labels,
'datasets': [{
'items': items
}]
})
else:
return response.not_success('empty')
else:
return response.not_success('not-found')
else:
return response.from_form(form)
def action_create(account):
if not account.is_admin:
return response.unauthorized()
content = request.get_json(silent=True)
content = content if content is not None else {}
form = AccountCreateForm.from_json(content)
if form.validate():
new_account = Account()
new_account.name = form.name.data
new_account.email = form.email.data
new_account.photo_url = form.photo_url.data
new_account.is_admin = form.is_admin.data
new_account.created_at = datetime.utcnow()
new_account.set_password(form.password.data)
db.session.add(new_account)
db.session.flush()
db.session.commit()
new_account = Account.query.get(new_account.id)
return response.success(
data={'account': new_account.to_dict('create')})
else:
return response.from_form(form)
def news_item():
date = request.args.get("date")
date = datetime.datetime.strptime(date, '%d/%m/%Y')
news = portal_repository.news_item(date)
return success(message="Noticias retornadas com sucesso", daily_news=news)
def renew():
book = request.form.get('book')
token = request.headers.get("phpsessid")
pergamum_repository.renew(token, book)
return success(message="Livro renovado com sucesso", token=token)
def handler(event, context):
# print("event={}".format(json.dumps(event)))
# print("request_id={}".format(context.aws_request_id))
for record in event["Records"]:
payload = base64.b64decode(record["kinesis"]["data"])
partition_key = record["kinesis"]["partitionKey"]
output = {
"request_id": context.aws_request_id,
"sandbox_id": str(sandbox_id),
"partition_key": partition_key
}
try:
output["payload"] = json.loads(payload)
status = 200
except json.JSONDecodeError:
output["payload"] = payload.decode("utf-8")
status = 500
print(json.dumps(output))
if status == 200:
response = success("success")
else:
response = failure("failure")
return response
def login():
login = request.form.get('login')
password = request.form.get('password')
token = pergamum_repository.authenticate(login, password)
return success(message="Login realizado com sucesso", token=token)
def action_delete(account):
if not account.is_admin:
return response.unauthorized()
content = request.get_json(silent=True)
content = content if content is not None else {}
form = AccountDeleteForm.from_json(content)
if form.validate():
if form.id.data > 1:
found_account = Account.query.get(form.id.data)
if found_account:
db.session.delete(found_account)
db.session.flush()
db.session.commit()
return response.success()
else:
return response.not_success("not-found")
else:
return response.with_validate_error(
"id", ["Cannot delete this account."])
else:
return response.from_form(form)
def action_update(account):
if not account.is_admin:
return response.unauthorized()
content = request.get_json(silent=True)
content = content if content is not None else {}
form = AccountUpdateForm.from_json(content)
if form.validate():
found_account = Account.query.get(form.id.data)
if found_account:
found_account.name = form.name.data
found_account.token = form.token.data
found_account.email = form.email.data
found_account.photo_url = form.photo_url.data
found_account.is_admin = form.is_admin.data
found_account.updated_at = datetime.utcnow()
if form.password.data:
found_account.set_password(form.password.data)
db.session.flush()
db.session.commit()
found_account = Account.query.get(found_account.id)
return response.success(
data={"account": found_account.to_dict("update")})
else:
return response.not_success("not-found")
else:
return response.from_form(form)
def set_password():
data = request.get_json()
token = request.headers.get("x-api-token")
acadonline_repository.set_password(token, data)
return success(message="Perfil atualizado com sucesso", token=token)
def api_outage_fix():
set_outage(False)
control = get_control()
emit('control', control, namespace='/app', broadcast=True)
return success(get_state())
def action_list(account):
if not account.is_admin:
return response.unauthorized()
accounts = Account.query.order_by(Account.created_at.desc()).all()
accounts = [r.to_dict("list") for r in accounts]
return response.success(data={"list": accounts})
def weekly_news_items():
date = request.args.get("date")
date = datetime.datetime.strptime(date, '%d/%m/%Y')
_weekly_news_items = portal_repository.weekly_news_items(date)
return success(message="Noticias retornadas com sucesso",
weekly_news=_weekly_news_items)
def home():
phpsessid = request.headers.get("phpsessid")
headers = {"cookie": f"PHPSESSID={phpsessid};"}
home_page = requests.get(pergamum_urls["home"], headers=headers)
return success(message="Meu pergamum capturado com sucesso!",
token=phpsessid)
def api_set_clock_skew():
skew = request.args.get('skew', 1)
set_clock_skew(skew)
control = get_control()
emit('control', control, namespace='/app', broadcast=True)
return success(get_state())
def books():
token = request.headers.get("phpsessid")
# loans = pergamum_repository.books(token)
loans = pergamum_repository.books_mock()
return success(message="Livros retornados com sucesso",
token=token,
loans=loans)
def api_outage_strategy():
strategy = request.args.get('strategy', 'immediate')
set_outage_strategy(strategy)
control = get_control()
emit('control', control, namespace='/app', broadcast=True)
return success(get_state())
def api_set_data_frequency():
frequency = request.args.get('frequency', 1)
set_data_frequency(frequency)
control = get_control()
emit('control', control, namespace='/app', broadcast=True)
return success(get_state())
def menu():
campus = request.args.get("campus")
shift = request.args.get("shift")
next = request.args.get("next")
sample = request.args.get("sample")
weekly_menu = ru_repository.weekly_menu(campus, shift, next, sample)
return success(message="Cardápio retornado com sucesso",
weekly_menu=weekly_menu)
def get_additional_activities():
token = request.headers.get("x-api-token")
activities = acadonline_repository.get_additional_activities(token)
return success(
message="Atividades capturadas com sucesso!",
token=token,
activities=activities,
)
def get_perfil():
token = request.headers.get("x-api-token")
perfil = acadonline_repository.get_perfil(token)
return conditional_response(
perfil,
success(message="Perfil capturado com sucesso!",
perfil=perfil,
token=token), error(message="Perfil inválido"))
def news_items():
page = int(request.args.get("page", 1))
initial_date = now_subtracted_weeks(page * 2)
final_date = now_subtracted_weeks((page - 1) * 2)
_news_items = portal_repository.news_items(initial_date, final_date)
return success(message="Noticias retornadapys com sucesso",
news_items=_news_items)
def test_return_success(self):
data = {
'name': 'Steve Jobs',
'age': 30,
'gender': "male",
'email': "*****@*****.**"
}
r, status_code = response.success(data)
assert r == {'status': 'success', 'data': data}
assert status_code == 200
def action_data_out_by_device():
content = request.get_json(silent=True)
content = content if content is not None else {}
form = DeviceDataOutByDeviceForm.from_json(content)
if form.validate():
device = Device.query.filter(
Device.token == form.device_token.data).first()
if device:
if form.order.data == "asc":
order_by = asc(DeviceData.created_at)
else:
order_by = desc(DeviceData.created_at)
items = (DeviceData.query.filter(
DeviceData.device_id == device.id,
DeviceData.type == form.type.data,
DeviceData.created_at >= form.start_dt.data,
DeviceData.created_at <= form.end_dt.data,
).order_by(order_by).limit(form.amount.data).all())
if items:
if form.format_dt.data:
labels = map(
lambda item: item.created_at.strftime(form.format_dt.
data),
items,
)
else:
labels = map(
lambda item: int(
calendar.timegm(item.created_at.timetuple()) * 1000
),
items,
)
items = map(lambda item: item.value, items)
return response.success(data={
"labels": labels,
"datasets": [{
"items": items
}]
})
else:
return response.not_success("empty")
else:
return response.not_success("not-found")
else:
return response.from_form(form)
def get_disciplines():
token = request.headers.get("x-api-token")
disciplines = acadonline_repository.get_disciplines(token)
condition = len(disciplines) > 0
return conditional_response(
condition,
success(message="Disciplinas returnadas com sucesso!",
token=token,
disciplines=disciplines),
error(message="Erro ao retornar disciplinas"))
def get_grade():
token = request.headers.get("x-api-token")
extra = request.args.get("extra")
grade = acadonline_repository.get_grade_with_info(
token) if extra else acadonline_repository.get_grade(token)
condition = len(grade["disciplines"]) > 0
return conditional_response(
condition,
success(message="Notas capturadas com sucesso!",
token=token,
grade=grade), error(message="Erro ao capturar notas"))
