tango-app-api-audio-analytics 1.0.0

package/src/controllers/cohort.controller.js

@@ -0,0 +1,357 @@
+/**
+ * Cohort Controller
+ * Handles cohort creation and management endpoints
+ */
+
+import {
+  createCohort as createCohortService,
+  getCohortById,
+  getCohortsByClientId,
+  updateCohort as updateCohortService,
+  deleteCohort as deleteCohortService,
+  searchCohorts,
+  getCohortAnalytics,
+  cohortExists,
+} from '../services/cohort.service.js';
+import {
+  cohortCreationSchema,
+  cohortUpdateSchema,
+  cohortQuerySchema,
+  validateCohortData,
+} from '../validations/cohort.validation.js';
+import { logger } from 'tango-app-api-middleware';
+
+/**
+ * Create new cohort
+ * POST /cohorts
+ *
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+export const createCohort = async ( req, res ) => {
+  try {
+    logger.info( 'Creating new cohort' );
+
+    const { error, value: validatedData } = await validateCohortData(
+        req.body,
+        cohortCreationSchema,
+    );
+
+    if ( error ) {
+      logger.warn( 'Cohort validation failed', error );
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: error.message,
+        code: 'VALIDATION_ERROR',
+        details: error.details,
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    // Check if cohort already exists
+    const exists = await cohortExists( validatedData.cohortId );
+    if ( exists ) {
+      logger.warn( `Cohort already exists: ${validatedData.cohortId}` );
+      return res.status( 409 ).json( {
+        status: 'error',
+        message: 'Cohort with this ID already exists',
+        code: 'COHORT_EXISTS',
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    // Create cohort in OpenSearch
+    const result = await createCohortService( validatedData );
+
+    logger.info( 'Cohort created successfully', {
+      cohortId: validatedData.cohortId,
+      documentId: result.data.documentId,
+    } );
+
+    res.status( 201 ).json( {
+      status: 'success',
+      message: result.message,
+      data: {
+        cohortId: result.data.cohortId,
+        cohortName: result.data.cohortName,
+        clientId: result.data.clientId,
+        documentId: result.data.documentId,
+        createdAt: result.data.createdAt,
+        metricsCount: result.data.metrics.length,
+      },
+      timestamp: new Date().toISOString(),
+    } );
+  } catch ( error ) {
+    logger.error( `Error creating cohort: ${error.message}`, error );
+
+    if ( error.code === 'COHORT_CREATE_ERROR' ) {
+      return res.status( 500 ).json( {
+        status: 'error',
+        message: error.message,
+        code: error.code,
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    res.status( 500 ).json( {
+      status: 'error',
+      message: 'Internal server error',
+      code: 'INTERNAL_ERROR',
+      timestamp: new Date().toISOString(),
+    } );
+  }
+};
+
+/**
+ * Get cohort by ID
+ * GET /cohorts/:cohortId
+ *
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+export const getCohort = async ( req, res ) => {
+  try {
+    const { cohortId } = req.params;
+
+    logger.info( `Fetching cohort: ${cohortId}` );
+
+    const cohort = await getCohortById( cohortId );
+
+    res.status( 200 ).json( {
+      status: 'success',
+      data: cohort,
+      timestamp: new Date().toISOString(),
+    } );
+  } catch ( error ) {
+    logger.error( `Error fetching cohort: ${error.message}`, error );
+
+    if ( error.message.includes( 'not found' ) ) {
+      return res.status( 404 ).json( {
+        status: 'error',
+        message: 'Cohort not found',
+        code: 'COHORT_NOT_FOUND',
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    res.status( 500 ).json( {
+      status: 'error',
+      message: 'Internal server error',
+      code: 'INTERNAL_ERROR',
+      timestamp: new Date().toISOString(),
+    } );
+  }
+};
+
+/**
+ * Get cohorts by client ID
+ * GET /cohorts/client/:clientId
+ *
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+export const getCohortsByClient = async ( req, res ) => {
+  try {
+    const { clientId } = req.params;
+    const { limit = 10, offset = 0 } = req.query;
+
+    logger.info( `Fetching cohorts for client: ${clientId}` );
+
+    const result = await getCohortsByClientId(
+        clientId,
+        parseInt( limit ),
+        parseInt( offset ),
+    );
+
+    res.status( 200 ).json( {
+      status: 'success',
+      data: result.cohorts,
+      pagination: result.pagination,
+      timestamp: new Date().toISOString(),
+    } );
+  } catch ( error ) {
+    logger.error( `Error fetching cohorts: ${error.message}`, error );
+
+    res.status( 500 ).json( {
+      status: 'error',
+      message: 'Internal server error',
+      code: 'INTERNAL_ERROR',
+      timestamp: new Date().toISOString(),
+    } );
+  }
+};
+
+/**
+ * Search cohorts
+ * POST /cohorts/search
+ *
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+export const searchCohortsEndpoint = async ( req, res ) => {
+  try {
+    const { error, value: validatedData } = await validateCohortData(
+        req.body,
+        cohortQuerySchema,
+    );
+
+    if ( error ) {
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: error.message,
+        code: 'VALIDATION_ERROR',
+        details: error.details,
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    logger.info( 'Searching cohorts' );
+
+    const result = await searchCohorts(
+        {
+          clientId: validatedData.clientId,
+          cohortId: validatedData.cohortId,
+          cohortName: validatedData.cohortName,
+        },
+        validatedData.limit,
+        validatedData.offset,
+    );
+
+    res.status( 200 ).json( {
+      status: 'success',
+      data: result.cohorts,
+      pagination: result.pagination,
+      timestamp: new Date().toISOString(),
+    } );
+  } catch ( error ) {
+    logger.error( `Error searching cohorts: ${error.message}`, error );
+
+    res.status( 500 ).json( {
+      status: 'error',
+      message: 'Internal server error',
+      code: 'INTERNAL_ERROR',
+      timestamp: new Date().toISOString(),
+    } );
+  }
+};
+
+/**
+ * Update cohort
+ * PUT /cohorts/:documentId
+ *
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+export const updateCohort = async ( req, res ) => {
+  try {
+    const { documentId } = req.params;
+
+    const { error, value: validatedData } = await validateCohortData(
+        req.body,
+        cohortUpdateSchema,
+    );
+
+    if ( error ) {
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: error.message,
+        code: 'VALIDATION_ERROR',
+        details: error.details,
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    logger.info( `Updating cohort: ${documentId}` );
+
+    const result = await updateCohortService( documentId, validatedData );
+
+    res.status( 200 ).json( {
+      status: 'success',
+      message: result.message,
+      data: result.data,
+      timestamp: new Date().toISOString(),
+    } );
+  } catch ( error ) {
+    logger.error( `Error updating cohort: ${error.message}`, error );
+
+    res.status( 500 ).json( {
+      status: 'error',
+      message: 'Internal server error',
+      code: 'INTERNAL_ERROR',
+      timestamp: new Date().toISOString(),
+    } );
+  }
+};
+
+/**
+ * Delete cohort
+ * DELETE /cohorts/:documentId
+ *
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+export const deleteCohort = async ( req, res ) => {
+  try {
+    const { documentId } = req.params;
+
+    logger.info( `Deleting cohort: ${documentId}` );
+
+    const result = await deleteCohortService( documentId );
+
+    res.status( 200 ).json( {
+      status: 'success',
+      message: result.message,
+      timestamp: new Date().toISOString(),
+    } );
+  } catch ( error ) {
+    logger.error( `Error deleting cohort: ${error.message}`, error );
+
+    res.status( 500 ).json( {
+      status: 'error',
+      message: 'Internal server error',
+      code: 'INTERNAL_ERROR',
+      timestamp: new Date().toISOString(),
+    } );
+  }
+};
+
+/**
+ * Get cohort analytics
+ * GET /cohorts/:cohortId/analytics
+ *
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+export const getCohortAnalyticsEndpoint = async ( req, res ) => {
+  try {
+    const { cohortId } = req.params;
+
+    logger.info( `Fetching analytics for cohort: ${cohortId}` );
+
+    const analytics = await getCohortAnalytics( cohortId );
+
+    res.status( 200 ).json( {
+      status: 'success',
+      data: analytics,
+      timestamp: new Date().toISOString(),
+    } );
+  } catch ( error ) {
+    logger.error( `Error fetching cohort analytics: ${error.message}`, error );
+
+    if ( error.message.includes( 'not found' ) ) {
+      return res.status( 404 ).json( {
+        status: 'error',
+        message: 'Cohort not found',
+        code: 'COHORT_NOT_FOUND',
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    res.status( 500 ).json( {
+      status: 'error',
+      message: 'Internal server error',
+      code: 'INTERNAL_ERROR',
+      timestamp: new Date().toISOString(),
+    } );
+  }
+};

package/src/controllers/cohortAnalytics.controller.js

@@ -0,0 +1,46 @@
+// import { sampleCohortData } from '../models/cohortAnalysis.model.js';
+import { logger } from 'tango-app-api-middleware';
+
+/**
+ * Get Complete Cohort Analysis
+ * GET /cohort-analysis
+ * @param {Object} req - Express request object
+ * @param {Object} req.body - Request body with analysis parameters
+ * @param {string} req.body.startDate - Start date for analysis
+ * @param {string} req.body.endDate - End date for analysis
+ * @param {string} req.body.storeId - Store ID for filtering
+ * @param {Object} res - Express response object
+ * @return {void} Returns JSON response with cohort analysis data
+ */
+export const getCohortAnalysis = async ( req, res ) => {
+  try {
+    const { startDate, endDate, storeId } = req.body;
+
+    // Validation
+    if ( !startDate || !endDate || !storeId ) {
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: 'Missing required parameters: startDate, endDate, storeId',
+        code: 'MISSING_PARAMETERS',
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    logger.info( `Fetching cohort analysis for store ${storeId} from ${startDate} to ${endDate}` );
+
+    // Return sample data (replace with database query later)
+    return res.status( 200 ).json( {
+      status: 'success',
+      data: 'sampleCohortData',
+      timestamp: new Date().toISOString(),
+    } );
+  } catch ( error ) {
+    logger.error( `Error fetching cohort analysis: ${error.message}` );
+    return res.status( 500 ).json( {
+      status: 'error',
+      message: 'Internal server error',
+      code: 'INTERNAL_ERROR',
+      timestamp: new Date().toISOString(),
+    } );
+  }
+};

package/src/controllers/conversationAnalytics.controller.js

@@ -0,0 +1,92 @@
+// import { sampleConversationData, sampleConversationsList } from '../models/conversationAnalysis.model.js';
+import { logger } from 'tango-app-api-middleware';
+
+/**
+ * Get Conversation Analysis List
+ * POST /conversations/list
+ * @param {Object} req - Express request object
+ * @param {Object} req.body - Request body with query parameters
+ * @param {string} req.body.startDate - Start date for filtering
+ * @param {string} req.body.endDate - End date for filtering
+ * @param {string} req.body.storeId - Store ID for filtering
+ * @param {Object} res - Express response object
+ * @return {void} Returns JSON response with conversations list
+ */
+export const getConversationsList = async ( req, res ) => {
+  try {
+    const { startDate, endDate, storeId } = req.body;
+
+    // Validation
+    if ( !startDate || !endDate || !storeId ) {
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: 'Missing required parameters: startDate, endDate, storeId',
+        code: 'MISSING_PARAMETERS',
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    logger.info( `Fetching conversations for store ${storeId} from ${startDate} to ${endDate}` );
+
+    return res.status( 200 ).json( {
+      status: 'success',
+      data: {
+        totalConversations: 0,
+        conversations: 'sampleConversationsList',
+      },
+      timestamp: new Date().toISOString(),
+    } );
+  } catch ( error ) {
+    logger.error( `Error fetching conversations: ${error.message}` );
+    return res.status( 500 ).json( {
+      status: 'error',
+      message: 'Internal server error',
+      code: 'INTERNAL_ERROR',
+      timestamp: new Date().toISOString(),
+    } );
+  }
+};
+
+/**
+ * Get Single Conversation Details
+ * POST /conversations/:conversationId
+ * @param {Object} req - Express request object
+ * @param {Object} req.params - URL parameters
+ * @param {string} req.params.conversationId - Conversation ID from URL
+ * @param {Object} req.body - Request body with store information
+ * @param {string} req.body.storeId - Store ID for filtering
+ * @param {Object} res - Express response object
+ * @return {void} Returns JSON response with conversation details
+ */
+export const getConversationDetails = async ( req, res ) => {
+  try {
+    const { conversationId } = req.params;
+    const { storeId } = req.body;
+
+    if ( !conversationId || !storeId ) {
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: 'Missing required parameters',
+        code: 'MISSING_PARAMETERS',
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    logger.info( `Fetching conversation ${conversationId}` );
+
+    return res.status( 200 ).json( {
+      status: 'success',
+      data: 'sampleConversationData',
+      timestamp: new Date().toISOString(),
+    } );
+  } catch ( error ) {
+    logger.error( `Error fetching conversation: ${error.message}` );
+    return res.status( 500 ).json( {
+      status: 'error',
+      message: 'Internal server error',
+      code: 'INTERNAL_ERROR',
+      timestamp: new Date().toISOString(),
+    } );
+  }
+};
+