@dhyasama/totem-models 11.113.0 → 11.115.0

package/lib/Financials.js

@@ -61,7 +61,7 @@ module.exports = function(mongoose, config) {
         month: { type: Number, default: 12 },
         day: { type: Number, default: 31 },
       },
-      review: { type: Boolean, default: false },
+      approval: { type: Boolean, default: false },
 
       // For reminding customer about upcoming collections
       // Don't store recipients, just query admins at time of sending or check postmark post-facto
@@ -78,9 +78,9 @@ module.exports = function(mongoose, config) {
 
       currency: { type: String, default: 'USD' },
 
-      review: { type: Boolean, default: false },
+      approval:{ type: Boolean, default: false },
 
-      status: { type: String, enum: ['Created', 'Scheduled', 'Delivered', 'Opened', 'Overdue', 'In Review', 'Completed', 'Archived'] },
+      status: { type: String, enum: ['Created', 'Scheduled', 'Delivered', 'Opened', 'Delayed', 'Unapproved', 'Completed', 'Archived'] },
 
       year: { type: Number, default: 0 },
       period: { type: String, enum: ['FY', 'H1', 'H2', 'Q1', 'Q2', 'Q3', 'Q4', 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'] },
@@ -97,21 +97,49 @@ module.exports = function(mongoose, config) {
         _id: false,
         name: { type: String, trim: true },
         document: { type: Schema.ObjectId, ref: 'Document' },
+        verified: { type: Boolean, default: false },
+        history: [{
+          timestamp: { type: Date, required: true, default: Date.now },
+          user: { type: String, trim: true, required: true },
+          description: { type: String, trim: true, required: true }
+        }]
       }],
 
       metrics: [{
         _id: false,
         name: { type: String, trim: true },
-        actual: { type: Number },
-        budget: { type: Number },
-        forecast: { type: Number },
-        breakdown: { type: Schema.Types.Mixed }
+        scenario: { type: String, enum: ['actual', 'budget', 'forecast'] },
+        value: { type: Number },
+        breakdown: { type: Schema.Types.Mixed },
+        source: {
+          _id: false,
+          model: {
+            type: String,
+            enum: ['Document', 'Meeting', 'Message', 'Note']
+          },
+          ref: {
+            type: Schema.Types.ObjectId,
+            refPath: 'metrics.source.model',
+          },
+        },
+        verified: { type: Boolean, default: false },
+        history: [{
+          timestamp: { type: Date, required: true, default: Date.now },
+          user: { type: String, trim: true, required: true },
+          description: { type: String, trim: true, required: true }
+        }]
       }],
       
       questions: [{
         _id: false,
         prompt: { type: String, trim: true },
         response: { type: String, trim: true },
+        verified: { type: Boolean, default: false },
+        history: [{
+          timestamp: { type: Date, required: true, default: Date.now },
+          user: { type: String, trim: true, required: true },
+          description: { type: String, trim: true, required: true }
+        }]
       }],
 
       dueOn: { type: Date, index: false },
@@ -927,14 +955,14 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Financials.statics.getPassivelyOverdue = function getPassivelyOverdue(cb) {
+  Financials.statics.getOverdue = function getOverdue(cb) {
 
     const self = this;
 
     const query = self.find({
       'snapshots': {
         $elemMatch: {
-          'status': { $nin: ['Completed', 'Archived', 'Overdue'] },
+          'status': { $nin: ['Completed', 'Archived', 'Delayed'] },
           'dueOn': { $lte: new Date() }
         }
       }
@@ -944,14 +972,6 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Financials.statics.markAsOverdue = function markAsOverdue(financials, cb) {
-
-    if (!financials) { return cb(new Error('financials is required'), null); }
-
-    financials.save(cb);
-
-  };
-
   Financials.statics.updateProperty = function updateProperty(id, key, value, cb) {
 
     const self = this;
@@ -1000,12 +1020,12 @@ module.exports = function(mongoose, config) {
 
       if (!snapshot) return;
 
-      var needsReview = snapshot.review;
+      var needsApproval = snapshot.approval;
       var isSubmitted = snapshot.submittedOn;
       var isApproved = snapshot.approvedOn;
       var isRejected = snapshot.rejectedOn && snapshot.rejection;
       var isArchived = snapshot.archivedOn;
-      var isOverdue = snapshot.dueOn ? moment(new Date()).isAfter(moment(snapshot.dueOn)) : false;
+      var isDelayed = snapshot.dueOn ? moment(new Date()).isAfter(moment(snapshot.dueOn)) : false;
 
       var isOpened = false;
       var isDelivered = false;
@@ -1017,12 +1037,12 @@ module.exports = function(mongoose, config) {
       }
 
       if(!snapshot.uuid) snapshot.status = 'Completed'; // no uuid means the snapshot was created from the google sheet and should always be completed
-      else if(needsReview && isApproved) snapshot.status = 'Completed';
-      else if(!needsReview && isSubmitted) snapshot.status = 'Completed';
+      else if(needsApproval && isApproved) snapshot.status = 'Completed';
+      else if(!needsApproval && isSubmitted) snapshot.status = 'Completed';
       else if(isArchived) snapshot.status = 'Archived';
-      else if(needsReview && isSubmitted && !isRejected) snapshot.status = 'In Review';
-      else if(needsReview && isSubmitted && isRejected) snapshot.status = 'Opened';
-      else if(isOverdue) snapshot.status = 'Overdue';
+      else if(needsApproval && isSubmitted && !isRejected) snapshot.status = 'Unapproved';
+      else if(needsApproval && isSubmitted && isRejected) snapshot.status = 'Opened';
+      else if(isDelayed) snapshot.status = 'Delayed';
       else if(isDelivered && isOpened) snapshot.status = 'Opened';
       else if(isDelivered) snapshot.status = 'Delivered';
       else if(isScheduled) snapshot.status = 'Scheduled'; // when a snapshot is scheduled, but not yet sent (checks every 5 minutes)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhyasama/totem-models",
-  "version": "11.113.0",
+  "version": "11.115.0",
   "author": "Jason Reynolds",
   "license": "UNLICENSED",
   "description": "Models for Totem platform",

package/scripts/migrate-financials-schema.js

@@ -0,0 +1,279 @@
+'use strict';
+
+/**
+ * Migration script for Financials model schema changes
+ *
+ * Changes being migrated:
+ * 1. Rename field: review → approval (in recurring and snapshots)
+ * 2. Update status enum values in snapshots:
+ *    - 'Overdue' → 'Delayed'
+ *    - 'In Review' → 'Unapproved'
+ * 3. Add verified: true to all existing documents[], metrics[], questions[]
+ * 4. Convert metrics from actual/budget/forecast fields to scenario/value structure
+ *
+ * Usage:
+ *   node scripts/migrate-financials-schema.js <customerId> [--config <configPath>] [--dry-run]
+ *   node scripts/migrate-financials-schema.js <customerId> [--db-uri <mongoUri>] [--dry-run]
+ *
+ * Examples:
+ *   # Use totem-web production config
+ *   NODE_ENV=production node scripts/migrate-financials-schema.js 5cdc3340e67922775af918ca --config ../totem-web/config/config.js --dry-run
+ *
+ *   # Use DB_URI environment variable
+ *   DB_URI="mongodb://..." node scripts/migrate-financials-schema.js 5cdc3340e67922775af918ca --dry-run
+ */
+
+const mongoose = require('mongoose');
+const path = require('path');
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const CUSTOMER_ID = args[0];
+const DRY_RUN = args.includes('--dry-run');
+
+// Get config path or db uri
+let configPath = null;
+let dbUri = null;
+
+const configIndex = args.indexOf('--config');
+if (configIndex !== -1 && args[configIndex + 1]) {
+  configPath = path.resolve(args[configIndex + 1]);
+}
+
+const dbUriIndex = args.indexOf('--db-uri');
+if (dbUriIndex !== -1 && args[dbUriIndex + 1]) {
+  dbUri = args[dbUriIndex + 1];
+}
+
+// Check for DB_URI environment variable
+if (!dbUri && process.env.DB_URI) {
+  dbUri = process.env.DB_URI;
+}
+
+// Validate arguments
+if (!CUSTOMER_ID || CUSTOMER_ID.startsWith('--')) {
+  console.error('Error: Customer ID is required');
+  console.error('Usage: node scripts/migrate-financials-schema.js <customerId> [--config <configPath>] [--db-uri <mongoUri>] [--dry-run]');
+  process.exit(1);
+}
+
+if (!configPath && !dbUri) {
+  console.error('Error: Either --config, --db-uri, or DB_URI environment variable is required');
+  console.error('Usage: node scripts/migrate-financials-schema.js <customerId> [--config <configPath>] [--db-uri <mongoUri>] [--dry-run]');
+  process.exit(1);
+}
+
+// Load config if provided
+if (configPath) {
+  console.log(`Loading config from: ${configPath}`);
+  const config = require(configPath);
+  dbUri = config.db.uri;
+}
+
+console.log('Migration Configuration:');
+console.log('  Customer ID:', CUSTOMER_ID);
+console.log('  Database URI:', dbUri.replace(/\/\/[^:]+:[^@]+@/, '//*****:*****@')); // Mask credentials
+console.log('  Dry Run:', DRY_RUN);
+console.log('');
+
+// Connect to MongoDB
+const mongooseOptions = {
+  useNewUrlParser: true,
+  useUnifiedTopology: true
+};
+
+mongoose.connect(dbUri, mongooseOptions);
+
+const db = mongoose.connection;
+
+db.on('error', (err) => {
+  console.error('MongoDB connection error:', err);
+  process.exit(1);
+});
+
+db.once('open', async () => {
+  console.log('Connected to MongoDB');
+
+  try {
+    await migrateFinancials();
+    console.log('\nMigration completed successfully!');
+    process.exit(0);
+  } catch (err) {
+    console.error('\nMigration failed:', err);
+    process.exit(1);
+  }
+});
+
+async function migrateFinancials() {
+  const Financials = db.collection('financials');
+
+  // Find all financials for this customer
+  const query = { customer: mongoose.Types.ObjectId(CUSTOMER_ID) };
+  const financials = await Financials.find(query).toArray();
+
+  console.log(`Found ${financials.length} financial document(s) for customer ${CUSTOMER_ID}\n`);
+
+  if (financials.length === 0) {
+    console.log('No documents to migrate.');
+    return;
+  }
+
+  let migratedCount = 0;
+  let unchangedCount = 0;
+
+  for (const financial of financials) {
+    const updates = {};
+    const changes = [];
+
+    // 1. Migrate recurring.review → recurring.approval
+    if (financial.recurring && 'review' in financial.recurring) {
+      updates['recurring.approval'] = financial.recurring.review;
+      updates.$unset = updates.$unset || {};
+      updates.$unset['recurring.review'] = '';
+      changes.push('  - Renamed recurring.review → recurring.approval');
+    }
+
+    // 2. Migrate snapshots
+    if (financial.snapshots && financial.snapshots.length > 0) {
+      financial.snapshots.forEach((snapshot, index) => {
+
+        // 2a. Rename snapshot.review → snapshot.approval
+        if ('review' in snapshot) {
+          updates[`snapshots.${index}.approval`] = snapshot.review;
+          updates.$unset = updates.$unset || {};
+          updates.$unset[`snapshots.${index}.review`] = '';
+          changes.push(`  - Snapshot ${index}: Renamed review → approval`);
+        }
+
+        // 2b. Update status enum values
+        if (snapshot.status === 'Overdue') {
+          updates[`snapshots.${index}.status`] = 'Delayed';
+          changes.push(`  - Snapshot ${index}: Changed status 'Overdue' → 'Delayed'`);
+        } else if (snapshot.status === 'In Review') {
+          updates[`snapshots.${index}.status`] = 'Unapproved';
+          changes.push(`  - Snapshot ${index}: Changed status 'In Review' → 'Unapproved'`);
+        }
+
+        // 2c. Add verified: true to documents
+        if (snapshot.documents && snapshot.documents.length > 0) {
+          snapshot.documents.forEach((doc, docIndex) => {
+            if (!('verified' in doc)) {
+              updates[`snapshots.${index}.documents.${docIndex}.verified`] = true;
+              changes.push(`  - Snapshot ${index}: Added verified to document ${docIndex}`);
+            }
+          });
+        }
+
+        // 2d. Add verified: true to questions
+        if (snapshot.questions && snapshot.questions.length > 0) {
+          snapshot.questions.forEach((question, qIndex) => {
+            if (!('verified' in question)) {
+              updates[`snapshots.${index}.questions.${qIndex}.verified`] = true;
+              changes.push(`  - Snapshot ${index}: Added verified to question ${qIndex}`);
+            }
+          });
+        }
+
+        // 2e. Migrate metrics structure and add verified
+        if (snapshot.metrics && snapshot.metrics.length > 0) {
+          const oldMetrics = [...snapshot.metrics];
+          const newMetrics = [];
+
+          // Check if metrics need conversion from old structure
+          const needsConversion = oldMetrics.some(m =>
+            ('actual' in m || 'budget' in m || 'forecast' in m) && !('scenario' in m)
+          );
+
+          if (needsConversion) {
+            // Convert old structure (actual/budget/forecast) to new structure (scenario/value)
+            oldMetrics.forEach((metric) => {
+              // Create separate metric entries for each scenario
+              if ('actual' in metric && metric.actual !== undefined && metric.actual !== null) {
+                newMetrics.push({
+                  name: metric.name,
+                  scenario: 'actual',
+                  value: metric.actual,
+                  breakdown: metric.breakdown,
+                  verified: true
+                });
+              }
+
+              if ('budget' in metric && metric.budget !== undefined && metric.budget !== null) {
+                newMetrics.push({
+                  name: metric.name,
+                  scenario: 'budget',
+                  value: metric.budget,
+                  breakdown: metric.breakdown,
+                  verified: true
+                });
+              }
+
+              if ('forecast' in metric && metric.forecast !== undefined && metric.forecast !== null) {
+                newMetrics.push({
+                  name: metric.name,
+                  scenario: 'forecast',
+                  value: metric.forecast,
+                  breakdown: metric.breakdown,
+                  verified: true
+                });
+              }
+            });
+
+            updates[`snapshots.${index}.metrics`] = newMetrics;
+            changes.push(`  - Snapshot ${index}: Converted ${oldMetrics.length} metric(s) to new structure (${newMetrics.length} entries)`);
+          } else {
+            // Already in new structure, just add verified if missing
+            oldMetrics.forEach((metric, mIndex) => {
+              if (!('verified' in metric)) {
+                updates[`snapshots.${index}.metrics.${mIndex}.verified`] = true;
+                changes.push(`  - Snapshot ${index}: Added verified to metric ${mIndex}`);
+              }
+            });
+          }
+        }
+      });
+    }
+
+    // Apply updates
+    if (Object.keys(updates).length > 0 && !DRY_RUN) {
+      const updateDoc = {};
+
+      // Separate $set and $unset operations
+      if (updates.$unset) {
+        updateDoc.$unset = updates.$unset;
+        delete updates.$unset;
+      }
+
+      if (Object.keys(updates).length > 0) {
+        updateDoc.$set = updates;
+      }
+
+      await Financials.updateOne(
+        { _id: financial._id },
+        updateDoc
+      );
+
+      console.log(`Migrated financial ${financial._id}:`);
+      changes.forEach(change => console.log(change));
+      console.log('');
+      migratedCount++;
+    } else if (Object.keys(updates).length > 0 && DRY_RUN) {
+      console.log(`[DRY RUN] Would migrate financial ${financial._id}:`);
+      changes.forEach(change => console.log(change));
+      console.log('');
+      migratedCount++;
+    } else {
+      unchangedCount++;
+    }
+  }
+
+  console.log('\n=== Migration Summary ===');
+  console.log(`Documents migrated: ${migratedCount}`);
+  console.log(`Documents unchanged: ${unchangedCount}`);
+  console.log(`Total documents: ${financials.length}`);
+
+  if (DRY_RUN) {
+    console.log('\nThis was a dry run. No changes were made to the database.');
+    console.log('Run without --dry-run to apply changes.');
+  }
+}