data-syncmaster 0.1.1__py3-none-any.whl

syncmaster/backend/api/v1/connections.py

@@ -0,0 +1,300 @@
+# SPDX-FileCopyrightText: 2023-2024 MTS (Mobile Telesystems)
+# SPDX-License-Identifier: Apache-2.0
+import asyncio
+from typing import get_args
+
+from fastapi import APIRouter, Depends, Query, status
+from pydantic import SecretStr
+
+from syncmaster.backend.api.deps import UnitOfWorkMarker
+from syncmaster.backend.services import UnitOfWork, get_user
+from syncmaster.db.models import User
+from syncmaster.db.utils import Permission
+from syncmaster.exceptions import ActionNotAllowedError
+from syncmaster.exceptions.connection import (
+    ConnectionDeleteError,
+    ConnectionNotFoundError,
+)
+from syncmaster.exceptions.credentials import AuthDataNotFoundError
+from syncmaster.exceptions.group import GroupNotFoundError
+from syncmaster.schemas.v1.connection_types import ORACLE_TYPE, POSTGRES_TYPE
+from syncmaster.schemas.v1.connections.connection import (
+    ConnectionCopySchema,
+    ConnectionPageSchema,
+    CreateConnectionSchema,
+    ReadConnectionSchema,
+    UpdateConnectionSchema,
+)
+from syncmaster.schemas.v1.page import MetaPageSchema
+from syncmaster.schemas.v1.status import StatusResponseSchema
+
+router = APIRouter(tags=["Connections"])
+
+
+CONNECTION_TYPES = ORACLE_TYPE, POSTGRES_TYPE
+
+
+@router.get("/connections")
+async def read_connections(
+    group_id: int,
+    page: int = Query(gt=0, default=1),
+    page_size: int = Query(gt=0, le=200, default=20),
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> ConnectionPageSchema:
+    """Return connections in page format"""
+    resource_role = await unit_of_work.connection.get_group_permission(
+        user=current_user,
+        group_id=group_id,
+    )
+
+    if resource_role == Permission.NONE:
+        raise GroupNotFoundError
+
+    pagination = await unit_of_work.connection.paginate(
+        page=page,
+        page_size=page_size,
+        group_id=group_id,
+    )
+    items: list[ReadConnectionSchema] = []
+
+    if pagination.items:
+        creds = await asyncio.gather(
+            *[unit_of_work.credentials.get_for_connection(connection_id=item.id) for item in pagination.items]
+        )
+        items = [
+            ReadConnectionSchema(
+                id=item.id,
+                group_id=item.group_id,
+                name=item.name,
+                description=item.description,
+                auth_data=creds[n_item],
+                data=item.data,
+            )
+            for n_item, item in enumerate(pagination.items)
+        ]
+
+    return ConnectionPageSchema(
+        meta=MetaPageSchema(
+            page=pagination.page,
+            pages=pagination.pages,
+            total=pagination.total,
+            page_size=pagination.page_size,
+            has_next=pagination.has_next,
+            has_previous=pagination.has_previous,
+            next_page=pagination.next_page,
+            previous_page=pagination.previous_page,
+        ),
+        items=items,
+    )
+
+
+@router.post("/connections")
+async def create_connection(
+    connection_data: CreateConnectionSchema,
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> ReadConnectionSchema:
+    """Create new connection"""
+    group_permission = await unit_of_work.connection.get_group_permission(
+        user=current_user,
+        group_id=connection_data.group_id,
+    )
+    if group_permission == Permission.NONE:
+        raise GroupNotFoundError
+
+    if group_permission < Permission.WRITE:
+        raise ActionNotAllowedError
+
+    data = connection_data.data.dict()
+    auth_data = connection_data.auth_data.dict()
+
+    # Trick to serialize SecretStr to JSON
+    for k, v in auth_data.items():
+        if isinstance(v, SecretStr):
+            auth_data[k] = v.get_secret_value()
+    async with unit_of_work:
+        connection = await unit_of_work.connection.create(
+            name=connection_data.name,
+            description=connection_data.description,
+            group_id=connection_data.group_id,
+            data=data,
+        )
+
+        await unit_of_work.credentials.add_to_connection(
+            connection_id=connection.id,
+            data=auth_data,
+        )
+
+    return ReadConnectionSchema(
+        id=connection.id,
+        group_id=connection.group_id,
+        name=connection.name,
+        description=connection.description,
+        data=connection.data,
+        auth_data=auth_data,
+    )
+
+
+@router.get("/connections/known_types", dependencies=[Depends(get_user(is_active=True))])
+async def read_connection_types() -> list[str]:
+    return [get_args(type_)[0] for type_ in CONNECTION_TYPES]
+
+
+@router.get("/connections/{connection_id}")
+async def read_connection(
+    connection_id: int,
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> ReadConnectionSchema:
+    resource_role = await unit_of_work.connection.get_resource_permission(
+        user=current_user,
+        resource_id=connection_id,
+    )
+
+    if resource_role == Permission.NONE:
+        raise ConnectionNotFoundError
+
+    connection = await unit_of_work.connection.read_by_id(connection_id=connection_id)
+
+    try:
+        credentials = await unit_of_work.credentials.get_for_connection(
+            connection_id=connection.id,
+        )
+    except AuthDataNotFoundError:
+        credentials = None
+
+    return ReadConnectionSchema(
+        id=connection.id,
+        group_id=connection.group_id,
+        name=connection.name,
+        description=connection.description,
+        data=connection.data,
+        auth_data=credentials,
+    )
+
+
+@router.patch("/connections/{connection_id}")
+async def update_connection(
+    connection_id: int,
+    connection_data: UpdateConnectionSchema,
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> ReadConnectionSchema:
+    resource_role = await unit_of_work.connection.get_resource_permission(
+        user=current_user,
+        resource_id=connection_id,
+    )
+
+    if resource_role == Permission.NONE:
+        raise ConnectionNotFoundError
+
+    if resource_role < Permission.WRITE:
+        raise ActionNotAllowedError
+
+    async with unit_of_work:
+        connection = await unit_of_work.connection.update(
+            connection_id=connection_id,
+            name=connection_data.name,
+            description=connection_data.description,
+            connection_data=connection_data.data.dict(exclude={"auth_data"}) if connection_data.data else {},
+        )
+
+        if connection_data.auth_data:
+            await unit_of_work.credentials.update(
+                connection_id=connection_id,
+                credential_data=connection_data.auth_data.dict(),
+            )
+
+    auth_data = await unit_of_work.credentials.get_for_connection(connection_id)
+    return ReadConnectionSchema(
+        id=connection.id,
+        group_id=connection.group_id,
+        name=connection.name,
+        description=connection.description,
+        data=connection.data,
+        auth_data=auth_data,
+    )
+
+
+@router.delete("/connections/{connection_id}")
+async def delete_connection(
+    connection_id: int,
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> StatusResponseSchema:
+    resource_role = await unit_of_work.connection.get_resource_permission(
+        user=current_user,
+        resource_id=connection_id,
+    )
+
+    if resource_role == Permission.NONE:
+        raise ConnectionNotFoundError
+
+    if resource_role < Permission.DELETE:
+        raise ActionNotAllowedError
+
+    connection = await unit_of_work.connection.read_by_id(connection_id=connection_id)
+
+    transfers = await unit_of_work.transfer.list_by_connection_id(conn_id=connection.id)
+    async with unit_of_work:
+        if not transfers:
+            await unit_of_work.connection.delete(connection_id=connection_id)
+
+            return StatusResponseSchema(
+                ok=True,
+                status_code=status.HTTP_200_OK,
+                message="Connection was deleted",
+            )
+
+    raise ConnectionDeleteError(
+        f"The connection has an associated transfers. Number of the connected transfers: {len(transfers)}",
+    )
+
+
+@router.post("/connections/{connection_id}/copy_connection")
+async def copy_connection(
+    connection_id: int,
+    copy_connection_data: ConnectionCopySchema,
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> StatusResponseSchema:
+    target_source_rules = await asyncio.gather(
+        unit_of_work.connection.get_resource_permission(
+            user=current_user,
+            resource_id=connection_id,
+        ),
+        unit_of_work.connection.get_group_permission(
+            user=current_user,
+            group_id=copy_connection_data.new_group_id,
+        ),
+    )
+    resource_role, target_group_role = target_source_rules
+
+    if copy_connection_data.remove_source and resource_role < Permission.DELETE:
+        raise ActionNotAllowedError
+
+    if resource_role == Permission.NONE:
+        raise ConnectionNotFoundError
+
+    if target_group_role == Permission.NONE:
+        raise GroupNotFoundError
+
+    if target_group_role < Permission.WRITE:
+        raise ActionNotAllowedError
+
+    async with unit_of_work:
+        await unit_of_work.connection.copy(
+            connection_id=connection_id,
+            new_group_id=copy_connection_data.new_group_id,
+            new_name=copy_connection_data.new_name,
+        )
+
+        if copy_connection_data.remove_source:
+            await unit_of_work.connection.delete(connection_id=connection_id)
+
+    return StatusResponseSchema(
+        ok=True,
+        status_code=status.HTTP_200_OK,
+        message="Connection was copied",
+    )

syncmaster/backend/api/v1/groups.py

@@ -0,0 +1,225 @@
+# SPDX-FileCopyrightText: 2023-2024 MTS (Mobile Telesystems)
+# SPDX-License-Identifier: Apache-2.0
+from fastapi import APIRouter, Depends, Query
+
+from syncmaster.backend.api.deps import UnitOfWorkMarker
+from syncmaster.backend.services import UnitOfWork, get_user
+from syncmaster.db.models import User
+from syncmaster.db.utils import Permission
+from syncmaster.exceptions import ActionNotAllowedError
+from syncmaster.exceptions.group import GroupNotFoundError
+from syncmaster.schemas.v1.groups import (
+    AddUserSchema,
+    CreateGroupSchema,
+    GroupPageSchema,
+    ReadGroupSchema,
+    UpdateGroupSchema,
+)
+from syncmaster.schemas.v1.status import StatusResponseSchema
+from syncmaster.schemas.v1.users import UserPageSchemaAsGroupMember
+
+router = APIRouter(tags=["Groups"])
+
+
+@router.get("/groups")
+async def read_groups(
+    page: int = Query(gt=0, default=1),
+    page_size: int = Query(gt=0, le=200, default=20),
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> GroupPageSchema:
+    if current_user.is_superuser:
+        pagination = await unit_of_work.group.paginate_all(
+            page=page,
+            page_size=page_size,
+        )
+    else:
+        pagination = await unit_of_work.group.paginate_for_user(
+            page=page,
+            page_size=page_size,
+            current_user_id=current_user.id,
+        )
+    return GroupPageSchema.from_pagination(pagination=pagination)
+
+
+@router.post("/groups")
+async def create_group(
+    group_data: CreateGroupSchema,
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+    current_user: User = Depends(get_user(is_active=True)),
+) -> ReadGroupSchema:
+    async with unit_of_work:
+        group = await unit_of_work.group.create(
+            name=group_data.name,
+            description=group_data.description,
+            owner_id=current_user.id,
+        )
+    return ReadGroupSchema.from_orm(group)
+
+
+@router.get("/groups/{group_id}")
+async def read_group(
+    group_id: int,
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> ReadGroupSchema:
+    resource_role = await unit_of_work.group.get_group_permission(
+        user=current_user,
+        group_id=group_id,
+    )
+
+    if resource_role == Permission.NONE:
+        raise GroupNotFoundError
+
+    group = await unit_of_work.group.read_by_id(group_id=group_id)
+    return ReadGroupSchema.from_orm(group)
+
+
+@router.patch("/groups/{group_id}")
+async def update_group(
+    group_id: int,
+    group_data: UpdateGroupSchema,
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> ReadGroupSchema:
+    resource_rule = await unit_of_work.group.get_group_permission(
+        user=current_user,
+        group_id=group_id,
+    )
+    if resource_rule == Permission.NONE:
+        raise GroupNotFoundError
+
+    if resource_rule < Permission.DELETE:
+        raise ActionNotAllowedError
+
+    async with unit_of_work:
+        group = await unit_of_work.group.update(
+            group_id=group_id,
+            owner_id=group_data.owner_id,
+            name=group_data.name,
+            description=group_data.description,
+        )
+    return ReadGroupSchema.from_orm(group)
+
+
+@router.delete("/groups/{group_id}", dependencies=[Depends(get_user(is_superuser=True))])
+async def delete_group(
+    group_id: int,
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> StatusResponseSchema:
+    async with unit_of_work:
+        await unit_of_work.group.delete(group_id=group_id)
+    return StatusResponseSchema(ok=True, status_code=200, message="Group was deleted")
+
+
+@router.get("/groups/{group_id}/users")
+async def read_group_users(
+    group_id: int,
+    page: int = Query(gt=0, default=1),
+    page_size: int = Query(gt=0, le=200, default=20),
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> UserPageSchemaAsGroupMember:
+    resource_role = await unit_of_work.group.get_group_permission(
+        user=current_user,
+        group_id=group_id,
+    )
+
+    if resource_role == Permission.NONE:
+        raise GroupNotFoundError
+
+    pagination = await unit_of_work.group.get_member_paginate(
+        group_id=group_id,
+        page=page,
+        page_size=page_size,
+    )
+    return UserPageSchemaAsGroupMember.from_pagination(pagination=pagination)
+
+
+@router.patch("/groups/{group_id}/users/{user_id}")
+async def update_user_role_group(
+    group_id: int,
+    user_id: int,
+    update_user_data: AddUserSchema,
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> AddUserSchema:
+    resource_rule = await unit_of_work.group.get_group_permission(
+        user=current_user,
+        group_id=group_id,
+    )
+
+    if resource_rule == Permission.NONE:
+        raise GroupNotFoundError
+
+    if resource_rule < Permission.DELETE:
+        raise ActionNotAllowedError
+
+    async with unit_of_work:
+        result = await unit_of_work.group.update_member_role(
+            group_id=group_id,
+            user_id=user_id,
+            role=update_user_data.role,
+        )
+
+    return AddUserSchema.from_orm(result)
+
+
+@router.post("/groups/{group_id}/users/{user_id}")
+async def add_user_to_group(
+    group_id: int,
+    user_id: int,
+    add_user_data: AddUserSchema,
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> StatusResponseSchema:
+    resource_rule = await unit_of_work.group.get_group_permission(
+        user=current_user,
+        group_id=group_id,
+    )
+
+    if resource_rule == Permission.NONE:
+        raise GroupNotFoundError
+
+    if resource_rule < Permission.DELETE:
+        raise ActionNotAllowedError
+
+    async with unit_of_work:
+        await unit_of_work.group.add_user(
+            group_id=group_id,
+            new_user_id=user_id,
+            role=add_user_data.role,
+        )
+    return StatusResponseSchema(
+        ok=True,
+        status_code=200,
+        message="User was successfully added to group",
+    )
+
+
+@router.delete("/groups/{group_id}/users/{user_id}")
+async def delete_user_from_group(
+    group_id: int,
+    user_id: int,
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> StatusResponseSchema:
+    resource_rule = await unit_of_work.group.get_group_permission(
+        user=current_user,
+        group_id=group_id,
+    )
+
+    if resource_rule == Permission.NONE:
+        raise GroupNotFoundError
+
+    # User can delete himself from the group
+    if user_id != current_user.id:
+        if resource_rule < Permission.DELETE:
+            raise ActionNotAllowedError
+
+    async with unit_of_work:
+        await unit_of_work.group.delete_user(
+            group_id=group_id,
+            target_user_id=user_id,
+        )
+    return StatusResponseSchema(ok=True, status_code=200, message="User was successfully removed from group")

syncmaster/backend/api/v1/queue.py

@@ -0,0 +1,148 @@
+# SPDX-FileCopyrightText: 2023-2024 MTS (Mobile Telesystems)
+# SPDX-License-Identifier: Apache-2.0
+from fastapi import APIRouter, Depends, Query, status
+
+from syncmaster.backend.api.deps import UnitOfWorkMarker
+from syncmaster.backend.services import UnitOfWork, get_user
+from syncmaster.db.models import User
+from syncmaster.db.utils import Permission
+from syncmaster.exceptions import ActionNotAllowedError
+from syncmaster.exceptions.group import GroupNotFoundError
+from syncmaster.exceptions.queue import QueueDeleteError, QueueNotFoundError
+from syncmaster.schemas.v1.queue import (
+    CreateQueueSchema,
+    QueuePageSchema,
+    ReadQueueSchema,
+    UpdateQueueSchema,
+)
+from syncmaster.schemas.v1.status import StatusResponseSchema
+
+router = APIRouter(tags=["Queues"])
+
+
+@router.get("/queues/{queue_id}", description="Read queue by id")
+async def read_queue(
+    queue_id: int,
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> ReadQueueSchema:
+    resource_role = await unit_of_work.queue.get_resource_permission(
+        user=current_user,
+        resource_id=queue_id,
+    )
+
+    if resource_role == Permission.NONE:
+        raise QueueNotFoundError
+
+    queue = await unit_of_work.queue.read_by_id(
+        queue_id=queue_id,
+    )
+    return ReadQueueSchema.from_orm(queue)
+
+
+@router.post("/queues", description="Create new queue")
+async def create_queue(
+    queue_data: CreateQueueSchema,
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> ReadQueueSchema:
+    group_permission = await unit_of_work.queue.get_group_permission(
+        user=current_user,
+        group_id=queue_data.group_id,
+    )
+    if group_permission == Permission.NONE:
+        raise GroupNotFoundError
+
+    if group_permission < Permission.DELETE:
+        raise ActionNotAllowedError
+
+    async with unit_of_work:
+        queue = await unit_of_work.queue.create(queue_data.dict())
+
+    return ReadQueueSchema.from_orm(queue)
+
+
+@router.patch("/queues/{queue_id}", description="Updating queue information")
+async def update_queue(
+    queue_id: int,
+    queue_data: UpdateQueueSchema,
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> ReadQueueSchema:
+    resource_role = await unit_of_work.queue.get_resource_permission(
+        user=current_user,
+        resource_id=queue_id,
+    )
+
+    if resource_role == Permission.NONE:
+        raise QueueNotFoundError
+
+    if resource_role < Permission.DELETE:
+        raise ActionNotAllowedError
+
+    async with unit_of_work:
+        queue = await unit_of_work.queue.update(
+            queue_id=queue_id,
+            queue_data=queue_data,
+        )
+    return ReadQueueSchema.from_orm(queue)
+
+
+@router.delete("/queues/{queue_id}", description="Delete queue by id")
+async def delete_queue(
+    queue_id: int,
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> StatusResponseSchema:
+    resource_role = await unit_of_work.queue.get_resource_permission(
+        user=current_user,
+        resource_id=queue_id,
+    )
+
+    if resource_role == Permission.NONE:
+        raise QueueNotFoundError
+
+    if resource_role < Permission.DELETE:
+        raise ActionNotAllowedError
+
+    queue = await unit_of_work.queue.read_by_id(queue_id=queue_id)
+
+    transfers = queue.transfers
+
+    if transfers:
+        raise QueueDeleteError(
+            f"The queue has an associated transfers(s). Number of the linked transfers: {len(transfers)}",
+        )
+
+    async with unit_of_work:
+        await unit_of_work.queue.delete(queue_id=queue_id)
+
+    return StatusResponseSchema(
+        ok=True,
+        status_code=status.HTTP_200_OK,
+        message="Queue was deleted",
+    )
+
+
+@router.get("/queues", description="Queues in page format")
+async def read_queues(
+    group_id: int,
+    page: int = Query(gt=0, default=1),
+    page_size: int = Query(gt=0, le=200, default=20),
+    current_user: User = Depends(get_user(is_active=True)),
+    unit_of_work: UnitOfWork = Depends(UnitOfWorkMarker),
+) -> QueuePageSchema:
+    resource_role = await unit_of_work.queue.get_group_permission(
+        user=current_user,
+        group_id=group_id,
+    )
+
+    if resource_role == Permission.NONE:
+        raise GroupNotFoundError
+
+    pagination = await unit_of_work.queue.paginate(
+        page=page,
+        page_size=page_size,
+        group_id=group_id,
+    )
+    return QueuePageSchema.from_pagination(pagination=pagination)

syncmaster/backend/api/v1/router.py

@@ -0,0 +1,18 @@
+# SPDX-FileCopyrightText: 2023-2024 MTS (Mobile Telesystems)
+# SPDX-License-Identifier: Apache-2.0
+from fastapi import APIRouter
+
+from syncmaster.backend.api.v1.auth.router import router as auth_router
+from syncmaster.backend.api.v1.connections import router as connection_router
+from syncmaster.backend.api.v1.groups import router as group_router
+from syncmaster.backend.api.v1.queue import router as queue_router
+from syncmaster.backend.api.v1.transfers.router import router as transfer_router
+from syncmaster.backend.api.v1.users import router as user_router
+
+router = APIRouter(prefix="/v1")
+router.include_router(user_router)
+router.include_router(auth_router)
+router.include_router(group_router)
+router.include_router(connection_router)
+router.include_router(transfer_router)
+router.include_router(queue_router)

syncmaster/backend/api/v1/transfers/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: 2023-2024 MTS (Mobile Telesystems)
+# SPDX-License-Identifier: Apache-2.0