brynq-sdk-nmbrs 2.3.1__py3-none-any.whl → 2.3.2.dev0__py3-none-any.whl

brynq_sdk_nmbrs/costcenter.py

@@ -1,13 +1,20 @@
+from typing import TYPE_CHECKING, Any, Dict
+
 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
+
+from .schemas.costcenter import (
+    CostcenterCreate,
+    CostcenterGet,
+    CostCentersResponse,
+    CostcenterUpdate,
+    EmployeeCostcenterGet,
+    EmployeeCostCentersResponse,
+    EmployeeCostcenterUpdate,
+)
+
 if TYPE_CHECKING:
     from brynq_sdk_nmbrs import Nmbrs
 
@@ -40,12 +47,40 @@ class EmployeeCostcenter:
                                    url=f"{self.nmbrs.base_url}companies/{company_id}/employees/costcenters",
                                    params=params)
         data = self.nmbrs.get_paginated_result(request)
+
+        # Parse and validate API response using Pydantic models
+        if not data:
+            return pd.DataFrame()
+
+        # Validate response structure with Pydantic
+        response = EmployeeCostCentersResponse(data=data)
+
+        # Serialize models to dicts using model_dump with by_alias=True
+        serialized_data = [item.model_dump(by_alias=True, mode='json') for item in response.data]
+
+        # Use json_normalize to flatten nested structure efficiently
         df = pd.json_normalize(
-            data,
+            serialized_data,
             record_path='employeeCostCenters',
             meta=['employeeId']
         )
 
+        # Flatten nested costUnits object if it exists
+        if 'costUnits' in df.columns:
+            # Check if costUnits contains dict-like objects
+            cost_units_dicts = df['costUnits'].dropna()
+            if not cost_units_dicts.empty and isinstance(cost_units_dicts.iloc[0], dict):
+                cost_units_expanded = pd.json_normalize(cost_units_dicts)
+                cost_units_expanded.columns = [f'costUnits.{col}' for col in cost_units_expanded.columns]
+                # Reindex to match original DataFrame index and fill missing values with None
+                cost_units_expanded = cost_units_expanded.reindex(df.index)
+                df = pd.concat([df.drop(columns=['costUnits']), cost_units_expanded], axis=1)
+            else:
+                # If costUnits is not dict-like or all None, create columns with None
+                for col in ['costUnits.costUnitId', 'costUnits.code', 'costUnits.description']:
+                    df[col] = None
+                df = df.drop(columns=['costUnits'])
+
         return df
 
     def update(self, employee_id: str, data: Dict[str, Any]):
@@ -101,7 +136,17 @@ class Costcenter:
         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)
+
+        # Parse and validate API response using Pydantic models
+        if not data:
+            return pd.DataFrame()
+
+        # Validate response structure with Pydantic
+        response = CostCentersResponse(data=data)
+
+        # Serialize models to dicts and convert to DataFrame efficiently
+        serialized_data = [item.model_dump(by_alias=True, mode='json') for item in response.data]
+        df = pd.DataFrame(serialized_data)
 
         return df
 

brynq_sdk_nmbrs/costunit.py

@@ -1,9 +1,16 @@
+from typing import Any, Dict
+
 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
+
+from .schemas.costunit import (
+    CostunitCreate,
+    CostunitDelete,
+    CostunitGet,
+    CostunitUpdate,
+)
 
 
 class Costunit:
@@ -13,7 +20,9 @@ class Costunit:
     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)])
+            company_costunits = self._get(company)
+            if not company_costunits.empty:
+                costunits = pd.concat([costunits, company_costunits])
 
         valid_costunits, invalid_costunits = Functions.validate_data(df=costunits, schema=CostunitGet, debug=True)
 
@@ -22,9 +31,12 @@ class Costunit:
     def _get(self,
             company_id: str):
         request = requests.Request(method='GET',
-                                   url=f"{self.nmbrs.base_url}companies/{company_id}/costunits")
+                                   url=f"{self.nmbrs.base_url}companies/{company_id}/costUnits")
 
         data = self.nmbrs.get_paginated_result(request)
+        if not data:
+            return pd.DataFrame()
+
         df = pd.DataFrame(data)
 
         return df

brynq_sdk_nmbrs/debtors.py

@@ -1,9 +1,11 @@
 import pandas as pd
 import requests
+from typing import Dict, Any
+from zeep.exceptions import Fault
 from brynq_sdk_functions import Functions
 from .department import Departments
 from .function import Functions as NmbrsFunctions
-from .schemas.debtor import DebtorsGet
+from .schemas.debtor import DebtorsGet, DebtorCreate, DebtorUpdate
 
 
 class Debtors:
@@ -12,7 +14,6 @@ class Debtors:
         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")
@@ -23,3 +24,76 @@ class Debtors:
         valid_debtors, invalid_debtors = Functions.validate_data(df=df, schema=DebtorsGet, debug=True)
 
         return valid_debtors, invalid_debtors
+
+    def create(self, data: Dict[str, Any]) -> int:
+        """
+        Create a new debtor using SOAP API.
+
+        Args:
+            data: Dictionary containing debtor data with fields matching DebtorCreate schema:
+                - number: Debtor number
+                - name: Debtor name
+
+        Returns:
+            The ID of the newly created debtor.
+        """
+        debtor_model = DebtorCreate(**data)
+
+        if self.nmbrs.mock_mode:
+            return 12345  # Mock ID
+
+        try:
+            DebtorType = self.nmbrs.soap_client_debtors.get_type('ns0:Debtor')
+            soap_debtor = DebtorType(
+                Id=0,  # 0 for new debtor
+                Number=debtor_model.number,
+                Name=debtor_model.name
+            )
+
+            response = self.nmbrs.soap_client_debtors.service.Debtor_Insert(
+                Debtor=soap_debtor,
+                _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_debtors}
+            )
+            return response
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Failed to create Debtor: {str(e)}")
+
+    def update(self, data: Dict[str, Any]):
+        """
+        Update a debtor using SOAP API.
+
+        Args:
+            data: Dictionary containing debtor data with fields matching DebtorUpdate schema:
+                - debtor_id: Debtor ID to update
+                - number: Debtor number
+                - name: Debtor name
+
+        Returns:
+            Response from the API
+        """
+        debtor_model = DebtorUpdate(**data)
+
+        if self.nmbrs.mock_mode:
+            return debtor_model
+
+        try:
+            DebtorType = self.nmbrs.soap_client_debtors.get_type('ns0:Debtor')
+            soap_debtor = DebtorType(
+                Id=debtor_model.debtor_id,
+                Number=debtor_model.number,
+                Name=debtor_model.name
+            )
+
+            response = self.nmbrs.soap_client_debtors.service.Debtor_Update(
+                Debtor=soap_debtor,
+                _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_debtors}
+            )
+            return response
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Failed to update Debtor: {str(e)}")

brynq_sdk_nmbrs/department.py

@@ -1,10 +1,22 @@
-import math
+from typing import Any, Dict
+
 import pandas as pd
 import requests
-from typing import Dict, Any
-from .schemas.department import DepartmentCreate, EmployeeDepartmentUpdate, Period, EmployeeDepartmentGet, DepartmentGet
+from zeep.exceptions import Fault
+
 from brynq_sdk_functions import Functions
 
+from .schemas.department import (
+    DepartmentCreate,
+    DepartmentGet,
+    DepartmentMasterCreate,
+    DepartmentMasterDelete,
+    DepartmentMasterUpdate,
+    EmployeeDepartmentGet,
+    EmployeeDepartmentUpdate,
+    Period,
+)
+
 
 class EmployeeDepartment:
     def __init__(self, nmbrs):
@@ -43,35 +55,35 @@ class EmployeeDepartment:
 
         return df
 
-    def create(self, employee_id: str, data: Dict[str, Any]):
-        """
-        Create a new department for an employee using Pydantic validation.
+    # def create(self, employee_id: str, data: Dict[str, Any]):
+    #     """
+    #     Create a new department for an employee using Pydantic validation.
 
-        Args:
-            employee_id: The ID of the employee
-            data: Dictionary containing department data with fields matching
-                 the DepartmentCreate schema (using camelCase field names)
+    #     Args:
+    #         employee_id: The ID of the employee
+    #         data: Dictionary containing department data with fields matching
+    #              the DepartmentCreate schema (using camelCase field names)
 
-        Returns:
-            Response from the API
-        """
-        # Validate with Pydantic model
-        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, DepartmentCreate)
-        department_model = DepartmentCreate(**nested_data)
+    #     Returns:
+    #         Response from the API
+    #     """
+    #     # Validate with Pydantic model
+    #     nested_data = self.nmbrs.flat_dict_to_nested_dict(data, DepartmentCreate)
+    #     department_model = DepartmentCreate(**nested_data)
 
-        if self.nmbrs.mock_mode:
-            return department_model
+    #     if self.nmbrs.mock_mode:
+    #         return department_model
 
-        # Convert validated model to dict for API payload
-        payload = department_model.model_dump(exclude_none=True, by_alias=True)
+    #     # Convert validated model to dict for API payload
+    #     payload = department_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}/department",
-            json=payload,
-            timeout=self.nmbrs.timeout
-        )
-        return resp
+    #     # Send request
+    #     resp = self.nmbrs.session.post(
+    #         url=f"{self.nmbrs.base_url}employees/{employee_id}/department",
+    #         json=payload,
+    #         timeout=self.nmbrs.timeout
+    #     )
+    #     return resp
 
     def update(self, employee_id: str, data: Dict[str, Any]):
         """
@@ -93,7 +105,7 @@ class EmployeeDepartment:
             return department_model
 
         # Convert validated model to dict for API payload
-        payload = department_model.model_dump(exclude_none=True, by_alias=True)
+        payload = department_model.model_dump(exclude_none=True, by_alias=True, mode='json')
 
         # Send request
         resp = self.nmbrs.session.put(
@@ -106,6 +118,8 @@ class EmployeeDepartment:
 
 
 class Departments:
+    """Master department operations (Debtor level) - uses SOAP for create/update/delete."""
+    
     def __init__(self, nmbrs):
         self.nmbrs = nmbrs
 
@@ -120,3 +134,110 @@ class Departments:
         valid_departments, invalid_departments = Functions.validate_data(df=df, schema=DepartmentGet, debug=True)
 
         return valid_departments, invalid_departments
+
+    def create(self, data: Dict[str, Any]) -> int:
+        """
+        Create a new master department for a debtor using SOAP API.
+
+        Args:
+            data: Dictionary containing department data with fields matching DepartmentMasterCreate schema:
+                - debtor_id: Debtor ID
+                - code: Department code
+                - description: Department description
+
+        Returns:
+            The ID of the newly created department.
+        """
+        dept_model = DepartmentMasterCreate(**data)
+
+        if self.nmbrs.mock_mode:
+            return 12345  # Mock ID
+
+        try:
+            DepartmentType = self.nmbrs.soap_client_debtors.get_type('ns0:Department')
+            soap_department = DepartmentType(
+                Id=0,  # 0 for new department
+                Code=dept_model.code,
+                Description=dept_model.description
+            )
+
+            response = self.nmbrs.soap_client_debtors.service.Department_Insert(
+                DebtorId=dept_model.debtor_id,
+                department=soap_department,
+                _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_debtors}
+            )
+            return response
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Failed to create Department: {str(e)}")
+
+    def update(self, data: Dict[str, Any]):
+        """
+        Update a master department for a debtor using SOAP API.
+
+        Args:
+            data: Dictionary containing department data with fields matching DepartmentMasterUpdate schema:
+                - debtor_id: Debtor ID
+                - department_id: Department ID to update
+                - code: Department code
+                - description: Department description
+
+        Returns:
+            Response from the API
+        """
+        dept_model = DepartmentMasterUpdate(**data)
+
+        if self.nmbrs.mock_mode:
+            return dept_model
+
+        try:
+            DepartmentType = self.nmbrs.soap_client_debtors.get_type('ns0:Department')
+            soap_department = DepartmentType(
+                Id=dept_model.department_id,
+                Code=dept_model.code,
+                Description=dept_model.description
+            )
+
+            response = self.nmbrs.soap_client_debtors.service.Department_Update(
+                DebtorId=dept_model.debtor_id,
+                department=soap_department,
+                _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_debtors}
+            )
+            return response
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Failed to update Department: {str(e)}")
+
+    def delete(self, data: Dict[str, Any]):
+        """
+        Delete a master department for a debtor using SOAP API.
+
+        Args:
+            data: Dictionary containing department data with fields matching DepartmentMasterDelete schema:
+                - debtor_id: Debtor ID
+                - department_id: Department ID to delete
+
+        Returns:
+            Response from the API
+        """
+        dept_model = DepartmentMasterDelete(**data)
+
+        if self.nmbrs.mock_mode:
+            return True
+
+        try:
+            response = self.nmbrs.soap_client_debtors.service.Department_Delete(
+                DebtorId=dept_model.debtor_id,
+                id=dept_model.department_id,
+                _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_debtors}
+            )
+            return response
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Failed to delete Department: {str(e)}")

brynq_sdk_nmbrs/document.py

@@ -1,7 +1,57 @@
 from io import BytesIO
+import base64
+from typing import Dict, Any, Union
 
 import pandas as pd
 import requests
+from zeep.exceptions import Fault
+
+from .schemas.document import DocumentUpload
+
+
+class EmployeeDocument:
+    """Handle employee document operations via SOAP API."""
+    
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def upload(self, data: Dict[str, Any], file_content: bytes) -> bool:
+        """
+        Upload a document to an employee using SOAP API.
+
+        Args:
+            data: Dictionary containing document data with fields matching DocumentUpload schema:
+                - employee_id: Employee ID
+                - document_name: Document name (with extension, e.g., "contract.pdf")
+                - document_type_guid: Document type GUID
+            file_content: Binary content of the file to upload
+
+        Returns:
+            True if upload was successful
+        """
+        doc_model = DocumentUpload(**data)
+
+        if self.nmbrs.mock_mode:
+            return True
+
+        try:
+            # Convert file content to base64
+            body_base64 = base64.b64encode(file_content)
+
+            response = self.nmbrs.soap_client_employees.service.EmployeeDocument_UploadDocument(
+                EmployeeId=doc_model.employee_id,
+                StrDocumentName=doc_model.document_name,
+                Body=body_base64,
+                GuidDocumentType=doc_model.document_type_guid,
+                _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_employees}
+            )
+
+            return response
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Failed to upload document: {str(e)}")
 
 
 class Payslip:

brynq_sdk_nmbrs/employee_wage_tax_settings.py

@@ -0,0 +1,113 @@
+from typing import Any, Dict
+
+import pandas as pd
+import requests
+
+from brynq_sdk_functions import Functions
+
+from .schemas.wage_tax_settings import (
+    EmployeeWageTaxSettingsCreate,
+    EmployeeWageTaxSettingsGet,
+)
+
+
+class EmployeeWageTaxSettings:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            employee_id: str = None) -> tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        Get wage tax settings history for employees in companies.
+
+        Args:
+            employee_id: Optional filter for a specific employee ID
+
+        Returns:
+            Tuple of (valid_data, invalid_data) DataFrames
+        """
+        wage_tax_settings = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            wage_tax_settings = pd.concat([wage_tax_settings, self._get(company, employee_id)])
+
+        valid_settings, invalid_settings = Functions.validate_data(
+            df=wage_tax_settings, schema=EmployeeWageTaxSettingsGet, debug=True
+        )
+
+        return valid_settings, invalid_settings
+
+    def _get(self,
+             company_id: str,
+             employee_id: str = None) -> pd.DataFrame:
+        """
+        Get wage tax settings history for a specific company.
+
+        Args:
+            company_id: The ID of the company
+            employee_id: Optional filter for a specific employee ID
+
+        Returns:
+            DataFrame with wage tax settings
+        """
+        params = {}
+        if employee_id:
+            params['employeeId'] = employee_id
+
+        request = requests.Request(
+            method='GET',
+            url=f"{self.nmbrs.base_url}companies/{company_id}/employees/wagetaxsettings",
+            params=params
+        )
+
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.json_normalize(
+            data,
+            record_path='wageTaxSettings',
+            meta=['employeeId']
+        )
+
+        # Flatten nested Calc30PercentRuling object if it exists
+        if 'Calc30PercentRuling' in df.columns:
+            calc_ruling_dicts = df['Calc30PercentRuling'].dropna()
+            if not calc_ruling_dicts.empty and isinstance(calc_ruling_dicts.iloc[0], dict):
+                calc_ruling_expanded = pd.json_normalize(calc_ruling_dicts)
+                calc_ruling_expanded.columns = [f'Calc30PercentRuling.{col}' for col in calc_ruling_expanded.columns]
+                calc_ruling_expanded = calc_ruling_expanded.reindex(df.index)
+                df = pd.concat([df.drop(columns=['Calc30PercentRuling']), calc_ruling_expanded], axis=1)
+            else:
+                # If Calc30PercentRuling is not dict-like or all None, create columns with None
+                for col in ['Calc30PercentRuling.Cal30PercentRuling', 'Calc30PercentRuling.endPeriod', 'Calc30PercentRuling.endYear']:
+                    df[col] = None
+                df = df.drop(columns=['Calc30PercentRuling'])
+
+        return df
+
+    def create(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Create wage tax settings for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing wage tax settings data with fields matching
+                 the EmployeeWageTaxSettingsCreate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, EmployeeWageTaxSettingsCreate)
+        settings_model = EmployeeWageTaxSettingsCreate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return settings_model
+
+        # Convert validated model to dict for API payload
+        payload = settings_model.model_dump(exclude_none=True, by_alias=True, mode='json')
+
+        # Send request
+        resp = self.nmbrs.session.post(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/wagetaxsettings",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp