def get(self, page_slug=""):
if page_slug:
t_values = {}
posts = Entry.all().filter("is_external_page =", True).filter("entrytype =", 'page').filter("slug =", page_slug)
if posts.count() == 1:
logging.warning("find one page with slug=%s" % (page_slug))
posts = posts.fetch(limit=1)
post = posts[0]
t_values['post'] = post
# dump(post)
# find all comments
comments = Comment.all().filter("entry =", post).order("date")
t_values['comments'] = comments
else:
logging.warning("%d entries share the same slug %s" % (posts.count(), page_slug))
links = Link.all().order("date")
t_values['links'] = links
categories = Category.all()
t_values['categories'] = categories
pages = Entry.all().filter("is_external_page =", True).filter("entrytype =", 'page').order("date")
t_values['pages'] = pages
return self.response.out.write(render_template("page.html", t_values, "basic", False))
else:
self.redirect(uri_for("weblog.index"))
def get(self):
# find stats for this blog
stats = {}
stats['posts'] = Entry.all().filter("entrytype =", "post").filter("is_external_page =", True).count()
stats['pages'] = Entry.all().filter("entrytype =", "page").filter("is_external_page =", True).count()
stats['comments'] = Comment.all().count()
stats['categories'] = Category.all().count()
stats['links'] = Link.all().count()
t_values = {}
t_values['stats'] = stats
return self.response.out.write(render_template("index.html", t_values, "", True))
def get(self):
context = {}
query = Entry.all().order("-updated")
next = self.request.get("next")
if next:
dt = datetime.strptime(next, "%Y-%m-%dT%H:%M:%S")
entries = query.filter("updated <=",
dt).fetch(PAGESIZE + 1)
if len(entries) == PAGESIZE + 1:
context["next"] = entries[-1].updated.isoformat("T")
else:
context["next"] = None
context["entries"] = entries[:PAGESIZE]
self.response.out.write(self.render_sec_entries(context))
return
else:
sec = {}
entries = query.fetch(PAGESIZE + 1)
if len(entries) == PAGESIZE + 1:
context["next"] = entries[-1].updated.isoformat("T")
else:
context["next"] = None
context["entries"] = entries[:PAGESIZE]
sec["entries"] = self.render_sec_entries(context)
sec["featured"] = self.render_sec_featured()
path = templatepath("main.html")
self.response.out.write(template.render(path, sec))
def get(self):
entry_count = Entry.all().count(1000)
tags = Tag.all().order('usetime')
tags_count = tags.count(1000)
tag_list = []
for tag in tags:
tag_count = tag.count_link + tag.count_note + tag.count_pic
if tag.count_link >= tag.count_note:
if tag.count_link >= tag.count_pic:
max_type = 'link'
else:
max_type = 'pic'
else:
if tag.count_pic >= tag.count_note:
max_type = 'pic'
else:
max_type = 'note'
tag_list.append({
"info": tag,
"type": max_type,
"level": tag_count / (entry_count / tags_count)
})
template_values = {'tags': tag_list}
path = os.path.join(os.path.dirname(__file__), 'templates/tag.html')
self.response.out.write(template.render(path, template_values))
def EntryHandler_postTest(self):
weight = 75.0
variance = 1.4
currDate = "2012-10-10"
currDt =dt.date(2012, 10, 10)
nick= users.get_current_user().nickname()
head = {"Content-Type" : "application/x-www-form-urlencoded", "Accept" : "text/plain"}
payload = urlencode({"date" : currDate, "variance" : float(variance),"weight":float(weight)})
#request = requests.Request("POST","/users/%s/"%nick, data=payload)
request = webapp2.Request.blank('/users/%s/entry/%s'%(nick,currDate))
request.method="POST"
request.headers=head
request.body=payload
currUser=users.get_current_user()
response = webapp2.Response()
handler = EntryHandler()
handler.initialize(request, response)
handler.post(user=None,cd=None)
self.setCurrentUser("*****@*****.**", "aaaaaaa")
userId=users.get_current_user().user_id()
db.delete(Entry.all())
nick=users.get_current_user().nickname()
handler.post(user=nick,cd='2012-10-10')
Entry(weight=100.0, variance=5.0,date=currDt,user=currUser, parent=log_key(userId)).put()
handler.post(user=nick,cd='2012-10-10')
db.delete(Biometric.all())
Biometric(height=150, target=73.3, parent=bio_key(currUser.user_id())).put()
handler.post(user=nick,cd='2012-10-10')
#Put Test
handler.put(user=nick,cd='2012-10-10')
handler.put(user=nick,cd='2012-10-15')
handler.delete(user=nick,cd='2012-10-10')
def getTagsForUrl(url):
try:
content = resource.get(url).decodeBody().lower()
except:
content = ""
soup = BeautifulSoup(content)
texts = soup.findAll(text=True)
def visible(element):
if element.parent.name in ['style', 'script', '[document]', 'head', 'title']:
return False
elif re.match('<!--.*-->', str(element)):
return False
return True
visible_texts = filter(visible, texts)
visibleText = " ".join(visible_texts)
result = getTagsProposalsForText(visibleText)
entry = Entry.all().filter("url =", url).fetch(1)
if len(entry) > 0:
entryStableTags = entry[0].tags
for t in entryStableTags:
found = False
name = Tag.get(t).name
for r in result:
if name == r:
found = True
if not found:
result.append(name)
return result
def update_basic_info(
update_categories=False,
update_tags=False,
update_links=False,
update_comments=False,
update_archives=False,
update_pages=False):
from model import Entry,Archive,Comment,Category,Tag,Link
basic_info = ObjCache.get(is_basicinfo=True)
if basic_info is not None:
info = ObjCache.get_cache_value(basic_info.cache_key)
if update_pages:
info['menu_pages'] = Entry.all().filter('entrytype =','page')\
.filter('published =',True)\
.filter('entry_parent =',0)\
.order('menu_order').fetch(limit=1000)
if update_archives:
info['archives'] = Archive.all().order('-year').order('-month').fetch(12)
if update_comments:
info['recent_comments'] = Comment.all().order('-date').fetch(5)
if update_links:
info['blogroll'] = Link.all().filter('linktype =','blogroll').fetch(limit=1000)
if update_tags:
info['alltags'] = Tag.all().order('-tagcount').fetch(limit=100)
if update_categories:
info['categories'] = Category.all().fetch(limit=1000)
logging.debug('basic_info updated')
basic_info.update(info)
def get(self, user, tag_title):
"""Gets RSS feed for a user, filtered by tag"""
user = utils.get_user_model_by_id_or_nick(user)
if not user:
self.error(403)
return
tag_title = tag_title.decode('utf-8')
tag = Tag.all().ancestor(user.key()).filter('title_lower =', tag_title.lower()).get()
if not tag:
self.error(404)
return
entries = Entry.all().filter('tags =', tag.key()).filter('published =', True).order('-time_published').fetch(20)
entries = [e.to_struct() for e in entries]
path = os.path.join(os.path.dirname(__file__), 'template.rss')
self.response.headers['Content-Type'] = 'application/xml; charset=utf-8'
self.response.out.write(template.render(path, {
'entries': entries,
'url': self.request.url,
'title': tag_title,
}))
def post(self):
# add new post or edit existed post
t_values = {}
current_post_id = self.request.POST["current_post_id"]
post_title = self.request.POST["blog_title"]
post_slug = get_safe_slug(self.request.POST["blog_slug"])
post_content = self.request.POST["blog_content"]
# find category
blog_category_id = self.request.POST["blog_category_id"]
post_category = Category.get_by_id(long(blog_category_id))
if post_category:
logging.info("find category %s for id %s" % (post_category.name, blog_category_id))
else:
logging.error("category id %s can't be located" % (blog_category_id))
if current_post_id:
logging.info("PostManager: post : edit post current_post_id = %s" % (current_post_id))
# update existed post
post = Entry.get_by_id(long(current_post_id))
if post:
t_values['alert_message'] = "Post %s has been updated!" % (post.title)
post.title = post_title
post.slug = post_slug
post.content = post_content
post.entrytype = "post"
# update category count if this post is public
if post.is_external_page and post.category != post_category:
if post.category and (post.category.entrycount > 0):
post.category.entrycount -= 1
post.category.put()
post_category.entrycount += 1
post.category.put()
post.category = post_category
post.put()
else:
logging.info("PostManager: post : new post title %s" % (self.request.POST['blog_title']))
# create new post
post = Entry()
post.title = post_title
post.slug = post_slug
post.content = post_content
post.entrytype = 'post'
post.category = post_category
# save as public or private?
operation = self.request.POST["submit_action"]
if operation == "save_publish":
post.is_external_page = True
# update category count
post.category.entrycount += 1
post.category.put()
else: # "save" operation
post.is_external_page = False
# save the post
post.put()
t_values['alert_message'] = "Post %s has been created!" % (post.title)
# show all posts
posts = Entry.all().filter("entrytype =", 'post')
t_values['posts'] = posts
return self.response.out.write(render_template("posts.html", t_values, "", True))
def get(self, page_id="", operation=""):
t_values = {}
logging.info("PageManager get: page_id = %s, operation = %s" % (page_id, operation))
# find current_post based on page_id
if page_id:
current_post = Entry.get_by_id(long(page_id))
if current_post:
logging.info("find post %s from post id %s" % (page_id, current_post.title))
if operation == "edit":
t_values['current_post'] = current_post
elif operation == "publish":
current_post.is_external_page = True
current_post.put()
t_values['alert_message'] = "Post %s has been changed to public" % (current_post.title)
elif operation == "unpublish":
current_post.is_external_page = False
current_post.put()
t_values['alert_message'] = "Post %s has been changed to private" % (current_post.title)
elif operation == "delete":
current_post.delete()
t_values['alert_message'] = "Post %s has been changed to deleted" % (current_post.title)
# show all posts
posts = Entry.all().filter("entrytype =", 'page')
t_values['posts'] = posts
return self.response.out.write(render_template("pages.html", t_values, "", True))
def delete(self, title):
"""Delete the specified tag for the current user"""
user = utils.get_current_user()
title = title.decode('utf-8')
if not user:
self.error(403)
return
m = Tag.all().ancestor(user).filter('title_lower =', title.lower()).get()
if not m:
# Original tag not found
self.error(404)
return
entries = Entry.all().filter('tags =', m.key())
# Remove tag from entries
for entry in entries:
logging.info(entry)
entry.tags.remove(m.key())
entry.save()
m.delete()
self.response.headers['Content-Type'] = 'text/plain; charset=utf-8'
self.response.headers['Access-Control-Allow-Origin'] = '*'
self.response.out.write('ok')
def get (self):
offset = self.request.get('offset')
if not offset:
offset = 0
e = Entry.all().order('addtime')
e = e.fetch(10,int(offset))
path = os.path.join(os.path.dirname(__file__),'templates/export.tpl')
self.response.out.write(template.render(path,{'e':e}))
def get(self,req_user=''):
user_lang = 'en'
#********************** User Auth **************************#
user = users.get_current_user()
nickname = ''
if user:
nickname=user.nickname()
if nickname:
user_info = User.all().filter('user',nickname)
if user_info.count(1)>0:
user_info = user_info.get()
user_lang = user_info.lang
auth_url = users.create_logout_url(self.request.uri)
auth_text= 'signout'
else:
auth_url = users.create_login_url(self.request.uri)
auth_text= 'signin'
entry_count =Entry.all().count(1000)
if req_user:
tag_user = req_user
tags = Tag.all().filter("user",req_user)
else:
tag_user = '******'
tags = Tag.all()
tags_count = tags.count(1000)
tag_list=[]
for tag in tags:
tag_count=tag.count_link + tag.count_note + tag.count_pic
if tag.count_link >= tag.count_note:
if tag.count_link >= tag.count_pic:
max_type = 'link'
else:
max_type = 'pic'
else:
if tag.count_pic >= tag.count_note:
max_type = 'pic'
else:
max_type = 'note'
#logging.info(tag_count)
#logging.info(entry_count)
#logging.info(tags_count)
tag_list.append({
"info":tag,
"type":max_type,
"level":int(round(tag_count/(float(entry_count)/tags_count)))
})
template_values = {
'nickname' : nickname,
'req_user' : req_user,
'auth_url' : auth_url,
'auth_text': auth_text,
'tag_user' : tag_user,
'tags' : tag_list,
'uri' : self.request.uri
}
path = os.path.join(os.path.dirname(__file__),'templates/'+user_lang+'/tag.html')
self.response.out.write(template.render(path,template_values))
def get(self, page="1", cate_slug=""):
t_values = {}
page = int(page)
logging.info("IndexHandler - get: page = %d, cate_slug = %s" % (page, cate_slug))
# find all entries by order
query = Entry.all().filter("is_external_page =", True).filter("entrytype =", 'post').order("-date")
# add category filter?
if cate_slug:
cates = Category.all().filter("slug =", cate_slug)
if cates:
query = query.filter("category =", cates[0])
# pagination
total_posts = query.count()
q_limit = Configuration["posts_per_page"]
q_offset = (page - 1) * Configuration["posts_per_page"]
logging.info("limit = %d, offset = %d" % (q_limit, q_offset))
# get entries
entries = query.fetch(limit=q_limit, offset=q_offset)
t_values['entries'] = entries
# show entries for debug purpose
# for entry in entries:
# logging.info("entry title: %s, public = %s, cate = %s" % (entry.title, entry.is_external_page, entry.category.name))
logging.info("total posts = %d, current_page = %d, posts_per_page = %d" % (total_posts, page, Configuration['posts_per_page']))
t_values['navlist'] = generateNavList(total_posts, page, Configuration["posts_per_page"])
# logging.info(t_values['navlist'])
# find all links
links = Link.all().order("date")
t_values['links'] = links
# find all categories
categories = Category.all()
t_values['categories'] = categories
# find all pages
pages = Entry.all().filter("is_external_page =", True).filter("entrytype =", 'page').order("date")
t_values['pages'] = pages
# show index page
return self.response.out.write(render_template("index.html", t_values, "basic", False))
def get(self):
"""Gets all entries from all feeds this user subscribes to"""
user = utils.get_current_user()
if not user:
self.error(403)
return
# Filter and sorting
order = self.request.get('order')
lang = self.request.get('lang')
tag_title = self.request.get('tag')
# Filter
if tag_title:
tag = Tag.all().ancestor(user.key()).filter('title_lower =', tag_title.lower()).get()
entries = Entry.all().filter('tags =', tag.key())
else:
entries = Entry.all().ancestor(user)
if lang and lang != 'all':
entries = entries.filter('language =', lang)
# Sorting
if order:
if order == 'date-asc':
entries = entries.order('time_published')
elif order == 'date-desc':
entries = entries.order('-time_published')
elif order == 'title-asc':
entries = entries.order('title')
elif order == 'title-desc':
entries = entries.order('-title')
else:
entries = entries.order('-time_published')
entries = entries.fetch(25)
self.response.headers['Content-Type'] = 'application/json; charset=utf-8'
self.response.headers['Access-Control-Allow-Origin'] = '*'
entries = [i.to_struct(include_tags=True) for i in entries]
self.response.out.write(json.dumps(entries))
def get(self):
entry_count =Entry.all().count(1000)
tags = Tag.all().order('usetime')
tags_count = tags.count(1000)
tag_list=[]
for tag in tags:
tag_count=tag.count_link + tag.count_note + tag.count_pic
if tag.count_link >= tag.count_note:
if tag.count_link >= tag.count_pic:
max_type = 'link'
else:
max_type = 'pic'
else:
if tag.count_pic >= tag.count_note:
max_type = 'pic'
else:
max_type = 'note'
tag_list.append({
"info":tag,
"type":max_type,
"level":tag_count/(entry_count/tags_count)
})
template_values = {
'tags' : tag_list
}
path = os.path.join(os.path.dirname(__file__),'templates/tag.html')
self.response.out.write(template.render(path,template_values))
def get(self, format="json"):
results = []
tagsRaw = getTagTerms(self.request.get("q").lower())
if len(tagsRaw) == 0 or tagsRaw[0] == "":
simplewebapp.formatResponse(format, self, results)
return
entries = Entry.all().filter("tagsRaw IN ", tagsRaw).run()
results = findEntries(entries, tagsRaw)
simplewebapp.formatResponse(format, self, results)
def get(self, format="json"):
results = []
tagsRaw = getTagTerms(self.request.get("q").lower())
if len(tagsRaw) == 0 or tagsRaw[0] == "":
simplewebapp.formatResponse(format, self, results)
return
# EXTREMELY SLOW ! OPTIMIZE!
entries = Entry.all().order("-updatedAt").run()
results = findEntries(entries, tagsRaw)
simplewebapp.formatResponse(format, self, results)
def get(self,format):
tags = Tag.all().run()
db.delete(tags)
firstLevelTags = [
"ActionScript",
"Asp",
"BASIC",
"C",
"C++",
"Clojure",
"COBOL",
"ColdFusion",
"Erlang",
"Fortran",
"Groovy",
"Haskell",
"Java",
"JavaScript",
"Lisp",
"Perl",
"PHP",
"Python",
"Ruby",
"Scala",
"Scheme",
"haxe",
"nodejs",
'framework',
'tool',
'wiki',
'tutorial',
'howto',
'library',
'service',
'language'
]
for tag in firstLevelTags:
t = Tag(name=tag.lower())
t.put()
entries = Entry.all()
for e in entries:
newtags = getTagKeys(e.tagsRaw)
e.tags = newtags
e.put()
simplewebapp.formatResponse(format, self, "OK")
def get(self,req_user='',req_tag=''):
entry = Entry.all().filter("private", False).order("-addtime")
if req_user != '' and req_user!='all':
entry = entry.filter("user", req_user)
if req_tag:
entry = entry.filter("tags", unquote(req_tag).decode('utf-8'))
self.response.headers['Content-Type'] = 'text/xml'
self.response.out.write('<?xml version="1.0" encoding="UTF-8"?>\r\n')
#self.response.out.write('<?xml-stylesheet type="text/xsl" href="/css/rss_xml_style.css"?>\r\n')
self.response.out.write('<rss version="2.0">\r\n')
self.response.out.write('\t<channel>\r\n')
self.response.out.write('\t\t<title>%s - http://5dnote.appspot.com</title>\r\n' % req_user)
self.response.out.write('\t\t<image>\r\n')
self.response.out.write('\t\t\t<title>5dnote.appspot.com</title>\r\n')
self.response.out.write('\t\t\t<link>http://5dnote.appspot.com/</link>\r\n')
self.response.out.write('\t\t\t<url>http://5dnote.appspot.com/media/logo.jpg</url>\r\n')
self.response.out.write('\t\t</image>\r\n')
self.response.out.write('\t\t<description>%s @ http://5dnote.appspot.com</description>\r\n' % req_user)
self.response.out.write('\t\t<link>http://5dnote.appspot.com/</link>\r\n')
self.response.out.write('\t\t<copyright>Copyright 2009 5dnote.appspot.com All Rights Reserved</copyright>\r\n')
self.response.out.write('\t\t<language>zh-cn</language>\r\n')
self.response.out.write('\t\t<generator>Google App Engine</generator>\r\n')
i=0
for item in entry:
i +=1
self.response.out.write('\t\t<item>\r\n')
self.response.out.write('\t\t\t<title>%s</title>\r\n' % (item.title) )
self.response.out.write('\t\t\t<link>%s</link>\r\n' % item.url)
self.response.out.write('\t\t\t<author>%s</author>\r\n' % item.user)
#for tag in item.tags:
tag_names =','.join(tag for tag in item.tags)
self.response.out.write('\t\t\t<category>%s</category>\r\n' % tag_names)
self.response.out.write('\t\t\t<pubDate>%s</pubDate>\r\n' % item.addtime)
comment = ''
self.response.out.write('\t\t\t<comments>%s</comments>\r\n' % comment)
if item.content:
content = '<![CDATA[\n' + item.content + '\n]]>'
else:
content = ''
self.response.out.write('\t\t\t<description>%s</description>\r\n' % content)
self.response.out.write('\t\t</item>\r\n')
self.response.out.write('\t</channel>\r\n')
self.response.out.write('</rss>\r\n')
def get(self):
"""Gets all entries"""
page = int(self.request.get('page', '0'))
page_size = 30
if not users.is_current_user_admin():
self.error(401)
return
entries = Entry.all().order('-time_published').fetch(page_size, page_size * page)
self.response.headers['Content-Type'] = 'application/json; charset=utf-8'
self.response.headers['Access-Control-Allow-Origin'] = '*'
entries = [i.to_struct(include_tags=True) for i in entries]
self.response.out.write(json.dumps(entries))
def get(self, post_id="", operation=""):
t_values = {}
logging.info("PostManager get: post_id = %s, operation = %s" % (post_id, operation))
# find current_post based on post_id
if post_id:
current_post = Entry.get_by_id(long(post_id))
if current_post:
logging.info("find post %s from post id %s" % (post_id, current_post.title))
if operation == "edit":
t_values['current_post'] = current_post
elif operation == "publish":
if not current_post.is_external_page:
current_post.category.entrycount += 1
current_post.category.put()
current_post.is_external_page = True
current_post.put()
t_values['alert_message'] = "Post %s has been changed to public" % (current_post.title)
else:
t_values['alert_message'] = "Post %s was public already" % (current_post.title)
elif operation == "unpublish":
if current_post.is_external_page:
current_post.category.entrycount -= 1
current_post.category.put()
current_post.is_external_page = False
current_post.put()
t_values['alert_message'] = "Post %s has been changed to private" % (current_post.title)
else:
t_values['alert_message'] = "Post %s was private already" % (current_post.title)
elif operation == "delete":
if current_post.is_external_page:
current_post.category.entrycount -= 1
current_post.category.put()
current_post.delete()
t_values['alert_message'] = "Post %s has been changed to deleted" % (current_post.title)
# show all posts
posts = Entry.all().filter("entrytype =", 'post')
t_values['posts'] = posts
# load all categories
categories = Category.all().order("name")
t_values['categories'] = categories
return self.response.out.write(render_template("posts.html", t_values, "", True))
def get(self,req_tag=''):
entry = Entry.all().filter("private", False).order("-addtime")
if req_tag:
entry = entry.filter("tags =", unquote(req_tag).decode('utf-8'))
self.response.headers['Content-Type'] = 'text/xml'
self.response.out.write('<?xml version="1.0" encoding="UTF-8"?>\r\n')
#self.response.out.write('<?xml-stylesheet type="text/xsl" href="/css/rss_xml_style.css"?>\r\n')
self.response.out.write('<rss version="2.0">\r\n')
self.response.out.write('\t<channel>\r\n')
self.response.out.write('\t\t<title>zerofault.appspot.com</title>\r\n')
self.response.out.write('\t\t<image>\r\n')
self.response.out.write('\t\t\t<title>Link/Note/Pic @GAE</title>\r\n')
self.response.out.write('\t\t\t<link>http://zerofault.appspot.com/</link>\r\n')
self.response.out.write('\t\t\t<url>http://zerofault.appspot.com/media/logo.jpg</url>\r\n')
self.response.out.write('\t\t</image>\r\n')
self.response.out.write('\t\t<description>My Favorites at Google App Engine</description>\r\n')
self.response.out.write('\t\t<link>http://zerofault.appspot.com/</link>\r\n')
self.response.out.write('\t\t<copyright>Copyright 2009 zerofault. All Rights Reserved</copyright>\r\n')
self.response.out.write('\t\t<language>zh-cn</language>\r\n')
self.response.out.write('\t\t<generator>python @ google app engine</generator>\r\n')
i=0
for item in entry:
i +=1
self.response.out.write('\t\t<item>\r\n')
self.response.out.write('\t\t\t<title>%s</title>\r\n' % (item.title) )
self.response.out.write('\t\t\t<link>%s</link>\r\n' % item.url)
self.response.out.write('\t\t\t<author>[email protected]</author>\r\n')
#for tag in item.tags:
tag_names =' '.join(tag for tag in item.tags)
self.response.out.write('\t\t\t<category>%s</category>\r\n' % tag_names)
self.response.out.write('\t\t\t<pubDate>%s</pubDate>\r\n' % item.addtime)
comment = ''
self.response.out.write('\t\t\t<comments>%s</comments>\r\n' % comment)
if item.content:
content = '<![CDATA[\n' + item.content + '\n]]>'
else:
content = ''
self.response.out.write('\t\t\t<description>%s</description>\r\n' % content)
self.response.out.write('\t\t</item>\r\n')
self.response.out.write('\t</channel>\r\n')
self.response.out.write('</rss>\r\n')
def get(self):
i=0
self.response.headers['Content-Type'] = 'text/csv'
self.response.headers['Content-Disposition'] = 'attachment; filename="Link_Tag.csv"'
self.response.headers['Cache-Control'] = 'must-revalidate, post-check=0'
self.response.headers['Expires'] = '0'
self.response.headers['Pragma'] = 'public'
entry = Entry.all().order("-addtime")
for item in entry:
i +=1
self.response.out.write('"%d","%s","%s","%s","%s","' %(i, item.title, item.url, item.content, item.private))
tag_names =','.join(tag for tag in item.tags)
self.response.out.write('%s' % tag_names)
self.response.out.write('"\r\n')
def post(self):
t_values = {}
# add new post or edit existed post
current_post_id = self.request.POST["current_post_id"]
if current_post_id:
logging.info("PageManager: post : current_post_id = %s" % (current_post_id))
# update existed post
post = Entry.get_by_id(long(current_post_id))
if post:
t_values['alert_message'] = "Post %s has been updated!" % (post.title)
post.title = self.request.POST["blog_title"]
post.slug = get_safe_slug(self.request.POST["blog_slug"])
post.content = self.request.POST["blog_content"]
post.entrytype = 'page'
post.put()
else:
logging.info("PageManager: post : new post title %s" % (self.request.POST['blog_title']))
# create new post
post = Entry()
post.title = self.request.POST["blog_title"]
post.slug = get_safe_slug(self.request.POST["blog_slug"])
post.content = self.request.POST["blog_content"]
# post.categories = self.request.POST["blog_categories"]
operation = self.request.POST["submit_action"]
logging.info("operation = %s" % (operation))
if operation == "save_publish":
post.is_external_page = True
else: # "save" operation
post.is_external_page = False
post.entrytype = 'page'
post.put()
t_values['alert_message'] = "Page %s: %s has been created!" % (post.title, post.entrytype)
# show all posts
posts = Entry.all().filter("entrytype =", 'page')
t_values['posts'] = posts
return self.response.out.write(render_template("pages.html", t_values, "", True))
def post(self, feed_id, language):
current_user = utils.get_current_user()
if not current_user:
self.error(403)
return
feed = InputFeed.get_by_id(int(feed_id), parent=current_user)
if not feed:
self.error(404)
return
entries = Entry.all().ancestor(feed)
for entry in entries:
entry.language = language
entry.save()
feed.language = language
feed.save()
self.response.headers['Content-Type'] = 'text/plain; charset=utf-8'
self.response.headers['Access-Control-Allow-Origin'] = '*'
self.response.out.write('ok')
def get(self, req_user=''):
user_lang = 'en'
#********************** User Auth **************************#
user = users.get_current_user()
nickname = ''
if user:
nickname = user.nickname()
if nickname:
user_info = User.all().filter('user', nickname)
if user_info.count(1) > 0:
user_info = user_info.get()
user_lang = user_info.lang
auth_url = users.create_logout_url(self.request.uri)
auth_text = 'signout'
else:
auth_url = users.create_login_url(self.request.uri)
auth_text = 'signin'
entry_count = Entry.all().count(1000)
if req_user:
tag_user = req_user
tags = Tag.all().filter("user", req_user)
else:
tag_user = '******'
tags = Tag.all()
tags_count = tags.count(1000)
tag_list = []
for tag in tags:
tag_count = tag.count_link + tag.count_note + tag.count_pic
if tag.count_link >= tag.count_note:
if tag.count_link >= tag.count_pic:
max_type = 'link'
else:
max_type = 'pic'
else:
if tag.count_pic >= tag.count_note:
max_type = 'pic'
else:
max_type = 'note'
#logging.info(tag_count)
#logging.info(entry_count)
#logging.info(tags_count)
tag_list.append({
"info":
tag,
"type":
max_type,
"level":
int(round(tag_count / (float(entry_count) / tags_count)))
})
template_values = {
'nickname': nickname,
'req_user': req_user,
'auth_url': auth_url,
'auth_text': auth_text,
'tag_user': tag_user,
'tags': tag_list,
'uri': self.request.uri
}
path = os.path.join(os.path.dirname(__file__),
'templates/' + user_lang + '/tag.html')
self.response.out.write(template.render(path, template_values))
def entryRsetBuilderOrderByFetchNum(self,key,orderby,rows):
rset = Entry.all()
rset.ancestor(log_key(key))
rset.order(orderby)
return rset.fetch(rows)
def post(self):
if not self.is_login:
self.redirect(users.create_login_url(self.request.uri))
filename = self.param('filename')
do_comment = self.paramint('c', 0)
if filename[:4] == 'img/': #处理图片
new_filename = filename.split('/')[1]
mtype = new_filename.split('.')[1]
bits = self.request.body
media = Media.all().filter('name =', new_filename)
if media.count() > 0:
media = media[0]
else:
media = Media()
media.name = new_filename
media.mtype = mtype
media.bits = bits
media.put()
bid = '_'.join(new_filename.split('_')[:-1])
entries = Entry.all().filter('slug =', bid)
if entries.count() > 0:
entry = entries[0]
entry.content = entry.content.replace(
filename, '/media/' + str(media.key()))
entry.put()
return
if filename == "index.html" or filename[-5:] != '.html':
return
#处理html页面
bid = filename[:-5]
try:
soup = BeautifulSoup(self.request.body)
bp = soup.find(id='bp')
title = self.getChineseStr(soup.title.text)
logging.info(bid)
pubdate = self.getdate(bp.find(id='bp-' + bid + '-publish').text)
body = bp.find('div', 'blogpost')
entries = Entry.all().filter('title = ', title)
if entries.count() < 1:
entry = Entry()
else:
entry = entries[0]
## entry=Entry.get_by_key_name(bid)
## if not entry:
## entry=Entry(key_name=bid)
entry.slug = bid
entry.title = title
entry.author_name = self.login_user.nickname()
entry.date = pubdate
entry.settags("")
entry.content = unicode(body)
entry.author = self.login_user
entry.save(True)
if do_comment > 0:
comments = soup.find('div', 'comments', 'div')
if comments:
for comment in comments.contents:
name, date = comment.h5.text.split(' - ')
# modify by lastmind4
name_date_pair = comment.h5.text
if name_date_pair.index('- ') == 0:
name_date_pair = 'Anonymous ' + name_date_pair
name, date = name_date_pair.split(' - ')
key_id = comment.h5['id']
date = self.getdate(date)
content = comment.contents[1].text
comment = Comment.get_or_insert(key_id,
content=content)
comment.entry = entry
comment.date = date
comment.author = name
comment.save()
except Exception, e:
logging.info("import error: %s" % e.message)
def post(self):
if not self.is_login:
self.redirect(users.create_login_url(self.request.uri))
filename=self.param('filename')
do_comment=self.paramint('c',0)
if filename[:4]=='img/':#处理图片
new_filename=filename.split('/')[1]
mtype =new_filename.split('.')[1]
bits = self.request.body
media=Media.all().filter('name =',new_filename)
if media.count()>0:
media=media[0]
else:
media=Media()
media.name=new_filename
media.mtype=mtype
media.bits=bits
media.put()
bid='_'.join(new_filename.split('_')[:-1])
entries=Entry.all().filter('slug =',bid)
if entries.count()>0:
entry=entries[0]
entry.content=entry.content.replace(filename,'/media/'+str(media.key()))
entry.put()
return
if filename=="index.html" or filename[-5:]!='.html':
return
#处理html页面
bid=filename[:-5]
try:
soup=BeautifulSoup(self.request.body)
bp=soup.find(id='bp')
title=self.getChineseStr( soup.title.text)
logging.info(bid)
pubdate=self.getdate( bp.find(id='bp-'+bid+'-publish').text)
body=bp.find('div','blogpost')
entries=Entry.all().filter('title = ',title)
if entries.count()<1:
entry=Entry()
else:
entry=entries[0]
## entry=Entry.get_by_key_name(bid)
## if not entry:
## entry=Entry(key_name=bid)
entry.slug=bid
entry.title=title
entry.author_name=self.login_user.nickname()
entry.date=pubdate
entry.settags("")
entry.content=unicode(body)
entry.author=self.login_user
entry.save(True)
if do_comment>0:
comments=soup.find('div','comments','div')
if comments:
for comment in comments.contents:
name,date=comment.h5.text.split(' - ')
# modify by lastmind4
name_date_pair = comment.h5.text
if name_date_pair.index('- ') == 0:
name_date_pair = 'Anonymous ' + name_date_pair
name,date=name_date_pair.split(' - ')
key_id=comment.h5['id']
date=self.getdate(date)
content=comment.contents[1].text
comment=Comment.get_or_insert(key_id,content=content)
comment.entry=entry
comment.date=date
comment.author=name
comment.save()
except Exception,e :
logging.info("import error: %s"%e.message)
def get(self,req_type='link',req_tag=''):
if not req_type:
req_type = 'link'
#********************** User Auth **************************#
isAdmin = False
user = users.get_current_user()
if user:
if users.is_current_user_admin():
isAdmin = True
auth_url = users.create_logout_url(self.request.uri)
auth_text= '注销'
else:
auth_url = users.create_login_url(self.request.uri)
auth_text= '登录'
#********************** Pagenator init**************************#
limit = 20;
p = self.request.get('p')
if not p:
p=1
else:
p = int(p)
offset = (p-1)*limit
#********************** Query **************************#
e = Entry.all().filter('type',req_type).order("-addtime")
if req_tag:
e = e.filter("tags", unquote(req_tag).decode('utf-8'))
if not isAdmin:
e = e.filter("private", False)
if e and e.count()>0:
cur_pageid = e.get().pageid
else:
cur_pageid = 0
item_count = 0
while cur_pageid>=0:
entry=Entry.all().filter('type',req_type)
if req_tag:
entry = entry.filter('tags',unquote(req_tag).decode('utf-8'))
if not isAdmin:
entry = entry.filter('private', False)
item_count += entry.filter('pageid',cur_pageid).count()
cur_pageid -=1
e = e.fetch(limit,offset)
#********************** Pagenator **************************#
page_count = int(math.ceil(item_count / float(limit))) #总页数
if page_count <=7 :
page_numbers = range(1,page_count+1)
else:
if p<=6:
page_numbers = range(1,max(1,p-3))
else:
page_numbers = [1,2] + ['...']
page_numbers += range(max(1,p-3),min(p+4,page_count+1))
if p >= page_count-5:
page_numbers += range(min(p+4,page_count+1),page_count+1)
else:
page_numbers += (['...']+range(page_count-1,page_count+1))
template_values = {
'user' : user,
'req_type' : req_type,
'isAdmin' : isAdmin,
'auth_url' : auth_url,
'auth_text': auth_text,
'entry_list': e,
'tag_list' : Tag.all().order("-count_"+req_type),
'is_paginated': page_count> 1,
'has_next': p*limit < item_count,
'has_previous': p > 1,
'current_page': p,
'next_page': p + 1,
'previous_page': p - 1,
'pages': page_count,
'page_numbers': page_numbers,
'count': item_count
}
path = os.path.join(os.path.dirname(__file__),'templates/'+req_type+'.html')
self.response.out.write(template.render(path,template_values))
def post(self):
#********************** User Auth **************************#
user = users.get_current_user()
nickname = ''
if user:
nickname = user.nickname()
if nickname:
key = self.request.get('key')
if key:
e = db.get(key)
if e.user != nickname:
e = Entry()
e.user = nickname
else:
e = Entry()
e.user = nickname
type = self.request.get('type')
if not type:
type = 'link'
tz = self.request.get('tz')
if tz[0:1] == '-':
tz = int(tz[1:])
tz = -tz
else:
tz = int(tz[1:])
tz = +tz
title = self.request.get('title')
e.title = title.replace('&', '&').replace('<', '<').replace(
'>', '>')
url = self.request.get('url')
purl = self.request.get('purl')
if type == 'pic' and not key:
e.url = purl.replace('&', '&').replace('<',
'<').replace(
'>', '>')
else:
e.url = url.replace('&', '&').replace('<', '<').replace(
'>', '>')
content = self.request.get('content')
e.content = content
if not key:
e.addtime += datetime.timedelta(hours=tz)
e.private = bool(int(self.request.get('private')))
e.type = type
if type == 'pic' and not key:
if url:
try:
result = urlfetch.fetch(url)
if result.status_code == 200:
e.image = db.Blob(result.content)
except:
self.response.out.write(
'Fetch picture fail! You can <a href="/add?type=pic">upload</a> it manually'
)
return
else:
myfile = self.request.get("myfile")
if not myfile:
self.response.out.write('No file specified!')
return
try:
e.image = db.Blob(myfile)
except:
self.response.out.write('Uploading fail!')
return
if key: #更新数据
for oldtag in e.tags:
tag = Tag.all().filter("user",
nickname).filter('name', oldtag)
if (tag.count(1) > 0):
t = tag.get()
if type == 'link':
t.count_link -= 1
if type == 'note':
t.count_note -= 1
if type == 'pic':
t.count_pic -= 1
t.put()
else: #新增数据
max_pageCount = 900 #超过此数据，则pageid递增
entry = Entry.all().order('-addtime')
if entry.count() > 0:
cur_pageid = entry.get().pageid
else:
cur_pageid = 0
cur_pageCount = entry.filter('pageid =',
cur_pageid).count(1000)
if cur_pageCount >= max_pageCount:
e.pageid = cur_pageid + 1
else:
e.pageid = cur_pageid
e.tags = []
tag_names = self.request.get('tags').split()
for tag_name in tag_names:
tag = Tag.all().filter("user",
nickname).filter('name', tag_name)
if (tag.count(1) > 0):
t = tag.get()
if type == 'link':
t.count_link += 1
if type == 'note':
t.count_note += 1
if type == 'pic':
t.count_pic += 1
t.user = nickname
t.usetime = datetime.datetime.now()
t.put()
else:
t = Tag()
t.name = tag_name
if type == 'link':
t.count_link = 1
if type == 'note':
t.count_note = 1
if type == 'pic':
t.count_pic = 1
t.user = nickname
t.usetime = datetime.datetime.now()
t.put()
e.tags.append(db.Category(tag_name))
e.put()
self.redirect('/' + type + '/' + nickname)
else:
self.redirect(users.create_login_url(self.request.uri))
def post(self):
if users.is_current_user_admin():
key = self.request.get('key')
if key:
e = db.get(key)
else:
e = Entry()
type = self.request.get('type')
if not type:
type = 'link'
title = self.request.get('title')
e.title = title.replace('&', '&').replace('<', '<').replace(
'>', '>')
url = self.request.get('url')
purl = self.request.get('purl')
if type == 'pic' and not key:
e.url = purl.replace('&', '&').replace('<',
'<').replace(
'>', '>')
else:
e.url = url.replace('&', '&').replace('<', '<').replace(
'>', '>')
content = self.request.get('content')
e.content = content
if not key:
e.addtime += datetime.timedelta(hours=+8)
e.private = bool(int(self.request.get('private')))
e.type = type
if type == 'pic' and not key:
if url:
try:
result = urlfetch.fetch(url)
if result.status_code == 200:
e.image = db.Blob(result.content)
except:
self.response.out.write('获取图片超时！')
return
else:
myfile = self.request.get("myfile")
if not myfile:
self.response.out.write('没有选择文件！')
return
try:
e.image = db.Blob(myfile)
except:
self.response.out.write('文件上传失败！')
return
if key: #更新数据
for oldtag in e.tags:
tag = Tag.all().filter('name', oldtag)
if (tag.count(1) > 0):
t = tag.get()
if type == 'link':
t.count_link -= 1
if type == 'note':
t.count_note -= 1
if type == 'pic':
t.count_pic -= 1
t.put()
else: #新增数据
max_pageCount = 900 #超过此数据，则pageid递增
entry = Entry.all().order('-addtime')
if entry.count() > 0:
cur_pageid = entry.get().pageid
else:
cur_pageid = 0
cur_pageCount = entry.filter('pageid =',
cur_pageid).count(1000)
if cur_pageCount >= max_pageCount:
e.pageid = cur_pageid + 1
else:
e.pageid = cur_pageid
e.tags = []
tag_names = self.request.get('tags').split()
for tag_name in tag_names:
tag = Tag.all().filter('name', tag_name)
if (tag.count(1) > 0):
t = tag.get()
if type == 'link':
t.count_link += 1
if type == 'note':
t.count_note += 1
if type == 'pic':
t.count_pic += 1
t.usetime = datetime.datetime.now()
t.put()
else:
t = Tag()
t.name = tag_name
if type == 'link':
t.count_link = 1
if type == 'note':
t.count_note = 1
if type == 'pic':
t.count_pic = 1
t.usetime = datetime.datetime.now()
t.put()
e.tags.append(db.Category(tag_name))
e.put()
self.redirect('/' + type + '/')
else:
self.redirect(users.create_login_url(self.request.uri))
def get(self, req_type='link', req_tag=''):
if not req_type:
req_type = 'link'
#********************** User Auth **************************#
isAdmin = False
user = users.get_current_user()
if user:
if users.is_current_user_admin():
isAdmin = True
auth_url = users.create_logout_url(self.request.uri)
auth_text = '注销'
else:
auth_url = users.create_login_url(self.request.uri)
auth_text = '登录'
#********************** Pagenator init**************************#
limit = 20
p = self.request.get('p')
if not p:
p = 1
else:
p = int(p)
offset = (p - 1) * limit
#********************** Query **************************#
e = Entry.all().filter('type', req_type).order("-addtime")
if req_tag:
e = e.filter("tags", unquote(req_tag).decode('utf-8'))
if not isAdmin:
e = e.filter("private", False)
if e and e.count() > 0:
cur_pageid = e.get().pageid
else:
cur_pageid = 0
item_count = 0
while cur_pageid >= 0:
entry = Entry.all().filter('type', req_type)
if req_tag:
entry = entry.filter('tags', unquote(req_tag).decode('utf-8'))
if not isAdmin:
entry = entry.filter('private', False)
item_count += entry.filter('pageid', cur_pageid).count()
cur_pageid -= 1
e = e.fetch(limit, offset)
#********************** Pagenator **************************#
page_count = int(math.ceil(item_count / float(limit))) #总页数
if page_count <= 7:
page_numbers = range(1, page_count + 1)
else:
if p <= 6:
page_numbers = range(1, max(1, p - 3))
else:
page_numbers = [1, 2] + ['...']
page_numbers += range(max(1, p - 3), min(p + 4, page_count + 1))
if p >= page_count - 5:
page_numbers += range(min(p + 4, page_count + 1),
page_count + 1)
else:
page_numbers += (['...'] +
range(page_count - 1, page_count + 1))
template_values = {
'user': user,
'req_type': req_type,
'isAdmin': isAdmin,
'auth_url': auth_url,
'auth_text': auth_text,
'entry_list': e,
'tag_list': Tag.all().order("-count_" + req_type),
'is_paginated': page_count > 1,
'has_next': p * limit < item_count,
'has_previous': p > 1,
'current_page': p,
'next_page': p + 1,
'previous_page': p - 1,
'pages': page_count,
'page_numbers': page_numbers,
'count': item_count
}
path = os.path.join(os.path.dirname(__file__),
'templates/' + req_type + '.html')
self.response.out.write(template.render(path, template_values))
def entryRsetBuilder(self,key):
rset = Entry.all()
rset.ancestor(log_key(key))
return rset
def getEntrybyDateDesc(self,key):
return Entry.all().ancestor(log_key(key)).order("-date")
def post(self, post_slug=""):
if post_slug:
t_values = {}
post_id = self.request.POST['post_id']
post = Entry.get_by_id(long(post_id))
if post:
# ok, we find the post, try to add comment to this post
logging.warning("find one post with post_id %s" % (post_id))
t_values['post'] = post
# dump(post)
# check google recaptcha, these two fileds might not exist due to connection to reCAPTCHA
recaptcha_challenge_field = self.request.POST.get('recaptcha_challenge_field', "")
recaptcha_response_field = self.request.POST.get('recaptcha_response_field', "")
remote_ip = self.request.environ['REMOTE_ADDR']
private_key = "6LdwFdISAAAAAOYRK7ls3O-kXPTnYDEstrLM2MRo"
antispam_flag = False
try:
result = submit(recaptcha_challenge_field, recaptcha_response_field, private_key, remote_ip)
logging.info("google recaptcha %s, %s" % (result.is_valid, result.error_code))
if result.is_valid:
antispam_flag = True
except:
e = sys.exc_info()[0]
logging.info(e)
# create comment for this post
if antispam_flag:
logging.info("PostManager - add comment")
comm_author = self.request.POST['author']
comm_email = self.request.POST['email']
comm_weburl = self.request.POST['weburl']
comm_content = self.request.POST['comment']
comment_ip = self.request.environ['REMOTE_ADDR']
comm = Comment(entry=post, author=comm_author, email=comm_email, weburl=comm_weburl, content=comm_content, ip=comment_ip)
comm.put()
t_values['alert_message'] = "Thanks %s for your comment!" % (comm_author)
else:
logging.warning("comment ignored because antispam failed")
t_values['alert_message'] = "Sorry, your comment was ignored because of reCAPTCHA failure!"
# find all comments
comments = Comment.all().filter("entry =", post).order("date")
logging.info("PostHandler, post, find %d comments" % (comments.count()))
if post_id:
# only update commentcount when new comment is added
post.commentcount = comments.count()
post.put()
t_values['comments'] = comments
else:
logging.warning("post_id %s does not exist" % (post_id))
links = Link.all().order("date")
t_values['links'] = links
categories = Category.all()
t_values['categories'] = categories
pages = Entry.all().filter("is_external_page =", True).filter("entrytype =", 'page').order("date")
t_values['pages'] = pages
return self.response.out.write(render_template("post.html", t_values, "basic", False))
else:
self.redirect(uri_for("weblog.index"))
