def store():
# Create new post
post = Post(request.form['message'])
# Commit new post to db
post.save()
# Respond with completed post object
return json.dumps(post.json)
def create_post(self, content):
from app.posts.models import Post
try:
Post.create(
user=self,
content=content
)
return "Posted!"
except:
return "There was an error posting your post."
def new():
form = NewPostForm()
post = Post()
if form.validate_on_submit():
form.populate_obj(post)
db.session.add(post)
db.session.commit()
posts = Post.nearby_posts(post.lat, post.long, POST_DISTANCE_THRESHOLD)
return jsonify(result=[{'long': str(p.long), 'lat': str(p.lat), 'secret': p.secret, 'created': str(p.created_time)} for p in posts]), 200
return jsonify(result={'error': 'invalid form.'})
def add_comment():
form = CommentForm()
if form.validate_on_submit():
post = Post.objects(id=form.post_id.data).get()
comment = Comment(text=form.comment_text.data,
from_user=User.objects(id=current_user.id).get(),
post=post)
comment.save()
Post.objects(id=form.post_id.data).update_one(push__comments=comment)
return redirect(get_redirect_target())
def index():
form = PostForm()
if form.validate_on_submit():
post = Post(author=current_user, body=form.body.data)
post.commit()
# Reload the page to avoid resubmit.
return redirect(url_for('users.index'))
posts = Post.query\
.filter_by(author=current_user, active=True)\
.order_by(Post.created.desc())\
.all()
return render_template('users/index.jinja', form=form, posts=posts)
def add_post_proc():
form = PostAddForm()
#if form.validate_on_submit():
user = User.objects(id=current_user.id).get()
post = Post(
title=form.title.data,
tag=form.tag.data,
text=form.text.data,
urls=form.url.data.split(),
user=user,
)
post.save()
flash('Add post')
return redirect(url_for("posts.index")) #redirect(get_redirect_target())
def get_posts(self, number=10, offset=0):
from app.posts.models import Post, Comment
friends = self.get_friends()
print(friends)
query = Post.select().join(User).where(
(User.id << friends + [self.id])
).order_by(Post.timestamp.desc()).limit(number).offset(offset)
posts = []
for post in query:
print("POST ID {} POSTED BY {} IS FRIEND {}".format(post.id, post.user.username, post.user in friends))
data = [post.user.username, post.timestamp.strftime("%H:%M %d/%m/%y"), post.content]
comment_query = Comment.select().where(Comment.post == post).order_by(Comment.timestamp.asc())
comments = []
for comment in comment_query:
print(comment.__dict__)
commenter = User.get(User.id == comment.user)
comment_data = [commenter.username, comment.timestamp.strftime("%H:%M %d/%m/%y"), comment.content]
comments.append(comment_data)
data.append(comments)
data.append(post.id)
if post.user == self:
data.append(True)
else:
data.append(False)
data.append(h.handle(post.content))
posts.append(data)
return posts
def search_posts(
self, field=None, field_type=ID, start_time=None,
start_post=0, num_posts=0, direction=ASCENDING):
'''
Searches database for posts that meet parameters
:id: int
:return: [Post, Post, ...]
'''
search = {}
if field:
if field_type is ID:
try:
search[field_type] = ObjectId(field)
except InvalidId:
return None
else:
search[field_type] = field
if start_time != None:
search[TIME] = {'$lte': start_time}
query = self._collection.find(search) \
.sort(field_type, direction) \
.skip(start_post) \
.limit(num_posts)
posts = []
for item in query:
post_data = generate_post_data(item)
posts.append(Post(**post_data))
return posts
def dispatch_request(self):
form = PostForm()
username = session['active_user']['username']
author = db_user(username=username)
posts = db_posts(author=author)
if request.method == 'POST':
if form.validate_on_submit():
title = form.title.data
content = form.content.data
tag = form.tag.data
try:
new_post = Post(author=author,
title=title,
content=content,
tag=tag)
db.session.add(new_post)
db.session.commit()
flash('Your post is successfully submitted', 'success')
return redirect(url_for(request.endpoint))
except Exception as e:
flash('Invalid inputs.', 'error')
return redirect(url_for(request.endpoint))
return render_template('admin.html',
username=username,
form=form,
posts=posts)
def view_tag(tag):
title = f"Tag: {tag}"
search = False
q = request.args.get('q')
if q:
search = True
page = request.args.get(get_page_parameter(), type=int, default=1)
posts_list = Post.objects(tag=tag).paginate(page=page, per_page=10)
pagination = Pagination(page=page,
total=Post.objects(tag=tag).count(),
css_framework='bootstrap4',
search=search,
record_name='posts')
return render_template('posts/tag_page.html',
page_title=title,
posts_list=posts_list,
pagination=pagination)
def setUpTestData(cls):
socialmedia = SocialMedia(socialmedia="linkedin")
socialmedia.save()
author = User.objects.create_user(
username="******",
email="*****@*****.**",
password="******",
)
author.save()
post = Post(
body="Mon post de test",
author=author,
schedule_time="2021-09-07 09:23",
)
post.save()
print(post.id)
post.socialmedia.add(socialmedia.id)
def single_post(post_id):
my_post = Post.objects(id=post_id).get()
if not my_post:
abort(404)
form = CommentForm(post_id=post_id)
return render_template('posts/single_post.html',
page_title=my_post.title,
post=my_post,
comment_form=form)
def edit_post_proc(post_id):
form = PostAddForm()
post = Post.objects(id=post_id).get()
post.title = form.title.data
post.tag = form.tag.data
post.text = form.text.data
post.urls = form.url.data.split()
post.save()
flash('Edited post')
return redirect(url_for("posts.index"))
def user_profile(user_id):
title = "User profile"
search = False
q = request.args.get('q')
if q:
search = True
page = request.args.get(get_page_parameter(), type=int, default=1)
user_id = user_id
user_posts = Post.objects(user=user_id).order_by("-posted").paginate(
page=page, per_page=10)
pagination = Pagination(page=page,
total=Post.objects(user=user_id).count(),
css_framework='bootstrap4',
search=search,
record_name='posts')
return render_template('user/user_profile.html',
title=title,
posts_list=user_posts,
pagination=pagination)
def delete_post(self, post_id):
from app.posts.models import Post
try:
post = Post.get(Post.id == post_id)
if self.owns_post(post):
post.delete_instance()
return "Done"
return "You do not have correct permissions."
except:
return "Error"
def execute(self, user_id: int, caption: str) -> Union[Post, NoReturn]:
post = Post(user_id=user_id, caption=caption)
try:
session.add(post)
session.commit()
except IntegrityError as e:
session.rollback()
raise CustomException(str(e), code=500)
return post
def posts_view(username=None, page=1):
user = db.session.query(User).filter_by(name=username).first()
if user is None:
return render_template('404.html'), 404
posts = user.posts.order_by(desc(Post.created_at)).paginate(page, POSTS_PER_PAGE, False)
form = None
if current_user == user:
form = SubmitPostForm(request.form)
if form.validate_on_submit():
post = Post()
form.populate_obj(post)
post.user_id = current_user.id
db.session.add(post)
db.session.commit()
return redirect('/flitter/user/' + username)
return render_template('posts/index.html', form=form, posts=posts, username=user.name)
def edit_post(self, post_id, content):
from app.posts.models import Post
try:
post = Post.get(Post.id == post_id)
if self.owns_post(post):
post.content = content
post.save()
return "Done"
return "Do not have correct permissions."
except:
return "Error"
def add_post(self, post):
'''
Save post to database
:data: Post
:return: Post
'''
self._collection.insert_one(post)
post_data = generate_post_data(post)
new_post = Post(**post_data)
return new_post
def edit_post(post_id):
page_title = 'Edit post:'
post = Post.objects(id=post_id).get()
form = PostAddForm()
form.title.data = post.title
form.url.data = " ".join(post.urls)
form.tag.data = post.tag
form.text.data = post.text
return render_template("posts/edit_post.html",
page_title=page_title,
form=form,
post_id=post_id)
def get_stat(value):
if value == 4:
last_post, count = Post.pagination()
return last_post
elif value == 5:
last_comments, count = Comment.pagination()
return last_comments
elif value == 6:
last_categories, count = Category.pagination()
return last_categories
else:
return 0
def write_posts(login, password, count, owner_id, username):
urls = get_pic_urls(login, password, count, owner_id)
user = User.objects(username=username).get()
posts_value = Post.objects.count()
last_posts_urls = get_last_urls(50)
for url in urls:
if url not in last_posts_urls:
Post(title=f"Post {posts_value}",
urls=[url],
tag='vk',
text='',
user=user).save()
posts_value += 1
def index(page=1):
limit = 5
posts, count = Post.pagination(limit=limit, page=page)
pagination = Pagination(page=page,
per_page=limit,
total=count,
record_name=gettext('posts'),
alignment='right',
bs_version=3)
return render_template("blog/index.html",
title=gettext('Home'),
posts=posts,
pagination=pagination)
def create_post(): # todo: check if only available to admin
form = PostForm()
if form.validate_on_submit():
post = Post(title=form.title.data,
text=form.text.data,
user_id=current_user.id)
db.session.add(post)
db.session.commit()
return redirect(url_for('settings_blueprint.administration'))
return render_template('create_post.html', form=form)
def before_request():
if request.endpoint:
if request.endpoint in ['index', 'show_post', 'search_post', 'show_article', 'show_category']:
g.user_count = User.count()
g.post_count = Post.count()
g.comment_count = Comment.count()
if request.endpoint != 'search_post':
g.searhform = SearchForm()
if 'redirect_to' in session and request.endpoint not in ['static',
'sessions.login',
'sessions.signup',
'sessions.login_comment']:
session.pop('redirect_to', None)
def create_posts(cls):
print "*******************************************"
user = User.get_by_id(1)
if not user is None:
for i in range(1, 51):
print 'creating post # %s' % i
post = Post.create()
post.title = unicode('Title %s' % i)
post.body = unicode('Body %s' % i)
post.user = user
post.save()
print "Created Dummy Posts for %r" % user
print "*******************************************"
user = User.get_by_id(2)
if not user is None:
for i in range(1, 51):
print 'creating post # %s' % i
post = Post.create()
post.title = unicode('Title %s' % i)
post.body = unicode('Body %s' % i)
post.user = user
post.save()
print "Created Dummy Posts for %r" % user
def get_context(self, slug=None):
form_cls = model_form(Post, exclude=('created_at', 'comments'))
if slug:
post = Post.objects.get_or_404(slug=slug)
if request.method == 'POST':
form = form_cls(request.form, inital=post._data)
else:
form = form_cls(obj=post)
else:
post = Post()
form = form_cls(request.form)
context = {"post": post, "form": form, "create": slug is None}
return context
def add_post():
form = PostForm()
if form.validate_on_submit():
post = Post(title=form.title.data,
subtitle=form.subtitle.data,
content=form.content.data,
author=current_user)
db.session.add(post)
db.session.commit()
flash('Post has been created!', 'success')
return redirect(url_for('posts.home'))
return render_template('add_post.html',
form=form,
form_title="Add a new post")
def write_to_db():
posts = take_posts()
user = User.objects(username='******').get()
last_posts_urls = get_last_urls(50)
posts_value = Post.objects.count()
for post in posts:
data = get_data(post)
if data.get('img') is None:
continue
if data.get('img') not in last_posts_urls:
Post(title=f"Post {posts_value}",
urls=[data.get('img')],
tag='vk2',
text=data.get('text'),
user=user).save()
posts_value += 1
def post_editor():
form = PostingForm()
if form.validate_on_submit():
title = form.title.data
subtitle = form.subtitle.data
content = form.content.data
new_post = Post(title=title,
subtitle=subtitle,
content=content,
user_id=current_user.id)
db.session.add(new_post)
db.session.commit()
flash("Post has been created", "success")
return redirect(url_for("posts.home"))
return render_template("post_editor.html", form=form, post=None)
def comment(self, post_id, comment_text):
from app.posts.models import Post, Comment
post = Post.get(Post.id == post_id)
user = User.get(User.id == post.user)
ids = [friend.id for friend in user.get_friends()]
ids.append(user.id)
print(ids)
print(comment_text)
try:
if self.id in ids:
Comment.create(
user=self,
post=post,
content=comment_text
)
return "Commented."
return "You do not have correct permissions"
except:
return "Error commenting."
def reply_comment(post_id, id):
try:
comment = Comment.get_by_id(id)
except:
comment = None
try:
post = Post.get_by_id(post_id)
except:
post = None
if comment is None or post is None:
abort(403)
form = CommentForm()
if request.method == 'POST':
if form.validate_on_submit():
try:
reply = Comment.create()
form.populate_obj(reply)
reply.user = current_user
reply.post = post
reply.reply = comment
reply.save()
flash(gettext('Comment succesfully created'))
return redirect('%s#comment_%s' % (url_for('show_post', id=post.id), reply.id))
except:
flash(gettext('Error while posting the new comment, please retry later'), 'error')
else:
flash(gettext('Invalid submission, please check the message below'), 'error')
return redirect(url_for('show_post', id=post.id))
else:
form = CommentForm()
tmplt = render_template("blog/post_form.js",
comment=comment,
form=form,
postid=post.id)
resp = Response(tmplt, status=200, mimetype='text/javascript')
return resp
def show_post(id):
try:
post = Post.get_by_id(id)
except:
post = None
if post is None:
abort(404)
if request.method == 'POST':
if not current_user.is_authenticated():
abort(401)
form = CommentForm()
if form.validate_on_submit():
try:
comment = Comment.create()
form.populate_obj(comment)
comment.user = current_user
comment.post = post
comment.save()
flash(gettext('Comment succesfully created'))
return redirect('%s#comment_%s' % (url_for('show_article',
cat=post.category.slug,
post=post.slug),
comment.id))
except:
flash(gettext('Error while posting the new comment, please retry later'), 'error')
else:
flash(gettext('Invalid submission, please check the message below'), 'error')
else:
if not current_user.is_authenticated() or post.comments.count() > 50:
form = None
else:
form = CommentForm()
return render_template("blog/post-detail.html",
title=gettext('Post | %(title)s', title=post.title),
post=post,
form=form)
def editpost():
if g.auth is not None and g.auth.role is not USER.ADMIN:
return redirect(url_for('not_found'))
if request.method == 'POST':
try:
form = request.args
title = form.get('title')
pid = form.get('drafts')
dopost = form.get('dopost')
post = Post.query.filter_by(title=title).first()
if post is None:
post = Post.query.filter_by(id=pid).first()
if post is None:
post = Post()
post.user_id = g.user.id
post.title = title
post.textbody = form.get('textbody').encode('u8')
post.htmlbody = form.get('htmlbody').encode('u8')
if dopost == True or dopost == "true":
post.draft = False
post.posted = datetime.datetime.now()
db.session.add(post)
else:
post.title = title
post.textbody = form.get('textbody').encode('u8')
post.htmlbody = form.get('htmlbody').encode('u8')
if dopost == True or dopost == "true":
post.draft = False
post.posted = datetime.datetime.now()
db.session.commit()
return make_response("Post Saved")
except:
print >> sys.stderr, sys.exc_info()
return make_response("Exceptional Error")
pid = request.args.get('pid')
form = PostForm()
form.drafts.choices = [(p.id,p.title) for p in Post.query.filter_by(draft=True).order_by(Post.title).all()]
form.drafts.choices.insert(0,(-1,"New Post"))
return render_template("posts/editpost.html", form=form, user=g.user, admin=g.admin, pid=pid)
def editpost():
if g.auth is not None and g.auth.role is not USER.ADMIN:
return redirect(url_for('not_found'))
if request.method == 'POST':
try:
form = request.args
title = form.get('title')
pid = form.get('drafts')
dopost = form.get('dopost')
post = Post.query.filter_by(title=title).first()
if post is None:
post = Post.query.filter_by(id=pid).first()
if post is None:
post = Post()
post.user_id = g.user.id
post.title = title
post.textbody = form.get('textbody').encode('u8')
post.htmlbody = form.get('htmlbody').encode('u8')
if dopost == True or dopost == "true":
post.draft = False
post.posted = datetime.datetime.now()
db.session.add(post)
else:
post.title = title
post.textbody = form.get('textbody').encode('u8')
post.htmlbody = form.get('htmlbody').encode('u8')
if dopost == True or dopost == "true":
post.draft = False
post.posted = datetime.datetime.now()
db.session.commit()
return make_response("Post Saved")
except:
print >> sys.stderr, sys.exc_info()
return make_response("Exceptional Error")
pid = request.args.get('pid')
form = PostForm()
form.drafts.choices = [
(p.id, p.title)
for p in Post.query.filter_by(draft=True).order_by(Post.title).all()
]
form.drafts.choices.insert(0, (-1, "New Post"))
return render_template("posts/editpost.html",
form=form,
user=g.user,
admin=g.admin,
pid=pid)
from app import create_app
from app.posts.models import Post
from app.user.models import User
flask_app = create_app()
user = User.objects(username="******").get()
for post in Post.objects():
post.user = user
post.save()
print(post.user)
def create_posts(n=10, *, user_id=None, session):
for _ in range(n):
p = Post(content=fake.unique.text(), user_id=user_id)
session.add(p)
session.commit()
def delete_post():
form = DeleteForm()
id_ = form.id_.data
post = Post.objects(id=id_).get()
post.delete()
return redirect(url_for('posts.index'))
def list(lat, long):
posts = Post.nearby_posts(lat, long, POST_DISTANCE_THRESHOLD)
return jsonify(result=[{'long': str(p.long), 'lat': str(p.lat), 'secret': p.secret, 'created': str(p.created_time)} for p in posts]), 200
def get_post():
id = request.form["id"]
post = Post.get_post(id)
post = json.dumps(post)
return post
def get_last_urls(count):
urls = []
for post in Post.objects().order_by("-posted").limit(count):
urls.append(post.urls)
urls = sum(urls, [])
return urls
