logs-py 4.0.7__py3-none-any.whl

LOGS/Interfaces/IModificationRecord.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary import Tools
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+if TYPE_CHECKING:
+    from LOGS.Entities.PersonMinimal import PersonMinimal
+
+
+@dataclass
+class IModificationRecordRequest:
+    pass
+
+
+class IModifiedOnRequest:
+    modifiedFrom: Optional[datetime] = None
+    modifiedTo: Optional[datetime] = None
+
+
+class IModifiedByRequest:
+    modifiedByIds: Optional[List[int]]
+
+
+class IModifiedOn(IEntityInterface):
+    _modifiedOn: Optional[datetime] = None
+
+    @property
+    def modifiedOn(self) -> Optional[datetime]:
+        return self._modifiedOn
+
+    @modifiedOn.setter
+    def modifiedOn(self, value):
+        self._modifiedOn = Tools.checkAndConvert(
+            value, datetime, "modifiedOn", allowNone=True
+        )
+
+
+class IModifiedBy(IEntityInterface):
+    _modifiedBy: Optional["PersonMinimal"] = None
+
+    @property
+    def modifiedBy(self) -> Optional["PersonMinimal"]:
+        return self._modifiedBy
+
+    @modifiedBy.setter
+    def modifiedBy(self, value):
+        self._modifiedBy = MinimalModelGenerator.MinimalFromSingle(
+            value, "PersonMinimal", "modifiedBy", connection=self._getEntityConnection()
+        )
+
+
+class IModificationRecord(IModifiedOn, IModifiedBy):
+    pass

LOGS/Interfaces/INamedEntity.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary import Tools
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+if TYPE_CHECKING:
+    pass
+
+
+@dataclass
+class INamedEntityRequest:
+    names: Optional[List[str]] = None
+
+
+class INamedEntity(IEntityInterface):
+    _name: Optional[str] = None
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = Tools.checkAndConvert(value, str, "name", allowNone=True)

LOGS/Interfaces/IOwnedEntity.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+if TYPE_CHECKING:
+    from LOGS.Entities.PersonMinimal import PersonMinimal
+
+
+@dataclass
+class IOwnedEntityRequest:
+    ownerIds: Optional[List[int]] = None
+
+
+class IOwnedEntity(IEntityInterface):
+    _owner: Optional["PersonMinimal"] = None
+
+    @property
+    def owner(self) -> Optional["PersonMinimal"]:
+        return self._owner
+
+    @owner.setter
+    def owner(self, value):
+        self._owner = MinimalModelGenerator.MinimalFromSingle(
+            value, "PersonMinimal", "owner", connection=self._getEntityConnection()
+        )

LOGS/Interfaces/IPaginationRequest.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    pass
+
+
+@dataclass
+class IPaginationRequest:
+    page: Optional[int] = None
+    pageSize: Optional[int] = None

LOGS/Interfaces/IPermissionedEntity.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generic, Optional, Type, TypeVar, cast
+
+from LOGS.Auxiliary import Tools
+from LOGS.Entity.SerializableContent import SerializableClass
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+if TYPE_CHECKING:
+    pass
+
+
+@dataclass
+class IPermissionedEntityRequest:
+    includePermissions: Optional[bool] = None
+
+
+class IPermissionModel:
+    edit: Optional[bool] = None
+
+
+class GenericPermission(IPermissionModel, SerializableClass):
+    canDownload: Optional[bool] = None
+    canEdit: Optional[bool] = None
+    canTrash: Optional[bool] = None
+    canRestore: Optional[bool] = None
+    canDelete: Optional[bool] = None
+    canLock: Optional[bool] = None
+    canUnlock: Optional[bool] = None
+    canSign: Optional[bool] = None
+    canRemoveSignatures: Optional[bool] = None
+
+    def __str__(self):
+        attrList = self._getAttrList()
+
+        s = ",".join(
+            k
+            for k in attrList
+            if k.startswith("can") and getattr(self, k, None) is True
+        )
+        return f"<{type(self).__name__} access:{s}>"
+
+    def contentToString(self, indentation: int = 1, hideNone: bool = False) -> str:
+        return str(self)
+
+
+_PERMISSION = TypeVar("_PERMISSION", bound=IPermissionModel)
+
+
+class IPermissionedEntity(Generic[_PERMISSION], IEntityInterface):
+    _permissionType: Optional[Type[_PERMISSION]] = None
+
+    _permissions: Optional[_PERMISSION] = None
+
+    @property
+    def permissions(self) -> Optional[_PERMISSION]:
+        return self._permissions
+
+    @permissions.setter
+    def permissions(self, value):
+        if not self._permissionType:
+            raise NotImplementedError("Permission type must be set")
+
+        self._permissions = Tools.checkAndConvert(
+            value,
+            cast(Type[_PERMISSION], self._permissionType),
+            "permissions",
+            allowNone=True,
+        )
+
+
+class IGenericPermissionEntity(IPermissionedEntity[GenericPermission]):
+    _permissionType: Type[GenericPermission] = GenericPermission

LOGS/Interfaces/IProjectBased.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+if TYPE_CHECKING:
+    from LOGS.Entities.ProjectMinimal import ProjectMinimal
+
+
+@dataclass
+class IProjectBasedRequest:
+    projectIds: Optional[List[int]] = None
+
+
+class IProjectBased(IEntityInterface):
+    _projects: Optional[List["ProjectMinimal"]] = None
+
+    @property
+    def projects(self) -> Optional[List["ProjectMinimal"]]:
+        return self._projects
+
+    @projects.setter
+    def projects(self, value):
+        self._projects = MinimalModelGenerator.MinimalFromList(
+            value, "ProjectMinimal", "projects", connection=self._getEntityConnection()
+        )

LOGS/Interfaces/ISessionedEntity.py

@@ -0,0 +1,59 @@
+from datetime import datetime
+from typing import TYPE_CHECKING, Optional
+
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+if TYPE_CHECKING:
+    from LOGS.Entities.PersonMinimal import PersonMinimal
+
+
+class ISessionedEntity(IEntityInterface):
+    _currentlyEditedBy: Optional["PersonMinimal"] = None
+    _currentlyEditedSince: Optional[datetime] = None
+    _publicSessionId: Optional[str] = None
+    _isCurrentlyEdited: Optional[bool] = None
+
+    @property
+    def currentlyEditedBy(self) -> Optional["PersonMinimal"]:
+        return self._currentlyEditedBy
+
+    @currentlyEditedBy.setter
+    def currentlyEditedBy(self, value):
+        self._currentlyEditedBy = MinimalModelGenerator.MinimalFromSingle(
+            value,
+            "PersonMinimal",
+            "currentlyEditedBy",
+            connection=self._getEntityConnection(),
+        )
+
+    @property
+    def currentlyEditedSince(self) -> Optional[datetime]:
+        return self._currentlyEditedSince
+
+    @currentlyEditedSince.setter
+    def currentlyEditedSince(self, value):
+        self._currentlyEditedSince = Tools.checkAndConvert(
+            value, datetime, "currentlyEditedSince", allowNone=True
+        )
+
+    @property
+    def publicSessionId(self) -> Optional[str]:
+        return self._publicSessionId
+
+    @publicSessionId.setter
+    def publicSessionId(self, value):
+        self._publicSessionId = Tools.checkAndConvert(
+            value, str, "publicSessionId", allowNone=True
+        )
+
+    @property
+    def isCurrentlyEdited(self) -> Optional[bool]:
+        return self._isCurrentlyEdited
+
+    @isCurrentlyEdited.setter
+    def isCurrentlyEdited(self, value):
+        self._isCurrentlyEdited = Tools.checkAndConvert(
+            value, bool, "isCurrentlyEdited", allowNone=True
+        )

LOGS/Interfaces/ISignableEntity.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import TYPE_CHECKING, List, Optional, Union
+
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+if TYPE_CHECKING:
+    from LOGS.Entities.Signature import Signature, SignatureType
+
+
+@dataclass
+class ISignableEntityRequest:
+    signedByIds: Optional[List[int]] = None
+    notSignedByIds: Optional[List[int]] = None
+    signedFrom: Optional[datetime] = None
+    signedTo: Optional[datetime] = None
+    isSigned: Optional[bool] = None
+    signatureTypes: Optional[List["SignatureType"]] = None
+
+
+class ISignableEntity(IEntityInterface):
+    _signatures: Optional[List["Signature"]] = None
+    _isSigned: Optional[bool] = None
+
+    @property
+    def signatures(self) -> Optional[List["Signature"]]:
+        return self._signatures
+
+    @signatures.setter
+    def signatures(self, value: Optional[Union[List["Signature"], List[dict]]]):
+        from LOGS.Entities.Signature import Signature
+        from LOGS.Entity.ConnectedEntity import ConnectedEntity
+
+        self._signatures = ConnectedEntity.checkListAndConvertWithConnection(
+            value,
+            Signature,
+            "signatures",
+            allowNone=True,
+            connection=self._getEntityConnection(),
+        )
+
+    @property
+    def isSigned(self) -> Optional[bool]:
+        return self._isSigned
+
+    @isSigned.setter
+    def isSigned(self, value: Optional[bool]):
+        self._isSigned = Tools.checkAndConvert(value, bool, "isSigned", allowNone=True)

LOGS/Interfaces/ISoftDeletable.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional
+
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+if TYPE_CHECKING:
+    pass
+
+
+@dataclass
+class ISoftDeletableRequest:
+    includeSoftDeleted: Optional[bool] = None
+    isSoftDeleted: Optional[bool] = None
+
+
+class ISoftDeletable(IEntityInterface):
+    _isDeleted: Optional[bool] = None
+
+    @property
+    def isDeleted(self) -> Optional[bool]:
+        return self._isDeleted
+
+    @isDeleted.setter
+    def isDeleted(self, value):
+        self._isDeleted = Tools.checkAndConvert(
+            value, bool, "isDeleted", allowNone=True
+        )

LOGS/Interfaces/ITypedEntity.py

@@ -0,0 +1,129 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type
+
+from typing_extensions import Self
+
+from LOGS.Auxiliary.Exceptions import EntityNotConnectedException
+from LOGS.Entities.CustomType import CustomType
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+if TYPE_CHECKING:
+    from LOGS.Entity.Entity import Entity
+    from LOGS.Interfaces.ICustomTypeValue import ICustomTypeValue
+
+
+@dataclass
+class ITypedEntityRequest:
+    customTypeIds: Optional[List[int]] = None
+    customFieldIds: Optional[List[int]] = None
+
+
+class ITypedEntity(IEntityInterface):
+    _customType: Optional["CustomType"] = (
+        None  # this diverges from the LOGS model (CustomTypeMinimal) because here the full custom type is retrieved
+    )
+    _customValues: Optional["ICustomTypeValue"] = None
+
+    _untypedValues: Optional[List[Dict[str, Any]]] = None
+    _untypedCustomType: Optional[Dict[str, Any]] = None
+    _initCustomValues: bool = True
+    _baseType: Optional[Type["Entity"]] = None
+
+    def _contentToString(self) -> str:
+        s = f"{type(self).__name__}"
+        if self.customType:
+            s += f" <{self.customType.name}>\n"
+            s += self.customValues._contentToString(1) if self.customValues else ""
+        else:
+            s += " <no type>\n"
+        return s
+
+    def _createCustomValuesInstance(self) -> None:
+        from LOGS.Auxiliary.CustomTypeClassGenerator import CustomTypeClassGenerator
+
+        if self.customType is None:
+            return
+
+        connection = self._getEntityConnection()
+        if not connection:
+            raise EntityNotConnectedException()
+
+        self._customValues = CustomTypeClassGenerator.convert(
+            [],
+            customTypeOrId=self.customType,
+            fieldName="customValues",
+            connection=connection,
+        )
+
+    def getUntypedInstance(self) -> Self:
+        from LOGS.Auxiliary.CustomEntityClassGenerator import CustomEntityClassGenerator
+
+        return CustomEntityClassGenerator.convertToUntyped(self)
+
+    def _getTypedInstance(self) -> "ITypedEntity":
+        from LOGS.Auxiliary.CustomEntityClassGenerator import CustomEntityClassGenerator
+        from LOGS.Interfaces.INamedEntity import INamedEntity
+
+        return CustomEntityClassGenerator.convertFromUntyped(
+            self,
+            fieldName=self.name if isinstance(self, INamedEntity) else None,
+            limitToEntityType=type(self),
+        )
+
+    @property
+    def baseType(self) -> Optional[Type["Entity"]]:
+        return self._baseType
+
+    @property
+    def customType(self) -> Optional["CustomType"]:
+        return self._customType
+
+    @customType.setter
+    def customType(self, value):
+        if not self._customType and isinstance(value, dict) and "id" in value:
+            self._untypedCustomType = value
+            return
+
+        if self._customType == value or value == None:
+            return
+
+        newId = (
+            value.id
+            if isinstance(value, CustomType)
+            else value["id"] if isinstance(value, dict) and "id" in value else None
+        )
+        if newId and self._customType and self._customType.id == newId:
+            return
+
+        raise ValueError(f"Custom type {self._customType} cannot be changed.")
+
+    @property
+    def customValues(
+        self,
+    ) -> Optional["ICustomTypeValue"]:
+        if self._customType and self._customValues is None:
+            self._createCustomValuesInstance()
+        return self._customValues
+
+    @customValues.setter
+    def customValues(self, value):
+        from LOGS.Auxiliary.CustomTypeClassGenerator import CustomTypeClassGenerator
+
+        if (
+            self.customType is None
+            or self._getEntityConnection() is None
+            or value is None
+        ):
+            self._untypedValues = value
+            return
+
+        connection = self._getEntityConnection()
+        if not connection:
+            raise EntityNotConnectedException()
+
+        self._customValues = CustomTypeClassGenerator.convert(
+            value,
+            customTypeOrId=self.customType,
+            fieldName="customValues",
+            connection=connection,
+        )

LOGS/Interfaces/IUniqueEntity.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass
+from typing import List, Optional, Union
+from uuid import UUID
+
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Entities.Origin import Origin
+from LOGS.Entities.OriginMinimal import OriginMinimal
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+
+@dataclass
+class IUniqueEntityRequest:
+    originIds: Optional[List[int]] = None
+
+
+class IUniqueEntity(IEntityInterface):
+    _uid: Optional[str] = None
+    _origin: Optional[OriginMinimal] = None
+
+    _foreignUid: Optional[UUID] = None
+    _foreignOrigin: Optional[OriginMinimal] = None
+
+    def setOrigin(
+        self,
+        uid: Optional[Union[str, UUID]] = None,
+        origin: Optional[Union[Origin, OriginMinimal]] = None,
+    ):
+        self._foreignUid = Tools.checkAndConvert(
+            uid, UUID, "setOrigin(uid)", allowNone=True
+        )
+        self._foreignOrigin = Tools.checkAndConvert(
+            origin, OriginMinimal, "setOrigin(origin)", allowNone=True
+        )
+
+    def _originConverter(self, origin: Union[Origin, OriginMinimal]) -> OriginMinimal:
+        if isinstance(origin, OriginMinimal):
+            return origin
+        if isinstance(origin, Origin):
+            return OriginMinimal(name=origin.name, id=origin.id)
+        return Tools.checkAndConvert(origin, OriginMinimal, allowNone=True)
+
+    @property
+    def uid(self) -> Optional[str]:
+        return self._uid
+
+    @uid.setter
+    def uid(self, value):
+        self._uid = Tools.checkAndConvert(
+            value=value, fieldType=str, fieldName="uid", allowNone=True
+        )
+
+    @property
+    def origin(self) -> Optional[OriginMinimal]:
+        return self._origin
+
+    @origin.setter
+    def origin(self, value):
+        self._origin = MinimalModelGenerator.MinimalFromSingle(
+            value, "PersonMinimal", "origin", connection=self._getEntityConnection()
+        )

LOGS/Interfaces/IVersionedEntity.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generic, List, Optional, TypeVar, Union
+
+from LOGS.Auxiliary import Tools
+from LOGS.Interfaces.IEntryRecord import IEntryRecord, IEntryRecordRequest
+from LOGS.Interfaces.IModificationRecord import (
+    IModificationRecord,
+    IModificationRecordRequest,
+)
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletable, ISoftDeletableRequest
+
+if TYPE_CHECKING:
+    pass
+
+_idType = TypeVar("_idType", bound=Union[int, str])
+
+
+@dataclass
+class IVersionedEntityRequest(
+    Generic[_idType],
+    IEntryRecordRequest,
+    IModificationRecordRequest,
+    ISoftDeletableRequest,
+):
+    originalIds: Optional[List[_idType]] = None
+    versionIds: Optional[List[int]] = None
+    versions: Optional[List[int]] = None
+
+
+class IVersionedEntity(IEntryRecord, IModificationRecord, ISoftDeletable):
+    _version: Optional[int] = None
+
+    @property
+    def version(self) -> Optional[int]:
+        return self._version
+
+    @version.setter
+    def version(self, value):
+        self._version = Tools.checkAndConvert(value, int, "version", allowNone=True)

LOGS/Interfaces/__init__.py

@@ -0,0 +1,7 @@
+"""
+This Module is written for the LOGS Repository.
+
+It's objects can be used to access the LOGS public API
+programatically via python scripts.
+...
+"""