def presentation(request):
"""
LifeX - A Presentation
Args:
request(HttpRequest)
Returns:
HttpResponse: 200 on success
Raises:
None
"""
title = 'Life Experiments - A Presentation'
description = '''
A presentation on Life Experiments.
What lifeX is, why it is so awesome,
and why I feel we all should apply it.'''
keywords = ['lifeX', 'experiments', 'life', 'idea', 'presentation', ]
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url,
)
return render_to_response(
'lifeX/presentation_UCC2014.html',
{
'meta': meta,
'page_url': url,
},
)
def index(request):
"""Index view showing all poems
Args:
request(HttpRequest)
Returns:
HttpResponse: 200 on success, 404 otherwise
Raises:
Http404: poem not found
"""
try:
poemposts = Poem.objects.order_by('-published').values()
title = 'poems at harshp.com'
description = 'poems composed and dreamed up by me'
keywords = ['poem', 'harshp.com', 'coolharsh55', ]
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url
)
except Poem.DoesNotExist:
raise Http404('Poem Post does not exist...')
return render_to_response(
'poems/index.html',
{
'posts': poemposts,
'page_url': url,
'meta': meta,
}
)
def post(request, week, idea):
"""
lifeX experiment post
Show associated week and idea
Show other ideas and posts in this week
Args:
request(HttpRequest)
week(slug): week number in url
idea(slug): idea title in url
Returns:
HttpResponse: 200 on success, 404 on failure
Raises:
Http404: lifeX week, post, or idea does not exist
"""
# TODO: show other ideas and posts in this week
try:
week = LifeXWeek.objects.get(number=week)
idea = LifeXIdea.objects.get(slug=idea)
post = LifeXPost.objects.get(week=week, idea=idea)
# contruct meta tags
title = post.title
description = 'A lifeX post at harshp.com'
keywords = ['lifeX', 'experiments', 'life', 'post', ]
for tag in post.tags.all():
keywords.append(tag.tagname)
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url,
)
except (
LifeXPost.DoesNotExist,
LifeXWeek.DoesNotExist,
LifeXIdea.DoesNotExist,
):
raise Http404('Life Experiment Post does not exist...')
return render_to_response(
'lifeX/post.html',
{
'post': post,
'page_url': url,
'meta': meta,
}
)
def home(request):
"""homepage for harshp.com
show all the latest posts in different apps
Args:
request(HttpResponse)
Returns:
HttpResponse: 200 on success, 404 on error
Raises:
Http404: error retrieving posts
"""
try:
blogs = BlogPost.objects.order_by('-published')[:3]
stories = StoryPost.objects.order_by('-published')[:3]
poems = Poem.objects.order_by('-published')[:3]
articles = Article.objects.order_by('-published')[:3]
brainbank_idea = BrainBankIdea.objects.latest('published')
lifexweek = LifeXWeek.objects.latest('number')
description = """
The personal website of Harshvardhan Pandit (coolharsh55)"""
keywords = ['harshp.com', 'blog', 'stories', 'poems', ]
meta = create_meta(
'harshp.com',
description,
keywords,
url=request.build_absolute_uri(),
)
except (BlogPost.DoesNotExist,
StoryPost.DoesNotExist,
Poem.DoesNotExist,
Article.DoesNotExist,
LifeXWeek.DoesNotExist,
BrainBankIdea.DoesNotExist):
raise Http404('Error retrieving website data...')
return render_to_response(
'harshp/index.html',
{
'blogs': blogs,
'stories': stories,
'poems': poems,
'articles': articles,
'brainbank_idea': brainbank_idea,
'lifeXweek': lifexweek,
'meta': meta,
}
)
def blogpost(request, blogpost):
"""
lifeX blog post
Show blog post
Args:
request(HttpRequest)
blogpost(slug) blog post title in url
Returns:
HttpResponse: 200 on success, 404 on failure
Raises:
Http404: lifeX blog does not exist
"""
try:
blogpost = LifeXBlog.objects.get(slug=blogpost)
# contruct meta tags
title = blogpost.title
description = 'A blog post at harshp.com'
keywords = ['blog', 'lifeX', 'experiments', 'life', ]
for tag in blogpost.tags.all():
keywords.append(tag.tagname)
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url,
blogpost.headerimage
)
except LifeXBlog.DoesNotExist:
raise Http404('Blog Post does not exist...')
return render_to_response(
'lifeX/blogpost.html',
{
'blogpost': blogpost,
'page_url': url,
'meta': meta,
}
)
def idea(request, category, idea):
"""
lifeX idea
Show Idea and associated information
Status (experimented/retry)
Link to each week and post that uses that idea
Args:
request(HttpRequest)
category(slug): category name in url
idea(slug): idea title in url
Returns:
HttpResponse: 200 on success, 404 on failure
Raises:
Http404: lifeX idea does not exist
"""
try:
idea = LifeXIdea.objects.get(slug=idea)
# contruct meta tags
title = idea.title
description = 'A lifeX idea at harshp.com'
keywords = ['lifeX', 'experiments', 'life', 'idea', ]
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url,
)
except LifeXIdea.DoesNotExist:
raise Http404('Life Experiment Idea does not exist...')
return render_to_response(
'lifeX/idea.html',
{
'idea': idea,
'page_url': url,
'meta': meta,
}
)
def brainbank_demo(request, idea, demo):
"""Brainbank Demo for Idea
Shows the demo with custom css and js
Shows link to related idea
Args:
request(HttpRequest)
idea(str): idea slug
demo(str): demo slug
Returns:
HttpResponse: 200 on success, 404 otherwise
Raises:
Http404: brainbank demo does not exist
"""
try:
demo = BrainBankDemo.objects.get(slug=demo)
# contruct meta tags
title = demo.title
description = 'A brainbank idea demo at harshp.com'
keywords = ['brainbank', 'idea', 'demo', ]
# for tag in demo.tags.all():
# keywords.append(tag.tagname)
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url,
)
except BrainBankDemo.DoesNotExist:
raise Http404('Brainbank Idea Demo does not exist...')
return render_to_response(
'brainbank/demo.html',
{
'demo': demo,
'page_url': url,
'meta': meta,
}
)
def week(request, week):
"""
lifeX week
All posts and ideas associated with a week
Show if the idea is marked for retry
Args:
request(HttpRequest)
week(slug): week number in url
Returns:
HttpResponse: 200 on success, 404 on failure
Raises:
Http404: lifeX week does not exist
"""
# TODO: show if the idea is marked for retry
try:
week = LifeXWeek.objects.get(number=week)
# contruct meta tags
title = str(week)
description = 'A lifeX week at harshp.com'
keywords = ['lifeX', 'experiments', 'life', 'idea', ]
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url,
)
except LifeXWeek.DoesNotExist:
raise Http404('Life Experiment Week does not exist...')
return render_to_response(
'lifeX/week.html',
{
'week': week,
'page_url': url,
'meta': meta,
}
)
def blog(request):
"""
lifeX blog
Show all blog posts as links
OR Show all blog posts as paged posts
Args:
request(HttpRequest)
Returns:
HttpResponse: 200 on success, 404 on failure
Raises:
Http404: lifeX blog does not exist
"""
# TODO: pagination for blog posts
try:
blogposts = LifeXBlog.objects.order_by('-date')
# contruct meta tags
title = 'LifeX Blog'
description = 'LifeX blog at harshp.com'
keywords = ['blog', 'lifeX', 'experiments', 'life', ]
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url,
None
)
except LifeXBlog.DoesNotExist:
raise Http404('Error retrieving LifeX Blog...')
return render_to_response(
'lifeX/blog.html',
{
'blogposts': blogposts,
'page_url': url,
'meta': meta,
}
)
def category(request, category):
"""
lifeX category
All Ideas within the Category
Status of each Idea (experimented/retry)
Args:
request(HttpRequest)
category(slug): category name in url
Returns:
HttpResponse: 200 on success, 404 on failure
Raises:
Http404: category does not exist
"""
try:
category = LifeXCategory.objects.get(slug=category)
# contruct meta tags
title = category.name
description = 'A collection of lifeX ideas at harshp.com'
keywords = ['lifeX', 'experiments', 'life', 'idea', ]
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url,
)
except LifeXCategory.DoesNotExist:
raise Http404('Life Experiment Idea Category does not exist...')
return render_to_response(
'lifeX/category.html',
{
'category': category,
'page_url': url,
'meta': meta,
}
)
def article(request, article):
"""view for article post
Args:
request(HttpRequest): request for article
article(str): article requested through url
Returns:
HttpResponse: 200 on success, 404 otherwise
Raises:
Http404: article not found
"""
try:
article = Article.objects.get(slug=article)
# contruct meta tags
title = article.title
description = 'An article at harshp.com'
keywords = ['article', ]
for tag in article.tags.all():
keywords.append(tag.tagname)
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url,
article.headerimage
)
except Article.DoesNotExist:
raise Http404('Article does not exist...')
return render_to_response(
'articles/article.html',
{
'post': article,
'page_url': url,
'meta': meta,
}
)
def poem(request, poem):
"""view poem post
Args:
request(HttpRequest)
Returns:
HttpResponse: 200 on success, 404 otherwise
Raises:
Http404: poem not found
"""
try:
poempost = Poem.objects.get(slug=poem)
# contruct meta tags
title = poempost.title
description = 'A beautiful poem at harshp.com'
keywords = ['poem', ]
for tag in poempost.tags.all():
keywords.append(tag.tagname)
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url,
poempost.headerimage
)
except Poem.DoesNotExist:
raise Http404('Poem Post does not exist...')
return render_to_response(
'poems/poem.html',
{
'post': poempost,
'page_url': url,
'meta': meta,
}
)
def brainbank_idea(request, idea):
"""Brainbank Idea page
Shows information about the idea
Shows all posts and demos associated with the idea
Args:
request(HttpRequest)
idea(str): slug in url
Returns:
HttpResponse: 200 on success, 404 otherwise
Raises:
Http404: brainbank idea does not exist
"""
try:
idea = BrainBankIdea.objects.get(slug=idea)
# contruct meta tags
title = idea.title
description = 'A brainbank idea at harshp.com'
keywords = ['idea', 'brainbank', ]
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url,
)
except BrainBankIdea.DoesNotExist:
raise Http404('Brainbank Idea does not exist...')
return render_to_response(
'brainbank/idea.html',
{
'idea': idea,
'page_url': url,
'meta': meta,
}
)
def experiments(request):
"""
lifeX experiments
All weeks and associated posts
All ideas associated with each week
Args:
request(HttpRequest)
Returns:
HttpResponse: 200 on success, 404 on failure
Raises:
Http404: lifeX week does not exist
"""
try:
weeks = LifeXWeek.objects.order_by('-number')
# contruct meta tags
title = 'Life Experiment Weeks'
description = 'All the weeks of lifeX at harshp.com'
keywords = ['lifeX', 'experiments', 'life', 'idea', ]
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url,
)
except LifeXWeek.DoesNotExist:
raise Http404('Error retrieving LifeX Experiments...')
return render_to_response(
'lifeX/experiments.html',
{
'weeks': weeks,
'page_url': url,
'meta': meta,
}
)
def index(request):
"""lifeX homepage
Some information about lifeX
Links to ideas, weeks
Latest week and its experiments
Args:
request(HttpRequest)
Returns:
HttpResponse: 200 on success, 404 on failure
Raises:
Http404: lifeX week does not exist
"""
try:
latest_week = LifeXWeek.objects.latest('number')
# contruct meta tags
title = 'Life Experiments'
description = 'life and experiments at harshp.com'
keywords = ['lifeX', 'experiments', 'life', ]
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url,
)
except LifeXWeek.DoesNotExist:
raise Http404('Error loading LifeX module...')
return render_to_response(
'lifeX/index.html',
{
'latest_week': latest_week,
'page_url': url, 'meta': meta,
}
)
def index(request):
"""index view for article homepage
show all articles sorted by last published
Args:
request: HttpRequest
Returns:
HttpResponse: 200 on success, 404 on Not found
Raises:
Http404: article not found
"""
try:
articles = Article.objects.order_by('-published').values()
title = 'articles at harshp.com'
description = 'articles written by me'
keywords = ['article', 'harshp.com', 'coolharsh55', ]
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url
)
except Article.DoesNotExist:
raise Http404('Article does not exist...')
return render_to_response(
'articles/index.html',
{
'posts': articles,
'page_url': url,
'meta': meta,
}
)
def blogpost(request, blogpost):
"""view for blog post
Args:
request(HttpRequest)
blogpost(str): slug of blog post in url
Returns:
HttpResponse: 200 on success, 404 on error
Raises:
Http404: blog post not found
"""
try:
blogpost = BlogPost.objects.get(slug=blogpost)
# contruct meta tags
title = blogpost.title
description = 'A blog post at harshp.com'
keywords = ['blog', ]
for tag in blogpost.tags.all():
keywords.append(tag.tagname)
url = request.build_absolute_uri()
meta = create_meta(
title, description, keywords, url, blogpost.headerimage)
except BlogPost.DoesNotExist:
raise Http404('Blog Post does not exist...')
return render_to_response(
'blog/blogpost.html',
{
'post': blogpost,
'page_url': url,
'meta': meta,
}
)
def brainbank_post(request, idea, post):
"""
Brainbank Post for Idea
Shows a post with custom css and js
Shows link to related idea
Args:
request(HttpRequest)
idea(str): idea slug
post(str): post slug
Returns:
HttpResponse: 200 on success, 404 otherwise
Raises:
Http404: brainbank post does not exist
"""
try:
post = BrainBankPost.objects.get(slug=post)
# contruct meta tags
title = post.title
description = 'A brainbank idea post at harshp.com'
keywords = ['brainbank', 'idea', 'post', ]
for tag in post.tags.all():
keywords.append(tag.tagname)
url = request.build_absolute_uri()
meta = create_meta(title, description, keywords, url,)
except BrainBankPost.DoesNotExist:
raise Http404('Brainbank Idea Post does not exist...')
return render_to_response(
'brainbank/post.html',
{
'post': post,
'page_url': url,
'meta': meta,
}
)
def index(request):
"""Brainbank Index page
Shows all available ideas ordered by date
Shows all posts and demos associated with the idea
Args:
request(HttpRequest)
Returns:
HttpResponse: 200 on success, 404 otherwise
Raises:
Http404: brainbank idea does not exist
"""
try:
ideas = BrainBankIdea.objects.order_by('-published').all()
title = 'brainbank at harshp.com'
description = 'a brainbank of my ideas'
keywords = ['idea', 'brainbank', 'harshp.com', 'coolharsh55', ]
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url
)
except BrainBankIdea.DoesNotExist:
raise Http404('Error loading Brainbank...')
return render_to_response(
'brainbank/index.html',
{
'ideas': ideas,
'page_url': url,
'meta': meta,
}
)
def ideas(request):
"""
lifeX ideas
All Ideas organized by Categories
Args:
request(HttpRequest)
Returns:
HttpResponse: 200 on success, 404 on failure
Raises:
Http404: idea does not exist
"""
try:
categories = LifeXCategory.objects.order_by('name')
# contruct meta tags
title = 'Life Experiment Ideas'
description = 'lifeX experiment ideas at harshp.com'
keywords = ['lifeX', 'experiments', 'idea', 'life', ]
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url,
)
except LifeXCategory.DoesNotExist:
raise Http404('Error retrieving LifeX Ideas...')
return render_to_response(
'lifeX/ideas.html',
{
'categories': categories,
'page_url': url, 'meta': meta,
}
)
def index(request):
"""index view for blogs
shows all blog posts sorted by last published
Args:
request(HttpRequest)
Returns:
HttpResponse: 200 on success, 404 otherwise
Raises:
Http404: blog post not found
"""
try:
blogposts = BlogPost.objects.order_by('-published').values()
title = 'blog at harshp.com'
description = 'a blog with my thoughts and reflections'
keywords = ['blog', 'harshp.com', 'coolharsh55', ]
url = request.build_absolute_uri()
meta = create_meta(
title,
description,
keywords,
url
)
except BlogPost.DoesNotExist:
raise Http404('Blog Post does not exist...')
return render_to_response(
'blog/index.html', {
'posts': blogposts,
'meta': meta,
},
)
