goosebit 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

goosebit/schema/software.py

@@ -1,37 +1,42 @@
 from __future__ import annotations
 
-import asyncio
+from urllib.parse import unquote, urlparse
+from urllib.request import url2pathname
 
-from pydantic import BaseModel
-
-from goosebit.db.models import Hardware, Software
+from anyio import Path
+from pydantic import BaseModel, ConfigDict, Field, computed_field
 
 
 class HardwareSchema(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
     id: int
     model: str
     revision: str
 
-    @classmethod
-    async def convert(cls, hardware: Hardware):
-        return cls(id=hardware.id, model=hardware.model, revision=hardware.revision)
-
 
 class SoftwareSchema(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
     id: int
-    name: str
+    uri: str = Field(exclude=True)
     size: int
     hash: str
     version: str
     compatibility: list[HardwareSchema]
 
-    @classmethod
-    async def convert(cls, software: Software):
-        return cls(
-            id=software.id,
-            name=software.path_user,
-            size=software.size,
-            hash=software.hash,
-            version=software.version,
-            compatibility=await asyncio.gather(*[HardwareSchema.convert(h) for h in software.compatibility]),
-        )
+    @property
+    def path(self) -> Path:
+        return Path(url2pathname(unquote(urlparse(self.uri).path)))
+
+    @property
+    def local(self) -> bool:
+        return urlparse(self.uri).scheme == "file"
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def name(self) -> str:
+        if self.local:
+            return self.path.name
+        else:
+            return self.uri

goosebit/settings/schema.py

@@ -52,6 +52,8 @@ class GooseBitSettings(BaseSettings):
 
     logging: dict = LOGGING_DEFAULT
 
+    track_device_ip: bool = True
+
     @classmethod
     def settings_customise_sources(
         cls,

goosebit/ui/bff/common/requests.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from enum import StrEnum
+
+from pydantic import BaseModel, computed_field
+
+
+class DataTableSearchSchema(BaseModel):
+    value: str | None = None
+    regex: bool | None = False
+
+
+class DataTableOrderDirection(StrEnum):
+    ASCENDING = "asc"
+    DESCENDING = "desc"
+
+
+class DataTableOrderSchema(BaseModel):
+    column: int | None = None
+    dir: DataTableOrderDirection | None = None
+    name: str | None = None
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def direction(self) -> str:
+        return "-" if self.dir == DataTableOrderDirection.DESCENDING else ""
+
+
+class DataTableRequest(BaseModel):
+    draw: int = 1
+    order: list[DataTableOrderSchema] = list()
+    start: int = 0
+    length: int | None = None
+    search: DataTableSearchSchema = DataTableSearchSchema()
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def order_query(self) -> str | None:
+        try:
+            if len(self.order) == 0 or self.order[0].direction is None or self.order[0].name is None:
+                return None
+            return f"{self.order[0].direction}{self.order[0].name}"
+        except LookupError:
+            return None

goosebit/ui/bff/common/responses.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class DTColumnDescription(BaseModel):
+    title: str
+    data: str
+    name: str | None = None
+
+    searchable: bool | None = None
+    orderable: bool | None = None
+
+
+class DTColumns(BaseModel):
+    columns: list[DTColumnDescription]

goosebit/ui/bff/common/util.py

@@ -0,0 +1,32 @@
+from fastapi.requests import Request
+
+from goosebit.ui.bff.common.requests import DataTableRequest
+
+
+def parse_datatables_query(request: Request):
+    # parsing adapted from https://github.com/ziiiio/datatable_ajax_request_parser
+
+    result = {}
+    for key, value in request.query_params.items():
+        key_list = key.replace("][", ";").replace("[", ";").replace("]", "").split(";")
+
+        if len(key_list) == 0:
+            continue
+
+        if len(key_list) == 1:
+            result[key] = value[0] if len(value) == 1 else value
+            continue
+
+        temp_dict = result
+        for inner_key in key_list[:-1]:
+            if inner_key not in temp_dict:
+                temp_dict.update({inner_key: {}})
+            temp_dict = temp_dict[inner_key]
+        temp_dict[key_list[-1]] = value[0] if len(value) == 1 else value
+
+    if result.get("columns"):
+        result["columns"] = [result["columns"][str(idx)] for idx, _ in enumerate(result["columns"])]
+    if result.get("order"):
+        result["order"] = [result["order"][str(idx)] for idx, _ in enumerate(result["order"])]
+
+    return DataTableRequest.model_validate(result)

goosebit/ui/bff/devices/responses.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
-import asyncio
+from typing import Callable
 
-from fastapi.requests import Request
 from pydantic import BaseModel, Field
+from tortoise.queryset import QuerySet
 
 from goosebit.schema.devices import DeviceSchema
+from goosebit.ui.bff.common.requests import DataTableRequest
 
 
 class BFFDeviceResponse(BaseModel):
@@ -15,25 +16,20 @@ class BFFDeviceResponse(BaseModel):
     records_filtered: int = Field(serialization_alias="recordsFiltered")
 
     @classmethod
-    async def convert(cls, request: Request, query, search_filter, total_records):
-        params = request.query_params
+    async def convert(cls, dt_query: DataTableRequest, query: QuerySet, search_filter: Callable):
+        total_records = await query.count()
+        if dt_query.search.value:
+            query = query.filter(search_filter(dt_query.search.value))
 
-        draw = int(params.get("draw", 1))
-        start = int(params.get("start", 0))
-        length = int(params.get("length", 10))
-        search_value = params.get("search[value]", None)
-        order_column_index = params.get("order[0][column]", None)
-        order_column = params.get(f"columns[{order_column_index}][data]", None)
-        order_dir = params.get("order[0][dir]", None)
+        filtered_records = await query.count()
 
-        if search_value:
-            query = query.filter(search_filter(search_value))
+        if dt_query.order_query:
+            query = query.order_by(dt_query.order_query)
 
-        if order_column:
-            query = query.order_by(f"{'-' if order_dir == 'desc' else ''}{order_column}")
+        if dt_query.length is not None:
+            query = query.limit(dt_query.length)
 
-        filtered_records = await query.count()
-        devices = await query.offset(start).limit(length).all()
-        data = await asyncio.gather(*[DeviceSchema.convert(d) for d in devices])
+        devices = await query.offset(dt_query.start).all()
+        data = [DeviceSchema.model_validate(d) for d in devices]
 
-        return cls(data=data, draw=draw, records_total=total_records, records_filtered=filtered_records)
+        return cls(data=data, draw=dt_query.draw, records_total=total_records, records_filtered=filtered_records)

goosebit/ui/bff/devices/routes.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
-from fastapi import APIRouter, Security
+import asyncio
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Security
 from fastapi.requests import Request
 from tortoise.expressions import Q
 
@@ -8,8 +11,14 @@ from goosebit.api.responses import StatusResponse
 from goosebit.api.v1.devices import routes
 from goosebit.auth import validate_user_permissions
 from goosebit.db.models import Device, Software, UpdateModeEnum, UpdateStateEnum
+from goosebit.schema.devices import DeviceSchema
+from goosebit.schema.software import SoftwareSchema
+from goosebit.settings import config
+from goosebit.ui.bff.common.requests import DataTableRequest
+from goosebit.ui.bff.common.util import parse_datatables_query
 from goosebit.updater.manager import get_update_manager
 
+from ..common.responses import DTColumnDescription, DTColumns
 from .requests import DevicesPatchRequest
 from .responses import BFFDeviceResponse
 
@@ -18,10 +27,10 @@ router = APIRouter(prefix="/devices")
 
 @router.get(
     "",
-    dependencies=[Security(validate_user_permissions, scopes=["home.read"])],
+    dependencies=[Security(validate_user_permissions, scopes=["device.read"])],
 )
-async def devices_get(request: Request) -> BFFDeviceResponse:
-    def search_filter(search_value):
+async def devices_get(dt_query: Annotated[DataTableRequest, Depends(parse_datatables_query)]) -> BFFDeviceResponse:
+    def search_filter(search_value: str):
         return (
             Q(uuid__icontains=search_value)
             | Q(name__icontains=search_value)
@@ -31,10 +40,20 @@ async def devices_get(request: Request) -> BFFDeviceResponse:
             | Q(last_state=int(UpdateStateEnum.from_str(search_value)))
         )
 
-    query = Device.all().prefetch_related("assigned_software", "hardware")
-    total_records = await Device.all().count()
+    query = Device.all().prefetch_related("assigned_software", "hardware", "assigned_software__compatibility")
+
+    response = await BFFDeviceResponse.convert(dt_query, query, search_filter)
+
+    async def set_assigned_sw(d: DeviceSchema):
+        updater = await get_update_manager(d.uuid)
+        _, target = await updater.get_update()
+        if target is not None:
+            await target.fetch_related("compatibility")
+            d.assigned_software = SoftwareSchema.model_validate(target)
+        return d
 
-    return await BFFDeviceResponse.convert(request, query, search_filter, total_records)
+    response.data = await asyncio.gather(*[set_assigned_sw(d) for d in response.data])
+    return response
 
 
 @router.patch(
@@ -70,3 +89,38 @@ router.add_api_route(
     dependencies=[Security(validate_user_permissions, scopes=["device.delete"])],
     name="bff_devices_delete",
 )
+
+
+@router.get(
+    "/columns",
+    dependencies=[Security(validate_user_permissions, scopes=["device.read"])],
+    response_model_exclude_none=True,
+)
+async def devices_get_columns() -> DTColumns:
+    columns = []
+    columns.append(DTColumnDescription(title="Online", data="online"))
+    columns.append(DTColumnDescription(title="UUID", data="uuid", name="uuid", searchable=True, orderable=True))
+    columns.append(DTColumnDescription(title="Name", data="name", name="name", searchable=True, orderable=True))
+    columns.append(DTColumnDescription(title="Model", data="hw_model"))
+    columns.append(DTColumnDescription(title="Revision", data="hw_revision"))
+    columns.append(DTColumnDescription(title="Feed", data="feed", name="feed", searchable=True, orderable=True))
+    columns.append(
+        DTColumnDescription(
+            title="Installed Software", data="sw_version", name="sw_version", searchable=True, orderable=True
+        )
+    )
+    columns.append(DTColumnDescription(title="Target Software", data="sw_target_version"))
+    columns.append(
+        DTColumnDescription(
+            title="Update Mode", data="update_mode", name="update_mode", searchable=True, orderable=True
+        )
+    )
+    columns.append(
+        DTColumnDescription(title="State", data="last_state", name="last_state", searchable=True, orderable=True)
+    )
+    columns.append(DTColumnDescription(title="Force Update", data="force_update"))
+    columns.append(DTColumnDescription(title="Progress", data="progress"))
+    if config.track_device_ip:
+        columns.append(DTColumnDescription(title="Last IP", data="last_ip"))
+    columns.append(DTColumnDescription(title="Last Seen", data="last_seen"))
+    return DTColumns(columns=columns)

goosebit/ui/bff/rollouts/responses.py

@@ -1,9 +1,10 @@
-import asyncio
+from typing import Callable
 
-from fastapi.requests import Request
 from pydantic import BaseModel, Field
+from tortoise.queryset import QuerySet
 
 from goosebit.schema.rollouts import RolloutSchema
+from goosebit.ui.bff.common.requests import DataTableRequest
 
 
 class BFFRolloutsResponse(BaseModel):
@@ -13,25 +14,20 @@ class BFFRolloutsResponse(BaseModel):
     records_filtered: int = Field(serialization_alias="recordsFiltered")
 
     @classmethod
-    async def convert(cls, request: Request, query, search_filter, total_records):
-        params = request.query_params
+    async def convert(cls, dt_query: DataTableRequest, query: QuerySet, search_filter: Callable):
+        total_records = await query.count()
+        if dt_query.search.value:
+            query = query.filter(search_filter(dt_query.search.value))
 
-        draw = int(params.get("draw", 1))
-        start = int(params.get("start", 0))
-        length = int(params.get("length", 10))
-        search_value = params.get("search[value]", None)
-        order_column_index = params.get("order[0][column]", None)
-        order_column = params.get(f"columns[{order_column_index}][data]", None)
-        order_dir = params.get("order[0][dir]", None)
+        filtered_records = await query.count()
 
-        if search_value:
-            query = query.filter(search_filter(search_value))
+        if dt_query.order_query:
+            query = query.order_by(dt_query.order_query)
 
-        if order_column:
-            query = query.order_by(f"{'-' if order_dir == 'desc' else ''}{order_column}")
+        if dt_query.length is not None:
+            query = query.limit(dt_query.length)
 
-        filtered_records = await query.count()
-        rollouts = await query.offset(start).limit(length).all()
-        data = await asyncio.gather(*[RolloutSchema.convert(r) for r in rollouts])
+        rollouts = await query.offset(dt_query.start).all()
+        data = [RolloutSchema.model_validate(r) for r in rollouts]
 
-        return cls(data=data, draw=draw, records_total=total_records, records_filtered=filtered_records)
+        return cls(data=data, draw=dt_query.draw, records_total=total_records, records_filtered=filtered_records)

goosebit/ui/bff/rollouts/routes.py

@@ -1,10 +1,13 @@
-from fastapi import APIRouter, Security
-from fastapi.requests import Request
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Security
 from tortoise.expressions import Q
 
 from goosebit.api.v1.rollouts import routes
 from goosebit.auth import validate_user_permissions
 from goosebit.db.models import Rollout
+from goosebit.ui.bff.common.requests import DataTableRequest
+from goosebit.ui.bff.common.util import parse_datatables_query
 
 from .responses import BFFRolloutsResponse
 
@@ -15,14 +18,13 @@ router = APIRouter(prefix="/rollouts")
     "",
     dependencies=[Security(validate_user_permissions, scopes=["rollout.read"])],
 )
-async def rollouts_get(request: Request) -> BFFRolloutsResponse:
+async def rollouts_get(dt_query: Annotated[DataTableRequest, Depends(parse_datatables_query)]) -> BFFRolloutsResponse:
     def search_filter(search_value):
         return Q(name__icontains=search_value) | Q(feed__icontains=search_value)
 
-    query = Rollout.all().prefetch_related("software")
-    total_records = await Rollout.all().count()
+    query = Rollout.all().prefetch_related("software", "software__compatibility")
 
-    return await BFFRolloutsResponse.convert(request, query, search_filter, total_records)
+    return await BFFRolloutsResponse.convert(dt_query, query, search_filter)
 
 
 router.add_api_route(

goosebit/ui/bff/routes.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends
+
+from goosebit.auth import validate_current_user
 
 from . import devices, download, rollouts, software
 
-router = APIRouter(prefix="/bff", tags=["bff"])
+router = APIRouter(prefix="/bff", tags=["bff"], dependencies=[Depends(validate_current_user)])
 router.include_router(devices.router)
 router.include_router(software.router)
 router.include_router(rollouts.router)

goosebit/ui/bff/software/responses.py

@@ -1,9 +1,11 @@
-import asyncio
+from typing import Callable
 
-from fastapi.requests import Request
 from pydantic import BaseModel, Field
+from tortoise.expressions import Q
+from tortoise.queryset import QuerySet
 
 from goosebit.schema.software import SoftwareSchema
+from goosebit.ui.bff.common.requests import DataTableOrderDirection, DataTableRequest
 
 
 class BFFSoftwareResponse(BaseModel):
@@ -13,25 +15,33 @@ class BFFSoftwareResponse(BaseModel):
     records_filtered: int = Field(serialization_alias="recordsFiltered")
 
     @classmethod
-    async def convert(cls, request: Request, query, search_filter, total_records):
-        params = request.query_params
+    async def convert(cls, dt_query: DataTableRequest, query: QuerySet, search_filter: Callable, alt_filter: Q):
+        total_records = await query.count()
+        query = query.filter(alt_filter)
+        if dt_query.search.value:
+            query = query.filter(search_filter(dt_query.search.value))
 
-        draw = int(params.get("draw", 1))
-        start = int(params.get("start", 0))
-        length = int(params.get("length", 10))
-        search_value = params.get("search[value]", None)
-        order_column_index = params.get("order[0][column]", None)
-        order_column = params.get(f"columns[{order_column_index}][data]", None)
-        order_dir = params.get("order[0][dir]", None)
+        filtered_records = await query.count()
 
-        if search_value:
-            query = query.filter(search_filter(search_value))
+        if len(dt_query.order) > 0 and dt_query.order[0].name == "version":
+            # ordering cannot be delegated to database as semantic versioning sorting is not supported
+            software = await query.all()
+            reverse = dt_query.order[0].dir == DataTableOrderDirection.DESCENDING
+            software.sort(key=lambda s: s.parsed_version, reverse=reverse)
 
-        if order_column:
-            query = query.order_by(f"{'-' if order_dir == 'desc' else ''}{order_column}")
+            # in-memory paging
+            if dt_query.length is None:
+                software = software[dt_query.start :]
+            else:
+                software = software[dt_query.start : dt_query.start + dt_query.length]
 
-        filtered_records = await query.count()
-        devices = await query.offset(start).limit(length).all()
-        data = await asyncio.gather(*[SoftwareSchema.convert(d) for d in devices])
+        else:
+            # if no ordering is specified, database-side paging can be used
+            if dt_query.length is not None:
+                query = query.limit(dt_query.length)
+
+            software = await query.offset(dt_query.start).all()
+
+        data = [SoftwareSchema.model_validate(s) for s in software]
 
-        return cls(data=data, draw=draw, records_total=total_records, records_filtered=filtered_records)
+        return cls(data=data, draw=dt_query.draw, records_total=total_records, records_filtered=filtered_records)

goosebit/ui/bff/software/routes.py

@@ -1,14 +1,18 @@
 from __future__ import annotations
 
-import aiofiles
-from fastapi import APIRouter, Form, HTTPException, Security, UploadFile
+from typing import Annotated
+
+from anyio import Path, open_file
+from fastapi import APIRouter, Depends, Form, HTTPException, Query, Security, UploadFile
 from fastapi.requests import Request
 from tortoise.expressions import Q
 
 from goosebit.api.v1.software import routes
 from goosebit.auth import validate_user_permissions
-from goosebit.db.models import Rollout, Software
+from goosebit.db.models import Hardware, Rollout, Software
 from goosebit.settings import config
+from goosebit.ui.bff.common.requests import DataTableRequest
+from goosebit.ui.bff.common.util import parse_datatables_query
 from goosebit.updates import create_software_update
 
 from .responses import BFFSoftwareResponse
@@ -20,14 +24,23 @@ router = APIRouter(prefix="/software")
     "",
     dependencies=[Security(validate_user_permissions, scopes=["software.read"])],
 )
-async def software_get(request: Request) -> BFFSoftwareResponse:
+async def software_get(
+    dt_query: Annotated[DataTableRequest, Depends(parse_datatables_query)],
+    uuids: list[str] = Query(default=None),
+) -> BFFSoftwareResponse:
+    filters: list[Q] = []
+
     def search_filter(search_value):
-        return Q(uri__icontains=search_value) | Q(version__icontains=search_value)
+        base_filter = Q(Q(uri__icontains=search_value), Q(version__icontains=search_value), join_type="OR")
+        return Q(base_filter, *filters, join_type="AND")
 
     query = Software.all().prefetch_related("compatibility")
-    total_records = await Software.all().count()
 
-    return await BFFSoftwareResponse.convert(request, query, search_filter, total_records)
+    if uuids:
+        hardware = await Hardware.filter(devices__uuid__in=uuids).distinct()
+        filters.append(Q(*[Q(compatibility__id=c.id) for c in hardware], join_type="AND"))
+
+    return await BFFSoftwareResponse.convert(dt_query, query, search_filter, Q(*filters))
 
 
 router.add_api_route(
@@ -64,20 +77,20 @@ async def post_update(
         await create_software_update(url, None)
     else:
         # local file
-        file = config.artifacts_dir.joinpath(filename)
-        config.artifacts_dir.mkdir(parents=True, exist_ok=True)
+        artifacts_dir = Path(config.artifacts_dir)
+        file = artifacts_dir.joinpath(filename)
+        await artifacts_dir.mkdir(parents=True, exist_ok=True)
 
         temp_file = file.with_suffix(".tmp")
         if init:
-            temp_file.unlink(missing_ok=True)
-
-        contents = await chunk.read()
+            await temp_file.unlink(missing_ok=True)
 
-        async with aiofiles.open(temp_file, mode="ab") as f:
-            await f.write(contents)
+        async with await open_file(temp_file, "ab") as f:
+            await f.write(await chunk.read())
 
         if done:
             try:
-                await create_software_update(file.absolute().as_uri(), temp_file)
+                absolute = await file.absolute()
+                await create_software_update(absolute.as_uri(), temp_file)
             finally:
-                temp_file.unlink(missing_ok=True)
+                await temp_file.unlink(missing_ok=True)

goosebit/ui/nav.py

@@ -2,7 +2,7 @@ class Navigation:
     def __init__(self):
         self.items = []
 
-    def route(self, text: str, permissions: str = None):
+    def route(self, text: str, permissions: str | None = None):
         def decorator(func):
             self.items.append({"function": func.__name__, "text": text, "permissions": permissions})
             return func

goosebit/ui/routes.py

@@ -11,54 +11,45 @@ from .templates import templates
 
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="login")
 
-router = APIRouter(prefix="/ui", dependencies=[Depends(redirect_if_unauthenticated)], include_in_schema=False)
+router = APIRouter(prefix="/ui", include_in_schema=False)
 router.include_router(bff.router)
 
 
-@router.get("")
+@router.get("", dependencies=[Depends(redirect_if_unauthenticated)])
 async def ui_root(request: Request):
-    return RedirectResponse(request.url_for("home_ui"))
-
-
-@router.get(
-    "/home",
-    dependencies=[Security(validate_user_permissions, scopes=["home.read"])],
-)
-@nav.route("Home", permissions=["home.read"])
-async def home_ui(request: Request):
-    return templates.TemplateResponse(request, "index.html.jinja", context={"title": "Home"})
+    return RedirectResponse(request.url_for("devices_ui"))
 
 
 @router.get(
     "/devices",
-    dependencies=[Security(validate_user_permissions, scopes=["device.read"])],
+    dependencies=[Depends(redirect_if_unauthenticated), Security(validate_user_permissions, scopes=["device.read"])],
 )
-@nav.route("Devices", permissions=["device.read"])
+@nav.route("Devices", permissions="device.read")
 async def devices_ui(request: Request):
     return templates.TemplateResponse(request, "devices.html.jinja", context={"title": "Devices"})
 
 
 @router.get(
     "/software",
-    dependencies=[Security(validate_user_permissions, scopes=["software.read"])],
+    dependencies=[Depends(redirect_if_unauthenticated), Security(validate_user_permissions, scopes=["software.read"])],
 )
-@nav.route("Software", permissions=["software.read"])
+@nav.route("Software", permissions="software.read")
 async def software_ui(request: Request):
     return templates.TemplateResponse(request, "software.html.jinja", context={"title": "Software"})
 
 
 @router.get(
     "/rollouts",
-    dependencies=[Security(validate_user_permissions, scopes=["rollout.read"])],
+    dependencies=[Depends(redirect_if_unauthenticated), Security(validate_user_permissions, scopes=["rollout.read"])],
 )
-@nav.route("Rollouts", permissions=["rollout.read"])
+@nav.route("Rollouts", permissions="rollout.read")
 async def rollouts_ui(request: Request):
     return templates.TemplateResponse(request, "rollouts.html.jinja", context={"title": "Rollouts"})
 
 
 @router.get(
     "/logs/{dev_id}",
-    dependencies=[Security(validate_user_permissions, scopes=["device.read"])],
+    dependencies=[Depends(redirect_if_unauthenticated), Security(validate_user_permissions, scopes=["device.read"])],
 )
 async def logs_ui(request: Request, dev_id: str):
     return templates.TemplateResponse(request, "logs.html.jinja", context={"title": "Log", "device": dev_id})