Added users and organisations api methods

User Session

Logging in/out

Users

Get User

Update User

Activate User

Request Password

Reset Password

Organizations

Get All Organizations

Get Single Organization

Organization Roles

Organization Users

Transfer Organization Ownership

Organization Stacks

Organization Logs

Author: sunil-lakshman

.talismanrc

@@ -0,0 +1,10 @@
+fileignoreconfig:
+- filename: contentstack_management/users/user.py
+  checksum: 9fd02cdc5e1cd22cf3fcd9b3f2159a3e7680d19052c58ab7425bfca4bd675a4f
+- filename: tests/test_organizations.py
+  checksum: a9ee8e15a00474ab16920da1a9cb7f96f9a0e40f945406506ed1e46030758025
+- filename: tests/test_users.py
+  checksum: 55b60bc69e941184bf16697cec82f5e14369460259729bbbd62437e019e6ab60
+- filename: contentstack_management/core/client.py
+  checksum: 1bec47304a29a7c482f530e3ac283e8ddd8fa96f99153833feac5a6513d726df
+version: ""

contentstack_management/__init__.py

@@ -0,0 +1,18 @@
+"""The __init__.py file that contains modules that need to import"""
+
+
+from .core.login import Login
+from .core.error import Error
+
+from contentstack_management import contentstack
+
+__title__ = 'contentstack-cms'
+__author__ = 'contentstack'
+__status__ = 'debug'
+__version__ = '0.0.1'
+__host__ = 'api.contentstack.io'
+__protocol__ = 'https://'
+__api_version__ = 'v3'
+__endpoint__ = 'https://api.contentstack.io/v3/'
+__email__ = 'mobile@contentstack.com'
+__issues__ = 'customer_care@contentstack.com'

contentstack_management/contentstack.py

@@ -0,0 +1,76 @@
+import platform
+
+import contentstack_management
+from .core.client import ApiClient
+
+
+default_host = 'api.contentstack.io'
+default_endpoint = 'https://api.contentstack.io'
+default_api_version = 'v3'
+default_protocol = 'https://'
+default_timeout = 30
+default_max_request = 5
+
+
+def __platform():
+    os_platform = platform.system()
+    if os_platform == 'Darwin':
+        os_platform = 'macOS'
+    elif not os_platform or os_platform == 'Java':
+        os_platform = None
+    elif os_platform and os_platform not in ['macOS', 'Windows']:
+        os_platform = 'Linux'
+    os_platform = {'name': os_platform, 'version': platform.release()}
+    return os_platform
+
+
+def user_agents(headers):
+    headers.update({'sdk': dict(
+        name=contentstack_management.__package__,
+        version=contentstack_management.__version__
+    ), 'os': __platform})
+    package = f"contentstack-management-python/{contentstack_management.__version__}"
+    return {'User-Agent': str(headers), "X-User-Agent": package, 'Content-Type': 'application/json' }
+
+
+def client(endpoint=None,
+           host: str = None, authtoken: str = None, headers=None, authorization: str = None,
+           timeout: int = None, failure_retry: int = 0, exceptions: bool = True,
+           errors: bool = True, max_requests: int = default_max_request, retry_on_error: bool = True):
+    """
+    :param endpoint: Optional API endpoint.
+    :param host: Optional hostname for the API endpoint.
+    :param authtoken: Optional authentication token for API requests
+    :param headers: Optional headers to be included with API requests
+    :param authorization: Optional authorization value for API requests
+    :param timeout: Optional timeout value for API requests
+    :param failure_retry: Optional number of retries for API requests that fail
+    :param exceptions: Optional boolean value indicating whether to handle exceptions during API requests
+    :param errors: Optional boolean value indicating whether to handle errors during API requests.
+    :param max_requests:Optional maximum number of requests to be made
+    :param retry_on_error: Optional boolean value indicating whether to retry API requests on error.
+    :return: A client object for performing API operations.
+
+    :example:
+    >>> from contentstack_management import contentstack
+    >>> client = contentstack.client()
+    """
+    if headers is None:
+        headers = {}
+    headers = user_agents(headers)
+    if host is None:
+        host = contentstack_management.__host__
+
+    if endpoint is None:
+        endpoint = contentstack_management.__endpoint__
+        if host is not None:
+            endpoint = f'{contentstack_management.__protocol__}{host}/{contentstack_management.__api_version__}'
+
+    if timeout is None:
+        timeout = default_timeout
+
+    return ApiClient(host=host, endpoint=endpoint, authtoken=authtoken,
+                     headers=headers, authorization=authorization,
+                     timeout=timeout, failure_retry=failure_retry, exceptions=exceptions, errors=errors,
+                     max_requests=max_requests, retry_on_error=retry_on_error)
+

contentstack_management/core/client.py

@@ -0,0 +1,181 @@
+"""This class takes a base URL as an argument when it's initialized, 
+which is the endpoint for the RESTFUL API that we'll be interacting with.
+The create(), read(), update(), and delete() methods each correspond to 
+the CRUD operations that can be performed on the API """
+
+import requests
+import json
+
+
+from ..organizations.organizations import Organization
+from ..users.user import User
+from ..user_session.user_session import UserSession
+
+class ApiClient:
+    """
+    This class takes a base URL as an argument when it's initialized, 
+    which is the endpoint for the RESTFUL API that
+    we'll be interacting with. The create(), read(), update(), and delete() 
+    methods each correspond to the CRUD 
+    operations that can be performed on the API """
+
+    def __init__(self, endpoint, host, headers, authtoken, authorization, failure_retry, exceptions: bool,
+                 errors: bool, timeout: int, max_requests: int, retry_on_error: bool):
+        self.authorization = authorization
+        self.authtoken = authtoken
+        self.headers = headers
+        self.host = host
+        self.endpoint = endpoint
+        self.failure_retry = failure_retry
+        self.exceptions = exceptions
+        self.errors = errors
+        self.timeout = timeout
+        self.max_requests = max_requests
+        self.retry_on_error = retry_on_error
+        
+        
+
+    def get(self, url, headers=None, params=None):
+        """
+        Perform an HTTP GET request with the specified URL and parameters.
+
+        :param url: The URL to send the request to.
+        :param headers: Optional dictionary of headers to include in the request.
+        :param params: Optional dictionary of URL parameters to include in the request.
+        :return: The response from the server.
+        """
+        return self._call_request('GET', url, headers=headers, params=params)
+
+    def put(self, url, headers=None, params=None, data=None, json=None):
+        """
+        Perform an HTTP PUT request with the specified URL and parameters.
+
+        :param url: The URL to send the request to.
+        :param headers: Optional dictionary of headers to include in the request.
+        :param params: Optional dictionary of URL parameters to include in the request.
+        :param data: Optional dictionary, list of tuples, or bytes to include in the body of the request.
+        :param json: Optional JSON data to include in the body of the request.
+        :return: The response from the server.
+        """
+        return self._call_request('PUT', url, headers=headers, params=params, data=data, json=json)
+
+    def post(self, url, headers=None, params=None, data=None, json=None):
+        """
+        Perform an HTTP POST request with the specified URL and parameters.
+
+        :param url: The URL to send the request to.
+        :param headers: Optional dictionary of headers to include in the request.
+        :param params: Optional dictionary of URL parameters to include in the request.
+        :param data: Optional dictionary, list of tuples, or bytes to include in the body of the request.
+        :param json: Optional JSON data to include in the body of the request.
+        :return: The response from the server.
+        """
+        return self._call_request('POST', url, headers=headers, params=params, data=data, json=json)
+
+    def delete(self, url, headers=None, params=None):
+        """
+        Perform an HTTP DELETE request with the specified URL and parameters.
+
+        :param url: The URL to send the request to.
+        :param headers: Optional dictionary of headers to include in the request.
+        :param params: Optional dictionary of URL parameters to include in the request.
+        :return: The response from the server.
+        """
+        return self._call_request('DELETE', url, headers=headers, params=params)
+    
+
+    
+    def _call_request(self, method, url_path, headers=None, params=None, data=None, json=None):
+        url = f"{self.endpoint}/{url_path}"
+        retries = self.failure_retry + 1
+
+        while retries > 0:
+            try:
+                response = requests.request(method, url, data=data, headers=headers, params=params, json=json)
+
+                if response.status_code >= 400:
+                    if self.errors:
+                        raise Exception(f"API returned an error: {response.text}")
+                    elif retries > 1:
+                        retries -= 1
+                    else:
+                        return None
+                else:
+                    return response
+
+            except Exception as e:
+                if self.exceptions:
+                    raise e
+                elif retries > 1:
+                    retries -= 1
+                else:
+                    return None
+                
+    def login(self,  email, password):
+        url = "user-session"
+        data = {
+            "user": {
+                "email": email,
+                "password": password
+
+            }
+        }
+        data = json.dumps(data)
+        self.api_client = ApiClient(
+                    host=self.host, endpoint=self.endpoint, authtoken=self.authtoken,
+                     headers=self.headers, authorization=self.authorization,
+                     timeout=self.timeout, failure_retry=self.failure_retry, exceptions=self.exceptions, errors=self.errors,
+                     max_requests=self.max_requests, retry_on_error=self.retry_on_error
+        )
+
+        response =  UserSession(url = url,headers = self.headers, data = data, api_client=self.api_client, endpoint=self.endpoint).login()
+        self.auth_token = self.get_authtoken(response)
+        return response
+    
+    def logout(self):
+        url = "user-session"
+        self.headers['authtoken'] = self.auth_token
+        response =  UserSession(url = url,headers = self.headers, api_client = self.api_client, endpoint=self.endpoint).logout()
+        return response
+        
+    def get_authtoken(self, response):
+        return response['user']['authtoken']
+        
+    
+    def get_user(self):
+        return User(self.endpoint, self.auth_token, self.headers,self.api_client).get_user()
+    
+    def update_user(self, user_data):
+        return User(self.endpoint, self.auth_token, self.headers,self.api_client).update_user(user_data)
+    
+    def active_user(self, user_activation_token, user_data):
+        return User(self.endpoint, self.auth_token, self.headers,self.api_client).update_user(user_activation_token, user_data)
+    
+    def request_password(self, user_data):
+        return User(self.endpoint, self.auth_token, self.headers,self.api_client).request_password(user_data)
+    
+    def reset_password(self, user_data):
+        return User(self.endpoint, self.auth_token, self.headers,self.api_client).reset_password(user_data)
+    
+    def get_organizations(self):
+        return Organization(self.endpoint, self.auth_token, self.headers,self.api_client).get_organizations()
+    
+    def get_organization(self, organization_uid):
+        return Organization(self.endpoint, self.auth_token, self.headers,self.api_client).get_organizations(organization_uid)
+    
+    def get_organization_roles(self, organization_uid):
+        return Organization(self.endpoint, self.auth_token, self.headers,self.api_client).get_organization_roles(organization_uid)
+    
+    def organization_add_users(self, organization_uid):
+        return Organization(self.endpoint, self.auth_token, self.headers,self.api_client).organization_add_users(organization_uid)
+    
+    def transfer_organizations_onership(self, organization_uid):
+        return Organization(self.endpoint, self.auth_token, self.headers,self.api_client).transfer_organizations_onership(organization_uid)
+    
+    def organization_stacks(self, organization_uid):
+        return Organization(self.endpoint, self.auth_token, self.headers,self.api_client).organization_stacks(organization_uid)
+    
+    def organization_logs(self, organization_uid):
+        return Organization(self.endpoint, self.auth_token, self.headers,self.api_client).organization_logs(organization_uid)
+                
+    

contentstack_management/core/http_client.py

@@ -0,0 +1,104 @@
+"""This class takes a base URL as an argument when it's initialized, 
+which is the endpoint for the RESTFUL API that we'll be interacting with.
+The create(), read(), update(), and delete() methods each correspond to 
+the CRUD operations that can be performed on the API """
+
+import requests
+import json
+
+
+class HttpClient:
+    """
+    This class takes a base URL as an argument when it's initialized, 
+    which is the endpoint for the RESTFUL API that
+    we'll be interacting with. The create(), read(), update(), and delete() 
+    methods each correspond to the CRUD 
+    operations that can be performed on the API """
+
+    def __init__(self, endpoint):
+        #init method
+        self.url="user"
+        self.endpoint = endpoint
+        self.failure_retry = 0
+        self.exceptions = True
+        self.errors = True
+
+
+
+    def get(self, url, headers=None, params=None):
+        """
+        Perform an HTTP GET request with the specified URL and parameters.
+
+        :param url: The URL to send the request to.
+        :param headers: Optional dictionary of headers to include in the request.
+        :param params: Optional dictionary of URL parameters to include in the request.
+        :return: The response from the server.
+        """
+        return self._call_request('GET', url, headers=headers, params=params)
+
+    def put(self, url, headers=None, params=None, data=None, json=None):
+        """
+        Perform an HTTP PUT request with the specified URL and parameters.
+
+        :param url: The URL to send the request to.
+        :param headers: Optional dictionary of headers to include in the request.
+        :param params: Optional dictionary of URL parameters to include in the request.
+        :param data: Optional dictionary, list of tuples, or bytes to include in the body of the request.
+        :param json: Optional JSON data to include in the body of the request.
+        :return: The response from the server.
+        """
+        return self._call_request('PUT', url, headers=headers, params=params, data=data, json=json)
+
+    def post(self, url, headers=None, params=None, data=None, json=None):
+        """
+        Perform an HTTP POST request with the specified URL and parameters.
+
+        :param url: The URL to send the request to.
+        :param headers: Optional dictionary of headers to include in the request.
+        :param params: Optional dictionary of URL parameters to include in the request.
+        :param data: Optional dictionary, list of tuples, or bytes to include in the body of the request.
+        :param json: Optional JSON data to include in the body of the request.
+        :return: The response from the server.
+        """
+        return self._call_request('POST', url, headers=headers, params=params, data=data, json=json)
+
+    def delete(self, url, headers=None, params=None):
+        """
+        Perform an HTTP DELETE request with the specified URL and parameters.
+
+        :param url: The URL to send the request to.
+        :param headers: Optional dictionary of headers to include in the request.
+        :param params: Optional dictionary of URL parameters to include in the request.
+        :return: The response from the server.
+        """
+        return self._call_request('DELETE', url, headers=headers, params=params)
+    
+
+    
+    def _call_request(self, method, url_path, headers=None, params=None, data=None, json=None):
+        url = f"{self.endpoint}/{url_path}"
+        retries = self.failure_retry + 1
+
+        while retries > 0:
+            try:
+                response = requests.request(method, url, data=data, headers=headers, params=params, json=json)
+
+                if response.status_code >= 400:
+                    if self.errors:
+                        raise Exception(f"API returned an error: {response.text}")
+                    elif retries > 1:
+                        retries -= 1
+                    else:
+                        return None
+                else:
+                    return response.json()
+
+            except Exception as e:
+                if self.exceptions:
+                    raise e
+                elif retries > 1:
+                    retries -= 1
+                else:
+                    return None
+                
+