10700118976

Committed 04 Sep 2024 10:45AM UTC coverage: 67.425% (+0.01%) from 67.413%

Build # 10700118976

Build Type

Pull #988

github

Committed by

web-flow

Commit Message

Merge branch 'main' into feature/crud/get-from-index-endpoint

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

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

Run Details

6177 of 10012 branches covered (61.7%)

Branch coverage included in aggregate %.

85 of 99 new or added lines in 9 files covered. (85.86%)

7 existing lines in 2 files now uncovered.

7813 of 10737 relevant lines covered (72.77%)

5.76 hits per line

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

86.2

/flexmeasures/api/v3_0/assets.py

from __future__ import annotations

import json

from flask import current_app
from flask_classful import FlaskView, route
from flask_login import current_user
from flask_security import auth_required
from flask_json import as_json
from flask_sqlalchemy.pagination import SelectPagination

from marshmallow import fields
import marshmallow.validate as validate

from webargs.flaskparser import use_kwargs, use_args
from sqlalchemy import select, delete, func

from flexmeasures.auth.decorators import permission_required_for_context
from flexmeasures.data import db
from flexmeasures.data.models.user import Account
from flexmeasures.data.models.audit_log import AssetAuditLog
from flexmeasures.data.models.generic_assets import GenericAsset
from flexmeasures.data.schemas import AwareDateTimeField
from flexmeasures.data.schemas.generic_assets import GenericAssetSchema as AssetSchema
from flexmeasures.api.common.schemas.generic_assets import AssetIdField
from flexmeasures.api.common.schemas.users import AccountIdField
from flexmeasures.utils.coding_utils import flatten_unique
from flexmeasures.ui.utils.view_utils import set_session_variables
from flexmeasures.auth.policy import check_access
from werkzeug.exceptions import Forbidden, Unauthorized


asset_schema = AssetSchema()
assets_schema = AssetSchema(many=True)
partial_asset_schema = AssetSchema(partial=True, exclude=["account_id"])


def get_acessible_accounts() -> list[Account]:
    accounts = []
    for _account in db.session.scalars(select(Account)).all():
        try:
            check_access(_account, "read")
            accounts.append(_account)
        except (Forbidden, Unauthorized):
            pass

    return accounts


class AssetAPI(FlaskView):
    """
    This API view exposes generic assets.
    """

    route_base = "/assets"
    trailing_slash = False
    decorators = [auth_required()]

    @route("", methods=["GET"])
    @use_kwargs(
        {
            "account": AccountIdField(data_key="account_id", load_default=None),
        },
        location="query",
    )
    @use_kwargs(
        {
            "all_accessible": fields.Bool(
                data_key="all_accessible", load_default=False
            ),
        },
        location="query",
    )
    @use_kwargs(
        {
            "page": fields.Int(
                required=False, validate=validate.Range(min=1), default=1
            ),
            "per_page": fields.Int(
                required=False, validate=validate.Range(min=1), default=10
            ),
            "filter": fields.Str(required=False, default=None),
        },
        location="query",
    )
    @as_json
    def index(
        self,
        account: Account | None,
        all_accessible: bool,
        page: int | None = None,
        per_page: int | None = None,
        filter: str | None = None,
    ):
        """List all assets owned or accessible by a certain account.

        .. :quickref: Asset; Download asset list

        This endpoint returns all accessible assets for the account of the user.
        The `account_id` query parameter can be used to list assets from a different account.
        The `all_accessible` query parameter can be used to list assets not only from the current user's account, but from all accounts the current_user has read-access to, plus all public assets. Defaults to `false`.

        The endpoint supports pagination of the asset list using the `page` and `per_page` query parameters.

            - If the `page` parameter is not provided, all assets are returned, without pagination information. The result will be a list of assets.
            - If a `page` parameter is provided, the response will be paginated, showing a specific number of assets per page as defined by `per_page` (default is 10).
              The response schema for pagination is inspired by https://datatables.net/manual/server-side#Returned-data


        **Example response**

        An example of one asset being returned in a paginated response:

        .. sourcecode:: json

            {
                "data" : [
                    {
                      "id": 1,
                      "name": "Test battery",
                      "latitude": 10,
                      "longitude": 100,
                      "account_id": 2,
                      "generic_asset_type": {"id": 1, "name": "battery"}
                    }
                ],
                "num-records" : 1,
                "filtered-records" : 1

            }

        If no pagination is requested, the response only consists of the list under the "data" key.

        :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
        """

        # find out which accounts are relevant
        accounts = []
        if all_accessible:
            accounts = get_acessible_accounts()
            if account is not None:
                check_access(account, "read")
        else:
            if account is None:
                account = current_user.account
            check_access(account, "read")
            accounts = [account]

        filter_statement = GenericAsset.account_id.in_([a.id for a in accounts])

        # add public assets if the request asks for all the accessible assets
        if all_accessible:
            filter_statement = filter_statement | GenericAsset.account_id.is_(None)

        num_records = db.session.scalar(
            select(func.count(GenericAsset.id)).where(filter_statement)
        )

        if filter is not None:
            filter_statement = filter_statement & GenericAsset.name.ilike(f"%{filter}%")

        query = select(GenericAsset).where(filter_statement)

        if page is None:
            response = asset_schema.dump(db.session.scalars(query).all(), many=True)
        else:
            if per_page is None:
                per_page = 10

            select_pagination: SelectPagination = db.paginate(
                query, per_page=per_page, page=page
            )
            response = {
                "data": asset_schema.dump(select_pagination.items, many=True),
                "num-records": num_records,
                "filtered-records": select_pagination.total,
            }

        return response, 200

    @route("/public", methods=["GET"])
    @as_json
    def public(self):
        """Return all public assets.

        .. :quickref: Asset; Return all public assets.

        This endpoint returns all public assets.

        :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 422: UNPROCESSABLE_ENTITY
        """
        assets = db.session.scalars(
            select(GenericAsset).filter(GenericAsset.account_id.is_(None))
        ).all()
        return assets_schema.dump(assets), 200

    @route("", methods=["POST"])
    @permission_required_for_context(
        "create-children", ctx_loader=AccountIdField.load_current
    )
    @use_args(asset_schema)
    def post(self, asset_data: dict):
        """Create new asset.

        .. :quickref: Asset; Create a new asset

        This endpoint creates a new asset.

        **Example request**

        .. sourcecode:: json

            {
                "name": "Test battery",
                "generic_asset_type_id": 2,
                "account_id": 2,
                "latitude": 40,
                "longitude": 170.3,
            }


        The newly posted asset is returned in the response.

        :reqheader Authorization: The authentication token
        :reqheader Content-Type: application/json
        :resheader Content-Type: application/json
        :status 201: CREATED
        :status 400: INVALID_REQUEST
        :status 401: UNAUTHORIZED
        :status 403: INVALID_SENDER
        :status 422: UNPROCESSABLE_ENTITY
        """
        inflexible_sensor_ids = asset_data.pop("inflexible_device_sensor_ids", [])
        asset = GenericAsset(**asset_data)
        db.session.add(asset)
        # assign asset id
        db.session.flush()

        asset.set_inflexible_sensors(inflexible_sensor_ids)
        db.session.commit()

        AssetAuditLog.add_record(asset, f"Created asset '{asset.name}': {asset.id}")

        return asset_schema.dump(asset), 201

    @route("/<id>", methods=["GET"])
    @use_kwargs({"asset": AssetIdField(data_key="id")}, location="path")
    @permission_required_for_context("read", ctx_arg_name="asset")
    @as_json
    def fetch_one(self, id, asset):
        """Fetch a given asset.

        .. :quickref: Asset; Get an asset

        This endpoint gets an asset.

        **Example response**

        .. sourcecode:: json

            {
                "generic_asset_type_id": 2,
                "name": "Test battery",
                "id": 1,
                "latitude": 10,
                "longitude": 100,
                "account_id": 1,
            }

        :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 asset_schema.dump(asset), 200

    @route("/<id>", methods=["PATCH"])
    @use_args(partial_asset_schema)
    @use_kwargs({"db_asset": AssetIdField(data_key="id")}, location="path")
    @permission_required_for_context("update", ctx_arg_name="db_asset")
    @as_json
    def patch(self, asset_data: dict, id: int, db_asset: GenericAsset):
        """Update an asset given its identifier.

        .. :quickref: Asset; Update an asset

        This endpoint sets data for an existing asset.
        Any subset of asset fields can be sent.

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

        **Example request**

        .. sourcecode:: json

            {
                "latitude": 11.1,
                "longitude": 99.9,
            }


        **Example response**

        The whole asset is returned in the response:

        .. sourcecode:: json

            {
                "generic_asset_type_id": 2,
                "id": 1,
                "latitude": 11.1,
                "longitude": 99.9,
                "name": "Test battery",
                "account_id": 2,
            }

        :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
        """
        inflexible_sensor_ids = asset_data.pop("inflexible_device_sensor_ids", [])
        db_asset.set_inflexible_sensors(inflexible_sensor_ids)

        audit_log_data = list()
        for k, v in asset_data.items():
            if getattr(db_asset, k) == v:
                continue
            if k == "attributes":
                current_attributes = getattr(db_asset, k)
                for attr_key, attr_value in v.items():
                    if current_attributes.get(attr_key) != attr_value:
                        audit_log_data.append(
                            f"Attribute name: {attr_key}, Old value: {current_attributes.get(attr_key)}, New value: {attr_value}"
                        )
                continue
            audit_log_data.append(
                f"Field name: {k}, Old value: {getattr(db_asset, k)}, New value: {v}"
            )
        audit_log_event = f"Updated asset '{db_asset.name}': {db_asset.id} fields: {'; '.join(audit_log_data)}"
        AssetAuditLog.add_record(db_asset, audit_log_event)

        for k, v in asset_data.items():
            setattr(db_asset, k, v)
        db.session.add(db_asset)
        db.session.commit()
        return asset_schema.dump(db_asset), 200

    @route("/<id>", methods=["DELETE"])
    @use_kwargs({"asset": AssetIdField(data_key="id")}, location="path")
    @permission_required_for_context("delete", ctx_arg_name="asset")
    @as_json
    def delete(self, id: int, asset: GenericAsset):
        """Delete an asset given its identifier.

        .. :quickref: Asset; Delete an asset

        This endpoint deletes an existing asset, as well as all sensors and measurements recorded for it.

        :reqheader Authorization: The authentication token
        :reqheader Content-Type: application/json
        :resheader Content-Type: application/json
        :status 204: DELETED
        :status 400: INVALID_REQUEST, REQUIRED_INFO_MISSING, UNEXPECTED_PARAMS
        :status 401: UNAUTHORIZED
        :status 403: INVALID_SENDER
        :status 422: UNPROCESSABLE_ENTITY
        """
        asset_name, asset_id = asset.name, asset.id
        AssetAuditLog.add_record(asset, f"Deleted asset '{asset_name}': {asset_id}")

        db.session.execute(delete(GenericAsset).filter_by(id=asset.id))
        db.session.commit()
        current_app.logger.info("Deleted asset '%s'." % asset_name)
        return {}, 204

    @route("/<id>/chart", strict_slashes=False)  # strict on next version? see #1014
    @use_kwargs(
        {"asset": AssetIdField(data_key="id")},
        location="path",
    )
    @use_kwargs(
        {
            "event_starts_after": AwareDateTimeField(format="iso", required=False),
            "event_ends_before": AwareDateTimeField(format="iso", required=False),
            "beliefs_after": AwareDateTimeField(format="iso", required=False),
            "beliefs_before": AwareDateTimeField(format="iso", required=False),
            "include_data": fields.Boolean(required=False),
            "dataset_name": fields.Str(required=False),
            "height": fields.Str(required=False),
            "width": fields.Str(required=False),
        },
        location="query",
    )
    @permission_required_for_context("read", ctx_arg_name="asset")
    def get_chart(self, id: int, asset: GenericAsset, **kwargs):
        """GET from /assets/<id>/chart

        .. :quickref: Chart; Download a chart with time series
        """
        # Store selected time range as session variables, for a consistent UX across UI page loads
        set_session_variables("event_starts_after", "event_ends_before")
        return json.dumps(asset.chart(**kwargs))

    @route(
        "/<id>/chart_data", strict_slashes=False
    )  # strict on next version? see #1014
    @use_kwargs(
        {"asset": AssetIdField(data_key="id")},
        location="path",
    )
    @use_kwargs(
        {
            "event_starts_after": AwareDateTimeField(format="iso", required=False),
            "event_ends_before": AwareDateTimeField(format="iso", required=False),
            "beliefs_after": AwareDateTimeField(format="iso", required=False),
            "beliefs_before": AwareDateTimeField(format="iso", required=False),
            "most_recent_beliefs_only": fields.Boolean(required=False),
        },
        location="query",
    )
    @permission_required_for_context("read", ctx_arg_name="asset")
    def get_chart_data(self, id: int, asset: GenericAsset, **kwargs):
        """GET from /assets/<id>/chart_data

        .. :quickref: Chart; Download time series for use in charts

        Data for use in charts (in case you have the chart specs already).
        """
        sensors = flatten_unique(asset.sensors_to_show)
        return asset.search_beliefs(sensors=sensors, as_json=True, **kwargs)

    @route("/<id>/auditlog")
    @use_kwargs(
        {"asset": AssetIdField(data_key="id")},
        location="path",
    )
    @permission_required_for_context("read", ctx_arg_name="asset")
    @as_json
    def auditlog(self, id: int, asset: GenericAsset):
        """API endpoint to get history of asset related actions.
        **Example response**

        .. sourcecode:: json
            [
                {
                    'event': 'Asset test asset 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 = (
            db.session.query(AssetAuditLog).filter_by(affected_asset_id=asset.id).all()
        )
        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 __future__ import annotations	8✔
2
3	import json	8✔
4
5	from flask import current_app	8✔
6	from flask_classful import FlaskView, route	8✔
7	from flask_login import current_user	8✔
8	from flask_security import auth_required	8✔
9	from flask_json import as_json	8✔
10	from flask_sqlalchemy.pagination import SelectPagination	8✔
11
12	from marshmallow import fields	8✔
13	import marshmallow.validate as validate	8✔
14
15	from webargs.flaskparser import use_kwargs, use_args	8✔
16	from sqlalchemy import select, delete, func	8✔
17
18	from flexmeasures.auth.decorators import permission_required_for_context	8✔
19	from flexmeasures.data import db	8✔
20	from flexmeasures.data.models.user import Account	8✔
21	from flexmeasures.data.models.audit_log import AssetAuditLog	8✔
22	from flexmeasures.data.models.generic_assets import GenericAsset	8✔
23	from flexmeasures.data.schemas import AwareDateTimeField	8✔
24	from flexmeasures.data.schemas.generic_assets import GenericAssetSchema as AssetSchema	8✔
25	from flexmeasures.api.common.schemas.generic_assets import AssetIdField	8✔
26	from flexmeasures.api.common.schemas.users import AccountIdField	8✔
27	from flexmeasures.utils.coding_utils import flatten_unique	8✔
28	from flexmeasures.ui.utils.view_utils import set_session_variables	8✔
29	from flexmeasures.auth.policy import check_access	8✔
30	from werkzeug.exceptions import Forbidden, Unauthorized	8✔
31
32
33	asset_schema = AssetSchema()	8✔
34	assets_schema = AssetSchema(many=True)	8✔
35	partial_asset_schema = AssetSchema(partial=True, exclude=["account_id"])	8✔
36
37
38	def get_acessible_accounts() -> list[Account]:	8✔
39	accounts = []	8✔
40	for _account in db.session.scalars(select(Account)).all():	8✔
41	try:	8✔
42	check_access(_account, "read")	8✔
43	accounts.append(_account)	8✔
44	except (Forbidden, Unauthorized):	8✔
45	pass	8✔
46
47	return accounts	8✔
48
49
50	class AssetAPI(FlaskView):	8✔
51	"""	4✔
52	This API view exposes generic assets.
53	"""
54
55	route_base = "/assets"	8✔
56	trailing_slash = False	8✔
57	decorators = [auth_required()]	8✔
58
59	@route("", methods=["GET"])	8✔
60	@use_kwargs(	8✔
61	{
62	"account": AccountIdField(data_key="account_id", load_default=None),
63	},
64	location="query",
65	)
66	@use_kwargs(	8✔
67	{
68	"all_accessible": fields.Bool(
69	data_key="all_accessible", load_default=False
70	),
71	},
72	location="query",
73	)
74	@use_kwargs(	8✔
75	{
76	"page": fields.Int(
77	required=False, validate=validate.Range(min=1), default=1
78	),
79	"per_page": fields.Int(
80	required=False, validate=validate.Range(min=1), default=10
81	),
82	"filter": fields.Str(required=False, default=None),
83	},
84	location="query",
85	)
86	@as_json	8✔
87	def index(	8✔
88	self,
89	account: Account \| None,
90	all_accessible: bool,
91	page: int \| None = None,
92	per_page: int \| None = None,
93	filter: str \| None = None,
94	):
95	"""List all assets owned or accessible by a certain account.
96
97	.. :quickref: Asset; Download asset list
98
99	This endpoint returns all accessible assets for the account of the user.
100	The `account_id` query parameter can be used to list assets from a different account.
101	The `all_accessible` query parameter can be used to list assets not only from the current user's account, but from all accounts the current_user has read-access to, plus all public assets. Defaults to `false`.
102
103	The endpoint supports pagination of the asset list using the `page` and `per_page` query parameters.
104
105	- If the `page` parameter is not provided, all assets are returned, without pagination information. The result will be a list of assets.
106	- If a `page` parameter is provided, the response will be paginated, showing a specific number of assets per page as defined by `per_page` (default is 10).
107	The response schema for pagination is inspired by https://datatables.net/manual/server-side#Returned-data
108
109
110	Example response
111
112	An example of one asset being returned in a paginated response:
113
114	.. sourcecode:: json
115
116	{
117	"data" : [
118	{
119	"id": 1,
120	"name": "Test battery",
121	"latitude": 10,
122	"longitude": 100,
123	"account_id": 2,
124	"generic_asset_type": {"id": 1, "name": "battery"}
125	}
126	],
127	"num-records" : 1,
128	"filtered-records" : 1
129
130	}
131
132	If no pagination is requested, the response only consists of the list under the "data" key.
133
134	:reqheader Authorization: The authentication token
135	:reqheader Content-Type: application/json
136	:resheader Content-Type: application/json
137	:status 200: PROCESSED
138	:status 400: INVALID_REQUEST
139	:status 401: UNAUTHORIZED
140	:status 403: INVALID_SENDER
141	:status 422: UNPROCESSABLE_ENTITY
142	"""
143
144	# find out which accounts are relevant
145	accounts = []	8✔
146	if all_accessible:	8✔
NEW 147	accounts = get_acessible_accounts()	×
NEW 148	if account is not None:	×
NEW 149	check_access(account, "read")	×
150	else:
151	if account is None:	8✔
152	account = current_user.account	8✔
153	check_access(account, "read")	8✔
154	accounts = [account]	8✔
155
156	filter_statement = GenericAsset.account_id.in_([a.id for a in accounts])	8!
157
158	# add public assets if the request asks for all the accessible assets
159	if all_accessible:	8✔
NEW 160	filter_statement = filter_statement \| GenericAsset.account_id.is_(None)	×
161
162	num_records = db.session.scalar(	8✔
163	select(func.count(GenericAsset.id)).where(filter_statement)
164	)
165
166	if filter is not None:	8✔
NEW 167	filter_statement = filter_statement & GenericAsset.name.ilike(f"%{filter}%")	×
168
169	query = select(GenericAsset).where(filter_statement)	8✔
170
171	if page is None:	8✔
172	response = asset_schema.dump(db.session.scalars(query).all(), many=True)	8✔
173	else:
174	if per_page is None:	8✔
175	per_page = 10	8✔
176
177	select_pagination: SelectPagination = db.paginate(	8!
178	query, per_page=per_page, page=page
179	)
180	response = {	8✔
181	"data": asset_schema.dump(select_pagination.items, many=True),
182	"num-records": num_records,
183	"filtered-records": select_pagination.total,
184	}
185
186	return response, 200	8✔
187
188	@route("/public", methods=["GET"])	8✔
189	@as_json	8✔
190	def public(self):	8✔
191	"""Return all public assets.
192
193	.. :quickref: Asset; Return all public assets.
194
195	This endpoint returns all public assets.
196
197	:reqheader Authorization: The authentication token
198	:reqheader Content-Type: application/json
199	:resheader Content-Type: application/json
200	:status 200: PROCESSED
201	:status 400: INVALID_REQUEST
202	:status 401: UNAUTHORIZED
203	:status 422: UNPROCESSABLE_ENTITY
204	"""
205	assets = db.session.scalars(	8✔
206	select(GenericAsset).filter(GenericAsset.account_id.is_(None))
207	).all()
208	return assets_schema.dump(assets), 200	8✔
209
210	@route("", methods=["POST"])	8✔
211	@permission_required_for_context(	8✔
212	"create-children", ctx_loader=AccountIdField.load_current
213	)
214	@use_args(asset_schema)	8✔
215	def post(self, asset_data: dict):	8✔
216	"""Create new asset.
217
218	.. :quickref: Asset; Create a new asset
219
220	This endpoint creates a new asset.
221
222	Example request
223
224	.. sourcecode:: json
225
226	{
227	"name": "Test battery",
228	"generic_asset_type_id": 2,
229	"account_id": 2,
230	"latitude": 40,
231	"longitude": 170.3,
232	}
233
234
235	The newly posted asset is returned in the response.
236
237	:reqheader Authorization: The authentication token
238	:reqheader Content-Type: application/json
239	:resheader Content-Type: application/json
240	:status 201: CREATED
241	:status 400: INVALID_REQUEST
242	:status 401: UNAUTHORIZED
243	:status 403: INVALID_SENDER
244	:status 422: UNPROCESSABLE_ENTITY
245	"""
246	inflexible_sensor_ids = asset_data.pop("inflexible_device_sensor_ids", [])	8✔
247	asset = GenericAsset(**asset_data)	8✔
248	db.session.add(asset)	8✔
249	# assign asset id
250	db.session.flush()	8✔
251
252	asset.set_inflexible_sensors(inflexible_sensor_ids)	8✔
253	db.session.commit()	8✔
254
255	AssetAuditLog.add_record(asset, f"Created asset '{asset.name}': {asset.id}")	8✔
256
257	return asset_schema.dump(asset), 201	8✔
258
259	@route("/<id>", methods=["GET"])	8✔
260	@use_kwargs({"asset": AssetIdField(data_key="id")}, location="path")	8✔
261	@permission_required_for_context("read", ctx_arg_name="asset")	8✔
262	@as_json	8✔
263	def fetch_one(self, id, asset):	8✔
264	"""Fetch a given asset.
265
266	.. :quickref: Asset; Get an asset
267
268	This endpoint gets an asset.
269
270	Example response
271
272	.. sourcecode:: json
273
274	{
275	"generic_asset_type_id": 2,
276	"name": "Test battery",
277	"id": 1,
278	"latitude": 10,
279	"longitude": 100,
280	"account_id": 1,
281	}
282
283	:reqheader Authorization: The authentication token
284	:reqheader Content-Type: application/json
285	:resheader Content-Type: application/json
286	:status 200: PROCESSED
287	:status 400: INVALID_REQUEST, REQUIRED_INFO_MISSING, UNEXPECTED_PARAMS
288	:status 401: UNAUTHORIZED
289	:status 403: INVALID_SENDER
290	:status 422: UNPROCESSABLE_ENTITY
291	"""
292	return asset_schema.dump(asset), 200	8✔
293
294	@route("/<id>", methods=["PATCH"])	8✔
295	@use_args(partial_asset_schema)	8✔
296	@use_kwargs({"db_asset": AssetIdField(data_key="id")}, location="path")	8✔
297	@permission_required_for_context("update", ctx_arg_name="db_asset")	8✔
298	@as_json	8✔
299	def patch(self, asset_data: dict, id: int, db_asset: GenericAsset):	8✔
300	"""Update an asset given its identifier.
301
302	.. :quickref: Asset; Update an asset
303
304	This endpoint sets data for an existing asset.
305	Any subset of asset fields can be sent.
306
307	The following fields are not allowed to be updated:
308	- id
309	- account_id
310
311	Example request
312
313	.. sourcecode:: json
314
315	{
316	"latitude": 11.1,
317	"longitude": 99.9,
318	}
319
320
321	Example response
322
323	The whole asset is returned in the response:
324
325	.. sourcecode:: json
326
327	{
328	"generic_asset_type_id": 2,
329	"id": 1,
330	"latitude": 11.1,
331	"longitude": 99.9,
332	"name": "Test battery",
333	"account_id": 2,
334	}
335
336	:reqheader Authorization: The authentication token
337	:reqheader Content-Type: application/json
338	:resheader Content-Type: application/json
339	:status 200: UPDATED
340	:status 400: INVALID_REQUEST, REQUIRED_INFO_MISSING, UNEXPECTED_PARAMS
341	:status 401: UNAUTHORIZED
342	:status 403: INVALID_SENDER
343	:status 422: UNPROCESSABLE_ENTITY
344	"""
345	inflexible_sensor_ids = asset_data.pop("inflexible_device_sensor_ids", [])	8✔
346	db_asset.set_inflexible_sensors(inflexible_sensor_ids)	8✔
347
348	audit_log_data = list()	8✔
349	for k, v in asset_data.items():	8✔
350	if getattr(db_asset, k) == v:	8✔
351	continue	8✔
352	if k == "attributes":	8✔
353	current_attributes = getattr(db_asset, k)	×
354	for attr_key, attr_value in v.items():	×
355	if current_attributes.get(attr_key) != attr_value:	×
356	audit_log_data.append(	×
357	f"Attribute name: {attr_key}, Old value: {current_attributes.get(attr_key)}, New value: {attr_value}"
358	)
359	continue	×
360	audit_log_data.append(	8✔
361	f"Field name: {k}, Old value: {getattr(db_asset, k)}, New value: {v}"
362	)
363	audit_log_event = f"Updated asset '{db_asset.name}': {db_asset.id} fields: {'; '.join(audit_log_data)}"	8✔
364	AssetAuditLog.add_record(db_asset, audit_log_event)	8✔
365
366	for k, v in asset_data.items():	8✔
367	setattr(db_asset, k, v)	8✔
368	db.session.add(db_asset)	8✔
369	db.session.commit()	8✔
370	return asset_schema.dump(db_asset), 200	8✔
371
372	@route("/<id>", methods=["DELETE"])	8✔
373	@use_kwargs({"asset": AssetIdField(data_key="id")}, location="path")	8✔
374	@permission_required_for_context("delete", ctx_arg_name="asset")	8✔
375	@as_json	8✔
376	def delete(self, id: int, asset: GenericAsset):	8✔
377	"""Delete an asset given its identifier.
378
379	.. :quickref: Asset; Delete an asset
380
381	This endpoint deletes an existing asset, as well as all sensors and measurements recorded for it.
382
383	:reqheader Authorization: The authentication token
384	:reqheader Content-Type: application/json
385	:resheader Content-Type: application/json
386	:status 204: DELETED
387	:status 400: INVALID_REQUEST, REQUIRED_INFO_MISSING, UNEXPECTED_PARAMS
388	:status 401: UNAUTHORIZED
389	:status 403: INVALID_SENDER
390	:status 422: UNPROCESSABLE_ENTITY
391	"""
392	asset_name, asset_id = asset.name, asset.id	8✔
393	AssetAuditLog.add_record(asset, f"Deleted asset '{asset_name}': {asset_id}")	8✔
394
395	db.session.execute(delete(GenericAsset).filter_by(id=asset.id))	8✔
396	db.session.commit()	8✔
397	current_app.logger.info("Deleted asset '%s'." % asset_name)	8✔
398	return {}, 204	8✔
399
400	@route("/<id>/chart", strict_slashes=False) # strict on next version? see #1014	8✔
401	@use_kwargs(	8✔
402	{"asset": AssetIdField(data_key="id")},
403	location="path",
404	)
405	@use_kwargs(	8✔
406	{
407	"event_starts_after": AwareDateTimeField(format="iso", required=False),
408	"event_ends_before": AwareDateTimeField(format="iso", required=False),
409	"beliefs_after": AwareDateTimeField(format="iso", required=False),
410	"beliefs_before": AwareDateTimeField(format="iso", required=False),
411	"include_data": fields.Boolean(required=False),
412	"dataset_name": fields.Str(required=False),
413	"height": fields.Str(required=False),
414	"width": fields.Str(required=False),
415	},
416	location="query",
417	)
418	@permission_required_for_context("read", ctx_arg_name="asset")	8✔
419	def get_chart(self, id: int, asset: GenericAsset, **kwargs):	8✔
420	"""GET from /assets/<id>/chart
421
422	.. :quickref: Chart; Download a chart with time series
423	"""
424	# Store selected time range as session variables, for a consistent UX across UI page loads
425	set_session_variables("event_starts_after", "event_ends_before")	×
426	return json.dumps(asset.chart(**kwargs))	×
427
428	@route(	8✔
429	"/<id>/chart_data", strict_slashes=False
430	) # strict on next version? see #1014
431	@use_kwargs(	8✔
432	{"asset": AssetIdField(data_key="id")},
433	location="path",
434	)
435	@use_kwargs(	8✔
436	{
437	"event_starts_after": AwareDateTimeField(format="iso", required=False),
438	"event_ends_before": AwareDateTimeField(format="iso", required=False),
439	"beliefs_after": AwareDateTimeField(format="iso", required=False),
440	"beliefs_before": AwareDateTimeField(format="iso", required=False),
441	"most_recent_beliefs_only": fields.Boolean(required=False),
442	},
443	location="query",
444	)
445	@permission_required_for_context("read", ctx_arg_name="asset")	8✔
446	def get_chart_data(self, id: int, asset: GenericAsset, **kwargs):	8✔
447	"""GET from /assets/<id>/chart_data
448
449	.. :quickref: Chart; Download time series for use in charts
450
451	Data for use in charts (in case you have the chart specs already).
452	"""
453	sensors = flatten_unique(asset.sensors_to_show)	×
454	return asset.search_beliefs(sensors=sensors, as_json=True, **kwargs)	×
455
456	@route("/<id>/auditlog")	8✔
457	@use_kwargs(	8✔
458	{"asset": AssetIdField(data_key="id")},
459	location="path",
460	)
461	@permission_required_for_context("read", ctx_arg_name="asset")	8✔
462	@as_json	8✔
463	def auditlog(self, id: int, asset: GenericAsset):	8✔
464	"""API endpoint to get history of asset related actions.
465	Example response
466
467	.. sourcecode:: json
468	[
469	{
470	'event': 'Asset test asset deleted',
471	'event_datetime': '2021-01-01T00:00:00',
472	'active_user_name': 'Test user',
473	}
474	]
475
476	:reqheader Authorization: The authentication token
477	:reqheader Content-Type: application/json
478	:resheader Content-Type: application/json
479	:status 200: PROCESSED
480	:status 400: INVALID_REQUEST, REQUIRED_INFO_MISSING, UNEXPECTED_PARAMS
481	:status 401: UNAUTHORIZED
482	:status 403: INVALID_SENDER
483	:status 422: UNPROCESSABLE_ENTITY
484	"""
485	audit_logs = (	×
486	db.session.query(AssetAuditLog).filter_by(affected_asset_id=asset.id).all()
487	)
488	audit_logs = [	×
489	{
490	k: getattr(log, k)
491	for k in (
492	"event",
493	"event_datetime",
494	"active_user_name",
495	"active_user_id",
496	)
497	}
498	for log in audit_logs
499	]
500	return audit_logs, 200	×

FlexMeasures / flexmeasures / 10700118976

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