npis-api-utils 1.0.0__tar.gz

npis_api_utils-1.0.0/MANIFEST.in

@@ -0,0 +1 @@
+include README.md requirements.txt

npis_api_utils-1.0.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: npis_api_utils
+Version: 1.0.0
+Summary: NPIS api related libraries.
+Home-page: https://github.com/katxeus/npis_api_utils
+Author: JK
+Description-Content-Type: text/markdown
+
+# NPIS UTILS
+
+![Python](https://img.shields.io/badge/python-3.9-blue) ![Flask](https://img.shields.io/badge/Flask-2.3.2-blue) ![postgres](https://img.shields.io/badge/postgres-11.0-blue)
+[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/) [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)[![linting: pylint](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/PyCQA/pylint)
+
+
+This Python package include all the libraries and utils needed for NPIS related services.
+
+## Usage
+
+Install using pip
+

npis_api_utils-1.0.0/README.md

@@ -0,0 +1,12 @@
+# NPIS UTILS
+
+![Python](https://img.shields.io/badge/python-3.9-blue) ![Flask](https://img.shields.io/badge/Flask-2.3.2-blue) ![postgres](https://img.shields.io/badge/postgres-11.0-blue)
+[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/) [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)[![linting: pylint](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/PyCQA/pylint)
+
+
+This Python package include all the libraries and utils needed for NPIS related services.
+
+## Usage
+
+Install using pip
+

npis_api_utils-1.0.0/requirements.txt

@@ -0,0 +1,19 @@
+gunicorn
+Flask
+Flask-Caching
+Flask-Migrate
+Flask-Moment
+Flask-SQLAlchemy
+flask-restx
+flask-marshmallow
+flask-jwt-oidc
+python-dotenv
+psycopg2-binary
+marshmallow-sqlalchemy
+requests
+Werkzeug
+sqlalchemy_utils
+markupsafe
+PyJWT
+selenium
+selenium-wire

npis_api_utils-1.0.0/setup.cfg

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

npis_api_utils-1.0.0/setup.py

@@ -0,0 +1,42 @@
+import setuptools
+from glob import glob
+from os.path import basename, splitext
+
+def read(filepath):
+    """Read the contents from a file.
+    :param str filepath: path to the file to be read
+    :return: file contents
+    :rtype: str
+    """
+    with open(filepath, "r") as file_handle:
+        content = file_handle.read()
+    return content
+
+
+def read_requirements(filename):
+    """Get application requirements from the requirements.txt file.
+    :return: Python requirements
+    :rtype: list
+    """
+    with open(filename, "r") as req:
+        requirements = req.readlines()
+    install_requires = [r.strip() for r in requirements if r.find("git+") != 0]
+    return install_requires
+
+REQUIREMENTS = read_requirements("requirements.txt")
+
+setuptools.setup(
+    name='npis_api_utils',
+    version='1.0.0',
+    author='JK',
+    description='NPIS api related libraries.',
+    long_description=read("README.md"),
+    long_description_content_type="text/markdown",
+    url='https://github.com/katxeus/npis_api_utils',
+    packages=setuptools.find_packages("src"),
+    package_dir={"": "src"},
+    py_modules=[splitext(basename(path))[0] for path in glob("src/*.py")],
+    include_package_data=True,
+    zip_safe=False,
+    install_requires=REQUIREMENTS,
+)

npis_api_utils-1.0.0/src/npis_api_utils/__init__.py

@@ -0,0 +1,9 @@
+"""The forms flow API service."""
+
+from npis_api_utils.utils.startup import (
+    collect_role_ids,
+    setup_jwt_manager,
+    collect_user_resource_ids,
+)
+
+__version__ = "5.0.1"

npis_api_utils-1.0.0/src/npis_api_utils/exceptions/__init__.py

@@ -0,0 +1,16 @@
+"""Application Specific Exceptions, to manage the business errors.
+
+BusinessException - error, status_code - Business rules error
+error - a description of the error {code / description: classname / full text}
+status_code - where possible use HTTP Error Codes
+"""
+
+
+class BusinessException(Exception):
+    """Exception that adds error code and error."""
+
+    def __init__(self, error, status_code, *args, **kwargs):
+        """Return a valid BusinessException."""
+        super().__init__(*args, **kwargs)
+        self.error = error
+        self.status_code = status_code

npis_api_utils-1.0.0/src/npis_api_utils/schemas/__init__.py

@@ -0,0 +1,2 @@
+"""This exports all of the schemas used by the application."""
+from npis_api_utils.schemas.formio_roles import FormioRoleSchema

npis_api_utils-1.0.0/src/npis_api_utils/schemas/formio_roles.py

@@ -0,0 +1,14 @@
+"""This is for marshmallowing Formio role ids."""
+from marshmallow import EXCLUDE, Schema, fields
+
+
+class FormioRoleSchema(Schema):
+    """This class manages the Formio role id request response schema."""
+
+    class Meta:  # pylint: disable=too-few-public-methods
+        """Exclude unknown fields in the deserialized output."""
+
+        unknown = EXCLUDE
+
+    roleId = fields.Str(data_key="_id", required=True)
+    type = fields.Str(data_key="machineName", required=True)

npis_api_utils-1.0.0/src/npis_api_utils/services/__init__.py

@@ -0,0 +1,7 @@
+"""This exports all of the services used by the application."""
+
+from npis_api_utils.services.external.formio import FormioService
+
+__all__ = [
+    "FormioService",
+]

npis_api_utils-1.0.0/src/npis_api_utils/services/external/__init__.py

@@ -0,0 +1,3 @@
+"""This exports all of the external communication services used by the application."""
+
+from .formio import FormioService

npis_api_utils-1.0.0/src/npis_api_utils/services/external/formio.py

@@ -0,0 +1,140 @@
+"""This exposes the Formio APIs."""
+import json
+from http import HTTPStatus
+
+import jwt
+import requests
+from flask import current_app
+
+from npis_api_utils.exceptions import BusinessException
+from npis_api_utils.utils import cache
+
+
+class FormioService:
+    """This class manages formio API calls."""
+
+    def __init__(self):
+        """Initializing the service."""
+        self.base_url = current_app.config.get("FORMIO_URL")
+
+    @classmethod
+    def decode_timeout(cls, token):
+        """Method to decode token and get timeout."""
+        token = jwt.decode(token, options={"verify_signature": False})
+        timeout = token["exp"] - token["iat"]
+        return timeout
+
+    def get_formio_access_token(self):
+        """Method to get formio access token."""
+        formio_token = cache.get("formio_token")
+        if formio_token is None:
+            formio_token = self.generate_formio_token()
+            cache.set(
+                "formio_token",
+                formio_token,
+                timeout=self.decode_timeout(formio_token),
+            )
+        return formio_token
+
+    def generate_formio_token(self):
+        """Method to generate formio token using formio login API."""
+        headers = {"Content-Type": "application/json"}
+        url = f"{self.base_url}/user/login"
+        payload = {
+            "data": {
+                "email": current_app.config.get("FORMIO_USERNAME"),
+                "password": current_app.config.get("FORMIO_PASSWORD"),
+            }
+        }
+        current_app.logger.info("Generate formio token using formio login API.")
+        response = requests.post(url, headers=headers, data=json.dumps(payload))
+        if response.ok:
+            form_io_token = response.headers["x-jwt-token"]
+            return form_io_token
+        raise BusinessException(
+            "Unable to get access token from formio server",
+            HTTPStatus.SERVICE_UNAVAILABLE,
+        )
+
+    def create_form(self, data, formio_token):
+        """Post request to formio API to create form."""
+        headers = {"Content-Type": "application/json", "x-jwt-token": formio_token}
+        url = f"{self.base_url}/form"
+        response = requests.post(url, headers=headers, data=json.dumps(data))
+        if response.ok:
+            return response.json()
+        raise BusinessException(response.json(), HTTPStatus.BAD_REQUEST)
+    
+    def update_form(self, form_id, data, formio_token):
+        """Put request to formio API to update form."""
+        headers = {"Content-Type": "application/json", "x-jwt-token": formio_token}
+        url = f"{self.base_url}/form/{form_id}"
+        response = requests.put(url, headers=headers, data=json.dumps(data))
+        if response.ok:
+            return response.json()
+        raise BusinessException(response.json(), HTTPStatus.BAD_REQUEST)
+
+    def get_role_ids(self):
+        """Get request to Formio API to retrieve role ids."""
+        url = f"{self.base_url}/role"
+        headers = {"x-jwt-token": self.get_formio_access_token()}
+        current_app.logger.info("Role id fetching started...")
+
+        response = requests.get(url, headers=headers)
+        if response.ok:
+            current_app.logger.info("Role ids collected successfully...")
+            return response.json()
+        current_app.logger.error("Failed to fetch role ids !!!")
+        raise BusinessException(response.json(), HTTPStatus.SERVICE_UNAVAILABLE)
+
+    def get_user_resource_ids(self):
+        """Get request to Formio API to retrieve user resource ids."""
+        url = f"{self.base_url}/user"
+        current_app.logger.info("Fetching user resource ids...")
+        response = requests.get(url)
+        if response.ok:
+            current_app.logger.info("User resource ids collected successfully.")
+            return response.json()
+        current_app.logger.error("Failed to fetch user resource ids!")
+        raise BusinessException(response.json(), HTTPStatus.SERVICE_UNAVAILABLE)
+
+    def get_form(self, data, formio_token):
+        """Get request to formio API to get form details."""
+        headers = {"Content-Type": "application/json", "x-jwt-token": formio_token}
+        url = f"{self.base_url}/form/" + data["form_id"]
+        response = requests.get(url, headers=headers)
+        if response.ok:
+            return response.json()
+        raise BusinessException(response.json(), HTTPStatus.BAD_REQUEST)
+
+    def get_submission(self, data, formio_token):
+        """Get request to formio API to get submission details."""
+        headers = {"Content-Type": "application/json", "x-jwt-token": formio_token}
+        url = (
+            f"{self.base_url}/form/" + data["form_id"] + "/submission/" + data["sub_id"]
+        )
+        response = requests.get(url, headers=headers, data=json.dumps(data))
+        if response.ok:
+            return response.json()
+        raise BusinessException(response.json(), HTTPStatus.BAD_REQUEST)
+
+    def post_submission(self, data, formio_token):
+        """Post request to formio API to create submission details."""
+        headers = {"Content-Type": "application/json", "x-jwt-token": formio_token}
+        url = (
+            f"{self.base_url}/form/{data['formId']}/submission"
+        )
+        response = requests.post(url, headers=headers, data=json.dumps(data))
+        if response.ok:
+            return response.json()
+        raise BusinessException(response.json(), HTTPStatus.BAD_REQUEST)
+
+    def get_form_by_path(self, path_name: str, formio_token: str) -> dict:
+        """Get request to formio API to get form details from path."""
+        headers = {"Content-Type": "application/json", "x-jwt-token": formio_token}
+        url = f"{self.base_url}/{path_name}" 
+        response = requests.get(url, headers=headers)
+        if response.ok:
+            return response.json()
+        raise BusinessException(response.json(), HTTPStatus.BAD_REQUEST)
+        

npis_api_utils-1.0.0/src/npis_api_utils/utils/__init__.py

@@ -0,0 +1,35 @@
+"""This module holds general utility functions and helpers for the main package."""
+
+from .auth import auth, jwt
+from .caching import cache
+from .constants import (
+    ALLOW_ALL_APPLICATIONS,
+    ALLOW_ALL_ORIGINS,
+    ANONYMOUS_USER,
+    ADMIN_GROUP,
+    CLIENT_GROUP,
+    CORS_ORIGINS,
+    DEFAULT_PROCESS_KEY,
+    DEFAULT_PROCESS_NAME,
+    DESIGNER_GROUP,
+    DRAFT_APPLICATION_STATUS,
+    FILTER_MAPS,
+    NPIS_API_CORS_ORIGINS,
+    NPIS_ROLES,
+    KEYCLOAK_DASHBOARD_BASE_GROUP,
+    NEW_APPLICATION_STATUS,
+    REVIEWER_GROUP,
+    HTTP_TIMEOUT
+)
+from .enums import ApplicationSortingParameters
+from .format import CustomFormatter
+from .logging import setup_logging, log_bpm_error
+from .profiler import profiletime
+from .user_context import UserContext, user_context
+from .util import (
+    cors_preflight,
+    get_form_and_submission_id_from_form_url,
+    get_role_ids_from_user_groups,
+    translate,
+    validate_sort_order_and_order_by,
+)

npis_api_utils-1.0.0/src/npis_api_utils/utils/auth.py

@@ -0,0 +1,83 @@
+"""Bring in the common JWT Manager and helper functions."""
+
+from functools import wraps
+from http import HTTPStatus
+
+from flask import g, request, current_app
+from flask_jwt_oidc import JwtManager
+
+from jose import jwt as json_web_token
+from jose.exceptions import JWTError
+
+from ..exceptions import BusinessException
+
+jwt = JwtManager()  # pylint: disable=invalid-name
+
+
+class Auth:
+    """Extending JwtManager to include additional functionalities."""
+
+    @classmethod
+    def require(cls, f):
+        """Validate the Bearer Token."""
+
+        @jwt.requires_auth
+        @wraps(f)
+        def decorated(*args, **kwargs):
+            g.authorization_header = request.headers.get("Authorization", None)
+            g.token_info = g.jwt_oidc_token_info
+
+            return f(*args, **kwargs)
+
+        return decorated
+
+    @classmethod
+    def has_one_of_roles(cls, roles):
+        """Check that at least one of the realm roles are in the token.
+
+        Args:
+            roles [str,]: Comma separated list of valid roles
+        """
+
+        def decorated(f):
+            @Auth.require
+            @wraps(f)
+            def wrapper(*args, **kwargs):
+                if jwt.contains_role(roles):
+                    return f(*args, **kwargs)
+
+                raise BusinessException("Access Denied", HTTPStatus.UNAUTHORIZED)
+
+            return wrapper
+
+        return decorated
+
+    @classmethod
+    def has_role(cls, role):
+        """Method to validate the role."""
+        return jwt.validate_roles(role)
+
+    @classmethod
+    def require_custom(cls, f):
+        """Validate custom form embed token."""
+        @wraps(f)
+        def decorated(*args, **kwargs):
+            token = jwt.get_token_auth_header()
+            try:
+                data = json_web_token.decode(
+                    token,
+                    algorithms="HS256",
+                    key=current_app.config.get('FORM_EMBED_JWT_SECRET'),
+                    )
+                g.authorization_header = token
+                g.token_info = g.jwt_oidc_token_info = data
+            except JWTError as err:
+                raise BusinessException("Invalid token", HTTPStatus.UNAUTHORIZED)
+            except Exception as err:
+                raise err
+            return f(*args, **kwargs)
+        return decorated
+
+auth = (
+    Auth()
+)  # pylint: disable=invalid-name; lower case name as used by convention in most Flask apps

npis_api_utils-1.0.0/src/npis_api_utils/utils/caching.py

@@ -0,0 +1,5 @@
+"""Cache configurations."""
+
+from flask_caching import Cache
+
+cache = Cache(config={"CACHE_TYPE": "SimpleCache"})

npis_api_utils-1.0.0/src/npis_api_utils/utils/constants.py

@@ -0,0 +1,46 @@
+"""All constants for project."""
+import os
+
+from dotenv import find_dotenv, load_dotenv
+
+# this will load all the envars from a .env file located in the project root (api)
+load_dotenv(find_dotenv())
+
+NPIS_API_CORS_ORIGINS = os.getenv("NPIS_API_CORS_ORIGINS", "*")
+ALLOW_ALL_ORIGINS = "*"
+CORS_ORIGINS = []
+if NPIS_API_CORS_ORIGINS != "*":
+    CORS_ORIGINS = NPIS_API_CORS_ORIGINS.split(",")
+ADMIN_GROUP = "npis-admin"
+DESIGNER_GROUP = "npis-designer"
+REVIEWER_GROUP = "npis-reviewer"
+CLIENT_GROUP = "npis-client"
+NPIS_ROLES = [DESIGNER_GROUP, REVIEWER_GROUP, CLIENT_GROUP]
+ALLOW_ALL_APPLICATIONS = "/npis/npis-reviewer/access-allow-applications"
+
+NEW_APPLICATION_STATUS = "New"
+DRAFT_APPLICATION_STATUS = "Draft"
+KEYCLOAK_DASHBOARD_BASE_GROUP = "npis-analytics"
+ANONYMOUS_USER = "Anonymous-user"
+
+FILTER_MAPS = {
+    "application_id": {"field": "id", "operator": "eq"},
+    "application_name": {"field": "form_name", "operator": "ilike"},
+    "application_status": {"field": "application_status", "operator": "eq"},
+    "created_by": {"field": "created_by", "operator": "eq"},
+    "modified_from": {"field": "modified", "operator": "ge"},
+    "modified_to": {"field": "modified", "operator": "le"},
+    "created_from": {"field": "created", "operator": "ge"},
+    "created_to": {"field": "created", "operator": "le"},
+    "form_name": {"field": "form_name", "operator": "ilike"},
+    "id": {"field": "id", "operator": "eq"},
+    "form_type": {"field": "form_type", "operator": "eq"},
+    "can_bundle": {"field": "can_bundle", "operator": "eq"},
+    "is_bundle": {"field": "is_bundle", "operator": "eq"},
+    "title":{"field": "title", "operator": "ilike"},
+    "category":{"field": "category", "operator": "ilike"},
+}
+
+DEFAULT_PROCESS_KEY = "Defaultflow"
+DEFAULT_PROCESS_NAME = "Default Flow"
+HTTP_TIMEOUT = 30

npis_api_utils-1.0.0/src/npis_api_utils/utils/enums.py

@@ -0,0 +1,70 @@
+"""Enum User Definition."""
+from enum import Enum, unique
+
+
+class FormProcessMapperStatus(Enum):
+    """This enum provides the list of FormProcessMapper Status."""
+
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+
+
+class MetricsState(Enum):
+    """This enum provides the list of states of Metrics."""
+
+    CREATED = "created"
+    MODIFIED = "modified"
+
+
+class ApplicationSortingParameters:  # pylint: disable=too-few-public-methods
+    """This enum provides the list of Sorting Parameters."""
+
+    Id = "id"
+    Created = "created"
+    Name = "applicationName"
+    Status = "applicationStatus"
+    Modified = "modified"
+    FormName = "formName"
+
+
+@unique
+class FormioRoles(Enum):
+    """Roles and corresponding machine names."""
+
+    CLIENT = "npisClient"
+    REVIEWER = "npisReviewer"
+    DESIGNER = "administrator"
+    ANONYMOUS = "anonymous"
+    RESOURCE_ID = "RESOURCE_ID"
+
+    @classmethod
+    def contains(cls, item: str) -> bool:
+        """Checks if the parameter exists in the enum."""
+        return item in [entry.value for entry in cls]
+
+
+@unique
+class DraftStatus(Enum):
+    """Draft status and corresponding values."""
+
+    ACTIVE = 1
+    INACTIVE = 0
+
+
+class DraftSortingParameters:  # pylint: disable=too-few-public-methods
+    """This enum provides the list of Sorting Parameters."""
+
+    id = "id"
+    Created = "created"
+    Name = "DraftName"
+    Status = "applicationStatus"
+    Modified = "modified"
+    FormName = "formName"
+
+
+@unique
+class FilterStatus(Enum):
+    """This enum provides the filter status."""
+
+    ACTIVE = "active"
+    INACTIVE = "inactive"

npis_api_utils-1.0.0/src/npis_api_utils/utils/format.py

@@ -0,0 +1,31 @@
+"""Module handle the console display formatting."""
+import logging
+
+
+class CustomFormatter(logging.Formatter):
+    """Class extends the logging Formatter class to support custom colour messages."""
+
+    blue = "\x1b[34;21m"
+    grey = "\x1b[38;21m"
+    green = "\x1b[32;1m"
+    yellow = "\x1b[33;21m"
+    red = "\x1b[31;21m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    __format = (
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
+    )
+
+    FORMATS = {
+        logging.DEBUG: blue + __format + reset,
+        logging.INFO: green + __format + reset,
+        logging.WARNING: yellow + __format + reset,
+        logging.ERROR: red + __format + reset,
+        logging.CRITICAL: bold_red + __format + reset,
+    }
+
+    def format(self, record):
+        """Returns the formatted information."""
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)

npis_api_utils-1.0.0/src/npis_api_utils/utils/logging.py

@@ -0,0 +1,38 @@
+"""Centralized setup of logging for the service."""
+
+import logging.config
+import sys
+from os import path
+
+
+def setup_logging(conf):
+    """Create the services logger."""
+    if conf and path.isfile(conf):
+        logging.config.fileConfig(conf)
+        print(f"Configure logging, from conf:{conf}", file=sys.stdout)
+    else:
+        print(
+            f"Unable to configure logging, attempted conf:{conf}",
+            file=sys.stderr,
+        )
+    return logging.getLogger(__name__)
+
+
+def log_error(msg):
+    """Log error."""
+    logging.error(msg)
+
+
+def log_bpm_error(msg):
+    """Log error."""
+    logging.error(msg)
+    logging.error(
+        """The connection with Python and Camunda API is not proper.
+        Ensure you have passed env variables properly and
+        have set listener in Keycloak(camunda-rest-api)"""
+    )
+
+
+def log_info(msg):
+    """Log info."""
+    logging.info(msg)

npis_api_utils-1.0.0/src/npis_api_utils/utils/pdf.py

@@ -0,0 +1,101 @@
+"""Utility functions to manage pdf generation using selenium chrome."""
+
+import base64
+import json
+
+from flask import current_app, make_response
+from selenium.common.exceptions import TimeoutException
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.chrome.service import Service
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+from seleniumwire import webdriver
+
+
+def send_devtools(driver, cmd, params=None):
+    """Chrome dev tools execution function."""
+    resource = "/session/" + driver.session_id + "/chromium/send_command_and_get_result"
+    # pylint: disable=protected-access
+    url = driver.command_executor._url + resource
+    body = json.dumps({"cmd": cmd, "params": params})
+    # pylint: disable=protected-access
+    response = driver.command_executor._request("POST", url, body)
+    if response.get("status"):
+        raise Exception(response.get("value"))
+    return response.get("value")
+
+
+# pylint: disable=R1710
+
+
+def get_pdf_from_html(path, chromedriver=None, p_options=None, args=None):
+    """Load url in chrome web driver and print as pdf."""
+
+    def interceptor(request):
+        request.headers["Authorization"] = args["auth_token"]
+
+    if args is None:
+        args = {}
+
+    options = Options()
+    options.add_argument("--headless")
+    options.add_argument("--disable-gpu")
+    options.add_argument("--no-sandbox")
+    options.add_argument("--disable-dev-shm-usage")
+    options.add_argument("--run-all-compositor-stages-before-draw")
+    options.add_argument("--disable-logging")
+    options.add_argument("--log-level=3")
+    sel_options = {"request_storage_base_dir": "/tmp"}
+
+    service = Service(executable_path=chromedriver)
+    # pylint: disable=E1123
+    driver = webdriver.Chrome(
+        service=service, options=options, seleniumwire_options=sel_options
+    )
+    driver.set_window_size(1920, 1080)
+
+    if "auth_token" in args:
+        driver.request_interceptor = interceptor
+
+    if "timezone" in args and args["timezone"] is not None:
+        tz_params = {"timezoneId": args["timezone"]}
+        driver.execute_cdp_cmd("Emulation.setTimezoneOverride", tz_params)
+
+    driver.get(path)
+
+    try:
+        if "wait" in args:
+            delay = 30  # seconds
+            elem_loc = EC.presence_of_element_located((By.CLASS_NAME, args["wait"]))
+            WebDriverWait(driver, delay).until(elem_loc)
+        calculated_print_options = {
+            "landscape": False,
+            "displayHeaderFooter": False,
+            "printBackground": True,
+            "preferCSSPageSize": True,
+        }
+        if p_options is not None:
+            calculated_print_options.update(p_options)
+        result = send_devtools(driver, "Page.printToPDF", calculated_print_options)
+        driver.quit()
+        return base64.b64decode(result["data"])
+
+    except TimeoutException as err:
+        driver.quit()
+        current_app.logger.warning(err)
+        return False
+
+
+def pdf_response(result, file_name="Pdf.pdf"):
+    """Render pdf response from html content."""
+    response = make_response(result)
+    response.headers["Content-Type"] = "application/pdf"
+    response.headers["Content-Disposition"] = "inline; filename=" + file_name
+    return response
+
+
+def save_pdf_local(result, file_name="Pdf.pdf"):
+    """Save html content as pdf response."""
+    with open(file_name, "wb") as file:
+        file.write(result)

npis_api_utils-1.0.0/src/npis_api_utils/utils/profiler.py

@@ -0,0 +1,24 @@
+"""Utility function for profiling functions."""
+import time
+from functools import wraps
+
+from flask import current_app
+
+
+def profiletime(profile_fn):
+    """Function to profile time."""
+
+    @wraps(profile_fn)
+    def measure_time(*args, **kwargs):
+        """Measure the API response time using time module."""
+        start_time = time.time()
+        result = profile_fn(*args, **kwargs)
+        end_time = time.time()
+        diff = end_time - start_time
+
+        current_app.logger.info(
+            f"API endpoint: {profile_fn.__qualname__} took {diff} seconds"
+        )
+        return result
+
+    return measure_time

npis_api_utils-1.0.0/src/npis_api_utils/utils/roles.py

@@ -0,0 +1,9 @@
+"""Role definitions."""
+
+
+# class Role:  # pylint: disable=too-few-public-methods
+#     """User Role."""
+
+#     rpas_designer = "rpas-designer"
+#     rpas_reviewer = "rpas-reviewer"
+#     rpas_client = "rpas-client"

npis_api_utils-1.0.0/src/npis_api_utils/utils/startup.py

@@ -0,0 +1,68 @@
+"""
+App initialization.
+Functions to initialize app and startup
+
+"""
+from typing import Dict
+from npis_api_utils.exceptions import BusinessException
+from npis_api_utils.schemas import FormioRoleSchema
+from npis_api_utils.services.external import FormioService
+from npis_api_utils.utils import cache
+from npis_api_utils.utils.enums import FormioRoles
+
+
+def setup_jwt_manager(app, jwt_manager):
+    """Use flask app to configure the JWTManager to work for a particular Realm."""
+
+    def get_roles(a_dict):
+        resource = a_dict["resource_access"].get(app.config["JWT_OIDC_AUDIENCE"])
+        return resource["roles"] if resource else a_dict["roles"]
+
+    app.config["JWT_ROLE_CALLBACK"] = get_roles
+    jwt_manager.init_app(app)
+
+
+def collect_role_ids(app):
+    """Collect role ids from Form.io."""
+    try:
+        service = FormioService()
+        app.logger.info("Establishing new connection to formio...")
+        role_ids = FormioRoleSchema().load(service.get_role_ids(), many=True)
+        role_ids_filtered = list(filter(None, map(standardization_fn, role_ids)))
+        # Cache will be having infinite expiry
+        if role_ids:
+            cache.set(
+                "formio_role_ids",
+                role_ids_filtered,
+                timeout=0,
+            )
+            app.logger.info("Role ids saved to cache successfully.")
+    except BusinessException as err:
+        app.logger.error(err.error)
+    except Exception as err:  # pylint: disable=broad-except
+        app.logger.error(err)
+
+
+def collect_user_resource_ids(app):
+    """Collects user resource ids from Form.io."""
+    try:
+        service = FormioService()
+        user_resource = service.get_user_resource_ids()
+        user_resource_id = user_resource["_id"]
+        if user_resource:
+            cache.set(
+                "user_resource_id",
+                user_resource_id,
+                timeout=0,
+            )
+            app.logger.info("User resource ids saved to cache successfully.")
+    except Exception as err:  # pylint: disable=broad-except
+        app.logger.error(err)
+
+
+def standardization_fn(item: Dict) -> Dict or None:
+    """Updates the type value to enum key for standardization."""
+    if FormioRoles.contains(item["type"]):
+        item["type"] = FormioRoles(item["type"]).name
+        return item
+    return None

npis_api_utils-1.0.0/src/npis_api_utils/utils/translations/__init__.py

@@ -0,0 +1,3 @@
+"""This module holds translations related files."""
+
+from .translations import translations

npis_api_utils-1.0.0/src/npis_api_utils/utils/translations/translations.py

@@ -0,0 +1,130 @@
+"""Translations dictionary."""
+# pylint: skip-file
+
+translations = {
+    "fr": {
+        "errors": "les erreurs",
+        "type": "taper",
+        "message": "message",
+        "Bad request error": "Mauvaise erreur de demande",
+        "Invalid request data object": "Objet de données de requête non valide",
+        "Invalid Token Error": "Erreur de jeton non valide",
+        "Invalid Request Object": "Objet de demande non valide",
+        "Required fields are not passed": "Les champs obligatoires ne sont pas passés",
+        "Access to NPIS API Denied. Check if the bearer token is passed for Authorization or has expired.": "Accès à l'API NPIS refusé. Vérifiez si le jeton du porteur est passé pour l'autorisation ou a expiré.",
+        "Authorization error": "Erreur d'autorisation",
+        "Permission denied": "Permission refusée",
+        "Invalid application request passed": "Demande de candidature invalide transmise",
+        "Invalid Request Object Passed": "Objet de demande non valide transmis",
+        "Welcome to NPIS API": "Bienvenue dans l'API NPIS",
+        "Dashboards not available": "Tableaux de bord non disponibles",
+        "Error": "Erreur",
+        "Dashboard not found": "Tableau de bord introuvable",
+        "Invalid request object passed for FormProcessmapper POST API": "Objet de demande non valide transmis pour l'API POST FormProcessmapper",
+        "Invalid response data": "Données de réponse non valides",
+        "Invalid request passed": "Demande invalide transmise",
+        "Invalid Request Object format": "Format d'objet de demande non valide",
+        "Missing from_date or to_date. Invalid request object for application metrics endpoint": "From_date ou to_date manquant. Objet de requête non valide pour le point de terminaison des métriques d'application",
+        "Error while getting application metrics": "Erreur lors de l'obtention des métriques d'application",
+    },
+    "zh-CN": {
+        "errors": "错误",
+        "type": "类型",
+        "message": "信息",
+        "Bad request error": "错误的请求错误",
+        "Invalid request data object": "请求数据对象无效",
+        "Invalid Token Error": "无效令牌错误",
+        "Invalid Request Object": "无效的请求对象",
+        "Required fields are not passed": "必填字段未通过",
+        "Access to NPIS API Denied. Check if the bearer token is passed for Authorization or has expired.": "拒绝访问 N API。检查不记名令牌是否已通过授权或已过期。",
+        "Authorization error": "授权错误",
+        "Permission denied": "“没有权限",
+        "Invalid application request passed": "通过了无效的应用程序请求",
+        "Invalid Request Object Passed": "传递的请求对象无效",
+        "Welcome to NPIS API": "欢迎使用 NPIS API",
+        "Dashboards not available": "仪表板不可用",
+        "Error": "错误",
+        "Dashboard not found": "未找到仪表板",
+        "Invalid request object passed for FormProcessmapper POST API": "为 FormProcessmapper POST API 传递的请求对象无效",
+        "Invalid response data": "无效的响应数据",
+        "Invalid request passed": "无效请求已通过",
+        "Invalid Request Object format": "请求对象格式无效",
+        "Missing from_date or to_date. Invalid request object for application metrics endpoint": "缺少 from_date 或 to_date。应用程序指标端点的请求对象无效",
+        "Error while getting application metrics": "获取应用程序指标时出错",
+    },
+    "bg": {
+        "errors": "errors",
+        "type": "Тип",
+        "message": "съобщение",
+        "Bad request error": "Грешка в лоша заявка",
+        "Invalid request data object": "Невалиден обект с данни за заявка",
+        "Invalid Token Error": "Грешка с невалиден токен",
+        "Invalid Request Object": "Невалиден обект на заявка",
+        "Required fields are not passed": "Задължителните полета не се предават",
+        "Access to NPIS API Denied. Check if the bearer token is passed for Authorization or has expired.": "Достъпът до API на NPIS е отказан. Проверете дали токенът на носител е предаден за оторизация или е изтекъл.",
+        "Authorization error": "Грешка в упълномощаването",
+        "Permission denied": "Permission denied",
+        "Invalid application request passed": "Невалидна заявка за приложение е преминала",
+        "Invalid Request Object Passed": "Предаден е невалиден обект на заявка",
+        "Welcome to NPIS API": "Добре дошли в API на NPIS",
+        "Dashboards not available": "Таблата за управление не са налични",
+        "Error": "Грешка",
+        "Dashboard not found": "Таблото за управление не е намерено",
+        "Invalid request object passed for FormProcessmapper POST API": "Предаден е невалиден обект на заявка за FormProcessmapper POST API",
+        "Invalid response data": "Невалидни данни за отговор",
+        "Invalid request passed": "Невалидна заявка е преминала",
+        "Invalid Request Object format": "Невалиден формат на обекта на заявка",
+        "Missing from_date or to_date. Invalid request object for application metrics endpoint": "Липсва от_дата или до_дата. Невалиден обект на заявка за крайна точка на показателите на приложението",
+        "Error while getting application metrics": "Грешка при получаване на показатели за приложението",
+    },
+    "pt": {
+        "errors": "erros",
+        "type": "modelo",
+        "message": "mensagem",
+        "Bad request error": "Erro de solicitação incorreta",
+        "Invalid request data object": "Objeto de dados de solicitação inválido",
+        "Invalid Token Error": "Erro de token inválido",
+        "Invalid Request Object": "Objeto de solicitação inválido",
+        "Required fields are not passed": "Campos obrigatórios não são passados",
+        "Access to NPIS API Denied. Check if the bearer token is passed for Authorization or has expired.": "Acesso negado à API do NPIS. Verifique se o token do portador foi aprovado para autorização ou expirou.",
+        "Authorization error": "Erro de autorização",
+        "Permission denied": "Permissão negada",
+        "Invalid application request passed": "Solicitação de inscrição inválida aprovada",
+        "Invalid Request Object Passed": "Objeto de solicitação inválido passado",
+        "Welcome to NPIS API": "Bem-vindo à API do NPIS",
+        "Dashboards not available": "Painéis não disponíveis",
+        "Error": "Erro",
+        "Dashboard not found": "Painel não encontrado",
+        "Invalid request object passed for FormProcessmapper POST API": "Objeto de solicitação inválido passado para API POST FormProcessmapper",
+        "Invalid response data": "Dados de resposta inválidos",
+        "Invalid request passed": "Solicitação inválida aprovada",
+        "Invalid Request Object format": "Formato de objeto de solicitação inválido",
+        "Missing from_date or to_date. Invalid request object for application metrics endpoint": "Está faltando from_date ou to_date. Objeto de solicitação inválido para o endpoint de métricas do aplicativo",
+        "Error while getting application metrics": "Erro ao obter as métricas do aplicativo",
+    },
+    "de": {
+        "errors": "Fehler",
+        "type": "Typ",
+        "message": "Botschaft",
+        "Bad request error": "Ungültiger Anforderungsfehler",
+        "Invalid request data object": "Ungültiges Anforderungsdatenobjekt",
+        "Invalid Token Error": "Ungültiger Token-Fehler",
+        "Invalid Request Object": "Ungültiges Anforderungsobjekt",
+        "Required fields are not passed": "Erforderliche Felder werden nicht übergeben",
+        "Access to NPIS API Denied. Check if the bearer token is passed for Authorization or has expired.": "Zugriff auf die Formsflow.ai-API verweigert. Überprüfen Sie, ob das Bearer-Token für die Autorisierung übergeben wurde oder abgelaufen ist.",
+        "Authorization error": "Autorisierungsfehlero",
+        "Permission denied": "Zugang verweigert",
+        "Invalid application request passed": "Ungültige Anwendungsanforderung bestanden",
+        "Invalid Request Object Passed": "Ungültiges Anforderungsobjekt übergeben",
+        "Welcome to NPIS API": "Willkommen bei der NPIS-API",
+        "Dashboards not available": "Dashboards nicht verfügbar",
+        "Error": "Fehler",
+        "Dashboard not found": "Dashboard nicht gefunden",
+        "Invalid request object passed for FormProcessmapper POST API": "Ungültiges Anforderungsobjekt für FormProcessmapper POST API übergeben",
+        "Invalid response data": "Ungültige Antwortdaten",
+        "Invalid request passed": "Ungültige Anfrage bestanden",
+        "Invalid Request Object format": "Ungültiges Anforderungsobjektformat",
+        "Missing from_date or to_date. Invalid request object for application metrics endpoint": "From_date oder to_date fehlen. Ungültiges Anforderungsobjekt für Endpunkt der Anwendungsmetriken",
+        "Error while getting application metrics": "Fehler beim Abrufen von Anwendungsmetriken",
+    },
+}

npis_api_utils-1.0.0/src/npis_api_utils/utils/user_context.py

@@ -0,0 +1,87 @@
+"""User Context to hold request scoped variables."""
+
+import functools
+from typing import Dict, List
+
+from flask import current_app, g, request
+
+
+def _get_context():
+    """Return User context."""
+    return UserContext()
+
+
+class UserContext:  # pylint: disable=too-many-instance-attributes
+    """Object to hold request scoped user context."""
+
+    def __init__(self):
+        """Return a User Context object."""
+        token_info: Dict = _get_token_info()
+        self._tenant_key = token_info.get("tenantKey", None)
+        self._user_name = token_info.get("preferred_username", None)
+        self._bearer_token: str = _get_token()
+        self.token_info = token_info
+        self._email = token_info.get("email")
+        self._roles: list = token_info.get("roles", None) or token_info.get(
+            "role", None
+        )
+        self._groups: list = token_info.get("groups", None)
+
+    @property
+    def tenant_key(self) -> str:
+        """Return the tenant key."""
+        return self._tenant_key
+
+    @property
+    def user_name(self) -> str:
+        """Return the user name."""
+        return self._user_name
+
+    @property
+    def bearer_token(self) -> str:
+        """Return the bearer_token."""
+        return self._bearer_token
+
+    @property
+    def email(self) -> str:
+        """Return the email."""
+        return self._email
+
+    @property
+    def roles(self) -> List[str]:
+        """Return the roles."""
+        return self._roles
+
+    @property
+    def group_or_roles(self) -> List[str]:
+        """Return groups is env is using groups, else roles."""
+        return (
+            self._roles
+            if current_app.config.get("KEYCLOAK_ENABLE_CLIENT_AUTH")
+            else self._groups
+        )
+
+
+def user_context(function):
+    """Add user context object as an argument to function."""
+
+    @functools.wraps(function)
+    def wrapper(*func_args, **func_kwargs):
+        context = _get_context()
+        func_kwargs["user"] = context
+        return function(*func_args, **func_kwargs)
+
+    return wrapper
+
+
+def _get_token_info() -> Dict:
+    return g.jwt_oidc_token_info if g and "jwt_oidc_token_info" in g else {}
+
+
+def _get_token() -> str:
+    token: str = (
+        request.headers["Authorization"]
+        if request and "Authorization" in request.headers
+        else None
+    )
+    return token

npis_api_utils-1.0.0/src/npis_api_utils/utils/util.py

@@ -0,0 +1,125 @@
+"""Common utils.
+
+CORS pre-flight decorator. A simple decorator to add the options
+method to a Request Class.
+camel_to_snake - Converts camel case to snake case.
+validate_sort_order_and_order_by - Utility function to validate
+if sort order and sort order by is correct.
+translate - Translate the response to provided language
+"""
+import re
+from typing import Tuple
+
+from .constants import (
+    ALLOW_ALL_ORIGINS,
+    CLIENT_GROUP,
+    DESIGNER_GROUP,
+    REVIEWER_GROUP,
+)
+from .enums import (
+    ApplicationSortingParameters,
+    DraftSortingParameters,
+    FormioRoles,
+)
+from .translations.translations import translations
+
+
+def cors_preflight(methods: str = "GET"):
+    """Render an option method on the class."""
+
+    def wrapper(f):  # pylint: disable=invalid-name
+        def options(self, *args, **kwargs):  # pylint: disable=unused-argument
+            return (
+                {"Allow": "GET"},
+                200,
+                {
+                    "Access-Control-Allow-Origin": ALLOW_ALL_ORIGINS,
+                    "Access-Control-Allow-Methods": methods,
+                    "Access-Control-Allow-Headers": "Authorization, Content-Type",
+                },
+            )
+
+        setattr(f, "options", options)
+        return f
+
+    return wrapper
+
+
+def camel_to_snake(name: str) -> str:
+    """Convert camel case to snake case."""
+    s_1 = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
+    return re.sub("([a-z0-9])([A-Z])", r"\1_\2", s_1).lower()
+
+
+def validate_sort_order_and_order_by(order_by: str, sort_order: str) -> bool:
+    """Validate sort order and order by."""
+    if order_by not in [
+        ApplicationSortingParameters.Id,
+        ApplicationSortingParameters.Name,
+        ApplicationSortingParameters.Status,
+        ApplicationSortingParameters.Modified,
+        ApplicationSortingParameters.FormName,
+        DraftSortingParameters.Name,
+    ]:
+        order_by = None
+    else:
+        if order_by in [ApplicationSortingParameters.Name, DraftSortingParameters.Name]:
+            order_by = ApplicationSortingParameters.FormName
+        order_by = camel_to_snake(order_by)
+    if sort_order not in ["asc", "desc"]:
+        sort_order = None
+    return order_by, sort_order
+
+
+def translate(to_lang: str, data: dict) -> dict:
+    """Translate the response to provided language.
+
+    will return the translated object if there is match
+    else return the original object
+    """
+    try:
+        translated_data = {}
+        if to_lang not in translations:
+            raise KeyError
+        for key, value in data.items():
+            # if matching translation is present for either key / value,
+            # then translated string is used
+            # original string otherwise
+            translated_data[
+                translations[to_lang][key] if key in translations[to_lang] else key
+            ] = (
+                translations[to_lang][value]
+                if value in translations[to_lang]
+                else value
+            )
+        return translated_data
+    except KeyError as err:
+        raise err
+    except Exception as err:
+        raise err
+
+
+def get_role_ids_from_user_groups(role_ids, user_role):
+    """Filters out formio role ids specific to user groups."""
+    if role_ids is None or user_role is None:
+        return None
+
+    if DESIGNER_GROUP in user_role:
+        return role_ids
+    if REVIEWER_GROUP in user_role:
+        return filter_list_by_user_role(FormioRoles.REVIEWER.name, role_ids)
+    if CLIENT_GROUP in user_role:
+        return filter_list_by_user_role(FormioRoles.CLIENT.name, role_ids)
+    return None
+
+
+def filter_list_by_user_role(formio_role, role_ids):
+    """Iterate over role_ids and return entries with matching formio role."""
+    return list(filter(lambda item: item["type"] == formio_role, role_ids))
+
+
+def get_form_and_submission_id_from_form_url(form_url: str) -> Tuple:
+    """Retrieves the formid and submission id from the url parameters."""
+    form_id = form_url[form_url.find("/form/") + 6 : form_url.find("/submission/")]
+    submission_id = form_url[form_url.find("/submission/") + 12 : len(form_url)]
+    return (form_id, submission_id)

npis_api_utils-1.0.0/src/npis_api_utils.egg-info/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: npis-api-utils
+Version: 1.0.0
+Summary: NPIS api related libraries.
+Home-page: https://github.com/katxeus/npis_api_utils
+Author: JK
+Description-Content-Type: text/markdown
+
+# NPIS UTILS
+
+![Python](https://img.shields.io/badge/python-3.9-blue) ![Flask](https://img.shields.io/badge/Flask-2.3.2-blue) ![postgres](https://img.shields.io/badge/postgres-11.0-blue)
+[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/) [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)[![linting: pylint](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/PyCQA/pylint)
+
+
+This Python package include all the libraries and utils needed for NPIS related services.
+
+## Usage
+
+Install using pip
+

npis_api_utils-1.0.0/src/npis_api_utils.egg-info/SOURCES.txt

@@ -0,0 +1,32 @@
+MANIFEST.in
+README.md
+requirements.txt
+setup.py
+src/npis_api_utils/__init__.py
+src/npis_api_utils.egg-info/PKG-INFO
+src/npis_api_utils.egg-info/SOURCES.txt
+src/npis_api_utils.egg-info/dependency_links.txt
+src/npis_api_utils.egg-info/not-zip-safe
+src/npis_api_utils.egg-info/requires.txt
+src/npis_api_utils.egg-info/top_level.txt
+src/npis_api_utils/exceptions/__init__.py
+src/npis_api_utils/schemas/__init__.py
+src/npis_api_utils/schemas/formio_roles.py
+src/npis_api_utils/services/__init__.py
+src/npis_api_utils/services/external/__init__.py
+src/npis_api_utils/services/external/formio.py
+src/npis_api_utils/utils/__init__.py
+src/npis_api_utils/utils/auth.py
+src/npis_api_utils/utils/caching.py
+src/npis_api_utils/utils/constants.py
+src/npis_api_utils/utils/enums.py
+src/npis_api_utils/utils/format.py
+src/npis_api_utils/utils/logging.py
+src/npis_api_utils/utils/pdf.py
+src/npis_api_utils/utils/profiler.py
+src/npis_api_utils/utils/roles.py
+src/npis_api_utils/utils/startup.py
+src/npis_api_utils/utils/user_context.py
+src/npis_api_utils/utils/util.py
+src/npis_api_utils/utils/translations/__init__.py
+src/npis_api_utils/utils/translations/translations.py

npis_api_utils-1.0.0/src/npis_api_utils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

npis_api_utils-1.0.0/src/npis_api_utils.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

npis_api_utils-1.0.0/src/npis_api_utils.egg-info/requires.txt

@@ -0,0 +1,19 @@
+Flask
+Flask-Caching
+Flask-Migrate
+Flask-Moment
+Flask-SQLAlchemy
+PyJWT
+Werkzeug
+flask-jwt-oidc
+flask-marshmallow
+flask-restx
+gunicorn
+markupsafe
+marshmallow-sqlalchemy
+psycopg2-binary
+python-dotenv
+requests
+selenium
+selenium-wire
+sqlalchemy_utils

npis_api_utils-1.0.0/src/npis_api_utils.egg-info/top_level.txt

@@ -0,0 +1 @@
+npis_api_utils