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)