agrs-sequelize-sdk 1.4.11 → 1.4.13

package/models/SyncHistory.js

@@ -1,250 +1,250 @@
-// models/SyncHistory.js
-module.exports = (sequelize, DataTypes) => {
-    const SyncHistory = sequelize.define(
-      "SyncHistory",
-      {
-        id: {
-          type: DataTypes.INTEGER,
-          primaryKey: true,
-          autoIncrement: true,
-        },
-        syncId: {
-          type: DataTypes.STRING,
-          allowNull: false,
-          unique: true,
-          comment: "Unique identifier for the sync operation"
-        },
-        syncType: {
-          type: DataTypes.ENUM('manual', 'quick_sync', 'group_sync', 'preset_sync', 'scheduled'),
-          allowNull: false,
-          defaultValue: 'manual',
-          comment: "Type of sync operation performed"
-        },
-        initiatedBy: {
-          type: DataTypes.STRING,
-          allowNull: true,
-          comment: "User who initiated the sync (username or user ID)"
-        },
-        startTime: {
-          type: DataTypes.DATE,
-          allowNull: false,
-          comment: "When the sync operation started"
-        },
-        endTime: {
-          type: DataTypes.DATE,
-          allowNull: true,
-          comment: "When the sync operation completed"
-        },
-        duration: {
-          type: DataTypes.INTEGER,
-          allowNull: true,
-          comment: "Duration in milliseconds"
-        },
-        status: {
-          type: DataTypes.ENUM('running', 'completed', 'failed', 'cancelled'),
-          allowNull: false,
-          defaultValue: 'running',
-          comment: "Current status of the sync operation"
-        },
-        success: {
-          type: DataTypes.BOOLEAN,
-          allowNull: true,
-          comment: "Whether the sync completed successfully"
-        },
-        totalTables: {
-          type: DataTypes.INTEGER,
-          allowNull: false,
-          defaultValue: 0,
-          comment: "Total number of tables in the sync"
-        },
-        successfulTables: {
-          type: DataTypes.INTEGER,
-          allowNull: false,
-          defaultValue: 0,
-          comment: "Number of tables synced successfully"
-        },
-        failedTables: {
-          type: DataTypes.INTEGER,
-          allowNull: false,
-          defaultValue: 0,
-          comment: "Number of tables that failed to sync"
-        },
-        totalRecords: {
-          type: DataTypes.INTEGER,
-          allowNull: false,
-          defaultValue: 0,
-          comment: "Total number of records synced"
-        },
-        tablesIncluded: {
-          type: DataTypes.ARRAY(DataTypes.STRING),
-          allowNull: false,
-          defaultValue: [],
-          comment: "List of tables included in this sync"
-        },
-        syncOptions: {
-          type: DataTypes.JSONB,
-          allowNull: true,
-          comment: "Sync options used (truncateFirst, batchSize, etc.)"
-        },
-        errorCount: {
-          type: DataTypes.INTEGER,
-          allowNull: false,
-          defaultValue: 0,
-          comment: "Number of errors encountered"
-        },
-        errorSummary: {
-          type: DataTypes.TEXT,
-          allowNull: true,
-          comment: "Brief summary of errors encountered"
-        },
-        detailedResults: {
-          type: DataTypes.JSONB,
-          allowNull: true,
-          comment: "Detailed results for each table (success/failure, record counts, errors)"
-        },
-        safetyChecks: {
-          type: DataTypes.JSONB,
-          allowNull: true,
-          comment: "Safety check results (hosts, direction, etc.)"
-        },
-        sourceHost: {
-          type: DataTypes.STRING,
-          allowNull: true,
-          comment: "Production database host"
-        },
-        targetHost: {
-          type: DataTypes.STRING,
-          allowNull: true,
-          comment: "Staging database host"
-        },
-        environment: {
-          type: DataTypes.STRING,
-          allowNull: true,
-          comment: "Environment where sync was executed (development, staging, production)"
-        },
-        groupsOrPreset: {
-          type: DataTypes.STRING,
-          allowNull: true,
-          comment: "If this was a group/preset sync, which one was used"
-        }
-      },
-      {
-        tableName: "SyncHistory",
-        timestamps: true, // Adds createdAt and updatedAt
-        indexes: [
-          {
-            fields: ["syncId"],
-            unique: true
-          },
-          {
-            fields: ["startTime"],
-            name: "idx_sync_history_start_time"
-          },
-          {
-            fields: ["status"],
-            name: "idx_sync_history_status"
-          },
-          {
-            fields: ["success"],
-            name: "idx_sync_history_success"
-          },
-          {
-            fields: ["syncType"],
-            name: "idx_sync_history_type"
-          },
-          {
-            fields: ["initiatedBy"],
-            name: "idx_sync_history_user"
-          },
-          {
-            fields: ["createdAt"],
-            name: "idx_sync_history_created"
-          }
-        ]
-      }
-    );
-  
-    // Add model methods
-    SyncHistory.prototype.getDurationInSeconds = function() {
-      return this.duration ? (this.duration / 1000).toFixed(1) : null;
-    };
-  
-    SyncHistory.prototype.getSuccessRate = function() {
-      if (this.totalTables === 0) return 0;
-      return ((this.successfulTables / this.totalTables) * 100).toFixed(1);
-    };
-  
-    SyncHistory.prototype.isRunning = function() {
-      return this.status === 'running';
-    };
-  
-    SyncHistory.prototype.hasErrors = function() {
-      return this.errorCount > 0;
-    };
-  
-    // Static methods for common queries
-    SyncHistory.getRecentHistory = async function(limit = 10) {
-      return await this.findAll({
-        order: [['startTime', 'DESC']],
-        limit: limit
-      });
-    };
-  
-    SyncHistory.getRunningsyncs = async function() {
-      return await this.findAll({
-        where: { status: 'running' },
-        order: [['startTime', 'DESC']]
-      });
-    };
-  
-    SyncHistory.getSuccessfulSyncs = async function(limit = 10) {
-      return await this.findAll({
-        where: { success: true },
-        order: [['startTime', 'DESC']],
-        limit: limit
-      });
-    };
-  
-    SyncHistory.getFailedSyncs = async function(limit = 10) {
-      return await this.findAll({
-        where: { success: false },
-        order: [['startTime', 'DESC']],
-        limit: limit
-      });
-    };
-  
-    SyncHistory.getSyncStats = async function() {
-      const total = await this.count();
-      const successful = await this.count({ where: { success: true } });
-      const failed = await this.count({ where: { success: false } });
-      const running = await this.count({ where: { status: 'running' } });
-  
-      const avgDuration = await this.findOne({
-        attributes: [
-          [sequelize.fn('AVG', sequelize.col('duration')), 'avgDuration']
-        ],
-        where: { success: true },
-        raw: true
-      });
-  
-      const totalRecords = await this.findOne({
-        attributes: [
-          [sequelize.fn('SUM', sequelize.col('totalRecords')), 'totalRecords']
-        ],
-        where: { success: true },
-        raw: true
-      });
-  
-      return {
-        totalSyncs: total,
-        successfulSyncs: successful,
-        failedSyncs: failed,
-        runningSyncs: running,
-        successRate: total > 0 ? ((successful / total) * 100).toFixed(1) : 0,
-        averageDuration: avgDuration?.avgDuration ? Math.round(avgDuration.avgDuration) : null,
-        totalRecordsSynced: totalRecords?.totalRecords || 0
-      };
-    };
-  
-    return SyncHistory;
+// models/SyncHistory.js
+module.exports = (sequelize, DataTypes) => {
+    const SyncHistory = sequelize.define(
+      "SyncHistory",
+      {
+        id: {
+          type: DataTypes.INTEGER,
+          primaryKey: true,
+          autoIncrement: true,
+        },
+        syncId: {
+          type: DataTypes.STRING,
+          allowNull: false,
+          unique: true,
+          comment: "Unique identifier for the sync operation"
+        },
+        syncType: {
+          type: DataTypes.ENUM('manual', 'quick_sync', 'group_sync', 'preset_sync', 'scheduled'),
+          allowNull: false,
+          defaultValue: 'manual',
+          comment: "Type of sync operation performed"
+        },
+        initiatedBy: {
+          type: DataTypes.STRING,
+          allowNull: true,
+          comment: "User who initiated the sync (username or user ID)"
+        },
+        startTime: {
+          type: DataTypes.DATE,
+          allowNull: false,
+          comment: "When the sync operation started"
+        },
+        endTime: {
+          type: DataTypes.DATE,
+          allowNull: true,
+          comment: "When the sync operation completed"
+        },
+        duration: {
+          type: DataTypes.INTEGER,
+          allowNull: true,
+          comment: "Duration in milliseconds"
+        },
+        status: {
+          type: DataTypes.ENUM('running', 'completed', 'failed', 'cancelled'),
+          allowNull: false,
+          defaultValue: 'running',
+          comment: "Current status of the sync operation"
+        },
+        success: {
+          type: DataTypes.BOOLEAN,
+          allowNull: true,
+          comment: "Whether the sync completed successfully"
+        },
+        totalTables: {
+          type: DataTypes.INTEGER,
+          allowNull: false,
+          defaultValue: 0,
+          comment: "Total number of tables in the sync"
+        },
+        successfulTables: {
+          type: DataTypes.INTEGER,
+          allowNull: false,
+          defaultValue: 0,
+          comment: "Number of tables synced successfully"
+        },
+        failedTables: {
+          type: DataTypes.INTEGER,
+          allowNull: false,
+          defaultValue: 0,
+          comment: "Number of tables that failed to sync"
+        },
+        totalRecords: {
+          type: DataTypes.INTEGER,
+          allowNull: false,
+          defaultValue: 0,
+          comment: "Total number of records synced"
+        },
+        tablesIncluded: {
+          type: DataTypes.ARRAY(DataTypes.STRING),
+          allowNull: false,
+          defaultValue: [],
+          comment: "List of tables included in this sync"
+        },
+        syncOptions: {
+          type: DataTypes.JSONB,
+          allowNull: true,
+          comment: "Sync options used (truncateFirst, batchSize, etc.)"
+        },
+        errorCount: {
+          type: DataTypes.INTEGER,
+          allowNull: false,
+          defaultValue: 0,
+          comment: "Number of errors encountered"
+        },
+        errorSummary: {
+          type: DataTypes.TEXT,
+          allowNull: true,
+          comment: "Brief summary of errors encountered"
+        },
+        detailedResults: {
+          type: DataTypes.JSONB,
+          allowNull: true,
+          comment: "Detailed results for each table (success/failure, record counts, errors)"
+        },
+        safetyChecks: {
+          type: DataTypes.JSONB,
+          allowNull: true,
+          comment: "Safety check results (hosts, direction, etc.)"
+        },
+        sourceHost: {
+          type: DataTypes.STRING,
+          allowNull: true,
+          comment: "Production database host"
+        },
+        targetHost: {
+          type: DataTypes.STRING,
+          allowNull: true,
+          comment: "Staging database host"
+        },
+        environment: {
+          type: DataTypes.STRING,
+          allowNull: true,
+          comment: "Environment where sync was executed (development, staging, production)"
+        },
+        groupsOrPreset: {
+          type: DataTypes.STRING,
+          allowNull: true,
+          comment: "If this was a group/preset sync, which one was used"
+        }
+      },
+      {
+        tableName: "SyncHistory",
+        timestamps: true, // Adds createdAt and updatedAt
+        indexes: [
+          {
+            fields: ["syncId"],
+            unique: true
+          },
+          {
+            fields: ["startTime"],
+            name: "idx_sync_history_start_time"
+          },
+          {
+            fields: ["status"],
+            name: "idx_sync_history_status"
+          },
+          {
+            fields: ["success"],
+            name: "idx_sync_history_success"
+          },
+          {
+            fields: ["syncType"],
+            name: "idx_sync_history_type"
+          },
+          {
+            fields: ["initiatedBy"],
+            name: "idx_sync_history_user"
+          },
+          {
+            fields: ["createdAt"],
+            name: "idx_sync_history_created"
+          }
+        ]
+      }
+    );
+  
+    // Add model methods
+    SyncHistory.prototype.getDurationInSeconds = function() {
+      return this.duration ? (this.duration / 1000).toFixed(1) : null;
+    };
+  
+    SyncHistory.prototype.getSuccessRate = function() {
+      if (this.totalTables === 0) return 0;
+      return ((this.successfulTables / this.totalTables) * 100).toFixed(1);
+    };
+  
+    SyncHistory.prototype.isRunning = function() {
+      return this.status === 'running';
+    };
+  
+    SyncHistory.prototype.hasErrors = function() {
+      return this.errorCount > 0;
+    };
+  
+    // Static methods for common queries
+    SyncHistory.getRecentHistory = async function(limit = 10) {
+      return await this.findAll({
+        order: [['startTime', 'DESC']],
+        limit: limit
+      });
+    };
+  
+    SyncHistory.getRunningsyncs = async function() {
+      return await this.findAll({
+        where: { status: 'running' },
+        order: [['startTime', 'DESC']]
+      });
+    };
+  
+    SyncHistory.getSuccessfulSyncs = async function(limit = 10) {
+      return await this.findAll({
+        where: { success: true },
+        order: [['startTime', 'DESC']],
+        limit: limit
+      });
+    };
+  
+    SyncHistory.getFailedSyncs = async function(limit = 10) {
+      return await this.findAll({
+        where: { success: false },
+        order: [['startTime', 'DESC']],
+        limit: limit
+      });
+    };
+  
+    SyncHistory.getSyncStats = async function() {
+      const total = await this.count();
+      const successful = await this.count({ where: { success: true } });
+      const failed = await this.count({ where: { success: false } });
+      const running = await this.count({ where: { status: 'running' } });
+  
+      const avgDuration = await this.findOne({
+        attributes: [
+          [sequelize.fn('AVG', sequelize.col('duration')), 'avgDuration']
+        ],
+        where: { success: true },
+        raw: true
+      });
+  
+      const totalRecords = await this.findOne({
+        attributes: [
+          [sequelize.fn('SUM', sequelize.col('totalRecords')), 'totalRecords']
+        ],
+        where: { success: true },
+        raw: true
+      });
+  
+      return {
+        totalSyncs: total,
+        successfulSyncs: successful,
+        failedSyncs: failed,
+        runningSyncs: running,
+        successRate: total > 0 ? ((successful / total) * 100).toFixed(1) : 0,
+        averageDuration: avgDuration?.avgDuration ? Math.round(avgDuration.avgDuration) : null,
+        totalRecordsSynced: totalRecords?.totalRecords || 0
+      };
+    };
+  
+    return SyncHistory;
   };

package/models/TTQChannel.js

@@ -1,42 +1,42 @@
-module.exports = (sequelize, DataTypes) => {
-  const TTQChannel = sequelize.define(
-    "TTQChannel",
-    {
-      channelId: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        unique: true,
-      },
-      status: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        defaultValue: "free",
-        validate: {
-          isIn: [["free", "used", "archived"]],
-        },
-      },
-      connectedCampaigns: {
-        type: DataTypes.JSONB,
-        allowNull: false,
-        defaultValue: [],
-      },
-    },
-    {
-      tableName: "ttq_rsoc_channels",
-      timestamps: true,
-    }
-  );
-
-  TTQChannel.associate = (models) => {
-    if (models.RSOCFeedCampaign) {
-      TTQChannel.hasMany(models.RSOCFeedCampaign, {
-        foreignKey: "channelId",
-        sourceKey: "channelId",
-        as: "RSOCFeedCampaigns",
-        constraints: false,
-      });
-    }
-  };
-
-  return TTQChannel;
-};
+module.exports = (sequelize, DataTypes) => {
+  const TTQChannel = sequelize.define(
+    "TTQChannel",
+    {
+      channelId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true,
+      },
+      status: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        defaultValue: "free",
+        validate: {
+          isIn: [["free", "used", "archived"]],
+        },
+      },
+      connectedCampaigns: {
+        type: DataTypes.JSONB,
+        allowNull: false,
+        defaultValue: [],
+      },
+    },
+    {
+      tableName: "ttq_rsoc_channels",
+      timestamps: true,
+    }
+  );
+
+  TTQChannel.associate = (models) => {
+    if (models.RSOCFeedCampaign) {
+      TTQChannel.hasMany(models.RSOCFeedCampaign, {
+        foreignKey: "channelId",
+        sourceKey: "channelId",
+        as: "RSOCFeedCampaigns",
+        constraints: false,
+      });
+    }
+  };
+
+  return TTQChannel;
+};