saviialib 1.6.1__py3-none-any.whl

saviialib/libs/sharepoint_client/clients/sharepoint_rest_api.py

@@ -0,0 +1,160 @@
+from typing import Any
+import json
+from aiohttp import ClientError, ClientSession, TCPConnector
+from dotenv import load_dotenv
+import ssl
+import certifi
+
+from saviialib.libs.sharepoint_client.sharepoint_client_contract import (
+    SharepointClientContract,
+)
+from saviialib.libs.sharepoint_client.types.sharepoint_client_types import (
+    SpListFilesArgs,
+    SpListFoldersArgs,
+    SpUploadFileArgs,
+    SpCreateFolderArgs,
+    SharepointClientInitArgs,
+)
+
+load_dotenv()
+ssl_context = ssl.create_default_context(cafile=certifi.where())
+
+
+class SharepointRestAPI(SharepointClientContract):
+    def __init__(self, args: SharepointClientInitArgs):
+        self.session: ClientSession | None = None
+        self.base_headers = {}
+        self.credentials = {}
+        self.base_url = ""
+        self.tenant_id = args.config.sharepoint_tenant_id
+        self.tenant_name = args.config.sharepoint_tenant_name
+        self.client_secret = args.config.sharepoint_client_secret
+        self.client_id = args.config.sharepoint_client_id
+        self.site_name = args.config.sharepoint_site_name
+
+    async def _load_form_digest_value(self) -> str:
+        try:
+            response = await self.session.post("contextinfo")
+            response_json = await response.json()
+            return response_json["FormDigestValue"]
+        except ClientError as error:
+            raise ConnectionError(error) from error
+
+    async def _load_credentials(self) -> dict:
+        resource_base = "00000003-0000-0ff1-ce00-000000000000"
+        resource = f"{resource_base}/{self.tenant_name}.sharepoint.com@{self.tenant_id}"
+        url = f"https://accounts.accesscontrol.windows.net/{self.tenant_id}/tokens/OAuth/2"
+        payload = {
+            "grant_type": "client_credentials",
+            "client_id": f"{self.client_id}@{self.tenant_id}",
+            "client_secret": self.client_secret,
+            "resource": resource,
+        }
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+        }
+
+        async with ClientSession(connector=TCPConnector(ssl=ssl_context)) as session:
+            # Load access token
+            response = await session.post(url, data=payload, headers=headers)
+            if response.status != 200:
+                raise ClientError(
+                    f"Failed to fetch credentials: {response.status}, {await response.text()}"
+                )
+            response_json = await response.json()
+
+            return {
+                "access_token": response_json["access_token"],
+            }
+
+    async def __aenter__(self) -> "SharepointRestAPI":
+        try:
+            self.credentials = await self._load_credentials()
+            site_url = f"https://{self.tenant_name}.sharepoint.com"
+
+            self.base_headers = {
+                "Authorization": f"Bearer {self.credentials['access_token']}",
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+            }
+            self.base_url = f"{site_url}/sites/{self.site_name}/_api/"
+            connector = TCPConnector(ssl=ssl_context)
+            self.session = ClientSession(
+                headers=self.base_headers, base_url=self.base_url, connector=connector
+            )
+            return self
+        except ClientError as error:
+            raise ConnectionError(error)
+
+    async def __aexit__(
+        self, _exc_type: type[BaseException], _exc_val: BaseException, _exc_tb: Any
+    ) -> None:
+        await self.session.close()
+
+    async def list_files(self, args: SpListFilesArgs) -> list:
+        try:
+            folder_relative_url = (
+                f"GetFolderByServerRelativeUrl('{args.folder_relative_url}')"
+            )
+            endpoint = f"web/{folder_relative_url}/Files"
+            response = await self.session.get(endpoint.lstrip("/"))
+            response.raise_for_status()
+            response_json = await response.json()
+            return response_json
+        except ClientError as error:
+            raise ConnectionError(error) from error
+
+    async def list_folders(self, args: SpListFoldersArgs) -> list:
+        try:
+            folder_relative_url = (
+                f"GetFolderByServerRelativeUrl('{args.folder_relative_url}')"
+            )
+            endpoint = f"web/{folder_relative_url}/Folders"
+            response = await self.session.get(endpoint.lstrip("/"))
+            response.raise_for_status()
+            response_json = await response.json()
+            return response_json
+        except ClientError as error:
+            raise ConnectionError(error) from error
+
+    async def upload_file(self, args: SpUploadFileArgs) -> dict:
+        try:
+            # Load form digest value
+            form_digest_value = await self._load_form_digest_value()
+            headers = {
+                **self.base_headers,
+                "X-RequestDigest": form_digest_value,
+                "Content-Type": "application/octet-stream",
+            }
+            # Upload the file in the requested folder
+            folder_relative_url = (
+                f"GetFolderByServerRelativeUrl('{args.folder_relative_url}')"
+            )
+            data = args.file_content
+
+            endpoint = f"web/{folder_relative_url}/Files/add(url='{args.file_name}',overwrite=true)"
+            response = await self.session.post(endpoint, data=data, headers=headers)
+
+            response.raise_for_status()
+            return await response.json()
+        except ClientError as error:
+            raise ConnectionError(error) from error
+
+    async def create_folder(self, args: SpCreateFolderArgs):
+        try:
+            # Load form digest value
+            form_digest_value = await self._load_form_digest_value()
+            headers = {
+                **self.base_headers,
+                "X-RequestDigest": form_digest_value,
+            }
+            body = {"ServerRelativeUrl": f"{args.folder_relative_url}"}
+            endpoint = "web/folders"
+            response = await self.session.post(
+                endpoint.lstrip("/"), data=json.dumps(body), headers=headers
+            )
+            response.raise_for_status()
+            response_json = await response.json()
+            return response_json
+        except ClientError as error:
+            raise ConnectionError(error) from error

saviialib/libs/sharepoint_client/sharepoint_client.py

@@ -0,0 +1,58 @@
+from .clients.sharepoint_rest_api import SharepointRestAPI
+from .sharepoint_client_contract import SharepointClientContract
+from .types.sharepoint_client_types import (
+    SharepointClientInitArgs,
+    SpListFilesArgs,
+    SpListFoldersArgs,
+    SpUploadFileArgs,
+    SpCreateFolderArgs,
+)
+
+
+class SharepointClient(SharepointClientContract):
+    CLIENTS = {"sharepoint_rest_api"}
+
+    def __init__(self, args: SharepointClientInitArgs):
+        if args.client_name not in SharepointClient.CLIENTS:
+            msg = f"Unsupported client {args.client_name}"
+            raise KeyError(msg)
+        elif args.client_name == "sharepoint_rest_api":
+            self.client_obj = SharepointRestAPI(args)
+
+    @property
+    def tenant_id(self):
+        return self.client_obj.tenant_id
+
+    @property
+    def tenant_name(self):
+        return self.client_obj.tenant_name
+
+    @property
+    def site_name(self):
+        return self.client_obj.site_name
+
+    @property
+    def client_id(self):
+        return self.client_obj.client_id
+
+    @property
+    def client_secret(self):
+        return self.client_obj.client_secret
+
+    async def __aenter__(self):
+        return await self.client_obj.__aenter__()
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.client_obj.__aexit__(exc_type, exc_val, exc_tb)
+
+    async def list_files(self, args: SpListFilesArgs) -> list:
+        return await self.client_obj.list_files(args)
+
+    async def list_folders(self, args: SpListFoldersArgs) -> list:
+        return await self.client_obj.list_folders(args)
+
+    async def upload_file(self, args: SpUploadFileArgs) -> dict:
+        return await self.client_obj.upload_file(args)
+
+    async def create_folder(self, args: SpCreateFolderArgs) -> dict:
+        return await self.client_obj.create_folder(args)

saviialib/libs/sharepoint_client/sharepoint_client_contract.py

@@ -0,0 +1,26 @@
+from abc import ABC, abstractmethod
+
+from .types.sharepoint_client_types import (
+    SpListFilesArgs,
+    SpListFoldersArgs,
+    SpUploadFileArgs,
+    SpCreateFolderArgs,
+)
+
+
+class SharepointClientContract(ABC):
+    @abstractmethod
+    async def list_files(self, args: SpListFilesArgs) -> list:
+        pass
+
+    @abstractmethod
+    async def list_folders(self, args: SpListFoldersArgs) -> list:
+        pass
+
+    @abstractmethod
+    async def upload_file(self, args: SpUploadFileArgs) -> dict:
+        pass
+
+    @abstractmethod
+    async def create_folder(self, args: SpCreateFolderArgs) -> dict:
+        pass

saviialib/libs/sharepoint_client/types/sharepoint_client_types.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class SharepointClientInitArgs:
+    config: Any
+    client_name: str = "sharepoint_rest_api"
+
+
+@dataclass
+class SpListFilesArgs:
+    folder_relative_url: str
+
+
+@dataclass
+class SpListFoldersArgs:
+    folder_relative_url: str
+
+
+@dataclass
+class SpUploadFileArgs:
+    folder_relative_url: str
+    file_name: str
+    file_content: bytes = bytes()
+
+
+@dataclass
+class SpCreateFolderArgs:
+    folder_relative_url: str

saviialib/libs/zero_dependency/utils/booleans_utils.py

@@ -0,0 +1,2 @@
+def boolean_to_emoji(boolean: bool) -> str:
+    return "✅" if boolean else "❌"

saviialib/libs/zero_dependency/utils/datetime_utils.py

@@ -0,0 +1,25 @@
+from datetime import datetime
+from zoneinfo import ZoneInfo
+
+
+def today(timezone: str = "America/Santiago") -> datetime:
+    """
+    Return the current date.
+
+    :param timezone: A string representing the IANA timezone name.
+        Defaults to "America/Santiago".
+    :return datetime:
+    """
+    return datetime.now(tz=ZoneInfo(timezone))
+
+
+def datetime_to_str(date: datetime, date_format: str = "%m/%d/%Y, %H:%M:%S") -> str:
+    """
+    Convert a datetime object to a string in the specified format.
+
+    :param date: The datetime object to convert.
+    :param date_format: The format to convert the datetime object to.
+        Defaults to "%Y-%m-%dT%H:%M:%S".
+    :return: A string in the specified format.
+    """
+    return date.strftime(date_format)

saviialib/libs/zero_dependency/utils/strings_utils.py

@@ -0,0 +1,5 @@
+def are_equal(str1: str, str2: str) -> bool:
+    if str1.lower() == str2.lower():
+        return True
+    else:
+        return False

saviialib/services/backup/api.py

@@ -0,0 +1,36 @@
+from typing import Any, Dict
+
+from .controllers.upload_backup_to_sharepoint import (
+    UploadBackupToSharepointControllerInput,
+)
+from .controllers.upload_backup_to_sharepoint import UploadBackupToSharepointController
+from saviialib.general_types.api.saviia_backup_api_types import SaviiaBackupConfig
+
+
+class SaviiaBackupAPI:
+    """
+    EpiiAPI is a service class that provides methods to interact with Patagonia Center system.
+    """
+
+    def __init__(self, config: SaviiaBackupConfig):
+        self.config = config
+
+    async def upload_backup_to_sharepoint(
+        self, local_backup_source_path: str, sharepoint_destination_path: str
+    ) -> Dict[str, Any]:
+        """Migrate a backup folder from Home assistant to Sharepoint directory.
+        Args:
+            local_backup_source_path (str): Local path to backup.
+        Returns:
+            response (dict): A dictionary containing the response from the upload operation.
+                This dictionary will typically include information about the success or
+                failure of the upload, as well as any relevant metadata.
+        """
+
+        controller = UploadBackupToSharepointController(
+            UploadBackupToSharepointControllerInput(
+                self.config, local_backup_source_path, sharepoint_destination_path
+            )
+        )
+        response = await controller.execute()
+        return response.__dict__

saviialib/services/backup/controllers/types/__init__.py

@@ -0,0 +1,6 @@
+from ....thies.controllers.types.update_thies_data_types import (
+    UpdateThiesDataControllerInput,
+    UpdateThiesDataControllerOutput,
+)
+
+__all__ = ["UpdateThiesDataControllerInput", "UpdateThiesDataControllerOutput"]

saviialib/services/backup/controllers/types/upload_backup_to_sharepoint_types.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass, field
+from typing import Dict
+
+from saviialib.general_types.api.saviia_backup_api_types import SaviiaBackupConfig
+
+
+@dataclass
+class UploadBackupToSharepointControllerInput:
+    config: SaviiaBackupConfig
+    local_backup_source_path: str
+    sharepoint_destination_path: str
+
+
+@dataclass
+class UploadBackupToSharepointControllerOutput:
+    message: str
+    status: int
+    metadata: Dict[str, str] = field(default_factory=dict)

saviialib/services/backup/controllers/upload_backup_to_sharepoint.py

@@ -0,0 +1,87 @@
+from http import HTTPStatus
+from saviialib.general_types.api.saviia_api_types import SharepointConfig
+
+from saviialib.general_types.error_types.api.saviia_api_error_types import (
+    BackupUploadError,
+    BackupSourcePathError,
+    BackupEmptyError,
+)
+from saviialib.general_types.error_types.common.common_types import (
+    EmptyDataError,
+    SharepointClientError,
+)
+from saviialib.services.backup.controllers.types.upload_backup_to_sharepoint_types import (
+    UploadBackupToSharepointControllerInput,
+    UploadBackupToSharepointControllerOutput,
+)
+from saviialib.services.backup.use_cases.types.upload_backup_to_sharepoint_types import (
+    UploadBackupToSharepointUseCaseInput,
+)
+from saviialib.services.backup.use_cases.upload_backup_to_sharepoint import (
+    UploadBackupToSharepointUsecase,
+)
+
+
+class UploadBackupToSharepointController:
+    def __init__(self, input: UploadBackupToSharepointControllerInput):
+        self.use_case = UploadBackupToSharepointUsecase(
+            UploadBackupToSharepointUseCaseInput(
+                sharepoint_config=SharepointConfig(
+                    sharepoint_client_id=input.config.sharepoint_client_id,
+                    sharepoint_client_secret=input.config.sharepoint_client_secret,
+                    sharepoint_site_name=input.config.sharepoint_site_name,
+                    sharepoint_tenant_name=input.config.sharepoint_tenant_name,
+                    sharepoint_tenant_id=input.config.sharepoint_tenant_id,
+                ),
+                local_backup_source_path=input.local_backup_source_path,
+                sharepoint_destination_path=input.sharepoint_destination_path,
+                logger=input.config.logger,
+            )
+        )
+
+    async def execute(self) -> UploadBackupToSharepointControllerOutput:
+        try:
+            data = await self.use_case.execute()
+            return UploadBackupToSharepointControllerOutput(
+                message="Local backup was migrated successfully",
+                status=HTTPStatus.OK.value,
+                metadata={"data": data},  # type: ignore
+            )
+        except EmptyDataError:
+            return UploadBackupToSharepointControllerOutput(
+                message="No files to upload", status=HTTPStatus.NO_CONTENT.value
+            )
+
+        except (AttributeError, NameError, ValueError) as error:
+            return UploadBackupToSharepointControllerOutput(
+                message="An unexpected error occurred during use case initialization.",
+                status=HTTPStatus.BAD_REQUEST.value,
+                metadata={"error": error.__str__()},
+            )
+
+        except SharepointClientError as error:
+            return UploadBackupToSharepointControllerOutput(
+                message="Sharepoint Client initialization fails.",
+                status=HTTPStatus.INTERNAL_SERVER_ERROR.value,
+                metadata={"error": error.__str__()},
+            )
+
+        except BackupUploadError as error:
+            return UploadBackupToSharepointControllerOutput(
+                message="An error occurred during local backup",
+                status=HTTPStatus.MULTI_STATUS.value,
+                metadata={"error": error.__str__()},
+            )
+
+        except BackupSourcePathError as error:
+            return UploadBackupToSharepointControllerOutput(
+                message="Invalid local backup source path provided.",
+                status=HTTPStatus.BAD_REQUEST.value,
+                metadata={"error": error.__str__()},
+            )
+        except BackupEmptyError as error:
+            return UploadBackupToSharepointControllerOutput(
+                message="Each folder in the backup folder is empty. Check out again",
+                status=HTTPStatus.EXPECTATION_FAILED.value,
+                metadata={"error": error.__str__()},
+            )

saviialib/services/backup/use_cases/constants/upload_backup_to_sharepoint_constants.py

@@ -0,0 +1,5 @@
+import logging
+
+
+logging.basicConfig(level=logging.DEBUG)
+LOGGER = logging.getLogger(__package__)

saviialib/services/backup/use_cases/types/__init__.py

@@ -0,0 +1,7 @@
+from ....thies.use_cases.types.update_thies_data_types import (
+    FtpClientConfig,
+    SharepointConfig,
+    UpdateThiesDataUseCaseInput,
+)
+
+__all__ = ["UpdateThiesDataUseCaseInput", "FtpClientConfig", "SharepointConfig"]

saviialib/services/backup/use_cases/types/upload_backup_to_sharepoint_types.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+from saviialib.general_types.api.saviia_api_types import SharepointConfig
+from logging import Logger
+
+
+@dataclass
+class UploadBackupToSharepointUseCaseInput:
+    sharepoint_config: SharepointConfig
+    local_backup_source_path: str
+    sharepoint_destination_path: str
+    logger: Logger