def get(self):
self.error(404)
output = get_cache("error404")
if output is None:
output = self.render("404.html")
memcache.add("error404", output, 3600)
self.response.out.write(output)
def get(self):
output = get_cache("projects_json")
if output is None:
projects = Project.all().order('-created_date').fetch(50)
projects_data = {}
for project in projects:
data = {
'internal_url':
"%s/projects/%s/" % (settings.SYSTEM_URL, project.slug),
'created_date':
str(project.created_date)[0:19],
'open_issues':
project.open_issues.count(),
'closed_issues':
project.closed_issues.count(),
}
if project.url:
data['external_url'] = project.url
projects_data[project.name] = data
json = {
'date': str(datetime.now())[0:19],
'projects': projects_data,
}
output = simplejson.dumps(json)
memcache.add("projects_json", output, 3600)
self.response.headers[
"Content-Type"] = "application/javascript; charset=utf8"
self.response.out.write(output)
def get(self):
output = get_cache("projects_rss")
if output is None:
projects = Project.all().order('-created_date').fetch(20)
rss = RSS2(
title="GitBug projects",
link="%s" % settings.SYSTEM_URL,
description="A list of the latest 20 projects on GitBug",
lastBuildDate=datetime.now())
for project in projects:
rss.items.append(
RSSItem(title=project.name,
link="%s/projects/%s/" %
(settings.SYSTEM_URL, project.slug),
description="",
pubDate=project.created_date))
output = rss.to_xml()
memcache.add("projects_rss", output, 3600)
self.response.headers[
"Content-Type"] = "application/rss+xml; charset=utf8"
self.response.out.write(output)
def get(self, slug):
output = get_cache("project_%s_json" % slug)
if output is None:
project = Project.all().filter('slug =', slug).fetch(1)[0]
issues = Issue.all().filter(
'project =', project).order('fixed').order('created_date')
issues_data = {}
for issue in issues:
# friendlier display of information
if issue.fixed:
status = "Fixed"
else:
status = "Open"
# set structure of inner json
data = {
'internal_url':
"%s/projects%s" %
(settings.SYSTEM_URL, issue.internal_url),
'created_date':
str(project.created_date)[0:19],
'description':
issue.html,
'status':
status,
'identifier':
"#gitbug%s" % issue.identifier,
}
if issue.fixed and issue.fixed_description:
data['fixed_description'] = issue.fixed_description
issues_data[issue.name] = data
# set structure of outer json
json = {
'date':
str(datetime.now())[0:19],
'name':
project.name,
'internal_url':
"%s/projects/%s/" % (settings.SYSTEM_URL, project.slug),
'created_date':
str(project.created_date)[0:19],
'issues':
issues_data,
}
if project.url:
json['external_url'] = project.url
# create the json
output = simplejson.dumps(json)
# cache it
memcache.add("project_%s_json" % slug, output, 3600)
# send the correct headers
self.response.headers[
"Content-Type"] = "application/javascript; charset=utf8"
self.response.out.write(output)
def get(self, slug):
output = get_cache("project_%s_rss" % slug)
if output is None:
project = Project.all().filter('slug =', slug).fetch(1)[0]
# allow query string arguments to specify filters
if self.request.get("open"):
status_filter = True
fixed = False
elif self.request.get("closed"):
status_filter = True
fixed = True
else:
status_filter = None
# if we have a filter then filter the results set
if status_filter:
issues = Issue.all().filter('project =', project).filter(
'fixed =', fixed).order('fixed').order('created_date')
else:
issues = Issue.all().filter(
'project =', project).order('fixed').order('created_date')
# create the RSS feed
rss = RSS2(title="Issues for %s on GitBug" % project.name,
link="%s/%s/" % (settings.SYSTEM_URL, project.slug),
description="",
lastBuildDate=datetime.now())
# add an item for each issue
for issue in issues:
if issue.fixed:
pubDate = issue.fixed_date
title = "%s (%s)" % (issue.name, "Fixed")
else:
pubDate = issue.created_date
title = issue.name
rss.items.append(
RSSItem(title=title,
link="%s/projects%s" %
(settings.SYSTEM_URL, issue.internal_url),
description=issue.html,
pubDate=pubDate))
# get the xml
output = rss.to_xml()
memcache.add("project_%s_rss" % slug, output, 3600)
# send the correct headers
self.response.headers[
"Content-Type"] = "application/rss+xml; charset=utf8"
self.response.out.write(output)
def get(self):
self.error(404)
user = users.get_current_user()
output = None
if not user:
output = get_cache("error404")
if output is None:
output = self.render("404.html")
if not user:
memcache.add("error404", output, 3600)
self.response.out.write(output)
def get(self):
output = get_cache("home")
if output is None:
items = Page.all().order('-publish_date').fetch(50)
context = {
"items": items,
"title": "Hacker Posts",
}
# calculate the template path
output = self.render("index.html", context)
memcache.add("home", output, 3600)
self.response.out.write(output)
def get(self):
if self.request.path[-1] != "/":
self.redirect("%s/" % self.request.path, True)
return
user = users.get_current_user()
output = None
if not user:
output = get_cache("faq")
if output is None:
output = self.render("faq.html")
if not user:
memcache.add("faq", output, 3600)
self.response.out.write(output)
def get(self):
if users.get_current_user():
# if we have a user then get their projects
projects = Project.all().filter(
'user ='******'-created_date').fetch(50)
context = {
'projects': projects,
}
output = self.render("index.html", context)
else:
# otherwise it's a static page so cache for a while
output = get_cache("home")
if output is None:
output = self.render("home.html")
memcache.add("home", output, 3600)
self.response.out.write(output)
def get(self, project_slug, issue_slug):
if self.request.path[-1] != "/":
self.redirect("%s/" % self.request.path, True)
return
user = users.get_current_user()
output = None
if not user:
output = get_cache("/%s/%s/" % (project_slug, issue_slug))
if output is None:
try:
issue = Issue.all().filter(
'internal_url =',
"/%s/%s/" % (project_slug, issue_slug)).fetch(1)[0]
issues = Issue.all().filter('project =', issue.project).filter(
'fixed =', False).fetch(10)
except IndexError:
self.render_404()
return
on_list = False
try:
if user.email() in issue.project.other_users:
on_list = True
except:
pass
if issue.project.user == user or users.is_current_user_admin(
) or on_list:
owner = True
else:
owner = False
context = {
'issue': issue,
'issues': issues,
'owner': owner,
}
# calculate the template path
output = self.render("issue.html", context)
if not user:
memcache.add("/%s/%s/" % (project_slug, issue_slug), output, 60)
self.response.out.write(output)
def get(self, year, month=None, day=None):
# we want a canonical url with the trailing slash
# so if it's missing we need to throw a 301, adding the slash in
# the process
if self.request.path[-1] != "/":
self.redirect("%s/" % self.request.path, True)
return
output = get_cache("%s%s%s" % (year, month, day))
if output is None:
if not month:
# we're dealing with a year only
# check how many days in this year
if isleap(int(year)):
days = 366
else:
days = 365
lower_limit = date(int(year), 1, 1)
upper_limit = lower_limit + timedelta(days)
title = year
elif not day:
# we have a month and year
lower_limit = date(int(year), int(month), 1)
upper_limit = lower_limit + timedelta(monthrange(int(year), int(month))[1])
title = "%s %s" % (lower_limit.strftime("%B"), year)
else:
# we have everything
lower_limit = date(int(year), int(month), int(day))
upper_limit = lower_limit + timedelta(1)
title = "%s %s %s" % (lower_limit.strftime("%d"), lower_limit.strftime("%B"), year)
items = Page.all()
items.filter('publish_date >', lower_limit)
items.filter('publish_date <', upper_limit)
items.order('-publish_date')
context = {
"items": items,
"title": "News from %s" % title
}
output = self.render("list.html", context)
memcache.add("%s%s%s" % (year, month, day), output, 3600)
self.response.out.write(output)
def get(self):
# we want a canonical url with the trailing slash
# so if it's missing we need to throw a 301, adding the slash in
# the process
if self.request.path[-1] != "/":
self.redirect("%s/" % self.request.path, True)
return
output = get_cache("tags")
if output is None:
tags = Tag.all().order('-date').fetch(300)
context = {
"tags": tags,
"title": "Latest tags",
}
output = self.render("tags.html", context)
memcache.add("tags", output, 3600)
self.response.out.write(output)
def get(self, slug):
# we want a canonical url with the trailing slash
# so if it's missing we need to throw a 301, adding the slash in
# the process
if slug[-1] != "/":
self.redirect("%s/" % slug, True)
return
output = get_cache(slug)
if output is None:
try:
item = Page.gql("WHERE internal_url=:1", slug)[0]
except IndexError:
self.error(404)
output = self.render("404.html", {"title": "Page not found"})
self.response.out.write(output)
return
# get a list of related items based on taggings
# remember to filter out the article we're on
related = []
for tag in item.tags:
related += (Tag.all().filter('name =', tag).filter('title !=', item.title))
# we also need to deduplicate the list as sometimes items
# will share tags
seen = []
deduped = []
for related_item in related:
if not related_item.url in seen:
deduped.append(related_item)
seen.append(related_item.url)
context = {
"item": item,
"related": deduped,
"title": item.title,
}
output = self.render("item.html", context)
memcache.add(slug, output, 3600)
self.response.out.write(output)
def get(self):
if self.request.path[-1] != "/":
self.redirect("%s/" % self.request.path, True)
return
user = users.get_current_user()
output = None
if not user:
output = get_cache("projects")
if output is None:
projects = Project.all().order('-created_date').fetch(50)
context = {
'projects': projects,
}
# calculate the template path
output = self.render("projects.html", context)
if not user:
memcache.add("projects", output, 3600)
self.response.out.write(output)
def get(self, project_slug, issue_slug):
output = get_cache("/%s/%s.json" % (project_slug, issue_slug))
if output is None:
issue = Issue.all().filter('internal_url =', "/%s/%s/" %
(project_slug, issue_slug)).fetch(1)[0]
if issue.fixed:
status = "Fixed"
else:
status = "Open"
json = {
'date':
str(datetime.now())[0:19],
'name':
issue.name,
'project':
issue.project.name,
'project_url':
"%s/projects/%s" % (settings.SYSTEM_URL, issue.project.slug),
'internal_url':
"%s/projects/%s/" % (settings.SYSTEM_URL, issue.internal_url),
'created_date':
str(issue.created_date)[0:19],
'description':
issue.html,
'status':
status,
'identifier':
"#gitbug%s" % issue.identifier,
}
if issue.fixed and issue.fixed_description:
json['fixed_description'] = issue.fixed_description
output = simplejson.dumps(json)
memcache.add("/%s/%s.json" % (project_slug, issue_slug), output,
3600)
self.response.headers[
"Content-Type"] = "application/javascript; charset=utf8"
self.response.out.write(output)
def get(self, slug):
# we want canonocal urls so redirect to add a trailing slash if needed
if self.request.path[-1] != "/":
self.redirect("%s/" % self.request.path, True)
return
user = users.get_current_user()
output = None
# if not logged in then use a cached version
if not user:
output = get_cache("project_%s" % slug)
# if we don't have a cached version or are logged in
if output is None:
try:
project = Project.all().filter('slug =', slug).fetch(1)[0]
issues = Issue.all().filter('project =', project)
files = DatastoreFile.all().filter('project =', project)
except IndexError:
self.render_404()
return
logging.info("Files in this project: %d" % files.count())
# check to see if we have admin rights over this project
if project.user == user or users.is_current_user_admin():
owner = True
else:
owner = False
context = {
'project': project,
'issues': issues,
'owner': owner,
'files': files,
}
output = self.render("project.html", context)
if not user:
# only save a cached version if we're not logged in
# so as to avoid revelaving user details
memcache.add("project_%s" % slug, output, 3600)
self.response.out.write(output)
def get(self, tag):
# we want a canonical url with the trailing slash
# so if it's missing we need to throw a 301, adding the slash in
# the process
if self.request.path[-1] != "/":
self.redirect("%s/" % self.request.path, True)
return
output = get_cache("%s" % tag)
if output is None:
items = Page.all()
items.order('-publish_date')
items.filter('tags = ', tag.replace("-", " "))
context = {
"items": items,
"title": "Content tagged <strong>%s</strong>" % tag.replace("-", " "),
}
output = self.render("list.html", context)
memcache.add("%s" % tag, output, 3600)
self.response.out.write(output)
def get(self, slug):
# we want canonocal urls so redirect to add a trailing slash if needed
if self.request.path[-1] != "/":
self.redirect("%s/" % self.request.path, True)
return
user = users.get_current_user()
output = None
# if not logged in then use a cached version
if not user:
output = get_cache("project_%s" % slug)
# if we don't have a cached version or are logged in
if output is None:
try:
project = Project.all().filter('slug =', slug).fetch(1)[0]
issues = Issue.all().filter('project =', project)
except IndexError:
self.render_404()
return
# check to see if we have admin rights over this project
if project.user == user or users.is_current_user_admin():
owner = True
else:
owner = False
context = {
'project': project,
'issues': issues,
'owner': owner,
}
output = self.render("project.html", context)
if not user:
# only save a cached version if we're not logged in
# so as to avoid revelaving user details
memcache.add("project_%s" % slug, output, 3600)
self.response.out.write(output)
