brynq-sdk-nmbrs 2.3.1.dev0__py3-none-any.whl → 2.3.3.dev0__py3-none-any.whl

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,14 +1,17 @@
-import math
 from typing import Any, Dict
 
 import pandas as pd
 import requests
+from zeep.exceptions import Fault
 
 from brynq_sdk_functions import Functions
 
 from .schemas.department import (
     DepartmentCreate,
     DepartmentGet,
+    DepartmentMasterCreate,
+    DepartmentMasterDelete,
+    DepartmentMasterUpdate,
     EmployeeDepartmentGet,
     EmployeeDepartmentUpdate,
     Period,
@@ -115,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
 
@@ -129,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

@@ -28,9 +28,7 @@ class EmployeeWageTaxSettings:
         """
         wage_tax_settings = pd.DataFrame()
         for company in self.nmbrs.company_ids:
-            company_settings = self._get(company, employee_id)
-            if not company_settings.empty:
-                wage_tax_settings = pd.concat([wage_tax_settings, company_settings])
+            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
@@ -62,17 +60,26 @@ class EmployeeWageTaxSettings:
         )
 
         data = self.nmbrs.get_paginated_result(request)
-
-        if not data:
-            return pd.DataFrame()
-
-        # Normalize nested structure similar to departments/employments
         df = pd.json_normalize(
             data,
-            record_path='wagetaxsettings',
+            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]):

brynq_sdk_nmbrs/function.py

@@ -2,8 +2,13 @@ import pandas as pd
 import requests
 from brynq_sdk_functions import Functions as BrynQFunctions
 import math
-from typing import Dict, Any
-from .schemas.function import EmployeeFunctionGet, FunctionUpdate, FunctionGet
+from typing import Dict, Any, Union
+from .schemas.function import (
+    EmployeeFunctionGet, FunctionUpdate, FunctionGet,
+    FunctionCreate, FunctionDelete, FunctionMasterUpdate
+)
+from zeep.exceptions import Fault
+from zeep.helpers import serialize_object
 
 
 class EmployeeFunction:
@@ -68,9 +73,44 @@ class EmployeeFunction:
         )
         return resp
 
+    def get_current(self, employee_id: Union[int, str]) -> pd.DataFrame:
+        """
+        Get current function for a specific employee using SOAP API.
+
+        Args:
+            employee_id: The ID of the employee
+
+        Returns:
+            DataFrame with current function
+        """
+        if self.nmbrs.mock_mode:
+            return pd.DataFrame()
+
+        try:
+            response = self.nmbrs.soap_client_employees.service.Function_GetCurrent(
+                EmployeeId=int(employee_id),
+                _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_employees}
+            )
+
+            if response:
+                serialized = serialize_object(response)
+                if not isinstance(serialized, list):
+                    serialized = [serialized]
+                df = pd.DataFrame(serialized)
+                df['employee_id'] = str(employee_id)
+                return df
+            else:
+                return pd.DataFrame()
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
 
 
 class Functions:
+    """
+    Master Functions (Debtor level) - manages function definitions.
+    Uses DebtorService SOAP API for create, update, delete.
+    """
     def __init__(self, nmbrs):
         self.nmbrs = nmbrs
 
@@ -87,3 +127,89 @@ class Functions:
             df = pd.DataFrame()
 
         return valid_functions, invalid_functions
+
+    def create(self, debtor_id: Union[int, str], data: Dict[str, Any]):
+        """
+        Create a new master function using SOAP API.
+
+        Args:
+            debtor_id: The ID of the debtor
+            data: Dictionary containing function data with fields matching FunctionCreate schema
+
+        Returns:
+            Response from the API (function ID)
+        """
+        function_model = FunctionCreate(**data)
+
+        if self.nmbrs.mock_mode:
+            return function_model
+
+        try:
+            response = self.nmbrs.soap_client_debtors.service.Function_Insert(
+                DebtorId=int(debtor_id),
+                function={
+                    'Id': 0,  # 0 for new function
+                    'Code': function_model.code,
+                    'Description': function_model.description
+                },
+                _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_debtors}
+            )
+            return response
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+
+    def delete(self, debtor_id: Union[int, str], function_id: Union[int, str]):
+        """
+        Delete a master function using SOAP API.
+
+        Args:
+            debtor_id: The ID of the debtor
+            function_id: The ID of the function to delete
+
+        Returns:
+            Response from the API
+        """
+        delete_model = FunctionDelete(function_id=int(function_id))
+
+        if self.nmbrs.mock_mode:
+            return delete_model
+
+        try:
+            response = self.nmbrs.soap_client_debtors.service.Function_Delete(
+                DebtorId=int(debtor_id),
+                id=delete_model.function_id,
+                _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_debtors}
+            )
+            return response
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+
+    def update(self, debtor_id: Union[int, str], data: Dict[str, Any]):
+        """
+        Update a master function using SOAP API.
+
+        Args:
+            debtor_id: The ID of the debtor
+            data: Dictionary containing function data with fields matching FunctionMasterUpdate schema
+
+        Returns:
+            Response from the API
+        """
+        function_model = FunctionMasterUpdate(**data)
+
+        if self.nmbrs.mock_mode:
+            return function_model
+
+        try:
+            response = self.nmbrs.soap_client_debtors.service.Function_Update(
+                DebtorId=int(debtor_id),
+                function={
+                    'Id': function_model.function_id,
+                    'Code': function_model.code,
+                    'Description': function_model.description
+                },
+                _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_debtors}
+            )
+            return response
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")

brynq_sdk_nmbrs/leave.py

@@ -2,8 +2,9 @@ import math
 import pandas as pd
 import requests
 from brynq_sdk_functions import Functions
-from typing import Dict, Any
-from .schemas.leave import LeaveBalanceGet, LeaveGet, LeaveCreate
+from typing import Dict, Any, Union
+from .schemas.leave import LeaveBalanceGet, LeaveGet, LeaveCreate, LeaveDelete, LeaveUpdate
+from zeep.exceptions import Fault
 
 
 class Leave:
@@ -95,6 +96,42 @@ class Leave:
         )
         return resp
 
+    def update(self, data: Dict[str, Any]):
+        """
+        Update a leave request for an employee using SOAP API.
+        (REST API does not support leave update)
+
+        Args:
+            data: Dictionary containing leave data with fields matching LeaveUpdate schema:
+                - employee_id: Employee ID
+                - leave_id: Leave ID
+                - start_date: Start date
+                - end_date: End date
+                - description: Optional description
+
+        Returns:
+            Response from the API
+        """
+        leave_model = LeaveUpdate(**data)
+
+        if self.nmbrs.mock_mode:
+            return leave_model
+
+        try:
+            resp = self.nmbrs.soap_client_employees.service.Leave_Update(
+                EmployeeId=leave_model.employee_id,
+                Leave={
+                    'Id': leave_model.leave_id,
+                    'Start': leave_model.start_date,
+                    'End': leave_model.end_date,
+                    'Description': leave_model.description or ''
+                },
+                _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header_employees}
+            )
+            return resp
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+
 
 class LeaveBalance:
     def __init__(self, nmbrs):
@@ -111,7 +148,12 @@ class LeaveBalance:
         return valid_leave, invalid_leave
 
     def _get(self,
-            company_id: str) -> pd.DataFrame:
+            company_id: str,
+            changed_from: str = None) -> pd.DataFrame:
+        """
+        Note: changed_from parameter is accepted for consistency but not used
+        by the leaveBalances endpoint.
+        """
         try:
             request = requests.Request(method='GET',
                                        url=f"{self.nmbrs.base_url}companies/{company_id}/employees/leaveBalances")
@@ -129,11 +171,66 @@ class LeaveBalance:
 
 
 class LeaveGroup:
+    """
+    LeaveGroup (Leave Type Groups) - uses SOAP CompanyLeaveTypeGroups_Get
+    """
     def __init__(self, nmbrs):
         self.nmbrs = nmbrs
 
-    def get(self,
-            changed_from: str = None) -> tuple[pd.DataFrame, pd.DataFrame]:
-        leave = pd.DataFrame()
-        for company in self.nmbrs.company_ids:
-            leave = pd.concat([leave, self._get(company, changed_from)])
+    def get(self, company_id: Union[int, str] = None) -> pd.DataFrame:
+        """
+        Get leave type groups using SOAP API.
+        
+        Args:
+            company_id: Optional. If provided, get groups for this company only.
+                       If not provided, get groups for all companies.
+        
+        Returns:
+            DataFrame with leave type groups
+        """
+        if self.nmbrs.mock_mode:
+            return pd.DataFrame()
+
+        from zeep.helpers import serialize_object
+        
+        all_groups = []
+        try:
+            # If company_id provided, only get for that company
+            if company_id is not None:
+                company_ids = [int(company_id)]
+            else:
+                # Get all company IDs from SOAP
+                companies_response = self.nmbrs.soap_client_companies.service.List_GetAll(
+                    _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header}
+                )
+                
+                # Handle response - could be list or object with Company attribute
+                companies = []
+                if companies_response:
+                    if hasattr(companies_response, 'Company'):
+                        companies = companies_response.Company or []
+                    elif isinstance(companies_response, list):
+                        companies = companies_response
+                
+                company_ids = [c.ID for c in companies]
+            
+            for cid in company_ids:
+                try:
+                    response = self.nmbrs.soap_client_companies.service.CompanyLeaveTypeGroups_Get(
+                        CompanyId=cid,
+                        _soapheaders={'AuthHeaderWithDomain': self.nmbrs.soap_auth_header}
+                    )
+                    if response and response.LeaveTypeGroup:
+                        groups = serialize_object(response.LeaveTypeGroup)
+                        if not isinstance(groups, list):
+                            groups = [groups]
+                        for group in groups:
+                            group['company_id'] = str(cid)
+                        all_groups.extend(groups)
+                except Exception:
+                    continue
+            
+            return pd.DataFrame(all_groups)
+        
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")