flowtask 5.8.4__cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

plugins/sources/venu.py

@@ -0,0 +1,244 @@
+from typing import Any
+from datetime import datetime, timedelta
+from urllib.parse import urlencode
+import pytz
+from navconfig.logging import logging
+from asyncdb.exceptions import NoDataFound
+from querysource.exceptions import DataNotFound
+from querysource.providers.sources import restSource
+
+
+class venu(restSource):
+    """VenU.
+
+        Get all information from VenU API
+    """
+    base_url: str = 'https://{main_url}/lms/datacore/api/GET/{endpoint}/'
+
+    def __post_init__(
+            self,
+            definition: dict = None,
+            conditions: dict = None,
+            request: Any = None,
+            **kwargs
+    ) -> None:
+        self._headers['Content-Type'] = 'application/x-www-form-urlencoded'
+        self.method = 'get'
+        if 'main_url' in self._conditions:
+            conditions['main_url'] = self._conditions['main_url']
+            del self._conditions['main_url']
+        else:
+            conditions['main_url'] = self._env.get('VENU_BASE_URL')
+            if not conditions['main_url']:
+                try:
+                    conditions['main_url'] = definition.params['main_url']
+                except (ValueError, AttributeError) as ex:
+                    raise ValueError("VenU: Missing Base URL") from ex
+        self.url = 'https://{main_url}/lms/datacore/api/GET/{endpoint}/'
+        # Credentials
+        if 'username' in self._conditions:
+            self._user = self._conditions['username']
+            del self._conditions['username']
+        else:
+            self._user = self._env.get('VENU_USERNAME')
+            if not self._user:
+                try:
+                    self._user = definition.params['username']
+                except (ValueError, AttributeError) as ex:
+                    raise ValueError("VenU: Missing UserName") from ex
+
+        if 'password' in self._conditions:
+            self._pwd = self._conditions['password']
+            del self._conditions['password']
+        else:
+            self._pwd = self._env.get('VENU_PASSWORD')
+            if not self._pwd:
+                try:
+                    self._pwd = definition.params['password']
+                except (ValueError, AttributeError):
+                    raise ValueError("VenU: Missing Password")
+
+        #Delta Timestamp
+        try:
+            print('>>>', self._conditions)
+            if 'delta_timestamp' in self._conditions:
+                tz = pytz.timezone('America/New_York')
+                dt = datetime.strptime(self._conditions['delta_timestamp'], "%Y-%m-%dT%H:%M:%S")
+                dt = tz.localize(dt, is_dst=None)
+                self._conditions['delta_timestamp'] = int((dt - datetime(1970, 1, 1, tzinfo=pytz.utc)).total_seconds())
+                self._conditions['delta_timestamp']
+            #else:
+            #    self._conditions['delta_timestamp'] = (datetime.now() - timedelta(days = 14)).strftime('%s')
+        except Exception as err:
+            logging.error(
+                f"VenU API: wrong date format: {err}"
+            )
+            raise ValueError(
+                f"VenU: Wrong Date Format: {err}"
+            ) from err
+
+        try:
+            self.type = definition.params['type']
+        except (ValueError, AttributeError):
+            self.type = None
+        if 'type' in self._conditions:
+            self.type = self._conditions['type']
+            del self._conditions['type']
+
+        if self.type == 'users':
+            if 'delta_timestamp' in self._conditions:
+                del self._conditions['delta_timestamp']
+            if 'report_type' in self._conditions:
+                self._conditions['reportType'] = self._conditions['report_type']
+            else:
+                self._conditions['reportType'] = 'UserAPI'
+            if 'is_employee' in self._conditions:
+                self._conditions['u_isemployee'] = self._conditions['is_employee']
+            if 'user_status' in self._conditions:
+                self._conditions['userstatus'] = self._conditions['user_status']
+            conditions['endpoint'] = 'User'
+        if self.type == 'curriculum_list':
+            conditions['endpoint'] = 'CurriculumList'
+        if self.type == 'curriculum_assignments':
+            if not 'delta_timestamp' in self._conditions:
+                self._conditions['delta_timestamp'] = (datetime.now() - timedelta(days = 14)).strftime('%s')
+            conditions['endpoint'] = 'CurriculumAssignments'
+        if self.type == 'curriculum_assignments_removed':
+            if not 'delta_timestamp' in self._conditions:
+                self._conditions['delta_timestamp'] = (datetime.now() - timedelta(days = 14)).strftime('%s')
+            conditions['endpoint'] = 'CurriculumAssignmentsRemoved'
+        if self.type == 'course_list':
+            conditions['endpoint'] = 'CourseList'
+        if self.type == 'course_enrollments':
+            if not 'delta_timestamp' in self._conditions:
+                self._conditions['delta_timestamp'] = (datetime.now() - timedelta(days = 14)).strftime('%s')
+            conditions['endpoint'] = 'CourseEnrollments'
+        if self.type == 'course_enrollments_removed':
+            if not 'delta_timestamp' in self._conditions:
+                self._conditions['delta_timestamp'] = (datetime.now() - timedelta(days = 14)).strftime('%s')
+            conditions['endpoint'] = 'CourseEnrollmentsRemoved'
+        if self.type == 'course_template_list':
+            conditions['endpoint'] = 'CourseTemplateList'
+
+        # set parameters
+        self._args = conditions
+
+    async def users(self):
+        """users.
+
+        Get All Users.
+        """
+        if 'delta_timestamp' in self._conditions:
+            del self._conditions['delta_timestamp']
+        if 'report_type' in self._conditions:
+            self._conditions['reportType'] = self._conditions['report_type']
+        else:
+            self._conditions['reportType'] = 'UserAPI'
+        if 'is_employee' in self._conditions:
+            self._conditions['u_isemployee'] = self._conditions['is_employee']
+        if 'user_status' in self._conditions:
+            self._conditions['userstatus'] = self._conditions['user_status']
+        self._args['endpoint'] = 'User'
+        self._result = await self.query()
+        return self._result
+
+    async def curriculum_list(self):
+        """curriculum_list.
+
+        Get the Curriculum List.
+        """
+        self._args['endpoint'] = 'CurriculumList'
+        self._result = await self.query()
+        return self._result
+
+    async def curriculum_assignments(self):
+        """curriculum_assignments.
+
+        Get the Curriculum Assignments.
+        """
+        if not 'delta_timestamp' in self._conditions:
+            self._conditions['delta_timestamp'] = (datetime.now() - timedelta(days = 14)).strftime('%s')
+        self._args['endpoint'] = 'CurriculumAssignments'
+        self._result = await self.query()
+        return self._result
+
+    async def curriculum_assignments_removed(self):
+        """curriculum_assignments_removed.
+
+        Get the Curriculum Assignments Removed.
+        """
+        if not 'delta_timestamp' in self._conditions:
+            self._conditions['delta_timestamp'] = (datetime.now() - timedelta(days = 14)).strftime('%s')
+        self._args['endpoint'] = 'CurriculumAssignmentsRemoved'
+        self._result = await self.query()
+        return self._result
+
+    async def course_list(self):
+        """course_list.
+
+        Get the Course List.
+        """
+        self._args['endpoint'] = 'CourseList'
+        self._result = await self.query()
+        return self._result
+
+    async def course_enrollments(self):
+        """course_enrollments.
+
+        Get the Course Enrollments.
+        """
+        if not 'delta_timestamp' in self._conditions:
+            self._conditions['delta_timestamp'] = (datetime.now() - timedelta(days = 14)).strftime('%s')
+        self._args['endpoint'] = 'CourseEnrollments'
+        self._result = await self.query()
+        return self._result
+
+    async def course_enrollments_removed(self):
+        """course_enrollments_removed.
+
+        Get the Course Enrollments Removed.
+        """
+        if not 'delta_timestamp' in self._conditions:
+            self._conditions['delta_timestamp'] = (datetime.now() - timedelta(days = 14)).strftime('%s')
+        self._args['endpoint'] = 'CourseEnrollmentsRemoved'
+        self._result = await self.query()
+        return self._result
+
+    async def course_template_list(self):
+        """course_template_list.
+
+        Get the Course Template List.
+        """
+        self._args['endpoint'] = 'CourseTemplateList'
+        self._result = await self.query()
+        return self._result
+
+    async def query(self):
+        """
+            Query.
+            Basic Query of VenU API.
+        """
+        self._result = None
+        # create URL
+        self.url = self.build_url(
+            self.url,
+            args=self._args,
+            queryparams=urlencode(self._conditions)
+        )
+        result = []
+        try:
+            result, error = await self.request(
+                self.url,
+                self.method
+            )
+            if error is not None:
+                logging.error(f'VenU: Error: {error!s}')
+            elif not result['Data']:
+                raise DataNotFound('VenU: No data was found')
+            else:
+                self._result = result['Data']
+                return self._result
+        except (DataNotFound, NoDataFound) as err:
+            raise DataNotFound('VenU: No data was found')
+        except Exception as err:
+            logging.error(f'VenU: Error: {err!s}')

plugins/sources/vocinity.py

@@ -0,0 +1,314 @@
+import json
+import logging
+import rapidjson
+import aiohttp
+import pytz
+from datetime import datetime
+from .rest import restSource
+from querysource.exceptions import *
+
+
+class vocinity(restSource):
+    """
+      Vocinity
+        Getting Data from Vocinity servers.
+    """
+
+    base_url: str = 'https://api.vocinity.com'
+    login_url = 'https://api.vocinity.com/public/auth/login'
+    _token_type: str = 'Bearer'
+    _saved_token: str = 'navigator_vocinity_token'
+    pagination: int = 100
+    caching: bool = True  # this component uses Redis
+
+    def __init__(self, definition=None, params: dict = {}, **kwargs):
+        self._token: str = None
+        self._expiration = 3600
+        super(vocinity, self).__init__(definition, params, **kwargs)
+
+        try:
+            self.type = definition.params['type']
+        except (ValueError, AttributeError, KeyError):
+            self.type = None
+
+        try:
+            self.type = self._params['type']
+            del self._params['type']
+        except (ValueError, AttributeError, KeyError):
+            pass
+
+        try:
+            self.pagination = self._params['pagination']
+            del self._params['pagination']
+        except (KeyError, AttributeError):
+            pass
+
+        if 'type' in params:
+            self.type = params['type']
+            del params['type']
+
+        # Credentials
+        if 'email' in self._params:
+            self.email = self._params['email']
+            del self._params['email']
+        else:
+            self.email = self._env.get('VOCINITY_EMAIL')
+            if not self.email:
+                try:
+                    self.email = definition.params['email']
+                except (ValueError, AttributeError):
+                    raise ValueError("Vocinity: Missing Email")
+
+        if 'password' in self._params:
+            self.password = self._params['password']
+            del self._params['password']
+        else:
+            self.password = self._env.get('VOCINITY_PASSWORD')
+            if not self.password:
+                try:
+                    self.password = definition.params['password']
+                except (ValueError, AttributeError):
+                    raise ValueError("Vocinity: Missing Password")
+
+        try:
+            self.agent = self._params['agent']
+            del self._params['agent']
+        except (ValueError, AttributeError, KeyError):
+            self.agent = None
+
+        if 'startdate' in self._params:
+            try:
+                tz = pytz.timezone('America/New_York')
+                dt1 = datetime.strptime(self._params['startdate'], "%Y-%m-%dT%H:%M:%S")
+                dt1 = tz.localize(dt1, is_dst=None)
+                self._params['startdate'] = dt1.strftime("%Y-%m-%dT%H:%M:%S")
+
+                # .replace(tzinfo=timezone.utc).isoformat()
+
+                dt2 = datetime.strptime(self._params['enddate'], "%Y-%m-%dT%H:%M:%S")
+                dt2 = tz.localize(dt2, is_dst=None)
+                self._params['enddate'] = dt2.strftime("%Y-%m-%dT%H:%M:%S")
+
+                self._startdate = self._params['startdate']
+                self._enddate = self._params['enddate']
+
+                # print('DATES: ', self._startdate, self._enddate)
+
+            except Exception as err:
+                logging.info("Vocinity API: wrong date format: {}".format(str(err)))
+                self._startdate = None
+                self._enddate = None
+            finally:
+                # remove unused conditions
+                try:
+                    del self._params['startdate']
+                    del self._params['enddate']
+                except (KeyError, ValueError, TypeError) as err:
+                    pass
+
+        # set parameters
+        self._args = params
+
+    async def get_token(self):
+        result = None
+        # get the redis connection
+        try:
+            await self._redis.connection()
+        except Exception as err:
+            logging.exception(f'REST Vocinity error: {err!s}')
+            raise
+        # try if is saved on redis:
+        try:
+            result = await self._redis.get(self._saved_token)
+            if result:
+                data = rapidjson.loads(result)
+                logging.debug(':: Vocinity: Using credentials in Cache')
+                self._token = data['token']
+                return self._token
+        except Exception as err:
+            print(err)
+            logging.exception(f'Vocinity Redis Error: {err!s}')
+            raise
+        # else: get token from URL
+        data = {
+            "email": self.email,
+            "password": self.password
+        }
+        result = None
+        # getting the authentication token
+        # first: search in redis (with expiration)
+        timeout = aiohttp.ClientTimeout(total=self.timeout)
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                self.login_url,
+                timeout=timeout,
+                data=data
+            ) as response:
+                if response.status == 200:
+                    try:
+                        result = await response.json()
+                        data = await response.text()
+                        # saving the token on redis with expiration:
+                        self._token = result['token']
+                        try:
+                            status = await self._redis.setex(
+                                self._saved_token,
+                                data,
+                                self._expiration
+                            )
+                            print('Token Saved?:', status)
+                        except Exception as err:
+                            print(err)
+                        finally:
+                            await self._redis.close()
+                            return self._token
+                    except Exception as e:
+                        print(e)
+                        b = await response.content.read()
+                        result = b.decode("utf-8")
+                        raise DriverError(f'Error: {result}')
+                else:
+                    raise DriverError(f'Error: {response.text()}')
+
+    async def agents(self):
+        """
+            agents.
+            Returns a list of all agents from logged user.
+        """
+        self.method = 'GET'
+        self.data = None
+        self.url = self.base_url + '/agents'
+        try:
+            self._result = await self.query()
+            return self._result
+        except Exception as err:
+            logging.exception(err)
+            raise
+
+    async def conversation(self):
+        """
+            conversation.
+            Get the details of a conversation for a given sessionID.
+        """
+        if 'session_id' in self._params:
+            self.session_id = self._params['session_id']
+        else:
+            logging.exception('session_id not provided')
+            raise ValueError("session_id not provided")
+        self.method = 'GET'
+        self.data = None
+        self.url = self.base_url + '/agents/session/conversation?sessionID={}'.format(self.session_id)
+        del self._params['session_id']
+        try:
+            self._result = await self.query()
+            return self._result
+        except Exception as err:
+            logging.exception(err)
+            raise
+
+    async def conversations(self):
+        """
+            conversations.
+            Get the list of conversations.
+        """
+        if not self.agent:
+            try:
+                self.agent = self._params['agent']
+                del self._params['agent']
+            except (KeyError, ValueError):
+                logging.exception('Agent ID was not provided')
+                raise ValueError("Agent Id not provided")
+        self.method = 'POST'
+        self.headers['Content-Type'] = 'application/json'
+        self.url = self.base_url + '/agents/{}/conversations'.format(self.agent)
+        # getting filter dates:
+        self.data = {
+            'identifier': self.agent,
+            "additional_attributes": ["tracker"],
+            'start': 0,
+            'length': self.pagination,
+            'columns': [],
+            'order': [],
+            'search': {},
+            'draw': 1
+        }
+        filters = {}
+        if self._startdate is not None:
+            filters = {
+                "startTime": {
+                    "gte":  self._startdate,
+                    "lte": self._enddate
+                }
+            }
+        # if len(self._params) > 0:
+        #     filters = {**filters, **self._params}
+        self.data['filters'] = filters
+        print('VOCINITY FILTER: ', self.data)
+        try:
+            self._result = await self.query()
+            return self._result
+        except Exception as err:
+            logging.exception(err)
+            raise
+
+    def setup_bearer_token_request(self, token):
+        # pass
+        self.auth_type = 'api_key'
+        self.auth = {'Authorization': 'Bearer {}'.format(token)}
+
+    async def query(self):
+        """
+            Query.
+            Basic Query of Vocinity API.
+        """
+        self._result = None
+        # initial connection
+        await self.prepare_connection()
+        # get the credentials
+        try:
+            jwt = await self.get_token()
+            self.setup_bearer_token_request(jwt)
+        except Exception as err:
+            print(err)
+            logging.error(f'Vocinity: Error getting token: {err!s}')
+        try:
+            if self.type == 'conversations':
+                # and other endpoints with pagination.
+                # pagination results:
+                result = []
+                print('Conversations URL', self.url)
+                while True:
+                    print('Start at:', self.data['start'])
+                    try:
+                        data = json.dumps(self.data)
+                        res, error = await self.request(self.url, method=self.method, data=data)
+                        if error:
+                            print(error)
+                            break
+                        if res['data'] == []:
+                            break
+                        result += res['data']
+                        self.data['start'] += self.pagination
+                    except Exception as err:
+                        print('VO ', err)
+                        logging.exception(err)
+                        raise
+                self._result = result
+                return self._result
+            else:
+                data = json.dumps(self.data)
+                self._result, error = await self.request(self.url, method=self.method, data=data)
+                # print(self._result, error)
+            if error is not None:
+                # print(error)
+                logging.error(f'Vocinity: Error: {error!s}')
+            elif not self._result:
+                raise DataNotFound('Vocinity: No data was found')
+            else:
+                return self._result
+        except DataNotFound as err:
+            print(err)
+            raise
+        except Exception as err:
+            print(err)
+            logging.error(f'Vocinity: Error: {err!s}')