logs-py 4.0.7__py3-none-any.whl

LOGS/Entities/CustomField.py

@@ -0,0 +1,243 @@
+from typing import TYPE_CHECKING, Any, List, Optional, cast
+
+from LOGS.Auxiliary.CustomFieldValueTypeChecker import CustomFieldValueTypeChecker
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Entities.CustomFieldModels import CustomFieldDataType
+from LOGS.Entities.ILiteraryTypedEntity import ILiteraryTypedEntity
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+from LOGS.Interfaces.IEntryRecord import IEntryRecord
+from LOGS.Interfaces.IModificationRecord import IModificationRecord
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IOwnedEntity import IOwnedEntity
+from LOGS.Interfaces.IPermissionedEntity import IGenericPermissionEntity
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
+from LOGS.LOGSConnection import LOGSConnection
+
+if TYPE_CHECKING:
+    from LOGS.Entities.CustomTypeMinimal import CustomTypeMinimal
+
+
+@Endpoint("custom_fields")
+class CustomField(
+    IEntityWithIntId,
+    IOwnedEntity,
+    INamedEntity,
+    IUniqueEntity,
+    IEntryRecord,
+    IModificationRecord,
+    ILiteraryTypedEntity,
+    IGenericPermissionEntity,
+):
+    _type = "CustomField"
+    _valueTypeChecker: CustomFieldValueTypeChecker = cast(
+        CustomFieldValueTypeChecker, None
+    )
+    _description: Optional[str] = None
+    _placeholder: Optional[str] = None
+    _dataType: Optional[CustomFieldDataType] = None
+    _required: Optional[bool] = None
+    _readOnly: Optional[bool] = None
+    _validationRegexp: Optional[str] = None
+    _validationMessage: Optional[str] = None
+    _showAsTextArea: Optional[bool] = None
+    _predefinedOptions: Optional[List[Any]] = None
+    _predefinedOptionsFromValues: bool = False
+    _defaultValues: Optional[Any] = None
+    _customTypeConstraint: Optional[List["CustomTypeMinimal"]] = None
+    _templateVersion: Optional[str] = None
+    _integrationId: Optional[str] = None
+
+    def __init__(
+        self,
+        ref=None,
+        id: Optional[int] = None,
+        connection: Optional[LOGSConnection] = None,
+    ):
+        if ref != None and isinstance(ref, (str, int, float)):
+            ref = {"text": str(ref)}
+
+        super().__init__(id=id, ref=ref, connection=connection)
+
+    def fromDict(self, ref) -> None:
+        if (
+            isinstance(ref, dict)
+            and "dataType" in ref
+            and isinstance(ref["dataType"], str)
+        ):
+            self.dataType = CustomFieldDataType(ref["dataType"])
+
+        super().fromDict(ref=ref)
+
+    def __str__(self) -> str:
+        i = " id:'%s'" % self.id if self.id is not None else ""
+        t = " type:'%s'" % self._dataType.name if self._dataType else ""
+        n = " name:'%s'" % self.name if self.name is not None else ""
+        return "<%s%s%s%s>" % (type(self).__name__, i, t, n)
+
+    @staticmethod
+    def isValidClassName(name: str) -> bool:
+        if not isinstance(name, str) or not name:
+            return False
+        if not name.isidentifier():
+            return False
+        if not name[0].isupper():
+            return False
+        return True
+
+    @property
+    def className(self) -> Optional[str]:
+        return self._name
+
+    @property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @description.setter
+    def description(self, value):
+        self._description = self.checkAndConvertNullable(value, str, "description")
+
+    @property
+    def defaultValues(self) -> Optional[Any]:
+        return self._defaultValues
+
+    @defaultValues.setter
+    def defaultValues(self, value):
+        if not self._dataType:
+            raise Exception("Data type is not set")
+
+        self._defaultValues = self._valueTypeChecker.checkAndConvert(
+            value, "defaultValues"
+        )
+
+    @property
+    def readOnly(self) -> Optional[bool]:
+        return self._readOnly
+
+    @readOnly.setter
+    def readOnly(self, value):
+        self._readOnly = self.checkAndConvertNullable(value, bool, "readOnly")
+
+    @property
+    def required(self) -> Optional[bool]:
+        return self._required
+
+    @required.setter
+    def required(self, value):
+        self._required = self.checkAndConvertNullable(value, bool, "required")
+
+    @property
+    def validationRegexp(self) -> Optional[str]:
+        return self._validationRegexp
+
+    @validationRegexp.setter
+    def validationRegexp(self, value):
+        self._validationRegexp = self.checkAndConvertNullable(
+            value, str, "validationRegexp"
+        )
+
+    @property
+    def validationMessage(self) -> Optional[str]:
+        return self._validationMessage
+
+    @validationMessage.setter
+    def validationMessage(self, value):
+        self._validationMessage = self.checkAndConvertNullable(
+            value, str, "validationMessage"
+        )
+
+    @property
+    def predefinedOptions(self) -> Optional[List[Any]]:
+        return self._predefinedOptions
+
+    @predefinedOptions.setter
+    def predefinedOptions(self, value):
+        if not self._dataType:
+            raise Exception("Data type is not set")
+
+        if not value:
+            self._predefinedOptions = None
+            return
+
+        self._predefinedOptions = (
+            self._valueTypeChecker.checkAndConvertIgnoreEnumOptions(
+                value, "predefinedOptions"
+            )
+        )
+        if not self._predefinedOptionsFromValues and self._predefinedOptions:
+            self._valueTypeChecker.enumOptions = self._predefinedOptions
+
+    @property
+    def customTypeConstraint(self) -> Optional[List["CustomTypeMinimal"]]:
+        return self._customTypeConstraint
+
+    @customTypeConstraint.setter
+    def customTypeConstraint(self, value):
+        self._customTypeConstraint = MinimalModelGenerator.MinimalFromList(
+            value, "CustomTypeMinimal", "customTypeConstraint", self._getConnection()
+        )
+
+    @property
+    def dataType(self) -> Optional[CustomFieldDataType]:
+        return self._dataType
+
+    @dataType.setter
+    def dataType(self, value):
+        self._dataType = self.checkAndConvertNullable(
+            value, CustomFieldDataType, "dataType"
+        )
+        if (
+            not self._valueTypeChecker
+            or self._valueTypeChecker.dataType != self._dataType
+        ):
+            self._valueTypeChecker = CustomFieldValueTypeChecker(
+                self._dataType,
+                self._getConnection(),
+                self._valueTypeChecker.enumOptions if self._valueTypeChecker else None,
+            )
+
+    @property
+    def predefinedOptionsFromValues(self) -> bool:
+        return self._predefinedOptionsFromValues
+
+    @predefinedOptionsFromValues.setter
+    def predefinedOptionsFromValues(self, value):
+        self._predefinedOptionsFromValues = self.checkAndConvert(
+            value, bool, "predefinedOptionsFromValues"
+        )
+
+    @property
+    def placeholder(self) -> Optional[str]:
+        return self._placeholder
+
+    @placeholder.setter
+    def placeholder(self, value):
+        self._placeholder = self.checkAndConvertNullable(value, str, "placeholder")
+
+    @property
+    def showAsTextArea(self) -> Optional[bool]:
+        return self._showAsTextArea
+
+    @showAsTextArea.setter
+    def showAsTextArea(self, value):
+        self._showAsTextArea = self.checkAndConvertNullable(
+            value, bool, "showAsTextArea"
+        )
+
+    @property
+    def templateVersion(self) -> Optional[str]:
+        return self._templateVersion
+
+    @templateVersion.setter
+    def templateVersion(self, value):
+        self._templateVersion = self.checkAndConvertNullable(
+            value, str, "templateVersion"
+        )
+
+    @property
+    def integrationId(self) -> Optional[str]:
+        return self._integrationId
+
+    @integrationId.setter
+    def integrationId(self, value):
+        self._integrationId = self.checkAndConvertNullable(value, str, "integrationId")

LOGS/Entities/CustomFieldMinimal.py

@@ -0,0 +1,8 @@
+from LOGS.Auxiliary.Decorators import FullModel
+from LOGS.Entities.CustomField import CustomField
+from LOGS.Entity.EntityMinimalWithIntId import EntityMinimalWithIntId
+
+
+@FullModel(CustomField)
+class CustomFieldMinimal(EntityMinimalWithIntId[CustomField]):
+    pass

LOGS/Entities/CustomFieldModels.py

@@ -0,0 +1,111 @@
+from enum import Enum
+from typing import TYPE_CHECKING, Type
+
+if TYPE_CHECKING:
+    from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+
+
+class CustomTypeEntityType(Enum):
+    Sample = "Sample"
+    Dataset = "Dataset"
+    InventoryItem = "InventoryItem"
+    Project = "Project"
+    Person = "Person"
+
+
+class CustomTypeEntityTypeMapper:
+    @classmethod
+    def getClass(cls, entityType: CustomTypeEntityType) -> Type["IEntityWithIntId"]:
+        mapping = {
+            CustomTypeEntityType.Sample: cls.Sample(),
+            CustomTypeEntityType.Dataset: cls.Dataset(),
+            CustomTypeEntityType.InventoryItem: cls.InventoryItem(),
+            CustomTypeEntityType.Project: cls.Project(),
+            CustomTypeEntityType.Person: cls.Person(),
+        }
+        result = mapping.get(entityType, None)
+        if result is None:
+            raise Exception(f"Unknown entity type '{entityType.name}'.")
+        return result
+
+    @classmethod
+    def Sample(cls):
+        from LOGS.Entities.Sample import Sample
+
+        return Sample
+
+    @classmethod
+    def Dataset(cls):
+        from LOGS.Entities.Dataset import Dataset
+
+        return Dataset
+
+    @classmethod
+    def InventoryItem(cls):
+        from LOGS.Entities.InventoryItem import InventoryItem
+
+        return InventoryItem
+
+    @classmethod
+    def Project(cls):
+        from LOGS.Entities.Project import Project
+
+        return Project
+
+    @classmethod
+    def Person(cls):
+        from LOGS.Entities.Person import Person
+
+        return Person
+
+
+class CustomFieldDataType(Enum):
+    String = "String"
+    StringArray = "StringArray"
+    Integer = "Integer"
+    IntegerArray = "IntegerArray"
+    Float = "Float"
+    FloatArray = "FloatArray"
+    Boolean = "Boolean"
+    Date = "Date"
+    DateArray = "DateArray"
+    DateTime = "DateTime"
+    DateTimeArray = "DateTimeArray"
+    Time = "Time"
+    TimeArray = "TimeArray"
+    DateTimeRange = "DateTimeRange"
+    TimeRange = "TimeRange"
+    Dataset = "Dataset"
+    DatasetArray = "DatasetArray"
+    Sample = "Sample"
+    SampleArray = "SampleArray"
+    Project = "Project"
+    ProjectArray = "ProjectArray"
+    Person = "Person"
+    PersonArray = "PersonArray"
+    Method = "Method"
+    MethodArray = "MethodArray"
+    SharedContent = "SharedContent"
+    SharedContentArray = "SharedContentArray"
+    LabNotebook = "LabNotebook"
+    LabNotebookArray = "LabNotebookArray"
+    LabNotebookExperiment = "LabNotebookExperiment"
+    LabNotebookExperimentArray = "LabNotebookExperimentArray"
+    LabNotebookEntry = "LabNotebookEntry"
+    LabNotebookEntryArray = "LabNotebookEntryArray"
+    Attachment = "Attachment"
+    InventoryItem = "InventoryItem"
+    InventoryItemArray = "InventoryItemArray"
+    Barcode = "Barcode"
+    Url = "Url"
+    UrlArray = "UrlArray"
+
+
+class CustomFieldValuesSearchPredicate(Enum):
+    AND = "AND"
+    OR = "OR"
+
+
+class CustomFieldValueType(Enum):
+    CustomField = "CustomField"
+    CustomTypeSection = "CustomTypeSection"

LOGS/Entities/CustomFieldRequestParameter.py

@@ -0,0 +1,69 @@
+from dataclasses import dataclass, field
+from typing import Any, List, Optional, Type, cast
+
+from typing_extensions import Self
+
+from LOGS.Entities.CustomFieldModels import (
+    CustomFieldDataType,
+    CustomFieldValuesSearchPredicate,
+)
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Entity.IGenericEntityOrderBy import (
+    IEntryRecordSortingOptions,
+    IGenericEntitySortingOptions,
+    IModificationRecordSortingOptions,
+    INamedEntitySortingOptions,
+)
+from LOGS.Interfaces.IEntryRecord import IEntryRecordRequest
+from LOGS.Interfaces.IModificationRecord import IModificationRecordRequest
+from LOGS.Interfaces.INamedEntity import INamedEntityRequest
+from LOGS.Interfaces.IOwnedEntity import IOwnedEntityRequest
+from LOGS.Interfaces.IPaginationRequest import IPaginationRequest
+from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntityRequest
+
+
+class CustomFieldSortingOptions(
+    IGenericEntitySortingOptions,
+    INamedEntitySortingOptions,
+    IEntryRecordSortingOptions,
+    IModificationRecordSortingOptions,
+):
+    DATATYPE: Self = cast(Self, "DATATYPE")
+
+
+@dataclass
+class CustomFieldValuesSearchParameters:
+    values: Optional[List[Any]] = None
+    dataType: Optional[CustomFieldDataType] = None
+    customFieldIds: Optional[List[int]] = None
+    sampleIds: Optional[List[int]] = None
+    datasetIds: Optional[List[int]] = None
+    projectIds: Optional[List[int]] = None
+    personIds: Optional[List[int]] = None
+    inventoryIds: Optional[List[int]] = None
+    facilityIds: Optional[List[int]] = None
+    predicate: Optional[CustomFieldValuesSearchPredicate] = None
+
+
+@dataclass
+class ICustomFieldValuesSearchRequest:
+    customFieldValues: Optional[List[CustomFieldValuesSearchParameters]] = None
+
+
+@dataclass
+class CustomFieldRequestParameter(
+    EntityRequestParameter[CustomFieldSortingOptions],
+    IPaginationRequest,
+    IPermissionedEntityRequest,
+    IEntryRecordRequest,
+    IModificationRecordRequest,
+    ICustomFieldValuesSearchRequest,
+    IOwnedEntityRequest,
+    INamedEntityRequest,
+):
+    _orderByType: Type[CustomFieldSortingOptions] = field(
+        default=CustomFieldSortingOptions, init=False
+    )
+
+    dataTypes: Optional[List[CustomFieldDataType]] = None
+    customFieldValues: Optional[List[CustomFieldValuesSearchParameters]] = None

LOGS/Entities/CustomFieldSearchQuery.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Optional
+
+from LOGS.Entity.SerializableContent import SerializableClass
+
+if TYPE_CHECKING:
+    pass
+
+
+class CustomFieldValuesSearchPredicate(Enum):
+    AND = "AND"
+    OR = "OR"
+
+
+class CustomFieldSearchOperator(Enum):
+    EQUALS = "EQUALS"
+    NOT_EQUALS = "NOT_EQUALS"
+    GREATER_THAN = "GREATER_THAN"
+    GREATER_THAN_OR_EQUAL = "GREATER_THAN_OR_EQUAL"
+    LESS_THAN = "LESS_THAN"
+    LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL"
+    STRING_CONTAINS = "STRING_CONTAINS"
+    STRING_NOT_CONTAINS = "STRING_NOT_CONTAINS"
+    IN_ = "IN_"
+    NOT_IN = "NOT_IN"
+    STARTS_WITH = "STARTS_WITH"
+    ENDS_WITH = "ENDS_WITH"
+    IS_NULL = "IS_NULL"
+    IS_NOT_NULL = "IS_NOT_NULL"
+
+
+@dataclass
+class CustomFieldSearchQuery(SerializableClass):
+    predicate: Optional[CustomFieldValuesSearchPredicate] = None
+    left: Optional["CustomFieldSearchQuery"] = None
+    right: Optional["CustomFieldSearchQuery"] = None
+    customFieldId: Optional[int] = None
+    operator: Optional[CustomFieldSearchOperator] = None
+    value: Optional[Any] = None

LOGS/Entities/CustomFields.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.CustomField import CustomField
+from LOGS.Entities.CustomFieldRequestParameter import CustomFieldRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("custom_fields")
+class CustomFields(EntityIterator[CustomField, CustomFieldRequestParameter]):
+    """LOGS connected CustomFields iterator"""
+
+    _generatorType = CustomField
+    _parameterType = CustomFieldRequestParameter

LOGS/Entities/CustomType.py

@@ -0,0 +1,212 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Entities.CustomField import CustomField
+from LOGS.Entities.CustomFieldModels import CustomTypeEntityType
+from LOGS.Entities.CustomTypeSection import CustomTypeSection
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+from LOGS.Interfaces.IEntryRecord import IEntryRecord
+from LOGS.Interfaces.IHierarchyType import IHierarchyType
+from LOGS.Interfaces.IModificationRecord import IModificationRecord
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IPermissionedEntity import IGenericPermissionEntity
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletable
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
+
+if TYPE_CHECKING:
+    from LOGS.Entities.CustomTypeMinimal import CustomTypeMinimal
+
+
+@Endpoint("types")
+class CustomType(
+    IEntityWithIntId,
+    IGenericPermissionEntity,
+    INamedEntity,
+    IUniqueEntity,
+    IEntryRecord,
+    IModificationRecord,
+    ISoftDeletable,
+    IHierarchyType,
+):
+    _noSerialize = ["connection", "cachePath", "cacheId", "cacheDir", "customFields"]
+
+    _description: Optional[str] = None
+    _entityType: Optional[CustomTypeEntityType] = None
+    _hasRestrictedAddPermission: Optional[bool] = None
+    _hasRestrictedEditPermission: Optional[bool] = None
+    _hasRestrictedReadPermission: Optional[bool] = None
+    _isEnabled: Optional[bool] = None
+    _inventoryName: Optional[str] = None
+    _inventoryDescription: Optional[str] = None
+    _isHierarchyRoot: Optional[bool] = None
+    _rootHierarchy: Optional["CustomTypeMinimal"] = None
+    _parentTypes: Optional[List["CustomTypeMinimal"]] = None
+    _templateVersion: Optional[str] = None
+    _integrationId: Optional[str] = None
+    _sections: Optional[List[CustomTypeSection]] = None
+
+    def contentToString(self, indentation: int = 1, hideNone: bool = False) -> str:
+        bak = self._noSerialize
+        self._noSerialize = [*bak, "sections"]
+        tab = self._indentationString * indentation
+        tabContent = self._indentationString * (indentation + 1)
+        s = super().contentToString(indentation, hideNone)
+        # s = ""
+        s += f"{tab}sections=\n"
+        self._noSerialize = bak
+        for section in self.sections or []:
+            if not section and hideNone:
+                continue
+            content = ""
+            if section is not None:
+                content = section.contentToString(indentation + 2, hideNone=hideNone)
+            if not content and hideNone:
+                continue
+            s += f"{tabContent}{content}"
+        return s
+
+    @property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @description.setter
+    def description(self, value):
+        self._description = self.checkAndConvertNullable(value, str, "description")
+
+    @property
+    def entityType(self) -> Optional[CustomTypeEntityType]:
+        return self._entityType
+
+    @entityType.setter
+    def entityType(self, value):
+        self._entityType = self.checkAndConvertNullable(
+            value, CustomTypeEntityType, "entityType"
+        )
+
+    @property
+    def hasRestrictedAddPermission(self) -> Optional[bool]:
+        return self._hasRestrictedAddPermission
+
+    @hasRestrictedAddPermission.setter
+    def hasRestrictedAddPermission(self, value):
+        self._hasRestrictedAddPermission = self.checkAndConvertNullable(
+            value, bool, "hasRestrictedAddPermission"
+        )
+
+    @property
+    def hasRestrictedEditPermission(self) -> Optional[bool]:
+        return self._hasRestrictedEditPermission
+
+    @hasRestrictedEditPermission.setter
+    def hasRestrictedEditPermission(self, value):
+        self._hasRestrictedEditPermission = self.checkAndConvertNullable(
+            value, bool, "hasRestrictedEditPermission"
+        )
+
+    @property
+    def hasRestrictedReadPermission(self) -> Optional[bool]:
+        return self._hasRestrictedReadPermission
+
+    @hasRestrictedReadPermission.setter
+    def hasRestrictedReadPermission(self, value):
+        self._hasRestrictedReadPermission = self.checkAndConvertNullable(
+            value, bool, "hasRestrictedReadPermission"
+        )
+
+    @property
+    def sections(self) -> Optional[List[CustomTypeSection]]:
+        return self._sections
+
+    @sections.setter
+    def sections(self, value):
+        self._sections = self.checkListAndConvertNullable(
+            value, CustomTypeSection, "sections"
+        )
+
+    @property
+    def isEnabled(self) -> Optional[bool]:
+        return self._isEnabled
+
+    @isEnabled.setter
+    def isEnabled(self, value):
+        self._isEnabled = self.checkAndConvertNullable(value, bool, "isEnabled")
+
+    @property
+    def inventoryName(self) -> Optional[str]:
+        return self._inventoryName
+
+    @inventoryName.setter
+    def inventoryName(self, value):
+        self._inventoryName = self.checkAndConvertNullable(value, str, "inventoryName")
+
+    @property
+    def inventoryDescription(self) -> Optional[str]:
+        return self._inventoryDescription
+
+    @inventoryDescription.setter
+    def inventoryDescription(self, value):
+        self._inventoryDescription = self.checkAndConvertNullable(
+            value, str, "inventoryDescription"
+        )
+
+    @property
+    def isHierarchyRoot(self) -> Optional[bool]:
+        return self._isHierarchyRoot
+
+    @isHierarchyRoot.setter
+    def isHierarchyRoot(self, value):
+        self._isHierarchyRoot = self.checkAndConvertNullable(
+            value, bool, "isHierarchyRoot"
+        )
+
+    @property
+    def rootHierarchy(self) -> Optional["CustomTypeMinimal"]:
+        return self._rootHierarchy
+
+    @rootHierarchy.setter
+    def rootHierarchy(self, value):
+        self._rootHierarchy = MinimalModelGenerator.MinimalFromSingle(
+            value, "CustomTypeMinimal", "rootHierarchy", self._getConnection()
+        )
+
+    @property
+    def parentTypes(self) -> Optional[List["CustomTypeMinimal"]]:
+        return self._parentTypes
+
+    @parentTypes.setter
+    def parentTypes(self, value):
+        self._parentTypes = MinimalModelGenerator.MinimalFromList(
+            value, "CustomTypeMinimal", "parentTypes", self._getConnection()
+        )
+
+    @property
+    def customFields(self) -> List[CustomField]:
+        if self.sections is None:
+            return []
+
+        return [
+            field
+            for section in self.sections
+            if section.customFields is not None
+            for field in section.customFields
+            if field is not None
+        ]
+
+    @property
+    def templateVersion(self) -> Optional[str]:
+        return self._templateVersion
+
+    @templateVersion.setter
+    def templateVersion(self, value):
+        self._templateVersion = self.checkAndConvertNullable(
+            value, str, "templateVersion"
+        )
+
+    @property
+    def integrationId(self) -> Optional[str]:
+        return self._integrationId
+
+    @integrationId.setter
+    def integrationId(self, value):
+        self._integrationId = self.checkAndConvertNullable(value, str, "integrationId")