def get(self, year, month, day, slug):
year = int(year)
month = int(month)
day = int(day)
# Build the time span to check for the given slug
start_date = datetime.datetime(year, month, day)
time_delta = datetime.timedelta(days=1)
end_date = start_date + time_delta
# Create a query to check for slug uniqueness in the specified time span
query = blog.Post.all()
query.filter('pub_date >= ', start_date)
query.filter('pub_date < ', end_date)
query.filter('slug = ', slug)
post = query.get()
if post == None:
page = view.Page()
page.render_error(self, 404)
else:
template_values = {'post': post}
page = view.Page()
page.render(self, 'blog/post.html', template_values)
def post(self, page_url):
page_obj = blog.Page.all().filter('url =', page_url).get()
if page_obj == None:
page = view.Page()
page.render_error(self, 404)
else:
action_url = page_obj.get_edit_url()
page_obj.title = self.request.get('title')
page_obj.body = self.request.get('body')
if self.request.get('submit') == 'Submit':
page_obj.put()
# for now I use this sleep here to wait the post be created. I can't find a way to
# solve it. invesigate better later.
time.sleep(2)
self.redirect(page_obj.get_absolute_url())
else:
page_obj.populate_html_fields()
template_values = {
'action': action_url,
'page': page_obj,
}
page = view.Page()
page.render(self, 'admin/page_form.html', template_values)
def get(self, year, month, day, slug):
year = int(year)
month = int(month)
day = int(day)
# Build the time span to check for the given slug
start_date = datetime.datetime(year, month, day)
time_delta = datetime.timedelta(days=1)
end_date = start_date + time_delta
# Create a query to check for slug uniqueness in the specified time span
query = blog.Post.all()
query.filter('pub_date >= ', start_date)
query.filter('pub_date < ', end_date)
query.filter('slug = ', slug)
post = query.get()
if post == None:
page = view.Page()
page.render_error(self, 404)
else:
post.delete()
# for now I use this sleep here to wait the post be created. I can't find a way to
# solve it. invesigate better later.
time.sleep(2)
template_values = {'message': 'Your post has been deleted.'}
page = view.Page()
page.render(self, 'blog/post.html', template_values)
def post(self, year, month, day, slug):
year = int(year)
month = int(month)
day = int(day)
# Build the time span to check for the given slug
start_date = datetime.datetime(year, month, day)
time_delta = datetime.timedelta(days=1)
end_date = start_date + time_delta
# Create a query to check for slug uniqueness in the specified time span
query = blog.Post.all()
query.filter('pub_date >= ', start_date)
query.filter('pub_date < ', end_date)
query.filter('slug = ', slug)
post = query.get()
if post == None:
page = view.Page()
page.render_error(self, 404)
else:
action_url = post.get_edit_url()
post.title = self.request.get('title')
post.body = self.request.get('body')
slug = self.request.get('slug').strip()
if slug == '':
slug = blog.slugify(post.title)
post.slug = slug
excerpt = self.request.get('excerpt').strip()
if excerpt == '':
excerpt = None
post.excerpt = excerpt
post.tags = self.request.get('tags').split(',')
if self.request.get('submit') == 'Submit':
post.put()
# for now I use this sleep here to wait the post be created. I can't find a way to
# solve it. invesigate better later.
time.sleep(2)
self.redirect(post.get_absolute_url())
else:
post.populate_html_fields()
template_values = {
'action': action_url,
'post': post,
}
page = view.Page()
page.render(self, 'admin/post_form.html', template_values)
def get(self, year, month, day):
year = int(year)
month = int(month)
day = int(day)
# Build the time span to check for posts
start_date = datetime.datetime(year, month, day)
time_delta = datetime.timedelta(days=1)
end_date = start_date + time_delta
# Create a query to find posts in the given time span
query = blog.Post.all()
query.filter('pub_date >= ', start_date)
query.filter('pub_date < ', end_date)
query.order('-pub_date')
day_text = start_date.strftime('%x')
template_values = {
'page_title': 'Daily Post Archive: %s' % (day_text),
'page_description': 'Daily Post Archive: %s' % (day_text),
}
page = view.Page()
page.render_paginated_query(self, query, 'posts', 'blog/index.html',
template_values)
def get(self):
form = SiteForm()
page = view.Page()
template_values = {
'form': form,
}
page.render(self, 'templates/replace/form.html', template_values)
def get(self, page_url):
# Retrieve a page based on its url
page_obj = blog.Page.all().filter('url =', page_url).get()
template_values = {}
if page_obj == None:
page = view.Page()
page.render_error(self, 404)
else:
template_values = {'page': page_obj}
page = view.Page()
page.render(self, 'blog/page.html', template_values)
def get(self, site_key):
form = SiteForm()
page = view.Page()
site = Site.get(site_key)
content = site.content.lower()
found = []
parse = None
# for word in words_list.words_list:
#compile = re.compile(r"""\b%s\b""" % word, re.IGNORECASE)
# search = compile.findall(content)
# if search:
# found.append((word, len(search)))
# count = content.count(word)
# if count > 0:
# found.append((word, count))
soup = BeautifulSoup(content)
found = soup.findAll(text=re.compile(
r'\b(%s)\b' %
('|'.join(re.escape(s)
for s in words_list.words_list.keys())), re.IGNORECASE))
# for word in words_list.words_list:
# find_result = soup.findAll(text=word)
# if find_result:
# found.append((word, len(find_result)))
template_values = {
'form': form,
'site': site,
'found': found,
'parse': parse,
}
page.render(self, 'templates/replace/replace.html', template_values)
def get(self, year, month):
year = int(year)
month = int(month)
# Build the time span to check for posts
start_date = datetime.datetime(year, month, 1)
end_year = year if month < 12 else year + 1
end_month = month + 1 if month < 12 else 1
end_date = datetime.datetime(end_year, end_month, 1)
# Create a query to find posts in the given time span
query = blog.Post.all()
query.filter('pub_date >= ', start_date)
query.filter('pub_date < ', end_date)
query.order('-pub_date')
month_text = start_date.strftime('%B %Y')
template_values = {
'page_title': 'Monthly Post Archive: %s' % (month_text),
'page_description': 'Monthly Post Archive: %s' % (month_text),
}
page = view.Page()
page.render_paginated_query(self, query, 'posts', 'blog/index.html',
template_values)
def get(self, email):
page = view.Page()
player = Player.get(email)
stats = Stat.all().ancestor(player)
form = GraphForm()
puzzle, mode = '3x3x3', 'Normal'
graph_data = player.get_graph_data()
if self.request.GET:
form = GraphForm(self.request.GET)
if form.is_valid():
puzzle, mode = form.cleaned_data['puzzle'], form.cleaned_data[
'mode']
graph_data = form.get_graph_data(player)
template_values = {
'email': email,
'player': player,
'stats': stats,
'graph_data': graph_data,
'puzzle': puzzle,
'mode': mode,
'form': form,
}
page.render(self, 'templates/andy/user.html', template_values)
def post(self):
new_post = blog.Post()
new_post.title = self.request.get('title')
new_post.body = self.request.get('body')
slug = self.request.get('slug').strip()
if slug == '':
slug = blog.slugify(new_post.title)
new_post.slug = slug
excerpt = self.request.get('excerpt').strip()
if excerpt == '':
excerpt = None
new_post.excerpt = excerpt
new_post.tags = self.request.get('tags').split(',')
if self.request.get('submit') == 'Submit':
if new_post.put():
# for now I use this sleep here to wait the post be created. I can't find a way to
# solve it. invesigate better later.
time.sleep(2)
self.redirect(new_post.get_absolute_url())
else:
new_post.populate_html_fields()
template_values = {
'post': new_post,
}
page = view.Page()
page.render(self, 'admin/post_form.html', template_values)
def get(self):
page = view.Page()
form = PostForm(auto_id="item_form_%s")
template_values = {
'form': form,
'unpublish': get_unpublish_list(),
}
page.render(self, 'templates/post_form.html', template_values)
def get(self, url):
# Create a query to check for slug uniqueness in the specified time span
page_obj = blog.Page.all().filter('url =', url).get()
if page_obj == None:
page = view.Page()
page.render_error(self, 404)
else:
page_obj.delete()
# for now I use this sleep here to wait the post be created. I can't find a way to
# solve it. invesigate better later.
time.sleep(2)
template_values = {'message': 'Your post has been deleted.'}
page = view.Page()
page.render(self, 'blog/page.html', template_values)
def get(self, page_url):
page_obj = blog.Page.all().filter('url =', page_url).get()
if page_obj == None:
page = view.Page()
page.render_error(self, 404)
else:
action_url = page_obj.get_edit_url()
template_values = {
'action': action_url,
'page': page_obj,
}
page = view.Page()
page.render(self, 'admin/page_form.html', template_values)
def get(self):
pages = blog.Page.all()
pages.order('-name')
template_values = {'page_title': 'Pages'}
page = view.Page()
page.render_paginated_query(self, pages, 'pages', 'admin/pages.html',
template_values)
def get(self, stat):
page = view.Page()
stat = Stat.get(stat)
player = stat.parent()
template_values = {
'stat': stat,
'player': player,
}
page.render(self, 'templates/andy/stat.html', template_values)
def post(self, year, month, day, slug):
template_values = {}
year = int(year)
month = int(month)
day = int(day)
# Build the time span to check for the given slug
start_date = datetime.datetime(year, month, day)
time_delta = datetime.timedelta(days=1)
end_date = start_date + time_delta
# Create a query to check for slug uniqueness in the specified time span
query = blog.Post.all()
query.filter('pub_date >= ', start_date)
query.filter('pub_date < ', end_date)
query.filter('slug = ', slug)
post = query.get()
if post == None:
page = view.Page()
page.render_error(self, 404)
else:
action_url = post.get_edit_url()
form = PostForm(self.request.POST)
#form = PostForm2(self.request.POST, instance=post)
if self.request.get('submit') == 'Submit':
if form.is_valid():
post = form.save(post=post)
if post.publish:
memcache.delete('unpublish')
self.redirect(post.get_absolute_url())
else:
self.redirect('/admin/post/create')
else:
if form.is_valid():
post = form.save(post=post, commit=False)
template_values['action'] = action_url
template_values['post'] = post
template_values['form'] = form
template_values['unpublish'] = get_unpublish_list()
page = view.Page()
page.render(self, 'templates/post_form.html', template_values)
def get(self):
query = blog.Post.all()
query.order('-pub_date')
template_values = {'page_title': 'Posts'}
page = view.Page()
page.render_paginated_query(self, query, 'posts', 'admin/posts.html',
template_values)
def get(self, stat):
page = view.Page()
stat = Stat.get(stat)
temp_stat = stat
player = stat.parent()
stat.delete()
template_values = {
'temp_stat': temp_stat,
'player': player,
}
page.render(self, 'templates/andy/stat_delete.html', template_values)
def get(self):
query = blog.Post.all()
query.filter('publish =', True)
query.order('-pub_date')
template_values = {
'page_title': 'Home',
}
page = view.Page()
page.render_paginated_query(self, query, 'posts',
'templates/index.html', template_values)
def get(self, year, month, day, slug):
year = int(year)
month = int(month)
day = int(day)
# Build the time span to check for the given slug
start_date = datetime.datetime(year, month, day)
time_delta = datetime.timedelta(days=1)
end_date = start_date + time_delta
# Create a query to check for slug uniqueness in the specified time span
query = blog.Post.all()
query.filter('pub_date >= ', start_date)
query.filter('pub_date < ', end_date)
query.filter('slug = ', slug)
post = query.get()
if post == None:
page = view.Page()
page.render_error(self, 404)
else:
action_url = post.get_edit_url()
form = PostForm(initial={'title':post.title,
'slug':post.slug,
'tags':" ".join(post.tags),
'excerpt':post.excerpt,
'body':post.body,
'publish':post.publish})
#form = PostForm2(instance=post)
template_values = {
'action': action_url,
'post': post,
'form': form,
'unpublish': get_unpublish_list()
}
page = view.Page()
page.render(self, 'templates/post_form.html', template_values)
def get(self, site_key):
page = view.Page()
site = Site.get(site_key)
content = site.content.lower()
found = []
for k, v in words_list.words_list.items():
if not content.find(k.lower()) == -1:
found.append((k, v))
template_values = {
'site': site,
'found': found,
}
page.render(self, 'templates/replace/result.html', template_values)
def get(self, tag):
query = blog.Post.all()
query.filter('tags =', tag)
query.order('-pub_date')
template_values = {
'page_title': 'Posts tagged "%s"' % (tag),
'page_description': 'Posts tagged "%s"' % (tag),
}
page = view.Page()
page.render_paginated_query(self, query, 'posts', 'blog/index.html',
template_values)
def get(self):
query = blog.Post.all()
query.order('-pub_date')
user = users.get_current_user()
# Retrieve all pages registered on datastore
# to list on the page
pages = blog.Page.all()
template_values = {'pages': pages}
page = view.Page()
page.render_paginated_query(self, query, 'posts', 'blog/index.html',
template_values)
def post(self):
template_values = {}
form = PostForm(self.request.POST, auto_id="item_form_%s")
if self.request.get('submit') == 'Submit':
if form.is_valid():
new_post = form.save()
memcache.delete('unpublish')
if new_post.publish:
self.redirect(new_post.get_absolute_url())
else:
self.redirect('/admin/post/create')
else:
if form.is_valid():
new_post = form.save(commit=False)
template_values['post'] = new_post
template_values['form'] = form
template_values['unpublish'] = get_unpublish_list()
page = view.Page()
page.render(self, 'templates/post_form.html', template_values)
def post(self):
new_page = blog.Page()
new_page.name = self.request.get('name')
new_page.url = self.request.get('url')
new_page.body = self.request.get('body')
if self.request.get('submit') == 'Submit':
new_page.put()
# for now I use this sleep here to wait the post be created. I can't find a way to
# solve it. invesigate better later.
time.sleep(2)
self.redirect(new_page.get_absolute_url())
else:
new_page.populate_html_fields()
template_values = {
'page': new_page,
}
page = view.Page()
page.render(self, 'admin/page_form.html', template_values)
def post(self):
page = view.Page()
stat, player = None, None
check = PlayerForm(self.request.POST)
if check.is_valid():
player = check.login()
check = None
form = ExportForm(self.request.POST)
if player and not check:
if form.is_valid():
stat = form.save(player)
form = None
self.redirect('/qqtimer/stat/%s' % stat.key())
template_values = {
'check': check,
'form': form,
}
page.render(self, 'templates/andy/result.html', template_values)
def get(self, year):
year = int(year)
# Build the time span to check for posts
start_date = datetime.datetime(year, 1, 1)
end_date = datetime.datetime(year + 1, 1, 1)
# Create a query to find posts in the given time span
query = blog.Post.all()
query.filter('pub_date >= ', start_date)
query.filter('pub_date < ', end_date)
query.order('-pub_date')
template_values = {
'page_title': 'Yearly Post Archive: %d' % (year),
'page_description': 'Yearly Post Archive: %d' % (year),
}
page = view.Page()
page.render_paginated_query(self, query, 'posts', 'blog/index.html',
template_values)
def get(self):
page = view.Page()
page.render_error(self, 404)
def post(self):
page = view.Page()
form = SiteForm(self.request.POST)
if form.is_valid():
site = form.get()
self.redirect('/replace/replace/%s' % site.key())
