def get(self):
results_template = JINJA_ENVIRONMENT.get_template('templates/profile.html')
all_posts = Post.query().fetch()
user_key = Key('User', self.session.get('user_key_id'))
user_posts = Post.query(Post.author_key == user_key).order(-Post.date_time).fetch()
all_comments = Comment.query().order(Comment.date_time).fetch()
for post in all_posts:
author = post.author_key.get()
post.author_name = author.first_name + ' ' + author.last_name
post.author_pic = author.dp_url
author.put()
for comment in all_comments:
author = comment.author_key.get()
comment.author_name = author.first_name + ' ' + author.last_name
author.put()
info = {
'first_name' : self.session.get('f_name'),
'last_name' : self.session.get('l_name'),
'email' : self.session.get('email'),
'dp_url' : self.session.get('dp_url'),
'user_posts' : user_posts,
'all_comments' : all_comments
}
self.response.write(results_template.render(info))
def post(self):
user = self.getAuthentificatedUser()
if not user:
return
try:
id = int(self.request.get('post_id'))
post = Post().get(db.Key.from_path('Post', id))
if post.author != user:
self.redirect('/')
return
body = db.Text(strip_ml_tags(self.request.get('body')))
postmarkup = create(use_pygments=False)
post.body = postmarkup(body)
# replace('\n','<br />')
if post.body != '':
post.put()
# re-index it!
ix = getdatastoreindex("post_"+str(post.key().id()), schema=SEARCHSCHEMA)
writer = ix.writer()
writer.add_document(body=u"%s" % post.body)
writer.commit()
except:
pass
if self.request.get('page'):
self.redirect('/view?id=' + str(self.request.get('id')) + '&page=' + self.request.get('page'))
else:
self.redirect('/view?id=' + str(self.request.get('id')))
def post(self):
"""create a post and redirect to MyPost handler"""
if self.with_no_user():
self.redirect("/")
return
uid = self.user.key().id()
uname = self.user.name
title = self.request.get("title")
subtitle = self.request.get("subtitle", "")
content = self.request.get("content")
if title and content:
content = content.replace('\n', '<br>')
post = Post(uid=uid,
uname=uname,
title=title,
subtitle=subtitle,
content=content)
post.put()
self.redirect("/post/" + str(post.key().id()))
else:
error = "Both title, subtitle and content are needed!"
self.render("new_post.html",
title=title,
content=content,
error=error)
def get(self, user_id=""):
if user_id:
posts = Post.by_user(long(user_id))
else:
posts = Post.list_all()
self.render('posts_list.html', posts=posts)
def get(self, path):
gdict = self.GET
path = urllib.unquote(path)
if path == config.FEED_SRC: #FEED
self.set_content_type("atom")
posts = Post.get_feed_post(config.FEED_NUMBER)
self.render("feed.xml", {"posts": posts })
return
post = Post.get_by_path(path)
if post:
p = gdict.get("p", None)
p = int(p) if p and p.isdigit() else 1
def post_comment_filter(query):
query = query.filter("belong =", post)
if config.COMMENT_NEEDLOGINED:
query = query.filter("hashcheck =", True)
query = query.order("date_created")
return query
post_comments = Comment.fetch_page(p, config.COMMENT_PAGE_COUNT, func=post_comment_filter, realtime_count=True)
context = {"post": post,
"post_comments": post_comments, }
self.render("single.html", context)
return
def new_post(community_name):
community = Community.query.filter_by(
community_name=community_name).first()
members_count = CommunityMembers.query.filter_by(
community_id=community.id).count()
form = PostForm()
if form.validate_on_submit():
# Put data into our database here
if form.picture.data:
picture_file = save_picture(form.picture.data)
#Upload Picture to Cloudinary
# cloudinary.uploader.upload("./static/images/" + picture_file)
cloudinary_response = cloudinary.uploader.upload(
"./static/images/" + picture_file)
print(cloudinary_response)
print(dir(cloudinary_response))
print(cloudinary_response['public_id'])
cloudinary_url = cloudinary_prefix + str(
cloudinary_response['version']) + "/" + str(
cloudinary_response['public_id']) + "." + str(
cloudinary_response['format'])
print('Sassy' * 100)
print(cloudinary_url)
#cloudinary_response.public_idj example to get items
post = Post(user_id=current_user.id,
community_id=community.id,
title=form.title.data,
body=form.content.data,
image_url=picture_file,
cloud_version=cloudinary_response['version'],
cloud_public_id=cloudinary_response['public_id'],
cloud_format=cloudinary_response['format'],
cloudinary_url=cloudinary_url)
db.session.add(post)
db.session.commit()
flash('Your post has been created!', 'success')
# How to route user back to the community's page efficiently?
return redirect('/k/' + community_name)
else:
post = Post(user_id=current_user.id,
community_id=community.id,
title=form.title.data,
body=form.content.data)
db.session.add(post)
db.session.commit()
flash('Your post has been created!', 'success')
# How to route user back to the community's page efficiently?
return redirect('/k/' + community_name)
return render_template('create_post.html',
form=form,
community=community,
legend='New Post',
members_count=members_count)
def get(self):
args = parser.parse_args()
user_id = -1 if args['user_id'] is None else args['user_id']
posts = Post.fetch_all(user_id)
if len(posts) > 0:
for post in posts:
post['topics'] = Post.fetch_topics(post['post_id'])
return posts
def post():
user = islogin()
if user:
content = bottle.request.POST['content']
Post.create(user, content)
bottle.redirect('/')
else:
bottle.redirect('/signup')
def get(self, *post_id):
self.response.headers['Content-Type'] = 'application/json; charset=UTF-8'
if post_id:
post = Post.get_by_id(int(post_id[0]))
self.write(json.dumps(post.to_dict()))
else:
posts_query = Post.all().order('-created')
posts = posts_query.fetch(10)
self.write(json.dumps([p.to_dict() for p in posts]))
def post(self, subdomain, lense=None):
if self.request.headers['Content-type'] == 'application/json':
post = Post(**json.loads(self.request.body))
post.prefix = self.request.uri
post.author = self.current_user
post.save(db=self.db)
self.set_header('Location', post.url)
self.set_status(201)
else:
self.send_error(500)
def get(self):
self.user()
(forum, siteroot, tmpldir) = forum_siteroot_tmpldir_from_url(self.request.path_info)
if not forum or forum.is_disabled:
return self.redirect("/")
forum.title_or_url = forum.title or forum.url
topic_id = self.request.get('id')
if not topic_id:
return self.redirect(siteroot)
topic = db.get(db.Key.from_path('Topic', int(topic_id)))
if not topic:
return self.redirect(siteroot)
# is_moderator = users.is_current_user_admin()
is_moderator = False
if topic.is_deleted and not is_moderator:
return self.redirect(siteroot)
is_archived = False
# Note: auto-archiving disabled
#now = datetime.datetime.now()
#week = datetime.timedelta(days=7)
#week = datetime.timedelta(seconds=7)
#if now > topic.created_on + week:
# is_archived = True
# 200 is more than generous
MAX_POSTS = 200
if is_moderator:
posts = Post.gql("WHERE forum = :1 AND topic = :2 ORDER BY created_on", forum, topic).fetch(MAX_POSTS)
else:
posts = Post.gql("WHERE forum = :1 AND topic = :2 AND is_deleted = False ORDER BY created_on", forum, topic).fetch(MAX_POSTS)
if is_moderator:
for p in posts:
if 0 != p.user_ip:
p.user_ip_str = long2ip(p.user_ip)
if p.user_homepage:
p.user_homepage = sanitize_homepage(p.user_homepage)
tvals = {
'role': self.role,
'username': self.username,
'siteroot' : siteroot,
'forum' : forum,
'analytics_code' : forum.analytics_code or "",
'topic' : topic,
'is_moderator' : is_moderator,
'is_archived' : is_archived,
'posts' : posts
}
tmpl = os.path.join("templates/topic.html")
self.template_out(tmpl, tvals)
def post_add():
if request.method == "POST":
post = Post(request.form["author"], request.form["title"], request.form["content"], request.form["published"])
post_add = post.add(post)
if not post_add:
flash("Add was successful")
return redirect(url_for("post_index"))
else:
error = post_add
flash(error)
return render_template("add.html")
def get(name=None):
if name == None:
posts = Post.all()
posts.order('-date_create')
return render_template('index.html', posts=posts)
else:
try:
post = Post.all().filter('url', name).get()
return render_template('read_post.html', post=post)
except:
abort(404)
def post_add():
if request.method == 'POST':
post = Post(request.form['author'], request.form['title'], request.form['content'], request.form['published'])
post_add = post.add(post)
if not post_add:
flash("Add was successful")
return redirect(url_for('post_index'))
else:
error = post_add
flash(error)
return render_template('add.html')
def get(name=None):
if name == None:
posts = Post.all()
posts.order('-date_create')
return render_template('index.html', posts=posts)
else:
try:
post = Post.all().filter('url', name).get()
return render_template('read_post.html', post=post)
except:
abort(404)
def post():
"""
post handler, add a new post to db
"""
zid = session['zid']
if not zid:
return redirect(url_for('login'))
message = request.form.get('post')
new_post = Post(zid=zid, message=message)
new_post.save()
flash('Success: you have post a new psot.')
return redirect(url_for('home'))
def load(self):
import os
from model import Post
posts_dir = os.path.join(self.dir, 'posts')
for name in os.listdir(posts_dir):
path = os.path.join(posts_dir, name)
post = Post(path)
if post.is_draft():
self.draft_posts.append(post)
else:
self.posts.append(post)
self.loaded = True
def add_entry():
if not session.get('logged_in'):
abort(401)
entry = Post(request.form['title'], request.form['text'], session['user_id'], datetime.now())
if request.files['picture']:
entry.set_image(request.files['picture'])
db.session.add(entry)
db.session.commit()
flash('New entry was successfully posted')
return redirect(url_for('show_entries'))
def post(self):
user = self.getAuthentificatedUser()
if not user:
return
try:
id = int(self.request.get('id'))
topic = Topic().get(db.Key.from_path('Topic', id))
preview = self.request.get('preview', None)
if preview is not None:
forum = self.getForumInstance()
postmarkup = create(use_pygments=False)
body = strip_ml_tags(self.request.get('body'))
body2 = postmarkup(body)
template_values = {
'url' : users.CreateLogoutURL(self.request.uri),
'user' : user,
'forum' : forum,
'topic' : topic,
'body' : body,
'body2' : body2,
'page' : 100
}
path = os.path.join(os.path.dirname(__file__), os.path.join('templates', 'previewPost.htm'))
self.response.out.write(template.render(path, template_values))
return
except:
self.redirect('/')
return
post = Post() #parent=topic.key()
post.topic = topic
if users.get_current_user():
post.author = users.get_current_user()
body = db.Text(strip_ml_tags(self.request.get('body')))
postmarkup = create(use_pygments=False)
post.body = postmarkup(body)
# replace('\n','<br />')
if post.body != '':
post.put()
# index it!
ix = getdatastoreindex("post_"+str(post.key().id()), schema=SEARCHSCHEMA)
writer = ix.writer()
writer.add_document(body=u"%s" % post.body)
writer.commit()
# end index
mailAdditionalText = """ ... testing e-mail notification. Sorry if you get this message accidently."""
post.sendMailToAll(user.email(), mailAdditionalText)
#####
#message = mail.EmailMessage(sender=user.email(), subject="New message in small-forum")
#message.to = "log1 (sms) <*****@*****.**>"
#message.body = post.body
#message.send()
#####
# To Do
if self.request.get('page'):
self.redirect('/view?id=' + str(self.request.get('id')) + '&page=' + self.request.get('page'))
else:
self.redirect('/view?id=' + str(self.request.get('id')))
def test_post_tag(self):
t1 = Tag(name='iot')
t2 = Tag(name='web')
p1 = Post(content='This is a post contain iot and web tags.')
p2 = Post(content='This is a post contain web.')
p1.add_all_tags([t1, t2])
p2.tags.append(t2)
self.session.add_all([t1, t2, p1, p2])
self.session.commit()
self.assertCountEqual(t1.posts, [p1])
self.assertCountEqual(t2.posts, [p1, p2])
self.assertCountEqual(p1.tags, [t1, t2])
self.assertCountEqual(p2.tags, [t2])
def save(self): """Método responsável em salvar post no bigtable.""" if self.model: self.model.title = self.title.data self.model.text = self.text.data self.model.tags = self.set_tags(self.tags.data) else: self.model = Post( title = self.title.data, text = self.text.data, tags = self.set_tags(self.tags.data) ) self.model.put() return self.model
def get(self, category, page=1):
page = int(page)
category = category[:-1]
count, data = Post.get_post(page=page, pagesize=blogconfig['pagesize'], category=category)
self.datamap['recent'] = Post.get_recent_post()
self.datamap['count'] = count
self.datamap['data'] = data
self.datamap['pageurl'] = 'category'
self.datamap['page'] = page
self.datamap['pagecount'] = int(math.ceil(float(count) / blogconfig['pagesize']))
rtn = render.blog_index(self.datamap)
self.write(rtn)
return rtn
def post(self):
subject = self.request.get("subject")
content = self.request.get("content")
if subject and content:
post = Post(subject = subject, content = content)
post.put()
memcache.set('time', time.time())
post_id = post.key().id()
self.redirect("/%i" % post_id)
else:
error = "both subject and content required to post"
self.render_page(error = error, subject = subject, content = content)
def postdeal():
openid = request.forms.getunicode('openid')
title = request.forms.getunicode('title')
content = request.forms.getunicode('content')
faceimage = request.forms.getunicode('faceimage')
location = request.forms.getunicode('location')
data={
'title':title,
'content':content,
'faceimage':faceimage,
'location':json.loads(location),
}
user = User.find_by_id(openid)
Post.create(user,data)
return dict(res="server post deal succ")
class PostForm(Form):
title = TextField('Titulo:', [
validators.Length(min=5, max=60, message="O Titulo deve ter entre 5 a 60 caracteres.")
])
text = TextAreaField('Texto:', [
validators.Length(min=5, message="O Texto deve ter no minimo 5 caracteres.")
])
tags = TextField('Tags:',[
validators.required(message="Informe uma tag.")
])
def __init__(self, model_instance = None, *args, **kwargs):
"""Método construtor da classe, preenche model ao criar form."""
kwargs['csrf_enabled'] = False
super(PostForm, self).__init__(*args, **kwargs)
self.model = None
if model_instance:
self.title.data = model_instance.title
self.text.data = model_instance.text
self.tags.data = self.get_tags( model_instance.tags )
self.model = model_instance
def save(self):
"""Método responsável em salvar post no bigtable."""
if self.model:
self.model.title = self.title.data
self.model.text = self.text.data
self.model.tags = self.set_tags(self.tags.data)
else:
self.model = Post(
title = self.title.data,
text = self.text.data,
tags = self.set_tags(self.tags.data)
)
self.model.put()
return self.model
def get_tags(self, tags):
"""Metodo que recupera valor do atributo tags."""
tstr = ""
for tag in tags:
tstr += "%s," % tag
return tstr[:-1]
def set_tags(self, tags):
"""Método que define valor para o atributo tags."""
tag = TagCategory()
return tag.string_to_category( tags )
def run(self):
if not self.options.file:
raise Exception("Missing an argument")
print "File name:", self.options.file
existing = Post.by_file(self.options.file)
if existing:
content = open(self.options.file).read()
# validate that it's markdown
md = markdown.Markdown(extensions=['meta', 'codehilite'])
md.convert(content)
existing.markdown_content = content
st = os.stat(self.options.file)
existing.time_modified = datetime.datetime.fromtimestamp(st[stat.ST_MTIME])
meta.session.add(existing)
meta.session.commit()
print "updated blog post %s" % existing
else:
post = Post(self.options.file)
meta.session.add(post)
meta.session.commit()
print "Added blog post %s" % meta.session.query(Post).filter(Post.id == post.id).all()
def post(self, postId):
post = Post.get_post_by_id(postId)
if not post or post.status != 0 or post.commentstatus == 1:
self.write('抱歉，评论功能已关闭。')
else:
username = self.get_argument('username', '')
email = self.get_argument('email', '')
content = self.get_argument('comment', '')
parentid = int(self.get_argument('parentid', 0))
if self.islogin:
curr_user_info = self.get_current_user_info
username = curr_user_info.username
email = curr_user_info.email
if username == '' or content == '' or not isemail(email):
self.flash(u'错误:称呼、电子邮件与内容是必填项')
self.redirect(post.url + '#comments')
return
username = username[:20]
content = content[:512]
if not self.islogin:
is_spam = spam_check(content, self.request.remote_ip)
else:
is_spam = 0
if is_spam:
self.flash(u'sorry,your comment is not posted')
self.redirect(post.url+'#comments')
location = get_location_byip(self.request.remote_ip)
Comment.post_comment(postid=postId, username=username, email=email, content=content, parentid=parentid,
ip=self.request.remote_ip, isspam=is_spam, location=location)
if is_spam:
self.flash(u'您的评论可能会被认定为Spam')
self.set_comment_user(username, email)
self.redirect(post.url + '#comments')
def parse_entry(self, feed_data, entry):
"""Turn an entry into a Post."""
id = entry['id']
post, is_new = Post.for_external_key(self, id)
if is_new:
post.content = self.TWEET_TEMPLATE % entry
return post
def index():
## get the last date the webscraper was run
for post in Post.objects().fields(
date_str=1).order_by('-date_str').limit(1):
day_to_pull = post.date_str
return render_template('index.html', Post=Post, day_to_pull=day_to_pull)
def load_posts():
"""Load users from posts.txt into database."""
print("Posts")
for i, row in enumerate(open("seed_data/posts.txt")):
row = row.rstrip()
post_id, account, shortcode, location_name, slug, lat, lng, viewport_ne_lat, viewport_ne_lng, viewport_sw_lat, viewport_sw_lng, formatted_address, maps_name, rating, place_id = row.split(
"|")
post = Post(post_id=post_id,
account=account,
shortcode=shortcode,
location_name=location_name,
slug=slug,
lat=lat,
lng=lng,
viewport_ne_lat=viewport_ne_lat,
viewport_ne_lng=viewport_ne_lng,
viewport_sw_lat=viewport_sw_lat,
viewport_sw_lng=viewport_sw_lng,
formatted_address=formatted_address,
maps_name=maps_name,
rating=rating,
place_id=place_id)
db.session.add(post)
# provide some sense of progress
if i % 100 == 0:
print(i)
db.session.commit()
def _to_post_list(self, obj):
"""Take the output of a post generation process and make
sure it becomes a list of Posts.
"""
def is_list_of_posts(posts):
return (
isinstance(posts, list) and
all(isinstance(i, Post) for i in posts)
)
if isinstance(obj, Post):
# It's already a Post.
return [obj]
if is_list_of_posts(obj):
# It's already a list of Posts.
return obj
posts = self.object_to_post(obj)
if isinstance(posts, basestring):
post, is_new = Post.from_content(
self.model, posts, reuse_existing=self.duplicate_filter
)
return [post]
if isinstance(posts, Post):
return [posts]
if is_list_of_posts(posts):
# It's already a list of Posts.
return posts
raise InvalidPost(
"object_to_post must return a Post or a list containing only Posts. (got %r)" % posts
)
def search(action=None):
"""
search handler,
if query for user, then return all users contain the query
if query for post, then return all posts contain the query
"""
zid = session['zid']
user = User.findByKey(zid)
page = int(request.args.get('page', '1'))
total = len(user.mateSuggestions())
pag = Pagination(page, total)
if not action:
action = request.args.get('action')
if action == 'user':
query = request.args.get('query', '')
if "'" not in query:
users = User.findByName(query)
else:
users = []
flash('Failed: query contains illegal character.')
total = len(users)
pag = Pagination(page, total)
return render_template('search.html', user=user, users=users, query=query, pag=pag)
if action == 'post':
query = request.args.get('query', '')
if "'" not in query:
posts = Post.findPosts('message', query)
else:
posts = []
flash('Failed: query contains illegal character.')
total = len(posts)
pag = Pagination(page, total)
return render_template('search.html', user=user, posts=posts, query=query, pag=pag)
return render_template('search.html', user=user, pag=pag)
def user_comments(userid):
try:
user = User.objects(pk=userid).first()
commentLst = []
posts = Post.objects(comments__user=user)
for post in posts:
comments = post.comments
for comment in comments:
if comment.user.id == user.id:
obj = {
"content": comment.content,
"created":
comment.created.strftime("%Y-%m-%d %H:%M:%S"),
"user": {
"id": str(comment.user.id),
"nickname": comment.user.username
}
}
commentLst.append(obj)
except:
pass
return jsonify(commentLst)
def comment():
"""
comment handler, add a new comment to DB
give a new notification to post poster
and send a validate email
"""
zid = session['zid']
user = User.findByKey(zid)
if not user:
return redirect(url_for('login'))
pid = request.form.get('pid')
poster_zid = request.form.get('poster_zid')
m_user = User.findByKey(poster_zid)
message = request.form.get('message')
new_comment = Comment(pid=pid, zid=zid, message=message)
new_comment.save()
flash('Success: you have post a new comment.')
notification = Notifications(from_zid=user.zid, to_zid=poster_zid, noti_type='reply', from_name=user.full_name, from_img=user.image, pid=pid)
# notification.pid = pid
notification.save()
mail = MailUtils('*****@*****.**', 'MateLook Team', m_user.full_name)
mail.notificaion()
post = Post.findByKey(pid)
poster = User.findByKey(post.zid)
page = int(request.args.get('page', '1'))
total = len(post.getComments())
pag = Pagination(page, total)
return redirect(url_for('postlook', pid=pid, page=page))
def posts_update(userid, pid):
print(userid)
try:
post = Post.objects(pk=pid).first()
if not post:
raise ValidationError
coverLst = post.covers
coverLst.clear()
for cover_obj in request.json.get('cover'):
cover = Cover.objects(pk=cover_obj['uid']).first()
coverLst.append(cover)
post.categories.clear()
for category_id in request.json.get('categories'):
cate = Category.objects(pk=category_id).first()
post.categories.append(cate)
post.title = request.json.get('title')
post.content = request.json.get('content')
post.type = request.json.get('type')
post.save()
except:
return jsonify({'message': 'post not found'})
return jsonify(post.to_public_json())
def get_comments(userid, id):
try:
post = Post.objects(pk=id).first()
except ValidationError:
return jsonify({"error": "Post not found"}), 404
if not request.args.get('pageSize'):
pageSize = len(post.comments)
else:
pageSize = int(request.args.get('pageSize'))
commentLst = []
for comment in post.comments[::-1]:
commentLst.append({
"content":
comment.content,
"created":
comment.created.strftime("%Y-%m-%d %H:%M:%S"),
"user": {
"id": str(comment.user.id),
"nickname": comment.user.username
}
})
pageSize -= 1
if pageSize == 0:
break
return jsonify(commentLst)
def posts_detail(userid, id):
try:
post = Post.objects(pk=id).first()
# If post has alreay been deleted
if not post:
raise ValidationError
user = User.objects(pk=userid).first()
user_collect = post.user_collect
usernameLst = [u.username for u in user_collect]
if user.username in usernameLst:
post.has_star = True
else:
post.has_star = False
user_agree = post.user_agree
usernameLst = [u.username for u in user_agree]
if user.username in usernameLst:
post.has_like = True
else:
post.has_like = False
if post.user in user.user_followed:
post.has_follow = True
else:
post.has_follow = False
except ValidationError:
return jsonify({"error": "Post not found"}), 404
return jsonify(post.to_public_json())
def add_post_post():
post = Post(title=request.form["title"],
content=mistune.markdown(request.form["content"]),
author=current_user)
session.add(post)
session.commit()
return redirect(url_for("posts"))
def main():
client = Client(OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
max_id = Post.get_max_id()
for post in client.get_posts(max_id):
post = post_factory(post)
if post:
post.save()
def new_post():
"""
New post page
"""
user_id = login_session["user_id"]
if request.method == "GET":
return render_template("new_post.html",
user=user_id,
catalogs=CATALOGS)
else:
if ((not request.form["title"]) or (not request.form["body"])
or (not request.form["catalog"])):
return render_template("new_post.html",
catalogs=CATALOGS,
error="missing")
new_post = Post(title=request.form["title"],
body=request.form["body"],
catalog=request.form["catalog"],
author=user_id)
session.add(new_post)
session.commit()
post = session.query(Post).order_by(Post.create_at.desc()).first()
return redirect(url_for("post_detail", post_id=post.id))
def post(self, postId):
title = self.get_argument('title', '')
content = self.get_argument('content', '', strip=False)
status = self.get_argument('status', 0)
tag = self.get_arguments('tag', [])
category = self.get_arguments('category', [])
input_category = self.get_argument('input_category', '')
input_tag = self.get_argument('input_tag', '')
posttype = self.get_argument('posttype', 0)
alias = self.get_argument('alias', '')
tag = list(set(tag + input_tag.split(',')))
category = list(set(category + input_category.split(',')))
commentstatus = self.get_argument('commentstatus', 0)
password = self.get_argument('password', '')
if title == '' or content == '':
self.datamap['message'] = u'标题与内容不能为空'
else:
rtn = Post.edit_post(id=postId, title=title, content=content, status=status, commentstatus=commentstatus,
password=password, tag=tag, category=category, posttype=posttype, alias=alias)
if rtn:
self.flash(u'修改成功')
else:
self.flash(u'修改失败')
self.redirect('/admin/post/edit/' + postId + '/')
def get(self):
forum = Forum.from_url(self.request.path_info)
user = users.get_current_user()
is_admin = users.is_current_user_admin()
if not forum or (forum.is_disabled and not is_admin):
return self.redirect("/")
if not is_admin and not self.settings.check_ip(self.request.remote_addr):
return self.response.out.write('Your IP address has been banned')
if not is_admin and not self.settings.check_user( user ):
return self.redirect( users.create_login_url("/") )
offset, topics = Topic.getlist(forum, is_admin=is_admin, offset=self.request.get("from") or None)
for topic in topics:
topic.excerpt = Post.gql("WHERE topic = :1 ORDER BY created_on", topic)[0].get_excerpt()
tvals = {
'user': user,
'analytics_code': forum.analytics_code or "",
'siteurl': self.request.url,
'isadmin': is_admin,
'forum' : forum,
'forum_urls': [f.url for f in Forum.all()],
'topics': topics,
'offset': offset,
'login_url': users.create_login_url(forum.root()),
'logout_url': users.create_logout_url(forum.root())
}
self.template_out("skins/default/topic_list.html", tvals)
def index():
form = PostForm()
if current_user.can(Permission.WRITE_ARTICLES) and \
form.validate_on_submit():
post = Post(body=form.body.data,
author=current_user._get_current_object())
db.session.add(post)
return redirect(url_for('.index'))
page = request.args.get('page', 1, type=int)
show_followed = False
if current_user.is_authenticated:
show_followed = bool(request.cookies.get('show_followed', ''))
if show_followed:
query = current_user.followed_posts
else:
query = Post.query
pagination = query.order_by(Post.timestamp.desc()).paginate(
page,
per_page=current_app.config['FLASKY_POSTS_PER_PAGE'],
error_out=False)
posts = pagination.items
return render_template('index.html',
form=form,
posts=posts,
show_followed=show_followed,
pagination=pagination)
def get(self):
(forum, siteroot, tmpldir) = forum_siteroot_tmpldir_from_url(self.request.path_info)
if not forum or forum.is_disabled:
return self.error(HTTP_NOT_FOUND)
feed = feedgenerator.Atom1Feed(
title = forum.title or forum.url,
link = my_hostname() + siteroot + "rssall",
description = forum.tagline)
posts = Post.gql("WHERE forum = :1 AND is_deleted = False ORDER BY created_on DESC", forum).fetch(25)
for post in posts:
topic = post.topic
title = topic.subject
link = my_hostname() + siteroot + "topic?id=" + str(topic.key().id())
msg = post.message
# TODO: a hack: using a full template to format message body.
# There must be a way to do it using straight django APIs
name = post.user_name
if name:
t = Template("<strong>{{ name }}</strong>: {{ msg|striptags|escape|urlize|linebreaksbr }}")
else:
t = Template("{{ msg|striptags|escape|urlize|linebreaksbr }}")
c = Context({"msg": msg, "name" : name})
description = t.render(c)
pubdate = post.created_on
feed.add_item(title=title, link=link, description=description, pubdate=pubdate)
feedtxt = feed.writeString('utf-8')
self.response.headers['Content-Type'] = 'text/xml'
self.response.out.write(feedtxt)
def get(self):
page = int(self.get_argument('page', '1'))
key = self.get_argument('key', '')
act = self.get_argument('act', '')
if act == 'delete':
Post.delete_post_by_id(int(self.get_argument('id', 0)))
pagesize = 20
count, blogs = Post.get_post(page=page, pagesize=pagesize, showall=True, keyword=key, onlypost=False)
for x in blogs:
x.length = len(x.content)
self.datamap['count'] = count
self.datamap['posts'] = blogs
self.datamap['page'] = int(page)
self.datamap['pagecount'] = int(math.ceil(float(count) / pagesize))
self.write(render_admin.post(self.datamap))
def status(name,id):
post = Post.find_by_id(id)
if post:
if post.user.username == name:
return bottle.template('single',username=post.user.username,tweet=post,page='single',logged=user_is_logged())
return bottle.HTTPError(code=404,message='tweet not found')
def post(self, post_id):
post_id = int(post_id)
post = Post.id(post_id)
if not post:
#TODO 404
return
pdict = self.request.POST
nickname = pdict.get("author")
email = pdict.get("email")
website = pdict.get("url")
comment = pdict.get("comment")
logging.info(website)
#def new(cls, belong, nickname, email, author=None, re=None, ip=None, website=None, hascheck=True, commenttype=CommentType.COMMENT):
try:
c = Comment.new(belong=post,
nickname=nickname,
email=email,
website=website,
content=comment,
ip=self.request.client_ip)
except Exception, ex:
logging.info(traceback.format_exc())
def askpage(subject, obj, hashkey):
post = Post.get_by_key_name(subject + '||' + obj)
if post == None:
return 'We do not know that!', 404
if post.hashkey != hashkey:
return 'You are not authorized'
return render_template('index.html', sgender='female',
ogender='male', initmethod='EditPost', post=post, title=getTitle(post))
def get(self, alias):
post = Post.by_alias(unicode(alias))
if not post:
raise web.HTTPError(404)
header = self.load_header()
self.render('post.thtml', header=header, items=[post])
def get(self,PostID):
post = Post.get_by_id(int(PostID))
tags_commas = post.tags_commas
template_values = {
'post': post,
'tags_commas': tags_commas,
}
self.generate('../templates/edit.html', template_values)
def get(self):
p = self.GET.get("p")
p = int(p) if p and p.isdigit() else 1
pager = Post.fetch_page(p, func=INDEXPOSTFILTER)
context = {"pager": pager}
self.render("index.html", context)
def get(self):
p = self.GET.get("p")
p = int(p) if p and p.isdigit() else 1
pager = Post.fetch_page(p, func=ADMINPOSTFILTER)
context = {"page_name": u"文章管理",
"page_title": u"文章管理",
"pager": pager }
self.render("admin_post.html", context)
def get(self):
count, data = Post.get_post(page=1, pagesize=15)
self.datamap['rss'] = data
self.set_header('Content-Type', 'application/xml;charset=utf-8')
import common
rtn = render.rss(self.datamap)
self.write(rtn)
return rtn
def delete_post(id):
"""Método responsável em remover um post do blog."""
post = Post.get_by_id(id)
if post:
post.delete()
flash("Post foi removido com sucesso.")
else:
flash("Erro ao tentar remover post.")
return redirect(url_for('get'))
