10727718438

Committed 05 Sep 2024 08:05PM UTC coverage: 67.402% (-0.02%) from 67.425%

Build # 10727718438

Build Type

Pull #1164

github

Committed by

Flix6x

Commit Message

feature: allow grouping words as one search key

Signed-off-by: F.N. Claessen <felix@seita.nl>

Pull Request Pull Request #1164: Asset search filter applies to both asset names and account names

Run Details

6177 of 10018 branches covered (61.66%)

Branch coverage included in aggregate %.

4 of 7 new or added lines in 1 file covered. (57.14%)

7 existing lines in 1 file now uncovered.

7815 of 10741 relevant lines covered (72.76%)

5.76 hits per line

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

84.38

/flexmeasures/api/v3_0/assets.py

from __future__ import annotations

from shlex import split
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, or_, and_

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).
            - If a 'filter' sentence such as 'solar "ACME corp"' is provided, the response will filter out assets where each word is either present in their name or account name.
              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)
        )

        select_statement = select(GenericAsset)
        if filter is not None:
            # Words in the filter should either come back in the asset name or account name
            select_statement = select_statement.join(
                Account, Account.id == GenericAsset.account_id
            )
            terms = split(filter)
            filter_statement = filter_statement & and_(
                *(
                    or_(
                        GenericAsset.name.ilike(f"%{term}%"),
                        Account.name.ilike(f"%{term}%"),
                    )
                    for term in terms
                )
            )

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

FlexMeasures / flexmeasures / 10727718438

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