def create_post():
post_data = request.get_json(force=True, silent=True)
if post_data == None:
return "Bad request", 400
post = Post(post_data["title"], post_data["content"])
post.save()
return json.dumps(post.to_dict()), 201
def __from_dynamo(item: dict) -> Post:
return Post(name=item["name"]["S"],
text=item["text"]["S"],
post_id=item["post_id"]["S"],
timestamp=item["timestamp"]["S"],
img_url=item["img_url"]["S"],
tags=item.get("tags", {}).get("SS"))
def create_post():
post_data = request.get_json(force=True, silent=True)
if post_data == None:
return "Bad request", 400
post = Post(get_id(), post_data["title"], post_data["content"])
POSTS[post.id] = post
return json.dumps(post.to_dict()), 201
def new_post(self):
title = input("Enter post title:")
content = input("Enter post:")
date = input("Enter date or leave for today(ddmmyyyy):")
post = Post(self.author,title,content,self.id,datetime.datetime.strptime(date,"%d%m%Y"))
post.save_to_mongo()
def create_post():
post = Post()
try:
data = request.get_data()
data = json.loads(data)
post.title = data['title']
post.content = data['content']
post.category_id = data['category_id']
tags = data['tags']
post.region = data['region']
post.image_header_id = data['image_header_id']
except Exception:
raise ServiceException(ErrorCode.PARAM_ERROR, 'param error')
tag_ids = []
if tags is not None and tags != '':
tags = tags.split(",")
for tag_name in tags:
try:
tag = GroupService.get_tag_by_name(tag_name)
except ServiceException:
tag = GroupService.insert_tag(tag_name)
tag_ids.append(str(tag.id))
post.tag_ids = ",".join(tag_ids)
post = PostService.insert_post(post)
return jsonify(json_resp(data=model2dict(post)))
def create(self, request, *args, **kwargs):
try:
serializer = self.get_serializer(data=request.data)
if serializer.is_valid():
# 대댓글을 달 post, comment 확인
post_id = kwargs["post_id"]
comment_id = kwargs["comment_id"]
comment = Comment.objects.filter(id=comment_id,
post_id=post_id,
depth=1).first()
if comment:
sequence_max = Comment.objects.filter(
group=comment.group,
post_id=post_id).aggregate(Max('sequence'))
sequence = sequence_max["sequence__max"] + 1
post = Post(id=post_id)
Comment.objects.create(post=post,
sequence=sequence,
depth=2,
group=comment.group,
**request.data)
return Response(status=200, data=serializer.data)
else:
# 데이터 없음
return Response(status=400, data="데이터 없음")
else:
return Response(status=400)
except Exception as e:
print(e)
return Response(status=500)
def init_db():
session = Session()
file = open('example.json', 'r', encoding='utf-8')
data = json.load(file)
file.close()
for user in data['Users']:
item = User(username=user['username'])
session.add(item)
for section in data['Sections']:
item = Section(title=section['title'])
session.add(item)
for post in data['Posts']:
item = Post(title=post['title'],
section_id=post['section_id'],
user_id=post['user_id'],
description=post['description'])
session.add(item)
for tag in data['Tags']:
item = Tag(name=tag['name'], post_id=tag['post_id'])
session.add(item)
session.commit()
session.close()
def get(self, id):
query = ( "SELECT id, publish_date, length, user, topic, thread, hash "
"FROM post WHERE id=%s")
cursor = self.db.cursor(query, (id))
sql_result = cursor.fetchone()
cursor.close()
post = Post(sql_result[1], sql_result[2], sql_result[3], sql_result[4])
post.id = sql_result[0]
post.hash = sql_result[5]
return post
def post(self, id):
subject = self.request.get('subject')
content = self.request.get('content')
if subject and content:
post = Post(subject=subject, content=content)
key = post.put()
self.redirect('/blog/' + str(key.id()))
else:
self.render_form(content, subject, 'Both a subject and content must be present')
def deleteURL():
if not session["logged_in"]:
return redirect(url_for("index"))
if request.method == 'POST':
id = request.form['id']
post = Post(session["username"])
post.delete(id)
return "Success"
def blog():
form = PostForm()
if current_user.can(Permission.WRITE_ARTICLES) and \
form.validate_on_submit():
post = Post(title=form.title.data,
body=form.body.data,
author=current_user._get_current_object())
db.session.add(post)
db.session.commit()
return redirect(url_for('blog.index'))
return render_template('blog.html', form=form)
def setUp(self):
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
# Set up some initial users
valid_user = User(id="Valid User", password="******")
self.valid_user_key = valid_user.put()
invalid_user = User(id="Invalid User", password="******")
self.invalid_user_key = invalid_user.put()
valid_liker = User(id="Valid Liker", password="******")
self.valid_liker_key = valid_user.put()
invalid_liker = User(id="Invalid Liker", password="******")
self.invalid_liker_key = invalid_user.put()
# Set up an initial post
initial_post = Post(title="Test Post",
content="Some content",
submitter="Valid User")
self.initial_post_key = initial_post.put()
initial_post_to_like = Post(title="Test Post",
content="Some content",
submitter="Invalid Liker")
self.initial_post_to_like_key = initial_post_to_like.put()
# Set up some other posts
Post(title="Test Post A",
content="Some content",
submitter="Invalid Liker").put()
Post(title="Test Post B",
content="Some content",
submitter="Valid User").put()
Post(title="Test Post C",
content="Some content",
submitter="Valid User").put()
def updateURL():
if not session["logged_in"]:
return redirect(url_for("index"))
if request.method == 'POST':
id = request.form['id']
status = request.form['status']
post = Post(session["username"])
post.updateStatus(id, status)
return "Success"
def post(self, user_id):
"""
Make a new post
"""
args = postParser.parse_args()
content = args['content']
profile = Profile.objects(user=user_id).first()
post = Post(user=user_id, user_profile=profile, content=content)
post.save()
return {'status': 'success'}
def add_new_post_service(title, body, tags=None):
# cannot add two posts with the same title
if Post.objects(title=title).first() is None:
current_user = get_jwt_identity()
new_post = Post(title=title,
body=body,
tags=tags,
author=get_user_id(current_user))
new_post.save()
return jsonify(new_post)
else:
return Response("Post with that title already exist!", status=409)
def post(self):
titulo = self.request.get("edTitulo", "")
autor = self.request.get("edAutor", "")
contenido = self.request.get("edContenido", "")
if (not titulo or not autor or not contenido):
return self.redirect("/home")
else:
post = Post(titulo=titulo, contenido=contenido, autor=autor)
post.put()
time.sleep(1)
return self.redirect("/home")
def get(self, **kwargs):
template = jinja_env.get_template('new-post.html')
post = Post().get_by_id(int(kwargs['post_id']))
self.write(
template, {
'form': {
'title': post.title,
'content': post.content
},
'new': False,
'post_id': kwargs['post_id']
})
def create_post():
if request.method == 'GET':
return render_template("new_post.html")
elif request.method == 'POST':
post_data = request.get_json(force=True, silent=True)
if post_data == None:
return "Bad request", 400
post = Post(post_data["title"], post_data["content"],
post_data["price"], post_data["post_date"],
post_data["available"], post_data["buyer"])
post.save()
return redirect('/api/posts')
def addURL():
if not session["logged_in"]:
return redirect(url_for("index"))
if request.method == 'POST':
url = request.form['url']
post = Post(session["username"])
count = len(post.get(user_id=session["user_id"]).all())
if count < post.limit:
status = post.add(url)
return status
def comment(self, request, *args, **kwargs):
serializer = CommentSerializer(data=request.data)
if serializer.is_valid():
# 댓글을 달 post 번호
post_id = kwargs["pk"]
# 그룹 번호 갱신
group_max = Comment.objects.all().aggregate(Max('group'))
group = group_max["group__max"] + 1
post = Post(id=post_id)
Comment.objects.create(post=post, group=group, **request.data)
return Response(status=200)
else:
return Response(status=400)
def new_post(self):
title = input("Enter post title")
content = input("Enter post content")
date = input(
"Enter post date, or leave blank for today(in format ddmmyyyy): ")
if (date == ""):
date = datetime.datetime.utcnow()
else:
date = datetime.datetime.strptime(date, "%d%m%Y")
post = Post(blog_id=self.id,
title=title,
content=content,
author=self.author,
date=date) # strp allows to give a format string
post.save_to_mongo()
def add_post(title, body, publish_date, img, requires_login, author_id):
date = datetime.now()
if publish_date is None:
publish_date = date
else:
publish_date = __parse_date(publish_date)
requires_login = __parse_bool(requires_login.lower())
__validate_params(title, body, publish_date, requires_login)
img_path = storage.upload_image_file(img, "post")
post = Post(title, body, date, publish_date, img_path, requires_login, author_id)
insert(post)
def post(self, **kwargs):
title = self.request.POST['title']
content = self.request.POST['content']
submitter = self.request.cookies.get('user').split("|")[0]
# Check that title and content are non-empty and add the data to the
# datastore; otherwise, re-render the form with errors
if title != '' and content != '':
new_post = Post(title=title, content=content, submitter=submitter)
new_post_key = new_post.put()
new_post_id = new_post_key.id()
self.redirect('/posts/%d' % new_post_id)
else:
template = jinja_env.get_template('new-post.html')
form_data = {'title': title, 'content': content, 'error': True}
self.write(template, {'form': form_data, 'new': True})
def new_post(self):
title = input("Enter post title : ")
content = input("Enter Post content : ")
date = input(
"Enter the post date or leave blank for today (in format DDMMYYYY)"
)
if date == "":
date = datetime.datetime.utcnow()
else:
date = datetime.datetime.strptime(date, "%d%m%Y")
post = Post(blog_id=self.id,
title=title,
content=content,
author=self.author,
date=date)
post.save_to_mongo()
def select_posts(self) -> List[Post]:
"""
Iterate the posts and select only posts that can be published.
It selects posts that represent goal video and that are not already posted in the last hour.
Returns:
List[Post]: A list of posts that can be published.
"""
# Regex for goal posts
pattern = re.compile(
"^.* ([0-9]+|\[[0-9]+\])( )*-( )*([0-9]+|\[[0-9]+\]) .* ([0-9]+'|[0-9]+'\+[1-9]+')$"
)
posts = []
# Put all goal post in a list.
# It's a list of tuple.
for post in self.posts_iterator:
# Check if is a goal post
if (pattern.match(post.title) is not None
and post.link_flair_text == "Media"):
text = "⚽ " + post.title + "\n\nVideo: " + post.url
p = Post(
post.id,
datetime.datetime.fromtimestamp(post.created_utc,
tz=datetime.timezone.utc),
text,
)
posts.append(p)
one_hour_ago_ts = datetime.datetime.now(
datetime.timezone.utc) - datetime.timedelta(hours=1)
# Filter messages. Only messages not published in the last hour
to_post = [
p for p in posts
if p not in self.posted_last_hour and p.timestamp > one_hour_ago_ts
]
# Remove post older than one hour
self.posted_last_hour = [
p for p in self.posted_last_hour if p.timestamp > one_hour_ago_ts
]
self.posted_last_hour = self.posted_last_hour + to_post
# Save data posted
if self.save_mng is not None:
self.save_mng.save(self.posted_last_hour)
return to_post
def redirect_if_not_author(*args, **kwargs):
self = args[0]
user_id = kwargs['user_id']
post_id = kwargs['post_id']
post = Post().get_by_id(int(post_id))
is_author = (post.submitter == user_id)
# Perform is_author XOR invert to determine whether or not to
# call the decorated function
decorate = (is_author and not invert) or (not is_author and invert)
if decorate:
# Call the decorated function
fn(*args, **kwargs)
else:
self.redirect('/posts/' + kwargs['post_id'])
def add_entry():
if not session.get('logged_in'):
abort(401)
html_content = markdown(request.form['content'])
title = 'No title'
if request.form['title'] is not "":
title = request.form['title']
post = Post(title=title, content=html_content, date=time())
g.session.add(post)
g.session.commit()
flash("Added entry!")
return redirect(url_for('show_entries'))
def populate_db(filename):
engine = create_engine("sqlite:///{}".format(filename), echo=True)
Session = sessionmaker()
Session.configure(bind=engine)
session = Session()
default_post = Post(post_id=0,
date=int(time()),
title="Hello World",
content="Welcome :)")
session.add(default_post)
user = User(user_id=0,
username='******',
real_name='Root Fairy',
password_hash=sha1('password').hexdigest())
session.add(user)
session.commit()
def get_posts(self, tags):
"""Gets all unique posts that have at least one of supplied tags
Parameters
----------
tags : list(str)
list of tags
Returns
-------
List(dictionaries)
List of posts that have at least one of the supplied tags
"""
query_tags = copy.copy(tags)
final_results = list()
#caching functionality
for tag in tags:
cached_data = self.cache.get(tag)
if cached_data != None:
query_tags.remove(tag)
final_results.append(cached_data)
if len(query_tags) != 0:
asyncio.set_event_loop(asyncio.new_event_loop())
loop = asyncio.get_event_loop()
future = asyncio.ensure_future(self.get_tags(query_tags))
results = loop.run_until_complete(future)
#add our new results into the cache
for index in range(len(results)):
self.cache.set(query_tags[index],
results[index],
ex=self.time_to_expire)
final_results += results
posts = list(map(lambda x: json.loads(x), final_results))
all_posts = []
for post in posts:
object_form = list(map(lambda data: Post(data), post['posts']))
all_posts += object_form
all_posts = list(set(all_posts))
return all_posts
def post(self):
title = self.request.get('title')
content = self.request.get('content')
board = self.request.get('board')
if title == '':
self.error(400)
else:
author = getSecureUser(self.request)
if (author is not None):
# TODO: check if user is authorized to post in board
newPost = Post(title=title,
content=content,
author=author,
board=board)
newPost.put()
# TODO: redirect to post URL
else:
self.error(401)
