data-syncmaster 0.1.1__py3-none-any.whl

syncmaster/db/repositories/base.py

@@ -0,0 +1,109 @@
+# SPDX-FileCopyrightText: 2023-2024 MTS (Mobile Telesystems)
+# SPDX-License-Identifier: Apache-2.0
+from abc import ABC
+from typing import Any, Generic, TypeVar
+
+from sqlalchemy import ScalarResult, Select, and_, delete, func, insert, select, update
+from sqlalchemy.exc import NoResultFound
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from syncmaster.db.base import Base
+from syncmaster.db.utils import Pagination
+from syncmaster.exceptions import EntityNotFoundError
+
+Model = TypeVar("Model", bound=Base)
+
+
+class Repository(Generic[Model], ABC):
+    def __init__(self, model: type[Model], session: AsyncSession):
+        self._model = model
+        self._session = session
+
+    async def _read_by_id(self, id: int, **kwargs: Any) -> Model:
+        if hasattr(self._model, "is_deleted"):
+            query = select(self._model).filter_by(is_deleted=False, id=id, **kwargs)
+            obj = (await self._session.scalars(query)).first()
+        else:
+            obj = await self._session.get(self._model, id)
+        if obj is None:
+            raise EntityNotFoundError
+        return obj
+
+    @staticmethod
+    def _model_as_dict(model: Model) -> dict[str, Any]:
+        d = []
+        for c in model.__table__.columns:
+            if c.name == "id":  # 'id' is PK autoincrement
+                continue
+            d.append(c.name)
+
+        return {key: getattr(model, key) for key in d}
+
+    async def _copy(self, *args: Any, **kwargs: Any) -> Model:
+        query_prev_row = select(self._model).where(*args)
+        result_prev_row = await self._session.scalars(query_prev_row)
+        origin_model = result_prev_row.one()
+
+        d = self._model_as_dict(origin_model)
+
+        for k, v in kwargs.items():
+            if v is None:
+                kwargs.update({k: getattr(origin_model, k)})
+
+        d.update(kwargs)  # Process kwargs in order to keep only what needs to be updated
+        query_insert_new_row = insert(self._model).values(**d).returning(self._model)
+        try:
+            new_row = await self._session.scalars(query_insert_new_row)
+            await self._session.flush()
+            obj = new_row.one()
+        except NoResultFound as e:
+            raise EntityNotFoundError from e
+        return obj
+
+    async def _update(self, *args: Any, **kwargs: Any) -> Model:
+        query = update(self._model).where(*args).values(**kwargs).returning(self._model)
+        try:
+            result = await self._session.scalars(query)
+            await self._session.flush()
+            obj = result.one()
+        except NoResultFound as e:
+            raise EntityNotFoundError from e
+        return obj
+
+    async def _delete(self, id: int) -> Model:
+        if hasattr(self._model, "is_deleted"):
+            return await self._update(
+                and_(self._model.is_deleted.is_(False), self._model.id == id),
+                is_deleted=True,
+            )
+
+        query = delete(self._model).filter_by(id=id).returning(self._model)
+        result = await self._session.scalars(query)
+        await self._session.flush()
+        return result.one()
+
+    async def _paginate_raw_result(self, query: Select, page: int, page_size: int) -> Pagination:
+        items_result = await self._session.execute(query.limit(page_size).offset((page - 1) * page_size))
+        total: int = await self._session.scalar(select(func.count()).select_from(query.subquery()))
+        return Pagination(
+            items=items_result.all(),
+            total=total,
+            page=page,
+            page_size=page_size,
+        )
+
+    async def _paginate_scalar_result(self, query: Select, page: int, page_size: int) -> Pagination:
+        """
+        This method is needed for those queries where all fields are needed,
+        the scalars method discards all fields except the first
+        """
+        items_result: ScalarResult[Model] = await self._session.scalars(
+            query.limit(page_size).offset((page - 1) * page_size)
+        )
+        total: int = await self._session.scalar(select(func.count()).select_from(query.subquery()))
+        return Pagination(
+            items=items_result.all(),
+            total=total,
+            page=page,
+            page_size=page_size,
+        )

syncmaster/db/repositories/connection.py

@@ -0,0 +1,138 @@
+# SPDX-FileCopyrightText: 2023-2024 MTS (Mobile Telesystems)
+# SPDX-License-Identifier: Apache-2.0
+from typing import Any, NoReturn
+
+from sqlalchemy import ScalarResult, insert, select
+from sqlalchemy.exc import DBAPIError, IntegrityError, NoResultFound
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from syncmaster.db.models import Connection
+from syncmaster.db.repositories.repository_with_owner import RepositoryWithOwner
+from syncmaster.db.utils import Pagination
+from syncmaster.exceptions import EntityNotFoundError, SyncmasterError
+from syncmaster.exceptions.connection import (
+    ConnectionNotFoundError,
+    ConnectionOwnerError,
+    DuplicatedConnectionNameError,
+)
+from syncmaster.exceptions.group import GroupNotFoundError
+from syncmaster.exceptions.user import UserNotFoundError
+
+
+class ConnectionRepository(RepositoryWithOwner[Connection]):
+    def __init__(self, session: AsyncSession):
+        super().__init__(model=Connection, session=session)
+
+    async def paginate(
+        self,
+        page: int,
+        page_size: int,
+        group_id: int,
+    ) -> Pagination:
+        stmt = select(Connection).where(
+            Connection.is_deleted.is_(False),
+            Connection.group_id == group_id,
+        )
+
+        return await self._paginate_scalar_result(
+            query=stmt.order_by(Connection.name),
+            page=page,
+            page_size=page_size,
+        )
+
+    async def read_by_id(
+        self,
+        connection_id: int,
+    ) -> Connection:
+        stmt = select(Connection).where(Connection.id == connection_id, Connection.is_deleted.is_(False))
+        result: ScalarResult[Connection] = await self._session.scalars(stmt)
+        try:
+            return result.one()
+        except NoResultFound as e:
+            raise ConnectionNotFoundError from e
+
+    async def create(
+        self,
+        group_id: int,
+        name: str,
+        description: str,
+        data: dict[str, Any],
+    ) -> Connection:
+        query = (
+            insert(Connection)
+            .values(
+                group_id=group_id,
+                name=name,
+                description=description,
+                data=data,
+            )
+            .returning(Connection)
+        )
+        try:
+            result: ScalarResult[Connection] = await self._session.scalars(query)
+        except IntegrityError as e:
+            self._raise_error(e)
+        else:
+            await self._session.flush()
+            return result.one()
+
+    async def update(
+        self,
+        connection_id: int,
+        name: str | None,
+        description: str | None,
+        connection_data: dict[str, Any],
+    ) -> Connection:
+        try:
+            connection = await self.read_by_id(connection_id=connection_id)
+            for key in connection.data:
+                if key not in connection_data or connection_data[key] is None:
+                    connection_data[key] = connection.data[key]
+            return await self._update(
+                Connection.id == connection_id,
+                Connection.is_deleted.is_(False),
+                name=name or connection.name,
+                description=description or connection.description,
+                data=connection_data,
+            )
+        except IntegrityError as e:
+            self._raise_error(e)
+
+    async def delete(
+        self,
+        connection_id: int,
+    ) -> None:
+        try:
+            await self._delete(connection_id)
+        except (NoResultFound, EntityNotFoundError) as e:
+            raise ConnectionNotFoundError from e
+
+    async def copy(
+        self,
+        connection_id: int,
+        new_group_id: int,
+        new_name: str | None,
+    ) -> Connection:
+        try:
+            kwargs_for_copy = dict(group_id=new_group_id, name=new_name)
+            new_connection = await self._copy(
+                Connection.id == connection_id,
+                **kwargs_for_copy,
+            )
+
+            return new_connection
+
+        except IntegrityError as integrity_error:
+            self._raise_error(integrity_error)
+
+    def _raise_error(self, err: DBAPIError) -> NoReturn:
+        constraint = err.__cause__.__cause__.constraint_name
+        if constraint == "fk__connection__group_id__group":
+            raise GroupNotFoundError from err
+        if constraint == "fk__connection__user_id__user":
+            raise UserNotFoundError from err
+        if constraint == "ck__connection__owner_constraint":
+            raise ConnectionOwnerError from err
+        if constraint == "uq__connection__name_group_id":
+            raise DuplicatedConnectionNameError from err
+        raise SyncmasterError from err

syncmaster/db/repositories/credentials_repository.py

@@ -0,0 +1,87 @@
+# SPDX-FileCopyrightText: 2023-2024 MTS (Mobile Telesystems)
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import NoReturn
+
+from sqlalchemy import ScalarResult, delete, insert, select
+from sqlalchemy.exc import DBAPIError, IntegrityError, NoResultFound
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from syncmaster.config import Settings
+from syncmaster.db.models import AuthData
+from syncmaster.db.repositories.base import Repository
+from syncmaster.db.repositories.utils import decrypt_auth_data, encrypt_auth_data
+from syncmaster.exceptions import SyncmasterError
+from syncmaster.exceptions.credentials import AuthDataNotFoundError
+
+
+class CredentialsRepository(Repository[AuthData]):
+    def __init__(
+        self,
+        session: AsyncSession,
+        settings: Settings,
+        model: type[AuthData],
+    ):
+        super().__init__(model=model, session=session)
+        self._settings = settings
+
+    async def get_for_connection(
+        self,
+        connection_id: int,
+    ) -> dict:
+        query = select(AuthData).where(AuthData.connection_id == connection_id)
+        try:
+            result: ScalarResult[AuthData] = await self._session.scalars(query)
+            return decrypt_auth_data(result.one().value, settings=self._settings)
+        except NoResultFound as e:
+            raise AuthDataNotFoundError(f"Connection id = {connection_id}") from e
+
+    async def add_to_connection(self, connection_id: int, data: dict) -> AuthData:
+        query = (
+            insert(AuthData)
+            .values(
+                value=encrypt_auth_data(value=data, settings=self._settings),
+                connection_id=connection_id,
+            )
+            .returning(AuthData)
+        )
+        try:
+            result: ScalarResult[AuthData] = await self._session.scalars(query)
+        except IntegrityError as e:
+            self._raise_error(e)
+        else:
+            await self._session.flush()
+            return result.one()
+
+    async def delete_from_connection(self, connection_id: int) -> AuthData:
+        query = delete(AuthData).where(AuthData.connection_id == connection_id).returning(AuthData)
+
+        try:
+            result: ScalarResult[AuthData] = await self._session.scalars(query)
+        except IntegrityError as e:
+            self._raise_error(e)
+        else:
+            await self._session.flush()
+            return result.one()
+
+    async def update(
+        self,
+        connection_id: int,
+        credential_data: dict,
+    ) -> AuthData:
+        creds = await self.get_for_connection(connection_id)
+        try:
+            for key in creds:
+                if key not in credential_data or credential_data[key] is None:
+                    credential_data[key] = creds[key]
+
+            return await self._update(
+                AuthData.connection_id == connection_id,
+                value=encrypt_auth_data(value=credential_data, settings=self._settings),
+            )
+        except IntegrityError as e:
+            self._raise_error(e)
+
+    def _raise_error(self, err: DBAPIError) -> NoReturn:
+        raise SyncmasterError from err

syncmaster/db/repositories/group.py

@@ -0,0 +1,264 @@
+# SPDX-FileCopyrightText: 2023-2024 MTS (Mobile Telesystems)
+# SPDX-License-Identifier: Apache-2.0
+import re
+from typing import NoReturn
+
+from sqlalchemy import ScalarResult, insert, or_, select, update
+from sqlalchemy.exc import DBAPIError, IntegrityError, NoResultFound
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from syncmaster.db.models import Group, User, UserGroup
+from syncmaster.db.repositories.base import Repository
+from syncmaster.db.utils import Pagination, Permission
+from syncmaster.exceptions import EntityNotFoundError, SyncmasterError
+from syncmaster.exceptions.group import (
+    AlreadyIsGroupMemberError,
+    AlreadyIsNotGroupMemberError,
+    GroupAdminNotFoundError,
+    GroupAlreadyExistsError,
+    GroupNotFoundError,
+)
+from syncmaster.exceptions.user import UserNotFoundError
+
+
+class GroupRepository(Repository[Group]):
+    def __init__(self, session: AsyncSession):
+        super().__init__(model=Group, session=session)
+
+    async def paginate_all(
+        self,
+        page: int,
+        page_size: int,
+    ) -> Pagination:
+        stmt = select(Group).where(Group.is_deleted.is_(False))
+        return await self._paginate_scalar_result(query=stmt.order_by(Group.name), page=page, page_size=page_size)
+
+    async def paginate_for_user(
+        self,
+        page: int,
+        page_size: int,
+        current_user_id: int,
+    ):
+        stmt = (
+            select(Group)
+            .join(
+                UserGroup,
+                UserGroup.group_id == Group.id,
+            )
+            .where(
+                Group.is_deleted.is_(False),
+                or_(
+                    UserGroup.user_id == current_user_id,
+                    Group.owner_id == current_user_id,
+                ),
+            )
+            .group_by(Group.id)
+        )
+
+        return await self._paginate_scalar_result(query=stmt.order_by(Group.name), page=page, page_size=page_size)
+
+    async def read_by_id(
+        self,
+        group_id: int,
+    ) -> Group:
+        stmt = select(Group).where(Group.id == group_id, Group.is_deleted.is_(False))
+        try:
+            result: ScalarResult[Group] = await self._session.scalars(stmt)
+            return result.one()
+        except NoResultFound as e:
+            raise GroupNotFoundError from e
+
+    async def create(self, name: str, description: str, owner_id: int) -> Group:
+        query = (
+            insert(Group)
+            .values(
+                name=name,
+                description=description,
+                owner_id=owner_id,
+            )
+            .returning(Group)
+        )
+        try:
+            result: ScalarResult[Group] = await self._session.scalars(query)
+            await self._session.flush()
+        except IntegrityError as err:
+            self._raise_error(err)
+        else:
+            return result.one()
+
+    async def update(
+        self,
+        group_id: int,
+        name: str,
+        description: str,
+        owner_id: int,
+    ) -> Group:
+        args = [Group.id == group_id, Group.is_deleted.is_(False)]
+        try:
+            return await self._update(
+                *args,
+                name=name,
+                description=description,
+                owner_id=owner_id,
+            )
+        except EntityNotFoundError as e:
+            raise GroupNotFoundError from e
+        except IntegrityError as e:
+            self._raise_error(e)
+
+    async def update_member_role(
+        self,
+        group_id: int,
+        user_id: int,
+        role: str,
+    ):
+        try:
+            row_res = await self._session.scalars(
+                update(UserGroup)
+                .where(
+                    UserGroup.group_id == group_id,
+                    UserGroup.user_id == user_id,
+                )
+                .values(
+                    group_id=group_id,
+                    user_id=user_id,
+                    role=role,
+                )
+                .returning(UserGroup)
+            )
+            await self._session.flush()
+            obj = row_res.one_or_none()
+        except IntegrityError as err:
+            self._raise_error(err)
+
+        if not obj:
+            raise UserNotFoundError
+
+        return obj
+
+    async def get_member_paginate(
+        self,
+        page: int,
+        page_size: int,
+        group_id: int,
+    ) -> Pagination:
+        group = await self.read_by_id(group_id=group_id)
+        stmt = (
+            select(User, UserGroup.role)
+            .join(
+                UserGroup,
+                UserGroup.user_id == User.id,
+            )
+            .where(
+                User.is_deleted.is_(False),
+                User.is_active.is_(True),
+                UserGroup.group_id == group.id,
+            )
+            .order_by(User.username)
+        )
+        return await self._paginate_raw_result(stmt, page=page, page_size=page_size)
+
+    async def delete(self, group_id: int) -> None:
+        try:
+            await self._delete(group_id)
+        except EntityNotFoundError as e:
+            raise GroupNotFoundError from e
+
+    async def add_user(
+        self,
+        group_id: int,
+        new_user_id: int,
+        role: str,
+    ) -> None:
+        try:
+            await self._session.execute(
+                insert(UserGroup).values(
+                    group_id=group_id,
+                    user_id=new_user_id,
+                    role=role,
+                )
+            )
+        except IntegrityError as integrity_error:
+            self._raise_error(integrity_error)
+        else:
+            await self._session.flush()
+
+    async def get_group_permission(self, user: User, group_id: int) -> Permission:
+        """
+        Method for determining CRUD rights in a specified group
+        'DEVELOPER' and 'MAINTAINER' does not have WRITE and DELETE permission in the GROUP repository
+        """
+        # Check: group exists
+        if not await self._session.get(Group, group_id):
+            raise GroupNotFoundError
+
+        owner_query = (
+            (
+                select(Group).where(
+                    Group.owner_id == user.id,
+                    Group.id == group_id,
+                )
+            )
+            .exists()
+            .select()
+        )
+
+        is_owner = await self._session.scalar(owner_query)
+
+        if is_owner or user.is_superuser:
+            return Permission.DELETE
+
+        group_role_query = select(UserGroup).where(
+            UserGroup.group_id == group_id,
+            UserGroup.user_id == user.id,
+        )
+
+        user_group = await self._session.scalar(group_role_query)
+
+        if not user_group:
+            return Permission.NONE
+
+        return Permission.READ
+
+    async def delete_user(
+        self,
+        group_id: int,
+        target_user_id: int,
+    ) -> None:
+        user_group = await self._session.get(
+            UserGroup,
+            {
+                "group_id": group_id,
+                "user_id": target_user_id,
+            },
+        )
+        if user_group is None:
+            raise AlreadyIsNotGroupMemberError
+        await self._session.delete(user_group)
+        await self._session.flush()
+
+    def _raise_error(self, err: DBAPIError) -> NoReturn:
+        constraint = err.__cause__.__cause__.constraint_name
+
+        if constraint == "fk__group__owner_id__user":
+            raise GroupAdminNotFoundError from err
+
+        if constraint == "uq__group__name":
+            raise GroupAlreadyExistsError from err
+
+        if constraint == "pk__user_group":
+            raise AlreadyIsGroupMemberError from err
+
+        if constraint == "fk__user_group__group_id__group":
+            detail = err.__cause__.__cause__.detail
+            pattern = r'Key \(group_id\)=\(-?\d+\) is not present in table "group".'
+            if re.match(pattern, detail):
+                raise GroupNotFoundError from err
+
+        if constraint == "fk__user_group__user_id__user":
+            detail = err.__cause__.__cause__.detail
+            pattern = r'Key \(user_id\)=\(-?\d+\) is not present in table "user".'
+            if re.match(pattern, detail):
+                raise UserNotFoundError from err
+
+        raise SyncmasterError from err