async def not_found(request, exc):
"""
Return an HTTP 404 page.
"""
template = "error/404.html"
context = {"request": request}
return templates.TemplateResponse(template, context, status_code=404)
async def forgot_password(request):
status_code = 200
template = f"{page_url}/forgot-password.html"
context = {"request": request, "greeting": "hi"}
return templates.TemplateResponse(template,
context,
status_code=status_code)
async def profile(request):
if "username" not in request.session:
logger.error(
f"user page access without being logged in from {request.client.host}"
)
raise HTTPException(status_code=403)
username = request.path_params["username"]
# can_edit = check_can_edit(request, username)
query = users.select().where(users.c.username == username)
profile_user = await database.fetch_one(query)
if profile_user is None:
raise HTTPException(status_code=403)
repo_data = await github_calls.get_repo_list(username)
user_data = await github_calls.get_user_info(username)
user_events = await github_calls.get_user_events(username)
status_code = 200
template = "profile.html"
context = {
"request": request,
"owner": username,
"profile_user": profile_user,
"repo_data": repo_data,
"user_data": user_data,
"user_events": user_events,
}
return templates.TemplateResponse(template,
context,
status_code=status_code)
async def password_change(request):
form = await forms.UpdatePasswordForm.from_formdata(request)
form_data = await request.form()
if await form.validate_on_submit():
# TODO: make this work
hashed_pwd = encrypt_pass(form_data["password"])
query = users.update().where(
users.c.user_name == request.session["user_name"])
values = {
"password": hashed_pwd,
}
logger.debug(values)
db_result = await execute_one_db(query=query, values=values)
logger.info("Redirecting user to index page /")
return RedirectResponse(url="/", status_code=303)
status_code = 200
template = f"{page_url}/password.html"
context = {"request": request, "form": form}
logger.info(f"page accessed: /user/password-change")
return templates.TemplateResponse(template,
context,
status_code=status_code)
async def server_error(request, exc):
"""
Return an HTTP 500 page.
"""
template = "error/500.html"
context = {"request": request}
return templates.TemplateResponse(template, context, status_code=500)
async def index(request):
# library table
lib_data = await lib_crud.get_data()
# lib_data_month = await lib_crud.process_by_month(lib_data)
# lib_sum = await lib_crud.sum_lib(lib_data_month)
# library_data_count = await lib_crud.process_by_lib(lib_data)
# lib_data_sum = await lib_crud.sum_lib_count(library_data_count)
# requirements table
req_data = await lib_crud.requests_data()
data: dict = {
# "lib_data_month": lib_data_month,
# "lib_sum": lib_sum,
# "library_data_count": library_data_count,
# "lib_data_sum": lib_data_sum,
"req_data": req_data,
"lib_data": lib_data,
}
logger.critical(data)
template: str = "dashboard.html"
context = {"request": request, "data": data}
logger.info(f"page accessed: /{template}")
logger.critical(dict(request.headers))
return templates.TemplateResponse(template, context)
async def pypi_result(request):
request_group_id = request.path_params["page"]
data = await get_request_group_id(request_group_id=request_group_id)
template = f"/{base}/result.html"
context = {"request": request, "data": data}
logger.info(f"page accessed: /pypi/{request_group_id}")
return templates.TemplateResponse(template, context)
async def modeler_bpmn(request):
"""
BPM Viewer Page
"""
status_code = 200
template = f"/{base}/modeler_bpmn.html"
context = {"request": request}
logger.info("page accessed: /modeler/bpmn/view")
return templates.TemplateResponse(template,
context,
status_code=status_code)
async def get(self, request):
context = {'request': request}
if request.user.is_authenticated:
template = 'home_logged.html'
if request.user.follow_to:
context.update({'following': request.user.follow_to})
else:
template = 'home.html'
return templates.TemplateResponse(template, context=context)
async def get(self, request):
last_events = await twitch_services.get_last_events_by_streamer(
request.user.follow_to, 10)
template = 'streamer.html'
context = {
'request': request,
'streamer_name': request.user.follow_to,
'events': last_events
}
return templates.TemplateResponse(template, context=context)
async def dashboard(request):
"""
Index page for twitter bots
"""
template = f"{page_url}/index.html"
context = {
"request": request,
# "bots": bots_list,
}
logger.info("page accessed: /dashboard")
return templates.TemplateResponse(template, context)
async def server_error(request, exc):
"""
Return an HTTP 500 page.
"""
# if "username" not in request.session:
# logger.error(
# f"user page access without being logged in from {request.client.host}"
# )
# return RedirectResponse(url="/", status_code=303)
template = "error/500.html"
context = {"request": request}
return templates.TemplateResponse(template, context, status_code=500)
async def homepage_page(request):
try:
html_page = request.path_params["page"]
template = f"{html_page}.html"
context = {"request": request}
logger.info(f"page accessed: {template}")
return templates.TemplateResponse(template, context)
except Exception as e:
logger.critical(
f"Error: Page accessed: /{html_page} , but HTML page {e} does not exist"
)
raise HTTPException(404, detail="page note found")
async def not_found(request, exc):
"""
Return an HTTP 404 page.
"""
if "user_name" not in request.session:
logger.error(
f"user page access without being logged in from {request.client.host}"
)
return RedirectResponse(url="/", status_code=303)
template = "error/404.html"
context = {"request": request}
return templates.TemplateResponse(template, context, status_code=404)
async def example_pages_charts(request):
html_page = request.path_params["page"]
try:
template = f"/pages/charts/{html_page}.html"
context = {"request": request}
logger.info(f"page accessed: {template}")
return templates.TemplateResponse(template, context)
except Exception as e:
logger.critical(
f"Error: Page accessed: /{html_page} , but HTML page {e} does not exist"
)
raise HTTPException(404, detail=detail)
async def notes_index(request):
"""
Index page for notes
"""
user_name = request.session["user_name"]
user_data = await user_crud.user_info(user_name=user_name)
user_data: dict = dict(user_data)
template = f"{page_url}/index.html"
context = {
"request": request,
"user_data": user_data,
}
logger.info("page accessed: /notes")
return templates.TemplateResponse(template, context)
async def profile(request):
user_name = request.session["user_name"]
user_data = await user_crud.user_info(user_name=user_name)
user_data = dict(user_data)
pop_list: list = ['password', 'first_login', 'from_config']
for p in pop_list:
user_data.pop(p, None)
status_code = 200
template = f"{page_url}/profile.html"
context = {"request": request, "user_data": user_data}
return templates.TemplateResponse(template,
context,
status_code=status_code)
async def admin_all_requests(request):
"""
Index page for twitter bots
"""
approval_list = await admin_crud.get_all_approvals()
logging.debug(str(approval_list))
template = f"{page_url}/admin_all.html"
context = {
"request": request,
"approval_list": approval_list,
}
logger.info("page accessed: /admin")
return templates.TemplateResponse(template, context)
async def register(request):
form = await forms.CreateAccountForm.from_formdata(request)
form_data = await request.form()
if await form.validate_on_submit():
# check if unique email
email_check = await form_validators.email_check(form_data["email"])
# check if unique user_name
user_name_check = await form_validators.user_name_check(
form_data["user_name"])
if email_check != None:
if email_check["email"] == form_data["email"]:
logger.error(f'{form_data["email"]} exists in database')
form.email.errors.append(f"the email exists within database")
elif user_name_check != None:
if user_name_check["user_name"] == form_data["user_name"]:
logger.error(f'{form_data["user_name"]} exists in database')
form.user_name.errors.append(
f"the user_name exists within database")
else:
hashed_pwd = encrypt_pass(form_data["password"])
values = {
"first_name": form_data["first_name"],
"last_name": form_data["last_name"],
"user_name": form_data["user_name"].lower(),
"password": hashed_pwd,
"email": form_data["email"].lower(),
}
logger.debug(values)
await user_crud.user_register(data=values)
await create_review_user(form_data["user_name"].lower())
logger.info("Redirecting user to index page /")
return RedirectResponse(url="/", status_code=303)
status_code = 422 if form.errors else 200
template = "/user/register.html"
context = {"request": request, "form": form}
logger.info(f"page accessed: /user/register")
return templates.TemplateResponse(template,
context,
status_code=status_code)
async def pypi_index(request):
form = await forms.RequirementsForm.from_formdata(request)
form_data = await request.form()
if await form.validate_on_submit():
logger.critical(form_data)
logger.info(form_data["requirements"])
requirements_str = form_data["requirements"]
raw_data: str = requirements_str
# create UUID for request
request_group_id = uuid.uuid4()
# store incoming data
# process raw data
req_list = await pypi_calls.process_raw(raw_data=raw_data)
# clean data
cleaned_data = pypi_calls.clean_item(req_list)
# call pypi
fulllist = await pypi_calls.loop_calls_adv(
itemList=cleaned_data, request_group_id=str(request_group_id))
# store returned results (bulk)
values = {
"id": str(uuid.uuid4()),
"request_group_id": str(request_group_id),
"text_in": raw_data,
"json_data_in": req_list,
"json_data_out": fulllist,
"host_ip": request.client.host,
"header_data": dict(request.headers),
"dated_created": datetime.now(),
}
await store_in_data(values)
# request_group_id = await main(raw_data=text_in, host_ip=host_ip)
logger.info("Redirecting user to index page /")
return RedirectResponse(url=f"/pypi/results/{str(request_group_id)}",
status_code=303)
status_code = 200
template = f"/{base}/pypi_new.html"
context = {"request": request, "form": form}
logger.info("page accessed: /pypi/")
return templates.TemplateResponse(template,
context,
status_code=status_code)
async def homepage(request):
template = "index.html"
context = {"request": request}
logger.info(f"page accessed: /")
return templates.TemplateResponse(template, context)
async def login(request):
logger.debug(f"request")
form = await forms.AccountLoginForm.from_formdata(request)
form_data = await request.form()
if await form.validate_on_submit():
logger.critical(form_data)
user_name = form_data["user_name"]
user_name = user_name.lower()
pwd = form_data["password"]
logger.debug(f"user_name: {user_name}, pwd: {pwd}")
result = await form_validators.valid_login(pwd=pwd,
user_name=user_name)
logger.debug(f"loging valid = {result}")
# user_name = user_name.lower()
logger.debug(f"checking if {user_name.lower()} has valid login")
query = users.select().where(users.c.user_name == user_name)
logger.info(f"fetch user_name: {user_name}")
user_data = await fetch_one_db(query)
logger.debug(f"LOOK AT THIS query result = {user_data}")
last_login_values = {"last_login": datetime.datetime.now()}
last_login_query = users.update().where(users.c.user_name == user_name)
await execute_one_db(query=last_login_query, values=last_login_values)
logger.info(f"updating last login for {user_name}")
if result == False:
client_host = request.client.host
fail_values: dict = {
"id": str(uuid.uuid4()),
"date_created": datetime.datetime.now(),
"user_name": user_name,
"ip_address": client_host,
}
fail_query = user_login_failures.insert()
await execute_one_db(query=fail_query, values=fail_values)
logger.warning(
f"User login failure for {user_name} from {client_host}")
form.user_name.errors.append(f"user_name or Password is invalid")
elif user_data["is_active"] == False:
form.user_name.errors.append(
f"The user id is not active or been approved for login")
else:
# get user user_name
request.session["user_name"] = user_data["user_name"]
request.session["updated"] = str(datetime.datetime.utcnow())
request.session["admin"] = user_data["is_admin"]
request.session[
"realname"] = f'{user_data["first_name"]} {user_data["last_name"]}'
logger.info(
f'logger {request.session["user_name"]} and send to profile page'
)
return RedirectResponse(url="/", status_code=303)
template = f"{page_url}/login.html"
context = {"request": request, "form": form}
logger.info(f"page accessed: /user/login")
return templates.TemplateResponse(template, context)
async def authorize(request):
redirect_url = request.query_params.get("redirect_url", "#")
template = "mock_github/authorize.html"
context = {"request": request, "redirect_url": redirect_url}
return templates.TemplateResponse(template, context)
async def admin_review(request):
access_id = request.path_params["page"]
form = await forms.ApprovalReviewForm.from_formdata(request)
form_data = await request.form()
approval_info = await admin_crud.review_user(access_id=access_id)
user_name = approval_info["user_name"]
user_info = await admin_crud.user_data(user_name)
user_email = user_info["email"]
if form.validate_on_submit():
if "is_admin" not in form_data:
is_admin = False
else:
is_admin = True
if "is_active" not in form_data:
is_active = False
is_rejected = True
else:
is_active = True
is_rejected = False
if is_active == True:
data = {
"access_id": access_id,
"user_name": user_name,
"is_reviewed": True,
"is_rejected": is_rejected,
"is_active": is_active,
"is_admin": is_admin,
}
logger.critical(data)
await admin_crud.update_user_review(data)
logger.warning(user_email)
send_user_approved(user_email)
logger.info("Redirecting user to index page /admin/open")
return RedirectResponse(url="/admin/open", status_code=303)
else:
data = {
"access_id": access_id,
"user_name": user_name,
"is_reviewed": True,
"is_rejected": True,
"is_active": False,
"is_admin": False,
}
# update user_apprvoal
await admin_crud.update_user_review(data)
# send rejection email
logger.warning(user_email)
send_user_reject(user_email)
logger.info("Redirecting user to index page /admin/open")
return RedirectResponse(url="/admin/open", status_code=303)
html_page = request.path_params["page"]
template = f"{page_url}/admin_review.html"
context = {
"request": request,
"approval_info": approval_info,
"user_info": user_info,
"form": form,
}
logger.info(f"page accessed: {template}")
return templates.TemplateResponse(template, context)
async def about_page(request):
template = f"about.html"
context = {"request": request}
logger.info(f"page accessed: /{template}")
return templates.TemplateResponse(template, context)
