brynq-sdk-zenegy 1.3.3__py3-none-any.whl

brynq_sdk_zenegy/global_value_sets.py

@@ -0,0 +1,260 @@
+from .schemas.global_value_sets import GlobalValueSetsGet, GlobalValueSetCreate, GlobalValueSetUpdate, GlobalValueSetEmployeeAssignment, GlobalValueSetEmployeeAssignmentResponse, RemoveGlobalValuesFromSetRequest, GetAssignedEmployeesRequest, AssignedEmployeesGet, AddCompanyGlobalValueRequest, CompanyGlobalValuesGet
+from typing import Tuple, Dict, Any, List
+import pandas as pd
+from brynq_sdk_functions import Functions
+import requests
+from uuid import UUID
+
+class GlobalValueSets:
+    """
+    Handles all global value sets-related operations in Zenegy API
+    """
+    def __init__(self, zenegy):
+        """
+        Initialize the GlobalValueSets class.
+
+        Args:
+            zenegy: The Zenegy instance to use for API calls
+        """
+        self.zenegy = zenegy
+        self.endpoint = f"api/companies/{self.zenegy.company_uid}/global-value-sets"
+
+    def get(self) -> Tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        GetGlobalValueSetsPerCompanyAsync
+        Returns:
+            Tuple of (valid_data, invalid_data) DataFrames with global value sets information
+        """
+        try:
+            content = self.zenegy.get(endpoint=self.endpoint)
+
+            df = pd.json_normalize(
+                content,
+                sep='__'
+            )
+            if df.empty:
+                return pd.DataFrame(), pd.DataFrame()
+
+            # Validate against schema
+            valid_data, invalid_data = Functions.validate_data(df, GlobalValueSetsGet)
+
+            return valid_data, invalid_data
+        except Exception as e:
+            raise Exception(f"Failed to retrieve global value sets: {str(e)}") from e
+
+    def get_by_id(self, global_value_set_uid: UUID) -> Tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        GetGlobalValueSetByIdAsync
+        Args:
+            global_value_set_uid (UUID): The global value set UID to retrieve
+        Returns:
+            Tuple of (valid_data, invalid_data) DataFrames with global value set information
+        """
+        try:
+            endpoint = f"{self.endpoint}/{global_value_set_uid}"
+            content = self.zenegy.get(endpoint=endpoint)
+
+            # Normalize the data
+            df = pd.json_normalize(
+                [content],  # Wrap in list since it's a single object
+                sep='__'
+            )
+
+            if df.empty:
+                return pd.DataFrame(), pd.DataFrame()
+
+            # Validate data using schema
+            valid_data, invalid_data = Functions.validate_data(df, GlobalValueSetsGet)
+            return valid_data, invalid_data
+        except Exception as e:
+            raise Exception(f"Failed to retrieve global value set by ID: {str(e)}") from e
+
+    def get_assigned_employees(self, global_value_set_uid: UUID, filters: Dict[str, Any] = None) -> Tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        Get employees assigned to a global value set with optional filters.
+
+        Args:
+            global_value_set_uid (UUID): The global value set UID to get assigned employees for
+            filters (Dict[str, Any], optional): Filter criteria for employees
+
+        Returns:
+            Tuple of (valid_data, invalid_data) DataFrames with assigned employee information
+        """
+        try:
+            # Default filter if none provided
+            if filters is None:
+                filters = {"skip": 0, "take": 50}
+
+            # Validate the filter data using Pydantic
+            valid_filter = GetAssignedEmployeesRequest(**filters)
+            req_body = valid_filter.model_dump(by_alias=True, mode='json', exclude_none=True)
+
+            endpoint = f"{self.endpoint}/{global_value_set_uid}/assigned"
+            response = self.zenegy.post(endpoint=endpoint, json=req_body)
+            self.zenegy.raise_for_status_with_details(response)
+
+            content = response.json()
+
+            # Get data from response
+            data = content.get("data", [])
+
+            if not data:
+                return pd.DataFrame(), pd.DataFrame()
+
+            # Normalize the data with expanded department fields
+            df = pd.json_normalize(
+                data,
+                sep='__'
+            )
+
+            if df.empty:
+                return pd.DataFrame(), pd.DataFrame()
+
+            # Validate data using schema
+            valid_data, invalid_data = Functions.validate_data(df, AssignedEmployeesGet)
+            return valid_data, invalid_data
+
+        except Exception as e:
+            raise Exception(f"Failed to get assigned employees for global value set: {str(e)}") from e
+
+    def create(self, data: Dict[str, Any]) -> requests.Response:
+        """
+        Create a new global value set.
+
+        Args:
+            data (Dict[str, Any]): The global value set data to create
+
+        Returns:
+            requests.Response: The API response
+        """
+        try:
+            # Convert flat dictionary to nested structure based on Pydantic model
+            nested_data = Functions.flat_dict_to_nested_dict(data, GlobalValueSetCreate)
+
+            valid_data = GlobalValueSetCreate(**nested_data)
+            req_body = valid_data.model_dump(by_alias=True, mode='json', exclude_none=True)
+
+            response = self.zenegy.post(endpoint=self.endpoint, json=req_body)
+            self.zenegy.raise_for_status_with_details(response)
+            return response
+
+        except Exception as e:
+            raise Exception(f"Failed to create global value set: {str(e)}") from e
+
+    def delete(self, global_value_set_uid: UUID) -> requests.Response:
+        """
+        Delete a global value set by UID.
+
+        Args:
+            global_value_set_uid (UUID): The global value set UID to delete
+
+        Returns:
+            requests.Response: The API response
+        """
+        try:
+            endpoint = f"{self.endpoint}/{global_value_set_uid}"
+
+            response = self.zenegy.delete(endpoint=endpoint)
+            self.zenegy.raise_for_status_with_details(response)
+            return response
+
+        except Exception as e:
+            raise Exception(f"Failed to delete global value set: {str(e)}") from e
+
+    def update(self, global_value_set_uid: UUID, data: Dict[str, Any]) -> requests.Response:
+        """
+        Update a global value set by UID.
+
+        Args:
+            global_value_set_uid (UUID): The global value set UID to update
+            data (Dict[str, Any]): The global value set data to update
+
+        Returns:
+            requests.Response: The API response
+        """
+        try:
+            # Convert flat dictionary to nested structure based on Pydantic model
+            nested_data = Functions.flat_dict_to_nested_dict(data, GlobalValueSetUpdate)
+
+            valid_data = GlobalValueSetUpdate(**nested_data)
+            req_body = valid_data.model_dump(by_alias=True, mode='json', exclude_none=True)
+            endpoint = f"{self.endpoint}/{global_value_set_uid}"
+
+            response = self.zenegy.patch(endpoint=endpoint, json=req_body)
+            self.zenegy.raise_for_status_with_details(response)
+            return response
+
+        except Exception as e:
+            raise Exception(f"Failed to update global value set: {str(e)}") from e
+
+    def manage_employees(self, global_value_set_uid: UUID, data: Dict[str, Any]) -> requests.Response:
+        """
+        Manage employee assignments for a global value set (add and/or remove employees).
+
+        Args:
+            global_value_set_uid (UUID): The global value set UID to manage employees for
+            data (Dict[str, Any]): The employee assignment data (add_employees and/or remove_employees)
+
+        Returns:
+            requests.Response: The API response with assignment results
+        """
+        try:
+            # Convert flat dictionary to nested structure based on Pydantic model
+            nested_data = Functions.flat_dict_to_nested_dict(data, GlobalValueSetEmployeeAssignment)
+
+            valid_data = GlobalValueSetEmployeeAssignment(**nested_data)
+            req_body = valid_data.model_dump(by_alias=True, mode='json', exclude_none=True)
+            endpoint = f"{self.endpoint}/{global_value_set_uid}/employees"
+
+            response = self.zenegy.put(endpoint=endpoint, json=req_body)
+            self.zenegy.raise_for_status_with_details(response)
+            return response
+
+        except Exception as e:
+            raise Exception(f"Failed to manage employees for global value set: {str(e)}") from e
+
+    def assign_to_employees(self, global_value_set_uid: UUID, employee_uids: List[str]) -> requests.Response:
+        """
+        Assign a global value set to specified employees.
+
+        Args:
+            global_value_set_uid (UUID): The global value set UID to assign
+            employee_uids (List[str]): List of employee UIDs to assign the global value set to
+
+        Returns:
+            requests.Response: The API response (204 No Content on success)
+        """
+        try:
+            # API expects a simple Array[string] as body
+            endpoint = f"{self.endpoint}/{global_value_set_uid}/assign"
+            req_body = employee_uids
+
+            response = self.zenegy.post(endpoint=endpoint, json=employee_uids)
+            self.zenegy.raise_for_status_with_details(response)
+            return response
+
+        except Exception as e:
+            raise Exception(f"Failed to assign global value set to employees: {str(e)}") from e
+
+    def unassign_from_employees(self, global_value_set_uid: UUID, employee_uids: List[str]) -> requests.Response:
+        """
+        Unassign employees from a global value set.
+
+        Args:
+            global_value_set_uid (UUID): The global value set UID to unassign employees from
+            employee_uids (List[str]): List of employee UIDs to unassign
+
+        Returns:
+            requests.Response: The API response
+        """
+        try:
+            # API expects a simple Array[string] as body
+            endpoint = f"{self.endpoint}/{global_value_set_uid}/employees/delete"
+            req_body = employee_uids
+
+            response = self.zenegy.post(endpoint=endpoint, json=employee_uids)
+            self.zenegy.raise_for_status_with_details(response)
+            return response
+
+        except Exception as e:
+            raise Exception(f"Failed to unassign employees from global value set: {str(e)}") from e

brynq_sdk_zenegy/global_values.py

@@ -0,0 +1,265 @@
+from .schemas.global_values import (GlobalValuesGet, CompanyGlobalValueCreate, CompanyGlobalValueUpdate, GlobalValueAssign, AssignedGlobalValuesGet, GetAssignedEmployeesToGlobalValueAsyncRequest, AssignedEmployeesToGlobalValueGet)
+from typing import Tuple, Dict, Any, List
+import pandas as pd
+from brynq_sdk_functions import Functions
+import requests
+from uuid import UUID
+
+class GlobalValues:
+    """
+    Handles all globalvalues-related operations in Zenegy API
+    """
+    def __init__(self, zenegy):
+        """
+        Initialize the GlobalValues class.
+
+        Args:
+            zenegy: The Zenegy instance to use for API calls
+        """
+        self.zenegy = zenegy
+        self.endpoint = f"api/companies/{self.zenegy.company_uid}/global-values"
+
+    def get(self) -> Tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        GetGlobalValuesPerCompanyAsync
+        Returns:
+            Tuple of (valid_data, invalid_data) DataFrames with global values information
+        """
+        try:
+            # Make the API request and get raw response
+            content = self.zenegy.get(endpoint=self.endpoint)
+
+            # Normalize the data with expanded effectiveFrom and effectiveTo
+            df = pd.json_normalize(
+                content,
+                sep='__'
+            )
+
+            if df.empty:
+                return pd.DataFrame(), pd.DataFrame()
+
+            # Validate data using schema
+            valid_data, invalid_data = Functions.validate_data(df, GlobalValuesGet)
+            return valid_data, invalid_data
+
+        except Exception as e:
+            raise Exception(f"Failed to retrieve global values: {str(e)}") from e
+
+    def create(self, data: Dict[str, Any]) -> requests.Response:
+        """
+        CreateGlobalValueAsync
+        Args:
+            data (Dict[str, Any]): The global value data to create
+        Returns:
+            requests.Response: The API response
+        """
+        try:
+            # Convert flat dictionary to nested structure based on Pydantic model
+            nested_data = Functions.flat_dict_to_nested_dict(data, CompanyGlobalValueCreate)
+
+            # Validate the data using Pydantic
+            valid_data = CompanyGlobalValueCreate(**nested_data)
+            req_body = valid_data.model_dump(by_alias=True, mode='json', exclude_none=True)
+
+            response = self.zenegy.post(endpoint=self.endpoint, json=req_body)
+            self.zenegy.raise_for_status_with_details(response)
+            return response
+
+        except Exception as e:
+            raise Exception(f"Failed to create global value: {str(e)}") from e
+
+    def get_by_id(self, global_value_uid: UUID) -> Tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        GetGlobalValueByIdAsync
+        Args:
+            global_value_uid (UUID): The global value UID to retrieve
+        Returns:
+            Tuple of (valid_data, invalid_data) DataFrames with global value information
+        """
+        try:
+            endpoint = f"{self.endpoint}/{global_value_uid}"
+            content = self.zenegy.get(endpoint=endpoint)
+
+            # Normalize the data with expanded effectiveFrom and effectiveTo
+            df = pd.json_normalize(
+                [content],  # Wrap in list since it's a single object
+                sep='__'
+            )
+
+            if df.empty:
+                return pd.DataFrame(), pd.DataFrame()
+
+            # Validate data using schema
+            valid_data, invalid_data = Functions.validate_data(df, GlobalValuesGet)
+            return valid_data, invalid_data
+        except Exception as e:
+            raise Exception(f"Failed to retrieve global value by ID: {str(e)}") from e
+
+    def get_assigned_global_values(self, employee_uid: UUID) -> Tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        GetAssignedGlobalValuesAsync
+        Args:
+            employee_uid (UUID): The employee UID to get assigned global values for
+        Returns:
+            Tuple of (valid_data, invalid_data) DataFrames with assigned global values information
+        """
+        try:
+            endpoint = f"{self.endpoint}/assignedGlobalValues/{employee_uid}"
+            content = self.zenegy.get(endpoint=endpoint)
+
+            # Normalize the data with expanded companyGlobalValueReferenceUidsPairs
+            df = pd.json_normalize(
+                content,
+                record_path='companyGlobalValueReferenceUidsPairs',
+                meta=['type', 'isAvailableInCompany', 'isEmployeeAssigned'],
+                record_prefix='companyGlobalValueReferenceUidsPairs__',
+                sep='__'
+            )
+
+            if df.empty:
+                return pd.DataFrame(), pd.DataFrame()
+
+            # Validate data using schema
+            valid_data, invalid_data = Functions.validate_data(df, AssignedGlobalValuesGet)
+            return valid_data, invalid_data
+        except Exception as e:
+            raise Exception(f"Failed to retrieve assigned global values for employee: {str(e)}") from e
+
+    def get_assigned_employees(self, global_value_uid: UUID, filters: Dict[str, Any] = None) -> Tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        Get employees assigned to a global value with optional filters.
+
+        Args:
+            global_value_uid (UUID): The global value UID to get assigned employees for
+            filters (Dict[str, Any], optional): Filter criteria for employees
+
+        Returns:
+            Tuple of (valid_data, invalid_data) DataFrames with assigned employee information
+        """
+        try:
+            if filters is None:
+                filters = {"skip": 0, "take": 50}
+
+            # Validate the filter data using Pydantic
+            valid_filter = GetAssignedEmployeesToGlobalValueAsyncRequest(**filters)
+            req_body = valid_filter.model_dump(by_alias=True, mode='json', exclude_none=True)
+
+            endpoint = f"{self.endpoint}/{global_value_uid}/assigned"
+            response = self.zenegy.post(endpoint=endpoint, json=req_body)
+            self.zenegy.raise_for_status_with_details(response)
+
+            content = response.json()
+            data = content.get("data", [])
+
+            if not data:
+                return pd.DataFrame(), pd.DataFrame()
+
+            # Normalize the data with expanded department and user fields
+            df = pd.json_normalize(data, sep='__')
+
+            if df.empty:
+                return pd.DataFrame(), pd.DataFrame()
+
+            # Validate data using schema
+            valid_data, invalid_data = Functions.validate_data(df, AssignedEmployeesToGlobalValueGet)
+            return valid_data, invalid_data
+
+        except Exception as e:
+            raise Exception(f"Failed to get assigned employees for global value: {str(e)}") from e
+
+    def update(self, global_value_uid: UUID, data: Dict[str, Any]) -> requests.Response:
+        """
+        Update a global value by UID.
+
+        Args:
+            global_value_uid (UUID): The global value UID to update
+            data (Dict[str, Any]): The global value data to update
+
+        Returns:
+            requests.Response: The API response
+        """
+        try:
+            # Convert flat dictionary to nested structure based on Pydantic model
+            nested_data = Functions.flat_dict_to_nested_dict(data, CompanyGlobalValueUpdate)
+
+            # Validate the data using Pydantic
+            valid_data = CompanyGlobalValueUpdate(**nested_data)
+            req_body = valid_data.model_dump(by_alias=True, mode='json', exclude_none=True)
+            endpoint = f"{self.endpoint}/{global_value_uid}"
+
+            response = self.zenegy.patch(endpoint=endpoint, json=req_body)
+            self.zenegy.raise_for_status_with_details(response)
+            return response
+
+        except Exception as e:
+            raise Exception(f"Failed to update global value: {str(e)}") from e
+
+    def assign_to_employees(self, global_value_uid: UUID, data: Dict[str, Any]) -> requests.Response:
+        """
+        Assign a global value to multiple employees with optional settings.
+
+        Args:
+            global_value_uid (UUID): The global value UID to assign
+            data (Dict[str, Any]): The assignment data with employee UIDs and optional settings
+
+        Returns:
+            requests.Response: The API response (204 No Content on success)
+        """
+        try:
+            # Convert flat dictionary to nested structure based on Pydantic model
+            nested_data = Functions.flat_dict_to_nested_dict(data, GlobalValueAssign)
+
+            # Validate the data using Pydantic
+            valid_data = GlobalValueAssign(**nested_data)
+            req_body = valid_data.model_dump(by_alias=True, mode='json', exclude_none=True)
+            endpoint = f"{self.endpoint}/{global_value_uid}/assign"
+
+            response = self.zenegy.post(endpoint=endpoint, json=req_body)
+            self.zenegy.raise_for_status_with_details(response)
+            return response
+
+        except Exception as e:
+            raise Exception(f"Failed to assign global value to employees: {str(e)}") from e
+
+    def unassign_from_employees(self, global_value_uid: UUID, employee_uids: List[str]) -> requests.Response:
+        """
+        Unassign a global value from multiple employees.
+
+        Args:
+            global_value_uid (UUID): The global value UID to unassign
+            employee_uids (List[str]): List of employee UIDs to unassign from
+
+        Returns:
+            requests.Response: The API response (204 No Content on success)
+        """
+        try:
+            # API expects a simple Array[string] as body
+            endpoint = f"{self.endpoint}/{global_value_uid}/unassign"
+            req_body = employee_uids
+
+            response = self.zenegy.post(endpoint=endpoint, json=employee_uids)
+            self.zenegy.raise_for_status_with_details(response)
+            return response
+
+        except Exception as e:
+            raise Exception(f"Failed to unassign global value from employees: {str(e)}") from e
+
+    def delete(self, global_value_uid: UUID) -> requests.Response:
+        """
+        Delete a global value.
+
+        Args:
+            global_value_uid (UUID): The global value UID to delete
+
+        Returns:
+            requests.Response: The API response (204 No Content on success)
+        """
+        try:
+            endpoint = f"{self.endpoint}/{global_value_uid}"
+
+            response = self.zenegy.delete(endpoint=endpoint)
+            self.zenegy.raise_for_status_with_details(response)
+            return response
+
+        except Exception as e:
+            raise Exception(f"Failed to delete global value: {str(e)}") from e

brynq_sdk_zenegy/paychecks.py

@@ -0,0 +1,119 @@
+import requests
+from uuid import UUID
+from brynq_sdk_functions import Functions
+from .schemas.employee_pay_checks import (PaycheckUpdate,
+                                          PaycheckCreate,
+                                          PayChecksGet)
+from typing import Dict, Any, Tuple
+import pandas as pd
+from pydantic import ValidationError
+
+
+class PayChecks:
+    """
+    Handles all Employee Pay Check related operations in Zenegy API
+    """
+    def __init__(self, zenegy):
+        """
+        Initialize the Employeepaychecks class.
+
+        Args:
+            zenegy: The Zenegy instance to use for API calls
+        """
+        self.zenegy = zenegy
+        self.endpoint = f"api/companies/{self.zenegy.company_uid}/paychecks/bulk"
+
+    def get(self, employee_uid: UUID) -> Tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        GetPayCheckBasesAsync
+        Args:
+            employee_uid (UUID): The employee uid
+        Returns:
+            Tuple of (valid_data, invalid_data) DataFrames
+        """
+        try:
+            endpoint = f"api/companies/{self.zenegy.company_uid}/employees/{employee_uid}/paychecks"
+            content = self.zenegy.get(endpoint=endpoint)
+
+            # Normalize the response (direct list of dicts with nested objects)
+            df = pd.json_normalize(content, sep='__')
+            if df.empty:
+                return pd.DataFrame(), pd.DataFrame()
+            # Validate against schema
+            valid_data, invalid_data = Functions.validate_data(df, PayChecksGet)
+
+            return valid_data, invalid_data
+        except Exception as e:
+            raise Exception(f"Failed to retrieve pay checks: {str(e)}") from e
+
+    def create(self, employee_uid: UUID, data: Dict[str, Any]) -> requests.Response:
+        """
+        PostPayChecksAsync
+        Args:
+            employee_uid (UUID): The employee uid
+            data (Dict[str, Any]): The data to create the pay check
+        Returns:
+            requests.Response: The response from the API
+        Raises:
+            ValidationError: If the data is invalid
+            Exception: If there is an error in the API call
+        """
+        url = f"{self.zenegy.base_url}/api/companies/{self.zenegy.company_uid}/employees/{employee_uid}/paychecks"
+
+        try:
+            # Validate data using Pydantic schema
+            validated_data = PaycheckCreate(**data)
+            req_body = validated_data.model_dump(by_alias=True,mode='json')
+
+            endpoint = f"api/companies/{self.zenegy.company_uid}/employees/{employee_uid}/paychecks"
+            response = self.zenegy.post(endpoint=endpoint, json=req_body)
+            self.zenegy.raise_for_status_with_details(response)
+            return response
+        except ValidationError as e:
+            raise ValidationError(f"Invalid data: {e.errors()}")
+        except Exception as e:
+            raise Exception(f"Error creating pay check: {str(e)}")
+
+    def update(self, employee_uid: UUID, paycheck_uid: UUID, data: Dict[str, Any]) -> requests.Response:
+        """
+        UpdatePayCheckPerEmployeeAsync
+        Args:
+            employee_uid (UUID): The employee uid
+            paycheck_uid (UUID): The pay check uid
+            data (Dict[str, Any]): The data to update the pay check
+        Returns:
+            requests.Response: The response from the API
+        Raises:
+            ValidationError: If the data is invalid
+            Exception: If there is an error in the API call
+        """
+        try:
+            # Validate data using Pydantic schema
+            validated_data = PaycheckUpdate(**data)
+            req_body = validated_data.model_dump(by_alias=True,mode="json")
+            endpoint = f"api/companies/{self.zenegy.company_uid}/employees/{employee_uid}/paychecks"
+            response = self.zenegy.post(endpoint=endpoint, json=req_body)
+            self.zenegy.raise_for_status_with_details(response)
+            return response
+        except ValidationError as e:
+            raise ValidationError(f"Invalid data: {e.errors()}")
+        except Exception as e:
+            raise Exception(f"Error updating pay check: {str(e)}")
+
+    def delete(self, employee_uid: UUID, pay_check_uid: UUID) -> requests.Response:
+        """
+        DeletePayCheckPerEmployee
+        Args:
+            employee_uid (UUID): The employee uid
+        Args:
+            pay_check_uid (UUID): The pay check uid
+        Returns:
+            requests.Response: The API response
+        """
+        endpoint = f"api/companies/{self.zenegy.company_uid}/employees/{employee_uid}/paychecks/{pay_check_uid}"
+        try:
+            response = self.zenegy.delete(endpoint=endpoint)
+            self.zenegy.raise_for_status_with_details(response)
+            return response
+        except Exception as e:
+            raise Exception(f"Failed to delete pay check: {str(e)}")