11797771484

Committed 12 Nov 2024 12:57PM UTC coverage: 67.081% (-0.03%) from 67.11%

Build # 11797771484

Build Type

Pull #1239

github

Committed by

joshuaunity

Commit Message

feat: sort asset table

Signed-off-by: joshuaunity <oghenerobojosh01@gmail.com>

Pull Request Pull Request #1239: feat: sort asset table

Run Details

6764 of 10963 branches covered (61.7%)

Branch coverage included in aggregate %.

1 of 5 new or added lines in 1 file covered. (20.0%)

10 existing lines in 1 file now uncovered.

7985 of 11024 relevant lines covered (72.43%)

7.16 hits per line

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

86.91

/flexmeasures/api/v3_0/assets.py

from __future__ import annotations
import json
from humanize import naturaldelta

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.queries.generic_assets import query_assets_by_search_terms
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.search import SearchFilterField
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
from flexmeasures.data.schemas.sensors import SensorSchema
from flexmeasures.data.models.time_series import Sensor


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


def get_accessible_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),
            "all_accessible": fields.Bool(
                data_key="all_accessible", load_default=False
            ),
            "include_public": fields.Bool(
                data_key="include_public", load_default=False
            ),
            "page": fields.Int(
                required=False, validate=validate.Range(min=1), load_default=None
            ),
            "per_page": fields.Int(
                required=False, validate=validate.Range(min=1), load_default=10
            ),
            "filter": SearchFilterField(required=False, load_default=None),
            "sort_by": fields.Str(
                required=False,
                load_default=None,
            ),
            "sort_dir": fields.Str(
                required=False,
                load_default=None,
            ),
        },
        location="query",
    )
    @as_json
    def index(
        self,
        account: Account | None,
        all_accessible: bool,
        include_public: bool,
        page: int | None = None,
        per_page: int | None = None,
        filter: list[str] | None = None,
        sort_by: str | None = None,
        sort_dir: str | None = None,
    ):
        """List all assets owned  by user's accounts, or a certain account or all accessible accounts.

        .. :quickref: Asset; Download asset list

        This endpoint returns all accessible assets by accounts.
        The `account_id` query parameter can be used to list assets from any account (if the user is allowed to read them). Per default, the user's account is used.
        Alternatively, the `all_accessible` query parameter can be used to list assets from all accounts the current_user has read-access to, plus all public assets. Defaults to `false`.
        The `include_public` query parameter can be used to include public assets in the response. 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 search 'filter' such as 'solar "ACME corp"' is provided, the response will filter out assets where each search term 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
        if all_accessible:
            accounts = get_accessible_accounts()
        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 or include_public:
            filter_statement = filter_statement | GenericAsset.account_id.is_(None)

        query = query_assets_by_search_terms(
            search_terms=filter, filter_statement=filter_statement
        )

        if sort_by is not None:
            valid_sort_columns = {
                "name": GenericAsset.name,
                "owner": GenericAsset.account_id,
            }

            if sort_by not in valid_sort_columns:
                return {"error": f"Invalid sort column: {sort_by}"}, 400

            query = query.order_by(
                valid_sort_columns[sort_by].asc()
                if sort_dir == "asc"
                else valid_sort_columns[sort_by].desc()
            )

        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
            )
            num_records = db.session.scalar(
                select(func.count(GenericAsset.id)).filter(filter_statement)
            )
            response = {
                "data": asset_schema.dump(select_pagination.items, many=True),
                "num-records": num_records,
                "filtered-records": select_pagination.total,
            }

        return response, 200

    @route(
        "/<id>/sensors",
        methods=["GET"],
    )
    @use_kwargs(
        {
            "asset": AssetIdField(data_key="id"),
        },
        location="path",
    )
    @use_kwargs(
        {
            "page": fields.Int(
                required=False, validate=validate.Range(min=1), dump_default=1
            ),
            "per_page": fields.Int(
                required=False, validate=validate.Range(min=1), dump_default=10
            ),
        },
        location="query",
    )
    @as_json
    def asset_sensors(
        self,
        id: int,
        asset: GenericAsset | None,
        page: int | None = None,
        per_page: int | None = None,
    ):
        """
        List all sensors under an asset.

         .. :quickref: Asset; Return all sensors under an asset.

        This endpoint returns all sensors under an asset.

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

        - If the `page` parameter is not provided, all sensors are returned, without pagination information. The result will be a list of sensors.
        - 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
        """
        query_statement = Sensor.generic_asset_id == asset.id

        query = select(Sensor).filter(query_statement)

        select_pagination: SelectPagination = db.paginate(
            query, per_page=per_page, page=page
        )

        num_records = db.session.scalar(
            select(func.count(Sensor.id)).where(query_statement)
        )

        sensors_response: list = [
            {
                **sensor_schema.dump(sensor),
                "event_resolution": naturaldelta(sensor.event_resolution),
            }
            for sensor in select_pagination.items
        ]

        response = {
            "data": sensors_response,
            "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"Updated Attr: {attr_key}, From: {current_attributes.get(attr_key)}, To: {attr_value}"
                        )
                continue
            audit_log_data.append(
                f"Updated Field: {k}, From: {getattr(db_asset, k)}, To: {v}"
            )

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

FlexMeasures / flexmeasures / 11797771484

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