pyxecm 1.4__py3-none-any.whl → 1.6__py3-none-any.whl

pyxecm/customizer/salesforce.py

@@ -1,5 +1,6 @@
 """
 Salesforce Module to interact with the Salesforce API
+See: https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/intro_rest.htm
 
 Class: Salesforce
 Methods:
@@ -7,22 +8,38 @@ Methods:
 __init__ : class initializer
 config : Returns config data set
 credentials: Returns the token data
+
 request_header: Returns the request header for Salesforce API calls
+do_request: Call an Salesforce REST API in a safe way
 parse_request_response: Parse the REST API responses and convert
                         them to Python dict in a safe way
 exist_result_item: Check if an dict item is in the response
                    of the Salesforce API call
 get_result_value: Check if a defined value (based on a key) is in the Salesforce API response
 
-authenticate : Authenticates at Salesforce API
-
-get_user: Get a Salesforce user based on its ID.
-add_user: Add a new Salesforce user.
+authenticate: Authenticates at Salesforce API
 
+get_object_id_by_name: Get the ID of a given Salesforce object with a given type and name
 get_object: Get a Salesforce object based on a defined
             field value and return selected result fields.
 add_object: Add object to Salesforce. This is a generic wrapper method
             for the actual add methods.
+
+get_group: Get a Salesforce group based on its ID.
+add_group: Add a new Salesforce group.
+update_group: Update a Salesforce group.
+get_group_members: Get Salesforce group members
+add_group_member: Add a user or group to a Salesforce group
+
+get_all_user_profiles: Get all user profiles
+get_user_profile_id: Get a user profile ID by profile name
+get_user_id: Get a user ID by user name
+get_user: Get a Salesforce user based on its ID.
+add_user: Add a new Salesforce user.
+update_user: Update a Salesforce user.
+update_user_password: Update the password of a Salesforce user.
+update_user_photo: update the Salesforce user photo.
+
 add_account: Add a new Account object to Salesforce.
 add_product: Add a new Product object to Salesforce.
 add_opportunity: Add a new Opportunity object to Salesfoce.
@@ -38,20 +55,28 @@ __credits__ = ["Kai-Philip Gatzweiler"]
 __maintainer__ = "Dr. Marc Diefenbruch"
 __email__ = "mdiefenb@opentext.com"
 
+import os
 import json
 import logging
+import time
 
 from typing import Optional, Union, Any
+
+from http import HTTPStatus
 import requests
 
 logger = logging.getLogger("pyxecm.customizer.salesforce")
 
-request_login_headers = {
+REQUEST_LOGIN_HEADERS = {
     "Content-Type": "application/x-www-form-urlencoded",
     "Accept": "application/json",
 }
 
 REQUEST_TIMEOUT = 60
+REQUEST_RETRY_DELAY = 20
+REQUEST_MAX_RETRIES = 3
+
+SALESFORCE_API_VERSION = "v60.0"
 
 class Salesforce(object):
     """Used to retrieve and automate stettings in Salesforce."""
@@ -84,21 +109,56 @@ class Salesforce(object):
             security_token (str, optional): security token for Salesforce login
         """
 
+        # The instance URL is also returned by the authenticate call
+        # but typically it is identical to the base_url.
+        self._instance_url = base_url
+
         salesforce_config = {}
 
-        # Set the authentication endpoints and credentials
-        salesforce_config["baseUrl"] = base_url
+        # Store the credentials and parameters in a config dictionary:
         salesforce_config["clientId"] = client_id
         salesforce_config["clientSecret"] = client_secret
         salesforce_config["username"] = username
         salesforce_config["password"] = password
         salesforce_config["securityToken"] = security_token
+
+        # Set the Salesforce URLs and REST API endpoints:
+        salesforce_config["baseUrl"] = base_url
+        salesforce_config["objectUrl"] = salesforce_config[
+            "baseUrl"
+        ] + "/services/data/{}/sobjects/".format(SALESFORCE_API_VERSION)
+        salesforce_config["queryUrl"] = salesforce_config[
+            "baseUrl"
+        ] + "/services/data/{}/query/".format(SALESFORCE_API_VERSION)
+        salesforce_config["compositeUrl"] = salesforce_config[
+            "baseUrl"
+        ] + "/services/data/{}/composite/".format(SALESFORCE_API_VERSION)
+        salesforce_config["connectUrl"] = salesforce_config[
+            "baseUrl"
+        ] + "/services/data/{}/connect/".format(SALESFORCE_API_VERSION)
+        salesforce_config["toolingUrl"] = salesforce_config[
+            "baseUrl"
+        ] + "/services/data/{}/tooling/".format(SALESFORCE_API_VERSION)
         if authorization_url:
             salesforce_config["authenticationUrl"] = authorization_url
         else:
             salesforce_config["authenticationUrl"] = (
                 salesforce_config["baseUrl"] + "/services/oauth2/token"
             )
+        # URLs that are based on the objectURL (sobjects/):
+        salesforce_config["userUrl"] = salesforce_config["objectUrl"] + "User/"
+        salesforce_config["groupUrl"] = salesforce_config["objectUrl"] + "Group/"
+        salesforce_config["groupMemberUrl"] = (
+            salesforce_config["objectUrl"] + "GroupMember/"
+        )
+        salesforce_config["accountUrl"] = salesforce_config["objectUrl"] + "Account/"
+        salesforce_config["productUrl"] = salesforce_config["objectUrl"] + "Product2/"
+        salesforce_config["opportunityUrl"] = (
+            salesforce_config["objectUrl"] + "Opportunity/"
+        )
+        salesforce_config["caseUrl"] = salesforce_config["objectUrl"] + "Case/"
+        salesforce_config["assetUrl"] = salesforce_config["objectUrl"] + "Asset/"
+        salesforce_config["contractUrl"] = salesforce_config["objectUrl"] + "Contract/"
 
         # Set the data for the token request
         salesforce_config["authenticationData"] = {
@@ -111,6 +171,8 @@ class Salesforce(object):
 
         self._config = salesforce_config
 
+    # end method definition
+
     def config(self) -> dict:
         """Returns the configuration dictionary
 
@@ -143,12 +205,187 @@ class Salesforce(object):
 
         request_header = {
             "Authorization": "Bearer {}".format(self._access_token),
-            "Content-Type": content_type,
         }
+        if content_type:
+            request_header["Content-Type"] = content_type
+
         return request_header
 
     # end method definition
 
+    def do_request(
+        self,
+        url: str,
+        method: str = "GET",
+        headers: dict | None = None,
+        data: dict | None = None,
+        json_data: dict | None = None,
+        files: dict | None = None,
+        params: dict | None = None,
+        timeout: int | None = REQUEST_TIMEOUT,
+        show_error: bool = True,
+        show_warning: bool = False,
+        warning_message: str = "",
+        failure_message: str = "",
+        success_message: str = "",
+        max_retries: int = REQUEST_MAX_RETRIES,
+        retry_forever: bool = False,
+        parse_request_response: bool = True,
+        stream: bool = False,
+        verify: bool = True,
+    ) -> dict | None:
+        """Call an Salesforce REST API in a safe way
+
+        Args:
+            url (str): URL to send the request to.
+            method (str, optional): HTTP method (GET, POST, etc.). Defaults to "GET".
+            headers (dict | None, optional): Request Headers. Defaults to None.
+            data (dict | None, optional): Request payload. Defaults to None
+            files (dict | None, optional): Dictionary of {"name": file-tuple} for multipart encoding upload.
+                                           file-tuple can be a 2-tuple ("filename", fileobj) or a 3-tuple ("filename", fileobj, "content_type")
+            params (dict | None, optional): Add key-value pairs to the query string of the URL.
+                                            When you use the params parameter, requests automatically appends
+                                            the key-value pairs to the URL as part of the query string
+            timeout (int | None, optional): Timeout for the request in seconds. Defaults to REQUEST_TIMEOUT.
+            show_error (bool, optional): Whether or not an error should be logged in case of a failed REST call.
+                                         If False, then only a warning is logged. Defaults to True.
+            warning_message (str, optional): Specific warning message. Defaults to "". If not given the error_message will be used.
+            failure_message (str, optional): Specific error message. Defaults to "".
+            success_message (str, optional): Specific success message. Defaults to "".
+            max_retries (int, optional): How many retries on Connection errors? Default is REQUEST_MAX_RETRIES.
+            retry_forever (bool, optional): Eventually wait forever - without timeout. Defaults to False.
+            parse_request_response (bool, optional): should the response.text be interpreted as json and loaded into a dictionary. True is the default.
+            stream (bool, optional): parameter is used to control whether the response content should be immediately downloaded or streamed incrementally
+            verify (bool, optional): specify whether or not SSL certificates should be verified when making an HTTPS request. Default = True
+
+        Returns:
+            dict | None: Response of OTDS REST API or None in case of an error.
+        """
+
+        if headers is None:
+            logger.error("Missing request header. Cannot send request to Core Share!")
+            return None
+
+        # In case of an expired session we reauthenticate and
+        # try 1 more time. Session expiration should not happen
+        # twice in a row:
+        retries = 0
+
+        while True:
+            try:
+                response = requests.request(
+                    method=method,
+                    url=url,
+                    data=data,
+                    json=json_data,
+                    files=files,
+                    params=params,
+                    headers=headers,
+                    timeout=timeout,
+                    stream=stream,
+                    verify=verify,
+                )
+
+                if response.ok:
+                    if success_message:
+                        logger.info(success_message)
+                    if parse_request_response:
+                        return self.parse_request_response(response)
+                    else:
+                        return response
+                # Check if Session has expired - then re-authenticate and try once more
+                elif response.status_code == 401 and retries == 0:
+                    logger.debug("Session has expired - try to re-authenticate...")
+                    self.authenticate(revalidate=True)
+                    # Make sure to not change an existing content type
+                    # the do_request() method is called with:
+                    headers = self.request_header(
+                        content_type=headers.get("Content-Type", None)
+                    )
+                    retries += 1
+                else:
+                    # Handle plain HTML responses to not pollute the logs
+                    content_type = response.headers.get("content-type", None)
+                    if content_type == "text/html":
+                        response_text = "HTML content (only printed in debug log)"
+                    else:
+                        response_text = response.text
+
+                    if show_error:
+                        logger.error(
+                            "%s; status -> %s/%s; error -> %s",
+                            failure_message,
+                            response.status_code,
+                            HTTPStatus(response.status_code).phrase,
+                            response_text,
+                        )
+                    elif show_warning:
+                        logger.warning(
+                            "%s; status -> %s/%s; warning -> %s",
+                            warning_message if warning_message else failure_message,
+                            response.status_code,
+                            HTTPStatus(response.status_code).phrase,
+                            response_text,
+                        )
+                    if content_type == "text/html":
+                        logger.debug(
+                            "%s; status -> %s/%s; warning -> %s",
+                            failure_message,
+                            response.status_code,
+                            HTTPStatus(response.status_code).phrase,
+                            response.text,
+                        )
+                    return None
+            except requests.exceptions.Timeout:
+                if retries <= max_retries:
+                    logger.warning(
+                        "Request timed out. Retrying in %s seconds...",
+                        str(REQUEST_RETRY_DELAY),
+                    )
+                    retries += 1
+                    time.sleep(REQUEST_RETRY_DELAY)  # Add a delay before retrying
+                else:
+                    logger.error(
+                        "%s; timeout error",
+                        failure_message,
+                    )
+                    if retry_forever:
+                        # If it fails after REQUEST_MAX_RETRIES retries we let it wait forever
+                        logger.warning("Turn timeouts off and wait forever...")
+                        timeout = None
+                    else:
+                        return None
+            except requests.exceptions.ConnectionError:
+                if retries <= max_retries:
+                    logger.warning(
+                        "Connection error. Retrying in %s seconds...",
+                        str(REQUEST_RETRY_DELAY),
+                    )
+                    retries += 1
+                    time.sleep(REQUEST_RETRY_DELAY)  # Add a delay before retrying
+                else:
+                    logger.error(
+                        "%s; connection error",
+                        failure_message,
+                    )
+                    if retry_forever:
+                        # If it fails after REQUEST_MAX_RETRIES retries we let it wait forever
+                        logger.warning("Turn timeouts off and wait forever...")
+                        timeout = None
+                        time.sleep(REQUEST_RETRY_DELAY)  # Add a delay before retrying
+                    else:
+                        return None
+            # end try
+            logger.debug(
+                "Retrying REST API %s call -> %s... (retry = %s)",
+                method,
+                url,
+                str(retries),
+            )
+        # end while True
+
+    # end method definition
+
     def parse_request_response(
         self,
         response_object: requests.Response,
@@ -278,16 +515,16 @@ class Salesforce(object):
 
         # Already authenticated and session still valid?
         if self._access_token and not revalidate:
-            logger.info(
+            logger.debug(
                 "Session still valid - return existing access token -> %s",
                 str(self._access_token),
             )
             return self._access_token
 
         request_url = self.config()["authenticationUrl"]
-        request_header = request_login_headers
+        request_header = REQUEST_LOGIN_HEADERS
 
-        logger.info("Requesting Salesforce Access Token from -> %s", request_url)
+        logger.debug("Requesting Salesforce Access Token from -> %s", request_url)
 
         authenticate_post_body = self.credentials()
 
@@ -346,70 +583,27 @@ class Salesforce(object):
         """
 
         if not self._access_token or not self._instance_url:
-            logger.error("Authentication required.")
-            return None
+            self.authenticate()
 
         request_header = self.request_header()
-        request_url = f"{self._instance_url}/services/data/v52.0/query/"
+        request_url = self.config()["queryUrl"]
 
         query = f"SELECT Id FROM {object_type} WHERE {name_field} = '{name}'"
 
-        retries = 0
-        while True:
-            response = requests.get(
-                request_url,
-                headers=request_header,
-                params={"q": query},
-                timeout=REQUEST_TIMEOUT,
-            )
-            if response.ok:
-                response = self.parse_request_response(response)
-                object_id = self.get_result_value(response, "Id")
-                return object_id
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                request_header = self.request_header()
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to get Salesforce object ID for object type -> %s and object name -> %s; status -> %s; error -> %s",
-                    object_type,
-                    name,
-                    response.status_code,
-                    response.text,
-                )
-                return None
-
-    # end method definition
-
-    def get_profile_id(self, profile_name: str) -> Optional[str]:
-        """Get a user profile ID by profile name.
-
-        Args:
-            profile_name (str): Name of the User Profile.
-
-        Returns:
-            Optional[str]: Technical ID of the user profile.
-        """
-
-        return self.get_object_id_by_name(object_type="Profile", name=profile_name)
-
-    # end method definition
-
-    def get_user_id(self, username: str) -> Optional[str]:
-        """Get a user ID by user name.
-
-        Args:
-            username (str): Name of the User.
-
-        Returns:
-            Optional[str]: Technical ID of the user
-        """
-
-        return self.get_object_id_by_name(
-            object_type="User", name=username, name_field="Username"
+        response = self.do_request(
+            method="GET",
+            url=request_url,
+            headers=request_header,
+            params={"q": query},
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to get Salesforce object ID for object type -> '{}' and object name -> '{}'".format(
+                object_type, name
+            ),
         )
+        if not response:
+            return None
+
+        return self.get_result_value(response, "Id")
 
     # end method definition
 
@@ -433,11 +627,33 @@ class Salesforce(object):
 
         Returns:
             dict | None: Dictionary with the Salesforce object data.
+
+            Example response:
+            {
+                'totalSize': 2,
+                'done': True,
+                'records': [
+                    {
+                        'attributes': {
+                            'type': 'Opportunity',
+                            'url': '/services/data/v60.0/sobjects/Opportunity/006Dn00000EclybIAB'
+                        },
+                        'Id': '006Dn00000EclybIAB'
+                    },
+                    {
+                        'attributes': {
+                            'type': 'Opportunity',
+                            'url': '/services/data/v60.0/sobjects/Opportunity/006Dn00000EclyfIAB'
+                        },
+                        'Id': '006Dn00000EclyfIAB'
+                    }
+                ]
+            }
         """
 
         if not self._access_token or not self._instance_url:
-            logger.error("Authentication required.")
-            return None
+            self.authenticate()
+
         if search_field and not search_value:
             logger.error(
                 "No search value has been provided for search field -> %s!",
@@ -445,7 +661,7 @@ class Salesforce(object):
             )
             return None
         if not result_fields:
-            logger.info(
+            logger.debug(
                 "No result fields defined. Using 'FIELDS(STANDARD)' to deliver all standard fields of the object."
             )
             result_fields = ["FIELDS(STANDARD)"]
@@ -456,32 +672,21 @@ class Salesforce(object):
         query += " LIMIT {}".format(str(limit))
 
         request_header = self.request_header()
-        request_url = f"{self._instance_url}/services/data/v52.0/query/?q={query}"
+        request_url = self.config()["queryUrl"] + "?q={}".format(query)
 
-        logger.info(
+        logger.debug(
             "Sending query -> %s to Salesforce; calling -> %s", query, request_url
         )
 
-        retries = 0
-        while True:
-            response = requests.get(request_url, headers=request_header, timeout=30)
-            if response.ok:
-                return self.parse_request_response(response)
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                request_header = self.request_header()
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to retrieve Salesforce object -> %s with %s = %s; status -> %s; error -> %s",
-                    object_type,
-                    search_field,
-                    search_value,
-                    response.status_code,
-                    response.text,
-                )
-                return None
+        return self.do_request(
+            method="GET",
+            url=request_url,
+            headers=request_header,
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to retrieve Salesforce object type -> '{}' with {} = {}".format(
+                object_type, search_field, search_value
+            ),
+        )
 
     # end method definition
 
@@ -491,9 +696,10 @@ class Salesforce(object):
 
         Args:
             object_type (str): Type of the Salesforce business object, like "Account" or "Case".
+            **kwargs (dict): keyword / value ictionary with additional parameters
 
         Returns:
-            dict | None: Dictionary with the Salesforce Case data or None if the request fails.
+            dict | None: Dictionary with the Salesforce object data or None if the request fails.
         """
 
         match object_type:
@@ -568,49 +774,237 @@ class Salesforce(object):
 
     # end method definition
 
-    def get_user(self, user_id: str) -> dict | None:
-        """Get a Salesforce user based on its ID.
+    def get_group_id(self, groupname: str) -> Optional[str]:
+        """Get a group ID by group name.
 
         Args:
-            user_id (str): ID of the Salesforce user
+            groupname (str): Name of the Group.
 
         Returns:
-            dict | None: Dictionary with the Salesforce user data or None if the request fails.
+            Optional[str]: Technical ID of the group
+        """
+
+        return self.get_object_id_by_name(
+            object_type="Group", name=groupname, name_field="Name"
+        )
+
+    # end method definition
+
+    def get_group(self, group_id: str) -> dict | None:
+        """Get a Salesforce group based on its ID.
+
+        Args:
+            group_id (str): ID of the Salesforce group
+
+        Returns:
+            dict | None: Dictionary with the Salesforce group data or None if the request fails.
         """
 
         if not self._access_token or not self._instance_url:
-            logger.error("Authentication required.")
-            return None
+            self.authenticate()
 
         request_header = self.request_header()
-        request_url = (
-            f"{self._instance_url}/services/data/v52.0/sobjects/User/{user_id}"
+        request_url = self.config()["groupUrl"] + group_id
+
+        logger.debug(
+            "Get Salesforce group with ID -> %s; calling -> %s", group_id, request_url
         )
 
-        logger.info(
-            "Get Salesforce user with ID -> %s; calling -> %s", user_id, request_url
+        return self.do_request(
+            method="GET",
+            url=request_url,
+            headers=request_header,
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to get Salesforce group with ID -> {}".format(
+                group_id
+            ),
         )
 
-        retries = 0
-        while True:
-            response = requests.get(
-                request_url, headers=request_header, timeout=REQUEST_TIMEOUT
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                request_header = self.request_header()
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to get Salesforce user -> %s; status -> %s; error -> %s",
-                    user_id,
-                    response.status_code,
-                    response.text,
-                )
-                return None
+    # end method definition
+
+    def add_group(
+        self,
+        group_name: str,
+        group_type: str = "Regular",
+    ) -> dict | None:
+        """Add a new Salesforce group.
+
+        Args:
+            group_name (str): Name of the new Salesforce group
+
+        Returns:
+            dict | None: Dictionary with the Salesforce Group data or None if the request fails.
+
+            Example response:
+            {
+                'id': '00GDn000000KWE0MAO',
+                'success': True,
+                'errors': []
+            }
+        """
+
+        if not self._access_token or not self._instance_url:
+            self.authenticate()
+
+        request_header = self.request_header()
+        request_url = self.config()["groupUrl"]
+
+        payload = {"Name": group_name, "Type": group_type}
+
+        logger.debug(
+            "Adding Salesforce group -> %s; calling -> %s", group_name, request_url
+        )
+
+        return self.do_request(
+            method="POST",
+            url=request_url,
+            headers=request_header,
+            data=json.dumps(payload),
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to add Salesforce group -> '{}'".format(group_name),
+        )
+
+    # end method definition
+
+    def update_group(
+        self,
+        group_id: str,
+        update_data: dict,
+    ) -> dict | None:
+        """Update a Salesforce group.
+
+        Args:
+            group_id (str): The Salesforce group ID.
+            update_data (dict): Dictionary containing the fields to update.
+
+        Returns:
+            dict: Response from the Salesforce API.
+        """
+
+        if not self._access_token or not self._instance_url:
+            self.authenticate()
+
+        request_header = self.request_header()
+
+        request_url = self.config()["groupUrl"] + group_id
+
+        logger.debug(
+            "Update Salesforce group with ID -> %s; calling -> %s",
+            group_id,
+            request_url,
+        )
+
+        return self.do_request(
+            method="PATCH",
+            url=request_url,
+            headers=request_header,
+            json_data=update_data,
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to update Salesforce group with ID -> {}".format(
+                group_id
+            ),
+        )
+
+    # end method definition
+
+    def get_group_members(self, group_id: str) -> list | None:
+        """Get Salesforce group members
+
+        Args:
+            group_id (str): Id of the group to retrieve the members
+
+        Returns:
+            list | None: result
+
+            Example response:
+            {
+                'totalSize': 1,
+                'done': True,
+                'records': [
+                    {
+                        'attributes': {
+                            'type': 'GroupMember',
+                            'url': '/services/data/v60.0/sobjects/GroupMember/011Dn000000ELhwIAG'
+                        },
+                        'UserOrGroupId': '00GDn000000KWE5MAO'
+                    }
+                ]
+            }
+        """
+
+        if not self._access_token or not self._instance_url:
+            self.authenticate()
+
+        request_header = self.request_header()
+
+        request_url = self.config()["queryUrl"]
+
+        query = f"SELECT UserOrGroupId FROM GroupMember WHERE GroupId = '{group_id}'"
+        params = {"q": query}
+
+        logger.debug(
+            "Get members of Salesforce group with ID -> %s; calling -> %s",
+            group_id,
+            request_url,
+        )
+
+        return self.do_request(
+            method="GET",
+            url=request_url,
+            headers=request_header,
+            params=params,
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to get members of Salesforce group with ID -> {}".format(
+                group_id
+            ),
+        )
+
+    # end method definition
+
+    def add_group_member(self, group_id: str, member_id: str) -> dict | None:
+        """Add a user or group to a Salesforce group
+
+        Args:
+            group_id (str): ID of the Salesforce Group to add member to.
+            member_id (str): ID of the user or group.
+
+        Returns:
+            dict | None: Dictionary with the Salesforce membership data or None if the request fails.
+
+            Example response (id is the membership ID):
+            {
+                'id': '011Dn000000ELhwIAG',
+                'success': True,
+                'errors': []
+            }
+        """
+
+        if not self._access_token or not self._instance_url:
+            self.authenticate()
+
+        request_url = self.config()["groupMemberUrl"]
+
+        request_header = self.request_header()
+
+        payload = {"GroupId": group_id, "UserOrGroupId": member_id}
+
+        logger.debug(
+            "Add member with ID -> %s to Salesforce group with ID -> %s; calling -> %s",
+            member_id,
+            group_id,
+            request_url,
+        )
+
+        return self.do_request(
+            method="POST",
+            url=request_url,
+            headers=request_header,
+            json_data=payload,
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to add member with ID -> {} to Salesforce group with ID -> {}".format(
+                member_id, group_id
+            ),
+        )
 
     # end method definition
 
@@ -632,8 +1026,7 @@ class Salesforce(object):
                             'url': '/services/data/v52.0/sobjects/Profile/00eDn000001msL8IAI'},
                             'Id': '00eDn000001msL8IAI',
                             'Name': 'Standard User',
-                            'CreatedById':
-                            '005Dn000001rRodIAE',
+                            'CreatedById': '005Dn000001rRodIAE',
                             'CreatedDate': '2022-11-30T15:30:54.000+0000',
                             'Description': None,
                             'LastModifiedById': '005Dn000001rUacIAE',
@@ -648,36 +1041,83 @@ class Salesforce(object):
         """
 
         if not self._access_token or not self._instance_url:
-            logger.error("Authentication required.")
-            return None
+            self.authenticate()
 
         request_header = self.request_header()
-        request_url = f"{self._instance_url}/services/data/v52.0/query/"
+        request_url = self.config()["queryUrl"]
 
         query = "SELECT Id, Name, CreatedById, CreatedDate, Description, LastModifiedById, LastModifiedDate, PermissionsCustomizeApplication, PermissionsEditTask, PermissionsImportLeads FROM Profile"
 
-        retries = 0
-        while True:
-            response = requests.get(
-                request_url,
-                headers=request_header,
-                params={"q": query},
-                timeout=REQUEST_TIMEOUT,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                request_header = self.request_header()
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to get Salesforce user profiles; status -> %s; error -> %s",
-                    response.status_code,
-                    response.text,
-                )
-                return None
+        return self.do_request(
+            method="GET",
+            url=request_url,
+            headers=request_header,
+            params={"q": query},
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to get Salesforce user profiles",
+        )
+
+    # end method definition
+
+    def get_user_profile_id(self, profile_name: str) -> Optional[str]:
+        """Get a user profile ID by profile name.
+
+        Args:
+            profile_name (str): Name of the User Profile.
+
+        Returns:
+            Optional[str]: Technical ID of the user profile.
+        """
+
+        return self.get_object_id_by_name(object_type="Profile", name=profile_name)
+
+    # end method definition
+
+    def get_user_id(self, username: str) -> Optional[str]:
+        """Get a user ID by user name.
+
+        Args:
+            username (str): Name of the User.
+
+        Returns:
+            Optional[str]: Technical ID of the user
+        """
+
+        return self.get_object_id_by_name(
+            object_type="User", name=username, name_field="Username"
+        )
+
+    # end method definition
+
+    def get_user(self, user_id: str) -> dict | None:
+        """Get a Salesforce user based on its ID.
+
+        Args:
+            user_id (str): ID of the Salesforce user
+
+        Returns:
+            dict | None: Dictionary with the Salesforce user data or None if the request fails.
+        """
+
+        if not self._access_token or not self._instance_url:
+            self.authenticate()
+
+        request_header = self.request_header()
+        request_url = self.config()["userUrl"] + user_id
+
+        logger.debug(
+            "Get Salesforce user with ID -> %s; calling -> %s", user_id, request_url
+        )
+
+        return self.do_request(
+            method="GET",
+            url=request_url,
+            headers=request_header,
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to get Salesforce user with ID -> {}".format(
+                user_id
+            ),
+        )
 
     # end method definition
 
@@ -685,23 +1125,35 @@ class Salesforce(object):
         self,
         username: str,
         email: str,
-        password: str,
         firstname: str,
         lastname: str,
+        title: str | None = None,
+        department: str | None = None,
+        company_name: str = "Innovate",
+        profile_name: Optional[str] = "Standard User",
         profile_id: Optional[str] = None,
+        time_zone_key: Optional[str] = "America/Los_Angeles",
+        email_encoding_key: Optional[str] = "ISO-8859-1",
+        locale_key: Optional[str] = "en_US",
         alias: Optional[str] = None,
     ) -> dict | None:
-        """Add a new Salesforce user.
+        """Add a new Salesforce user. The password has to be set separately.
 
         Args:
             username (str): Login name of the new user
             email (str): Email of the new user
-            password (str): Password of the new user
             firstname (str): First name of the new user.
             lastname (str): Last name of the new user.
+            title (str): Title of the user.
+            department (str): Department of the user.
+            company_name (str): Name of the Company of the user.
+            profile_name (str): Profile name like "Standard User"
             profile_id (str, optional): Profile ID of the new user. Defaults to None.
                                         Use method get_all_user_profiles() to determine
-                                        the desired Profile for the user.
+                                        the desired Profile for the user. Or pass the profile_name.
+            time_zone_key (str, optional) in format country/city like "America/Los_Angeles",
+            email_encoding_key (str, optional). Default is "ISO-8859-1".
+            locale_key (str, optional). Default is "en_US".
             alias (str, optional): Alias of the new user. Defaults to None.
 
         Returns:
@@ -709,49 +1161,193 @@ class Salesforce(object):
         """
 
         if not self._access_token or not self._instance_url:
-            logger.error("Authentication required.")
-            return None
+            self.authenticate()
 
         request_header = self.request_header()
-        request_url = f"{self._instance_url}/services/data/v52.0/sobjects/User/"
+        request_url = self.config()["userUrl"]
+
+        # if just a profile name is given then we determine the profile ID by the name:
+        if profile_name and not profile_id:
+            profile_id = self.get_user_profile_id(profile_name)
 
         payload = {
             "Username": username,
             "Email": email,
-            "Password": password,
             "FirstName": firstname,
             "LastName": lastname,
             "ProfileId": profile_id,
-            "Alias": alias,
+            "Department": department,
+            "CompanyName": company_name,
+            "Title": title,
+            "Alias": alias if alias else username,
+            "TimeZoneSidKey": time_zone_key,  # Set default TimeZoneSidKey
+            "LocaleSidKey": locale_key,  # Set default LocaleSidKey
+            "EmailEncodingKey": email_encoding_key,  # Set default EmailEncodingKey
+            "LanguageLocaleKey": locale_key,  # Set default LanguageLocaleKey
         }
 
-        logger.info(
+        logger.debug(
             "Adding Salesforce user -> %s; calling -> %s", username, request_url
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                request_url,
-                headers=request_header,
-                data=json.dumps(payload),
-                timeout=REQUEST_TIMEOUT,
+        return self.do_request(
+            method="POST",
+            url=request_url,
+            headers=request_header,
+            data=json.dumps(payload),
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to add Salesforce user -> {}".format(username),
+        )
+
+    # end method definition
+
+    def update_user(
+        self,
+        user_id: str,
+        update_data: dict,
+    ) -> dict:
+        """Update a Salesforce user.
+
+        Args:
+            user_id (str): The Salesforce user ID.
+            update_data (dict): Dictionary containing the fields to update.
+
+        Returns:
+            dict: Response from the Salesforce API.
+        """
+
+        if not self._access_token or not self._instance_url:
+            self.authenticate()
+
+        request_header = self.request_header()
+
+        request_url = self.config()["userUrl"] + user_id
+
+        logger.debug(
+            "Update Salesforce user with ID -> %s; calling -> %s", user_id, request_url
+        )
+
+        return self.do_request(
+            method="PATCH",
+            url=request_url,
+            headers=request_header,
+            json_data=update_data,
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to update Salesforce user with ID -> {}".format(
+                user_id
+            ),
+        )
+
+    # end method definition
+
+    def update_user_password(
+        self,
+        user_id: str,
+        password: str,
+    ) -> dict:
+        """Update the password of a Salesforce user.
+
+        Args:
+            user_id (str): The Salesforce user ID.
+            password (str): New user password.
+
+        Returns:
+            dict: Response from the Salesforce API.
+        """
+
+        if not self._access_token or not self._instance_url:
+            self.authenticate()
+
+        request_header = self.request_header()
+
+        request_url = self.config()["userUrl"] + "{}/password".format(user_id)
+
+        logger.debug(
+            "Update password of Salesforce user with ID -> %s; calling -> %s",
+            user_id,
+            request_url,
+        )
+
+        update_data = {"NewPassword": password}
+
+        return self.do_request(
+            method="POST",
+            url=request_url,
+            headers=request_header,
+            json_data=update_data,
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to update password of Salesforce user with ID -> {}".format(
+                user_id
+            ),
+        )
+
+    # end method definition
+
+    def update_user_photo(
+        self,
+        user_id: str,
+        photo_path: str,
+    ) -> dict | None:
+        """Update the Salesforce user photo.
+
+        Args:
+            user_id (str): Salesforce ID of the user
+            photo_path (str): file system path with the location of the photo
+        Returns:
+            dict | None: Dictionary with the Salesforce User data or None if the request fails.
+        """
+
+        if not self._access_token or not self._instance_url:
+            self.authenticate()
+
+        # Check if the photo file exists
+        if not os.path.isfile(photo_path):
+            logger.error("Photo file -> %s not found!", photo_path)
+            return None
+
+        try:
+            # Read the photo file as binary data
+            with open(photo_path, "rb") as image_file:
+                photo_data = image_file.read()
+        except OSError as exception:
+            # Handle any errors that occurred while reading the photo file
+            logger.error(
+                "Error reading photo file -> %s; error -> %s", photo_path, exception
             )
-            if response.ok:
-                return self.parse_request_response(response)
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                request_header = self.request_header()
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add Salesforce user -> %s; status -> %s; error -> %s",
-                    username,
-                    response.status_code,
-                    response.text,
-                )
-                return None
+            return None
+
+        # Content Type = None is important as upload calls need
+        # a multipart header that is automatically selected if None is used:
+        request_header = self.request_header(content_type=None)
+
+        data = {"json": json.dumps({"cropX": 0, "cropY": 0, "cropSize": 200})}
+        request_url = self.config()["connectUrl"] + f"user-profiles/{user_id}/photo"
+        files = {
+            "fileUpload": (
+                photo_path,
+                photo_data,
+                "application/octet-stream",
+            )
+        }
+
+        logger.debug(
+            "Update profile photo of Salesforce user with ID -> %s; calling -> %s",
+            user_id,
+            request_url,
+        )
+
+        return self.do_request(
+            method="POST",
+            url=request_url,
+            headers=request_header,
+            files=files,
+            data=data,
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to update profile photo of Salesforce user with ID -> {}".format(
+                user_id
+            ),
+            verify=False,
+        )
 
     # end method definition
 
@@ -783,11 +1379,10 @@ class Salesforce(object):
         """
 
         if not self._access_token or not self._instance_url:
-            logger.error("Authentication required.")
-            return None
+            self.authenticate()
 
         request_header = self.request_header()
-        request_url = f"{self._instance_url}/services/data/v52.0/sobjects/Account/"
+        request_url = self.config()["accountUrl"]
 
         payload = {
             "Name": account_name,
@@ -800,33 +1395,23 @@ class Salesforce(object):
         }
         payload.update(kwargs)  # Add additional fields from kwargs
 
-        logger.info(
-            "Adding Salesforce account -> %s; calling -> %s", account_name, request_url
+        logger.debug(
+            "Adding Salesforce account -> '%s' (%s); calling -> %s",
+            account_name,
+            account_number,
+            request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                request_url,
-                headers=request_header,
-                data=json.dumps(payload),
-                timeout=REQUEST_TIMEOUT,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                request_header = self.request_header()
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add Salesforce account -> %s; status -> %s; error -> %s",
-                    account_name,
-                    response.status_code,
-                    response.text,
-                )
-                return None
+        return self.do_request(
+            method="POST",
+            url=request_url,
+            headers=request_header,
+            data=json.dumps(payload),
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to add Salesforce account -> '{}' ({})".format(
+                account_name, account_number
+            ),
+        )
 
     # end method definition
 
@@ -851,11 +1436,10 @@ class Salesforce(object):
         """
 
         if not self._access_token or not self._instance_url:
-            logger.error("Authentication required.")
-            return None
+            self.authenticate()
 
         request_header = self.request_header()
-        request_url = f"{self._instance_url}/services/data/v52.0/sobjects/Product2/"
+        request_url = self.config()["productUrl"]
 
         payload = {
             "Name": product_name,
@@ -865,33 +1449,23 @@ class Salesforce(object):
         }
         payload.update(kwargs)  # Add additional fields from kwargs
 
-        logger.info(
-            "Add Salesforce product -> %s; calling -> %s", product_name, request_url
+        logger.debug(
+            "Add Salesforce product -> '%s' (%s); calling -> %s",
+            product_name,
+            product_code,
+            request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                request_url,
-                headers=request_header,
-                data=json.dumps(payload),
-                timeout=REQUEST_TIMEOUT,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                request_header = self.request_header()
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add Salesforce product -> %s; status -> %s; error -> %s",
-                    product_name,
-                    response.status_code,
-                    response.text,
-                )
-                return None
+        return self.do_request(
+            method="POST",
+            url=request_url,
+            headers=request_header,
+            data=json.dumps(payload),
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to add Salesforce product -> '{}' ({})".format(
+                product_name, product_code
+            ),
+        )
 
     # end method definition
 
@@ -922,11 +1496,10 @@ class Salesforce(object):
         """
 
         if not self._access_token or not self._instance_url:
-            logger.error("Authentication required.")
-            return None
+            self.authenticate()
 
         request_header = self.request_header()
-        request_url = f"{self._instance_url}/services/data/v52.0/sobjects/Opportunity/"
+        request_url = self.config()["opportunityUrl"]
 
         payload = {
             "Name": name,
@@ -939,33 +1512,20 @@ class Salesforce(object):
             payload["Description"] = description
         payload.update(kwargs)  # Add additional fields from kwargs
 
-        logger.info(
-            "Add Salesforce opportunity -> %s; calling -> %s", name, request_url
+        logger.debug(
+            "Add Salesforce opportunity -> '%s'; calling -> %s", name, request_url
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                request_url,
-                headers=request_header,
-                data=json.dumps(payload),
-                timeout=REQUEST_TIMEOUT,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                request_header = self.request_header()
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add Salesforce opportunity -> %s; status -> %s; error -> %s",
-                    name,
-                    response.status_code,
-                    response.text,
-                )
-                return None
+        return self.do_request(
+            method="POST",
+            url=request_url,
+            headers=request_header,
+            data=json.dumps(payload),
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to add Salesforce opportunity -> '{}'".format(name),
+        )
+
+    # end method definition
 
     def add_case(
         self,
@@ -990,6 +1550,7 @@ class Salesforce(object):
             priority (str): Priority of the case. Typical values: "High", "Medium", "Low".
             origin (str): origin (source) of the case. Typical values: "Email", "Phone", "Web"
             account_id (str): technical ID of the related Account
+            owner_id (str): owner of the case
             asset_id (str): technical ID of the related Asset
             product_id (str): technical ID of the related Product
             kwargs (Any): additional values (e.g. custom fields)
@@ -999,11 +1560,10 @@ class Salesforce(object):
         """
 
         if not self._access_token or not self._instance_url:
-            logger.error("Authentication required.")
-            return None
+            self.authenticate()
 
         request_header = self.request_header()
-        request_url = f"{self._instance_url}/services/data/v52.0/sobjects/Case/"
+        request_url = self.config()["caseUrl"]
 
         payload = {
             "Subject": subject,
@@ -1021,31 +1581,16 @@ class Salesforce(object):
             payload["ProductId"] = product_id
         payload.update(kwargs)  # Add additional fields from kwargs
 
-        logger.info("Add Salesforce case -> %s; calling -> %s", subject, request_url)
+        logger.debug("Add Salesforce case -> '%s'; calling -> %s", subject, request_url)
 
-        retries = 0
-        while True:
-            response = requests.post(
-                request_url,
-                headers=request_header,
-                data=json.dumps(payload),
-                timeout=REQUEST_TIMEOUT,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                request_header = self.request_header()
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add Salesforce case -> %s; status -> %s; error -> %s",
-                    subject,
-                    response.status_code,
-                    response.text,
-                )
-                return None
+        return self.do_request(
+            method="POST",
+            url=request_url,
+            headers=request_header,
+            data=json.dumps(payload),
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to add Salesforce case -> '{}'".format(subject),
+        )
 
     # end method definition
 
@@ -1077,11 +1622,10 @@ class Salesforce(object):
         """
 
         if not self._access_token or not self._instance_url:
-            logger.error("Authentication required.")
-            return None
+            self.authenticate()
 
         request_header = self.request_header()
-        request_url = f"{self._instance_url}/services/data/v52.0/sobjects/Asset/"
+        request_url = self.config()["assetUrl"]
 
         payload = {
             "Name": asset_name,
@@ -1095,33 +1639,18 @@ class Salesforce(object):
             payload["Description"] = description
         payload.update(kwargs)  # Add additional fields from kwargs
 
-        logger.info(
-            "Add Salesforce asset -> %s; calling -> %s", asset_name, request_url
+        logger.debug(
+            "Add Salesforce asset -> '%s'; calling -> %s", asset_name, request_url
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                request_url,
-                headers=request_header,
-                data=json.dumps(payload),
-                timeout=REQUEST_TIMEOUT,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                request_header = self.request_header()
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add Salesforce user -> %s; status -> %s; error -> %s",
-                    asset_name,
-                    response.status_code,
-                    response.text,
-                )
-                return None
+        return self.do_request(
+            method="POST",
+            url=request_url,
+            headers=request_header,
+            data=json.dumps(payload),
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to add Salesforce asset -> '{}'".format(asset_name),
+        )
 
     # end method definition
 
@@ -1151,11 +1680,10 @@ class Salesforce(object):
         """
 
         if not self._access_token or not self._instance_url:
-            logger.error("Authentication required.")
-            return None
+            self.authenticate()
 
         request_header = self.request_header()
-        request_url = f"{self._instance_url}/services/data/v52.0/sobjects/Contract/"
+        request_url = self.config()["contractUrl"]
 
         payload = {
             "AccountId": account_id,
@@ -1169,34 +1697,21 @@ class Salesforce(object):
             payload["ContractType"] = contract_type
         payload.update(kwargs)  # Add additional fields from kwargs
 
-        logger.info(
-            "Adding Salesforce contract for account ID -> %s; calling -> %s",
+        logger.debug(
+            "Adding Salesforce contract for account with ID -> %s; calling -> %s",
             account_id,
             request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                request_url,
-                headers=request_header,
-                data=json.dumps(payload),
-                timeout=REQUEST_TIMEOUT,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                request_header = self.request_header()
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add Salesforce contract for account ID -> %s; status -> %s; error -> %s",
-                    account_id,
-                    response.status_code,
-                    response.text,
-                )
-                return None
+        return self.do_request(
+            method="POST",
+            url=request_url,
+            headers=request_header,
+            data=json.dumps(payload),
+            timeout=REQUEST_TIMEOUT,
+            failure_message="Failed to add Salesforce contract for account with ID -> {}".format(
+                account_id
+            ),
+        )
 
     # end method definition