brynq-sdk-nmbrs 2.3.1__py3-none-any.whl

brynq_sdk_nmbrs/companies.py

@@ -0,0 +1,93 @@
+import pandas as pd
+import requests
+import logging
+
+from .leave import LeaveGroup
+from .costcenter import Costcenter
+from .costunit import Costunit
+from .hours import Hours
+from .bank import Bank
+from .function import Functions
+from zeep.exceptions import Fault
+from zeep.helpers import serialize_object
+
+
+class Companies:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+        self.costcenters = Costcenter(nmbrs)
+        self.costunits = Costunit(nmbrs)
+        self.hours = Hours(nmbrs)
+        self.banks = Bank(nmbrs)
+        self.soap_client_companies = nmbrs.soap_client_companies
+        self.logger = logging.getLogger(__name__)
+        self.leave_groups = LeaveGroup(nmbrs)
+
+    def get(self) -> pd.DataFrame:
+        try:
+            request = requests.Request(method='GET',
+                                    url=f"{self.nmbrs.base_url}companies")
+            data = self.nmbrs.get_paginated_result(request)
+            df = pd.DataFrame(data)
+        except requests.HTTPError as e:
+            if e.response.status_code == 403 and e.response.json().get("title") == "ForbiddenMultiDebtor.":
+                df = pd.DataFrame()
+                for debtor_id in self.nmbrs.debtor_ids:
+                    request = requests.Request(method='GET',
+                                        url=f"{self.nmbrs.base_url}debtors/{debtor_id}/companies")
+                    data = self.nmbrs.get_paginated_result(request)
+                    df = pd.concat([df, pd.DataFrame(data)])
+            else:
+                raise e
+        # TODO: add validation
+
+        return df
+
+    def get_soap_ids(self) -> pd.DataFrame:
+        """
+        Get all companies using the SOAP API.
+
+        Returns:
+            pd.DataFrame: DataFrame containing all companies
+        """
+        try:
+            # Make SOAP request with the proper header structure
+            response = self.soap_client_companies.service.List_GetAll(
+                _soapheaders=[self.nmbrs.soap_auth_header]
+            )
+
+            # Convert response to DataFrame
+            if response:
+                # Convert Zeep objects to Python dictionaries
+                serialized_response = serialize_object(response)
+
+                # TODO: add validation here
+                # Convert to DataFrame
+                df = pd.DataFrame(serialized_response)
+                df = self.nmbrs._rename_camel_columns_to_snake_case(df)
+
+                return df
+            else:
+                return pd.DataFrame()
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+        except Exception as e:
+            self.logger.exception("Exception occurred:")
+            raise Exception(f"Failed to get companies: {str(e)}")
+
+    def get_current_period(self) -> int:
+        try:
+            df = pd.DataFrame()
+            for company_id in self.nmbrs.company_ids:
+                request = requests.Request(method='GET',
+                                    url=f"{self.nmbrs.base_url}companies/{company_id}/period")
+                data = self.nmbrs.get_paginated_result(request)
+                df_temp = pd.json_normalize(data)
+                df_temp['company_id'] = company_id
+                df = pd.concat([df, df_temp])
+
+            return df
+        except Exception as e:
+            self.logger.exception("Exception occurred:")
+            raise Exception(f"Failed to get current period: {str(e)}")

brynq_sdk_nmbrs/contract.py

@@ -0,0 +1,132 @@
+import math
+import pandas as pd
+import requests
+from typing import Dict, Any
+from .schemas.contracts import ContractGet, ContractCreate, ContractUpdate, ContractDelete
+from brynq_sdk_functions import Functions
+
+
+class Contract:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            created_from: str = None,
+            employee_id: str = None) -> (pd.DataFrame, pd.DataFrame):
+        contracts = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            contracts = pd.concat([contracts, self._get(company, created_from, employee_id)])
+
+        valid_contracts, invalid_contracts = Functions.validate_data(df=contracts, schema=ContractGet, debug=True)
+
+        return valid_contracts, invalid_contracts
+
+    def _get(self,
+            company_id: str,
+            created_from: str = None,
+            employee_id: str = None) -> pd.DataFrame:
+        params = {}
+        if created_from:
+            params['createdFrom'] = created_from
+        if employee_id:
+            params['employeeId'] = employee_id
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}companies/{company_id}/employees/contracts",
+                                   params=params)
+
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.json_normalize(
+            data,
+            record_path='contracts',
+            meta=['employeeId']
+        )
+
+        df['company_id'] = company_id
+
+        return df
+
+    def create(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Create a new contract for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing contract data with fields matching
+                 the ContractCreate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model - this will raise an error if required fields are missing
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, ContractCreate)
+        contract_model = ContractCreate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return contract_model
+
+        # Convert validated model to dict for API payload
+        payload = contract_model.model_dump_json(exclude_none=True, by_alias=True)
+
+        # Send request
+        resp = self.nmbrs.session.post(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/contract",
+            data=payload,
+            headers={"Content-Type": "application/json"},
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def update(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Update a contract for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing contract data with fields matching
+                 the ContractUpdate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model - this will raise an error if required fields are missing
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, ContractUpdate)
+        contract_model = ContractUpdate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return contract_model
+
+        # Convert validated model to dict for API payload
+        payload = contract_model.model_dump_json(exclude_none=True, by_alias=True)
+
+        # Send request
+        resp = self.nmbrs.session.put(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/contract",
+            data=payload,
+            headers={"Content-Type": "application/json"},
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def delete(self, employee_id: str, contract_id: str):
+        """
+        Delete a contract for an employee.
+
+        Args:
+            employee_id: The ID of the employee
+            contract_id: The ID of the contract to delete
+
+        Returns:
+            Response from the API
+        """
+        # Create and validate a ContractDelete model
+        contract_model = ContractDelete(contractId=contract_id)
+
+        if self.nmbrs.mock_mode:
+            return contract_model
+
+        # Send request
+        resp = self.nmbrs.session.delete(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/contracts/{contract_id}",
+            timeout=self.nmbrs.timeout
+        )
+        return resp

brynq_sdk_nmbrs/costcenter.py

@@ -0,0 +1,166 @@
+import pandas as pd
+import requests
+from dateutil.utils import today
+from requests import HTTPError
+from typing import Dict, Any, TYPE_CHECKING
+
+from brynq_sdk_functions import Functions
+from .schemas.costcenter import CostcenterGet, EmployeeCostcenterGet
+from .schemas.costcenter import EmployeeCostcenterUpdate, EmployeeCostcenterDelete
+from .schemas.costcenter import CostcenterCreate, CostcenterUpdate, CostcenterDelete
+if TYPE_CHECKING:
+    from brynq_sdk_nmbrs import Nmbrs
+
+
+class EmployeeCostcenter:
+    def __init__(self, nmbrs):
+        self.nmbrs: Nmbrs = nmbrs
+
+    def get(self,
+            created_from: str = None,
+            employee_id: str = None) -> tuple[pd.DataFrame, pd.DataFrame]:
+        costcenters = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            costcenters = pd.concat([costcenters, self._get(company, created_from, employee_id)])
+
+        valid_costcenters, invalid_costcenters = Functions.validate_data(df=costcenters, schema=EmployeeCostcenterGet, debug=True)
+
+        return valid_costcenters, invalid_costcenters
+
+    def _get(self,
+            company_id: str,
+            created_from: str = None,
+            employee_id: str = None) -> pd.DataFrame:
+        params = {}
+        if created_from:
+            params['createdFrom'] = created_from
+        if employee_id:
+            params['employeeId'] = employee_id
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}companies/{company_id}/employees/costcenters",
+                                   params=params)
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.json_normalize(
+            data,
+            record_path='employeeCostCenters',
+            meta=['employeeId']
+        )
+
+        return df
+
+    def update(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Update a costcenter for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing costcenter data with fields matching
+                 the EmployeeCostcenterUpdate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # this is the Nmbrs GUID that is returned after creating an employee, for some reason also included in body here.
+        data['employee_id'] = employee_id
+        data['default'] = True
+        # Validate with Pydantic model - this will raise an error if required fields are missing
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, EmployeeCostcenterUpdate)
+        costcenter_model = EmployeeCostcenterUpdate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return costcenter_model
+
+        # Convert validated model to dict for API payload
+        payload = costcenter_model.model_dump(exclude_none=True, by_alias=True)
+
+        # Send request
+        resp = self.nmbrs.session.put(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/employeecostcenter",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+
+
+class Costcenter:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self) -> tuple[pd.DataFrame, pd.DataFrame]:
+        costcenters = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            costcenters = pd.concat([costcenters, self._get(company)])
+
+        valid_costcenters, invalid_costcenters = Functions.validate_data(df=costcenters, schema=CostcenterGet, debug=True)
+
+        return valid_costcenters, invalid_costcenters
+
+    def _get(self,
+            company_id: str):
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}companies/{company_id}/costcenters")
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.DataFrame(data)
+
+        return df
+
+    def create(self, company_id: str, data: Dict[str, Any]):
+        """
+        Create a new costcenter using Pydantic validation.
+
+        Args:
+            company_id: The ID of the company
+            data: Dictionary containing costcenter data with fields matching
+                 the CostcenterCreate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model - this will raise an error if required fields are missing
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, CostcenterCreate)
+        costcenter_model = CostcenterCreate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return costcenter_model
+
+        # Convert validated model to dict for API payload
+        payload = costcenter_model.model_dump(exclude_none=True, by_alias=True)
+
+        # Send request
+        resp = self.nmbrs.session.post(
+            url=f"{self.nmbrs.base_url}companies/{company_id}/costcenter",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def update(self, company_id: str, data: Dict[str, Any]):
+        """
+        Update a costcenter using Pydantic validation.
+
+        Args:
+            company_id: The ID of the company
+            data: Dictionary containing costcenter data with fields matching
+                 the CostcenterUpdate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model - this will raise an error if required fields are missing
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, CostcenterUpdate)
+        costcenter_model = CostcenterUpdate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return costcenter_model
+
+        # Convert validated model to dict for API payload
+        payload = costcenter_model.model_dump(exclude_none=True, by_alias=True)
+
+        # Send request
+        resp = self.nmbrs.session.put(
+            url=f"{self.nmbrs.base_url}companies/{company_id}/costcenter",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp

brynq_sdk_nmbrs/costunit.py

@@ -0,0 +1,90 @@
+import pandas as pd
+import requests
+from typing import Dict, Any
+
+from brynq_sdk_functions import Functions
+from .schemas.costunit import CostunitGet, CostunitCreate, CostunitUpdate, CostunitDelete
+
+
+class Costunit:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self) -> tuple[pd.DataFrame, pd.DataFrame]:
+        costunits = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            costunits = pd.concat([costunits, self._get(company)])
+
+        valid_costunits, invalid_costunits = Functions.validate_data(df=costunits, schema=CostunitGet, debug=True)
+
+        return valid_costunits, invalid_costunits
+
+    def _get(self,
+            company_id: str):
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}companies/{company_id}/costunits")
+
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.DataFrame(data)
+
+        return df
+
+    def create(self, company_id: str, data: Dict[str, Any]):
+        """
+        Create a new costunit using Pydantic validation.
+
+        Args:
+            company_id: The ID of the company
+            data: Dictionary containing costunit data with fields matching
+                 the CostunitCreate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model - this will raise an error if required fields are missing
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, CostunitCreate)
+        costunit_model = CostunitCreate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return costunit_model
+
+        # Convert validated model to dict for API payload
+        payload = costunit_model.model_dump(exclude_none=True, by_alias=True)
+
+        # Send request
+        resp = self.nmbrs.session.post(
+            url=f"{self.nmbrs.base_url}companies/{company_id}/costunit",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def update(self, company_id: str, data: Dict[str, Any]):
+        """
+        Update a costunit using Pydantic validation.
+
+        Args:
+            company_id: The ID of the company
+            data: Dictionary containing costunit data with fields matching
+                 the CostunitUpdate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model - this will raise an error if required fields are missing
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, CostunitUpdate)
+        costunit_model = CostunitUpdate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return costunit_model
+
+        # Convert validated model to dict for API payload
+        payload = costunit_model.model_dump(exclude_none=True, by_alias=True)
+
+        # Send request
+        resp = self.nmbrs.session.put(
+            url=f"{self.nmbrs.base_url}companies/{company_id}/costunit",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp

brynq_sdk_nmbrs/days.py

@@ -0,0 +1,137 @@
+import pandas as pd
+import requests
+from typing import Dict, Any
+from .schemas.days import (
+    VariableDaysGet, VariableDaysCreate, FixedDaysCreate, FixedDaysGet
+)
+from brynq_sdk_functions import Functions
+
+
+class VariableDays:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            employee_id: str,
+            created_from: str = None,
+            period: int = None,
+            year: int = None) -> tuple[pd.DataFrame, pd.DataFrame]:
+        params = {}
+        if created_from:
+            params['createdFrom'] = created_from
+        if period:
+            params['period'] = period
+        if year:
+            params['year'] = year
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}employees/{employee_id}/variabledays",
+                                   params=params)
+
+        data = self.nmbrs.get_paginated_result(request)
+
+        df = pd.DataFrame(data)
+
+        df['employeeId'] = employee_id  # Add employee_id for tracking
+        df['period'] = period
+        df['year'] = year
+        # Validate data using the schema
+        valid_days, invalid_days = Functions.validate_data(df=df, schema=VariableDaysGet, debug=True)
+
+        return valid_days, invalid_days
+
+    def create(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Create variable hours for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing hours data with fields matching
+                 the VariableHoursCreate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, VariableDaysCreate)
+        hours_model = VariableDaysCreate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return hours_model
+
+        # Convert validated model to dict for API payload
+        payload = hours_model.model_dump(exclude_none=True, by_alias=True)
+
+        # Send request
+        resp = self.nmbrs.session.post(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/variabledays",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+
+class FixedDays:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            company_id: str,
+            created_from: str = None,
+            employee_id: str = None,
+            period: int = None,
+            year: int = None) -> tuple[pd.DataFrame, pd.DataFrame]:
+        params = {}
+        if created_from:
+            params['createdFrom'] = created_from
+        if employee_id:
+            params['employeeId'] = employee_id
+        if period:
+            params['period'] = period
+        if year:
+            params['year'] = year
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}employees/{employee_id}/fixeddays",
+                                   params=params)
+
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.DataFrame(data)
+        df['employeeId'] = employee_id  # Add employee_id for tracking
+        df['period'] = period
+        df['year'] = year
+
+        # Validate data using the schema
+        valid_days, invalid_days = Functions.validate_data(df=df, schema=VariableDaysGet, debug=True)
+
+        return valid_days, invalid_days
+
+        return df
+
+    def create(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Create fixed hours for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing hours data with fields matching
+                 the FixedHoursCreate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, FixedDaysCreate)
+        hours_model = FixedDaysCreate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return hours_model
+
+        # Convert validated model to dict for API payload
+        payload = hours_model.model_dump(exclude_none=True, by_alias=True)
+
+        # Send request
+        resp = self.nmbrs.session.post(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/fixeddays",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp

brynq_sdk_nmbrs/debtors.py

@@ -0,0 +1,25 @@
+import pandas as pd
+import requests
+from brynq_sdk_functions import Functions
+from .department import Departments
+from .function import Functions as NmbrsFunctions
+from .schemas.debtor import DebtorsGet
+
+
+class Debtors:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+        self.departments = Departments(nmbrs)
+        self.functions = NmbrsFunctions(nmbrs)
+
+
+    def get(self) -> (pd.DataFrame, pd.DataFrame):
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}debtors")
+        data = self.nmbrs.get_paginated_result(request)
+
+        df = pd.DataFrame(data)
+
+        valid_debtors, invalid_debtors = Functions.validate_data(df=df, schema=DebtorsGet, debug=True)
+
+        return valid_debtors, invalid_debtors