brynq-sdk-nmbrs 2.3.1.dev0__tar.gz → 2.3.3.dev0__tar.gz

{brynq_sdk_nmbrs-2.3.1.dev0 → brynq_sdk_nmbrs-2.3.3.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brynq_sdk_nmbrs
-Version: 2.3.1.dev0
+Version: 2.3.3.dev0
 Summary: Nmbrs wrapper from BrynQ
 Author: BrynQ
 Author-email: support@brynq.com

{brynq_sdk_nmbrs-2.3.1.dev0 → brynq_sdk_nmbrs-2.3.3.dev0}/brynq_sdk_nmbrs/__init__.py

@@ -21,17 +21,18 @@ from .costunit import Costunit
 from .days import FixedDays, VariableDays
 from .debtors import Debtors
 from .department import Departments, EmployeeDepartment
-from .document import Payslip
+from .document import EmployeeDocument, Payslip
 from .employee_wage_tax_settings import EmployeeWageTaxSettings
 from .employees import Employees
 from .employment import Employment
 from .function import EmployeeFunction, Functions
 from .hours import FixedHours, VariableHours
+from .leave import Leave, LeaveBalance, LeaveGroup
 from .manager import EmployeeManager, Manager
 from .salaries import Salaries
 from .salary_tables import SalaryScales, SalarySteps, SalaryTables
 from .schedules import Schedule
-from .wage_tax import WageTax
+from .wage_tax import WageTax, WageTaxSettings
 from .wagecomponents import EmployeeFixedWageComponents, EmployeeVariableWageComponents
 
 
@@ -43,21 +44,42 @@ class Nmbrs(BrynQ):
         Args:
             label: The label of the system in BrynQ. legacy
             debug: Whether to print debug information
-11            mock_mode: If true, data will NOT be sent to Nmbrs but only be tested for validity against Pydantic schemas
+            mock_mode: If true, data will NOT be sent to Nmbrs but only be tested for validity against Pydantic schemas
         """
         self.mock_mode = mock_mode
         self.debug = debug
         self.timeout = 3600
         self.system_type = system_type
+
+        # Initialize classes that work in both mock and real mode
+        self.address = Address(self)
+        self.bank = Bank(self)
+        self.children = Children(self)
+        self.contract = Contract(self)
+        self.leave = Leave(self)
+        self.leave_group = LeaveGroup(self)
+        self.function = EmployeeFunction(self)
+        self.functions = Functions(self)
+        self.employee_document = EmployeeDocument(self)
+        self.departments = Departments(self)
+        self.debtor = Debtors(self)
+        self.companies = Companies(self)
+
         if mock_mode is False:
+            # Initialize BrynQ parent class for REST API credentials
             super().__init__()
             self.data_interface_id = os.getenv("DATA_INTERFACE_ID")
+
+            # Get credentials once and store
+            self._credentials = self.interfaces.credentials.get(system='nmbrs', system_type=self.system_type)
+            self._custom_config = self._credentials.get("custom_data", {})
+
             headers = self._get_request_headers()
             self.base_url = "https://api.nmbrsapp.com/api/"
             self.session = requests.Session()
             self.session.headers.update(headers)
 
-            # Initialize SOAP client
+            # Initialize SOAP clients
             self.soap_settings = Settings(
                 strict=False,
                 xml_huge_tree=True,
@@ -71,11 +93,24 @@ class Nmbrs(BrynQ):
                 'https://api.nmbrs.nl/soap/v3/EmployeeService.asmx?wsdl',
                 settings=self.soap_settings
             )
-            self.soap_auth_header = self._get_soap_auth_header_companies()
-            self.soap_auth_header_employees = self._get_soap_auth_header_employees()
-            # Following methods can only be used if the SOAP authentication header is set (optional, this is not always in scope for all integrations)
+            self.soap_client_debtors = Client(
+                'https://api.nmbrs.nl/soap/v3/DebtorService.asmx?wsdl',
+                settings=self.soap_settings
+            )
+            # Create auth headers for each service (namespace must match)
+            self.soap_auth_header = self._create_soap_auth_header(self.soap_client_companies)
+            self.soap_auth_header_employees = self._create_soap_auth_header(self.soap_client_employees)
+            self.soap_auth_header_debtors = self._create_soap_auth_header(self.soap_client_debtors)
+
+            # REST API dependent classes
+            self.employee_department = EmployeeDepartment(self)
+
+            debtors, _ = self.debtor.get()
+            self.debtor_ids = debtors['debtor_id'].to_list()
+            self.company_ids = self.companies.get()['companyId'].to_list()
+
+            # SOAP dependent on REST - companies must be defined first
             if self.soap_auth_header is not None:
-                self.companies = Companies(self)
                 self.employees = Employees(self)
                 self.soap_company_ids = self.companies.get_soap_ids()
                 self.soap_employee_ids = self.employees.get_soap_ids()
@@ -84,96 +119,67 @@ class Nmbrs(BrynQ):
                 self.salary_steps = SalarySteps(self)
                 self.wage_tax = WageTax(self)
                 self.absence = Absence(self)
-                self.children = Children(self)
-
-        self.address = Address(self)
-        self.bank = Bank(self)
-        self.children = Children(self)
-        self.debtor = Debtors(self)
-        self.companies = Companies(self)
-        self.contract = Contract(self)
-        self.employee_department = EmployeeDepartment(self)
-        self.department = Departments(self)
-        debtors, _ = self.debtor.get()
-        self.debtor_ids = debtors['debtor_id'].to_list()
-        self.company_ids = self.companies.get()['companyId'].to_list()
-        self.employees = Employees(self)
-        self.employment = Employment(self)
-        self.employee_function = EmployeeFunction(self)
-        self.functions = Functions(self)
-        self.fixed_hours = FixedHours(self)
-        self.fixed_days = FixedDays(self)
-        self.variable_hours = VariableHours(self)
-        self.variable_days = VariableDays(self)
-        self.manager = Manager(self)
-        self.employee_manager = EmployeeManager(self)
-        self.salaries = Salaries(self)
-        self.schedule = Schedule(self)
-        self.cost_center = Costcenter(self)
-        self.employee_cost_center = EmployeeCostcenter(self)
-        self.cost_unit = Costunit(self)
-        self.employee_wage_tax_settings = EmployeeWageTaxSettings(self)
-        self.fixed_wagecomponents = EmployeeFixedWageComponents(self)
-        self.variable_wagecomponents = EmployeeVariableWageComponents(self)
-        self.current_period = self.companies.get_current_period()
 
+            self.employees = Employees(self)
+            self.employment = Employment(self)
+            self.wage_tax_settings = WageTaxSettings(self)
+            self.fixed_hours = FixedHours(self)
+            self.fixed_days = FixedDays(self)
+            self.variable_hours = VariableHours(self)
+            self.variable_days = VariableDays(self)
+            self.manager = Manager(self)
+            self.employee_manager = EmployeeManager(self)
+            self.salaries = Salaries(self)
+            self.schedule = Schedule(self)
+            self.fixed_wagecomponents = EmployeeFixedWageComponents(self)
+            self.variable_wagecomponents = EmployeeVariableWageComponents(self)
+            self.current_period = self.companies.get_current_period()
+            self.cost_center = Costcenter(self)
+            self.employee_cost_center = EmployeeCostcenter(self)
+            self.cost_unit = Costunit(self)
+            self.employee_wage_tax_settings = EmployeeWageTaxSettings(self)
     def _get_request_headers(self):
-        credentials = self.interfaces.credentials.get(system='nmbrs', system_type=self.system_type)
+        access_token = self._credentials.get('data').get('access_token')
+        subscription_key = self._custom_config.get("subscription_key")
         headers = {
             "accept": "application/json",
-            "Authorization": f"Bearer {credentials.get('data').get('access_token')}",
+            "Authorization": f"Bearer {access_token.strip() if access_token else ''}",
             # partner identifier
-            "X-Subscription-Key": credentials.get("custom_data").get("subscription_key")
+            "X-Subscription-Key": subscription_key.strip() if subscription_key else ''
         }
 
         return headers
 
-    def _get_soap_auth_header_companies(self):
+    def _create_soap_auth_header(self, soap_client):
         """
-        Creates the SOAP authentication header using credentials from initial_credentials.
-
-        Returns:
-            AuthHeaderWithDomainType: The authentication header for SOAP requests
-        """
-        initial_credentials = self.interfaces.credentials.get(system='nmbrs', system_type=self.system_type)
-        config = initial_credentials.get("custom_data", {})
-
-        if 'soap_api_token' not in config.keys():
-            return None
-        else:
-            # Get the AuthHeaderWithDomain type from the WSDL
-            AuthHeaderWithDomainType = self.soap_client_companies.get_element('ns0:AuthHeaderWithDomain')
-
-            # Create the auth header using credentials from config
-            auth_header = AuthHeaderWithDomainType(
-                Username=config.get("soap_api_username"),
-                Token=config.get("soap_api_token"),
-                Domain=config.get("soap_api_domain")
-            )
-
-            return auth_header
+        Creates SOAP authentication header for a specific SOAP client.
+        Each service needs its own auth header with matching namespace.
 
-    def _get_soap_auth_header_employees(self):
-        """
-        Creates the SOAP authentication header using credentials from initial_credentials.
+        Args:
+            soap_client: The zeep SOAP client to create auth header for
 
         Returns:
-            AuthHeaderWithDomainType: The authentication header for SOAP requests
+            AuthHeaderWithDomainType: The authentication header for SOAP requests,
+            or None if SOAP credentials are not configured.
         """
-        initial_credentials = self.interfaces.credentials.get(system='nmbrs', system_type=self.system_type)
-        custom_data = initial_credentials.get("custom_data", {})
+        if 'soap_api_token' not in self._custom_config.keys():
+            return None
 
-        # Get the AuthHeaderWithDomain type from the WSDL
-        AuthHeaderWithDomainType = self.soap_client_employees.get_element('ns0:AuthHeaderWithDomain')
+        AuthHeaderWithDomainType = soap_client.get_element('ns0:AuthHeaderWithDomain')
 
-        # Create the auth header using credentials from config
-        auth_header = AuthHeaderWithDomainType(
-            Username=custom_data.get("soap_api_username"),
-            Token=custom_data.get("soap_api_token"),
-            Domain=custom_data.get("soap_api_domain")
+        return AuthHeaderWithDomainType(
+            Username=self._custom_config.get("soap_api_username"),
+            Token=self._custom_config.get("soap_api_token"),
+            Domain=self._custom_config.get("soap_api_domain")
         )
 
-        return auth_header
+    def _get_soap_auth_header(self):
+        """Legacy method - use _create_soap_auth_header instead."""
+        return self._create_soap_auth_header(self.soap_client_companies)
+
+    def _get_soap_auth_header_employees(self):
+        """Legacy method - use soap_auth_header_employees instead."""
+        return self.soap_auth_header_employees
 
     def get_paginated_result(self, request: requests.Request) -> List:
         has_next_page = True

brynq_sdk_nmbrs-2.3.3.dev0/brynq_sdk_nmbrs/address.py

@@ -0,0 +1,146 @@
+import pandas as pd
+import requests
+from typing import Dict, Any, Union
+from .schemas.address import AddressCreate, AddressGet, AddressDelete, AddressUpdate, Period
+from brynq_sdk_functions import Functions
+
+
+class Address:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            created_from: str = None) -> pd.DataFrame:
+        addresses = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            addresses = pd.concat([addresses, self._get(company, created_from)])
+
+        valid_addresses, invalid_addresses = Functions.validate_data(df=addresses, schema=AddressGet, debug=True)
+
+        return valid_addresses, invalid_addresses
+
+    def _get(self,
+            company_id: str,
+            created_from: str = None) -> pd.DataFrame:
+        params = {} if created_from is None else {'createdFrom': created_from}
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}companies/{company_id}/employees/addresses",
+                                   params=params)
+
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.json_normalize(
+            data,
+            record_path='addresses',
+            meta=['employeeId']
+        )
+
+        return df
+
+    def create(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Create a new address for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing address data with fields matching
+                 the AddressCreate 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, AddressCreate)
+        address_model = AddressCreate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return address_model
+
+        # Convert validated model to dict for API payload
+        payload = address_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}/address",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def delete(self, employee_id: Union[int, str], address_id: Union[int, str]) -> bool:
+        """
+        Delete an address for an employee using SOAP API.
+        
+        REST API does not support address deletion, so we use SOAP as interim solution.
+
+        Args:
+            employee_id: The ID of the employee
+            address_id: The ID of the address to delete
+
+        Returns:
+            bool: True if deletion was successful
+            
+        Raises:
+            Exception: If SOAP client is not available or deletion fails
+        """
+        # Validate input using Pydantic schema
+        delete_model = AddressDelete(employeeId=int(employee_id), addressId=int(address_id))
+
+        if self.nmbrs.mock_mode:
+            return delete_model
+
+        # Call SOAP Address_Delete using EmployeeService auth header
+        resp = self.nmbrs.soap_client_employees.service.Address_Delete(
+            EmployeeId=delete_model.employee_id,
+            AddressID=delete_model.address_id,
+            _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_employees}
+        )
+        
+        return resp
+
+    def update(self, employee_id: Union[int, str], data: Dict[str, Any]):
+        """
+        Update an address for an employee using SOAP API.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing address data with fields matching AddressUpdate schema:
+                - id: Address ID to update
+                - street: Street name
+                - house_number: House number (optional)
+                - house_number_addition: House number addition (optional)
+                - postal_code: Postal code (optional)
+                - city: City name
+                - state_province: State or province (optional)
+                - country_iso_code: Country ISO code (e.g., "NL")
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        address_model = AddressUpdate(**data)
+
+        if self.nmbrs.mock_mode:
+            return address_model
+
+        # Create EmployeeAddress type
+        AddressType = self.nmbrs.soap_client_employees.get_type('ns0:EmployeeAddress')
+        soap_address = AddressType(
+            Id=address_model.id,
+            Default=address_model.default,
+            Street=address_model.street,
+            HouseNumber=address_model.house_number or '',
+            HouseNumberAddition=address_model.house_number_addition or '',
+            PostalCode=address_model.postal_code or '',
+            City=address_model.city,
+            StateProvince=address_model.state_province or '',
+            CountryISOCode=address_model.country_iso_code,
+            Type=address_model.address_type
+        )
+
+        # Call SOAP Address_Update
+        result = self.nmbrs.soap_client_employees.service.Address_Update(
+            EmployeeId=int(employee_id),
+            Address=soap_address,
+            _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_employees}
+        )
+        return result

{brynq_sdk_nmbrs-2.3.1.dev0 → brynq_sdk_nmbrs-2.3.3.dev0}/brynq_sdk_nmbrs/bank.py

@@ -1,9 +1,12 @@
 import math
+from typing import Any, Dict
+
 import pandas as pd
 import requests
+
 from brynq_sdk_functions import Functions
-from typing import Dict, Any
-from .schemas.bank import BankGet, BankCreate, BankUpdate, BankDelete
+
+from .schemas.bank import BankCreate, BankDelete, BankGet, BankUpdate
 
 
 class Bank:

brynq_sdk_nmbrs-2.3.3.dev0/brynq_sdk_nmbrs/children.py

@@ -0,0 +1,135 @@
+from typing import Union, Dict, Any
+
+import requests
+import pandas as pd
+
+from .schemas.children import ChildCreate, ChildDelete, ChildUpdate
+
+
+class Children:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            company_id: str,
+            created_from: str = None) -> pd.DataFrame:
+        params = {}
+        if created_from:
+            params['createdFrom'] = created_from
+        try:
+            request = requests.Request(method='GET',
+                                       url=f"{self.nmbrs.base_url}companies/{company_id}/employees/functions",
+                                       params=params)
+
+            data = self.nmbrs.get_paginated_result(request)
+            df = pd.json_normalize(
+                data,
+                record_path='functions',
+                meta=['employeeId']
+            )
+        except requests.HTTPError as e:
+            df = pd.DataFrame()
+
+        return df
+
+    def create(self, employee_id: Union[int, str], data: Dict[str, Any]):
+        """
+        Create a new child for an employee using SOAP API.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing child data with fields matching ChildCreate schema
+
+        Returns:
+            Response from the API (child ID)
+        """
+        # Validate with Pydantic model
+        child_model = ChildCreate(**data)
+
+        if self.nmbrs.mock_mode:
+            return child_model
+
+        ChildType = self.nmbrs.soap_client_employees.get_type('ns0:Child')
+        child = ChildType(
+            Id=0,  # Use 0 for new child
+            Name=child_model.name,
+            FirstName=child_model.first_name,
+            Initials=child_model.initials or '',
+            Gender=child_model.gender,
+            Birthday=child_model.birthday
+        )
+
+        # Make the API call
+        result = self.nmbrs.soap_client_employees.service.Children_Insert(
+            EmployeeId=int(employee_id),
+            child=child,
+            _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_employees}
+        )
+        return result
+
+    def delete(self, employee_id: Union[int, str], child_id: Union[int, str]):
+        """
+        Delete a child for an employee using SOAP API.
+
+        Args:
+            employee_id: The ID of the employee
+            child_id: The ID of the child to delete
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        delete_model = ChildDelete(employeeId=int(employee_id), childId=int(child_id))
+
+        if self.nmbrs.mock_mode:
+            return delete_model
+
+        # Call SOAP Child_Delete
+        resp = self.nmbrs.soap_client_employees.service.Child_Delete(
+            EmployeeId=delete_model.employee_id,
+            ChildId=delete_model.child_id,
+            _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_employees}
+        )
+        return resp
+
+    def update(self, employee_id: Union[int, str], data: Dict[str, Any]):
+        """
+        Update a child for an employee using SOAP API.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing child data with fields matching ChildUpdate schema:
+                - id: Child ID to update
+                - name: Last name
+                - first_name: First name
+                - initials: Initials (optional)
+                - gender: Gender (male/female/unknown/undefined)
+                - birthday: Birthday
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        child_model = ChildUpdate(**data)
+
+        if self.nmbrs.mock_mode:
+            return child_model
+
+        ChildType = self.nmbrs.soap_client_employees.get_type('ns0:Child')
+        child = ChildType(
+            Id=child_model.id,
+            Name=child_model.name,
+            FirstName=child_model.first_name,
+            Initials=child_model.initials or '',
+            Gender=child_model.gender,
+            Birthday=child_model.birthday
+        )
+
+        # Make the API call
+        result = self.nmbrs.soap_client_employees.service.Children_Update(
+            EmployeeId=int(employee_id),
+            child=child,
+            _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_employees}
+        )
+        return result
+

{brynq_sdk_nmbrs-2.3.1.dev0 → brynq_sdk_nmbrs-2.3.3.dev0}/brynq_sdk_nmbrs/companies.py

@@ -1,6 +1,7 @@
 import pandas as pd
 import requests
 import logging
+from typing import Dict, Any
 
 from .leave import LeaveGroup
 from .costcenter import Costcenter
@@ -8,6 +9,7 @@ from .costunit import Costunit
 from .hours import Hours
 from .bank import Bank
 from .function import Functions
+from .schemas.company import CompanyCreate
 from zeep.exceptions import Fault
 from zeep.helpers import serialize_object
 
@@ -19,10 +21,13 @@ class Companies:
         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)
 
+    @property
+    def soap_client_companies(self):
+        return self.nmbrs.soap_client_companies
+
     def get(self) -> pd.DataFrame:
         try:
             request = requests.Request(method='GET',
@@ -91,3 +96,42 @@ class Companies:
         except Exception as e:
             self.logger.exception("Exception occurred:")
             raise Exception(f"Failed to get current period: {str(e)}")
+
+    def create(self, data: Dict[str, Any]) -> int:
+        """
+        Create a new company using SOAP API.
+
+        Args:
+            data: Dictionary containing company data with fields matching CompanyCreate schema:
+                - debtor_id: Debtor ID
+                - company_name: Company name
+                - period_type: Period type (1=Monthly, 2=4-Weekly, 3=Weekly, 4=Quarterly)
+                - default_company_id: Default company ID to copy settings from (0 for none)
+                - labour_agreement_settings_group_guid: Labour agreement settings group GUID
+                - pay_in_advance: Pay in advance
+
+        Returns:
+            The ID of the newly created company.
+        """
+        company_model = CompanyCreate(**data)
+
+        if self.nmbrs.mock_mode:
+            return 12345  # Mock ID
+
+        try:
+            response = self.soap_client_companies.service.Company_Insert(
+                DebtorId=company_model.debtor_id,
+                CompanyName=company_model.company_name,
+                PeriodType=company_model.period_type,
+                DefaultCompanyId=company_model.default_company_id,
+                LabourAgreementSettingsGroupGuid=company_model.labour_agreement_settings_group_guid or "00000000-0000-0000-0000-000000000000",
+                PayInAdvance=company_model.pay_in_advance,
+                _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header}
+            )
+            return response
+
+        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 create company: {str(e)}")