def get(self, page_title):
"""When we receive an HTTP Get request to the view pages, we pull that
page from the datastore and render it. If the page does not exist
we pass empty arguments to the template and the template displays
the option to the user to create the page
"""
# Attempt to locate the page
entry = WikiPage.gql('WHERE title = :1', page_title).get()
# If it exists, render the body, if not, don't
if entry and entry.body:
wiki_body, count = _WIKI_WORD.subn(r'<a href="/view/\1" >\1</a>',
entry.body)
wiki_body = markdown.markdown(wiki_body)
author = entry.author
else:
wiki_body = ""
author = ""
self.generate('view.html',
template_values={
'page_title': page_title,
'body': wiki_body,
'author': author
})
def get_page_content(self, page_title):
"""When memcache lookup fails, we want to query the information from
the datastore and return it. If the data isn't in the data store,
simply return empty strings
"""
# Find the wiki entry
entry = WikiContent.gql('WHERE title = :1', page_title).get()
if entry:
# Retrieve the current version
current_version = WikiRevision.gql('WHERE wiki_page = :1 '
'ORDER BY version_number DESC', entry).get()
# Define the body, version number, author email, author nickname
# and revision date
body = current_version.revision_body
version = current_version.version_number
author_email = urllib.quote(current_version.author.wiki_user.email())
author_nickname = current_version.author.wiki_user.nickname()
version_date = current_version.created
# Replace all wiki words with links to those wiki pages
wiki_body, count = _WIKI_WORD.subn(r'<a href="/view/\1">\1</a>',
body)
# Markdown the body to allow formatting of the wiki page
wiki_body = markdown.markdown(wiki_body)
else:
# These things do not exist
wiki_body = ''
author_email = ''
author_nickname = ''
version = ''
version_date = ''
return [wiki_body, author_email, author_nickname, version, version_date]
def parse(self, path: Path, source: Path, dest: Path):
content = Content.load(self.read(path))
html = markdown.markdown(content.body)
self.write(path, dest, html)
sys.stdout.write(
"\x1b[1;32m{} converted to HTML. Metadata: {}\n".format(
path.name, content))
def markdown_to_text(markdown_string):
# md -> html -> text since BeautifulSoup can extract text cleanly
html = markdown.markdown(markdown_string)
# extract text
soup = BeautifulSoup(html, "html.parser")
text = ''.join(soup.findAll(text=True))
return text
def markdown2(value):
try:
import markdown
except ImportError:
if settings.DEBUG:
raise template.TemplateSyntaxError("Error in 'markdonw' filter: The Python markdown2 library isn't install.")
return force_text(value)
else:
return mark_safe(markdown.markdown(value,
extensions=['markdown.extensions.fenced_code', 'markdown.extensions.codehilite'],
safe_mode=True,
enable_attributes=False))
def get(self, slug=None):
# look up the article
article = models.Article.get_by_slug(slug)
if not article:
return self.render_template('errors/default_error.html')
# fetch the content from ourselves
http = httplib2.Http(cache=None, timeout=None, proxy_info=None)
uri = "http://%s/assets/blog/%s" % (self.request.host,
article.filename)
response, content = http.request(uri,
method="GET",
body=None,
headers=None)
# if the article wasn't found
if response['status'] == '404':
return self.render_template('errors/default_error.html')
# fetch the user's info who wrote the article
owner_info = models.User.get_by_id(article.owner.id())
if not owner_info.name:
article_owner = owner_info.username
else:
article_owner = owner_info.name
# build gravatar URL
gravatar_hash = md5.new(owner_info.email.lower().strip()).hexdigest()
article_gravatar_url = "https://www.gravatar.com/avatar/%s?s=48" % gravatar_hash
# date format
date_format = "%A, %d %b %Y"
article_created = article.created.strftime(date_format)
# create markdown and sanitize
article_html = markdown.markdown(content)
article_html = bleach.clean(article_html, config.bleach_tags,
config.bleach_attributes)
# load page content into params
params = {
'article_created': article_created,
'article_html': article_html,
'article_slug': article.slug,
'article_title': article.title,
'article_type': article.article_type,
'article_owner': article_owner,
'article_gravatar_url': article_gravatar_url,
'article_host': self.request.host,
}
return self.render_template('blog/detail.html', **params)
def post(self, page_title):
# Again, only accept saves from a signed in user
current_user = users.get_current_user()
if not current_user:
self.redirect(users.create_login_url('/edit/' + page_title))
# See if this user has a profile
wiki_user = WikiUser.gql('WHERE wiki_user = :1', current_user).get()
# If not, create the profile
if not wiki_user:
wiki_user = WikiUser(wiki_user=current_user)
wiki_user.put()
# get the user entered content in the form
body = self.request.get('body')
# Find the entry, if it exists
entry = WikiContent.gql('WHERE title = :1', page_title).get()
# Generate the version number based on the entries previous existence
if entry:
latest_version = WikiRevision.gql(
'WHERE wiki_page = :content'
' ORDER BY version_number DESC',
content=entry).get()
version_number = latest_version.version_number + 1
else:
version_number = 1
entry = WikiContent(title=page_title)
entry.put()
# Create a version for this entry
version = WikiRevision(version_number=version_number,
revision_body=body,
author=wiki_user,
wiki_page=entry)
version.put()
# above, memcache sets the following:
# return [wiki_body, author_email, author_nickname, version, version_date]
content = [
markdown.markdown(body),
current_user.email(),
current_user.nickname(), version_number, version.created
]
memcache.set(page_title, content, 600)
# After the entry has been saved, direct the user back to view the page
self.redirect('/view/' + page_title)
def get(self, page_title):
"""When we receive an HTTP Get request to the view pages, we pull that
page from the datastore and render it. If the page does not exist
we pass empty arguments to the template and the template displays
the option to the user to create the page
"""
# Find the wiki entry
entry = WikiContent.gql('WHERE title = :1', page_title).get()
if entry:
# Retrieve the current version
current_version = WikiRevision.gql(
'WHERE wiki_page = :1 '
'ORDER BY version_number DESC', entry).get()
# Define the body, version number, author email, author nickname
# and revision date
body = current_version.revision_body
version = current_version.version_number
author_email = urllib.quote(
current_version.author.wiki_user.email())
author_nickname = current_version.author.wiki_user.nickname()
version_date = current_version.created
# Replace all wiki words with links to those wiki pages
wiki_body, count = _WIKI_WORD.subn(r'<a href="/view/\1">\1</a>',
body)
# Markdown the body to allow formatting of the wiki page
wiki_body = markdown.markdown(wiki_body)
else:
# These things do not exist
wiki_body = ''
author_email = ''
author_nickname = ''
version = ''
version_date = ''
# Render the template view.html, which extends base.html
self.generate('view.html',
template_values={
'page_title': page_title,
'body': wiki_body,
'author': author_nickname,
'author_email': author_email,
'version': version,
'version_date': version_date
})
def post(self, page_title):
# Again, only accept saves from a signed in user
current_user = users.get_current_user()
if not current_user:
self.redirect(users.create_login_url('/edit/' + page_title))
# See if this user has a profile
wiki_user = WikiUser.gql('WHERE wiki_user = :1', current_user).get()
# If not, create the profile
if not wiki_user:
wiki_user = WikiUser(wiki_user=current_user)
wiki_user.put()
# get the user entered content in the form
body = self.request.get('body')
# Find the entry, if it exists
entry = WikiContent.gql('WHERE title = :1', page_title).get()
# Generate the version number based on the entries previous existence
if entry:
latest_version = WikiRevision.gql('WHERE wiki_page = :content'
' ORDER BY version_number DESC', content=entry).get()
version_number = latest_version.version_number + 1
else:
version_number = 1
entry = WikiContent(title=page_title)
entry.put()
# Create a version for this entry
version = WikiRevision(version_number=version_number,
revision_body=body, author=wiki_user,
wiki_page=entry)
version.put()
# above, memcache sets the following:
# return [wiki_body, author_email, author_nickname, version, version_date]
content = [markdown.markdown(body), current_user.email(),
current_user.nickname(), version_number, version.created]
memcache.set(page_title, content, 600)
# After the entry has been saved, direct the user back to view the page
self.redirect('/view/' + page_title)
def get_page_content(self, page_title, revision_number=1):
"""When memcache lookup fails, we want to query the information from
the datastore and return it. If the data isn't in the data store,
simply return empty strings
"""
# Find the wiki entry
entry = WikiContent.gql('WHERE title = :1', page_title).get()
if entry:
# Retrieve the current version
if revision_number is not None:
requested_version = WikiRevision.gql(
'WHERE wiki_page = :1 '
'AND version_number = :2', entry,
int(revision_number)).get()
else:
requested_version = WikiRevision.gql(
'WHERE wiki_page = :1 '
'ORDER BY version_number DESC', entry).get()
# Define the body, version number, author email, author nickname
# and revision date
body = requested_version.revision_body
version = requested_version.version_number
author_email = urllib.quote(
requested_version.author.wiki_user.email())
author_nickname = requested_version.author.wiki_user.nickname()
version_date = requested_version.created
# Replace all wiki words with links to those wiki pages
wiki_body, count = _WIKI_WORD.subn(r'<a href="/view/\1">\1</a>',
body)
# Markdown the body to allow formatting of the wiki page
wiki_body = markdown.markdown(wiki_body)
else:
# These things do not exist
wiki_body = ''
author_email = ''
author_nickname = ''
version = ''
version_date = ''
return [
wiki_body, author_email, author_nickname, version, version_date
]
def get(self, page_title):
"""When we receive an HTTP Get request to the view pages, we pull that
page from the datastore and render it. If the page does not exist
we pass empty arguments to the template and the template displays
the option to the user to create the page
"""
# Find the wiki entry
entry = WikiContent.gql('WHERE title = :1', page_title).get()
if entry:
# Retrieve the current version
current_version = WikiRevision.gql('WHERE wiki_page = :1 '
'ORDER BY version_number DESC', entry).get()
# Define the body, version number, author email, author nickname
# and revision date
body = current_version.revision_body
version = current_version.version_number
author_email = urllib.quote(current_version.author.wiki_user.email())
author_nickname = current_version.author.wiki_user.nickname()
version_date = current_version.created
# Replace all wiki words with links to those wiki pages
wiki_body, count = _WIKI_WORD.subn(r'<a href="/view/\1">\1</a>',
body)
# Markdown the body to allow formatting of the wiki page
wiki_body = markdown.markdown(wiki_body)
else:
# These things do not exist
wiki_body = ''
author_email = ''
author_nickname = ''
version = ''
version_date = ''
# Render the template view.html, which extends base.html
self.generate('view.html', template_values={'page_title': page_title,
'body': wiki_body,
'author': author_nickname,
'author_email': author_email,
'version': version,
'version_date': version_date})
def get(self, page_title):
"""When we receive an HTTP Get request to the view pages, we pull that
page from the datastore and render it. If the page does not exist
we pass empty arguments to the template and the template displays
the option to the user to create the page
"""
# Attempt to locate the page
entry = WikiPage.gql('WHERE title = :1', page_title).get()
# If it exists, render the body, if not, don't
if entry and entry.body:
wiki_body, count = _WIKI_WORD.subn(r'<a href="/view/\1" >\1</a>', entry.body)
wiki_body = markdown.markdown(wiki_body)
author = entry.author
else:
wiki_body = ""
author = ""
self.generate('view.html', template_values={'page_title': page_title,
'body': wiki_body,
'author': author})
def get(self):
# load articles in from db and then stuff them in an array
date_format = "%A, %d %b %Y"
articles = models.Article.get_all()
# http connection start
http = httplib2.Http(cache=None, timeout=None, proxy_info=None)
blogposts = []
# loop through articles
for article in articles:
# fetch the content from ourselves
uri = "http://%s/assets/blog/%s" % (self.request.host,
article.filename)
response, content = http.request(uri,
method="GET",
body=None,
headers=None)
if content:
# create markdown and sanitize
article_html = bleach.clean(markdown.markdown(content),
config.bleach_tags,
config.bleach_attributes)
article_title = bleach.clean(article.title)
# created when and by whom
article_created = article.created.strftime(date_format)
owner_info = models.User.get_by_id(article.owner.id())
# load name
try:
if not owner_info.name:
article_owner = owner_info.username
else:
article_owner = owner_info.name
except:
article_owner = "StackMonkey"
# build gravatar URL
try:
gravatar_hash = md5.new(
owner_info.email.lower().strip()).hexdigest()
except:
gravatar_hash = md5.new(
config.app_email.strip()).hexdigest()
article_gravatar_url = "https://www.gravatar.com/avatar/%s?s=48" % gravatar_hash
# build entry
entry = {
'article_created': article_created,
'article_id': article.key.id(),
'article_title': article_title,
'article_type': article.article_type,
'article_html': article_html,
'article_slug': article.slug,
'article_owner': article_owner,
'article_gravatar_url': article_gravatar_url,
'article_host': self.request.host,
}
# append article if it's a post and not a draft
if article.article_type == 'post' and not article.draft:
blogposts.append(entry)
# pack and stuff into template
params = {'blogposts': blogposts}
return self.render_template('blog/blog.html', **params)
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify(self.firstname + self.lastname + self.resort)
import markdown
self.description = markdown.markdown(self.markdown_description)
super(Profile, self).save(*args, **kwargs)
newzip.write(f, arcname=f.relative_to(probdir))
tmp.seek(0)
data = tmp.read()
m = hashlib.sha256()
m.update(data)
datahash = m.hexdigest()
# convert task
statement = ''
with open(probdir / 'task.md') as f:
statement = markdown.markdown(
f.read(),
extensions=[
'markdown.extensions.fenced_code',
'markdown.extensions.tables',
ExampleExtension(base_path=str(probdir))
],
)
with conn.cursor() as cursor:
cursor.execute(
'''
insert into problems (name, title, statement, timelimit, testhash, testzip)
values (%s, %s, %s, %s, %s, %s)
on conflict(name) do update
set (title, statement, timelimit, testhash, testzip)
= (EXCLUDED.title, EXCLUDED.statement, EXCLUDED.timelimit,
EXCLUDED.testhash, EXCLUDED.testzip)
''', (name, title, statement, int(
timelimit * 1000), datahash, data))
