def test_blog_invite_cant_accept_other_user(
client, blog, user_token, user_not_in_blog_with_token, other_user_and_token
):
body = {"user": user_not_in_blog_with_token[0].id, "role": "writer"}
rv = client.post(
"/blogs/" + str(blog.url) + "/invite/",
headers={"Authorization": user_token[1].token},
json=body,
)
assert rv.json["success"] == 1
assert "invite" in rv.json
assert BlogInvite.select().count() == 1, "There should be one invite"
invite = BlogInvite.get()
assert invite.blog.id == blog.id
assert invite.user_from.id == user_token[0].id
assert invite.user_to.id == user_not_in_blog_with_token[0].id
assert invite.role == 2
assert not invite.is_accepted
query = BlogParticipiation.select().where(
(BlogParticipiation.user == user_not_in_blog_with_token[0])
& (BlogParticipiation.blog == blog)
)
assert query.count() == 0, "User should not be added to blog"
from src.model import db
db.db_wrapper.database.close()
rv = client.post(
"/blogs/" + str(blog.url) + "/invite/",
headers={"Authorization": other_user_and_token[1].token},
json={"invite": rv.json["invite"]},
)
assert rv.json["success"] == 0
assert rv.json["error"]["code"] == 3
assert BlogInvite.select().count() == 1, "There should be one invite"
invite = BlogInvite.get()
assert invite.blog.id == blog.id
assert invite.user_from.id == user_token[0].id
assert invite.user_to.id == user_not_in_blog_with_token[0].id
assert invite.role == 2
assert not invite.is_accepted
query = BlogParticipiation.select().where(
(BlogParticipiation.user == user_not_in_blog_with_token[0])
& (BlogParticipiation.blog == blog)
)
assert query.count() == 0, "User should not be added to blog"
query = BlogParticipiation.select().where(
(BlogParticipiation.user == other_user_and_token[0])
& (BlogParticipiation.blog == blog)
)
assert query.count() == 0, "Other user should not be added to blog"
def invites(url):
"""Пригласить пользователя или принять инвайт"""
blog = Blog.get_or_none(Blog.url == url)
if blog is None:
return errors.not_found()
user = get_user_from_request()
json = request.get_json()
if "invite" in json:
invite = BlogInvite.get_or_none(BlogInvite.id == json["invite"])
if invite is None:
return errors.invite_not_found()
if invite.user_to.id != user.id:
return errors.no_access()
invite.is_accepted = True
invite.save()
BlogParticipiation.create(blog=invite.blog, user=user, role=invite.role)
return jsonify({"success": 1})
elif "user" in json and "role" in json:
user_to = User.get_or_none(User.id == json["user"])
if user_to is None:
return errors.not_found()
role = Blog.get_user_role(blog, user)
if role is None:
return errors.no_access()
role_to = json["role"]
roles = {"owner": 1, "writer": 2, "reader": 3}
if role_to not in roles:
return errors.invite_wrong_role()
role_to = roles[role_to]
if role > role_to:
return errors.no_access()
invite = BlogInvite.create(
blog=blog, user_from=user, user_to=user_to, role=role_to
)
Notification.create(
user=user,
created_date=datetime.datetime.now(),
text='Вас пригласили в блог "{0}"'.format(blog.title),
object_type="invite",
object_id=invite.id,
)
return jsonify({"success": 1, "invite": invite.id})
def join(url):
"""Присоеденится к блогу. Работает только с открытми блогами"""
blog = Blog.get_or_none(Blog.url == url)
if blog is None:
return errors.not_found()
if blog.blog_type != 1:
return errors.no_access()
user = get_user_from_request()
if user is None:
return errors.not_authorized()
if BlogParticipiation.get_or_none(blog=blog, user=user) is None:
BlogParticipiation.create(blog=blog, user=user, role=3)
return jsonify({"success": 1})
def blog(user):
blog = Blog.create(
title="test_blog",
url="test_blog",
creator=user,
created_date=datetime.datetime.now(),
updated_date=datetime.datetime.now(),
)
BlogParticipiation.create(blog=blog, user=user, role=1)
from src.model import db
db.db_wrapper.database.close()
return blog
def test_create_jam(client, user_token):
rv = client.post(
"/jams/",
headers={"Authorization": user_token[1].token},
json={
"title": "test title for jam",
"url": "test-jam",
"description": "description",
"short_description": "short",
"start_date": datetime.datetime.now().timestamp() + 5,
"end_date": datetime.datetime.now().timestamp() + 10,
},
)
assert rv.json["success"] == 1
assert "jam" in rv.json
blog = Blog.get()
assert blog.creator == user_token[0], "Wrong creator"
assert blog.description == 'Это блог для джема "test title for jam"'
participiation = BlogParticipiation.get()
assert participiation.user == user_token[0]
assert participiation.role == 1, "Not owner on creation"
jam = Jam.get()
assert jam.creator == user_token[0], "Wrong creator"
assert jam.title == "test title for jam"
assert jam.url == "test-jam"
assert jam.description == "description"
assert jam.short_description == "short"
assert int(jam.start_date) > int(datetime.datetime.now().timestamp())
assert int(jam.start_date) == int(jam.end_date - 5)
def create_blog_for_jam(user, title, url, image=None):
blog = Blog.create(
created_date=datetime.datetime.now(),
updated_date=datetime.datetime.now(),
creator=user,
)
BlogParticipiation.create(blog=blog, user=user, role=1)
blog.title = title
blog.description = f'Это блог для джема "{title}"'
blog.url = url
blog.blog_type = 1
if image:
blog.image = Content.get_or_none(Content.id == image)
blog.updated_date = datetime.datetime.now()
blog.save()
return blog
def create_blog():
"""Создать блог"""
user = get_user_from_request()
url = request.get_json()["url"]
if Blog.get_or_none(Blog.url == url) is not None:
return errors.blog_url_already_taken()
blog = Blog.create(
created_date=datetime.datetime.now(),
updated_date=datetime.datetime.now(),
creator=user,
)
BlogParticipiation.create(blog=blog, user=user, role=1)
fill_blog_from_json(blog, request.get_json())
blog.save()
return jsonify({"success": 1, "blog": blog.to_json()})
def blog(user, reader_token):
blog = Blog.create(
title="test_blog",
url="test_blog",
creator=user,
created_date=datetime.datetime.now(),
updated_date=datetime.datetime.now(),
)
BlogParticipiation.create(blog=blog, user=user, role=1)
writer = User.create(
username="******",
password="******",
email="asd",
registration_date=datetime.datetime.now(),
last_active_date=datetime.datetime.now(),
)
BlogParticipiation.create(blog=blog, user=writer, role=2)
BlogParticipiation.create(blog=blog, user=reader_token[0], role=3)
from src.model import db
db.db_wrapper.database.close()
return blog
def jam(user, reader_token):
jam_title = "test jam"
jam_url = "test-jam"
blog = Blog.create(
title="test_blog",
url="test_blog",
creator=user,
created_date=datetime.datetime.now(),
updated_date=datetime.datetime.now(),
)
BlogParticipiation.create(blog=blog, user=user, role=1)
blog.title = jam_title
blog.description = f'Это блог для джема "{jam_title}"'
blog.url = jam_url
blog.blog_type = 1
blog.save()
jam = Jam.create(
created_date=datetime.datetime.now(),
updated_date=datetime.datetime.now(),
creator=user,
blog=blog,
title=jam_title,
url=jam_url,
description="some description without tags",
short_description="short description",
start_date=datetime.datetime.now() + timedelta(seconds=1),
end_date=datetime.datetime.now() + timedelta(seconds=5),
)
from src.model import db
db.db_wrapper.database.close()
return jam
def test_create_blog(client, user_token):
rv = client.post(
"/blogs/",
headers={"Authorization": user_token[1].token},
json={"url": "blog-url"},
)
assert rv.json["success"] == 1
assert "blog" in rv.json, "No blog in response"
blog = Blog.get()
assert blog.creator == user_token[0], "Wrong creator"
assert blog.id == rv.json["blog"]["id"]
participiation = BlogParticipiation.get()
assert participiation.blog.id == rv.json["blog"]["id"]
assert participiation.user == user_token[0]
assert participiation.role == 1, "Not owner on creation"
def test_edit_jam(client, user_token, jam):
rv = client.post(
f"/jams/{jam.url}/",
headers={"Authorization": user_token[1].token},
json={"title": "new title"},
)
assert rv.json["success"] == 1
assert "jam" in rv.json
blog = Blog.get()
assert blog.creator == user_token[0], "Wrong creator"
assert blog.description == 'Это блог для джема "new title"'
participiation = BlogParticipiation.get()
assert participiation.user == user_token[0]
assert participiation.role == 1, "Not owner on creation"
jam = Jam.get()
assert jam.creator == user_token[0], "Wrong creator"
assert jam.title == "new title"
assert jam.url == jam.url
assert jam.description == jam.description
assert jam.short_description == jam.short_description
def convert():
create_app()
def get_blog_type(blog):
if blog.blog_type == "open":
return 1
elif blog.blog_type == "hidden":
return 3
else:
return 2
for b in TuBlog.select():
blog_type = get_blog_type(b)
year = b.blog_date_add.year
month = b.blog_date_add.month
avatar = content.create_content(b.blog_avatar, "blog_avatar", b.blog,
b.user_owner, year, month)
updated = b.blog_date_edit
if not updated:
updated = b.blog_date_add
owner = User.get_or_none(User.id == b.user_owner)
if not owner:
print("Skipped blog. Owner:" +
TuUser.get(TuUser.user == b.user_owner).user_login)
continue
about = content.replace_uploads_in_text(owner, b.blog_description)
url = b.blog_url or "blog" + str(b.blog)
blog = Blog.create(
id=b.blog,
created_date=b.blog_date_add,
updated_date=updated,
description=about,
title=b.blog_title,
url=url,
blog_type=blog_type,
creator=owner,
image=avatar,
)
BlogParticipiation.create(
blog=blog,
user=owner,
role=1,
)
for bu in TuBlogUser.select():
role = 1
if bu.user_role == 1:
role = 3
if bu.user_role > 1:
role = 1
BlogParticipiation.create(
blog=Blog.get(Blog.id == bu.blog),
user=User.get(User.id == bu.user),
role=role,
)