brynq-sdk-vplan 0.1.0__tar.gz

brynq_sdk_vplan-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 1.0
+Name: brynq_sdk_vplan
+Version: 0.1.0
+Summary: vPlan wrapper from BrynQ
+Home-page: UNKNOWN
+Author: BrynQ
+Author-email: support@brynq.com
+License: BrynQ License
+Description: vPlan wrapper from BrynQ
+Platform: UNKNOWN

brynq_sdk_vplan-0.1.0/brynq_sdk/vplan/__init__.py

@@ -0,0 +1,39 @@
+import requests
+import json
+from typing import List, Union
+from brynq_sdk.brynq import BrynQ
+from brynq_sdk.vplan.activity import Activity
+from brynq_sdk.vplan.item import Item
+from brynq_sdk.vplan.project import Project
+from brynq_sdk.vplan.resource import Resource
+from brynq_sdk.vplan.time_tracking import TimeTracking
+from brynq_sdk.vplan.user import User
+
+
+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.base_url = 'https://api.vplan.com/v1/'
+        self.activity = Activity(self)
+        self.item = Item(self)
+        self.project = Project(self)
+        self.resource = Resource(self)
+        self.time_tracking = TimeTracking(self)
+        self.user = User(self)
+
+    def _get_credentials(self, label) -> str:
+        """
+        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-0.1.0/brynq_sdk/vplan/activity.py

@@ -0,0 +1,132 @@
+import requests
+from typing import Union, List
+import warnings
+import json
+from brynq_sdk.vplan.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.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.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-0.1.0/brynq_sdk/vplan/get_data.py

@@ -0,0 +1,83 @@
+import pandas as pd
+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, 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 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-0.1.0/brynq_sdk/vplan/item.py

@@ -0,0 +1,141 @@
+import requests
+from typing import Union, List
+import warnings
+import json
+from brynq_sdk.vplan.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.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.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-0.1.0/brynq_sdk/vplan/project.py

@@ -0,0 +1,129 @@
+import requests
+from typing import Union, List
+import warnings
+import json
+from brynq_sdk.vplan.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.headers, data=base_body)
+        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.headers, json=base_body)
+        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)
+        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-0.1.0/brynq_sdk/vplan/resource.py

@@ -0,0 +1,142 @@
+import requests
+from typing import Union, List
+import warnings
+import json
+from brynq_sdk.vplan.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": 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.headers, data=json.dumps(base_body))
+        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": 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.headers, json=json.dumps(base_body))
+        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)
+        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-0.1.0/brynq_sdk/vplan/time_tracking.py

@@ -0,0 +1,144 @@
+import requests
+from typing import Union, List
+import warnings
+import json
+from brynq_sdk.vplan.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.headers, data=base_body)
+        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.headers, json=base_body)
+        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)
+        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-0.1.0/brynq_sdk/vplan/user.py

@@ -0,0 +1,141 @@
+import requests
+from typing import Union, List
+import warnings
+import json
+from brynq_sdk.vplan.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.headers, data=base_body)
+        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.headers, json=base_body)
+        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)
+        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-0.1.0/brynq_sdk_vplan.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 1.0
+Name: brynq-sdk-vplan
+Version: 0.1.0
+Summary: vPlan wrapper from BrynQ
+Home-page: UNKNOWN
+Author: BrynQ
+Author-email: support@brynq.com
+License: BrynQ License
+Description: vPlan wrapper from BrynQ
+Platform: UNKNOWN

brynq_sdk_vplan-0.1.0/brynq_sdk_vplan.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+setup.py
+brynq_sdk/vplan/__init__.py
+brynq_sdk/vplan/activity.py
+brynq_sdk/vplan/get_data.py
+brynq_sdk/vplan/item.py
+brynq_sdk/vplan/project.py
+brynq_sdk/vplan/resource.py
+brynq_sdk/vplan/time_tracking.py
+brynq_sdk/vplan/user.py
+brynq_sdk_vplan.egg-info/PKG-INFO
+brynq_sdk_vplan.egg-info/SOURCES.txt
+brynq_sdk_vplan.egg-info/dependency_links.txt
+brynq_sdk_vplan.egg-info/not-zip-safe
+brynq_sdk_vplan.egg-info/requires.txt
+brynq_sdk_vplan.egg-info/top_level.txt

brynq_sdk_vplan-0.1.0/brynq_sdk_vplan.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

brynq_sdk_vplan-0.1.0/brynq_sdk_vplan.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

brynq_sdk_vplan-0.1.0/brynq_sdk_vplan.egg-info/requires.txt

@@ -0,0 +1,2 @@
+brynq-sdk-brynq>=1
+pandas<3,>=2

brynq_sdk_vplan-0.1.0/brynq_sdk_vplan.egg-info/top_level.txt

@@ -0,0 +1 @@
+brynq_sdk

brynq_sdk_vplan-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

brynq_sdk_vplan-0.1.0/setup.py

@@ -0,0 +1,17 @@
+from setuptools import setup
+
+setup(
+    name='brynq_sdk_vplan',
+    version='0.1.0',
+    description='vPlan wrapper from BrynQ',
+    long_description='vPlan wrapper from BrynQ',
+    author='BrynQ',
+    author_email='support@brynq.com',
+    packages=["brynq_sdk.vplan"],
+    license='BrynQ License',
+    install_requires=[
+        'brynq-sdk-brynq>=1',
+        'pandas>=2,<3'
+    ],
+    zip_safe=False,
+)