eam-report-helper 0.0.1__tar.gz

eam_report_helper-0.0.1/.gitignore

@@ -0,0 +1 @@
+*.pyc

eam_report_helper-0.0.1/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.3
+Name: eam_report_helper
+Version: 0.0.1
+Summary: A package that returns formatted data for reports
+Author-email: Dave Gunn <daveg@8amsolutions.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8

eam_report_helper-0.0.1/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+
+
+[project]
+name = "eam_report_helper"
+version = "0.0.1"
+authors = [
+  { name="Dave Gunn", email="daveg@8amsolutions.com" }
+]
+description = "A package that returns formatted data for reports"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]

eam_report_helper-0.0.1/src/eam_report_helper/helpers.py

@@ -0,0 +1,16 @@
+import csv
+
+
+def generate_csv(column_list: list, file_name: str, data: list):
+    """create csv file and write data to it"""
+    csv_columns = column_list
+    csv_file = file_name
+
+    try:
+        with open(csv_file, 'w', encoding='utf8') as csvfile:
+            writer = csv.DictWriter(csvfile, fieldnames=csv_columns)
+            writer.writeheader()
+            for item in data:
+                writer.writerow(item)
+    except IOError:
+        print('error')

eam_report_helper-0.0.1/src/eam_report_helper/report_emp_questions.py

@@ -0,0 +1,77 @@
+
+
+class EmpQuestionsReport:
+    def __init__(self, db, company_id: str) -> None:
+        self.db = db
+        self.companyId = company_id
+
+    def format_questions(self, emp_questions: list) -> list:
+        """Format questions"""
+        results = []
+        for item in emp_questions:
+            if self.companyId in [x['id'] for x in item['employerList']]:
+                results.append(item)
+
+        return results
+
+    def format_answers(self, vendor_list_items: list, vend_answers: list, emp_questions_formatted: list, emp_questions: list) -> list:
+        """Format answers"""
+        vendor_ids = [x['vendorId'] for x in vendor_list_items]
+        emp_question_ids = [x['id'] for x in emp_questions_formatted]
+
+        results = []
+        for item in vend_answers:
+            if (item['vendorId'] in vendor_ids) and (item['empQuestionId'] in emp_question_ids):
+                item['inputType'] = [x['inputType']
+                                     for x in emp_questions if x['id'] == item['empQuestionId']][0]
+                item['questionText'] = [x['text']
+                                        for x in emp_questions if x['id'] == item['empQuestionId']][0]
+                results.append(item)
+
+        return results
+
+    def format_answers_by_question_type(self, vend_answers_formatted: list) -> list:
+        """Format answers by question type"""
+        for item in vend_answers_formatted:
+            if item['inputType'] == 'mult_select':
+                item['answer'] = str([x['text'] for x in item['answer'] if x['isActive'] is True]).replace(
+                    '[', '').replace(']', '').replace('\'', '')
+
+        return vend_answers_formatted
+
+    def build_emp_questions_report(self) -> dict:
+        """Build Tundra employee questions report"""
+        vendor_list_items = self.db.get_results(
+            query=f"SELECT c.vendorId, c.vendorName, c.employerId, c.employerName FROM c WHERE c.type = 'vendorList' AND c.employerId = '{self.companyId}'")
+
+        emp_questions = self.db.get_results(
+            query=f"SELECT * FROM c WHERE c.type = 'empQuestion'")
+
+        emp_questions_formatted = self.format_questions(emp_questions)
+
+        vend_answers = self.db.get_results(
+            query=f"SELECT * FROM c WHERE c.type = 'vendAnswer'")
+
+        vend_answers_formatted = self.format_answers(
+            vendor_list_items, vend_answers, emp_questions_formatted, emp_questions)
+
+        vend_answers_by_type = self.format_answers_by_question_type(
+            vend_answers_formatted)
+
+        rows = []
+        for vendor_id in list(set([x['vendorId'] for x in vendor_list_items])):
+            row_object = {'Vendor Name': [
+                x['vendorName'] for x in vendor_list_items if x['vendorId'] == vendor_id][0]}
+            for inner_item in vend_answers_by_type:
+                if vendor_id == inner_item['vendorId']:
+                    row_object[inner_item['questionText']
+                               ] = inner_item['answer']
+
+            if len(row_object) > 1:
+                rows.append(row_object)
+
+        return {
+            'file_name': 'Questions_Report.csv',
+            'headers': ['Vendor Name'] + [x['text'] for x in emp_questions_formatted],
+            'rows': rows
+        }

eam_report_helper-0.0.1/src/eam_report_helper/report_helper.py

@@ -0,0 +1,103 @@
+import os
+import base64
+import logging
+
+from shared_functions.reports.report_helper_forms import FormReportHelper
+
+from shared_functions.reports.helpers import generate_csv
+
+from shared_functions.reports.report_safety_tickets import SafetyTicketsReport
+from shared_functions.reports.report_vendor_documents import VendorDocumentsReport
+from shared_functions.reports.report_emp_questions import EmpQuestionsReport
+from shared_functions.reports.report_vendor_deficiencies import VendorDeficienciesReport
+from shared_functions.reports.report_newly_added_vendors import NewlyAddedVendorReport
+from shared_functions.reports.report_operator_tickets import OperatorTicketReport
+
+from eam_db_helper import db
+from eam_b2c_helper import b2c
+
+logger = logging.getLogger("azure")
+logger.setLevel(logging.WARN)
+
+
+class ReportHelper:
+    """Report Helper"""
+
+    def __init__(self, company_id: str) -> None:
+        self.company_id = company_id
+        self.db = db.DatabaseHelper({
+            'account_uri': os.environ['COSMOS_ACCOUNT_URI'],
+            'key': os.environ['COSMOS_KEY'],
+            'db_name': os.environ['COSMOS_DATABASE'],
+            'container_name': os.environ['COSMOS_CONTAINER']
+        })
+        self.b2c_helper = b2c.B2CHelper({
+            "grant_type": "client_credentials",
+            "user_mgmt_client_id": os.environ["B2C_USER_MANAGEMENT_APP_CLIENT_ID"],
+            "scope": "https://graph.microsoft.com/.default",
+            "user_mgmt_client_secret": os.environ[
+                "B2C_USER_MANAGEMENT_APP_CLIENT_SECRET"
+            ],
+            "tenant_id": os.environ["B2C_TENANT_ID"],
+            "ext_app_client_id": os.environ["B2C_EXTENSION_APP_CLIENT_ID"],
+        })
+
+    def assemble_data(self, column_names: list, rows: list, file_name: str) -> str:
+        """Assemble data into csv and return binary string."""
+        generate_csv(
+            column_names, file_name, rows)
+        data = open(file_name, "rb").read()
+        base64_string = base64.b64encode(data)
+        os.remove(file_name)
+        return base64_string
+
+    def build_report(self, report_id: str) -> list:
+        """Build report based on report_id"""
+
+        match report_id:
+
+            case '16918672-f971-42ce-bb16-c0ea46555321':
+                results = SafetyTicketsReport(
+                    self.db, self.company_id, self.b2c_helper).build_safety_ticket_report()
+
+            case 'd8cba0aa-b3d8-4efa-a50d-6b85acf5569c':
+                results = VendorDocumentsReport(
+                    self.db, self.company_id).build_vendor_document_report()
+
+            case 'c3fc0792-37d9-40a3-827f-30d2260701d8':
+                results = EmpQuestionsReport(
+                    self.db, self.company_id).build_emp_questions_report()
+
+            case '91d72e1c-c280-4946-a0bd-37979f70652d':
+                results = VendorDeficienciesReport(
+                    self.db, self.company_id).build_vendor_deficiencies_report()
+
+                for row in results['rows']:
+                    del row['vendor_id']
+
+                results['headers'] = [x for x in results['rows'][0].keys()]
+
+            case 'cecee74f-2f2f-46d5-8fb3-3e3e624f7587':
+                results = FormReportHelper(self.db, self.b2c_helper).get_form_report(
+                    "bbb961a1-e9ab-4419-bb21-34f4515e3997", "Insignia_IncidentReport_Tracking.csv")
+
+            case 'dc9b4bb1-91d6-4b37-aa9d-ee53cc7209b5':
+                results = FormReportHelper(self.db, self.b2c_helper).get_form_report(
+                    "19ae3e00-bfb9-4105-8f44-7e5bb740afc8", "Insignia_NearMiss_HazID_Tracking.csv")
+
+            case '57dcd8cd-49bb-4ebc-8c6c-5db3c360d308':
+                results = FormReportHelper(self.db, self.b2c_helper).get_form_report(
+                    "b3e979a8-19e0-49bb-b5dd-504df0b056bc", "Insignia_RegulatoryCorrectiveAction_Tracking.csv")
+
+            case 'dae860b7-3ea7-49a2-9d25-c95fedd42c60':
+                results = NewlyAddedVendorReport(
+                    self.db, self.company_id).build_saturn_report()
+
+            case '0197faf6-da1a-424b-ad79-807519926737':
+                vendor_deficiency_results = VendorDeficienciesReport(
+                    self.db, self.company_id).build_vendor_deficiencies_report()
+
+                results = OperatorTicketReport(
+                    self.db, self.company_id, vendor_deficiency_results).build_operator_tickets_report()
+
+        return self.assemble_data(results['headers'], results['rows'], results['file_name'])

eam_report_helper-0.0.1/src/eam_report_helper/report_helper_forms.py

@@ -0,0 +1,185 @@
+class FormReportHelper:
+    """Form Report Helper"""
+
+    def __init__(self, database, b2c_helper):
+        self.database = database
+        self.b2c_helper = b2c_helper
+
+    def get_item_by_template(self, v: dict, elements: list) -> str:
+        """Get the item by label"""
+
+        element: dict = [
+            x for x in elements if x['id'] == v['elementId']][0]
+        try:
+            v['value'] = [x['label']
+                          for x in element['options'] if x['value'] == v['value']][0]
+        except IndexError:
+            pass
+
+        return v['value']
+
+    def get_item_by_label(self, v: dict, users: list, template: dict) -> str:
+        """Get the item by label"""
+        try:
+            row_item = v['value']
+
+            if v['type'] == 'inpSelectUser':
+                row_item = [x['displayName']
+                            for x in users if x['id'] == v['value']['id']][0]
+            if v['type'] == 'inpSelect':
+                row_item = self.get_item_by_template(
+                    v, template['elements'])
+
+        except KeyError:
+            row_item = v['values']
+        return row_item
+
+    def match_elements(self, distribution: dict, template: dict, users: list, sub_forms: list = None) -> dict:
+        """Match the elements"""
+        row = {
+            'Form Name': distribution['template']['name'],
+        }
+
+        if 'sequenceNumber' in distribution:
+            row['Report Number'] = distribution['sequenceNumber']
+
+        for k, v in distribution['data'].items():
+            if ('value' in v) or ('values' in v):
+                label = [x['label'] for x in template['elements']
+                         if x['id'] == v['elementId']][0]
+
+                row[label] = self.get_item_by_label(v, users, template)
+
+        # Combine the sub form data with the form data
+        if sub_forms is not None:
+            for sub_form in sub_forms:
+                if distribution['id'] == sub_form['distribution_id']:
+                    row = {**row, **sub_form['matched_elements']}
+
+        return row
+
+    def get_sub_forms(self, distributions: list, users: list) -> list:
+        """Get the sub forms"""
+
+        sub_form_ref_list = []
+        # Match form with subform
+        for distribution in distributions:
+            for k, v in distribution['data'].items():
+                for key, value in v.items():
+                    if key == 'subForm':
+                        for item in value:
+                            sub_form_ref_list.append({
+                                'distribution_id': distribution['id'],
+                                'sub_form_distribution_id': item['id']
+                            })
+
+        # Get the sub form distributions
+        sub_forms = self.database.get_results(
+            query=f"SELECT * FROM c where c.type = 'formDistribution' and ARRAY_CONTAINS({[x['sub_form_distribution_id'] for x in sub_form_ref_list]}, c.id)")
+
+        for sub_form in sub_forms:
+
+            for ref in sub_form_ref_list:
+                if ref['sub_form_distribution_id'] == sub_form['id']:
+                    ref['sub_form_template_id'] = sub_form['template']['id']
+                    ref['sub_form'] = sub_form
+
+        # Get the sub form templates
+        templates = self.database.get_results(
+            query=f"SELECT * FROM c where c.type = 'formTemplate' and ARRAY_CONTAINS({[x['sub_form_template_id'] for x in sub_form_ref_list]}, c.id)")
+
+        for sub_form in sub_form_ref_list:
+            for template in templates:
+                if sub_form['sub_form_template_id'] == template['id']:
+                    sub_form['sub_form_template'] = template
+
+        # Match the sub form distribution items with the template
+        for sub_form in sub_form_ref_list:
+            matched_elements = self.match_elements(sub_form['sub_form'],
+                                                   sub_form['sub_form_template'], users, None)
+            matched_elements['Status'] = sub_form['sub_form']['status']
+            sub_form['matched_elements'] = matched_elements
+
+        # Get the sub form elements in proper order, this will only work for Corrective Action?
+        for sub_form in sub_form_ref_list:
+            sub_form['matched_elements'].pop('Form Name')
+            sub_form['matched_elements'] = dict({
+                'Corrective Action Description': sub_form['matched_elements']['Corrective Action Description'],
+                'Corrective Action Status': sub_form['matched_elements']['Status'],
+                'Corrective Action Asignee': sub_form['matched_elements']['Corrective Action Responsibility'],
+                'Corrective Action Target Date': sub_form['matched_elements']['Corrective Action Due Date'],
+                'Corrective Action Completion Date': sub_form['matched_elements']['Corrective Action Completion Date']
+            })
+
+        return sub_form_ref_list
+
+    def remove_empty_columns(self, column_names: list, rows: list):
+        """Remove empty columns"""
+
+        for column_name in column_names:
+            try:
+                if all(row[column_name] == '' for row in rows):
+                    for row in rows:
+                        del row[column_name]
+                if all(row[column_name] == [] for row in rows):
+                    for row in rows:
+                        del row[column_name]
+            except KeyError:
+                pass
+
+        all_keys = [key for row in rows for key in row.keys()]
+
+        return {'column_names': list(dict.fromkeys(all_keys)), 'rows': rows}
+
+    def format_cell_lists(self, rows: list) -> list:
+        """for all rows, if the value is a list, join the list into a string"""
+        for row in rows:
+            for key, value in row.items():
+                if isinstance(value, list):
+                    # if vlaues in value is also a list, join them with a new line
+                    for i, v in enumerate(value):
+                        if isinstance(v, list):
+                            value[i] = ' - '.join(v)
+
+                    row[key] = '\n'.join(value)
+
+        return rows
+
+    def get_form_report(self, template_id: str,  report_name: str) -> dict:
+        """Get the Insignia Hazard ID History"""
+        template = self.database.get_result(
+            query=f"SELECT * FROM c where c.type = 'formTemplate' and c.id = '{template_id}'")
+
+        distributions = self.database.get_results(
+            query=f"SELECT * FROM c where c.type = 'formDistribution' and c.template.id = '{template_id}' ORDER BY c.sequenceNumber DESC")
+
+        users = self.b2c_helper.get_users(
+            company_id=template['companyId']
+        )
+
+        sub_forms = self.get_sub_forms(distributions, users)
+
+        rows = []
+        for distribution in distributions:
+            rows.append(self.match_elements(
+                distribution, template, users, sub_forms))
+
+        ordinal_list = []
+
+        for item in template['elements']:
+            ordinal_list.append(item)
+
+        if len(sub_forms) > 0:
+            column_names = [x['label'] for x in ordinal_list] + \
+                [x for x in sub_forms[0]['matched_elements'].keys()]
+        else:
+            column_names = [x['label'] for x in ordinal_list]
+
+        formatted_rows: dict = self.format_cell_lists(rows)
+        formatted_rows: dict = self.remove_empty_columns(column_names, rows)
+
+        return {
+            'file_name': report_name,
+            'headers': formatted_rows['column_names'],
+            'rows': formatted_rows['rows']
+        }

eam_report_helper-0.0.1/src/eam_report_helper/report_newly_added_vendors.py

@@ -0,0 +1,34 @@
+import datetime
+
+
+class NewlyAddedVendorReport:
+    def __init__(self, db, company_id):
+        self.db = db
+        self.company_id = company_id
+
+    def build_saturn_report(self):
+        results = self.db.get_results(
+            query=f"SELECT * FROM c where c.type = 'vendorList' and c.employerId = '{self.company_id}' and c.vendorDates.added >= 1727762400 order by c.vendorDates.added desc")
+
+        rows = []
+        for item in results:
+            if item['vendorDates']['added'] != '':
+
+                item['vendorDates']['added'] = datetime.datetime.fromtimestamp(
+                    item['vendorDates']['added']).strftime('%Y-%m-%d')
+                rows.append({
+                    'Vendor Name': item['vendorName'],
+                    'Date Vendor Added': item['vendorDates']['added'],
+                    'Vendor City': item['vendorAddress']['city'],
+                    'Vendor Admin Name': item['vendorAccountAdmin']['name'],
+                    'Vendor Admin Email': item['vendorAccountAdmin']['email'],
+                    'Vendor Admin Phone': item['vendorAccountAdmin']['phone'],
+                    'Rating': item['vendorOverallRating'],
+                    'Current Deficiencies': '\n'.join(item['vendorOverallItems'])
+                })
+
+        return {
+            'file_name': 'Added_Vendors.xlsx',
+            'rows': rows,
+            'headers': [x for x in rows[0].keys()] if len(rows) > 0 else []
+        }

eam_report_helper-0.0.1/src/eam_report_helper/report_operator_tickets.py

@@ -0,0 +1,122 @@
+class OperatorTicketReport:
+    """Operator Ticket Report"""
+
+    def __init__(self, db, company_id: str, vendor_deficiency_results: dict) -> None:
+        self.db = db
+        self.company_id = company_id
+        self.vendor_deficiency_results = vendor_deficiency_results
+
+    def filter_operators(self) -> list:
+        """Filter Operators"""
+        operators = [x for x in self.vendor_deficiency_results['rows']
+                     if x['Subscription Type'] == 0]
+
+        distinct_operators = []
+        for operator in operators:
+            distinct_operators.append({
+                'vendor_id': operator['vendor_id'],
+                'Vendor Name': operator['Vendor Name'],
+                'Subscription Type': operator['Subscription Type'],
+                'Vendor Tags': operator['Vendor Tags'],
+                'Vendor Rating': operator['Vendor Rating'],
+                'Admin Name': operator['Admin Name'],
+                'Admin Email': operator['Admin Email'],
+                'Admin Phone': operator['Admin Phone'],
+                'Vendor Deficiencies': '\n'.join([x['Current Deficiencies'] for x in self.vendor_deficiency_results['rows'] if x['vendor_id'] == operator['vendor_id']])
+            })
+
+        return [dict(t) for t in {tuple(d.items()) for d in distinct_operators}]
+
+    def prime(self, tickets: list) -> list:
+        """Prime"""
+        doc_questions = self.db.get_results(
+            query=f"SELECT * FROM c WHERE c.type = 'docQuestion' AND ARRAY_CONTAINS({list(set([x['docId'] for x in tickets]))}, c.docId)")
+
+        ticket_headers = []
+        for ticket in tickets:
+            for question in doc_questions:
+                if ticket['docId'] == question['docId']:
+
+                    item = {
+                        "header": f"{ticket['docType']}: {question['text']}",
+                        "key": question['key'],
+                        # "ticket_id": ticket['id']
+                    }
+                    if item not in ticket_headers:
+                        ticket_headers.append(item)
+
+        return ticket_headers
+
+    def get_ocr_output(self, header_list: list, ticket: dict) -> dict:
+        """Get OCR Output"""
+        for item in ticket['ocrOutput']['values']:
+            for key in header_list:
+                if item['key'] == key['key']:
+
+                    return {
+                        'key': [x['header'] for x in header_list if x['header'].split(':')[0] == ticket['docType']][0],
+                        'val': item['updatedValue'] if item['updatedValue'] != '' else item['ocrValue'],
+                        'vendor_id': ticket['vendorId']
+                    }
+
+    def build_final(self, tickets: list, header_list: list):
+        """Build final"""
+        results = []
+        for inner in tickets:
+
+            for k, v in inner.items():
+                if k == 'ocrOutput':
+                    ocr_value = self.get_ocr_output(header_list, inner)
+                    results.append(ocr_value)
+
+        return results
+
+    def build_operator_tickets_report(self) -> dict:
+        """Build Operator Tickets Report"""
+        operators = self.filter_operators()
+
+        tickets = self.db.get_results(
+            query=f"SELECT * FROM c WHERE c.type = 'vendorDoc' AND c.docClass = 'additionalRequirement' AND c.status != 'Not Submitted' AND c.employerId = '{self.company_id}' AND ARRAY_CONTAINS({[x['vendor_id'] for x in operators]}, c.vendorId)")
+
+        ticket_headers = self.prime(tickets)
+        ticket_results = self.build_final(tickets, ticket_headers)
+
+        rows = []
+
+        for operator in operators:
+            rows.append({
+                'vendor_id': operator['vendor_id'],
+                'Vendor Name': operator['Vendor Name'],
+                'Subscription Type': operator['Subscription Type'],
+                'Vendor Tags': operator['Vendor Tags'],
+                'Vendor Rating': operator['Vendor Rating'],
+                'Admin Name': operator['Admin Name'],
+                'Admin Email': operator['Admin Email'],
+                'Admin Phone': operator['Admin Phone'],
+                'Vendor Deficiencies': operator['Vendor Deficiencies']
+            })
+
+        final_headers = list(rows[0].keys()) + [x['header']
+                                                for x in ticket_headers]
+        final_rows = []
+        for item in rows:
+            final_rows.append(
+                {**item, **{x['header']: '' for x in ticket_headers}})
+
+        for item in final_rows:
+            for ticket in ticket_results:
+                if item['vendor_id'] == ticket['vendor_id']:
+                    item[ticket['key']] = ticket['val']
+
+        more_final_rows = []
+        for item in final_rows:
+            item.pop('vendor_id')
+            more_final_rows.append(item)
+
+        final_headers.remove('vendor_id')
+
+        return {
+            'file_name': 'Operator_Ticket_Report.csv',
+            'headers': final_headers,
+            'rows': more_final_rows
+        }

eam_report_helper-0.0.1/src/eam_report_helper/report_safety_tickets.py

@@ -0,0 +1,164 @@
+from datetime import datetime
+import os
+
+
+class SafetyTicketsReport:
+    """Safety Tickets Report"""
+
+    def __init__(self, db, company_id: str, b2c_helper) -> None:
+        self.db = db
+        self.company_id = company_id
+        self.b2c_helper = b2c_helper
+
+    def get_report_headers(self) -> list:
+        """Get report headers"""
+
+        docs = self.db.get_results(
+            query="SELECT * FROM c WHERE c.type = 'doc' AND c.docClass = 'additionalRequirement' AND c.isUserTicket = true")
+
+        results = []
+        for doc in docs:
+            if 'employerId' in doc:
+                if doc['employerId'] == self.company_id:
+                    results.append(
+                        {'docType': doc['docType'], 'docRef': doc['docRef']})
+                else:
+                    pass
+            else:
+                results.append(
+                    {'docType': doc['docType'], 'docRef': doc['docRef']})
+
+        return results
+
+    def remove_duplicates(self, active_docs: list):
+        """Remove duplicates"""
+        test = []
+        for item in active_docs:
+            for key in item.keys():
+                test.append(key)
+
+        distinct_list = list(set(test))
+
+        test = []
+        for item in active_docs:
+            for inner in distinct_list:
+                for key, val in item.items():
+                    if key == inner:
+
+                        item = {
+                            'key': key,
+                            'val': val
+                        }
+
+                        try:
+                            item['val'] = datetime.strptime(val, '%Y-%m-%d')
+                        except ValueError:
+                            pass
+
+                        test.append(item)
+
+        filtered_list = [x for x in test if x['val'] != '']
+
+        final = []
+        for item in distinct_list:
+            try:
+                tested = datetime.strftime(
+                    max([x['val'] for x in filtered_list if x['key'] == item]), '%Y-%m-%d')
+                final.append({item: tested})
+            except ValueError:
+                final.append({item: ''})
+
+        return final
+
+    def prime(self, base_dict: dict, user_doc_questions: list, user_doc_ids_by_user: list):
+        """Prime"""
+        user_doc_questions = [
+            x for x in user_doc_questions if x['userDocId'] in user_doc_ids_by_user]
+
+        test = []
+        for k, v in enumerate(base_dict.items()):
+            for item in user_doc_questions:
+                if (k > 1) and (item['docRef'] == v[1]['docRef']):
+                    test.append(
+                        ({f"{v[1]['docType']} {item['text']}": item['answer']}))
+
+        return test
+
+    def build_final(self, user_docs: list, header_list: list):
+        """Build final"""
+        results = []
+        for item in header_list:
+            results.append({'key': item, 'val': ''})
+            for inner in user_docs:
+
+                for k, v in inner.items():
+                    if item == k:
+                        results.append({'key': k, 'val': v})
+
+        final_results = []
+        test = list(set(x['key'] for x in results))
+        for item in test:
+            tested = [x['val'] for x in results if x['key'] == item]
+
+            if len(tested) > 1:
+                final_results.append({
+                    item: tested[1]
+                })
+
+            else:
+                final_results.append({
+                    item: ''
+                })
+
+        return final_results
+
+    def build_safety_ticket_report(self):
+        """Build safety ticket report"""
+        headers = self.get_report_headers()
+
+        b2c_users = self.b2c_helper.get_users(self.company_id)
+
+        users = [
+            x for x in b2c_users if x[f'extension_{os.environ["B2C_EXTENSION_APP_CLIENT_ID"]}_UserRoles'] != '8amAdmin']
+
+        user_docs = self.db.get_results(
+            query=f"SELECT * FROM c WHERE c.type = 'userDoc' and ARRAY_CONTAINS({[x['id'] for x in users]}, c.userId)")
+
+        user_doc_questions = self.db.get_results(
+            query=f"SELECT * FROM c WHERE c.type = 'userDocQuestion' and ARRAY_CONTAINS({[x['id'] for x in user_docs]}, c.userDocId)")
+
+        doc_questions = self.db.get_results(
+            query=f"SELECT * FROM c WHERE c.type = 'docQuestion'")
+
+        new_headers = []
+        for item in headers:
+            for inner in doc_questions:
+                if item['docRef'] == inner['docRef']:
+                    new_headers.append(f"{item['docType']} {inner['text']}")
+
+        user_rows = []
+        for user in users:
+            user_doc_ids_by_user = [x['id']
+                                    for x in user_docs if user['id'] == x['userId']]
+
+            test = {**{'User Name': user['displayName'],
+                    'User Id': user['id']}, **dict(list(enumerate(headers)))}
+
+            test = self.prime(test, user_doc_questions, user_doc_ids_by_user)
+
+            if test:
+                docs = self.remove_duplicates(test)
+                row = self.build_final(docs, new_headers)
+                row[0] = {
+                    'User Name': user['displayName']
+                }
+                result = {}
+                for obj in row:
+                    result.update(obj)
+                user_rows.append(result)
+
+        return {
+            'file_name': 'Safety_Tickets_Report.csv',
+            'headers': ['User Name'] + new_headers,
+            'rows': user_rows
+        }

eam_report_helper-0.0.1/src/eam_report_helper/report_vendor_deficiencies.py

@@ -0,0 +1,92 @@
+from datetime import datetime
+
+
+class VendorDeficienciesReport:
+    """Vendor Deficiencies Report"""
+
+    def __init__(self, db, company_id: str) -> None:
+        self.db = db
+        self.company_id = company_id
+
+    def get_ratings_updated(self, vendor_list: dict) -> dict:
+        """Get ratings updated"""
+        if ('ratingsUpdated' in vendor_list) and (vendor_list['ratingsUpdated'] != ''):
+
+            return {
+                'dateRatingApplied': datetime.fromtimestamp(
+                    int(vendor_list['ratingsUpdated'])).strftime('%Y-%m-%d'),
+                'daysSinceRatingApplied': (
+                    datetime.now() - datetime.fromtimestamp(int(vendor_list['ratingsUpdated']))).days
+            }
+        else:
+            return {
+                'dateRatingApplied': '',
+                'daysSinceRatingApplied': ''
+            }
+
+    def split_vendor_list_by_deficiency(self, vendor_list: dict) -> list:
+        """Split vendor list by deficiency"""
+        new_list = []
+        if ('vendorOverallItems' in vendor_list) and (len(vendor_list['vendorOverallItems']) > 1):
+            for deficiency in vendor_list['vendorOverallItems']:
+                new_list.append({
+                    'vendor_id': vendor_list['vendorId'],
+                    'vendorName': vendor_list['vendorName'],
+                    'vendorSubscriptionType': vendor_list['vendorSubscriptionType'],
+                    'tags': vendor_list['tags'],
+                    'vendorOverallRating': vendor_list['vendorOverallRating'],
+                    'vendorDeficiency': deficiency,
+                    'ratingsUpdated': vendor_list['ratingsUpdated'],
+                    'vendorAccountAdmin': vendor_list['vendorAccountAdmin']
+                })
+
+        else:
+            new_list.append({
+                'vendor_id': vendor_list['vendorId'],
+                'vendorName': vendor_list['vendorName'],
+                'vendorSubscriptionType': vendor_list['vendorSubscriptionType'],
+                'tags': vendor_list['tags'],
+                'vendorOverallRating': vendor_list['vendorOverallRating'],
+                'vendorDeficiency': [x for x in vendor_list['vendorOverallItems']][0] if len(vendor_list['vendorOverallItems']) > 0 else '',
+                'ratingsUpdated': vendor_list['ratingsUpdated'],
+                'vendorAccountAdmin': vendor_list['vendorAccountAdmin']
+            })
+
+        return new_list
+
+    def build_vendor_deficiencies_report(self) -> dict:
+        """Build vendor deficiencies report"""
+        vendor_lists = self.db.get_results(
+            query=f"SELECT c.vendorId, c.vendorName, c.vendorSubscriptionType, c.tags, c.vendorOverallRating, c.vendorOverallItems, c.employerDates.ratingsUpdated,\
+                c.vendorAccountAdmin from c where c.type = 'vendorList'AND c.employerId = '{self.company_id}'")
+
+        formatted_list = []
+        for vendor_list in vendor_lists:
+            vendor_list['ratingsUpdated'] = self.get_ratings_updated(
+                vendor_list)
+
+            vendor_list: list = self.split_vendor_list_by_deficiency(
+                vendor_list)
+
+            for item in vendor_list:
+                item['tags'] = '\n'.join(item['tags'])
+
+                formatted_list.append({
+                    'vendor_id': item['vendor_id'],
+                    'Vendor Name': item['vendorName'],
+                    'Subscription Type': item['vendorSubscriptionType'],
+                    'Vendor Tags': item['tags'],
+                    'Vendor Rating': item['vendorOverallRating'],
+                    'Current Deficiencies': item['vendorDeficiency'],
+                    'Date Rating Applied': item['ratingsUpdated']['dateRatingApplied'],
+                    'Days Since Rating Applied': item['ratingsUpdated']['daysSinceRatingApplied'],
+                    'Admin Name': item['vendorAccountAdmin']['name'],
+                    'Admin Email': item['vendorAccountAdmin']['email'],
+                    'Admin Phone': item['vendorAccountAdmin']['phone']
+                })
+
+        return {
+            'file_name': 'Def_Report.csv',
+            'headers': list(formatted_list[0].keys()),
+            'rows': formatted_list
+        }

eam_report_helper-0.0.1/src/eam_report_helper/report_vendor_documents.py

@@ -0,0 +1,102 @@
+from datetime import datetime
+
+
+class VendorDocumentsReport:
+    """Report Vendor Documents"""
+
+    def __init__(self, db, company_id: str) -> None:
+        self.db = db
+        self.company_id = company_id
+
+    def key_func(self, k: dict) -> str:
+        """Key function"""
+        return k['Vendor Name']
+
+    def match_expiry_date(self, vendor_doc: dict, vendor_qoc_questions: list) -> str:
+        """Match expiry date"""
+        expiry_date = ''
+
+        if 'values' in vendor_doc['ocrOutput']:
+
+            if vendor_doc['ocrOutput']['values'] != []:
+
+                for item in vendor_doc['ocrOutput']['values']:
+
+                    if item['key'] == 'expiry_date':
+
+                        if item['updatedValue'] != '':
+                            expiry_date = item['updatedValue']
+                        else:
+                            expiry_date = item['ocrValue']
+            else:
+
+                for vendor_qoc_question in vendor_qoc_questions:
+                    if vendor_doc['id'] == vendor_qoc_question['vendorDocId']:
+                        expiry_date = vendor_qoc_question['answer']
+
+        else:
+
+            for vendor_qoc_question in vendor_qoc_questions:
+                if vendor_doc['id'] == vendor_qoc_question['vendorDocId']:
+                    expiry_date = vendor_qoc_question['answer']
+
+        return expiry_date
+
+    def build_vendor_document_report(self) -> dict:
+        """Build vendor document report"""
+
+        headers = ["Vendor Name", "Document Type", "Document Name",
+                   "Status", "Expiry Date", "Last Modified"]
+
+        vendor_list_by_employer = self.db.get_results(
+            query=f"SELECT c.vendorId, c.vendorName FROM c WHERE c.type = 'vendorList' AND c.employerId = '{self.company_id}'")
+
+        results = [x['vendorId'] for x in vendor_list_by_employer]
+
+        docs = self.db.get_results(
+            query=f"SELECT c.id, c.vendorId, c.employerId, c.docType, c.docName, c.status, c.ocrOutput, c._ts FROM c WHERE c.type = 'vendorDoc' AND ARRAY_CONTAINS({results}, c.vendorId) AND c.status != 'Not Submitted'")
+
+        vendor_doc_questions = self.db.get_results(
+            query="SELECT * FROM c WHERE c.type = 'vendorDocQuestion' AND c.key = 'expiry_date'")
+
+        results = []
+        for doc in docs:
+
+            if 'docName' in doc:
+                doc_name = doc['docName']
+            else:
+                doc_name = ''
+
+            expiry_date = self.match_expiry_date(doc, vendor_doc_questions)
+
+            if 'employerId' in doc:
+                if doc['employerId'] == self.company_id:
+
+                    results.append({
+                        'Vendor Name': [x['vendorName'] for x in vendor_list_by_employer if x['vendorId'] == doc['vendorId']][0],
+                        'Document Type': doc['docType'],
+                        'Document Name': doc_name,
+                        'Status': doc['status'],
+                        'Expiry Date': expiry_date,
+                        'Last Modified': datetime.fromtimestamp(doc["_ts"]).strftime("%Y-%m-%d")
+                    })
+                else:
+                    pass
+
+            else:
+                results.append({
+                    'Vendor Name': [x['vendorName'] for x in vendor_list_by_employer if x['vendorId'] == doc['vendorId']][0],
+                    'Document Type': doc['docType'],
+                    'Document Name': doc_name,
+                    'Status': doc['status'],
+                    'Expiry Date': expiry_date,
+                    'Last Modified': datetime.fromtimestamp(doc["_ts"]).strftime("%Y-%m-%d")
+                })
+
+        rows = sorted(results, key=self.key_func)
+
+        return {
+            'file_name': 'Vendor_Documents_Report.csv',
+            'headers': headers,
+            'rows': rows
+        }