def add_news():
parameters['message'] = ""
form = PostForm()
if form.validate_on_submit():
db_sess = db_session.create_session()
post = Posts()
post.text = form.text.data
post.author = current_user.id
# Загрузка фотографии
f = form.photo.data
filename = secure_filename(f.filename)
db_sess = db_session.create_session()
if db_sess.query(Posts).filter(Posts.photo == filename).first():
parameters['form'] = form
parameters['message'] = "Недопустимое имя файла. Переименуйте"
return render_template('post.html', **parameters)
if not allowed_file(filename):
parameters['form'] = form
parameters['message'] = "Загрузите корректное изображение"
return render_template('post.html', **parameters)
f.save(os.path.join(app.config['UPLOAD_FOLDER_POSTS'], filename))
post.photo = filename
db_sess.add(post)
db_sess.commit()
return redirect('/')
parameters['title'] = 'Опубликовать пост'
parameters['form'] = form
return render_template('post.html', **parameters)
def add_news():
form = NewsForm()
if form.validate_on_submit():
session = db_session.create_session()
news = Posts()
news.title = form.title.data
news.content = form.content.data
news.is_private = form.is_private.data
current_user.posts.append(news)
session.merge(current_user)
session.commit()
return redirect('/')
return render_template('news.html', title='Добавление новости', form=form)
def put(current_user, self, post_id, comment_id=None):
if not isinstance(post_id, str) or len(post_id) != 24:
abort(400, message="{} is not a valid post id".format(post_id))
if comment_id is None:
abort(
405, message="Can't PUT to this endpoint. Try /post/<post id>/comment/<comment id>")
elif not isinstance(comment_id, str) or len(comment_id) != 24:
abort(400, message="{} is not a valid comment id".format(comment_id))
existing_post = Posts.objects(id=post_id).first()
if existing_post is None:
abort(404, message="Post with id '{}' doesn't exist".format(post_id))
existing_comment = [
comment for comment in existing_post.comments if str(comment.id) == comment_id]
if len(existing_comment) < 1:
abort(404, message="Comment with id '{}' doesn't exist".format(comment_id))
else:
existing_comment = existing_comment[0]
if current_user != existing_comment.author and not current_user.is_admin:
abort(401, message="Missing rights.")
received_json = request.get_json()
errors = validate_values_in_dictionary(received_json, Comments)
if errors:
abort(400, errors=errors)
if received_json.get('body') is not None:
existing_comment.body = received_json.get('body')
existing_post.save()
return {}, 204
def post(current_user, self, post_id, comment_id=None):
if not isinstance(post_id, str) or len(post_id) != 24:
abort(400, message="{} is not a valid post id".format(post_id))
if comment_id is not None:
abort(405, message="Can't POST to this endpoint. Try /post/<post id>/comment")
post_data = Posts.objects(id=post_id).first()
if post_data is None:
abort(404, message="Post with id '{}' doesn't exist".format(post_id))
received_json = request.get_json()
errors = validate_values_in_dictionary(
received_json, Comments, required_keys={'body'})
if errors:
abort(400, errors=errors)
try:
new_comment = Comments(
author=current_user,
body=received_json['body'],
rating=Ratings()
)
post_data.comments.append(new_comment)
post_data.save()
current_user.comments.append(new_comment)
# TODO fix saving comments to user
# current_user.save()
except Exception as e:
abort(400, errors=str(e))
return {'message': "Comment posted successfully", 'comment': new_comment.to_json()}, 201
def delete(current_user, self, post_id, comment_id=None):
if not isinstance(post_id, str) or len(post_id) != 24:
abort(400, message="{} is not a valid post id".format(post_id))
if comment_id is None:
abort(
405, message="Can't DELETE at this endpoint. Try /post/<post id>/comment/<comment id>")
elif not isinstance(comment_id, str) or len(comment_id) != 24:
abort(400, message="{} is not a valid comment id".format(comment_id))
existing_post = Posts.objects(id=post_id).first()
if existing_post is None:
abort(404, message="Post with id '{}' doesn't exist".format(post_id))
existing_comment = [
comment for comment in existing_post.comments if str(comment.id) == comment_id]
if len(existing_comment) < 1:
abort(404, message="Comment with id '{}' doesn't exist".format(comment_id))
else:
existing_comment = existing_comment[0]
if current_user != existing_comment.author and not current_user.is_admin:
abort(401, message="Missing rights.")
existing_post.comments.remove(existing_comment)
existing_post.save()
# TODO fix saving comments to user
existing_comment.author.comments.remove(existing_comment)
existing_comment.author.save()
return {}, 204
def new_post():
form = NewPostForm()
if form.validate_on_submit():
f = form.audio_field.data
if f.filename[-3:] != 'mp3':
return render_template('new_post.html',
form=form,
error_message='Only mp3 files supports')
post = Posts()
post.title = form.title.data
sess = db_session.create_session()
posts = sess.query(Posts).all()
try:
num = posts[-1].audio_file
except IndexError:
num = 0
num = str(int(num) + 1)
post.audio_file = num
post.author = current_user.id
post.creation_date = datetime.datetime.now()
f.save(
os.path.join('C:\\Projects\\AudioNetwork', 'static', 'audio',
'mp3', num + '.mp3'))
sess.add(post)
sess.commit()
return render_template('new_post.html', form=form)
def post(current_user, self, name, post_id=None):
if post_id is not None:
abort(405, message="Can't POST to this endpoint. Try /post")
if current_user.name != name and not current_user.is_admin:
abort(401, message="Missing rights.")
received_json = request.get_json()
errors = validate_values_in_dictionary(
received_json,
Posts,
required_keys={'title', 'image'},
sensitive_keys={'title'})
if errors:
abort(400, errors=errors)
try:
new_post = Posts(title=received_json['title'],
author=current_user,
comments=[],
rating=Ratings())
image64 = received_json['image']
file_like = b64decode(image64)
bytes_image = bytearray(file_like)
with TemporaryFile() as f:
f.write(bytes_image)
f.flush()
f.seek(0)
new_post.image.put(f)
new_post.save()
current_user.posts.append(new_post)
current_user.save()
except Exception as e:
abort(400, errors=str(e))
return {'message': "Post successful", 'post': new_post.to_json()}, 201
def add_post():
# Пост может быть добавлен только администратором
if current_user.role == 'Admin':
form = PostsForm()
if form.validate_on_submit():
db_sess = db_session.create_session()
post = Posts()
post.type = form.type.data
# Заголовок поста может включать в себя не более 50 символов
if len(form.title.data) > 50:
return render_template('addPost.html', title='Adding a post',
form=form,
message="This title is too big, please, enter up to 50 characters")
post.title = form.title.data
# Описание поста может включать в себя не более 300 символов
if len(form.content.data) > 300:
return render_template('addPost.html', title='Adding a post',
form=form,
message="This content is too big, please, enter up to 300 characters")
post.content = form.content.data
# Как это уже было с аватарами, изображение при его наличии сохраняется в папку
# Если изображение не было загружено - оставляем изображение по умолчанию
# Путь изображения: static/img/Posts/{Имя картинки поста}
# Имя картинки имеет вид Post {текущая дата} {id текущего пользователя}
# Картинка обрабатывается также, как и аватар, имеет аналогичные проверки на подлинность
if not form.image.data:
post.image = 'Empty.png'
else:
image = form.image.data
if image.filename.split('.')[-1] not in ['png', 'jpeg', 'jpg', 'ico', 'gif', 'bmp']:
return render_template('addPost.html', title='Adding a post',
form=form,
message="This file is not an image")
filename = 'Post ' + str(datetime.datetime.now()).replace(":", "-") + f' {current_user.id}' + '.' + \
image.filename.split('.')[-1]
image.save("static/img/Posts/" + filename)
post.image = filename
post.is_private = form.is_private.data
current_user.posts.append(post)
# Заполняем все поля и сохраняем пост в базу данных
db_sess.merge(current_user)
db_sess.commit()
return redirect('/')
return render_template('addPost.html', title='Adding a post',
form=form)
else:
abort(404)
def post(self):
"""Добавление поста"""
parser = reqparse.RequestParser()
parser.add_argument('title', required=True)
parser.add_argument('content', required=True)
parser.add_argument('author', required=True, type=int)
args = parser.parse_args()
session = db_session.create_session()
post = Posts(title=args['title'],
content=args['content'],
author=args['author'])
session.add(post)
session.commit()
return jsonify({'success': 'OK'})
def get(self, post_id=None):
if post_id is not None and (not isinstance(post_id, str)
or len(post_id) != 24):
abort(400, message="{} is not a valid post id".format(post_id))
kwarg = {} if post_id is None else {'id': post_id}
post_data = Posts.objects(**kwarg)
post_data = [post.to_json() for post in post_data]
if post_id is None:
return {'posts': post_data}, 200
else:
if len(post_data) < 1:
abort(
404,
message="Post with id '{}' doesn't exist".format(post_id))
return {'post': post_data[0]}, 200
def a():
db_session.global_init('db/users_db.db')
ses = db_session.create_session()
posts = ses.query(Posts).all()
users = ses.query(User).all()
names = {name.id: (name.surname, name.name) for name in users}
numbers = {numbers.id: numbers.num_posts for numbers in users}
add_form = AddPostForm()
if add_form.validate_on_submit():
db_session.global_init('db/users_db.db')
db_sess = db_session.create_session()
post = Posts(post=add_form.post.data, user_id=current_user.id)
users = db_sess.query(User).all()
users[current_user.id - 1].num_posts += 1
db_sess.add(post)
db_sess.commit()
return redirect('/a')
return render_template('a.html', form=add_form, posts=posts, names=names, numbers=numbers)
def delete(current_user, self, name, post_id=None):
if post_id is None:
abort(405,
message="Can't DELETE at this endpoint. Try /post/<post id>")
elif not isinstance(post_id, str) or len(post_id) != 24:
abort(404, message="{} is not a valid post id".format(post_id))
existing_post = Posts.objects(id=post_id).first()
if existing_post is None:
abort(404, message="Post '{}' doesn't exist".format(post_id))
if current_user.name != existing_post.author.name and not current_user.is_admin:
abort(401, message="Missing rights.")
existing_post.author.posts.remove(existing_post)
existing_post.author.save()
existing_post.delete()
return {}, 204
def put(current_user, self, post_id=None):
if post_id is None:
abort(405,
message="Can't PUT to this endpoint. Try /post/<post id>")
elif not isinstance(post_id, str) or len(post_id) != 24:
abort(404,
message="{} is not a valid post post_id".format(post_id))
existing_post = Posts.objects(id=post_id).first()
if existing_post is None:
abort(
404,
message="Post with post_id '{}' doesn't exist".format(post_id))
if current_user != existing_post.author and not current_user.is_admin:
abort(401, message="Missing rights.")
received_json = request.get_json()
errors = validate_values_in_dictionary(received_json,
Posts,
sensitive_keys={'title'},
admin_keys={'image'},
admin=current_user.is_admin)
if errors:
abort(400, errors=errors)
if received_json.get('title') is not None:
existing_post.title = received_json.get('title')
if received_json.get('image') is not None:
image64 = received_json['image']
file_like = b64decode(image64)
bytes_image = bytearray(file_like)
with TemporaryFile() as f:
f.write(bytes_image)
f.flush()
f.seek(0)
existing_post.image.replace(f)
existing_post.save()
return {}, 204
def get(self, post_id, comment_id=None):
if not isinstance(post_id, str) or len(post_id) != 24:
abort(400, message="{} is not a valid post id".format(post_id))
if comment_id is not None and (not isinstance(comment_id, str) or len(comment_id) != 24):
abort(400, message="{} is not a valid comment id".format(comment_id))
post_data = Posts.objects(id=post_id).first()
if post_data is None:
abort(404, message="Post with id '{}' doesn't exist".format(post_id))
if comment_id is None:
comment_data = [comment.to_json()
for comment in post_data.comments]
return {"comments": comment_data}, 200
else:
comment_data = [comment.to_json() for comment in post_data.comments if str(
comment.id) == comment_id]
if len(comment_data) < 1:
abort(
404, message="Comment with id '{}' doesn't exist".format(comment_id))
return {"comment": comment_data[0]}, 200
# region image base64 string
# image64 = "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"
# endregion
# file_like = b64decode(image64)
# bytes_image = bytearray(file_like)
# with TemporaryFile() as f:
# f.write(bytes_image)
# f.flush()
# f.seek(0)
# post.image.put(f)
# post.save()
# print(post.to_json())
post = Posts.objects().first_or_404()
print(post.to_json())
########################## User ##########################
user_list = []
for i in range(0, 10):
name = "test" + str(i)
email = "primary.email_" + str(i) + "@gmail.com"
user_list.append(
Users(active=True,
is_admin=False,
name=name,
email=email,
password=urandom(16),
registered_datetime=datetime.utcnow(),
posts=[],