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

brynq_sdk_nmbrs/employees.py

@@ -1,36 +1,50 @@
+import logging
+from typing import Any, Dict, Optional
+
 import pandas as pd
 import requests
 from pydantic import BaseModel
+from zeep.exceptions import Fault
+from zeep.helpers import serialize_object
 
 from brynq_sdk_functions import Functions
-from typing import Dict, Any, Optional
-
-from .wage_tax import WageTax
 
-from .document import Payslip
 from .address import Address
+from .bank import Bank
 from .contract import Contract
 from .costcenter import EmployeeCostcenter
+from .days import VariableDays
 from .department import EmployeeDepartment
+from .document import Payslip
 from .employment import Employment
 from .function import EmployeeFunction
-from .hours import VariableHours, FixedHours
-from .schedules import Schedule
-from .salaries import Salaries
-from .bank import Bank
-from .days import VariableDays
-from .wagecomponents import EmployeeVariableWageComponents, EmployeeFixedWageComponents
+from .hours import FixedHours, VariableHours
 from .leave import Leave, LeaveBalance
+from .salaries import Salaries
+from .schedules import Schedule
 from .schemas.employees import (
-    BsnGet, EmployeeGet, EmployeeCreate, EmployeeUpdate, EmployeeDelete,
-    BasicInfo, BirthInfo, ContactInfo, PartnerInfo, Period, AdditionalEmployeeInfo,
-    CreateEmployeePersonalInfo
+    AdditionalEmployeeInfo,
+    BasicInfo,
+    BirthInfo,
+    BsnGet,
+    ContactInfo,
+    CreateEmployeePersonalInfo,
+    DefaultEmployeeTemplates,
+    EmployeeCreate,
+    EmployeeDelete,
+    EmployeeGet,
+    EmployeeUpdate,
+    PartnerInfo,
+    Period,
 )
+from .wage_tax import WageTax
+from .wagecomponents import EmployeeFixedWageComponents, EmployeeVariableWageComponents
 
 
 class Employees:
     def __init__(self, nmbrs):
         self.nmbrs = nmbrs
+        self.logger = logging.getLogger(__name__)
         self.address = Address(nmbrs)
         self.functions = EmployeeFunction(nmbrs)
         self.contract = Contract(nmbrs)
@@ -55,7 +69,9 @@ class Employees:
             ) -> (pd.DataFrame, pd.DataFrame):
         employees = pd.DataFrame()
         for company in self.nmbrs.company_ids:
-            employees = pd.concat([employees, self._get(company, employee_type)])
+            company_employees = self._get(company, employee_type)
+            if not company_employees.empty:
+                employees = pd.concat([employees, company_employees])
 
         valid_employees, invalid_employees = Functions.validate_data(df=employees, schema=EmployeeGet, debug=True)
 
@@ -70,18 +86,23 @@ class Employees:
                                    params=params)
 
         data = self.nmbrs.get_paginated_result(request)
+        if not data:
+            return pd.DataFrame()
+
         df = pd.json_normalize(
             data,
             record_path='info',
             meta=['employeeId']
         )
-        df['companyId'] = company_id
+        if df.empty:
+            return df
 
-        df['createdAt'] = pd.to_datetime(df['createdAt'])
-        df = df.loc[df.groupby('employeeId')['createdAt'].idxmax()]
-        df = df.reset_index(drop=True)
+        df['companyId'] = company_id
+        if 'createdAt' in df.columns and 'employeeId' in df.columns:
+            df['createdAt'] = pd.to_datetime(df['createdAt'])
+            df = df.loc[df.groupby('employeeId')['createdAt'].idxmax()]
 
-        return df
+        return df.reset_index(drop=True)
 
     def get_private_info(self) -> str:
         combined = []
@@ -108,9 +129,9 @@ class Employees:
             default_templates_temp['companyId'] = company
             default_templates = pd.concat([default_templates, default_templates_temp])
 
-        # valid_default_templates, invalid_default_templates = Functions.validate_data(df=default_templates, schema=EmployeeGet, debug=True)
+        valid_default_templates, invalid_default_templates = Functions.validate_data(df=default_templates, schema=DefaultEmployeeTemplates, debug=True)
 
-        return default_templates
+        return valid_default_templates, invalid_default_templates
 
 
     def _get_default_templates(self, company_id: str, employee_type: str = None) -> pd.DataFrame:
@@ -150,6 +171,8 @@ class Employees:
             json=payload,
             timeout=self.nmbrs.timeout
         )
+
+
         return resp
 
     def update(self, employee_id: str, data: Dict[str, Any]):
@@ -183,14 +206,86 @@ class Employees:
         )
 
         # Handle social security number update if present
-        if 'socialSecurityNumber' in data:
+        #TODO niuet overtschirjven
+        if 'social_security_number' in data:
             social_security_payload = {
-                "socialSecurityNumber": data['socialSecurityNumber']
+                "socialSecurityNumber": data['social_security_number']
             }
             resp = self.nmbrs.session.put(
-                url=f"{self.nmbrs.base_url}employees/{employee_id}/social_security_number",
+                url=f"{self.nmbrs.base_url}employees/{employee_id}/socialsecuritynumber",
                 json=social_security_payload,
                 timeout=self.nmbrs.timeout
             )
 
         return resp
+
+    def get_soap_ids(self) -> pd.DataFrame:
+        """
+        Get all employees using the SOAP API.
+
+        Returns:
+            pd.DataFrame: DataFrame containing all companies
+        """
+        try:
+            # Make SOAP request with the proper header structure
+            emp_list = []
+            comp_ids = self.nmbrs.soap_company_ids.i_d.unique()
+            for company_id in comp_ids:
+                response = self.nmbrs.soap_client_employees.service.Function_GetAll_AllEmployeesByCompany_V2(
+                    _soapheaders=[self.nmbrs.soap_auth_header_employees],
+                    CompanyID=company_id
+                )
+
+                # Convert response to DataFrame
+                if response:
+                    # Convert Zeep objects to Python dictionaries
+                    serialized_response = serialize_object(response)
+
+                    # TODO: add validation here
+                    # Convert to DataFrame
+                    df = pd.DataFrame(serialized_response)
+                    df = self.nmbrs._rename_camel_columns_to_snake_case(df)
+                    if not df.empty:
+                        emp_list.append(df)
+
+            if len(emp_list) > 0:
+                return pd.concat(emp_list, ignore_index=True)
+            else:
+                return pd.DataFrame()
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+        except Exception as e:
+            self.logger.exception("Exception occurred:")
+            raise Exception(f"Failed to get companies: {str(e)}")
+
+    def get_soap_personal_info(self):
+        try:
+            emp_list = []
+            comp_ids = self.nmbrs.soap_company_ids.i_d.unique()
+            for company_id in comp_ids:
+                response = self.nmbrs.soap_client_employees.service.PersonalInfo_GetAll_AllEmployeesByCompany(
+                    _soapheaders=[self.nmbrs.soap_auth_header_employees],
+                    CompanyID=company_id
+                )
+
+                if response:
+                    serialized_response = serialize_object(response)
+                    df = pd.json_normalize(
+                        serialized_response,
+                        record_path=['EmployeePersonalInfos', 'PersonalInfo_V2'],
+                        meta=['EmployeeId']
+                    )
+                    df = self.nmbrs._rename_camel_columns_to_snake_case(df)
+                    if not df.empty:
+                        emp_list.append(df)
+            if len(emp_list) > 0:
+                return pd.concat(emp_list, ignore_index=True)
+            else:
+                return pd.DataFrame()
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+        except Exception as e:
+            self.logger.exception("Exception occurred:")
+            raise Exception(f"Failed to get companies: {str(e)}")

brynq_sdk_nmbrs/employment.py

@@ -1,9 +1,17 @@
 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.employment import EmploymentGet, EmploymentCreate, EmploymentUpdate, EmploymentDelete
+
+from .schemas.employment import (
+    EmploymentCreate,
+    EmploymentDelete,
+    EmploymentGet,
+    EmploymentUpdate,
+)
 
 
 class Employment:
@@ -66,7 +74,7 @@ class Employment:
             return employment_model
 
         # Convert validated model to dict for API payload
-        payload = employment_model.model_dump(exclude_none=True, by_alias=True)
+        payload = employment_model.model_dump(exclude_none=True, by_alias=True, mode='json')
 
         # Send request
         resp = self.nmbrs.session.post(
@@ -96,7 +104,7 @@ class Employment:
             return employment_model
 
         # Convert validated model to dict for API payload
-        payload = employment_model.model_dump(exclude_none=True, by_alias=True)
+        payload = employment_model.model_dump(exclude_none=True, by_alias=True, mode='json')
 
         # Send request
         resp = self.nmbrs.session.put(

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)}")

brynq_sdk_nmbrs/salaries.py

@@ -1,9 +1,13 @@
-import math
+from typing import Any, Dict, Union
+
 import pandas as pd
 import requests
-from typing import Dict, Any
+from zeep.exceptions import Fault
+from zeep.helpers import serialize_object
+
 from brynq_sdk_functions import Functions
-from .schemas.salary import SalaryGet, SalaryCreate
+
+from .schemas.salary import SalaryCreate, SalaryGet, SalaryUpdate
 
 
 class Salaries:
@@ -83,3 +87,74 @@ class Salaries:
             timeout=self.nmbrs.timeout
         )
         return resp
+
+    def get_current(self, employee_id: Union[int, str]) -> pd.DataFrame:
+        """
+        Get current salary for an employee via SOAP.
+
+        Args:
+            employee_id: The ID of the employee
+
+        Returns:
+            DataFrame with current salary
+        """
+        if self.nmbrs.mock_mode:
+            return pd.DataFrame()
+
+        try:
+            response = self.nmbrs.soap_client_employees.service.Salary_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)}")
+        except Exception as e:
+            raise Exception(f"Failed to get Salary: {str(e)}")
+
+    def update(self, data: Dict[str, Any]):
+        """
+        Update salary for an employee using SOAP API.
+
+        Args:
+            data: Dictionary containing salary data with fields matching SalaryUpdate schema:
+                - employee_id: Employee ID
+                - salary_value: Salary value (gross amount)
+                - salary_type: Salary type (1=FulltimeSalary, 2=ParttimeSalary, etc.)
+                - start_date: Start date (optional)
+
+        Returns:
+            Response from the API
+        """
+        try:
+            salary_model = SalaryUpdate(**data)
+
+            if self.nmbrs.mock_mode:
+                return salary_model
+
+            # Make SOAP request with dict - SalaryInput only has Value, Type, SalaryTable
+            response = self.nmbrs.soap_client_employees.service.Salary_UpdateCurrent(
+                EmployeeId=salary_model.employee_id,
+                Salary={
+                    'Value': salary_model.salary_value,
+                    'Type': salary_model.salary_type
+                },
+                _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 update Salary: {str(e)}")