def create_posts(members_instances):
post1 = models.Post("Agriculture", "Agriculture is amazing",
members_instances[0].id)
post2 = models.Post("Engineering", "I love engineering",
members_instances[0].id)
post3 = models.Post("Medicine", "Medicine is great",
members_instances[1].id)
post4 = models.Post("Architecture", "Spectacular art",
members_instances[1].id)
post5 = models.Post("Astronomy", "Space is awesome",
members_instances[1].id)
post6 = models.Post("Geology", "Earth is our friend",
members_instances[2].id)
post7 = models.Post("ComputerSci", "Our passion", members_instances[2].id)
post8 = models.Post("Algorithms", "Yeah, more of that",
members_instances[2].id)
post9 = models.Post("Operating Systems", "Ewww", members_instances[2].id)
print(post1)
print(post2)
print(post3)
print("=" * 30)
return post1, post2, post3, post4, post5, post6, post7, post8, post9
def Post(isGET=False, data=dict()):
if isGET:
pt = models.Post.query.get(data['id'])
result = {
"type": 1,
"serialisedData": {
"photo": pt.photo_id,
"text": pt.description,
"author": pt.author_id,
"date": pt.timestamp,
"status": pt.status,
"id": pt.id
}
}
result['serialisedData'] = str(result['serialisedData'])
return result
else:
pt = models.Post(description=data['text'],
status=data['status'],
author_id=data['author'],
photo_id=data['photo'],
squad_id=None)
db.session.add(pt)
db.session.commit()
return str(pt.id)
def index():
form = forms.PostForm()
if form.validate_on_submit():
language = guess_language(form.post.data)
if language == 'UNKNOWN' or len(language) > 5:
language = ''
post = models.Post(body=form.post.data,
author=current_user,
language=language)
db.session.add(post)
db.session.commit()
flash(_('Your post is now live!'))
return redirect(url_for('main.index'))
page = request.args.get('page', 1, type=int)
posts = current_user.followed_posts().paginate(
page, current_app.config['POSTS_PER_PAGE'], False)
next_url = url_for('main.index',
page=posts.next_num) if posts.has_next else None
prev_url = url_for('main.index',
page=posts.prev_num) if posts.has_prev else None
# How is the current_user passed in? Just a global?
return render_template('index.html',
title=_('Home Page'),
form=form,
posts=posts.items,
next_url=next_url,
prev_url=prev_url)
def create_post(self, db: Session, post: PostCreate,
user_id: int) -> models.Post:
new_post = models.Post(**post.dict(), user_id=user_id)
db.add(new_post)
db.commit()
db.refresh(new_post)
return new_post
def test_add_post_data(self):
post = models.Post(title="testqwer", user="******", message="hello")
db.session.add(post)
db.session.commit()
exists = models.Post.query.filter_by(title='testqwer').first()
assert (exists is not None)
def cms_submit():
form = forms.DatabaseForm()
if not form.validate_on_submit():
return render_template('/old-site/blog/cms/new-post.html',
icons=dog_icons(),
form=form)
else:
css_class = get_theme(form.color.data)
title = bleach.clean(form.title.data)
icon = form.icon.data
subtitle = bleach.clean(form.subtitle.data)
content = generate_markdown(form.content.data, True)
date_string = form.hidden_date.data
month = form.month.data
year = form.year.data
post = models.Post(css_class=css_class,
title=title,
icon=icon,
subtitle=subtitle,
date=date_string,
month=month,
content=content,
year=year)
db.session.add(post)
db.session.commit()
flash('Your post titled %s has been added to the database!' % title)
return redirect(url_for('cms'))
def topic_add():
if request.method == "POST":
new_post = models.Post(request.form["title"], request.form["body"])
post_store.add(new_post)
return redirect(url_for("home"))
else:
return render_template("topic_add.html")
def add_topic():
if request.method == 'POST':
new_post = models.Post(title=request.form["title"], content=request.form["content"])
post_store.add(new_post)
return redirect(url_for('home'))
else:
return render_template("add_topic.html")
def new_post():
form = NewPostForm()
if form.validate_on_submit():
p = models.Post(title=form.title.data, \
body=form.body.data, \
slug=slugify(form.title.data), \
description=form.description.data, \
timestamp=datetime.datetime.utcnow(), \
author=g.user)
tagnames = form.tags.data.split(TAG_DELIM)
p.set_tags_str(tagnames)
filename = upload_file(request)
if filename:
p.thumbnail = "/uploads/thumbs/" + filename
else:
p.thumbnail = DEFAULT_THUMB
db.session.add(p)
db.session.commit()
flash(u'New post created successfully.', 'alert-success')
return redirect(url_for("index"))
return render_template("new_post.html", form=form)
def newpost():
form = PostForm()
if 'email' not in session:
return redirect(url_for('signin'))
if request.method == 'POST':
if form.validate() == False:
return render_template('newpost.html', title="New Post", form=form)
else:
cur_user = User.query.filter_by(email=session['email']).first()
link = form.body.data
article = Article(url=link)
article.download()
article.parse()
post_body = article.text[:160] + '...'
post_title = article.title
if len(str(article.top_image)) > 0:
img_addr = str(article.top_image)
else:
img_addr = '/static/userdata/avatar.png'
new = models.Post(title=post_title,
body=post_body,
timestamp=datetime.datetime.utcnow(),
link=link,
image=img_addr,
likes=0,
author=cur_user)
db.session.add(new)
db.session.commit()
flash("Post Successfull")
return redirect(url_for('profile', nick=session['nick']))
elif request.method == 'GET':
return render_template('newpost.html', title="New Post", form=form)
def posts():
try:
title = request.form.get('title') or ""
body = request.form.get('body')
p = models.Post(body=body, title=title)
db.session.add(p)
db.session.commit()
except:
print("############Error with database")
try:
from_email = Email("*****@*****.**")
subject = "New Post: " + title
to_email = Email("*****@*****.**")
content = Content("text/plain", body)
mail = Mail(from_email, subject, to_email, content)
response = sg.client.mail.send.post(request_body=mail.get())
print("response: ", response.status_code)
print("body: ", response.body)
print("headers: ", response.headers)
except:
print("###################### Failed to send email")
return jsonify({'error': 1, 'title': escape(title), 'body': escape(body)})
def post_create():
error = None
message = None
success = False
results = None
if request.is_json:
try:
data = request.get_json()
if not data:
error = 'Json data is missen'
return jsonify({'success': success, 'data': results, 'message': message, 'error': error})
except Exception as e:
error = 'Json data is missen'
return jsonify({'success': success, 'data': results, 'message': message, 'error': error})
try:
clean_data = schema_post.post_validate_schema.load(data)
except ValidationError as e:
error = e.normalized_messages()
return jsonify({'success': success, 'data': results, 'message': message, 'error': error})
try:
user = models.User.query.filter_by(
id=clean_data['user_id']).first()
if not user:
error = 'Invalid user_id parsed'
return jsonify({'success': success, 'data': results, 'message': message, 'error': error})
new_post = models.Post(body=clean_data['body'], created_by=user.id)
db.session.add(new_post)
db.session.commit()
success = True
message = "New post created successfully!!!"
results = schema_post.post_schema.dump(new_post)
results['liked_by'] = []
results['comments'] = []
for liked in post.liked_post:
results['liked_by'].append(liked.user.username)
for comment in post.comments:
data = {'body': comment.body, 'commented_by': comment.commented_by,
'comment_date': comment.comment_date}
results['comments'].append(data)
except Exception as e:
error = 'Invalid user_id parsed'
else:
error = 'Only Json data is required'
return jsonify({'success': success, 'data': results, 'message': message, 'error': error})
def add_post(user_id, body, date):
print user_id
print body
print date
post = models.Post(user_id=user_id, body=body, timestamp=date)
db.session.add(post)
db.session.commit()
return post
def topic_add():
if request.method == "POST":
# Note "title and "content" should be same "name" as in html form
new_post = models.Post(request.form["title"], request.form["content"])
post_store.add(new_post)
return redirect(url_for("home"))
else:
return render_template("topic_add.html")
def topic_add():
if request.method == "GET":
return render_template("topic_add.html")
elif request.method == "POST":
new_post = models.Post(title=request.form["topictitle"],
content=request.form["topicbody"])
post_store.add(new_post)
return redirect(url_for("home"))
def add_post():
if request.method == "POST":
new_post = models.Post(title=request.form["Title"],
content=request.form["Content"])
post_store.add(new_post)
return redirect(url_for("home"))
else:
return render_template("add_post.html")
def topic_add_api():
request_data = request.get_json()
try:
new_post = models.Post(request_data["title"], request_data["content"])
post_store.add(new_post)
result = jsonify(new_post.__dict__())
except KeyError:
result = abort(404, "couldn't parse the request data !")
return result
def topic_create():
request_data = request.get_json()
try:
new_post = models.Post(request_data["title"], request_data["body"])
post_store.add(new_post)
result = jsonify(new_post.__dict__())
except KeyError:
result = abort(400, f"could not parse the request data")
return result
def add_post():
user = request.form['user']
p = request.form['post']
u = models.User.query.get(user)
p = models.Post(body=p, timestamp=datetime.datetime.utcnow(), author=u)
db.session.add(p)
db.session.commit()
posts = u.posts.all()
return redirect("http://" + IP + "/view_posts?email=" + user, 302)
def api_topic_create():
request_data = request.get_json()
try:
new_post = models.Post(title=request_data["title"], content=request_data["content"])
post_store.add(new_post)
result = jsonify(new_post.__dict__())
except KeyError:
result = abort(400, "Couldn't parse the request data !")
return result
def create():
form = CreatePostForm(request.form)
if request.method == 'POST':
post = models.Post(title=form.title.data,
url=form.url.data,
subreddit=form.subreddit.data)
db.session.add(post)
db.session.commit()
return redirect('/home')
return render_template('create_post.html', form=form)
def submit():
name = request.form['name']
date = datetime.utcnow()
weight = request.form['weight']
try:
post = models.Post(name=name, date=date, weight=weight)
db.session.add(post)
db.session.commit()
except Exception as e:
return str(e)
return 'Submitted'
def add_api():
request_data = request.get_json()
try:
#new_post = models.Post(request_data['title'], request_data['content'])
new_post = models.Post(title=request_data["title"],
content=request_data["content"])
post_store.add(new_post)
result = jsonify(new_post.serialize())
except KeyError:
result = abort(400, f"Couldn't parse the request data !")
return result
def post():
form = PostForm()
if form.validate():
new_post = models.Post(body=form.body.data.strip(),
date=datetime.datetime.utcnow(),
author=current_user)
db.session.add(new_post)
db.session.commit()
return redirect(url_for("index"))
print form.body.errors
return redirect(url_for("index"))
def create_posts(member_instance):
post1 = models.Post("post1", "this is post1", member_instance[0].id)
post2 = models.Post("post2", "this is post2", member_instance[0].id)
post3 = models.Post("post3", "this is post3", member_instance[1].id)
post4 = models.Post("post4", "this is post4", member_instance[1].id)
post5 = models.Post("post5", "this is post5", member_instance[1].id)
post6 = models.Post("post6", "this is post6", member_instance[2].id)
post7 = models.Post("post7", "this is post7", member_instance[2].id)
post8 = models.Post("post8", "this is post8", member_instance[2].id)
post9 = models.Post("post9", "this is post9", member_instance[2].id)
print(post1)
print(post2)
print(post3)
print("=" * 40)
return post1, post2, post3, post4, post5, post6, post7, post8, post9
def test_follow_posts(self):
# create four users
u1 = models.User(username='******', email='*****@*****.**')
u2 = models.User(username='******', email='*****@*****.**')
u3 = models.User(username='******', email='*****@*****.**')
u4 = models.User(username='******', email='*****@*****.**')
db.session.add_all([u1, u2, u3, u4])
# create four posts
now = datetime.utcnow()
p1 = models.Post(body="post from john",
author=u1,
timestamp=now + timedelta(seconds=1))
p2 = models.Post(body="post from susan",
author=u2,
timestamp=now + timedelta(seconds=4))
p3 = models.Post(body="post from mary",
author=u3,
timestamp=now + timedelta(seconds=3))
p4 = models.Post(body="post from david",
author=u4,
timestamp=now + timedelta(seconds=2))
db.session.add_all([p1, p2, p3, p4])
db.session.commit()
# setup the followers
u1.follow(u2) # john follows susan
u1.follow(u4) # john follows david
u2.follow(u3) # susan follows mary
u3.follow(u4) # mary follows david
db.session.commit()
# check the followed posts of each user
f1 = u1.followed_posts().all()
f2 = u2.followed_posts().all()
f3 = u3.followed_posts().all()
f4 = u4.followed_posts().all()
self.assertEqual(f1, [p2, p4, p1])
self.assertEqual(f2, [p2, p3])
self.assertEqual(f3, [p3, p4])
self.assertEqual(f4, [p4])
def create_post():
form = CreatePostForm()
if request.method =='POST'and form.validate_on_submit():
posttext = form.posttext.data
timestamp = datetime.utcnow()
user = current_user
newpost = models.Post(user, posttext, timestamp)
db.session.add(newpost)
db.session.commit()
flash('New post by %s' % (user.userid))
return redirect(url_for('index'))
return render_template('create_post.html',title='Create a new post.',form=form)
def topic_add_api():
request_data = request.get_json()
try:
new_post = models.Post(title=request.form["title"],
content=request.form["content"])
post_store.add(new_post)
print(new_post)
result = jsonify(new_post.as_dict())
except KeyError:
result = abort(400, f"couldn't parse the request data!")
return result
def new_post():
form = PostForm()
if form.validate_on_submit():
tags = [db.session.query(models.Tag).filter_by(id=int(id)).one()
for id in form.tags.data]
new_post = models.Post(title=form.title.data, body=form.body.data, tags=tags)
db.session.add(new_post)
db.session.commit()
flash('Post with title %r created successfully!' % (new_post.title))
return redirect('/index')
form.tags.data = db.session.query(models.Tag).all()
return render_template('new_post.html', title="New Post - Admin", form=form, user=current_user)
def test_post_serialize(self):
tmp = models.Post(title='test title',
body='test body',
thumbnail_index=0)
actual = tmp.serialize()
expected = {
'body': 'test body',
'id': None,
'pictures': [],
'thumbnailIndex': 0,
'title': 'test title'
}
assert expected == actual
