brynq-sdk-vplan 1.0.0__tar.gz → 1.2.0__tar.gz

{brynq_sdk_vplan-1.0.0 → brynq_sdk_vplan-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: brynq_sdk_vplan
-Version: 1.0.0
+Version: 1.2.0
 Summary: vPlan wrapper from BrynQ
 Home-page: UNKNOWN
 Author: BrynQ

brynq_sdk_vplan-1.2.0/brynq_sdk_vplan/__init__.py

@@ -0,0 +1,44 @@
+from brynq_sdk_brynq import BrynQ
+from typing import List, Union
+from .get_data import GetData
+from .activity import Activity
+from .item import Item
+from .order import Order
+from .project import Project
+from .resource import Resource
+from .time_tracking import TimeTracking
+from .user import User
+from .leave import Leave
+
+
+class VPlan(BrynQ):
+    def __init__(self, label: Union[str, List], debug: bool = False):
+        """
+        A class to fetch data from the vPlan API. See https://developer.vplan.com/documentation/#tag/General/ for more information
+        """
+        super().__init__()
+        self.headers = self._get_credentials(label)
+        self.post_headers = {**self.headers, 'Content-Type': 'application/json'}
+        self.base_url = 'https://api.vplan.com/v1/'
+        self.get = GetData(self)
+        self.activity = Activity(self)
+        self.item = Item(self)
+        self.order = Order(self)
+        self.project = Project(self)
+        self.resource = Resource(self)
+        self.time_tracking = TimeTracking(self)
+        self.user = User(self)
+        self.leave = Leave(self)
+
+    def _get_credentials(self, label) -> dict:
+        """
+        Retrieve API key and env from the system credentials.
+        Args: label (Union[str, List]): The label or list of labels to get the credentials.
+        Returns: str: The authorization headers
+        """
+        credentials = self.get_system_credential(system='vplan', label=label)
+        headers = {
+            'X-Api-Key': credentials['X-Api-Key'],
+            'X-Api-Env': credentials['X-Api-Env']
+        }
+        return headers

brynq_sdk_vplan-1.2.0/brynq_sdk_vplan/activity.py

@@ -0,0 +1,132 @@
+import requests
+from typing import Union, List
+import warnings
+import json
+from .get_data import GetData
+
+
+class Activity:
+    def __init__(self, vplan):
+        """
+        Initialize the GetData class.
+        Args: vplan: contains the vplan object with the headers and base_url
+        """
+        self.vplan = vplan
+        self.get_data = GetData(vplan)
+
+    def get_activity_list(self, filter: str = None, show: str = None, hide: str = None):
+        """
+        Get all the activitys from vPlan: https://developer.vplan.com/documentation/#tag/activity/paths/~1activity/get
+        Args:   filter (str, optional): On the list endpoints it is possible to filter the result set given. To apply a filter use the filter query parameter with the format: field:operator:value
+                                        Example: ?filter=created_at:gt:2020-09-26,and,(id:not:starts_with:0000,or,id:contains:FFFF)
+
+                                        Colon : is the separator between the field, operator(s) and value.
+                                        Comma , can be used to combine filter statements by using ,and, or ,or,.
+                                        Braces (...) can be used to group filter statements.
+
+                                        The following operators are supported
+
+                                        operator	description
+                                        eq	        equal to the given value
+                                        gt	        greater than the given value
+                                        gte	        greater than or equal to the given value
+                                        lt	        lesser than the given value
+                                        lte	        lesser than or equal to the given value
+                                        not	        negation of the operator that follows it
+                                        contains	has occurrence of the given value
+                                        starts_with	starts with the given value
+                                        end_with	ends with the given value
+
+                                        warning: Currently the comma , and colon : are not supported within the filter value
+
+                show (str, optional): On the list endpoints it is possible to select the fields that should be returned. To apply a show use the show query parameter with the format: field1,field2,field3
+                hide (str, optional): On the list endpoints it is possible to hide the fields that should not be returned. To apply a hide use the hide query parameter with the format: field1,field2,field3
+
+        Returns: pd.DataFrame: The fetched data as a pandas DataFrame.
+        """
+        df = self.get_data.get_data(endpoint='activity', filter=filter, show=show, hide=hide)
+        return df
+
+    def post_activity(self, data: dict) -> requests.Response:
+        """
+        Create a new activity in vPlan: https://developer.vplan.com/documentation/#tag/activity/paths/~1activity/post
+
+        This method constructs a request URL based on the endpoint and sends a POST request
+        to the vPlan API with the provided data.
+
+        Args:   endpoint (str): The name of the endpoint to create a new activity in.
+                data (dict): The data to create the new activity with.
+
+        Returns: requests.Response: The response from the vPlan API.
+        """
+        required_fields = ['code', 'description']
+        allowed_fields = ['resource_type', 'default_duration', 'external_ref', 'archive']
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f"{self.vplan.base_url}activity"
+
+        base_body = {
+            "code": data['code'],
+            "description": data['description']
+        }
+        # Add fields that you want to update a dict (adding to body itself is too much text)
+        base_body.update({"resource_type": data['resource_type']}) if 'resource_type' in data else base_body
+        base_body.update({"default_duration": data['default_duration']}) if 'default_duration' in data else base_body
+        base_body.update({"external_ref": data['external_ref']}) if 'external_ref' in data else base_body
+        base_body.update({"archive": data['archive']}) if 'archive' in data else base_body
+
+        response = requests.request('POST', url, headers=self.vplan.post_headers, data=base_body)
+        return response
+
+    def update_activity(self, activity_id: str, data: dict) -> requests.Response:
+        """
+        Update an existing activity in vPlan: https://developer.vplan.com/documentation/#tag/activity/paths/~1activity~1%7Bactivity_id%7D/put
+
+        This method constructs a request URL based on the endpoint and sends a POST request
+        to the vPlan API with the provided data.
+
+        Args:   endpoint (str): The name of the endpoint to create a new activity in.
+                data (dict): The data to create the new activity with.
+
+        Returns: requests.Response: The response from the vPlan API.
+        """
+        required_fields = ['code', 'description']
+        allowed_fields = ['resource_type', 'default_duration', 'external_ref', 'archive']
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f"{self.vplan.base_url}activity/{activity_id}"
+
+        base_body = {
+            "code": data['code'],
+            "description": data['description']
+        }
+        # Add fields that you want to update a dict (adding to body itself is too much text)
+        base_body.update({"resource_type": data['resource_type']}) if 'resource_type' in data else base_body
+        base_body.update({"default_duration": data['default_duration']}) if 'default_duration' in data else base_body
+        base_body.update({"external_ref": data['external_ref']}) if 'external_ref' in data else base_body
+        base_body.update({"archive": data['archive']}) if 'archive' in data else base_body
+
+        response = requests.request('PUT', url, headers=self.vplan.post_headers, json=base_body)
+        return response
+
+    def delete_activity(self, activity_id):
+        """
+        Delete an existing activity in vPlan: https://developer.vplan.com/documentation/#tag/activity/paths/~1activity~1%7Bactivity_id%7D/delete
+        This method constructs a request URL based on the endpoint and sends a DELETE request to the vPlan API.
+        """
+        url = f"{self.vplan.base_url}activity/{activity_id}"
+        response = requests.request('DELETE', url, headers=self.vplan.headers)
+        return response
+
+    @staticmethod
+    def __check_fields(data: Union[dict, List], required_fields: List, allowed_fields: List):
+        if isinstance(data, dict):
+            data = data.keys()
+
+        for field in data:
+            if field not in allowed_fields and field not in required_fields:
+                warnings.warn('Field {field} is not implemented. Optional fields are: {allowed_fields}'.format(field=field, allowed_fields=tuple(allowed_fields)))
+
+        for field in required_fields:
+            if field not in data:
+                raise ValueError('Field {field} is required. Required fields are: {required_fields}'.format(field=field, required_fields=tuple(required_fields)))

brynq_sdk_vplan-1.2.0/brynq_sdk_vplan/get_data.py

@@ -0,0 +1,86 @@
+import pandas as pd
+from typing import List, Any
+import requests
+
+
+class GetData:
+    def __init__(self, vplan):
+        """
+        Initialize the GetData class.
+        Args: vplan: contains the vplan object with the headers and base_url
+        """
+        self.vplan = vplan
+
+    def get_data(self, endpoint: str, limit: int = 1000, filter: str = None, with_array: str = None, show: str = None, hide: str = None, archived: bool = False) -> pd.DataFrame:
+        """
+        Fetch data from a specified table from vPlan
+
+        This method constructs a request URL based on the table name and optional filter,
+        sends a request to the vPlan API, parses the JSON response, and converts it
+        to a pandas DataFrame. The DataFrame columns are cleaned to remove unnecessary
+        characters and duplicate columns are handled.
+
+        Args:   endpoint (str): The name of the endpoint to fetch data from.
+                filter (str, optional): On the list endpoints it is possible to filter the result set given. To apply a filter use the filter query parameter with the format: field:operator:value
+                                        Example: ?filter=created_at:gt:2020-09-26,and,(id:not:starts_with:0000,or,id:contains:FFFF)
+
+                                        Colon : is the separator between the field, operator(s) and value.
+                                        Comma , can be used to combine filter statements by using ,and, or ,or,.
+                                        Braces (...) can be used to group filter statements.
+
+                                        The following operators are supported
+
+                                        operator	description
+                                        eq	        equal to the given value
+                                        gt	        greater than the given value
+                                        gte	        greater than or equal to the given value
+                                        lt	        lesser than the given value
+                                        lte	        lesser than or equal to the given value
+                                        not	        negation of the operator that follows it
+                                        contains	has occurrence of the given value
+                                        starts_with	starts with the given value
+                                        end_with	ends with the given value
+
+                                        warning: Currently the comma , and colon : are not supported within the filter value
+
+                show (str, optional): On the list endpoints it is possible to select the fields that should be returned. To apply a show use the show query parameter with the format: field1,field2,field3
+                hide (str, optional): On the list endpoints it is possible to hide the fields that should not be returned. To apply a hide use the hide query parameter with the format: field1,field2,field3
+
+        Returns: pd.DataFrame: The fetched data as a pandas DataFrame.
+        """
+        # Initial URL with subscription-key
+        url = f"{self.vplan.base_url}{endpoint}?"
+        if limit:
+            url += f'limit={limit}&'
+        if filter:
+            url += f'filter={filter}&'
+        if with_array:
+            url += f'with={with_array}&'
+        if show:
+            url += f'show={show}&'
+        if hide:
+            url += f'hide={hide}&'
+        if archived:
+            url += f'archived={archived}&'
+
+        all_data = []
+        offset = 0
+        received = 0
+        while True:
+            final_url = f'{url}offset={offset}'
+            response = requests.get(url=final_url, headers=self.vplan.headers)
+            response.raise_for_status()
+            result = response.json()
+            data = result.get('data', result)
+            all_data.extend(data)
+
+            # Determine if we need to continue fetching data
+            count = result.get('count', 0)
+            received += len(data)
+            offset += limit
+            if received >= count:
+                break
+
+
+        df = pd.DataFrame(all_data)
+        return df

brynq_sdk_vplan-1.2.0/brynq_sdk_vplan/item.py

@@ -0,0 +1,141 @@
+import requests
+from typing import Union, List
+import warnings
+import json
+from .get_data import GetData
+
+
+class Item:
+    def __init__(self, vplan):
+        """
+        Initialize the GetData class.
+        Args: vplan: contains the vplan object with the headers and base_url
+        """
+        self.vplan = vplan
+        self.get_data = GetData(vplan)
+
+    def get_item_list(self, filter: str = None, show: str = None, hide: str = None):
+        """
+        Get all the items from vPlan: https://developer.vplan.com/documentation/#tag/item/paths/~1item/get
+        Args:   filter (str, optional): On the list endpoints it is possible to filter the result set given. To apply a filter use the filter query parameter with the format: field:operator:value
+                                        Example: ?filter=created_at:gt:2020-09-26,and,(id:not:starts_with:0000,or,id:contains:FFFF)
+
+                                        Colon : is the separator between the field, operator(s) and value.
+                                        Comma , can be used to combine filter statements by using ,and, or ,or,.
+                                        Braces (...) can be used to group filter statements.
+
+                                        The following operators are supported
+
+                                        operator	description
+                                        eq	        equal to the given value
+                                        gt	        greater than the given value
+                                        gte	        greater than or equal to the given value
+                                        lt	        lesser than the given value
+                                        lte	        lesser than or equal to the given value
+                                        not	        negation of the operator that follows it
+                                        contains	has occurrence of the given value
+                                        starts_with	starts with the given value
+                                        end_with	ends with the given value
+
+                                        warning: Currently the comma , and colon : are not supported within the filter value
+
+                show (str, optional): On the list endpoints it is possible to select the fields that should be returned. To apply a show use the show query parameter with the format: field1,field2,field3
+                hide (str, optional): On the list endpoints it is possible to hide the fields that should not be returned. To apply a hide use the hide query parameter with the format: field1,field2,field3
+
+        Returns: pd.DataFrame: The fetched data as a pandas DataFrame.
+        """
+        df = self.get_data.get_data(endpoint='item', filter=filter, show=show, hide=hide)
+        return df
+
+    def post_item(self, data: dict) -> requests.Response:
+        """
+        Create a new item in vPlan: https://developer.vplan.com/documentation/#tag/item/paths/~1item/post
+
+        This method constructs a request URL based on the endpoint and sends a POST request
+        to the vPlan API with the provided data.
+
+        Args:   endpoint (str): The name of the endpoint to create a new item in.
+                data (dict): The data to create the new item with.
+
+        Returns: requests.Response: The response from the vPlan API.
+        """
+        required_fields = ['code', 'description']
+        allowed_fields = ['stock_management', 'unit', 'type', 'location', 'note', 'external_ref']
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f"{self.vplan.base_url}item"
+
+        base_body = {
+            "code": data['code'],
+            "description": data['description']
+        }
+        # Add fields that you want to update a dict (adding to body itself is too much text)
+        base_body.update({"code": data['code']}) if 'code' in data else base_body
+        base_body.update({"description": data['description']}) if 'description' in data else base_body
+        base_body.update({"stock_management": data['stock_management']}) if 'stock_management' in data else base_body
+        base_body.update({"unit": data['unit']}) if 'unit' in data else base_body
+        base_body.update({"type": data['type']}) if 'type' in data else base_body
+        base_body.update({"location": data['location']}) if 'location' in data else base_body
+        base_body.update({"note": data['note']}) if 'note' in data else base_body
+        base_body.update({"external_ref": data['external_ref']}) if 'external_ref' in data else base_body
+
+        response = requests.request('POST', url, headers=self.vplan.post_headers, data=base_body)
+        return response
+
+    def update_item(self, item_id: str, data: dict) -> requests.Response:
+        """
+        Update an existing item in vPlan: https://developer.vplan.com/documentation/#tag/item/paths/~1item~1%7Bitem_id%7D/put
+
+        This method constructs a request URL based on the endpoint and sends a POST request
+        to the vPlan API with the provided data.
+
+        Args:   endpoint (str): The name of the endpoint to create a new item in.
+                data (dict): The data to create the new item with.
+
+        Returns: requests.Response: The response from the vPlan API.
+        """
+        required_fields = ['code', 'description']
+        allowed_fields = ['stock_management', 'unit', 'type', 'location', 'note', 'external_ref']
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f"{self.vplan.base_url}item/{item_id}"
+
+        base_body = {
+            "code": data['code'],
+            "description": data['description']
+        }
+        # Add fields that you want to update a dict (adding to body itself is too much text)
+        base_body.update({"code": data['code']}) if 'code' in data else base_body
+        base_body.update({"description": data['description']}) if 'description' in data else base_body
+        base_body.update({"stock_management": data['stock_management']}) if 'stock_management' in data else base_body
+        base_body.update({"unit": data['unit']}) if 'unit' in data else base_body
+        base_body.update({"type": data['type']}) if 'type' in data else base_body
+        base_body.update({"location": data['location']}) if 'location' in data else base_body
+        base_body.update({"note": data['note']}) if 'note' in data else base_body
+        base_body.update({"external_ref": data['external_ref']}) if 'external_ref' in data else base_body
+
+        response = requests.request('PUT', url, headers=self.vplan.post_headers, json=base_body)
+        return response
+
+    def delete_item(self, item_id):
+        """
+        Delete an existing item in vPlan: https://developer.vplan.com/documentation/#tag/Item/paths/~1item~1%7Bitem_id%7D/delete
+        This method constructs a request URL based on the endpoint and sends a DELETE request to the vPlan API.
+        """
+        url = f"{self.vplan.base_url}item/{item_id}"
+        response = requests.request('DELETE', url, headers=self.vplan.headers)
+        return response
+
+
+    @staticmethod
+    def __check_fields(data: Union[dict, List], required_fields: List, allowed_fields: List):
+        if isinstance(data, dict):
+            data = data.keys()
+
+        for field in data:
+            if field not in allowed_fields and field not in required_fields:
+                warnings.warn('Field {field} is not implemented. Optional fields are: {allowed_fields}'.format(field=field, allowed_fields=tuple(allowed_fields)))
+
+        for field in required_fields:
+            if field not in data:
+                raise ValueError('Field {field} is required. Required fields are: {required_fields}'.format(field=field, required_fields=tuple(required_fields)))

brynq_sdk_vplan-1.2.0/brynq_sdk_vplan/leave.py

@@ -0,0 +1,110 @@
+import requests
+from typing import Union, List, Any
+import warnings
+import json
+from .get_data import GetData
+
+
+class Leave:
+    def __init__(self, vplan):
+        """
+        Initialize the GetData class.
+        Args: vplan: contains the vplan object with the headers and base_url
+        """
+        self.vplan = vplan
+        self.get_data = GetData(vplan)
+
+    def get_leave(self, resource_id: str) -> requests.Response:
+        """
+        There is no documentation for this method available
+
+        This method constructs a request URL based on the endpoint and sends a GET request
+        to the vPlan API.
+
+        Args: resource_id (str): The id of the resource to get the leave from
+
+        Returns: requests.Response: The response from the vPlan API.
+        """
+        url = f"{self.vplan.base_url}resource/{resource_id}/schedule_deviation"
+        response = requests.request('GET', url, headers=self.vplan.headers)
+        return response
+
+    def post_leave(self, resource_id: str, data: dict) -> requests.Response:
+        """
+        There is no documentation for this method available
+
+        This method constructs a request URL based on the endpoint and sends a POST request
+        to the vPlan API with the provided data.
+
+        Args:   resource_id (str): The resource id of the employee to add the leave to
+                data (dict): The data to create the new order with.
+
+        Returns: requests.Response: The response from the vPlan API.
+        """
+        required_fields = ['type', 'time', 'description', 'start_date', 'end_date']
+        allowed_fields = []
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f"{self.vplan.base_url}resource/{resource_id}/schedule_deviation"
+        base_body = json.dumps({
+            "type": data['type'],
+            "time": data['time'],
+            "description": data['description'],
+            "start_date": data['start_date'],
+            "end_date": data['end_date']
+        })
+        response = requests.request('POST', url, headers=self.vplan.post_headers, data=base_body)
+        return response
+
+    def update_leave(self, resource_id: str, leave_id: str, data: dict) -> requests.Response:
+        """
+        There is no documentation for this method available
+
+        This method constructs a request URL based on the endpoint and sends a POST request
+        to the vPlan API with the provided data.
+
+        Args:   resource_id (str): The resource id of the employee to add the leave to
+                leave_id (str): The id of the leave to update
+                data (dict): The data to create the new order with.
+
+        Returns: requests.Response: The response from the vPlan API.
+        """
+        required_fields = ['type', 'time', 'description', 'start_date', 'end_date']
+        allowed_fields = []
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f"{self.vplan.base_url}resource/{resource_id}/schedule_deviation/{leave_id}"
+        base_body = json.dumps({
+            "type": data['type'],
+            "time": data['time'],
+            "description": data['description'],
+            "start_date": data['start_date'],
+            "end_date": data['end_date']
+        })
+        response = requests.request('PUT', url, headers=self.vplan.post_headers, json=base_body)
+        return response
+
+    def delete_leave(self, resource_id: str, leave_id: str):
+        """
+        There is no documentation for this method available
+        This method constructs a request URL based on the endpoint and sends a DELETE request to the vPlan API.
+        :param resource_id: The resource id of the employee to delete the the leave to
+        :param leave_id: The id of the leave to delete
+        """
+        url = f"{self.vplan.base_url}resource/{resource_id}/schedule_deviation/{leave_id}"
+        response = requests.request('DELETE', url, headers=self.vplan.headers)
+        return response
+
+
+    @staticmethod
+    def __check_fields(data: Union[dict, List], required_fields: List, allowed_fields: List):
+        if isinstance(data, dict):
+            data = data.keys()
+
+        for field in data:
+            if field not in allowed_fields and field not in required_fields:
+                warnings.warn('Field {field} is not implemented. Optional fields are: {allowed_fields}'.format(field=field, allowed_fields=tuple(allowed_fields)))
+
+        for field in required_fields:
+            if field not in data:
+                raise ValueError('Field {field} is required. Required fields are: {required_fields}'.format(field=field, required_fields=tuple(required_fields)))