models.py

from enum import Enum
import datetime
import json
import pydantic

from typing import Optional, List


class BaseModel(pydantic.BaseModel):
    @classmethod
    def from_dict(cls, data):
        return cls(**data)

    @classmethod
    def from_json(cls, json_data):
        data = json.loads(json_data)
        return cls.from_dict(data)

    def dict(self, by_alias=True, skip_defaults=True, *args, **kwargs):
        return super().dict(
            by_alias=by_alias, skip_defaults=skip_defaults, *args, **kwargs)

    def json(self, by_alias=True, skip_defaults=True, *args, **kwargs):
        return super().json(
            by_alias=by_alias, skip_defaults=skip_defaults, *args, **kwargs)


class Identifier(BaseModel):
    """ An object with only an ID that references some entity. """
    id: str


class Reference(BaseModel):
    """ Also called a searchlist. """
    id: str
    name: str


class OptionalFields(BaseModel):
    """ An abomination. """
    boolean1: Optional[bool]
    boolean2: Optional[bool]
    boolean3: Optional[bool]
    boolean4: Optional[bool]
    boolean5: Optional[bool]
    number1: Optional[int]
    number2: Optional[int]
    number3: Optional[int]
    number4: Optional[int]
    number5: Optional[int]
    date1: Optional[datetime.datetime]
    date2: Optional[datetime.datetime]
    date3: Optional[datetime.datetime]
    date4: Optional[datetime.datetime]
    date5: Optional[datetime.datetime]
    text1: Optional[str]
    text2: Optional[str]
    text3: Optional[str]
    text4: Optional[str]
    text5: Optional[str]
    searchlist1: Optional[Reference]
    searchlist2: Optional[Reference]
    searchlist3: Optional[Reference]
    searchlist4: Optional[Reference]
    searchlist5: Optional[Reference]


class AddressTypeEnum(str, Enum):
    gb = 'GB'
    nl = 'NL'
    memo = 'MEMO'


class Address(BaseModel):
    street: Optional[str] = ''
    number: Optional[str] = ''
    country: Optional[Reference]
    city: Optional[str] = ''
    county: Optional[str] = ''
    postcode: Optional[str] = ''
    memo: Optional[str] = ''
    type: Optional[AddressTypeEnum]

    class Config:
        fields = {
            'memo': {'alias': 'addressMemo'},
            'type': {'alias': 'addressType'},
        }


class BranchTypeEnum(str, Enum):
    independent = 'independentBranch'
    head = 'headBranch'
    has_a_head = 'hasAHeadBranch'


class Branch(BaseModel):
    id: str = None
    name: str = ''
    specification: str = ''
    client_reference_number: str = ''
    timezone: str = None
    extra_a: Optional[Reference]
    extra_b: Optional[Reference]
    phone: str = ''
    fax: str = ''
    address: Address = None
    postal_address: Address = None
    email: str = ''
    website: str = ''
    type: Optional[BranchTypeEnum]
    head_branch: Optional[Identifier]
    creator: Optional[Reference]
    created: Optional[datetime.datetime]
    modified: Optional[datetime.datetime]
    modifier: Optional[Reference]
    optional_fields_1: Optional[OptionalFields]
    optional_fields_2: Optional[OptionalFields]

    class Config:
        fields = {
            'client_reference_number': {'alias': 'clientReferenceNumber'},
            'timezone': {'alias': 'timeZone'},
            'extra_a': {'alias': 'extraA'},
            'extra_b': {'alias': 'extraB'},
            'postal_address': {'alias': 'postalAddress'},
            'type': {'alias': 'branchType'},
            'head_branch': {'alias': 'headBranch'},
            'optional_fields_1': {'alias': 'optionalFields1'},
            'optional_fields_2': {'alias': 'optionalFields2'},
            'created': {'alias': 'creationDate'},
            'modified': {'alias': 'modificationDate'},
        }

    def dict(self, *args, **kwargs):
        kwargs['exclude'] = {'id'}
        return super().dict(*args, **kwargs)


class BranchReference(BaseModel):
    id: str
    name: str
    client_reference_number: Optional[str]
    timezone: Optional[str]
    extra_a: Optional[Reference]
    extra_b: Optional[Reference]

    class Config:
        fields = {
            'client_reference_number': {'alias': 'clientReferenceNumber'},
            'timezone': {'alias': 'timeZone'},
            'extra_a': {'alias': 'extraA'},
            'extra_b': {'alias': 'extraB'},
        }

    def dict(self, *args, **kwargs):
        kwargs['include'] = {'id'}
        return super(BranchReference, self).dict(*args, **kwargs)

    def inclusive_dict(self, *args, **kwargs):
        return super(BranchReference, self).dict(*args, **kwargs)


class Operator(BaseModel):
    id: Optional[str]
    first_name: str
    last_name: str
    user_name: str
    phone: Optional[str]
    mobile: Optional[str]
    email: str
    branch: BranchReference
    # TODO: Remove the password field when proper auth is in place
    password: Optional[str]

    class Config:
        fields = {
            'first_name': {'alias': 'firstName'},
            'last_name': {'alias': 'surName'},
            'user_name': {'alias': 'loginName'},
            'phone': {'alias': 'telephone'},
            'mobile': {'alias': 'mobileNumber'},
        }

    def dict(self, *args, **kwargs):
        kwargs['exclude'] = {'id'}
        return super(Operator, self).dict(*args, **kwargs)

    def inclusive_dict(self, *args, **kwargs):
        return super(Operator, self).dict(*args, **kwargs)


class OperatorGroup(BaseModel):
    id: str
    groupName: str
    # TODO: add the other 40 fields if needed

    class Config:
        fields = {
            'name': {'alias': 'groupName'},
        }


class PermissionGroup(BaseModel):
    id: str
    name: str


class ExternalLink(BaseModel):
    id: str
    type: str
    date: str = datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%SZ')


class Department(BaseModel):
    id: Optional[str]
    name: str
    externalLinks: List[ExternalLink] = []

    def dict(self, *args, **kwargs):
        kwargs['exclude'] = {'id'}
        return super().dict(*args, **kwargs)


class DepartmentRef(BaseModel):
    id: str
    name: str

    def dict(self, *args, **kwargs):
        kwargs['include'] = {'id'}
        return super().dict(*args, **kwargs)


class BudgetHolder(BaseModel):
    id: Optional[str]
    name: str
    externalLink: List[ExternalLink] = []

    def dict(self, *args, **kwargs):
        kwargs['exclude'] = {'id'}
        return super().dict(*args, **kwargs)


class BudgetHolderRef(BaseModel):
    id: str
    name: str

    def dict(self, *args, **kwargs):
        kwargs['include'] = {'id'}
        return super().dict(*args, **kwargs)

class ExtraA(BaseModel):
    id: Optional[str]
    name: str
    externalLink: List[ExternalLink] = []


    def dict(self, *args, **kwargs):
        kwargs['exclude'] = {'id'}
        return super().dict(*args, **kwargs)


class ExtraARef(BaseModel):
    id: str
    name: Optional[str]

    def dict(self, *args, **kwargs):
        kwargs['include'] = {'id'}
        return super().dict(*args, **kwargs)


class Person(BaseModel):
    id: Optional[str]
    first_name: str
    last_name: str
    user_name: str
    networkLoginName: str
    phone: Optional[str]
    mobile: Optional[str]
    email: str
    employee_number: Optional[str]
    branch: BranchReference
    # TODO: Remove the password field when proper auth is in place
    password: Optional[str]

    department: Optional[DepartmentRef]
    budgetHolder: Optional[BudgetHolderRef]
    jobTitle: Optional[str]
    personExtraFieldA: Optional[ExtraARef]

    class Config:
        fields = {
            'first_name': 'firstName',
            'last_name': 'surName',
            'user_name': 'tasLoginName',
            'employee_number': 'employeeNumber',
            'phone': 'phoneNumber',
            'mobile': 'mobileNumber'
        }

    def dict(self, *args, **kwargs):
        kwargs['exclude'] = {'id'}
        return super(Person, self).dict(*args, **kwargs)

    def inclusive_dict(self, *args, **kwargs):
        return super(Person, self).dict(*args, **kwargs)