SocialNetwork

1
from flask import jsonify, make_response
2
from flask_login import current_user, login_required
3
from flask_restful import abort, Resource, reqparse
4

5
from data import db_session
6
from data.posts import Post
7
from data.users import User
8

9

10
def abort_if_user_not_found(user_id):
11
    session = db_session.create_session()
12
    user = session.query(User).filter(User.id == user_id)
13
    if not user:
14
        abort(404, message=f"User {user_id} not found")
15

16

17
def abort_if_user_posts_not_found(user_id):
18
    session = db_session.create_session()
19
    posts = session.query(Post).filter(Post.user_id == user_id)
20
    if not posts:
21
        abort(404, message=f"Posts for user {user_id} not found")
22

23

24
def abort_if_post_not_found(post_id):
25
    session = db_session.create_session()
26
    post = session.query(Post).get(post_id)
27
    if not post:
28
        abort(404, message=f"Posts {post} not found")
29

30

31
class PostResource(Resource):
32
    def get(self, post_id):
33
        abort_if_post_not_found(post_id)
34
        session = db_session.create_session()
35
        post = session.query(Post).get(post_id)
36
        if current_user.id != post.user.id:
37
            return make_response(jsonify({'error': 'method is not allowed for this account'}), 400)
38
        return make_response(jsonify({
39
            'posts': post.to_dict(only=('id', 'text', 'created_date', 'user_id'))
40

41
        }), 200)
42

43
    @login_required
44
    def delete(self, post_id):
45
        abort_if_post_not_found(post_id)
46
        session = db_session.create_session()
47
        post = session.query(Post).get(post_id)
48
        if current_user.id != post.user.id:
49
            return make_response(jsonify({'error': 'method is not allowed for this account'}), 400)
50
        session.delete(post)
51
        session.commit()
52
        return make_response(jsonify({'success': 'OK'}), 200)
53

54

55
parser = reqparse.RequestParser()
56
parser.add_argument('text', required=True)
57

58

59
class PostListResource(Resource):
60
    @login_required
61
    def get(self, user_id):
62
        if current_user.id != user_id:
63
            return make_response(jsonify({'error': 'method is not allowed for this account'}), 400)
64
        abort_if_user_posts_not_found(user_id)
65
        session = db_session.create_session()
66
        posts = session.query(Post).filter(Post.user_id == user_id)
67
        return make_response(jsonify({
68
            'user': user_id,
69
            'posts': [item.to_dict(only=('id', 'text', 'created_date')) for item in posts]
70

71
        }), 200)
72

73
    @login_required
74
    def post(self, user_id):
75
        if current_user.id != user_id:
76
            return make_response(jsonify({'error': 'method is not allowed for this account'}), 400)
77
        args = parser.parse_args()
78
        session = db_session.create_session()
79
        post = Post(
80
            text=args['text'],
81
            user_id=user_id,
82
        )
83
        session.add(post)
84
        session.commit()
85
        return make_response(jsonify({'success': 'OK',
86
                        'post': {'id': post.id, 'author': f'{post.user.name} {post.user.surname}'}}), 200)
87

88

89
class FriendsResource(Resource):
90
    @login_required
91
    def post(self, user_id, friend_id):
92
        if current_user.id != user_id and current_user.id != friend_id:
93
            return make_response(jsonify({'error': 'method is not allowed for this account'}), 400)
94

95
        abort_if_user_not_found(user_id)
96
        abort_if_user_not_found(friend_id)
97

98
        session = db_session.create_session()
99
        user = session.query(User).get(user_id)
100
        friend = session.query(User).get(friend_id)
101

102
        if friend not in user.friends:
103
            user.become_friends(friend)
104
            session.commit()
105
            return make_response(jsonify({'success': 'OK'}), 200)
106
        else:
107
            return make_response(jsonify({'error': 'users are already friends'}), 400)
108

109
    @login_required
110
    def delete(self, user_id, friend_id):
111
        if current_user.id != user_id and current_user.id != friend_id:
112
            return make_response(jsonify({'error': 'method is not allowed for this account'}), 400)
113

114
        abort_if_user_not_found(user_id)
115
        abort_if_user_not_found(friend_id)
116

117
        session = db_session.create_session()
118
        user = session.query(User).get(user_id)
119
        friend = session.query(User).get(friend_id)
120

121
        if friend not in user.friends:
122
            return make_response(jsonify({'error': 'users are not friends'}), 400)
123
        else:
124
            user.delete_friend(friend)
125
            session.commit()
126
            return make_response(jsonify({'success': 'OK'}), 200)
127