10673535382

Committed 02 Sep 2024 10:08PM UTC coverage: 67.383% (-0.04%) from 67.423%

Build # 10673535382

Build Type

Pull #988

github

Committed by

nhoening

Commit Message

remove no longer needed test

Signed-off-by: Nicolas Höning <nicolas@seita.nl>

Pull Request Pull Request #988: Speed up assets and accounts pages

Run Details

6130 of 9936 branches covered (61.69%)

Branch coverage included in aggregate %.

79 of 95 new or added lines in 9 files covered. (83.16%)

7 existing lines in 2 files now uncovered.

7695 of 10581 relevant lines covered (72.72%)

5.76 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.71

/flexmeasures/api/v3_0/users.py

from flask_classful import FlaskView, route
from marshmallow import fields
from sqlalchemy.exc import IntegrityError
from sqlalchemy import select
from webargs.flaskparser import use_kwargs
from flask_security import current_user, auth_required
from flask_security.recoverable import send_reset_password_instructions
from flask_json import as_json
from werkzeug.exceptions import Forbidden, Unauthorized
from flexmeasures.auth.policy import check_access

from flexmeasures.data.models.audit_log import AuditLog
from flexmeasures.data.models.user import User as UserModel, Account
from flexmeasures.api.common.schemas.users import AccountIdField, UserIdField
from flexmeasures.data.schemas.users import UserSchema
from flexmeasures.data.services.users import (
    get_users,
    set_random_password,
    remove_cookie_and_token_access,
    get_audit_log_records,
)
from flexmeasures.auth.decorators import permission_required_for_context
from flexmeasures.data import db
from flexmeasures.utils.time_utils import server_now

"""
API endpoints to manage users.

Both POST (to create) and DELETE are not accessible via the API, but as CLI functions.
"""

# Instantiate schemas outside of endpoint logic to minimize response time
user_schema = UserSchema()
users_schema = UserSchema(many=True)
partial_user_schema = UserSchema(partial=True)


class UserAPI(FlaskView):
    route_base = "/users"
    trailing_slash = False
    decorators = [auth_required()]

    @route("", methods=["GET"])
    @use_kwargs(
        {
            "account": AccountIdField(data_key="account_id", load_default=None),
            "include_inactive": fields.Bool(load_default=False),
        },
        location="query",
    )
    @as_json
    def index(self, account: Account, include_inactive: bool = False):
        """API endpoint to list all users.


        .. :quickref: User; Download user list

        This endpoint returns all accessible users.
        By default, only active users are returned.
        The `account_id` query parameter can be used to filter the users of
        a given account.
        The `include_inactive` query parameter can be used to also fetch
        inactive users.
        Accessible users are users in the same account as the current user.
        Only admins can use this endpoint to fetch users from a different account (by using the `account_id` query parameter).

        **Example response**

        An example of one user being returned:

        .. sourcecode:: json

            [
                {
                    'active': True,
                    'email': 'test_prosumer@seita.nl',
                    'account_id': 13,
                    'flexmeasures_roles': [1, 3],
                    'id': 1,
                    'timezone': 'Europe/Amsterdam',
                    'username': 'Test Prosumer User'
                }
            ]

        :reqheader Authorization: The authentication token
        :reqheader Content-Type: application/json
        :resheader Content-Type: application/json
        :status 200: PROCESSED
        :status 400: INVALID_REQUEST
        :status 401: UNAUTHORIZED
        :status 403: INVALID_SENDER
        :status 422: UNPROCESSABLE_ENTITY
        """

        if account is not None:
            check_access(account, "read")
            accounts = [account]
        else:
            accounts = []
            for account in db.session.scalars(select(Account)).all():
                try:
                    check_access(account, "read")
                    accounts.append(account)
                except (Forbidden, Unauthorized):
                    pass

        users = []
        for account in accounts:
            users += get_users(
                account_name=account.name,
                only_active=not include_inactive,
            )
        return users_schema.dump(users), 200

    @route("/<id>")
    @use_kwargs({"user": UserIdField(data_key="id")}, location="path")
    @permission_required_for_context("read", ctx_arg_name="user")
    @as_json
    def get(self, id: int, user: UserModel):
        """API endpoint to get a user.

        .. :quickref: User; Get a user

        This endpoint gets a user.
        Only admins or the members of the same account can use this endpoint.

        **Example response**

        .. sourcecode:: json

            {
                'account_id': 1,
                'active': True,
                'email': 'test_prosumer@seita.nl',
                'flexmeasures_roles': [1, 3],
                'id': 1,
                'timezone': 'Europe/Amsterdam',
                'username': 'Test Prosumer User'
            }

        :reqheader Authorization: The authentication token
        :reqheader Content-Type: application/json
        :resheader Content-Type: application/json
        :status 200: PROCESSED
        :status 400: INVALID_REQUEST, REQUIRED_INFO_MISSING, UNEXPECTED_PARAMS
        :status 401: UNAUTHORIZED
        :status 403: INVALID_SENDER
        :status 422: UNPROCESSABLE_ENTITY
        """
        return user_schema.dump(user), 200

    @route("/<id>", methods=["PATCH"])
    @use_kwargs(partial_user_schema)
    @use_kwargs({"user": UserIdField(data_key="id")}, location="path")
    @permission_required_for_context("update", ctx_arg_name="user")
    @as_json
    def patch(self, id: int, user: UserModel, **user_data):
        """API endpoint to patch user data.

        .. :quickref: User; Patch data for an existing user

        This endpoint sets data for an existing user.
        It has to be used by the user themselves, admins or account-admins (of the same account).
        Any subset of user fields can be sent.
        If the user is not an (account-)admin, they can only edit a few of their own fields.

        The following fields are not allowed to be updated at all:
         - id
         - account_id

        **Example request**

        .. sourcecode:: json

            {
                "active": false,
            }

        **Example response**

        The following user fields are returned:

        .. sourcecode:: json

            {
                'account_id': 1,
                'active': True,
                'email': 'test_prosumer@seita.nl',
                'flexmeasures_roles': [1, 3],
                'id': 1,
                'timezone': 'Europe/Amsterdam',
                'username': 'Test Prosumer User'
            }

        :reqheader Authorization: The authentication token
        :reqheader Content-Type: application/json
        :resheader Content-Type: application/json
        :status 200: UPDATED
        :status 400: INVALID_REQUEST, REQUIRED_INFO_MISSING, UNEXPECTED_PARAMS
        :status 401: UNAUTHORIZED
        :status 403: INVALID_SENDER
        :status 422: UNPROCESSABLE_ENTITY
        """
        allowed_fields = [
            "email",
            "username",
            "active",
            "timezone",
            "flexmeasures_roles",
        ]
        for k, v in [(k, v) for k, v in user_data.items() if k in allowed_fields]:
            if current_user.id == user.id and k in ("active", "flexmeasures_roles"):
                raise Forbidden(
                    "Users who edit themselves cannot edit security-sensitive fields."
                )
            setattr(user, k, v)
            if k == "active" and v is False:
                remove_cookie_and_token_access(user)
            if k == "active":
                active_user_id, active_user_name = None, None
                if hasattr(current_user, "id"):
                    active_user_id, active_user_name = (
                        current_user.id,
                        current_user.username,
                    )
                user_audit_log = AuditLog(
                    event_datetime=server_now(),
                    event=f"Active status set to '{v}' for user {user.username}",
                    active_user_id=active_user_id,
                    active_user_name=active_user_name,
                    affected_user_id=user.id,
                    affected_account_id=user.account_id,
                )
                db.session.add(user_audit_log)
        db.session.add(user)
        try:
            db.session.commit()
        except IntegrityError as ie:
            return (
                dict(message="Duplicate user already exists", detail=ie._message()),
                400,
            )
        return user_schema.dump(user), 200

    @route("/<id>/password-reset", methods=["PATCH"])
    @use_kwargs({"user": UserIdField(data_key="id")}, location="path")
    @permission_required_for_context("update", ctx_arg_name="user")
    @as_json
    def reset_user_password(self, id: int, user: UserModel):
        """API endpoint to reset the user's current password, cookies and auth tokens, and to email a password reset link to the user.

        .. :quickref: User; Password reset

        Reset the user's password, and send them instructions on how to reset the password.
        This endpoint is useful from a security standpoint, in case of worries the password might be compromised.
        It sets the current password to something random, invalidates cookies and auth tokens,
        and also sends an email for resetting the password to the user.

        Users can reset their own passwords. Only admins can use this endpoint to reset passwords of other users.

        :reqheader Authorization: The authentication token
        :reqheader Content-Type: application/json
        :resheader Content-Type: application/json
        :status 200: PROCESSED
        :status 400: INVALID_REQUEST, REQUIRED_INFO_MISSING, UNEXPECTED_PARAMS
        :status 401: UNAUTHORIZED
        :status 403: INVALID_SENDER
        :status 422: UNPROCESSABLE_ENTITY
        """
        set_random_password(user)
        remove_cookie_and_token_access(user)
        send_reset_password_instructions(user)

        # commit only if sending instructions worked, as well
        db.session.commit()

    @route("/<id>/auditlog")
    @use_kwargs({"user": UserIdField(data_key="id")}, location="path")
    @permission_required_for_context(
        "read",
        ctx_arg_name="user",
        pass_ctx_to_loader=True,
        ctx_loader=AuditLog.user_table_acl,
    )
    @as_json
    def auditlog(self, id: int, user: UserModel):
        """API endpoint to get history of user actions.
        **Example response**

        .. sourcecode:: json
            [
                {
                    'event': 'User test user deleted',
                    'event_datetime': '2021-01-01T00:00:00',
                    'active_user_name': 'Test user',
                }
            ]

        :reqheader Authorization: The authentication token
        :reqheader Content-Type: application/json
        :resheader Content-Type: application/json
        :status 200: PROCESSED
        :status 400: INVALID_REQUEST, REQUIRED_INFO_MISSING, UNEXPECTED_PARAMS
        :status 401: UNAUTHORIZED
        :status 403: INVALID_SENDER
        :status 422: UNPROCESSABLE_ENTITY
        """
        audit_logs = get_audit_log_records(user)
        audit_logs = [
            {
                k: getattr(log, k)
                for k in (
                    "event",
                    "event_datetime",
                    "active_user_name",
                    "active_user_id",
                )
            }
            for log in audit_logs
        ]
        return audit_logs, 200

1	from flask_classful import FlaskView, route	8✔
2	from marshmallow import fields	8✔
3	from sqlalchemy.exc import IntegrityError	8✔
4	from sqlalchemy import select	8✔
5	from webargs.flaskparser import use_kwargs	8✔
6	from flask_security import current_user, auth_required	8✔
7	from flask_security.recoverable import send_reset_password_instructions	8✔
8	from flask_json import as_json	8✔
9	from werkzeug.exceptions import Forbidden, Unauthorized	8✔
10	from flexmeasures.auth.policy import check_access	8✔
11
12	from flexmeasures.data.models.audit_log import AuditLog	8✔
13	from flexmeasures.data.models.user import User as UserModel, Account	8✔
14	from flexmeasures.api.common.schemas.users import AccountIdField, UserIdField	8✔
15	from flexmeasures.data.schemas.users import UserSchema	8✔
16	from flexmeasures.data.services.users import (	8✔
17	get_users,
18	set_random_password,
19	remove_cookie_and_token_access,
20	get_audit_log_records,
21	)
22	from flexmeasures.auth.decorators import permission_required_for_context	8✔
23	from flexmeasures.data import db	8✔
24	from flexmeasures.utils.time_utils import server_now	8✔
25
26	"""	4✔
27	API endpoints to manage users.
28
29	Both POST (to create) and DELETE are not accessible via the API, but as CLI functions.
30	"""
31
32	# Instantiate schemas outside of endpoint logic to minimize response time
33	user_schema = UserSchema()	8✔
34	users_schema = UserSchema(many=True)	8✔
35	partial_user_schema = UserSchema(partial=True)	8✔
36
37
38	class UserAPI(FlaskView):	8✔
39	route_base = "/users"	8✔
40	trailing_slash = False	8✔
41	decorators = [auth_required()]	8✔
42
43	@route("", methods=["GET"])	8✔
44	@use_kwargs(	8✔
45	{
46	"account": AccountIdField(data_key="account_id", load_default=None),
47	"include_inactive": fields.Bool(load_default=False),
48	},
49	location="query",
50	)
51	@as_json	8✔
52	def index(self, account: Account, include_inactive: bool = False):	8✔
53	"""API endpoint to list all users.
54
55
56	.. :quickref: User; Download user list
57
58	This endpoint returns all accessible users.
59	By default, only active users are returned.
60	The `account_id` query parameter can be used to filter the users of
61	a given account.
62	The `include_inactive` query parameter can be used to also fetch
63	inactive users.
64	Accessible users are users in the same account as the current user.
65	Only admins can use this endpoint to fetch users from a different account (by using the `account_id` query parameter).
66
67	Example response
68
69	An example of one user being returned:
70
71	.. sourcecode:: json
72
73	[
74	{
75	'active': True,
76	'email': 'test_prosumer@seita.nl',
77	'account_id': 13,
78	'flexmeasures_roles': [1, 3],
79	'id': 1,
80	'timezone': 'Europe/Amsterdam',
81	'username': 'Test Prosumer User'
82	}
83	]
84
85	:reqheader Authorization: The authentication token
86	:reqheader Content-Type: application/json
87	:resheader Content-Type: application/json
88	:status 200: PROCESSED
89	:status 400: INVALID_REQUEST
90	:status 401: UNAUTHORIZED
91	:status 403: INVALID_SENDER
92	:status 422: UNPROCESSABLE_ENTITY
93	"""
94
95	if account is not None:	8✔
96	check_access(account, "read")	8✔
NEW 97	accounts = [account]	×
98	else:
99	accounts = []	8✔
100	for account in db.session.scalars(select(Account)).all():	8✔
101	try:	8✔
102	check_access(account, "read")	8✔
103	accounts.append(account)	8✔
104	except (Forbidden, Unauthorized):	8✔
105	pass	8✔
106
107	users = []	8✔
108	for account in accounts:	8✔
109	users += get_users(	8✔
110	account_name=account.name,
111	only_active=not include_inactive,
112	)
113	return users_schema.dump(users), 200	8✔
114
115	@route("/<id>")	8✔
116	@use_kwargs({"user": UserIdField(data_key="id")}, location="path")	8✔
117	@permission_required_for_context("read", ctx_arg_name="user")	8✔
118	@as_json	8✔
119	def get(self, id: int, user: UserModel):	8✔
120	"""API endpoint to get a user.
121
122	.. :quickref: User; Get a user
123
124	This endpoint gets a user.
125	Only admins or the members of the same account can use this endpoint.
126
127	Example response
128
129	.. sourcecode:: json
130
131	{
132	'account_id': 1,
133	'active': True,
134	'email': 'test_prosumer@seita.nl',
135	'flexmeasures_roles': [1, 3],
136	'id': 1,
137	'timezone': 'Europe/Amsterdam',
138	'username': 'Test Prosumer User'
139	}
140
141	:reqheader Authorization: The authentication token
142	:reqheader Content-Type: application/json
143	:resheader Content-Type: application/json
144	:status 200: PROCESSED
145	:status 400: INVALID_REQUEST, REQUIRED_INFO_MISSING, UNEXPECTED_PARAMS
146	:status 401: UNAUTHORIZED
147	:status 403: INVALID_SENDER
148	:status 422: UNPROCESSABLE_ENTITY
149	"""
150	return user_schema.dump(user), 200	8✔
151
152	@route("/<id>", methods=["PATCH"])	8✔
153	@use_kwargs(partial_user_schema)	8✔
154	@use_kwargs({"user": UserIdField(data_key="id")}, location="path")	8✔
155	@permission_required_for_context("update", ctx_arg_name="user")	8✔
156	@as_json	8✔
157	def patch(self, id: int, user: UserModel, **user_data):	8✔
158	"""API endpoint to patch user data.
159
160	.. :quickref: User; Patch data for an existing user
161
162	This endpoint sets data for an existing user.
163	It has to be used by the user themselves, admins or account-admins (of the same account).
164	Any subset of user fields can be sent.
165	If the user is not an (account-)admin, they can only edit a few of their own fields.
166
167	The following fields are not allowed to be updated at all:
168	- id
169	- account_id
170
171	Example request
172
173	.. sourcecode:: json
174
175	{
176	"active": false,
177	}
178
179	Example response
180
181	The following user fields are returned:
182
183	.. sourcecode:: json
184
185	{
186	'account_id': 1,
187	'active': True,
188	'email': 'test_prosumer@seita.nl',
189	'flexmeasures_roles': [1, 3],
190	'id': 1,
191	'timezone': 'Europe/Amsterdam',
192	'username': 'Test Prosumer User'
193	}
194
195	:reqheader Authorization: The authentication token
196	:reqheader Content-Type: application/json
197	:resheader Content-Type: application/json
198	:status 200: UPDATED
199	:status 400: INVALID_REQUEST, REQUIRED_INFO_MISSING, UNEXPECTED_PARAMS
200	:status 401: UNAUTHORIZED
201	:status 403: INVALID_SENDER
202	:status 422: UNPROCESSABLE_ENTITY
203	"""
204	allowed_fields = [	8✔
205	"email",
206	"username",
207	"active",
208	"timezone",
209	"flexmeasures_roles",
210	]
211	for k, v in [(k, v) for k, v in user_data.items() if k in allowed_fields]:	8!
212	if current_user.id == user.id and k in ("active", "flexmeasures_roles"):	8✔
213	raise Forbidden(	8✔
214	"Users who edit themselves cannot edit security-sensitive fields."
215	)
216	setattr(user, k, v)	8✔
217	if k == "active" and v is False:	8✔
218	remove_cookie_and_token_access(user)	8✔
219	if k == "active":	8!
220	active_user_id, active_user_name = None, None	8✔
221	if hasattr(current_user, "id"):	8✔
222	active_user_id, active_user_name = (	8✔
223	current_user.id,
224	current_user.username,
225	)
226	user_audit_log = AuditLog(	8!
227	event_datetime=server_now(),
228	event=f"Active status set to '{v}' for user {user.username}",
229	active_user_id=active_user_id,
230	active_user_name=active_user_name,
231	affected_user_id=user.id,
232	affected_account_id=user.account_id,
233	)
234	db.session.add(user_audit_log)	8✔
235	db.session.add(user)	8✔
236	try:	8✔
237	db.session.commit()	8✔
238	except IntegrityError as ie:	×
239	return (	×
240	dict(message="Duplicate user already exists", detail=ie._message()),
241	400,
242	)
243	return user_schema.dump(user), 200	8✔
244
245	@route("/<id>/password-reset", methods=["PATCH"])	8✔
246	@use_kwargs({"user": UserIdField(data_key="id")}, location="path")	8✔
247	@permission_required_for_context("update", ctx_arg_name="user")	8✔
248	@as_json	8✔
249	def reset_user_password(self, id: int, user: UserModel):	8✔
250	"""API endpoint to reset the user's current password, cookies and auth tokens, and to email a password reset link to the user.
251
252	.. :quickref: User; Password reset
253
254	Reset the user's password, and send them instructions on how to reset the password.
255	This endpoint is useful from a security standpoint, in case of worries the password might be compromised.
256	It sets the current password to something random, invalidates cookies and auth tokens,
257	and also sends an email for resetting the password to the user.
258
259	Users can reset their own passwords. Only admins can use this endpoint to reset passwords of other users.
260
261	:reqheader Authorization: The authentication token
262	:reqheader Content-Type: application/json
263	:resheader Content-Type: application/json
264	:status 200: PROCESSED
265	:status 400: INVALID_REQUEST, REQUIRED_INFO_MISSING, UNEXPECTED_PARAMS
266	:status 401: UNAUTHORIZED
267	:status 403: INVALID_SENDER
268	:status 422: UNPROCESSABLE_ENTITY
269	"""
270	set_random_password(user)	8✔
271	remove_cookie_and_token_access(user)	8✔
272	send_reset_password_instructions(user)	8✔
273
274	# commit only if sending instructions worked, as well
275	db.session.commit()	8✔
276
277	@route("/<id>/auditlog")	8✔
278	@use_kwargs({"user": UserIdField(data_key="id")}, location="path")	8✔
279	@permission_required_for_context(	8✔
280	"read",
281	ctx_arg_name="user",
282	pass_ctx_to_loader=True,
283	ctx_loader=AuditLog.user_table_acl,
284	)
285	@as_json	8✔
286	def auditlog(self, id: int, user: UserModel):	8✔
287	"""API endpoint to get history of user actions.
288	Example response
289
290	.. sourcecode:: json
291	[
292	{
293	'event': 'User test user deleted',
294	'event_datetime': '2021-01-01T00:00:00',
295	'active_user_name': 'Test user',
296	}
297	]
298
299	:reqheader Authorization: The authentication token
300	:reqheader Content-Type: application/json
301	:resheader Content-Type: application/json
302	:status 200: PROCESSED
303	:status 400: INVALID_REQUEST, REQUIRED_INFO_MISSING, UNEXPECTED_PARAMS
304	:status 401: UNAUTHORIZED
305	:status 403: INVALID_SENDER
306	:status 422: UNPROCESSABLE_ENTITY
307	"""
308	audit_logs = get_audit_log_records(user)	8✔
309	audit_logs = [	8✔
310	{
311	k: getattr(log, k)
312	for k in (
313	"event",
314	"event_datetime",
315	"active_user_name",
316	"active_user_id",
317	)
318	}
319	for log in audit_logs
320	]
321	return audit_logs, 200	8✔

FlexMeasures / flexmeasures / 10673535382

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous