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

brynq_sdk_nmbrs/hours.py

@@ -0,0 +1,252 @@
+import pandas as pd
+import requests
+from typing import Dict, Any
+from .schemas.hours import (
+    VariableHoursCreate, VariableHoursUpdate, HoursDelete,
+    FixedHoursCreate, FixedHoursUpdate, VariableHoursGet, FixedHoursGet
+)
+from brynq_sdk_functions import Functions
+
+
+class Hours:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get_types(self,
+                  company_id: str) -> pd.DataFrame:
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}companies/{company_id}/hourcodes")
+
+        df = self.nmbrs.get_paginated_result(request)
+
+        return df
+
+
+class VariableHours:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            employee_id: str,
+            created_from: str = None,
+            period: int = None,
+            year: int = None) -> tuple[pd.DataFrame, pd.DataFrame]:
+        params = {}
+        if created_from:
+            params['createdFrom'] = created_from
+        if period:
+            params['period'] = period
+        if year:
+            params['year'] = year
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}employees/{employee_id}/variablehours",
+                                   params=params)
+
+        data = self.nmbrs.get_paginated_result(request)
+
+        df = pd.DataFrame(data)
+
+        df['employeeId'] = employee_id  # Add employee_id for tracking
+        df['period'] = period
+        df['year'] = year
+
+        # Validate data using the schema
+        valid_hours, invalid_hours = Functions.validate_data(df=df, schema=VariableHoursGet, debug=True)
+
+        return valid_hours, invalid_hours
+
+    def create(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Create variable hours for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing hours data with fields matching
+                 the VariableHoursCreate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, VariableHoursCreate)
+        hours_model = VariableHoursCreate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return hours_model
+
+        # Convert validated model to dict for API payload
+        payload = hours_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}/variablehours",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def update(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Update variable hours for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing hours data with fields matching
+                 the VariableHoursUpdate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, VariableHoursUpdate)
+        hours_model = VariableHoursUpdate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return hours_model
+
+        # Convert validated model to dict for API payload
+        payload = hours_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}/variablehours",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def delete(self, employee_id: str, hourcomponent_id: str):
+        """
+        Delete hours for an employee.
+
+        Args:
+            employee_id: The ID of the employee
+            hourcomponent_id: The ID of the hour component to delete
+
+        Returns:
+            Response from the API
+        """
+        # Create and validate a HoursDelete model
+        hours_model = HoursDelete(hourComponentId=hourcomponent_id)
+
+        if self.nmbrs.mock_mode:
+            return hours_model
+
+        # Send request
+        resp = self.nmbrs.session.delete(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/hours/{hourcomponent_id}",
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+
+class FixedHours:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            company_id: str,
+            created_from: str = None,
+            employee_id: str = None,
+            period: int = None,
+            year: int = None) -> tuple[pd.DataFrame, pd.DataFrame]:
+        params = {}
+        if created_from:
+            params['createdFrom'] = created_from
+        if employee_id:
+            params['employeeId'] = employee_id
+        if period:
+            params['period'] = period
+        if year:
+            params['year'] = year
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}employees/{employee_id}/fixedhours",
+                                   params=params)
+
+        df = self.nmbrs.get_paginated_result(request)
+
+        return df
+
+    def create(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Create fixed hours for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing hours data with fields matching
+                 the FixedHoursCreate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, FixedHoursCreate)
+        hours_model = FixedHoursCreate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return hours_model
+
+        # Convert validated model to dict for API payload
+        payload = hours_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}/fixedhours",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def update(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Update fixed hours for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing hours data with fields matching
+                 the FixedHoursUpdate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, FixedHoursUpdate)
+        hours_model = FixedHoursUpdate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return hours_model
+
+        # Convert validated model to dict for API payload
+        payload = hours_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}/fixedhours",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def delete(self, employee_id: str, hourcomponent_id: str):
+        """
+        Delete hours for an employee.
+
+        Args:
+            employee_id: The ID of the employee
+            hourcomponent_id: The ID of the hour component to delete
+
+        Returns:
+            Response from the API
+        """
+        # Create and validate a HoursDelete model
+        hours_model = HoursDelete(hourComponentId=hourcomponent_id)
+
+        if self.nmbrs.mock_mode:
+            return hours_model
+
+        # Send request
+        resp = self.nmbrs.session.delete(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/hours/{hourcomponent_id}",
+            timeout=self.nmbrs.timeout
+        )
+        return resp

brynq_sdk_nmbrs/leave.py

@@ -0,0 +1,139 @@
+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
+
+
+class Leave:
+    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)])
+
+        valid_leave, invalid_leave = Functions.validate_data(df=leave, schema=LeaveGet, debug=True)
+
+        return valid_leave, invalid_leave
+
+    def _get(self,
+            company_id: str,
+            changed_from: str = None) -> pd.DataFrame:
+        params = {}
+        if changed_from:
+            params['changed_from'] = changed_from
+        try:
+            request = requests.Request(method='GET',
+                                       url=f"{self.nmbrs.base_url}companies/{company_id}/employees/leaverequests",
+                                       params=params)
+
+            data = self.nmbrs.get_paginated_result(request)
+            df = pd.json_normalize(
+                data,
+                record_path='EmployeeLeaveRequests',
+                meta=['employeeId']
+            )
+        except requests.HTTPError as e:
+            df = pd.DataFrame()
+
+        return df
+
+    def create(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Create a new leave request for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing leave request data in the format matching LeaveCreate schema
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model - this will raise an error if required fields are missing
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, LeaveCreate)
+        leave_model = LeaveCreate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return leave_model
+
+        # Convert validated model to dict for API payload
+        payload = leave_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}/leaverequest",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def delete(self, employee_id: str, leave_request_id: str):
+        """
+        Delete a leave request for an employee.
+
+        Args:
+            employee_id: The ID of the employee
+            leave_request_id: The ID of the leave request to delete
+
+        Returns:
+            Response from the API
+        """
+        # Create and validate a BankDelete model
+        leave_model = LeaveDelete(leave_request_id=leave_request_id)
+
+        if self.nmbrs.mock_mode:
+            return leave_model
+
+        # Send request
+        resp = self.nmbrs.session.delete(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/leave/{leave_request_id}",
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+
+class LeaveBalance:
+    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)])
+
+        valid_leave, invalid_leave = Functions.validate_data(df=leave, schema=LeaveBalanceGet, debug=True)
+
+        return valid_leave, invalid_leave
+
+    def _get(self,
+            company_id: str) -> pd.DataFrame:
+        try:
+            request = requests.Request(method='GET',
+                                       url=f"{self.nmbrs.base_url}companies/{company_id}/employees/leaveBalances")
+
+            data = self.nmbrs.get_paginated_result(request)
+            df = pd.json_normalize(
+                data,
+                record_path='leaveBalances',
+                meta=['employeeId']
+            )
+        except requests.HTTPError as e:
+            df = pd.DataFrame()
+
+        return df
+
+
+class LeaveGroup:
+    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)])

brynq_sdk_nmbrs/manager.py

@@ -0,0 +1,294 @@
+import pandas as pd
+import requests
+from brynq_sdk_functions import Functions as BrynQFunctions
+import math
+from typing import Dict, Any
+from .schemas.manager import (
+    ManagerGet, ManagerBasicGet, EmployeeManagerGet, ManagerHistoricBasicGet,
+    ManagerCreate, ManagerUpdate, ManagerDelete, UpdateEmployeeManager
+)
+
+
+class EmployeeManager:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self, created_from: str = None) -> tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        Get employee manager history for all companies.
+
+        Args:
+            created_from: Optional filter to get managers created from a specific date
+
+        Returns:
+            Tuple of (valid_managers, invalid_managers) DataFrames
+        """
+        managers = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            managers = pd.concat([managers, self._get(company, created_from)])
+
+        valid_managers, invalid_managers = BrynQFunctions.validate_data(df=managers, schema=EmployeeManagerGet, debug=True)
+
+        return valid_managers, invalid_managers
+
+    def _get(self, company_id: str, created_from: str = None) -> pd.DataFrame:
+        """
+        Get employee manager history for a specific company.
+
+        Args:
+            company_id: The ID of the company
+            created_from: Optional filter to get managers created from a specific date
+
+        Returns:
+            DataFrame containing employee manager data
+        """
+        params = {}
+        if created_from:
+            params['createdFrom'] = created_from
+
+        try:
+            request = requests.Request(
+                method='GET',
+                url=f"{self.nmbrs.base_url}companies/{company_id}/employees/managers",
+                params=params
+            )
+            data = self.nmbrs.get_paginated_result(request)
+            df = pd.json_normalize(
+                data,
+                record_path='managers',
+                meta=['employeeId']
+            )
+            df['companyId'] = company_id
+        except requests.HTTPError as e:
+            df = pd.DataFrame()
+
+        return df
+
+    def get_historic_basic(self, created_from: str = None) -> tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        Get historic basic manager information for employees.
+
+        Args:
+            created_from: Optional filter to get managers created from a specific date
+
+        Returns:
+            Tuple of (valid_managers, invalid_managers) DataFrames
+        """
+        managers = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            managers = pd.concat([managers, self._get_historic_basic(company, created_from)])
+
+        valid_managers, invalid_managers = BrynQFunctions.validate_data(df=managers, schema=ManagerHistoricBasicGet, debug=True)
+
+        return valid_managers, invalid_managers
+
+    def _get_historic_basic(self, company_id: str, created_from: str = None) -> pd.DataFrame:
+        """
+        Get historic basic manager information for a specific company.
+
+        Args:
+            company_id: The ID of the company
+            created_from: Optional filter to get managers created from a specific date
+
+        Returns:
+            DataFrame containing historic basic manager data
+        """
+        params = {}
+        if created_from:
+            params['createdFrom'] = created_from
+
+        try:
+            request = requests.Request(
+                method='GET',
+                url=f"{self.nmbrs.base_url}companies/{company_id}/employees/managers",
+                params=params
+            )
+            data = self.nmbrs.get_paginated_result(request)
+            df = pd.json_normalize(
+                data,
+                record_path='managers',
+                meta=['employeeId']
+            )
+            df['companyId'] = company_id
+        except requests.HTTPError as e:
+            df = pd.DataFrame()
+
+        return df
+
+    def update(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Update the manager of a specific employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing manager data with fields matching
+                 the UpdateEmployeeManager schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        manager_model = UpdateEmployeeManager(**data)
+
+        if self.nmbrs.mock_mode:
+            return manager_model
+
+        # Convert validated model to dict for API payload
+        payload = manager_model.dict(exclude_none=True)
+
+        # Send request
+        resp = self.nmbrs.session.put(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/manager",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+
+class Manager:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self, debtor_id: str) -> tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        Get all managers for a specific debtor.
+
+        Args:
+            debtor_id: The ID of the debtor
+
+        Returns:
+            Tuple of (valid_managers, invalid_managers) DataFrames
+        """
+        try:
+            request = requests.Request(
+                method='GET',
+                url=f"{self.nmbrs.base_url}debtors/{debtor_id}/managers"
+            )
+
+            data = self.nmbrs.get_paginated_result(request)
+            df = pd.DataFrame(data)
+            df['debtorId'] = debtor_id
+
+            valid_managers, invalid_managers = BrynQFunctions.validate_data(df=df, schema=ManagerGet, debug=True)
+
+        except requests.HTTPError as e:
+            df = pd.DataFrame()
+            valid_managers = df
+            invalid_managers = df
+
+        return valid_managers, invalid_managers
+
+    def get_basic(self, debtor_id: str) -> tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        Get basic manager information for a specific debtor.
+
+        Args:
+            debtor_id: The ID of the debtor
+
+        Returns:
+            Tuple of (valid_managers, invalid_managers) DataFrames
+        """
+        try:
+            request = requests.Request(
+                method='GET',
+                url=f"{self.nmbrs.base_url}debtors/{debtor_id}/managers"
+            )
+
+            data = self.nmbrs.get_paginated_result(request)
+            df = pd.DataFrame(data)
+            df['debtorId'] = debtor_id
+
+            valid_managers, invalid_managers = BrynQFunctions.validate_data(df=df, schema=ManagerBasicGet, debug=True)
+
+        except requests.HTTPError as e:
+            df = pd.DataFrame()
+            valid_managers = df
+            invalid_managers = df
+
+        return valid_managers, invalid_managers
+
+    def create(self, debtor_id: str, data: Dict[str, Any]):
+        """
+        Create a new manager using Pydantic validation.
+
+        Args:
+            debtor_id: The ID of the debtor
+            data: Dictionary containing manager data with fields matching
+                 the ManagerCreate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        manager_model = ManagerCreate(**data)
+
+        if self.nmbrs.mock_mode:
+            return manager_model
+
+        # Convert validated model to dict for API payload
+        payload = manager_model.dict(exclude_none=True)
+
+        # Send request
+        resp = self.nmbrs.session.post(
+            url=f"{self.nmbrs.base_url}debtors/{debtor_id}/managers",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def update(self, debtor_id: str, data: Dict[str, Any]):
+        """
+        Update a manager using Pydantic validation.
+
+        Args:
+            debtor_id: The ID of the debtor
+            data: Dictionary containing manager data with fields matching
+                 the ManagerUpdate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        manager_model = ManagerUpdate(**data)
+
+        if self.nmbrs.mock_mode:
+            return manager_model
+
+        # Convert validated model to dict for API payload
+        payload = manager_model.dict(exclude_none=True)
+
+        # Send request
+        resp = self.nmbrs.session.put(
+            url=f"{self.nmbrs.base_url}debtors/{debtor_id}/managers/{payload['managerId']}",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def delete(self, debtor_id: str, data: Dict[str, Any]):
+        """
+        Delete a manager using Pydantic validation.
+
+        Args:
+            debtor_id: The ID of the debtor
+            data: Dictionary containing manager data with fields matching
+                 the ManagerDelete schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model
+        manager_model = ManagerDelete(**data)
+
+        if self.nmbrs.mock_mode:
+            return manager_model
+
+        # Convert validated model to dict for API payload
+        payload = manager_model.dict(exclude_none=True)
+
+        # Send request
+        resp = self.nmbrs.session.delete(
+            url=f"{self.nmbrs.base_url}debtors/{debtor_id}/managers/{payload['managerId']}",
+            timeout=self.nmbrs.timeout
+        )
+        return resp