def create_post():
post_body = json.loads(request.data)
post = Post(text=post_body.get('text'), username=post_body.get('username'))
db.session.add(post)
db.session.commit()
return json.dumps({'success': True, 'data': post.serialize()}), 201
def create_post(user_id, community_id, body):
post = Post(timestamp=datetime.datetime.now(),
content=body.get("content"),
edited=False,
user_id=user_id,
community_id=community_id)
db.session.add(post)
db.session.commit()
return post.serialize()
def create_post(content, user_id, tag_id):
new_post = Post(
content=content,
user_id=user_id,
tag_id=tag_id
)
db.session.add(new_post)
db.session.commit()
return new_post.serialize()
def create_post():
post_body = json.loads(request.data)
post = Post(
likes=0,
text=post_body["text"],
nickname=post_body["nickname"],
workout=post_body["workout"],
)
db.session.add(post)
db.session.commit()
return json.dumps({"success": True, "data": post.serialize()}), 200
def create_post(user):
post_body = json.loads(request.data)
try:
post = Post(text=post_body.get('text'), user_id=user)
db.session.add(post)
db.session.commit()
return json.dumps({'success': True, 'data': post.serialize()}), 201
except KeyError as e:
return json.dumps({'success': False, 'data': 'Invalid input'}), 404
def create_post(attraction_id):
body = json.loads(request.data)
attraction = Attraction.query.filter_by(id=attraction_id).first()
if not attraction:
return failure_response("Attraction not found")
new_post = Post(netid=body.get("netid"), name=body.get(
"name"), picture=body.get("picture"), description=body.get("description"), attraction_id=attraction_id)
if not new_post.netid or not new_post.description:
return failure_response("Missing required field")
db.session.add(new_post)
db.session.commit()
return success_response(new_post.serialize(), 201)
def create_post():
"""Append new post to list."""
post_body = json.loads(request.data)
if 'username' in post_body and 'text' in post_body:
post = Post(text=post_body.get('text'),
username=post_body.get('username'),
longitude=post_body.get('longitude'),
latitude=post_body.get('latitude'))
db.session.add(post)
db.session.commit()
return json.dumps({'success': True, 'data': post.serialize()}), 200
return json.dumps({'success': False, 'error': 'Invalid POST body!'}), 404
def create_post():
post_body = json.loads(request.data)
title = post_body.get('title')
body = post_body.get('body')
author_id = post_body.get('author_id')
user = User.query.filter_by(id=author_id).first()
if not user:
return json.dumps({'success': False, 'error': 'User not found'}), 404
post = Post(title=title, body=body, author_id=author_id)
db.session.add(post)
db.session.commit()
return json.dumps({'success': True, 'data': post.serialize()}), 201
def create_a_post():
# ensure the body is valid JSON
try:
post = json.loads(request.data)
except ValueError:
return json.dumps({
'success': False,
'data': 'Error: Body not a valid JSON'
}), 400
text = post.get("text")
token = post.get("token")
# ensure the body is in the expected format
if len(list(post.keys())) != 2 or text is None\
or token is None:
return json.dumps({
'success': False,
'data': 'Error: Body not in the expected format'
}), 400
# validate the user token with google oauth2
get_params = {'access_token': token}
r = requests.get(url=AUTH_URL, params=get_params)
data = r.json()
try:
google_id = data['id']
except KeyError:
# token is invalid
return json.dumps({
'success': False,
'data': 'Error: Token is invalid'
}), 400
print(google_id)
user = User.query.filter_by(google_id=google_id).first()
if user is None:
# the user trying to create a post is not stored in our database.
# i dont think this should ever happen (hopefully ?)
print("No user exists with that google id")
return json.dumps({
'success': False,
'data': 'Error: User does not exist'
}), 400
constructed_post = Post(text=text,
nickname=user.nickname,
upload_date=int(time.time()),
user_id=user.id)
db.session.add(constructed_post)
db.session.commit()
response = {'success': True, 'data': constructed_post.serialize()}
return json.dumps(response), 201
def create_post():
'''
file: ./documentation/create_post.yml
'''
request_body = json.loads(request.data)
# Code here checks for blank body requests / @beforerequests checks for None body requests
if not request_body.get('text') == '' and not request_body.get(
'username') == '':
post = Post(text=request_body.get('text'),
username=request_body.get('username'))
# Keep the two acts separate to reduce automatic commits to the server
db.session.add(post)
db.session.commit()
return json.dumps({'success': True, 'data': post.serialize()}), 201
return json.dumps({'success': False, 'error': 'invalid body format'}), 412
def make_a_post():
post_body = json.loads(request.data)
body_post = post_body.get('body')
username = post_body.get('username')
user = User.query.filter_by(username=username).first()
if not user:
return json.dumps({'success': False, 'error': 'user not found'}), 404
user_id = user.id
newPost = Post(upvotes=0,
body_post=body_post,
time_stamp=datetime.now(),
date=date.today(),
user_id=user_id)
db.session.add(newPost)
db.session.commit()
return json.dumps({'success': True, 'data': newPost.serialize()}), 201
def create_post():
body = json.loads(request.data)
if (body.get('title') is None):
return failure_response('No title provided')
if (body.get('price') is None):
return failure_response('No price provided')
if not logged_in(current_user):
return failure_response('User not logged in')
new_post = Post(title=body.get('title'),
description=body.get('description'),
seller=current_user.id,
price=body.get('price'),
image_data=body.get("image_data"))
db.session.add(new_post)
db.session.commit()
return success_response(new_post.serialize(), 201)
def post_post(user_id):
user = User.query.filter_by(id=user_id).first()
if user is not None:
post_body = json.loads(request.data)
post = Post(
title=post_body.get("title"),
content=post_body.get("content"),
username=post_body.get("username"),
tags=post_body.get("tags"),
user_id=post_body.get("user_id"),
)
user.posts.append(post)
db.session.add(post)
db.session.commit()
return json.dumps({"success": True, "data": post.serialize()})
return json.dumps({"success": False, "error": "User not found"}), 404
def post(user_id, **kwargs):
post = Post(title=kwargs.get("title"),
dateTime=datetime.datetime.now(),
ingredients=kwargs.get("ingredients"),
recipe=kwargs.get("recipe"),
recipeTime=kwargs.get("recipeTime"),
difficultyRating=kwargs.get("difficultyRating"),
overallRating=0,
priceRating=kwargs.get("priceRating"))
user = User.query.filter_by(id=user_id).first()
user.posts.append(post)
db.session.add(post)
db.session.commit()
return post.serialize()
def make_post():
post_body = extract(request)
if not all(post_body.get(i, '') for i in ['text', 'token', 'title']):
return missing()
if 'kind' not in post_body:
return missing()
kind = int(post_body['kind'])
if kind not in [0, 1, 2]:
return missing()
if kind == 1 and ('group_size' not in post_body):
return missing()
if kind == 1 and ('role' not in post_body):
return missing()
uid = token_to_uid(post_body)
if uid is None:
return invalid_token()
if not kind == 0:
post_body.pop('course', None)
if not kind == 1:
post_body.pop('group_size', None)
if not kind == 2:
post_body.pop('skills', None)
if kind == 1:
role = clean_tags(post_body.get('role', ))
if kind == 2:
role = User.query.filter_by(uid=uid).first().role
post = Post(uid=uid,
title=post_body.get('title'),
tags=clean_tags(post_body.get('tags', '')),
role=role,
text=post_body.get('text'),
creation_time=time.time(),
kind=int(post_body.get('kind')),
course=clean_courses(post_body.get('course_id', None), 1),
group_size=post_body.get('group_size', None),
skills=clean_tags(post_body.get('skills', None)))
activate(uid)
db.session.add(post)
db.session.commit()
return json.dumps({'success': True, 'data': post.serialize()}), 201
