brynq-sdk-nmbrs 2.3.1__py3-none-any.whl

brynq_sdk_nmbrs/department.py

@@ -0,0 +1,122 @@
+import math
+import pandas as pd
+import requests
+from typing import Dict, Any
+from .schemas.department import DepartmentCreate, EmployeeDepartmentUpdate, Period, EmployeeDepartmentGet, DepartmentGet
+from brynq_sdk_functions import Functions
+
+
+class EmployeeDepartment:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            created_from: str = None,
+            employee_id: str = None) -> tuple[pd.DataFrame, pd.DataFrame]:
+        departments = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            departments = pd.concat([departments, self._get(company, created_from, employee_id)])
+
+        valid_departments, invalid_departments = Functions.validate_data(df=departments, schema=EmployeeDepartmentGet, debug=True)
+
+        return valid_departments, invalid_departments
+
+    def _get(self,
+             company_id: str,
+             created_from: str = None,
+             employee_id: str = None) -> pd.DataFrame:
+        params = {}
+        if created_from:
+            params['createdFrom'] = created_from
+        if employee_id:
+            params['employeeId'] = employee_id
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}companies/{company_id}/employees/departments",
+                                   params=params)
+
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.json_normalize(
+            data,
+            record_path='departments',
+            meta=['employeeId']
+        )
+
+        return df
+
+    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)
+
+        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
+
+        # 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
+
+    def update(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Update a department for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing department data with fields matching
+                 the DepartmentUpdate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, EmployeeDepartmentUpdate)
+        department_model = EmployeeDepartmentUpdate(**nested_data)
+
+        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)
+
+        # Send request
+        resp = self.nmbrs.session.put(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/department",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+
+
+class Departments:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            debtor_id: str) -> pd.DataFrame:
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}debtors/{debtor_id}/departments")
+
+        data = self.nmbrs.get_paginated_result(request)
+
+        df = pd.DataFrame(data)
+        valid_departments, invalid_departments = Functions.validate_data(df=df, schema=DepartmentGet, debug=True)
+
+        return valid_departments, invalid_departments

brynq_sdk_nmbrs/document.py

@@ -0,0 +1,30 @@
+from io import BytesIO
+
+import pandas as pd
+import requests
+
+
+class Payslip:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            employee_id: str,
+            period: int = None,
+            year: int = None) -> pd.DataFrame:
+        params = {}
+        if period:
+            params['period'] = period
+        if year:
+            params['year'] = year
+        resp = self.nmbrs.session.get(f"{self.nmbrs.base_url}employees/{employee_id}/payslipperperiod/",
+                                      params=params,
+                                      timeout=self.nmbrs.timeout)
+        resp.raise_for_status()
+        task_id = resp.json()['taskId']
+
+        resp = self.nmbrs.session.get(f"{self.nmbrs.base_url}documents/{task_id}", timeout=self.nmbrs.timeout)
+
+        return BytesIO(resp.content)
+
+

brynq_sdk_nmbrs/employees.py

@@ -0,0 +1,196 @@
+import pandas as pd
+import requests
+from pydantic import BaseModel
+
+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 .contract import Contract
+from .costcenter import EmployeeCostcenter
+from .department import EmployeeDepartment
+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 .leave import Leave, LeaveBalance
+from .schemas.employees import (
+    BsnGet, EmployeeGet, EmployeeCreate, EmployeeUpdate, EmployeeDelete,
+    BasicInfo, BirthInfo, ContactInfo, PartnerInfo, Period, AdditionalEmployeeInfo,
+    CreateEmployeePersonalInfo
+)
+
+
+class Employees:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+        self.address = Address(nmbrs)
+        self.functions = EmployeeFunction(nmbrs)
+        self.contract = Contract(nmbrs)
+        self.departments = EmployeeDepartment(nmbrs)
+        self.costcenter = EmployeeCostcenter(nmbrs)
+        self.schedule = Schedule(nmbrs)
+        self.employment = Employment(nmbrs)
+        self.variable_hours = VariableHours(nmbrs)
+        self.fixed_hours = FixedHours(nmbrs)
+        self.variable_days = VariableDays(nmbrs)
+        self.salaries = Salaries(nmbrs)
+        self.variable_wagecomponents = EmployeeVariableWageComponents(nmbrs)
+        self.fixed_wagecomponents = EmployeeFixedWageComponents(nmbrs)
+        self.banks = Bank(nmbrs)
+        self.payslips = Payslip(nmbrs)
+        self.wage_tax = WageTax(nmbrs)
+        self.leave = Leave(nmbrs)
+        self.leave_balance = LeaveBalance(nmbrs)
+
+    def get(self,
+            employee_type: str = None
+            ) -> (pd.DataFrame, pd.DataFrame):
+        employees = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            employees = pd.concat([employees, self._get(company, employee_type)])
+
+        valid_employees, invalid_employees = Functions.validate_data(df=employees, schema=EmployeeGet, debug=True)
+
+        return valid_employees, invalid_employees
+
+    def _get(self,
+            company_id: str,
+            employee_type: str = None) -> pd.DataFrame:
+        params = {} if employee_type is None else {'employeeType': employee_type}
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}companies/{company_id}/employees/personalinfo",
+                                   params=params)
+
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.json_normalize(
+            data,
+            record_path='info',
+            meta=['employeeId']
+        )
+        df['companyId'] = company_id
+
+        df['createdAt'] = pd.to_datetime(df['createdAt'])
+        df = df.loc[df.groupby('employeeId')['createdAt'].idxmax()]
+        df = df.reset_index(drop=True)
+
+        return df
+
+    def get_private_info(self) -> str:
+        combined = []
+        for company_id in self.nmbrs.company_ids:
+            request = requests.Request(method='GET',
+                                    url=f"{self.nmbrs.base_url}companies/{company_id}/employees/privateInfos")
+            data = self.nmbrs.get_paginated_result(request)
+            df = pd.json_normalize(
+                data,
+                record_path='privateInfos',
+                meta=['employeeId']
+            )
+            df['companyId'] = company_id
+            combined.append(df)
+        df = pd.concat(combined, ignore_index=True)
+        valid_bsn, invalid_bsn = Functions.validate_data(df, BsnGet)
+
+        return valid_bsn, invalid_bsn
+
+    def get_default_templates(self) -> pd.DataFrame:
+        default_templates = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            default_templates_temp = self._get_default_templates(company)
+            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)
+
+        return default_templates
+
+
+    def _get_default_templates(self, company_id: str, employee_type: str = None) -> pd.DataFrame:
+        params = {} if employee_type is None else {'employeeType': employee_type}
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}companies/{company_id}/defaulttemplates",
+                                   params=params)
+        data = self.nmbrs.get_paginated_result(request)
+        return pd.DataFrame(data)
+
+    def create(self, company_id: str, data: Dict[str, Any]):
+        """
+        Create a new employee using Pydantic validation.
+
+        Args:
+            company_id: The ID of the company
+            data: Dictionary structured according to the EmployeeCreate schema with:
+                 - PersonalInfo: containing basicInfo, birthInfo, contactInfo, etc.
+                 - AdditionalEmployeeInfo: containing service date, etc.
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, EmployeeCreate)
+        employee_model = EmployeeCreate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return employee_model
+
+        # Convert validated model to dict for API payload
+        payload = employee_model.model_dump(exclude_none=True, by_alias=True)
+
+        # Send request
+        resp = self.nmbrs.session.post(
+            url=f"{self.nmbrs.base_url}companies/{company_id}/employees",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def update(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Update an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary structured according to the EmployeeUpdate schema with:
+                 - employeeId: The ID of the employee to update
+                 - personalInfo: containing any of basicInfo, birthInfo, contactInfo, etc.
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, EmployeeUpdate)
+        employee_model = EmployeeUpdate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return employee_model
+
+        # Convert validated model to dict for API payload
+        payload = employee_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}/personalInfo",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+
+        # Handle social security number update if present
+        if 'socialSecurityNumber' in data:
+            social_security_payload = {
+                "socialSecurityNumber": data['socialSecurityNumber']
+            }
+            resp = self.nmbrs.session.put(
+                url=f"{self.nmbrs.base_url}employees/{employee_id}/social_security_number",
+                json=social_security_payload,
+                timeout=self.nmbrs.timeout
+            )
+
+        return resp

brynq_sdk_nmbrs/employment.py

@@ -0,0 +1,107 @@
+import math
+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
+
+
+class Employment:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            changed_from: str = None,
+            created_from: str = None,
+            employee_id: str = None) -> tuple[pd.DataFrame, pd.DataFrame]:
+        employments = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            employments = pd.concat([employments, self._get(company, changed_from, created_from, employee_id)])
+
+        valid_employments, invalid_employments = Functions.validate_data(df=employments, schema=EmploymentGet, debug=True)
+
+        return valid_employments, invalid_employments
+
+    def _get(self,
+            company_id: str,
+            changed_from: str = None,
+            created_from: str = None,
+            employee_id: str = None) -> pd.DataFrame:
+        params = {}
+        if created_from:
+            params['createdFrom'] = created_from
+        if employee_id:
+            params['changedFrom'] = changed_from
+        if employee_id:
+            params['employeeId'] = employee_id
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}companies/{company_id}/employees/employments",
+                                   params=params)
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.json_normalize(
+            data,
+            record_path='employments',
+            meta=['employeeId']
+        )
+
+        return df
+
+    def create(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Create a new employment record for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing employment data with fields matching
+                 the EmploymentCreate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, EmploymentCreate)
+        employment_model = EmploymentCreate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return employment_model
+
+        # Convert validated model to dict for API payload
+        payload = employment_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}/employment",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def update(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Update an employment record for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing employment data with fields matching
+                 the EmploymentUpdate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, EmploymentUpdate)
+        employment_model = EmploymentUpdate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return employment_model
+
+        # Convert validated model to dict for API payload
+        payload = employment_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}/employment",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp

brynq_sdk_nmbrs/function.py

@@ -0,0 +1,89 @@
+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
+
+
+class EmployeeFunction:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            created_from: str = None) -> tuple[pd.DataFrame, pd.DataFrame]:
+        functions = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            functions = pd.concat([functions, self._get(company, created_from)])
+
+        valid_functions, invalid_functions = BrynQFunctions.validate_data(df=functions, schema=EmployeeFunctionGet, debug=True)
+
+        return valid_functions, invalid_functions
+
+    def _get(self,
+            company_id: str,
+            created_from: str = None) -> pd.DataFrame:
+        params = {}
+        if created_from:
+            params['createdFrom'] = created_from
+        try:
+            request = requests.Request(method='GET', url=f"{self.nmbrs.base_url}companies/{company_id}/employees/functions", params=params)
+            data = self.nmbrs.get_paginated_result(request)
+            df = pd.json_normalize(
+                data,
+                record_path='functions',
+                meta=['employeeId']
+            )
+        except requests.HTTPError as e:
+            df = pd.DataFrame()
+        return df
+
+    def update(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Update a function for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing function data with fields matching
+                 the FunctionUpdate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, FunctionUpdate)
+        function_model = FunctionUpdate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return function_model
+
+        # Convert validated model to dict for API payload
+        payload = function_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}/function",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+
+
+class Functions:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self, debtor_id: str) -> (pd.DataFrame, pd.DataFrame):
+        try:
+            request = requests.Request(method='GET',
+                                       url=f"{self.nmbrs.base_url}debtors/{debtor_id}/functions")
+
+            data = self.nmbrs.get_paginated_result(request)
+            df = pd.DataFrame(data)
+            valid_functions, invalid_functions = BrynQFunctions.validate_data(df=df, schema=FunctionGet, debug=True)
+
+        except requests.HTTPError as e:
+            df = pd.DataFrame()
+
+        return valid_functions, invalid_functions