async def ad(request):
"""
Single ad
"""
a = Ad
i = Image
r = Review
d = Rent
request_path_id = request.path_params["id"]
path = request.url.path
results = await get_ads().where(a.id == request_path_id).first().run()
# update ad views per session
session_key = f"viewed_ad_{results['id']}"
if not request.session.get(session_key, False):
await a.update({a.view: a.view + 1}).where(
a.id == int(request_path_id)
).run()
request.session[session_key] = True
image_results = (
await i.select().where(i.ad_image == int(request_path_id)).run()
)
review_results = (
await r.select(
r.id,
r.content,
r.created,
r.review_grade,
r.review_user.username,
r.ad.id,
)
.where(r.ad.id == request_path_id)
.order_by(r.id, ascending=False)
.run()
)
# if no reviews
try:
review_avg = sum(
item["review_grade"] for item in review_results
) / len(review_results)
except ZeroDivisionError:
review_avg = None
# proccesing form for booking ad
data = await request.form()
form = RentForm(data)
if request.method == "POST" and form.validate():
u = User
session_user = (
await u.select(u.id, u.username)
.where(u.username == request.user.username)
.first()
.run()
)
start = form.start_date.data
end = form.end_date.data
try:
between = (
await d.select()
.where(
(d.start_date <= end)
& (d.end_date >= start)
& (d.ad_rent == int(request_path_id))
)
.run()
)
now = datetime.datetime.now().date()
diff = (now - start).total_seconds()
if diff > 0:
rent_error = "Both dates can't be in the past."
days = (end - start).days
if days < 1:
rent_error = "The minimum rental period is one day."
if any(between):
rent_error = "Already rented in that time."
rented_apartments = await a.raw(
f"SELECT * FROM ad JOIN rent "
f"ON ad.id = rent.ad_rent WHERE ad.id = {request_path_id}"
).run()
return templates.TemplateResponse(
"ads/ad_detail.html",
{
"request": request,
"item": results,
"path": path,
"images": image_results,
"review_results": review_results,
"review_count": len(review_results),
"review_avg": review_avg,
"form": form,
"rented_apartments": rented_apartments,
"rent_error": rent_error,
},
)
except: # noqa
query = Rent(
start_date=form.start_date.data,
end_date=form.end_date.data,
client=session_user["id"],
ad_rent=results["id"],
)
await query.save().run()
# notification to ad owner
notification_query = Notification(
message=f"{results['title']} booked by {session_user['username']}",
created=datetime.datetime.now(),
is_read=0,
sender=session_user["id"],
recipient=results["ad_user.id"],
)
await notification_query.save().run()
return RedirectResponse(BASE_HOST + path, status_code=302)
rented_apartments = await a.raw(
f"SELECT * FROM ad JOIN rent "
f"ON ad.id = rent.ad_rent WHERE ad.id = {request_path_id}"
).run()
return templates.TemplateResponse(
"ads/ad_detail.html",
{
"request": request,
"item": results,
"path": path,
"images": image_results,
"review_results": review_results,
"review_count": len(review_results),
"review_avg": review_avg,
"rented_apartments": rented_apartments,
"form": form,
},
)
async def index(request):
results = "Home page"
return templates.TemplateResponse("index.html", {
"request": request,
"results": results
})
async def search(request):
"""
Search questions
"""
try:
page_query = pagination.get_page_number(url=request.url)
q = request.query_params['q']
count = (
await Question.all()
.prefetch_related("user")
.filter(Q(title__icontains=q) |
Q(content__icontains=q) |
Q(user__username__icontains=q))
.distinct()
.count()
)
paginator = pagination.Pagination(page_query, count)
results = (
await Question.all()
.prefetch_related("user", "tags")
.filter(Q(title__icontains=q) |
Q(content__icontains=q) |
Q(user__username__icontains=q) |
Q(tags__name__icontains=q))
.distinct()
.limit(paginator.page_size)
.offset(paginator.offset())
)
page_controls = pagination.get_page_controls(
url=request.url,
current_page=paginator.current_page(),
total_pages=paginator.total_pages()
)
except KeyError:
page_query = pagination.get_page_number(url=request.url)
count = await Question.all().count()
paginator = pagination.Pagination(page_query, count)
results = (
await Question.all()
.prefetch_related("user", "tags")
.limit(paginator.page_size)
.offset(paginator.offset())
)
page_controls = pagination.get_page_controls(
url=request.url,
current_page=paginator.current_page(),
total_pages=paginator.total_pages()
)
answer_count = []
for row in results:
r = (
await Answer.all()
.prefetch_related("question")
.filter(question__id=row.id).count()
)
answer_count.append(r)
return templates.TemplateResponse(
"questions/search.html", {
"request": request,
"results": zip(results, answer_count),
"page_controls": page_controls,
"count": count,
"q": q
}
)
async def ad_images(request):
return templates.TemplateResponse(
"ads/images.html", {"request": request, "BASE": BASE_HOST}
)
async def get(self, request):
return templates.TemplateResponse("index.html", {"request": request})
async def index(request):
template = "login.html"
context = {"request": request}
return templates.TemplateResponse(template, context)
async def upload_page(request: Request):
return templates.TemplateResponse("web/upload_file.html", {"request": request})
async def questions_categories(request):
"""
Questions categories
"""
p = Question
category = request.path_params["category"]
page_query = pagination.get_page_number(url=request.url)
count = await p.count().where(p.category.name == category).run()
paginator = pagination.Pagination(page_query, count)
try:
tab = request.query_params["tab"]
if tab == "oldest":
results = (
await get_questions()
.where(p.category.name == category)
.limit(paginator.page_size)
.offset(paginator.offset())
.order_by(p.id, ascending=True)
.run()
)
if tab == "unsolved":
count = len(
await get_questions().where(p.accepted_answer == False).run()
)
paginator = pagination.Pagination(page_query, count)
results = (
await get_questions()
.where(
(p.accepted_answer == False)
& (p.category.name == category)
)
.limit(paginator.page_size)
.offset(paginator.offset())
.order_by(p.id, ascending=False)
.run()
)
if tab == "solved":
count = len(
await get_questions().where(p.accepted_answer == True).run()
)
paginator = pagination.Pagination(page_query, count)
results = (
await get_questions()
.where(
(p.accepted_answer == True) & (p.category.name == category)
)
.limit(paginator.page_size)
.offset(paginator.offset())
.order_by(p.id, ascending=False)
.run()
)
except KeyError:
results = (
await get_questions()
.where(p.category.name == category)
.limit(paginator.page_size)
.offset(paginator.offset())
.order_by(p.id, ascending=False)
.run()
)
answer_count = [
await p.raw(
f"select count(answer.id) from answer "
f"join question on answer.question = question.id "
f"where question.id = {item['id']};"
).run()
for item in results
]
c = Category
categories = await c.select().order_by(c.name, ascending=True).run()
category_count = [
await p.count().where(p.category.name == item["name"]).run()
for item in categories
]
page_controls = pagination.get_page_controls(
url=request.url,
current_page=paginator.current_page(),
total_pages=paginator.total_pages(),
)
return templates.TemplateResponse(
"questions/questions_categories.html",
{
"request": request,
"results": zip(results, answer_count),
"categories": zip(categories, category_count),
"page_controls": page_controls,
"r": results,
},
)
async def index(request):
return templates.TemplateResponse("index.html", {"request": request})