async def get(self, request: HTTPConnection): id = request.path_params["id"] challenge = await Challenge.get(id) if challenge is None: return abort(404, "Challenge not found") if not can_edit(request): return abort(400) form = ChallengeForm( title=challenge.title, content=challenge.content, flag_or_answer=challenge.flag or challenge.answer, is_flag=challenge.flag is not None, hidden=challenge.hidden, depreciated=challenge.depreciated, points=challenge.points, tags=challenge.tags, ) images = await encoded_existing_images(request) tags = orjson.dumps(await get_all_tags(include_hidden=True)) return templates.TemplateResponse( "challenge/edit.j2", { "request": request, "form": form, "challenge": challenge, "existing_images": images, "existing_tags": tags, }, )
async def get(self, request: HTTPConnection): id = request.path_params["id"] blog = await Blog.get(id) if blog is None: return abort(404, "Blog not found") if not can_edit(request): return abort(400) form = PostForm(title=blog.title, tags=blog.tags, content=blog.content) images = await encoded_existing_images(request) tags = ujson.dumps(await get_all_tags()) return templates.TemplateResponse( "blog/edit.j2", { "request": request, "form": form, "blog": blog, "existing_images": images, "existing_tags": tags, }, )
async def writeups_all_tags(request: HTTPConnection): tags = await get_all_tags() return templates.TemplateResponse("writeups/tag_list.j2", { "request": request, "tags": tags })
async def get(self, request: HTTPConnection): id = request.path_params["id"] writeup = await Writeup.get(id) if writeup is None: return abort(404, "Writeup not found") if not can_edit(request, writeup.author_id): return abort(400) form = WriteupForm( title=writeup.title, tags=writeup.tags, content=writeup.content, private=writeup.private, ) images = await encoded_existing_images(request) tags = orjson.dumps(await get_all_tags(True)) return templates.TemplateResponse( "writeups/edit.j2", { "request": request, "form": form, "writeup": writeup, "existing_images": images, "existing_tags": tags, }, )
async def blog_all_tags(request: HTTPConnection): tags = await get_all_tags() grouped_blogs = await blogs_grouped() return templates.TemplateResponse( "blog/tag_list.j2", {"request": request, "tags": tags, "grouped_blogs": grouped_blogs} )
async def post(self, request: HTTPConnection): form = await request.form() form = ChallengeForm(form) is_valid = form.validate() if not slug(form.title.data): is_valid = False form.title.errors.append( "A valid url-safe name cannot be generated for this title.") if (await Challenge.query.where( sa.or_( Challenge.title == form.title.data, Challenge.slug == slug(form.title.data), )).gino.first() is not None): is_valid = False form.title.errors.append( f"A challenge with the title conflicting with '{form.title.data}' already exists." ) if is_valid: f_a = form.flag_or_answer.data flag, answer = (f_a, None) if form.is_flag.data else (None, f_a) challenge = await Challenge.create_auto( title=form.title.data, content=form.content.data, flag=flag, answer=answer, hidden=form.hidden.data, depreciated=form.depreciated.data, points=form.points.data, tags=form.tags.data, ) url = request.url_for("challenge_view", slug=challenge.slug) if not challenge.hidden: await log_create("challenge", challenge.title, request.user.username, url) return redirect_response(url=url) images = await encoded_existing_images(request) tags = orjson.dumps(await get_all_tags(include_hidden=True)) return templates.TemplateResponse( "challenge/new.j2", { "request": request, "form": form, "existing_images": images, "existing_tags": tags, }, )
async def challenge_all_tags(request: HTTPConnection): tags = await get_all_tags() return templates.TemplateResponse( "challenge/tag_list.j2", { "request": request, "tags": tags }, )
async def post(self, request: HTTPConnection): id = request.path_params["id"] blog = await Blog.get(id) if blog is None: return abort(404, "Blog not found") if not can_edit(request, blog.author_id): return abort(400) form = await request.form() form = PostForm(form) is_valid = form.validate() if not slug(form.title.data): is_valid = False form.title.errors.append( "A valid url-safe name cannot be generated for this title.") if blog.title != blog.title.data: if (await Blog.query.where( sa.or_(Blog.title == form.title.data, Blog.slug == slug(form.title.data))).gino.first() is not None): is_valid = False form.title.errors.append( f"A blog with the title '{form.title.data}' already exists." ) if is_valid: await blog.update_auto(title=form.title.data, tags=form.tags.data, content=form.content.data).apply() url = request.url_for("blog_view", slug=blog.slug) await log_edit("blog", blog.title, request.user.username, url) return redirect_response(url=url) images = await encoded_existing_images(request) tags = orjson.dumps(await get_all_tags()) return templates.TemplateResponse( "blog/edit.j2", { "request": request, "form": form, "blog": blog, "existing_images": images, "existing_tags": tags, }, )
async def blog_index(request: HTTPConnection): latest = (await Blog.load(author=User).order_by(sa.desc(Blog.creation_date) ).gino.all()) rendered = [(w, length_constrained_plaintext_markdown(w.content)) for w in latest] return templates.TemplateResponse("blog/index.j2", { "request": request, "blog": rendered })
async def post(self, request: HTTPConnection): form = await request.form() form = WriteupForm(form) is_valid = form.validate() if not slug(form.title.data): is_valid = False form.title.errors.append( "A valid url-safe name cannot be generated for this title." ) if ( await Writeup.query.where( sa.or_( Writeup.title == form.title.data, Writeup.slug == slug(form.title.data), ) ).gino.first() is not None ): is_valid = False form.title.errors.append( f"A writeup with the title conflicting with '{form.title.data}' already exists." ) if is_valid: writeup = await Writeup.create_auto( author_id=request.user.discord_id, title=form.title.data, tags=form.tags.data, content=form.content.data, private=form.private.data, ) url = request.url_for("writeups_view", slug=writeup.slug) await log_create("writeup", writeup.title, request.user.username, url) return redirect_response(url=url) images = await encoded_existing_images(request) tags = orjson.dumps(await get_all_tags(True)) return templates.TemplateResponse( "writeups/new.j2", { "request": request, "form": form, "existing_images": images, "existing_tags": tags, }, )
async def blog_by_user(request: HTTPConnection): user = request.path_params["user"] blog = (await Blog.load(author=User).where(User.username == user).order_by( sa.desc(Blog.creation_date)).gino.all()) rendered = [(w, length_constrained_plaintext_markdown(w.content)) for w in blog] return templates.TemplateResponse("writeups/index.j2", { "request": request, "writeups": rendered })
async def blog_index(request: HTTPConnection): latest = await Blog.query.order_by(sa.desc(Blog.creation_date)).limit(20).gino.all() rendered = [ (w, shorten(plaintext_markdown(w.content), width=800, placeholder="...")) for w in latest ] grouped_blogs = await blogs_grouped() return templates.TemplateResponse( "blog/index.j2", {"request": request, "blog": rendered, "grouped_blogs": grouped_blogs} )
async def blog_view(request: HTTPConnection): slug = request.path_params["slug"] blog = await Blog.query.where(Blog.slug == slug).gino.first() if blog is None: return abort(404, "Blog not found") rendered = highlight_markdown(blog.content) return templates.TemplateResponse( "blog/view.j2", {"blog": blog, "request": request, "rendered": rendered} )
async def writeups_search(request: HTTPConnection): s_query = request.query_params.get("search", "") # sorry about this query = pg_search(sa.select([Writeup.join(User)]), s_query, sort=True) query = query.column( sa.func.ts_headline( search_manager.options["regconfig"], Writeup.content, sa.func.tsq_parse(search_manager.options["regconfig"], s_query), f"StartSel=**,StopSel=**,MaxWords=70,MinWords=30,MaxFragments=3", ).label("headline")) writeups = await query.as_scalar().gino.all() def build_writeup(r): """we get back a RowProxy so manually construct the writeup from it.""" author = User(discord_id=r.discord_id, username=r.username, email=r.email) writeup = Writeup( id=r.id, author_id=r.author_id, title=r.title, slug=r.slug, tags=r.tags, content=r.content, creation_date=r.creation_date, edit_date=r.edit_date, ) writeup.author = author return writeup writeups = [(build_writeup(r), r.headline) for r in writeups] rendered = [(w, shorten(plaintext_markdown(headline), width=300, placeholder="...")) for (w, headline) in writeups] return templates.TemplateResponse( "writeups/index.j2", { "request": request, "writeups": rendered, "query": s_query }, )
async def writeups_index(request: HTTPConnection): latest = (await Writeup.load(author=User).order_by(sa.desc(Writeup.creation_date) ).limit(20).gino.all()) rendered = [(w, shorten(plaintext_markdown(w.content), width=300, placeholder="...")) for w in latest] return templates.TemplateResponse("writeups/index.j2", { "request": request, "writeups": rendered })
async def get(self, request: HTTPConnection): form = ChallengeForm() images = await encoded_existing_images(request) tags = orjson.dumps(await get_all_tags(include_hidden=True)) return templates.TemplateResponse( "challenge/new.j2", { "request": request, "form": form, "existing_images": images, "existing_tags": tags, }, )
async def blog_by_tag(request: HTTPConnection): tag = request.path_params["tag"] blog = (await Blog.load(author=User).where(Blog.tags.contains([tag]) ).order_by(sa.desc(Blog.creation_date) ).gino.all()) rendered = [(w, length_constrained_plaintext_markdown(w.content)) for w in blog] return templates.TemplateResponse("blog/index.j2", { "request": request, "blog": rendered })
async def get(self, request: HTTPConnection): form = WriteupForm() images = await encoded_existing_images(request) tags = orjson.dumps(await get_all_tags(True)) return templates.TemplateResponse( "writeups/new.j2", { "request": request, "form": form, "existing_images": images, "existing_tags": tags, }, )
async def writeups_index(request: HTTPConnection): latest = ( await Writeup.load(author=User) .order_by(sa.desc(Writeup.creation_date)) .gino.all() ) rendered = [ (w, length_constrained_plaintext_markdown(w.content)) for w in latest if not should_skip_writeup(w, request.user.is_authed) ] return templates.TemplateResponse( "writeups/index.j2", {"request": request, "writeups": rendered} )
async def writeups_by_tag(request: HTTPConnection): tag = request.path_params["tag"] writeups = (await Writeup.load(author=User).where( Writeup.tags.contains([tag])).order_by(sa.desc(Writeup.creation_date) ).gino.all()) rendered = [(w, shorten(plaintext_markdown(w.content), width=300, placeholder="...")) for w in writeups] return templates.TemplateResponse("writeups/index.j2", { "request": request, "writeups": rendered })
async def writeups_view(request: HTTPConnection): slug = request.path_params["slug"] writeup = await Writeup.load(author=User).where(Writeup.slug == slug).gino.first() if writeup is None: return abort(404, "Writeup not found") if should_skip_writeup(writeup, request.user.is_authed): return redirect_response(url=request.url_for("need_auth")) rendered = highlight_markdown(writeup.content) return templates.TemplateResponse( "writeups/view.j2", {"writeup": writeup, "request": request, "rendered": rendered}, )
async def blog_search(request: HTTPConnection): s_query = request.query_params.get("search", "") # sorry about this query = pg_search(sa.select([Blog.join(User)]), s_query, sort=True) query = query.column( sa.func.ts_headline( search_manager.options["regconfig"], Blog.content, sa.func.tsq_parse(search_manager.options["regconfig"], s_query), f"StartSel=**,StopSel=**,MaxWords=70,MinWords=30,MaxFragments=3", ).label("headline")) blog = await query.as_scalar().gino.all() def build_blog(r): """we get back a RowProxy so manually construct the blog from it.""" author = User(discord_id=r.discord_id, username=r.username, email=r.email) blog = Blog( id=r.id, author_id=r.author_id, title=r.title, slug=r.slug, tags=r.tags, content=r.content, creation_date=r.creation_date, edit_date=r.edit_date, ) return blog blog = [(build_blog(r), r.headline) for r in blog] rendered = [(w, length_constrained_plaintext_markdown(headline)) for (w, headline) in blog] return templates.TemplateResponse("blog/index.j2", { "request": request, "blog": rendered, "query": s_query })
async def challenge_by_tag(request: HTTPConnection): tag = request.path_params["tag"] solves = sa.func.count(CompletedChallenge.challenge_id).label("solves") select = [Challenge, solves] columns = (Challenge, ColumnLoader(solves)) if request.user.is_authenticated: solved_challenges = (db.select([ CompletedChallenge.challenge_id ]).where(CompletedChallenge.season == CURRENT_SEASON).where( CompletedChallenge.discord_id == request.user.discord_id).cte( "solved_challenges")) solved = (sa.exists().where( solved_challenges.c.challenge_id == Challenge.id).label("solved")) select.append(solved) columns = (*columns, ColumnLoader(solved)) challenges = await (db.select(select).select_from( Challenge.outerjoin( CompletedChallenge, (Challenge.id == CompletedChallenge.challenge_id) & (CompletedChallenge.season == CURRENT_SEASON), )).group_by(Challenge.id).where(Challenge.tags.contains( [tag])).order_by(Challenge.creation_date.desc(), Challenge.id.desc()).gino.load(columns).all()) rendered = [( w, length_constrained_plaintext_markdown(w.content), solves, did_solve and did_solve[0], ) for (w, solves, *did_solve) in challenges if not should_skip_challenge(w, request.user.is_admin)] return templates.TemplateResponse( "challenge/index.j2", { "request": request, "challenges": rendered, }, )
async def writeups_view(request: HTTPConnection): slug = request.path_params["slug"] writeup = await Writeup.load(author=User).where(Writeup.slug == slug ).gino.first() if writeup is None: return abort(404, "Writeup not found") rendered = highlight_markdown(writeup.content) return templates.TemplateResponse( "writeups/view.j2", { "writeup": writeup, "request": request, "rendered": rendered }, )
async def blog_search(request: HTTPConnection): s_query = request.query_params.get("search", "") # sorry about this query = pg_search(sa.select([Blog]), s_query, sort=True) query = query.column( sa.func.ts_headline( search_manager.options["regconfig"], Blog.content, sa.func.tsq_parse(search_manager.options["regconfig"], s_query), f"StartSel=**,StopSel=**,MaxWords=70,MinWords=30,MaxFragments=3", ).label("headline") ) blog = await query.as_scalar().gino.all() def build_blog(r): """we get back a RowProxy so manually construct the blog from it.""" blog = Blog( id=r.id, title=r.title, slug=r.slug, tags=r.tags, content=r.content, creation_date=r.creation_date, edit_date=r.edit_date, ) return blog blog = [(build_blog(r), r.headline) for r in blog] rendered = [ (w, shorten(plaintext_markdown(headline), width=800, placeholder="...")) for (w, headline) in blog ] grouped_blogs = await blogs_grouped() return templates.TemplateResponse( "blog/index.j2", {"request": request, "blog": rendered, "query": s_query, "grouped_blogs": grouped_blogs} )
async def writeups_by_tag(request: HTTPConnection): tag = request.path_params["tag"] writeups = ( await Writeup.load(author=User) .where(Writeup.tags.contains([tag])) .order_by(sa.desc(Writeup.creation_date)) .gino.all() ) rendered = [ (w, length_constrained_plaintext_markdown(w.content)) for w in writeups if not should_skip_writeup(w, request.user.is_authed) ] return templates.TemplateResponse( "writeups/index.j2", {"request": request, "writeups": rendered} )
async def blog_by_tag(request: HTTPConnection): tag = request.path_params["tag"] blog = ( await Blog.query.where(Blog.tags.contains([tag])) .order_by(sa.desc(Blog.creation_date)) .gino.all() ) rendered = [ (w, shorten(plaintext_markdown(w.content), width=800, placeholder="...")) for w in blog ] grouped_blogs = await blogs_grouped() return templates.TemplateResponse( "blog/index.j2", {"request": request, "blog": rendered, "grouped_blogs": grouped_blogs} )
async def challenge_view(request: HTTPConnection): slug = request.path_params["slug"] solves = sa.func.count(CompletedChallenge.challenge_id).label("solves") challenge = await (db.select([Challenge, solves]).select_from( Challenge.outerjoin( CompletedChallenge, (Challenge.id == CompletedChallenge.challenge_id) & (CompletedChallenge.season == CURRENT_SEASON), )).group_by(Challenge.id).where(Challenge.slug == slug).gino.load( (Challenge, ColumnLoader(solves))).first()) if challenge is None: return abort(404, "Challenge not found") challenge, solves = challenge if should_skip_challenge(challenge, request.user.is_admin): return abort(404, "Challenge not found") if request.user.is_authenticated: solved_challenge = await CompletedChallenge.query.where( (CompletedChallenge.discord_id == request.user.discord_id) & (CompletedChallenge.challenge_id == challenge.id) & (CompletedChallenge.season == CURRENT_SEASON)).gino.first() else: solved_challenge = False rendered = highlight_markdown_unsafe(challenge.content) return templates.TemplateResponse( "challenge/view.j2", { "challenge": challenge, "request": request, "rendered": rendered, "solves": solves, "submit_form": AnswerForm(), "solved_challenge": solved_challenge, }, )
async def post(self, request: HTTPConnection): id = request.path_params["id"] writeup = await Writeup.get(id) if writeup is None: return abort(404, "Writeup not found") if not can_edit(request, writeup.author_id): return abort(400) form = await request.form() form = PostForm(form) if form.validate(): await writeup.update_auto( author_id=request.user.discord_id, title=form.title.data, tags=form.tags.data, content=form.content.data, ).apply() url = request.url_for("writeups_view", slug=writeup.slug) await log_edit("writeup", writeup.title, request.user.username, url) return RedirectResponse(url=url) images = await encoded_existing_images(request) tags = ujson.dumps(await get_all_tags()) return templates.TemplateResponse( "writeups/edit.j2", { "request": request, "form": form, "writeup": writeup, "existing_images": images, "existing_tags": tags, }, )
async def post(self, request: HTTPConnection): form = await request.form() form = PostForm(form) is_valid = form.validate() if (await Writeup.query.where(Writeup.title == form.title.data ).gino.first() is not None): is_valid = False form.errors.setdefault("title", []).append( f"A writeup with the title '{form.title.data}' already exists." ) if is_valid: writeup = await Writeup.create_auto( author_id=request.user.discord_id, title=form.title.data, tags=form.tags.data, content=form.content.data, ) url = request.url_for("writeups_view", slug=writeup.slug) await log_create("writeup", writeup.title, request.user.username, url) return RedirectResponse(url=url) images = await encoded_existing_images(request) tags = ujson.dumps(await get_all_tags()) return templates.TemplateResponse( "writeups/new.j2", { "request": request, "form": form, "existing_images": images, "existing_tags": tags, }, )