brynq-sdk-vplan 2.0.1__py3-none-any.whl

brynq_sdk_vplan/__init__.py

@@ -0,0 +1,46 @@
+from brynq_sdk_brynq import BrynQ
+from typing import List, Union, Literal, Optional
+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, system_type: Optional[Literal['source', 'target']] = None, 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.timeout = 3600
+        self.headers = self._get_credentials(system_type)
+        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, system_type) -> 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.interfaces.credentials.get(system="vplan", system_type=system_type)
+        credentials = credentials.get('data')
+        headers = {
+            'X-Api-Key': credentials['X-Api-Key'],
+            'X-Api-Env': credentials['X-Api-Env']
+        }
+        return headers

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, timeout=self.vplan.timeout)
+        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, timeout=self.vplan.timeout)
+        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, timeout=self.vplan.timeout)
+        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/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/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, timeout=self.vplan.timeout)
+        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, data=json.dumps(base_body), timeout=self.vplan.timeout)
+        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, timeout=self.vplan.timeout)
+        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/leave.py

@@ -0,0 +1,109 @@
+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:
+        """
+        Get leave data for a specific resource.
+
+        Args:
+            resource_id (str): The id of the resource to get the leave from.
+
+        Returns:
+            requests.Response: The response from the vPlan API containing schedule deviations.
+        """
+        url = f"{self.vplan.base_url}resource/{resource_id}?with=schedule_deviations"
+        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, timeout=self.vplan.timeout)
+        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, data=base_body, timeout=self.vplan.timeout)
+        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, timeout=self.vplan.timeout)
+        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/order.py

@@ -0,0 +1,166 @@
+import requests
+from typing import Union, List, Any
+import warnings
+import json
+from .get_data import GetData
+
+
+class Order:
+    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_order_list(self, filter: str = None, with_array: str = None, show: str = None, hide: str = None):
+        """
+        Get all the orders from vPlan: https://developer.vplan.com/documentation/#tag/Order/paths/~1order/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
+
+                with_array (list, optional): object(s) included in the dataset, Possible options are: address, item, order_rows, collection, project, relation, warehouse, board, contact, user, activity, order, item, project, relation, warehouse, supplies_order_rows
+                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='order', filter=filter, with_array=with_array, show=show, hide=hide)
+        return df
+
+    def post_order(self, data: dict) -> requests.Response:
+        """
+        Create a new order in vPlan: https://developer.vplan.com/documentation/#tag/order/paths/~1order/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 order in.
+                data (dict): The data to create the new order with.
+
+        Returns: requests.Response: The response from the vPlan API.
+        """
+        required_fields = ['type', 'code', 'description']
+        allowed_fields = ['quantity', 'external_url', 'sub_type', 'status', 'note', 'contact', 'relation_ref', 'date', 'desired_date', 'promised_date',
+                          'delivered_date', 'collection_id', 'item_id', 'project_id', 'relation_id', 'warehouse_id', 'external_ref', 'board_id']
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f"{self.vplan.base_url}order"
+
+        base_body = {
+            "type": data['type'],
+            "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({"quantity": data['quantity']}) if 'quantity' in data else base_body
+        base_body.update({"external_url": data['external_url']}) if 'external_url' in data else base_body
+        base_body.update({"sub_type": data['sub_type']}) if 'sub_type' in data else base_body
+        base_body.update({"status": data['status']}) if 'status' in data else base_body
+        base_body.update({"note": data['note']}) if 'note' in data else base_body
+        base_body.update({"contact": data['contact']}) if 'contact' in data else base_body
+        base_body.update({"relation_ref": data['relation_ref']}) if 'relation_ref' in data else base_body
+        base_body.update({"date": data['date']}) if 'date' in data else base_body
+        base_body.update({"desired_date": data['desired_date']}) if 'desired_date' in data else base_body
+        base_body.update({"promised_date": data['promised_date']}) if 'promised_date' in data else base_body
+        base_body.update({"delivered_date": data['delivered_date']}) if 'delivered_date' in data else base_body
+        base_body.update({"collection_id": data['collection_id']}) if 'collection_id' in data else base_body
+        base_body.update({"item_id": data['item_id']}) if 'item_id' in data else base_body
+        base_body.update({"project_id": data['project_id']}) if 'project_id' in data else base_body
+        base_body.update({"relation_id": data['relation_id']}) if 'relation_id' in data else base_body
+        base_body.update({"warehouse_id": data['warehouse_id']}) if 'warehouse_id' in data else base_body
+        base_body.update({"external_ref": data['external_ref']}) if 'external_ref' in data else base_body
+        base_body.update({"board_id": data['board_id']}) if 'board_id' in data else base_body
+
+        response = requests.request('POST', url, headers=self.vplan.post_headers, data=json.dumps(base_body), timeout=self.vplan.timeout)
+        return response
+
+    def update_order(self, order_id: str, data: dict) -> requests.Response:
+        """
+        Update an existing order in vPlan: https://developer.vplan.com/documentation/#tag/order/paths/~1order~1%7Border_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 order in.
+                data (dict): The data to create the new order with.
+
+        Returns: requests.Response: The response from the vPlan API.
+        """
+        required_fields = []
+        allowed_fields = ['description' 'type', 'code', 'quantity', 'external_url', 'sub_type', 'status', 'note', 'contact', 'relation_ref', 'date', 'desired_date',
+                          'promised_date', 'delivered_date', 'collection_id', 'item_id', 'project_id', 'relation_id', 'warehouse_id', 'external_ref', 'board_id']
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f"{self.vplan.base_url}order/{order_id}"
+
+        base_body = {
+        }
+        # 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({"type": data['type']}) if 'type' in data else base_body
+        base_body.update({"quantity": data['quantity']}) if 'quantity' in data else base_body
+        base_body.update({"external_url": data['external_url']}) if 'external_url' in data else base_body
+        base_body.update({"sub_type": data['sub_type']}) if 'sub_type' in data else base_body
+        base_body.update({"status": data['status']}) if 'status' in data else base_body
+        base_body.update({"note": data['note']}) if 'note' in data else base_body
+        base_body.update({"contact": data['contact']}) if 'contact' in data else base_body
+        base_body.update({"relation_ref": data['relation_ref']}) if 'relation_ref' in data else base_body
+        base_body.update({"date": data['date']}) if 'date' in data else base_body
+        base_body.update({"desired_date": data['desired_date']}) if 'desired_date' in data else base_body
+        base_body.update({"promised_date": data['promised_date']}) if 'promised_date' in data else base_body
+        base_body.update({"delivered_date": data['delivered_date']}) if 'delivered_date' in data else base_body
+        base_body.update({"collection_id": data['collection_id']}) if 'collection_id' in data else base_body
+        base_body.update({"item_id": data['item_id']}) if 'item_id' in data else base_body
+        base_body.update({"project_id": data['project_id']}) if 'project_id' in data else base_body
+        base_body.update({"relation_id": data['relation_id']}) if 'relation_id' in data else base_body
+        base_body.update({"warehouse_id": data['warehouse_id']}) if 'warehouse_id' in data else base_body
+        base_body.update({"external_ref": data['external_ref']}) if 'external_ref' in data else base_body
+        base_body.update({"board_id": data['board_id']}) if 'board_id' in data else base_body
+
+        response = requests.request('PUT', url, headers=self.vplan.post_headers, data=json.dumps(base_body), timeout=self.vplan.timeout)
+        return response
+
+    def delete_order(self, order_id):
+        """
+        Delete an existing order in vPlan: https://developer.vplan.com/documentation/#tag/order/paths/~1order~1%7Border_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}order/{order_id}"
+        response = requests.request('DELETE', url, headers=self.vplan.headers, timeout=self.vplan.timeout)
+        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/project.py

@@ -0,0 +1,129 @@
+import requests
+from typing import Union, List
+import warnings
+import json
+from .get_data import GetData
+
+
+class Project:
+    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_project_list(self, filter: str = None, show: str = None, hide: str = None):
+        """
+        Get all the projects from vPlan: https://developer.vplan.com/documentation/#tag/Project/paths/~1project/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='project', filter=filter, show=show, hide=hide)
+        return df
+
+    def post_project(self, data: dict) -> requests.Response:
+        """
+        Create a new project in vPlan: https://developer.vplan.com/documentation/#tag/Project/paths/~1project/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 project in.
+                data (dict): The data to create the new project with.
+
+        Returns: requests.Response: The response from the vPlan API.
+        """
+        required_fields = ['name']
+        allowed_fields = ['code', 'description', 'external_ref']
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f"{self.vplan.base_url}project"
+
+        base_body = {
+            "name": data['name']
+        }
+
+        # 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({"external_ref": data['external_ref']}) if 'external_ref' in data else base_body
+
+        response = requests.request('POST', url, headers=self.vplan.post_headers, data=json.dumps(base_body), timeout=self.vplan.timeout)
+        return response
+
+    def update_project(self, project_id: str, data: dict) -> requests.Response:
+        """
+        Update an existing project in vPlan: https://developer.vplan.com/documentation/#tag/Project/paths/~1project~1%7Bproject_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 project in.
+                data (dict): The data to create the new project with.
+
+        Returns: requests.Response: The response from the vPlan API.
+        """
+        required_fields = ['name']
+        allowed_fields = ['code', 'description', 'external_ref']
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f"{self.vplan.base_url}project/{project_id}"
+
+        base_body = {
+            "name": data['name']
+        }
+        # 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({"external_ref": data['external_ref']}) if 'external_ref' in data else base_body
+
+        response = requests.request('PUT', url, headers=self.vplan.post_headers, data=json.dumps(base_body), timeout=self.vplan.timeout)
+        return response
+
+    def delete_project(self, project_id):
+        """
+        Delete an existing project in vPlan: https://developer.vplan.com/documentation/#tag/Project/paths/~1project~1%7Bproject_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}project/{project_id}"
+        response = requests.request('DELETE', url, headers=self.vplan.headers, timeout=self.vplan.timeout)
+        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/resource.py

@@ -0,0 +1,142 @@
+import requests
+from typing import Union, List
+import warnings
+import json
+from .get_data import GetData
+
+
+class Resource:
+    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_resource_list(self, filter: str = None, show: str = None, hide: str = None, archived: bool = False):
+        """
+        Get all the resources from vPlan: https://developer.vplan.com/documentation/#tag/Resource/paths/~1resource/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='resource', filter=filter, show=show, hide=hide, archived=archived)
+        return df
+
+    def post_resource(self, data: dict) -> requests.Response:
+        """
+        Create a new resource in vPlan: https://developer.vplan.com/documentation/#tag/Resource/paths/~1resource/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 resource in.
+                data (dict): The data to create the new resource with.
+
+        Returns: requests.Response: The response from the vPlan API.
+        """
+        required_fields = ['name']
+        allowed_fields = ['type', 'start_date', 'workdays', 'description', 'end_date', 'integration_schedule', 'avatar', 'color_hex', 'external_ref', 'archive']
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f"{self.vplan.base_url}resource"
+
+        base_body = {
+            "name": data['name']
+        }
+        # Add fields that you want to update a dict (adding to body itself is too much text)
+        base_body.update({"type": data['type']}) if 'type' in data else base_body
+        base_body.update({"start_date": data['start_date']}) if 'start_date' in data else base_body
+        base_body.update({"workdays": eval(data['workdays'])}) if 'workdays' in data else base_body
+        base_body.update({"description": data['description']}) if 'description' in data else base_body
+        base_body.update({"end_date": data['end_date']}) if 'end_date' in data else base_body
+        base_body.update({"integration_schedule": data['integration_schedule']}) if 'integration_schedule' in data else base_body
+        base_body.update({"avatar": data['avatar']}) if 'avatar' in data else base_body
+        base_body.update({"color_hex": data['color_hex']}) if 'color_hex' 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=json.dumps(base_body), timeout=self.vplan.timeout)
+        return response
+
+    def update_resource(self, resource_id: str, data: dict) -> requests.Response:
+        """
+        Update an existing resource in vPlan: https://developer.vplan.com/documentation/#tag/Resource/paths/~1resource/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 resource in.
+                data (dict): The data to create the new resource with.
+
+        Returns: requests.Response: The response from the vPlan API.
+        """
+        required_fields = []
+        allowed_fields = ['name', 'type', 'start_date', 'workdays', 'description', 'end_date', 'integration_schedule', 'avatar', 'color_hex', 'external_ref', 'archive']
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f"{self.vplan.base_url}resource/{resource_id}"
+
+        base_body = {}
+
+        # Add fields that you want to update a dict (adding to body itself is too much text)
+        base_body.update({"name": data['name']}) if 'name' in data else base_body
+        base_body.update({"type": data['type']}) if 'type' in data else base_body
+        base_body.update({"start_date": data['start_date']}) if 'start_date' in data else base_body
+        base_body.update({"workdays": eval(data['workdays'])}) if 'workdays' in data else base_body
+        base_body.update({"description": data['description']}) if 'description' in data else base_body
+        base_body.update({"end_date": data['end_date']}) if 'end_date' in data else base_body
+        base_body.update({"integration_schedule": data['integration_schedule']}) if 'integration_schedule' in data else base_body
+        base_body.update({"avatar": data['avatar']}) if 'avatar' in data else base_body
+        base_body.update({"color_hex": data['color_hex']}) if 'color_hex' 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, data=json.dumps(base_body), timeout=self.vplan.timeout)
+        return response
+
+    def delete_resource(self, resource_id):
+        """
+        Delete an existing resource in vPlan: https://developer.vplan.com/documentation/#tag/Resource/paths/~1resource~1%7Bresource_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}resource/{resource_id}"
+        response = requests.request('DELETE', url, headers=self.vplan.headers, timeout=self.vplan.timeout)
+        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/time_tracking.py

@@ -0,0 +1,144 @@
+import requests
+from typing import Union, List
+import warnings
+import json
+from .get_data import GetData
+
+
+class TimeTracking:
+    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_time_tracking_list(self, filter: str = None, show: str = None, hide: str = None):
+        """
+        Get all the time records from vPlan: https://developer.vplan.com/documentation/#tag/Time-Tracking/paths/~1time_tracking/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='time_tracking', filter=filter, show=show, hide=hide)
+        return df
+
+    def post_time_tracking(self, data: dict) -> requests.Response:
+        """
+        Create a new time record in vPlan: https://developer.vplan.com/documentation/#tag/Time-Tracking/paths/~1time_tracking/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 time record in.
+                data (dict): The data to create the new time record with.
+
+        Returns: requests.Response: The response from the vPlan API.
+        """
+        required_fields = ['activity_id', 'start']
+        allowed_fields = ['card_id', 'end', 'duration', 'status', 'user_id', 'note', 'locked', 'synchronized_at', 'external_ref', 'external_note', 'external_failed']
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f"{self.vplan.base_url}time_tracking"
+
+        base_body = {
+            "activity_id": data['activity_id'],
+            "start": data['start']
+        }
+        # Add fields that you want to update a dict (adding to body itself is too much text)
+        base_body.update({"card_id": data['card_id']}) if 'card_id' in data else base_body
+        base_body.update({"end": data['end']}) if 'end' in data else base_body
+        base_body.update({"duration": data['duration']}) if 'duration' in data else base_body
+        base_body.update({"status": data['status']}) if 'status' in data else base_body
+        base_body.update({"user_id": data['user_id']}) if 'user_id' in data else base_body
+        base_body.update({"note": data['note']}) if 'note' in data else base_body
+        base_body.update({"locked": data['locked']}) if 'locked' in data else base_body
+        base_body.update({"synchronized_at": data['synchronized_at']}) if 'synchronized_at' in data else base_body
+        base_body.update({"external_ref": data['external_ref']}) if 'external_ref' in data else base_body
+        base_body.update({"external_note": data['external_note']}) if 'external_note' in data else base_body
+        base_body.update({"external_failed": data['external_failed']}) if 'external_failed' in data else base_body
+
+        response = requests.request('POST', url, headers=self.vplan.post_headers, data=base_body, timeout=self.vplan.timeout)
+        return response
+
+    def update_time_tracking(self, time_tracking_id: str, data: dict) -> requests.Response:
+        """
+        Update an existing time record in vPlan: https://developer.vplan.com/documentation/#tag/Time-Tracking/paths/~1time_tracking~1%7Btime_tracking_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 time record in.
+                data (dict): The data to create the new time record with.
+
+        Returns: requests.Response: The response from the vPlan API.
+        """
+        required_fields = []
+        allowed_fields = ['activity_id', 'start', 'card_id', 'end', 'duration', 'status', 'user_id', 'note', 'locked', 'synchronized_at', 'external_ref', 'external_note', 'external_failed']
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f"{self.vplan.base_url}time_tracking/{time_tracking_id}"
+
+        base_body = {
+        }
+        # Add fields that you want to update a dict (adding to body itself is too much text)
+        base_body.update({"activity_id": data['activity_id']}) if 'activity_id' in data else base_body
+        base_body.update({"start": data['start']}) if 'start' in data else base_body
+        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, timeout=self.vplan.timeout)
+        return response
+
+    def delete_time_tracking(self, time_tracking_id):
+        """
+        Delete an existing time record in vPlan: https://developer.vplan.com/documentation/#tag/Time-Tracking/paths/~1time_tracking~1%7Btime_tracking_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}time_tracking/{time_tracking_id}"
+        response = requests.request('DELETE', url, headers=self.vplan.headers, timeout=self.vplan.timeout)
+        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/user.py

@@ -0,0 +1,141 @@
+import requests
+from typing import Union, List
+import warnings
+import json
+from .get_data import GetData
+
+
+class User:
+    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_user_list(self, filter: str = None, show: str = None, hide: str = None):
+        """
+        Get all the users from vPlan: https://developer.vplan.com/documentation/#tag/user/paths/~1user/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='user', filter=filter, show=show, hide=hide)
+        return df
+
+    def post_user(self, data: dict) -> requests.Response:
+        """
+        Create a new user in vPlan: https://developer.vplan.com/documentation/#tag/user/paths/~1user/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 user in.
+                data (dict): The data to create the new user 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}user"
+
+        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, timeout=self.vplan.timeout)
+        return response
+
+    def update_user(self, user_id: str, data: dict) -> requests.Response:
+        """
+        Update an existing user in vPlan: https://developer.vplan.com/documentation/#tag/user/paths/~1user~1%7Buser_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 user in.
+                data (dict): The data to create the new user 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}user/{user_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, timeout=self.vplan.timeout)
+        return response
+
+    def delete_user(self, user_id):
+        """
+        Delete an existing user in vPlan: https://developer.vplan.com/documentation/#tag/user/paths/~1user~1%7Buser_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}user/{user_id}"
+        response = requests.request('DELETE', url, headers=self.vplan.headers, timeout=self.vplan.timeout)
+        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-2.0.1.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: brynq_sdk_vplan
+Version: 2.0.1
+Summary: vPlan wrapper from BrynQ
+Author: BrynQ
+Author-email: support@brynq.com
+License: BrynQ License
+Requires-Dist: brynq-sdk-brynq<5,>=4
+Requires-Dist: pandas<3,>=2
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+vPlan wrapper from BrynQ

brynq_sdk_vplan-2.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+brynq_sdk_vplan/__init__.py,sha256=MrarXte0hUoGsw4qYVKiOMOvfv0ysgs9a3b1Oy_yfL4,1766
+brynq_sdk_vplan/activity.py,sha256=Obnobz9-3TLbSF4YCrqo4yr8lUqrX_3FJEKoU657gzc,7399
+brynq_sdk_vplan/get_data.py,sha256=jCc4l4l9ORcCebB_Trxm5Scju-HaB8Vy3BEcbf6NViw,4157
+brynq_sdk_vplan/item.py,sha256=fY-xveKAwtSFiVzybDsAaMfVbay7YhZu2L1GyZ4qUq4,7954
+brynq_sdk_vplan/leave.py,sha256=p72zg5XDiq5RYJflXph91QM0lyPcRE5Q5_G0g9G0l-Y,4729
+brynq_sdk_vplan/order.py,sha256=3hM9I56Eq-cHo6N1_ZaPitcauSv0eUnJDgW-s4HVlN0,11010
+brynq_sdk_vplan/project.py,sha256=oWgLBELcSAy8wSW6CuBlunWEkB3pI1pCdSIe9CR_xJw,6951
+brynq_sdk_vplan/resource.py,sha256=siBSdRsR907ZHt9cB4NFz06yybSORLcixWn8_y8Qs98,8641
+brynq_sdk_vplan/time_tracking.py,sha256=UXFl4mg_3M6a0Q3P5N77AlCLWyqmNib5yw5OfD_qYx4,8762
+brynq_sdk_vplan/user.py,sha256=Gdc6XFxhCSEwilDiNdeQTo5gd_CsVKgM4H6yk3IDFxI,7942
+brynq_sdk_vplan-2.0.1.dist-info/METADATA,sha256=DuOwWXCTiYd4zePph4aW4pvDMNuLCyAog7urOECzx_o,369
+brynq_sdk_vplan-2.0.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+brynq_sdk_vplan-2.0.1.dist-info/top_level.txt,sha256=XPJLb-gXBFxypv8aGn2jSIj3z9ltI6c_ZMZaLsZzhBk,16
+brynq_sdk_vplan-2.0.1.dist-info/RECORD,,

brynq_sdk_vplan-2.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

brynq_sdk_vplan-2.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+brynq_sdk_vplan