wcp-library 1.2.8__py3-none-any.whl → 1.3.1__py3-none-any.whl

wcp_library/{async_credentials/oracle.py → credentials/credential_manager_asynchronous.py}

@@ -1,4 +1,5 @@
 import logging
+from abc import ABC,abstractmethod
 
 import aiohttp
 from yarl import URL
@@ -8,12 +9,12 @@ from wcp_library.async_credentials import MissingCredentialsError
 logger = logging.getLogger(__name__)
 
 
-class AsyncOracleCredentialManager:
-    def __init__(self, passwordState_api_key: str):
+class AsyncCredentialManager(ABC):
+    def __init__(self, passwordState_api_key: str, password_list_id: int):
         self.password_url = URL("https://vault.wcap.ca/api/passwords/")
         self.api_key = passwordState_api_key
         self.headers = {"APIKey": self.api_key, 'Reason': 'Python Script Access'}
-        self._password_list_id = 207
+        self._password_list_id = password_list_id
 
     async def _get_credentials(self) -> dict:
         """
@@ -40,6 +41,46 @@ class AsyncOracleCredentialManager:
         logger.debug("Credentials retrieved")
         return password_dict
 
+    async def _get_credential(self, password_id: int) -> dict:
+        """
+        Get a specific credential from the password list
+
+        :param password_id:
+        :return:
+        """
+
+        logger.debug(f"Getting credential with ID {password_id}")
+        url = (self.password_url / str(password_id))
+        async with aiohttp.ClientSession() as session:
+            async with session.get(str(url), headers=self.headers) as response:
+                password = await response.json()
+
+        if not password:
+            raise MissingCredentialsError(f"No credentials found with ID {password_id}")
+        password = password[0]
+
+        password_info = {'PasswordID': password['PasswordID'], 'UserName': password['UserName'], 'Password': password['Password']}
+        for field in password['GenericFieldInfo']:
+            password_info[field['DisplayName']] = field['Value'].lower() if field['DisplayName'].lower() == 'username' else field['Value']
+        return password_info
+
+    async def _publish_new_password(self, data: dict) -> bool:
+        """
+        Publish a new password to the password list
+
+        :param data:
+        :return:
+        """
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(str(self.password_url), json=data, headers=self.headers) as response:
+                if response.status == 201:
+                    logger.debug(f"New credentials for {data['UserName']} created")
+                    return True
+                else:
+                    logger.error(f"Failed to create new credentials for {data['UserName']}")
+                    return False
+
     async def get_credentials(self, username: str) -> dict:
         """
         Get the credentials for a specific username
@@ -94,38 +135,6 @@ class AsyncOracleCredentialManager:
                     logger.error(f"Failed to update credentials for {credentials_dict['UserName']}")
                     return False
 
+    @abstractmethod
     async def new_credentials(self, credentials_dict: dict) -> bool:
-        """
-        Create a new credential entry
-
-        Credentials dictionary must have the following keys:
-            - UserName
-            - Password
-            - Host
-            - Port
-            - Service or SID
-
-        :param credentials_dict:
-        :return:
-        """
-
-        data = {
-            "PasswordListID": self._password_list_id,
-            "Title": credentials_dict['UserName'].upper() if "Title" not in credentials_dict else credentials_dict['Title'].upper(),
-            "Notes": credentials_dict['Notes'] if 'Notes' in credentials_dict else None,
-            "UserName": credentials_dict['UserName'].lower(),
-            "Password": credentials_dict['Password'],
-            "GenericField1": credentials_dict['Host'],
-            "GenericField2": credentials_dict['Port'],
-            "GenericField3": credentials_dict['Service'] if 'Service' in credentials_dict else None,
-            "GenericField4": credentials_dict['SID'] if 'SID' in credentials_dict else None
-        }
-
-        async with aiohttp.ClientSession() as session:
-            async with session.post(str(self.password_url), json=data, headers=self.headers) as response:
-                if response.status == 201:
-                    logger.debug(f"New credentials for {credentials_dict['UserName']} created")
-                    return True
-                else:
-                    logger.error(f"Failed to create new credentials for {credentials_dict['UserName']}")
-                    return False
+        raise NotImplementedError("Must override in child class")

wcp_library/credentials/credential_manager_synchronous.py

@@ -0,0 +1,144 @@
+import logging
+from abc import ABC,abstractmethod
+
+import requests
+from yarl import URL
+
+from wcp_library.credentials import MissingCredentialsError
+
+logger = logging.getLogger(__name__)
+
+
+class CredentialManager(ABC):
+    def __init__(self, passwordState_api_key: str, password_list_id: int):
+        self.password_url = URL("https://vault.wcap.ca/api/passwords/")
+        self.api_key = passwordState_api_key
+        self.headers = {"APIKey": self.api_key, 'Reason': 'Python Script Access'}
+        self._password_list_id = password_list_id
+
+    def _get_credentials(self) -> dict:
+        """
+        Get all credentials from the password list
+
+        :return: Dictionary of credentials
+        """
+
+        logger.debug("Getting credentials from PasswordState")
+        url = (self.password_url / str(self._password_list_id)).with_query("QueryAll")
+        passwords = requests.get(str(url), headers=self.headers).json()
+
+        if not passwords:
+            raise MissingCredentialsError("No credentials found in this Password List")
+
+        password_dict = {}
+        for password in passwords:
+            password_info = {'PasswordID': password['PasswordID'], 'UserName': password['UserName'], 'Password': password['Password']}
+            for field in password['GenericFieldInfo']:
+                password_info[field['DisplayName']] = field['Value'].lower() if field['DisplayName'].lower() == 'username' else field['Value']
+            password_dict[password['UserName'].lower()] = password_info
+        logger.debug("Credentials retrieved")
+        return password_dict
+
+    def _get_credential(self, password_id: int) -> dict:
+        """
+        Get a specific credential from the password list
+
+        :param password_id:
+        :return:
+        """
+
+        logger.debug(f"Getting credential with ID {password_id}")
+        url = (self.password_url / str(password_id))
+        password = requests.get(str(url), headers=self.headers).json()
+
+        if not password:
+            raise MissingCredentialsError(f"No credentials found with ID {password_id}")
+        password = password[0]
+
+        password_info = {'PasswordID': password['PasswordID'], 'UserName': password['UserName'], 'Password': password['Password']}
+        for field in password['GenericFieldInfo']:
+            password_info[field['DisplayName']] = field['Value'].lower() if field['DisplayName'].lower() == 'username' else field['Value']
+        logger.debug("Credential retrieved")
+        return password_info
+
+    def _publish_new_password(self, data: dict) -> bool:
+        """
+        Publish a new password to the password list
+
+        :param data:
+        :return:
+        """
+
+        response = requests.post(str(self.password_url), json=data, headers=self.headers)
+        if response.status_code == 201:
+            logger.debug(f"New credentials for {data['UserName']} created")
+            return True
+        else:
+            logger.error(f"Failed to create new credentials for {data['UserName']}")
+            return False
+
+    def get_credentials(self, username: str) -> dict:
+        """
+        Get the credentials for a specific username
+
+        :param username:
+        :return: Dictionary of credentials
+        """
+
+        logger.debug(f"Getting credentials for {username}")
+        credentials = self._get_credentials()
+
+        try:
+            return_credential = credentials[username.lower()]
+        except KeyError:
+            raise MissingCredentialsError(f"Credentials for {username} not found in this Password List")
+        logger.debug(f"Credentials for {username} retrieved")
+        return return_credential
+
+    def get_credential_from_id(self, password_id: int) -> dict:
+        """
+        Get the credentials for a specific password ID
+
+        :param password_id:
+        :return:
+        """
+
+        return self._get_credential(password_id)
+
+
+    def update_credential(self, credentials_dict: dict) -> bool:
+        """
+        Update the credentials for a specific username
+
+        Credentials dictionary must have the following keys:
+            - PasswordID
+            - UserName
+            - Password
+
+        The dictionary should be obtained from the get_credentials method and modified accordingly
+
+        :param credentials_dict:
+        :return: True if successful, False otherwise
+        """
+
+        logger.debug(f"Updating credentials for {credentials_dict['UserName']}")
+        url = (self.password_url / str(self._password_list_id)).with_query("QueryAll")
+        passwords = requests.get(str(url), headers=self.headers).json()
+
+        relevant_credential_entry = [x for x in passwords if x['UserName'] == credentials_dict['UserName']][0]
+        for field in relevant_credential_entry['GenericFieldInfo']:
+            if field['DisplayName'] in credentials_dict:
+                credentials_dict[field['GenericFieldID']] = credentials_dict[field['DisplayName']]
+                credentials_dict.pop(field['DisplayName'])
+
+        response = requests.put(str(self.password_url), json=credentials_dict, headers=self.headers)
+        if response.status_code == 200:
+            logger.debug(f"Credentials for {credentials_dict['UserName']} updated")
+            return True
+        else:
+            logger.error(f"Failed to update credentials for {credentials_dict['UserName']}")
+            return False
+
+    @abstractmethod
+    def new_credentials(self, credentials_dict: dict) -> bool:
+        raise NotImplementedError("Must override in child class")

wcp_library/credentials/ftp.py

@@ -1,95 +1,49 @@
 import logging
 
-import requests
-from yarl import URL
-
-from wcp_library.credentials import MissingCredentialsError
+from wcp_library.credentials.credential_manager_asynchronous import AsyncCredentialManager
+from wcp_library.credentials.credential_manager_synchronous import CredentialManager
 
 logger = logging.getLogger(__name__)
 
 
-class FTPCredentialManager:
+class FTPCredentialManager(CredentialManager):
     def __init__(self, passwordState_api_key: str):
-        self.password_url = URL("https://vault.wcap.ca/api/passwords/")
-        self.api_key = passwordState_api_key
-        self.headers = {"APIKey": self.api_key, 'Reason': 'Python Script Access'}
-        self._password_list_id = 208
-
-    def _get_credentials(self) -> dict:
-        """
-        Get all credentials from the password list
-
-        :return: Dictionary of credentials
-        """
+        super().__init__(passwordState_api_key, 208)
 
-        logger.debug("Getting credentials from PasswordState")
-        url = (self.password_url / str(self._password_list_id)).with_query("QueryAll")
-        passwords = requests.get(str(url), headers=self.headers).json()
-
-        if not passwords:
-            raise MissingCredentialsError("No credentials found in this Password List")
-
-        password_dict = {}
-        for password in passwords:
-            password_info = {'PasswordID': password['PasswordID'], 'UserName': password['UserName'], 'Password': password['Password']}
-            for field in password['GenericFieldInfo']:
-                password_info[field['DisplayName']] = field['Value'].lower() if field['DisplayName'].lower() == 'username' else field['Value']
-            password_dict[password['UserName'].lower()] = password_info
-        logger.debug("Credentials retrieved")
-        return password_dict
-
-    def get_credentials(self, username: str) -> dict:
-        """
-        Get the credentials for a specific username
-
-        :param username:
-        :return: Dictionary of credentials
-        """
-
-        logger.debug(f"Getting credentials for {username}")
-        credentials = self._get_credentials()
-
-        try:
-            return_credential = credentials[username.lower()]
-        except KeyError:
-            raise MissingCredentialsError(f"Credentials for {username} not found in this Password List")
-        logger.debug(f"Credentials for {username} retrieved")
-        return return_credential
-
-    def update_credential(self, credentials_dict: dict) -> bool:
+    def new_credentials(self, credentials_dict: dict) -> bool:
         """
-        Update the credentials for a specific username
+        Create a new credential entry
 
         Credentials dictionary must have the following keys:
-            - PasswordID
             - UserName
             - Password
-
-        The dictionary should be obtained from the get_credentials method and modified accordingly
+            - Host
+            - Port
+            - FTP/SFTP (FTP or SFTP)
 
         :param credentials_dict:
         :return: True if successful, False otherwise
         """
 
-        logger.debug(f"Updating credentials for {credentials_dict['UserName']}")
-        url = (self.password_url / str(self._password_list_id)).with_query("QueryAll")
-        passwords = requests.get(str(url), headers=self.headers).json()
+        data = {
+            "PasswordListID": self._password_list_id,
+            "Title": credentials_dict['UserName'].upper() if "Title" not in credentials_dict else credentials_dict['Title'].upper(),
+            "Notes": credentials_dict['Notes'] if 'Notes' in credentials_dict else None,
+            "UserName": credentials_dict['UserName'].lower(),
+            "Password": credentials_dict['Password'],
+            "GenericField1": credentials_dict['Host'],
+            "GenericField2": credentials_dict['Port'],
+            "GenericField3": credentials_dict['FTP/SFTP']
+        }
 
-        relevant_credential_entry = [x for x in passwords if x['UserName'] == credentials_dict['UserName']][0]
-        for field in relevant_credential_entry['GenericFieldInfo']:
-            if field['DisplayName'] in credentials_dict:
-                credentials_dict[field['GenericFieldID']] = credentials_dict[field['DisplayName']]
-                credentials_dict.pop(field['DisplayName'])
+        return self._publish_new_password(data)
 
-        response = requests.put(str(self.password_url), json=credentials_dict, headers=self.headers)
-        if response.status_code == 200:
-            logger.debug(f"Credentials for {credentials_dict['UserName']} updated")
-            return True
-        else:
-            logger.error(f"Failed to update credentials for {credentials_dict['UserName']}")
-            return False
 
-    def new_credentials(self, credentials_dict: dict) -> bool:
+class AsyncFTPCredentialManager(AsyncCredentialManager):
+    def __init__(self, passwordState_api_key: str):
+        super().__init__(passwordState_api_key, 208)
+
+    async def new_credentials(self, credentials_dict: dict) -> bool:
         """
         Create a new credential entry
 
@@ -101,7 +55,7 @@ class FTPCredentialManager:
             - FTP/SFTP (FTP or SFTP)
 
         :param credentials_dict:
-        :return: True if successful, False otherwise
+        :return:
         """
 
         data = {
@@ -115,10 +69,4 @@ class FTPCredentialManager:
             "GenericField3": credentials_dict['FTP/SFTP']
         }
 
-        response = requests.post(str(self.password_url), json=data, headers=self.headers)
-        if response.status_code == 201:
-            logger.debug(f"New credentials for {credentials_dict['UserName']} created")
-            return True
-        else:
-            logger.error(f"Failed to create new credentials for {credentials_dict['UserName']}")
-            return False
+        return await self._publish_new_password(data)

wcp_library/credentials/oracle.py

@@ -1,95 +1,52 @@
 import logging
 
-import requests
-from yarl import URL
+import aiohttp
 
-from wcp_library.credentials import MissingCredentialsError
+from wcp_library.credentials.credential_manager_asynchronous import AsyncCredentialManager
+from wcp_library.credentials.credential_manager_synchronous import CredentialManager
 
 logger = logging.getLogger(__name__)
 
 
-class OracleCredentialManager:
+class OracleCredentialManager(CredentialManager):
     def __init__(self, passwordState_api_key: str):
-        self.password_url = URL("https://vault.wcap.ca/api/passwords/")
-        self.api_key = passwordState_api_key
-        self.headers = {"APIKey": self.api_key, 'Reason': 'Python Script Access'}
-        self._password_list_id = 207
+        super().__init__(passwordState_api_key, 207)
 
-    def _get_credentials(self) -> dict:
-        """
-        Get all credentials from the password list
-
-        :return: Dictionary of credentials
-        """
-
-        logger.debug("Getting credentials from PasswordState")
-        url = (self.password_url / str(self._password_list_id)).with_query("QueryAll")
-        passwords = requests.get(str(url), headers=self.headers).json()
-
-        if not passwords:
-            raise MissingCredentialsError("No credentials found in this Password List")
-
-        password_dict = {}
-        for password in passwords:
-            password_info = {'PasswordID': password['PasswordID'], 'UserName': password['UserName'], 'Password': password['Password']}
-            for field in password['GenericFieldInfo']:
-                password_info[field['DisplayName']] = field['Value'].lower() if field['DisplayName'].lower() == 'username' else field['Value']
-            password_dict[password['UserName'].lower()] = password_info
-        logger.debug("Credentials retrieved")
-        return password_dict
-
-    def get_credentials(self, username: str) -> dict:
-        """
-        Get the credentials for a specific username
-
-        :param username:
-        :return: Dictionary of credentials
-        """
-
-        logger.debug(f"Getting credentials for {username}")
-        credentials = self._get_credentials()
-
-        try:
-            return_credential = credentials[username.lower()]
-        except KeyError:
-            raise MissingCredentialsError(f"Credentials for {username} not found in this Password List")
-        logger.debug(f"Credentials for {username} retrieved")
-        return return_credential
-
-    def update_credential(self, credentials_dict: dict) -> bool:
+    def new_credentials(self, credentials_dict: dict) -> bool:
         """
-        Update the credentials for a specific username
+        Create a new credential entry
 
         Credentials dictionary must have the following keys:
-            - PasswordID
             - UserName
             - Password
-
-        The dictionary should be obtained from the get_credentials method and modified accordingly
+            - Host
+            - Port
+            - Service or SID
 
         :param credentials_dict:
         :return: True if successful, False otherwise
         """
 
-        logger.debug(f"Updating credentials for {credentials_dict['UserName']}")
-        url = (self.password_url / str(self._password_list_id)).with_query("QueryAll")
-        passwords = requests.get(str(url), headers=self.headers).json()
+        data = {
+            "PasswordListID": self._password_list_id,
+            "Title": credentials_dict['UserName'].upper() if "Title" not in credentials_dict else credentials_dict['Title'].upper(),
+            "Notes": credentials_dict['Notes'] if 'Notes' in credentials_dict else None,
+            "UserName": credentials_dict['UserName'].lower(),
+            "Password": credentials_dict['Password'],
+            "GenericField1": credentials_dict['Host'],
+            "GenericField2": credentials_dict['Port'],
+            "GenericField3": credentials_dict['Service'] if 'Service' in credentials_dict else None,
+            "GenericField4": credentials_dict['SID'] if 'SID' in credentials_dict else None
+        }
 
-        relevant_credential_entry = [x for x in passwords if x['UserName'] == credentials_dict['UserName']][0]
-        for field in relevant_credential_entry['GenericFieldInfo']:
-            if field['DisplayName'] in credentials_dict:
-                credentials_dict[field['GenericFieldID']] = credentials_dict[field['DisplayName']]
-                credentials_dict.pop(field['DisplayName'])
+        return self._publish_new_password(data)
 
-        response = requests.put(str(self.password_url), json=credentials_dict, headers=self.headers)
-        if response.status_code == 200:
-            logger.debug(f"Credentials for {credentials_dict['UserName']} updated")
-            return True
-        else:
-            logger.error(f"Failed to update credentials for {credentials_dict['UserName']}")
-            return False
 
-    def new_credentials(self, credentials_dict: dict) -> bool:
+class AsyncOracleCredentialManager(AsyncCredentialManager):
+    def __init__(self, passwordState_api_key: str):
+        super().__init__(passwordState_api_key, 207)
+
+    async def new_credentials(self, credentials_dict: dict) -> bool:
         """
         Create a new credential entry
 
@@ -101,7 +58,7 @@ class OracleCredentialManager:
             - Service or SID
 
         :param credentials_dict:
-        :return: True if successful, False otherwise
+        :return:
         """
 
         data = {
@@ -116,10 +73,5 @@ class OracleCredentialManager:
             "GenericField4": credentials_dict['SID'] if 'SID' in credentials_dict else None
         }
 
-        response = requests.post(str(self.password_url), json=data, headers=self.headers)
-        if response.status_code == 201:
-            logger.debug(f"New credentials for {credentials_dict['UserName']} created")
-            return True
-        else:
-            logger.error(f"Failed to create new credentials for {credentials_dict['UserName']}")
-            return False
+        return await self._publish_new_password(data)
+