Remix

Make your own version of Behavior Report Studio

Edit the prompt below and generate a customized version in seconds.

Original by TSM The Safety Master Software

Describe your app

import Response from '../models/Response.js';
import Survey from '../models/Survey.js';
import Question from '../models/Question.js';
import mongoose from 'mongoose';
import puppeteer from 'puppeteer';
import fs from "fs";
import path from "path";

export class ReportService {
  constructor() {
    this.ROOT_CAUSE_TYPES = [
      'overconfidence',
      'negligence', 
      'procrastination',
      'overlooking_consequence',
      'attitude',
      'shortcuts',
    ];

// Industry standard safety categories
    this.SAFETY_CATEGORIES = {
      'Personal Protective Equipment': 'PPE',
      'Hazard Recognition': 'HAZARD',
      'Safety Procedures': 'PROCEDURE',
      'Communication': 'COMM',
      'Training & Competency': 'TRAINING',
      'Leadership & Management': 'LEADERSHIP',
      'Risk Assessment': 'RISK',
      'Emergency Response': 'EMERGENCY'
    };

// Industry benchmarks (percentages)
    this.INDUSTRY_BENCHMARKS = {
      'excellent': 85,
      'good': 70,
      'acceptable': 55,
      'poor': 40
    };
  }

async generateReportData(surveyId, filters = {}) {
    try {
      const matchQuery = { survey: new mongoose.Types.ObjectId(surveyId) };
      
      // Apply comprehensive filters
      if (filters.department) matchQuery.department = new RegExp(filters.department, 'i');
      if (filters.behaviorType) matchQuery.behaviorType = filters.behaviorType;
      if (filters.startDate || filters.endDate) {
        matchQuery.submittedAt = {};
        if (filters.startDate) matchQuery.submittedAt.$gte = new Date(filters.startDate);
        if (filters.endDate) matchQuery.submittedAt.$lte = new Date(filters.endDate + 'T23:59:59.999Z');
      }

// Get survey and questions
      const survey = await Survey.findById(surveyId).populate('createdBy', 'name email');
      const questions = await Question.find({ survey: surveyId }).sort({ order: 1 });
      
      if (!survey) throw new Error('Survey not found');

// Calculate comprehensive metrics
      const basicMetrics = await this.calculateBasicMetrics(matchQuery, questions.length);
      const detailedAnalysis = await this.calculateDetailedAnalysis(matchQuery, questions);
      const benchmarkComparison = await this.calculateBenchmarkComparison(matchQuery, questions);
      const trendAnalysis = await this.calculateTrendAnalysis(surveyId, filters);
      const riskAssessment = await this.calculateRiskAssessment(matchQuery, questions);
      const actionPriorities = await this.calculateActionPriorities(matchQuery, questions);

return {
        survey,
        surveys: [survey],
        reportMetadata: {
          generatedAt: new Date(),
          generatedBy: survey.createdBy,
          reportType: 'Single Survey Analysis',
          filters: filters,
          isMultiSurvey: false
        },
        ...basicMetrics,
        ...detailedAnalysis,
        benchmarkComparison,
        trendAnalysis,
        riskAssessment,
        actionPriorities
      };
    } catch (error) {
      throw new Error(`Failed to generate report data: ${error.message}`);
    }
  }

async generateMultiSurveyReportData(surveyIds, filters = {}) {
    try {
      const surveyObjectIds = surveyIds.map(id => new mongoose.Types.ObjectId(id));
      const matchQuery = { survey: { $in: surveyObjectIds } };
      
      // Apply filters
      if (filters.department) matchQuery.department = new RegExp(filters.department, 'i');
      if (filters.behaviorType) matchQuery.behaviorType = filters.behaviorType;
      if (filters.startDate || filters.endDate) {
        matchQuery.submittedAt = {};
        if (filters.startDate) matchQuery.submittedAt.$gte = new Date(filters.startDate);
        if (filters.endDate) matchQuery.submittedAt.$lte = new Date(filters.endDate + 'T23:59:59.999Z');
      }

// Get surveys and questions
      const surveys = await Survey.find({ _id: { $in: surveyObjectIds } }).populate('createdBy', 'name email');
      const allQuestions = await Question.find({ survey: { $in: surveyObjectIds } }).sort({ survey: 1, order: 1 });
      
      // Calculate average question count
      const avgQuestionCount = allQuestions.length / surveys.length;

// Calculate comprehensive metrics
      const basicMetrics = await this.calculateBasicMetrics(matchQuery, avgQuestionCount);
      const detailedAnalysis = await this.calculateMultiSurveyDetailedAnalysis(matchQuery, allQuestions, surveys);
      const surveyComparison = await this.calculateSurveyComparison(surveyObjectIds, matchQuery);
      const crossSurveyInsights = await this.calculateCrossSurveyInsights(matchQuery, allQuestions);
      const consolidatedRiskAssessment = await this.calculateConsolidatedRiskAssessment(matchQuery, allQuestions);

return {
        surveys,
        survey: { 
          title: `Combined Analysis Report (${surveys.length} Surveys)`,
          _id: 'multi-survey',
          createdBy: surveys[0]?.createdBy
        },
        reportMetadata: {
          generatedAt: new Date(),
          generatedBy: surveys[0]?.createdBy,
          reportType: 'Multi-Survey Comparative Analysis',
          filters: filters,
          isMultiSurvey: true,
          surveyCount: surveys.length
        },
        ...basicMetrics,
        ...detailedAnalysis,
        surveyComparison,
        crossSurveyInsights,
        consolidatedRiskAssessment
      };
    } catch (error) {
      throw new Error(`Failed to generate multi-survey report data: ${error.message}`);
    }
  }

async calculateBasicMetrics(matchQuery, questionCount) {
    const totalResponses = await Response.countDocuments(matchQuery);
    
    const scoreStats = await Response.aggregate([
      { $match: matchQuery },
      {
        $group: {
          _id: null,
          avgScore: { $avg: '$totalScore' },
          minScore: { $min: '$totalScore' },
          maxScore: { $max: '$totalScore' },
          stdDev: { $stdDevPop: '$totalScore' }
        }
      }
    ]);

const stats = scoreStats[0] || { avgScore: 0, minScore: 0, maxScore: 0, stdDev: 0 };
    const maxPossibleScore = questionCount * 5;
    const safetyIndex = (stats.avgScore / maxPossibleScore) * 100;

// Calculate response rate and completion metrics
    const completionStats = await Response.aggregate([
      { $match: matchQuery },
      {
        $project: {
          answerCount: { $size: { $ifNull: ['$answers', []] } },
          expectedAnswers: questionCount,
          completionRate: {
            $multiply: [
              { $divide: [{ $size: { $ifNull: ['$answers', []] } }, questionCount] },
              100
            ]
          }
        }
      },
      {
        $group: {
          _id: null,
          avgCompletionRate: { $avg: '$completionRate' },
          fullyCompleted: {
            $sum: {
              $cond: [{ $eq: ['$answerCount', '$expectedAnswers'] }, 1, 0]
            }
          }
        }
      }
    ]);

const completion = completionStats[0] || { avgCompletionRate: 0, fullyCompleted: 0 };

return {
      totalResponses,
      averageScore: Math.round(stats.avgScore * 100) / 100,
      scoreRange: {
        min: Math.round(stats.minScore * 100) / 100,
        max: Math.round(stats.maxScore * 100) / 100,
        standardDeviation: Math.round(stats.stdDev * 100) / 100
      },
      safetyIndex: Math.round(safetyIndex * 100) / 100,
      completionMetrics: {
        averageCompletionRate: Math.round(completion.avgCompletionRate * 100) / 100,
        fullyCompletedResponses: completion.fullyCompleted,
        completionPercentage: totalResponses > 0 ? Math.round((completion.fullyCompleted / totalResponses) * 100) : 0
      }
    };
  }

async calculateDetailedAnalysis(matchQuery, questions) {
    // Enhanced respondent profile with statistical analysis
    const respondentProfile = await this.getEnhancedRespondentProfile(matchQuery);
    
    // Detailed system performance by category
    const systemPerformance = await this.getDetailedSystemPerformance(matchQuery, questions);
    
    // Advanced behavior distribution with correlations
    const behaviorDistribution = await this.getAdvancedBehaviorDistribution(matchQuery);
    
    // Comprehensive root cause analysis
    const rootCauses = await this.getComprehensiveRootCauses(matchQuery, questions);
    
    // Detailed question analysis
    const questionComparison = await this.getDetailedQuestionComparison(questions[0]?.survey, matchQuery);
    
    // Perception gap analysis
    const perceptionGap = await this.getDetailedPerceptionGap(matchQuery);

// Safety culture maturity assessment
    const cultureMaturity = await this.calculateSafetyCultureMaturity(matchQuery, questions);

return {
      respondentProfile,
      systemPerformance,
      behaviorDistribution,
      rootCauses,
      questionComparison,
      perceptionGap,
      cultureMaturity
    };
  }
update report service as we need complete industry standard behavior survey report including various factors like age group, designation, shift, category indicating assertive, passive, agressive. and also show unsafe root causes all over. unsafe act for passive and agressive. unsafe act for factors like age group, different surveys, designation, experience, department, shift. provide backend: report Service

Free to use. No credit card required.