onspring-api-sdk-python/Models.py

import datetime
import uuid

from Enums import *
from decimal import Decimal
from datetime import datetime
from Helpers import parseDate

# generic

class ApiResponse:
    """
    An object to represent a response to a request made by an `OnspringClient`.

    Attributes:
        statusCode (`int`): The http status code of the response.
        data: If the success was successful will contain the response data deserialized to custom python objects.
        message (`str`): A message that may provide more detail about the requests success or failure.
        raw (`requests.Response`): Exposes the raw response object of the request if you'd like to handle it directly.
    """

    def __init__(self, statusCode=None, data=None, message=None, raw=None):
        self.statusCode = statusCode
        self.isSuccessful = int(statusCode) < 400
        self.data = data
        self.message = message
        self.raw = raw

class PagingRequest:
    """
    An object to represent the page number and page size of a paginated request made by an `OnspringClient`.

    Attributes:
        pageNumber (`int`): The page number that will be requested.
        pageSize (`int`): The size of the page that will be requested.
    """

    def __init__(self, pageNumber: int, pageSize: int):
        self.pageNumber = pageNumber
        self.pageSize = pageSize

#app specific

class App:
    """
    An object to represent an Onspring app.

    Attributes:
        href (`str`): The href for the Onspring app.
        id (`int`): The id of the Onspring app.
        name (`str`): The name of the Onspring app.
    """

    def __init__(self, href: str, id: int, name: str):
        self.href = href
        self.id = id
        self.name = name

class GetAppsResponse:
    """
    An object to represent a paginated response to a request made by an `OnspringClient` to request a collection of Onspring apps.

    Attributes:
        pageNumber (`int`): The page number returned.
        pageSize (`int`): The size of the page returned.
        totalPages (`int`): The total number of pages for the request.
        totalRecords (`int`): The total records for the request.
        apps (`list[Models.App]`): The apps requested.
    """

    def __init__(self, pageNumber: int, pageSize: int, totalPages:int , totalRecords: int, apps: list[App]):
        self.pageNumber = pageNumber
        self.pageSize = pageSize
        self.totalPages = totalPages
        self.totalRecords = totalRecords
        self.apps = apps

class GetAppByIdResponse:
    """
    An object to represent a response to a request made by an `OnspringClient` to request an Onspring app.

    Attributes:
        app (`Models.App`): The requested app.
    """

    def __init__(self, app: App):
        self.app = app

class GetAppsByIdsResponse:
    """
    An object to represent a response to a request made by an `OnspringClient` to request a collection of Onspring apps.

    Attributes:
        count (`int`): The number of apps requested.
        apps (`list[Models.App]`): The apps requested.
    """

    def __init__(self, count: int, apps: list[App]):
        self.count = count
        self.apps = apps

# field specific

class ListValue:
    """
    An object to represent an Onspring list value.

    Attributes:
        id (`int`): The id of the Onspring list value.
        name (`str`): The list value's name.
        sortOrder (`int`): The list value's sort order in respect to other values in the same list.
        numericalValue (`Decimal`): The numeric value assigned to the list value.
        color (`str`): The color assigned to the list value.
    """

    def __init__(self, id: int, name: str, sortOrder: int, numericValue: Decimal, color: str):
        self.id = id
        self.name = name
        self.sortOrder = sortOrder

        if numericValue != None:
            self.numericValue = Decimal(numericValue)
        else:
            self.numericValue = numericValue
        
        self.color = color

    def AsString(self):
        """
        Gets the list value as a comma separated string of it's properties and their values.

        Args:
            None

        Returns:
            A `str` representation of the list value object.
        """

        return f'Id: {self.id}, Name: {self.name}, Value: {self.numericValue}, Sort Order: {self.sortOrder}, Color: {self.color}'

class Field:
    """
    An object to represent an Onspring field.

    Attributes:
        id (`int`): The id of the Onspring field.
        appId ('int'): The id of the Onspring app where the field resides.
        name (`str`): The name of the field.
        type (`str`): The type of the field.
        status (`str`): The stuat of the field.
        isRequired (`bool`): Indicates whether the field is required in Onspring or not.
        isUnique (`bool`): Indicates whether the field requires unique values in Onspring or not.
        listId (`int`): The id of the fields list if applicable. Used for list fields and formula fields with list output type.
        values (`list[Models.ListValue]`): The values of the fields list if applicable. Used for list fields and formula fields with list output type.
        multiplicity (`str`): The multiplicity of the field if applicable. Used for list fields, reference fields, and formula fields with a list output type.
        outputType (`str`): The output type of the field if applicable. Used for formula fields.
    """

    def __init__(
        self, id: int, 
        appId: int, 
        name: str, 
        type: str, 
        status: str, 
        isRequired: bool, 
        isUnique: bool, 
        listId: int=None, 
        values: list[ListValue]=None, 
        multiplicity: str=None,
        outputType: str=None
        ):

        self.id = id
        self.appId = appId
        self.name = name
        self.type = type
        self.status = status
        self.isRequired = isRequired
        self.isUnique = isUnique
        self.listId = listId
        self.values = values
        self.outputType = outputType
        self.multiplicity = multiplicity

class GetFieldByIdResponse:
    """
    An object to represent a response to a request made by an `OnspringClient` to request an Onspring field.

    Attributes:
        field (`Models.Field`): The requested field.
    """

    def __init__(self, field: Field):
        self.field = field

class GetFieldsByIdsResponse:
    """
    An object to represent a response to a request made by an `OnspringClient` to request a collection of Onspring fields.

    Attributes:
        count (`int`): The number of fields requested.
        fields (`list[Models.Field]`): The fields requested.
    """

    def __init__(self, count: int, fields: list[Field]):
        self.count = count
        self.fields = fields

class GetFieldsByAppIdResponse:
    """
    An object to represent a paginated response to a request made by an `OnspringClient` to request a collection of Onspring fields.

    Attributes:
        pageNumber (`int`): The page number returned.
        pageSize (`int`): The size of the page returned.
        totalPages (`int`): The total number of pages for the request.
        totalRecords (`int`): The total records for the request.
        fields (`list[Models.Field]`): The fields requested.
    """

    def __init__(self, pageNumber: int, pageSize: int, totalPages: int, totalRecords: int, fields: list[Field]):
        self.pageNumber = pageNumber
        self.pageSize = pageSize
        self.totalPages = totalPages
        self.totalRecords = totalRecords
        self.fields = fields

# file specific

class File:
    """
    An object to represent a file stored in Onsprng.

    Attributes:
        name (`str`): The name of the file.
        contentType (`str`): The content type of the file.
        contentLength (`int`): The length of the file's content.
        content (`bytes`): The content of the file.
    """

    def __init__(self, name: str, contentType: str, contentLength: int, content: bytes):
        self.name = name
        self.contentType = contentType
        self.contentLength = contentLength
        self.content = content

class FileInfo:
    """
    An object to represent the metadata for a file stored in Onspring.

    Attributes:
        type (`str`): The type of file as stored in Onspring Attachment or Image.
        contentType (`str`): The content type of the file itself.
        name (`str`): The name of the file
        createdDate (`datetime`): The created date of the file.
        modifiedDate (`datetime`): The modified date of the file.
        owner (`str`): The owner of the file.
        fileHref (`str`): The href for the file.
    """

    def __init__(self, type: str, contentType: str, name: str, createdDate: datetime, modifiedDate: datetime, owner: str, fileHref: str):
        self.type = type
        self.contentType = contentType
        self.name = name
        self.createdDate = createdDate
        self.modifiedDate = modifiedDate
        self.owner = owner
        self.fileHref = fileHref

class GetFileInfoByIdResponse:
    """
    An object to represent a response to a request made by an `OnspringClient` to request a info for a file in Onspring.

    Attributes:
        fileInfo (`Models.FileInfo`): The file info requested.
    """

    def __init__(self, fileInfo: FileInfo):
        self.fileInfo = fileInfo

class GetFileByIdResponse:
    """
    An object to represent a response to a request made by an `OnspringClient` to request a file in Onspring.

    Attributes:
        file (`Models.File`): The file requested.
    """

    def __init__(self, file: File):
        self.file = file

class SaveFileRequest:
    """
    An object to represent all the necessary information needed to make a successful 'OnspringClient.SaveFile' request.

    Attributes:
        recordId (`int`): The unique id of the record where you want to save the file.
        fieldId (`int`): The unique id of the field where you want to save the file.
        fileName (`str`): The name of the file you want to save.
        filePath (`str`): The path to the file you want to save.
        contentType (`str`): The content type of the file you want to save.
        notes (`str`): An option note about the file.
        notes (`datetime`): An optional date noting when the file was modified.
    """
    def __init__(self, recordId: int, fieldId: int, fileName: str, filePath: str, contentType: str, notes: str=None, modifiedDate: datetime=None):
        self.recordId = recordId
        self.fieldId = fieldId
        self.notes = notes
        self.modifiedDate = modifiedDate
        self.fileName = fileName
        self.filePath = filePath
        self.contentType = contentType

class SaveFileResponse:
    """
    An object to represent a response to a request made by an `OnspringClient` to save a file in Onspring.

    Attributes:
        id (`int`): The id of the file saved in Onspring.
    """

    def __init__(self, id: int):
        self.id = id

# list specific

class ListItemRequest:
    """
    An object to represent the necessary information for adding or updating a list value. If no id is provided the list value will be added. If an id is provided then an attempt will be made to find that list value and update it.

    Attributes:
        listId (`int`): The id of the parent list that the list value belongs to.
        name (`str`): The name of the list value.
        id (`uuid`): The id of the list value.
        numericValue (`int`): The numeric value assigned to the list value.
        color (`str`): The color value assigned to the list value.
    """

    def __init__(self, listId: int, name: str, id: uuid=None, numericValue: int=None, color: str=None):
        self.listId = listId
        self.name = name
        self.id = id
        self.numericValue = numericValue
        self.color = color

class AddOrUpdateListItemResponse:
    """
    An object to represent a response to a request made by an `OnspringClient` to add or update a list value in Onspring.

    Attributes:
        id (`int`): The id of the list value updated or added in Onspring.
    """

    def __init__(self, id: uuid):
        self.id = id

# record specific

class RecordFieldValue:
    """
    An object to represent the value in a field in an Onspring record.

    Attributes:
        fieldId (`int`): The id of the field that the value is in.
        value (`str`): The value of the field.
        type (`str`): The type of value.
    """

    def __init__(self, fieldId: int, value: str, type: str=None):
        self.fieldId = fieldId
        self.value = value
        self.type = type

    def AsString(self):
        """
        If the `Models.RecordFieldValue` type is String will return the value property as a `str` otherwise will return `None`.

        Args:
            None

        Returns:
            The value of the `Models.RecordFieldValue` as a `str`.
        """
        
        if self.type != ResultValueType.String.name:
            return None

        return StringFieldValue(self.fieldId, self.value).value

    def AsInteger(self):
        """
        If the `Models.RecordFieldValue` type is Integer will return the value property as an `int` otherwise will return `None`.

        Args:
            None

        Returns:
            The value of the `Models.RecordFieldValue` as an `int`.
        """
        
        if self.type != ResultValueType.Integer.name:
            return None
        
        return IntegerFieldValue(self.fieldId, int(self.value)).value

    def AsDecimal(self):
        """
        If the `Models.RecordFieldValue` type is Decimal will return the value property as a `Decimal` otherwise will return `None`.

        Args:
            None

        Returns:
            The value of the `Models.RecordFieldValue` as a `Decimal`.
        """
        
        if self.type != ResultValueType.Decimal.name:
            return None
        
        return DecimalFieldValue(self.fieldId, Decimal(self.value)).value

    def AsDate(self):
        """
        If the `Models.RecordFieldValue` type is Date will return the value property as a `datetime` otherwise will return `None`.

        Args:
            None

        Returns:
            The value of the `Models.RecordFieldValue` as a `datetime`.
        """
        
        if self.type != ResultValueType.Date.name:
            return None

        date = parseDate(self.value)

        return DateFieldValue(self.fieldId, date).value

    def AsGuid(self):
        """
        If the `Models.RecordFieldValue` type is Guid will return the value property as an `UUID` otherwise will return `None`.

        Args:
            None

        Returns:
            The value of the `Models.RecordFieldValue` as an `UUID`.
        """

        if self.type != ResultValueType.Guid.name:
            return None
        
        return GuidFieldValue(self.fieldId, uuid.UUID(self.value)).value
        
    def AsTimeSpan(self):
        """
        If the `Models.RecordFieldValue` type is TimeSpan will return the value property as a `Model.TimeSpanData` otherwise will return `None`.

        Args:
            None

        Returns:
            The value of the `Models.RecordFieldValue` as a `Model.TimeSpanData`.
        """

        if self.type != ResultValueType.TimeSpan.name:
            return None
        
        value = dict(self.value)

        quantity = value.get('quantity')
        increment = value.get('increment')
        recurrence = value.get('recurrence')
        endByDate = value.get('endByDate')
        endAfterOccurrences = value.get('endAfterOccurrences')

        endByDate = parseDate(endByDate)

        data = TimeSpanData(
            quantity,
            increment,
            recurrence,
            endByDate,
            endAfterOccurrences)

        return TimeSpanValue(self.fieldId, data).value

    def AsStringList(self):
        """
        If the `Models.RecordFieldValue` type is StringList will return the value property as a `list[str]` otherwise will return `None`.

        Args:
            None

        Returns:
            The value of the `Models.RecordFieldValue` as a `list[str]`.
        """

        if self.type != ResultValueType.StringList.name:
            return None
        
        strings = [str(string) for string in self.value]

        return StringListValue(self.fieldId, strings).value

    def AsIntegerList(self):
        """
        If the `Models.RecordFieldValue` type is IntegerList will return the value property as a `list[int]` otherwise will return `None`.

        Args:
            None

        Returns:
            The value of the `Models.RecordFieldValue` as a `list[int]`.
        """
        
        if self.type != ResultValueType.IntegerList.name:
            return None

        integers = [int(integer) for integer in self.value]
            
        return IntegerListValue(self.fieldId, integers).value

    def AsGuidList(self):
        """
        If the `Models.RecordFieldValue` type is GuidList will return the value property as a `list[UUID]` otherwise will return `None`.

        Args:
            None

        Returns:
            The value of the `Models.RecordFieldValue` as a `list[UUID]`.
        """

        if self.type != ResultValueType.GuidList.name:
            return None

        guids = []

        for guid in self.value:
            guids.append(uuid.UUID(guid))
            
        return GuidListValue(self.fieldId, guids).value

    def AsAttachmentList(self):
        """
        If the `Models.RecordFieldValue` type is AttachmentList will return the value property as a `list[Models.Attachment]` otherwise will return `None`.

        Args:
            None

        Returns:
            The value of the `Models.RecordFieldValue` as a `list[Models.Attachment]`.
        """

        if self.type != ResultValueType.AttachmentList.name:
            return None

        attachments = []

        for attachment in self.value:

            attachment = dict(attachment)

            attachment = Attachment(
                attachment.get('fileId'),
                attachment.get('fileName'),
                attachment.get('notes'),
                attachment.get('storageLocation'))

            attachments.append(attachment)

        return AttachmentListValue(self.fieldId, attachments).value

    def AsScoringGroupList(self):
        """
        If the `Models.RecordFieldValue` type is ScoringGroupList will return the value property as a `list[Models.ScoringGroup]` otherwise will return `None`.

        Args:
            None

        Returns:
            The value of the `Models.RecordFieldValue` as a `list[Models.ScoringGroup]`.
        """

        if self.type != ResultValueType.ScoringGroupList.name:
            return

        scoringGroups = []

        for scoringGroup in self.value:

            scoringGroup = dict(scoringGroup)

            scoringGroup = ScoringGroup(
                uuid.UUID(scoringGroup.get('listValueId')),
                scoringGroup.get('name'),
                Decimal(scoringGroup.get('score')),
                Decimal(scoringGroup.get('maximumScore')))

            scoringGroups.append(scoringGroup)
        
        return ScoringGroupListValue(self.fieldId, scoringGroups).value

    def AsFileList(self):
        """
        If the `Models.RecordFieldValue` type is FileList will return the value property as a `list[int]` otherwise will return `None`.

        Args:
            None

        Returns:
            The value of the `Models.RecordFieldValue` as a `list[int]`.
        """
        
        if self.type != ResultValueType.FileList.name:
            return None

        files = [int(file) for file in self.value]
            
        return FileListValue(self.fieldId, files).value

    def getValue(self):
        """
        Will determine the appropriate way to return the fields value based on it's type.

        Args:
            None

        Returns:
            The value of the `Models.RecordFieldValue` as the appropriate object.
        """

        if self.type == ResultValueType.String.name:
            return self.AsString()

        elif self.type == ResultValueType.Integer.name:
            return self.AsInteger()

        elif self.type == ResultValueType.Decimal.name:
            return self.AsDecimal()

        elif self.type == ResultValueType.Date.name:
            return self.AsDate()

        elif self.type == ResultValueType.TimeSpan.name:
            return self.AsTimeSpan()

        elif self.type == ResultValueType.Guid.name:
            return self.AsGuid()

        elif self.type == ResultValueType.StringList.name:
            return self.AsStringList()

        elif self.type == ResultValueType.IntegerList.name:
            return self.AsIntegerList()

        elif self.type == ResultValueType.GuidList.name:
            return self.AsGuidList()

        elif self.type == ResultValueType.AttachmentList.name:
            return self.AsAttachmentList()

        elif self.type == ResultValueType.ScoringGroupList.name:
            return self.AsScoringGroupList()

        elif self.type == ResultValueType.FileList.name:
            return self.AsFileList()

        else:
            return None

    def GetResultValueString(self):
        """
        Will return the value property regardless of the field value's type as a string.

        Args:
            None

        Returns:
            The value of the `Models.RecordFieldValue` as a string.
        """
        if self.type == ResultValueType.String.name:
            return self.AsString()

        elif self.type == ResultValueType.Integer.name:
            return self.AsInteger()

        elif self.type == ResultValueType.Decimal.name:
            return self.AsDecimal()

        elif self.type == ResultValueType.Date.name:
            return self.AsDate()

        elif self.type ==  ResultValueType.TimeSpan.name:
            data = self.AsTimeSpan()
            return f'Quantity: {data.quantity}, Increment: {data.increment}, Recurrence: {data.recurrence}, EndByDate: {data.endByDate}, EndAfterOccurrences: {data.endAfterOccurrences}'
            
        elif self.type == ResultValueType.Guid.name:
            return self.AsGuid()
            
        elif self.type ==  ResultValueType.StringList.name:
            data = self.AsStringList()
            return f'{",".join(data)}'
            
        elif self.type == ResultValueType.IntegerList.name:
            data = self.AsIntegerList()
            return f'{",".join([str(i) for i in data])}'
            
        elif self.type == ResultValueType.GuidList.name:
            data = self.AsGuidList()
            return f'{",".join([str(guid) for guid in data])}'
            
        elif self.type == ResultValueType.AttachmentList.name:
            data = self.AsAttachmentList()

            strings = []

            for attachment in data:
                string = f'FileId: {attachment.fileId}, FileName: {attachment.fileName}, Notes: {attachment.notes}, StorageLocation: {attachment.storageLocation}'
                strings.append(string)
            
            return f'{"; ".join(strings)}'
            
        elif self.type == ResultValueType.ScoringGroupList.name:
            data = self.AsScoringGroupList()

            strings = []

            for scoringGroup in data:
                string = f'ListValueId: {scoringGroup.listValueId}, Name: {scoringGroup.name}, Score: {scoringGroup.score}, Max Score: {scoringGroup.maximumScore}'
                strings.append(string)

            return f'{"; ".join(strings)}'

        elif self.type == ResultValueType.FileList.name:
            data = self.AsFileList()
            return f'{",".join([str(i) for i in data])}'

        else:
            return None

class Record:
    """
    An object to represent an Onspring record.

    Attributes:
        appId ('int'): The id of the Onspring app where the record resides.
        recordId (`int`): The id of the Onspring record.
        fields (`list[Models.RecordFieldValue]`): The record's field values.
    """
    
    def __init__(self, appId: int, fields: list[RecordFieldValue], recordId: int=None):
        self.appId = appId
        self.recordId = recordId
        self.fields = fields

class GetRecordsByAppRequest:
    """
    An object to represent all the necessary information for making a succcessful request to get a collection of Onspring records.

    Attributes:
        appId (`int`): The id for the Onspring app where the records reside.
        fieldIds (`list[int]`): The ids for the fields in the Onspring app that should be included for each record in the response.
        dataFormat (`str`): The format of the response data.
        pagingRequest (`Models.PagingRequest`): Used to set the page number and page size of the request. By default the these will be 1 and 50 respectively.
    """

    def __init__(self, appId: int, fieldIds: list[int]=[], dataFormat: str=DataFormat.Raw.name, pagingRequest: PagingRequest=PagingRequest(1,50)):
        self.appId = appId
        self.fieldIds = fieldIds
        self.dataFormat = dataFormat
        self.pageSize = pagingRequest.pageSize
        self.pageNumber = pagingRequest.pageNumber

class QueryRecordsRequest:
    """
    An object to represent all the necessary information for making a succcessful request to get a collection of Onspring records based on a specific criteria. For more information on constructing a proper filter please refer to the official Onspring API guide: https://shorturl.at/cnsFK.

    Attributes:
        appId (`int`): The id for the Onspring app where the records reside.
        filter (`str`): The criteria used to determine what records should be included in the response.
        fieldIds (`list[int]`): The ids for the fields in the Onspring app that should be included for each record in the response.
        dataFormat (`str`): The format of the response data.
        pagingRequest (`Models.PagingRequest`): Used to set the page number and page size of the request. By default the these will be 1 and 50 respectively.
    """

    def __init__(self, appId: int, filter: str, fieldIds: list[int]=[], dataFormat: str=DataFormat.Raw.name, pagingRequest: PagingRequest=PagingRequest(1,50)):
        self.appId = appId
        self.filter = filter
        self.fieldIds = fieldIds
        self.dataFormat = dataFormat
        self.pagingRequest = pagingRequest

class GetRecordsResponse:


    def __init__(self, pageNumber: int, pageSize: int, totalPages: int, totalRecords: int, records: list[Record]):
        self.pageNumber = pageNumber
        self.pageSize = pageSize
        self.totalPages = totalPages
        self.totalRecords = totalRecords
        self.records = records

class GetRecordByIdRequest:
    def __init__(self, appId: int, recordId: int, fieldIds: list[int]=[], dataFormat: str=DataFormat.Raw.name):
        self.appId = appId
        self.recordId = recordId
        self.fieldIds = fieldIds
        self.dataFormat = dataFormat

class GetBatchRecordsRequest:
    def __init__(self, appId: int, recordIds: list[int], fieldIds: list[int]=[], dataFormat: str=DataFormat.Raw.name):
        self.appId = appId
        self.recordIds = recordIds
        self.fieldIds = fieldIds
        self.dataFormat = dataFormat

class GetBatchRecordsResponse:
    def __init__(self, count: int, records: list[Record]):
        self.count = count
        self.records = records

class AddOrUpdateRecordResponse:
    def __init__(self, id: int, warnings: list[str]=[]):
        self.id = id
        self.warnings = warnings

class DeleteBatchRecordsRequest:
    def __init__(self, appId: int, recordIds: list[int]):
        self.appId = appId
        self.recordIds = recordIds

# field types

class StringFieldValue(RecordFieldValue):
    def __init__(self, fieldId: int, value):
        self.type = ResultValueType.String.name
        RecordFieldValue.__init__(self, fieldId, value, self.type)

class IntegerFieldValue(RecordFieldValue):
    def __init__(self, fieldId: int, value: int):
        self.type = ResultValueType.Integer.name
        RecordFieldValue.__init__(self, fieldId, value, self.type)

class DecimalFieldValue(RecordFieldValue):
    def __init__(self, fieldId: int, value: Decimal):
        self.type = ResultValueType.Decimal.name
        RecordFieldValue.__init__(self, fieldId, value, self.type)

class DateFieldValue(RecordFieldValue):
    def __init__(self, fieldId: int, value: datetime):
        self.type = ResultValueType.Date.name
        RecordFieldValue.__init__(self, fieldId, value, self.type)

class GuidFieldValue(RecordFieldValue):
    def __init__(self, fieldId: int, value: uuid.UUID):
        self.type = ResultValueType.Guid.name
        RecordFieldValue.__init__(self, fieldId, value, self.type)

class TimeSpanData:
    def __init__(self, quantity: Decimal, increment: Increment, recurrence: Recurrence=None, endByDate: datetime=None, endAfterOccurrences: int=None):
        self.quantity = quantity
        self.increment = increment
        self.recurrence = recurrence
        self.endByDate = endByDate
        self.endAfterOccurrences = endAfterOccurrences

    def AsString(self):
        if self.endByDate != None:
            formattedDate = self.endByDate.strftime("%m/%d/%Y %I:%M %p")
            return f'Every {self.quantity} {self.increment} End By {formattedDate}'
        elif self.endAfterOccurrences != None:
            return f'Every {self.quantity} {self.increment} End After {self.endAfterOccurrences}'
        else:
            return f'{self.quantity} {self.increment}'

class TimeSpanValue(RecordFieldValue):
    def __init__(self, fieldId: int, value: TimeSpanData):
        self.type = ResultValueType.TimeSpan.name
        RecordFieldValue.__init__(self, fieldId, value, self.type)

class StringListValue(RecordFieldValue):
    def __init__(self, fieldId: int, value: list[str]):
        self.type = ResultValueType.StringList.name
        RecordFieldValue.__init__(self, fieldId, value, self.type)

class IntegerListValue(RecordFieldValue):
    def __init__(self, fieldId: int, value: list[int]):
        self.type = ResultValueType.IntegerList.name
        RecordFieldValue.__init__(self, fieldId, value, self.type)

class GuidListValue(RecordFieldValue):
    def __init__(self, fieldId: int, value: list[uuid.UUID]):
        self.type = ResultValueType.GuidList.name
        RecordFieldValue.__init__(self, fieldId, value, self.type)

class Attachment:
    def __init__(self, fileId: int, fileName: str, notes: str, storageLocation: str):
        self.fileId = fileId
        self.fileName = fileName
        self.notes = notes
        self.storageLocation = storageLocation

class AttachmentListValue(RecordFieldValue):
    def __init__(self, fieldId: int, value: list[Attachment]):
        self.type = ResultValueType.AttachmentList.name
        RecordFieldValue.__init__(self, fieldId, value, self.type)

class FileListValue(RecordFieldValue):
    def __init__(self, fieldId: int, value: list[int]):
        self.type = ResultValueType.FileList.name
        RecordFieldValue.__init__(self, fieldId, value, self.type)

class ScoringGroup:
    def __init__(self, listValueId: uuid.UUID, name: str, score: Decimal, maximumScore: Decimal):
        self.listValueId = listValueId
        self.name = name
        self.score = score
        self.maximumScore = maximumScore

class ScoringGroupListValue(RecordFieldValue):
    def __init__(self, fieldId: int, value: list[ScoringGroup]):
        self.type = ResultValueType.ScoringGroupList.name
        RecordFieldValue.__init__(self, fieldId, value, self.type)

# report specific

class GetReportByIdRequest:
    def __init__(self, reportId: int, apiDataFormat: str=DataFormat.Raw.name, dataType: str=ReportDataType.ReportData.name):
        self.reportId = reportId
        self.apiDataFormat = apiDataFormat
        self.dataType = dataType

class Row:
    def __init__(self, recordId: int, cells: list[str]):
        self.recordId = recordId
        self.cells = cells

class GetReportByIdResponse:
    def __init__(self, columns: list[str], rows: list[Row]):
        self.columns = columns
        self.rows = rows

class Report:
    def __init__(self, appId: int, id: int, name: str, description: str):
        self.appId = appId
        self.id = id
        self.name = name
        self.description = description

class GetReportsByAppIdResponse:
    def __init__(self, pageNumber: int, pageSize: int, totalPages: int, totalRecords: int, reports: list[Report]):
        self.pageNumber = pageNumber
        self.pageSize = pageSize
        self.totalPages = totalPages
        self.totalRecords = totalRecords
        self.reports = reports