brynq-sdk-nmbrs 2.1.0__tar.gz → 2.2.1__tar.gz

{brynq_sdk_nmbrs-2.1.0 → brynq_sdk_nmbrs-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: brynq_sdk_nmbrs
-Version: 2.1.0
+Version: 2.2.1
 Summary: Nmbrs wrapper from BrynQ
 Home-page: UNKNOWN
 Author: BrynQ

{brynq_sdk_nmbrs-2.1.0 → brynq_sdk_nmbrs-2.2.1}/brynq_sdk_nmbrs/__init__.py

@@ -1,9 +1,12 @@
 import warnings
-from typing import Union, List, Literal, Optional
+from typing import Union, List, Literal, Optional, get_args, get_origin
 import re
 import pandas as pd
+from pydantic import BaseModel
 import requests
 from brynq_sdk_brynq import BrynQ
+from .absence import Absence
+from .wage_tax import WageTax
 from .address import Address
 from .bank import Bank
 from zeep import Client, Settings
@@ -20,6 +23,7 @@ from .salary_tables import SalaryTables, SalaryScales, SalarySteps
 from .employment import Employment
 from .function import EmployeeFunction
 from .hours import VariableHours, FixedHours
+from .days import VariableDays, FixedDays
 from .manager import EmployeeManager, Manager
 from .salaries import Salaries
 from .schedules import Schedule
@@ -35,7 +39,7 @@ class Nmbrs(BrynQ):
         Args:
             label: The label of the system in BrynQ. legacy
             debug: Whether to print debug information
-            mock_mode: If true, data will NOT be send to Nmbrs but only be tested for validity against Pydantic schemas
+11            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
@@ -55,10 +59,14 @@ class Nmbrs(BrynQ):
                 xml_huge_tree=True,
                 force_https=True
             )
-            self.soap_client = Client(
+            self.soap_client_companies = Client(
                 'https://api.nmbrs.nl/soap/v3/CompanyService.asmx?wsdl',
                 settings=self.soap_settings
             )
+            self.soap_client_employees = Client(
+                'https://api.nmbrs.nl/soap/v3/EmployeeService.asmx?wsdl',
+                settings=self.soap_settings
+            )
 
         self.address = Address(self)
         self.bank = Bank(self)
@@ -67,13 +75,17 @@ class Nmbrs(BrynQ):
         self.companies = Companies(self)
         self.contract = Contract(self)
         self.department = EmployeeDepartment(self)
-        self.company_ids = self.companies.get()['companyId']
+        debtors, _ = self.debtor.get()
+        self.debtor_ids = debtors['debtor_id'].to_list()
+        self.company_ids = self.companies.get()['companyId'].to_list()
         self.soap_company_ids = self.companies.get_soap_ids()
         self.employees = Employees(self)
         self.employment = Employment(self)
         self.function = EmployeeFunction(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)
@@ -84,6 +96,9 @@ class Nmbrs(BrynQ):
         self.salary_tables = SalaryTables(self)
         self.salary_scales = SalaryScales(self)
         self.salary_steps = SalarySteps(self)
+        self.wage_tax = WageTax(self)
+        self.absence = Absence(self)
+        self.current_period = self.companies.get_current_period()
 
     def _get_request_headers(self):
         credentials = self.interfaces.credentials.get(system='nmbrs', system_type=self.system_type)
@@ -99,6 +114,7 @@ class Nmbrs(BrynQ):
     def _get_soap_auth_header(self):
         """
         Creates the SOAP authentication header using credentials from initial_credentials.
+
         Returns:
             AuthHeaderWithDomainType: The authentication header for SOAP requests
         """
@@ -106,7 +122,7 @@ class Nmbrs(BrynQ):
         config = initial_credentials.get("config", {})
 
         # Get the AuthHeaderWithDomain type from the WSDL
-        AuthHeaderWithDomainType = self.soap_client.get_element('ns0:AuthHeaderWithDomain')
+        AuthHeaderWithDomainType = self.soap_client_companies.get_element('ns0:AuthHeaderWithDomain')
 
         # Create the auth header using credentials from config
         auth_header = AuthHeaderWithDomainType(
@@ -160,3 +176,23 @@ class Nmbrs(BrynQ):
         df.columns = map(camel_to_snake_case, df.columns)
 
         return df
+
+    def flat_dict_to_nested_dict(self, flat_dict: dict, model: BaseModel) -> dict:
+        nested = {}
+        for name, field in model.model_fields.items():
+            key_in_input = name  # Original model field name as key in flat_dict
+            alias = field.alias or name
+            if isinstance(field.annotation, type) and issubclass(field.annotation, BaseModel):
+                nested[alias] = self.flat_dict_to_nested_dict(flat_dict, field.annotation)
+            elif any(isinstance(item, type) and issubclass(item, BaseModel) for item in get_args(field.annotation)):
+                # get the basemodel class from the list
+                nested_model_name = [item for item in get_args(field.annotation) if isinstance(item, type) and issubclass(item, BaseModel)][0]
+                origin = get_origin(field.annotation)
+                if origin in (list, List):
+                    nested[alias] = [self.flat_dict_to_nested_dict(flat_dict, nested_model_name)]
+                else:
+                    nested[alias] = self.flat_dict_to_nested_dict(flat_dict, nested_model_name)
+            else:
+                if key_in_input in flat_dict:
+                    nested[alias] = flat_dict[key_in_input]
+        return nested

brynq_sdk_nmbrs-2.2.1/brynq_sdk_nmbrs/absence.py

@@ -0,0 +1,131 @@
+from typing import Any, Dict, List, Union, Tuple
+import pandas as pd
+from .schemas.absence import AbsenceCreate, AbsenceGet
+from zeep.exceptions import Fault
+from zeep.ns import WSDL, SOAP_ENV_11
+from zeep.xsd import ComplexType, Element, String
+from zeep.helpers import serialize_object
+# import logging
+from brynq_sdk_functions import Functions
+
+
+class Absence:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+        self.soap_client_companies = nmbrs.soap_client_companies
+        self.soap_client_employees = nmbrs.soap_client_employees
+
+    def get(self, employee_id: int = None) -> Tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        Get salary tables for all companies for a specific period and year.
+
+        Args:
+            period (int): The period number
+            year (int): The year
+
+        Returns:
+            pd.DataFrame: DataFrame containing the salary tables
+        """
+        absences = pd.DataFrame()
+        for company in self.nmbrs.soap_company_ids.to_dict(orient='records'):
+            absences_temp = self._get(company['i_d'], employee_id=employee_id)
+            if not absences_temp.empty:
+                absences_temp['companyId'] = company['number']
+                absences = pd.concat([absences, absences_temp])
+
+        valid_absences, invalid_absences = Functions.validate_data(df=absences, schema=AbsenceGet, debug=True)
+
+        # No validation schema for now, but could be added later
+        return valid_absences, invalid_absences
+
+    def _get(self, company_id: int, employee_id: int = None) -> pd.DataFrame:
+        """
+        Get salary tables for a specific company, period and year.
+
+        Args:
+            company_id (int): The ID of the company
+            period (int): The period number
+            year (int): The year
+
+        Returns:
+            pd.DataFrame: DataFrame containing the salary tables
+        """
+        try:
+
+            # Get the auth header using the centralized method
+            auth_header = self.nmbrs._get_soap_auth_header()
+
+            if employee_id is None:
+                response = self.soap_client_employees.service.Absence_GetAll_AllEmployeesByCompany(
+                    CompanyId=company_id,
+                    _soapheaders=[auth_header]
+                )
+            else:
+                # Make SOAP request with the proper header structure
+                response = self.soap_client_employees.service.Absence_GetList(
+                    EmployeeId=employee_id,
+                    _soapheaders=[auth_header]
+                )
+
+            # Convert response to DataFrame
+            if response:
+                # Convert Zeep objects to Python dictionaries
+                serialized_response = serialize_object(response)
+
+                # Convert to list if it's not already
+                if not isinstance(serialized_response, list):
+                    serialized_response = [serialized_response]
+
+                # Convert to DataFrame
+                df = pd.DataFrame(serialized_response)
+
+                return df
+            else:
+                return pd.DataFrame()
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Failed to get salary tables: {str(e)}")
+
+    def create(self, data: Dict[str, Any]) -> pd.DataFrame:
+        try:
+            absence_model = AbsenceCreate(**data)
+
+            if self.nmbrs.mock_mode:
+                return absence_model
+
+            # Get the auth header using the centralized method
+            auth_header = self.nmbrs._get_soap_auth_header()
+
+            # Use the model's built-in SOAP conversion method
+            absence_settings = absence_model.to_soap_settings(self.nmbrs.soap_client_employees)
+
+            # Make SOAP request with clean, simple call
+            response = self.nmbrs.soap_client_employees.service.Absence_Create(
+                EmployeeId=absence_model.employee_id,
+                Dossier=absence_model.new_dossier,
+                Absence=absence_settings,
+                _soapheaders=[auth_header]
+            )
+
+            # Convert response to DataFrame
+            if response:
+                # Convert Zeep objects to Python dictionaries
+                serialized_response = serialize_object(response)
+
+                # Convert to list if it's not already
+                if not isinstance(serialized_response, list):
+                    serialized_response = [serialized_response]
+
+                # Convert to DataFrame
+                df = pd.DataFrame(serialized_response)
+
+                return df
+            else:
+                return pd.DataFrame()
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Failed to update WageTax: {str(e)}")

{brynq_sdk_nmbrs-2.1.0 → brynq_sdk_nmbrs-2.2.1}/brynq_sdk_nmbrs/address.py

@@ -48,13 +48,14 @@ class Address:
             Response from the API
         """
         # Validate with Pydantic model - this will raise an error if required fields are missing
-        address_model = AddressCreate(**data)
+        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.dict(exclude_none=True)
+        payload = address_model.model_dump(exclude_none=True, by_alias=True)
 
         # Send request
         resp = self.nmbrs.session.post(
@@ -63,4 +64,3 @@ class Address:
             timeout=self.nmbrs.timeout
         )
         return resp
-

{brynq_sdk_nmbrs-2.1.0 → brynq_sdk_nmbrs-2.2.1}/brynq_sdk_nmbrs/bank.py

@@ -54,13 +54,14 @@ class Bank:
             Response from the API
         """
         # Validate with Pydantic model - this will raise an error if required fields are missing
-        bank_model = BankCreate(**data)
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, BankCreate)
+        bank_model = BankCreate(**nested_data)
 
         if self.nmbrs.mock_mode:
             return bank_model
 
         # Convert validated model to dict for API payload
-        payload = bank_model.dict(exclude_none=True)
+        payload = bank_model.model_dump(exclude_none=True, by_alias=True)
 
         # Send request
         resp = self.nmbrs.session.post(
@@ -82,13 +83,14 @@ class Bank:
             Response from the API
         """
         # Validate with Pydantic model - this will raise an error if required fields are missing
-        bank_model = BankUpdate(**data)
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, BankUpdate)
+        bank_model = BankUpdate(**nested_data)
 
         if self.nmbrs.mock_mode:
             return bank_model
 
         # Convert validated model to dict for API payload
-        payload = bank_model.dict(exclude_none=True)
+        payload = bank_model.model_dump(exclude_none=True, by_alias=True)
 
         # Send request
         resp = self.nmbrs.session.put(

{brynq_sdk_nmbrs-2.1.0 → brynq_sdk_nmbrs-2.2.1}/brynq_sdk_nmbrs/companies.py

@@ -1,6 +1,8 @@
 import pandas as pd
 import requests
 import logging
+
+from .leave import LeaveGroup
 from .costcenter import Costcenter
 from .costunit import Costunit
 from .hours import Hours
@@ -17,22 +19,34 @@ class Companies:
         self.costunits = Costunit(nmbrs)
         self.hours = Hours(nmbrs)
         self.banks = Bank(nmbrs)
-        self.soap_client = nmbrs.soap_client
+        self.soap_client_companies = nmbrs.soap_client_companies
         self.logger = logging.getLogger(__name__)
+        self.leave_groups = LeaveGroup(nmbrs)
 
     def get(self) -> pd.DataFrame:
-        request = requests.Request(method='GET',
-                                   url=f"{self.nmbrs.base_url}companies")
-        data = self.nmbrs.get_paginated_result(request)
-        df = pd.DataFrame(data)
-        # TODO: add validation for rename
+        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
         """
@@ -41,10 +55,10 @@ class Companies:
             auth_header = self.nmbrs._get_soap_auth_header()
 
             # Make SOAP request with the proper header structure
-            response = self.soap_client.service.List_GetAll(
+            response = self.soap_client_companies.service.List_GetAll(
                 _soapheaders=[auth_header]
             )
-            
+
             # Convert response to DataFrame
             if response:
                 # Convert Zeep objects to Python dictionaries
@@ -64,3 +78,19 @@ class Companies:
         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-2.1.0 → brynq_sdk_nmbrs-2.2.1}/brynq_sdk_nmbrs/contract.py

@@ -58,18 +58,20 @@ class Contract:
             Response from the API
         """
         # Validate with Pydantic model - this will raise an error if required fields are missing
-        contract_model = ContractCreate(**data)
+        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.dict(exclude_none=True)
+        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",
-            json=payload,
+            data=payload,
+            headers={"Content-Type": "application/json"},
             timeout=self.nmbrs.timeout
         )
         return resp
@@ -87,18 +89,20 @@ class Contract:
             Response from the API
         """
         # Validate with Pydantic model - this will raise an error if required fields are missing
-        contract_model = ContractUpdate(**data)
+        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.dict(exclude_none=True)
+        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",
-            json=payload,
+            data=payload,
+            headers={"Content-Type": "application/json"},
             timeout=self.nmbrs.timeout
         )
         return resp

{brynq_sdk_nmbrs-2.1.0 → brynq_sdk_nmbrs-2.2.1}/brynq_sdk_nmbrs/costcenter.py

@@ -2,17 +2,19 @@ import pandas as pd
 import requests
 from dateutil.utils import today
 from requests import HTTPError
-from typing import Dict, Any
+from typing import Dict, Any, TYPE_CHECKING
 
 from brynq_sdk_functions import Functions
 from .schemas.costcenter import CostcenterGet, EmployeeCostcenterGet
-from .schemas.costcenter import EmployeeCostcenterCreate, EmployeeCostcenterUpdate, EmployeeCostcenterDelete
+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
+        self.nmbrs: Nmbrs = nmbrs
 
     def get(self,
             created_from: str = None,
@@ -46,35 +48,6 @@ class EmployeeCostcenter:
 
         return df
 
-    def create(self, employee_id: str, data: Dict[str, Any]):
-        """
-        Create a new costcenter for an employee using Pydantic validation.
-
-        Args:
-            employee_id: The ID of the employee
-            data: Dictionary containing costcenter data with fields matching
-                 the EmployeeCostcenterCreate schema (using camelCase field names)
-
-        Returns:
-            Response from the API
-        """
-        # Validate with Pydantic model - this will raise an error if required fields are missing
-        costcenter_model = EmployeeCostcenterCreate(**data)
-
-        if self.nmbrs.mock_mode:
-            return costcenter_model
-
-        # Convert validated model to dict for API payload
-        payload = costcenter_model.dict(exclude_none=True)
-
-        # Send request
-        resp = self.nmbrs.session.post(
-            url=f"{self.nmbrs.base_url}employees/{employee_id}/costcenter",
-            json=payload,
-            timeout=self.nmbrs.timeout
-        )
-        return resp
-
     def update(self, employee_id: str, data: Dict[str, Any]):
         """
         Update a costcenter for an employee using Pydantic validation.
@@ -87,18 +60,22 @@ class EmployeeCostcenter:
         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
-        costcenter_model = EmployeeCostcenterUpdate(**data)
+        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.dict(exclude_none=True)
+        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}/costcenter",
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/employeecostcenter",
             json=payload,
             timeout=self.nmbrs.timeout
         )
@@ -141,13 +118,14 @@ class Costcenter:
             Response from the API
         """
         # Validate with Pydantic model - this will raise an error if required fields are missing
-        costcenter_model = CostcenterCreate(**data)
+        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.dict(exclude_none=True)
+        payload = costcenter_model.model_dump(exclude_none=True, by_alias=True)
 
         # Send request
         resp = self.nmbrs.session.post(
@@ -170,13 +148,14 @@ class Costcenter:
             Response from the API
         """
         # Validate with Pydantic model - this will raise an error if required fields are missing
-        costcenter_model = CostcenterUpdate(**data)
+        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.dict(exclude_none=True)
+        payload = costcenter_model.model_dump(exclude_none=True, by_alias=True)
 
         # Send request
         resp = self.nmbrs.session.put(

{brynq_sdk_nmbrs-2.1.0 → brynq_sdk_nmbrs-2.2.1}/brynq_sdk_nmbrs/costunit.py

@@ -42,13 +42,14 @@ class Costunit:
             Response from the API
         """
         # Validate with Pydantic model - this will raise an error if required fields are missing
-        costunit_model = CostunitCreate(**data)
+        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.dict(exclude_none=True)
+        payload = costunit_model.model_dump(exclude_none=True, by_alias=True)
 
         # Send request
         resp = self.nmbrs.session.post(
@@ -71,13 +72,14 @@ class Costunit:
             Response from the API
         """
         # Validate with Pydantic model - this will raise an error if required fields are missing
-        costunit_model = CostunitUpdate(**data)
+        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.dict(exclude_none=True)
+        payload = costunit_model.model_dump(exclude_none=True, by_alias=True)
 
         # Send request
         resp = self.nmbrs.session.put(