agrs-sequelize-sdk 1.4.22 → 1.4.24

package/.worktrees/aicampaign-queue-group-id/models/Folders.js

@@ -0,0 +1,133 @@
+module.exports = (sequelize, DataTypes) => {
+  const Folders = sequelize.define("Folders", {
+    id: {
+      type: DataTypes.STRING,
+      primaryKey: true,
+    },
+    ParentFolder: {
+      type: DataTypes.STRING, // Self-referencing folder ID
+      allowNull: true,
+    },
+    ParentFolders: {
+      type: DataTypes.ARRAY(DataTypes.STRING), // Array of folder IDs
+      allowNull: true,
+    },
+    name: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    FilesCount: {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+      defaultValue: 0,
+    }
+  });
+
+  Folders.associate = function (models) {
+    // One-to-many: A folder can have many files
+    Folders.hasMany(models.Files, { foreignKey: "ParentFolder", sourceKey: "id" });
+
+    // Self-referencing: A folder can have subfolders
+    Folders.hasMany(models.Folders, { foreignKey: "ParentFolder", sourceKey: "id" });
+    Folders.belongsTo(models.Folders, { foreignKey: "ParentFolder", targetKey: "id" });
+  };
+
+  // Function to count files and subfolders for each parent folder in ParentFolders array
+  Folders.countFilesAndSubfolders = async function (parentFolderIds) {
+    try {
+      const { Files } = sequelize.models; // Move the reference inside the function
+      
+      // Loop through each parent folder ID
+      for (const parentFolderId of parentFolderIds) {
+        // Find the parent folder by ID
+        const parentFolder = await Folders.findOne({ where: { id: parentFolderId } });
+
+        if (!parentFolder) {
+          console.warn(`Folder with ID ${parentFolderId} not found.`);
+          continue;
+        }
+
+        // Count the number of files directly under this folder
+        const fileCount = await Files.count({
+          where: { ParentFolder: parentFolder.id }
+        });
+
+        // Count the number of subfolders directly under this folder
+        const subfolderCount = await Folders.count({
+          where: { ParentFolder: parentFolder.id }
+        });
+
+        // Total count is files + subfolders
+        const totalFilesCount = fileCount + subfolderCount;
+
+        // Update the FilesCount field in the parent folder
+        await parentFolder.update({ FilesCount: totalFilesCount });
+      }
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+  };
+
+  // Add a hook that triggers after a folder is created, updated, or deleted
+  Folders.addHook('afterCreate', async (folder, options) => {
+    if (folder.ParentFolders && folder.ParentFolders.length > 0) {
+      await Folders.countFilesAndSubfolders(folder.ParentFolders);
+    }
+  });
+
+  Folders.addHook('afterDestroy', async (folder, options) => {
+    if (folder.ParentFolders && folder.ParentFolders.length > 0) {
+      await Folders.countFilesAndSubfolders(folder.ParentFolders);
+    }
+  });
+
+  Folders.addHook('afterUpdate', async (folder, options) => {
+    if (folder.ParentFolders && folder.ParentFolders.length > 0) {
+      await Folders.countFilesAndSubfolders(folder.ParentFolders);
+    }
+  });
+
+  // Add hooks for Files
+  sequelize.models.Files.addHook('afterCreate', async (file, options) => {
+    if (file.ParentFolders && file.ParentFolders.length > 0) {
+      await Folders.countFilesAndSubfolders(file.ParentFolders);
+    } else if (file.ParentFolder) {
+      await Folders.countFilesAndSubfolders([file.ParentFolder]);
+    }
+  });
+
+  sequelize.models.Files.addHook('afterDestroy', async (file, options) => {
+    if (file.ParentFolders && file.ParentFolders.length > 0) {
+      await Folders.countFilesAndSubfolders(file.ParentFolders);
+    } else if (file.ParentFolder) {
+      await Folders.countFilesAndSubfolders([file.ParentFolder]);
+    }
+  });
+
+  sequelize.models.Files.addHook('afterUpdate', async (file, options) => {
+    if (file.ParentFolders && file.ParentFolders.length > 0) {
+      await Folders.countFilesAndSubfolders(file.ParentFolders);
+    } else if (file.ParentFolder) {
+      await Folders.countFilesAndSubfolders([file.ParentFolder]);
+    }
+  });
+
+    // Add a hook before saving the folder to check ParentFolders
+  Folders.addHook('beforeSave', (folder, options) => {
+    // If ParentFolders is an empty array or contains only nulls, set it to null
+    if (folder.ParentFolders && (folder.ParentFolders.length === 0 || folder.ParentFolders.every(f => f === null))) {
+      folder.ParentFolders = null;
+    }
+  });
+
+  // You can also add this hook for files
+  sequelize.models.Files.addHook('beforeSave', (file, options) => {
+    // If ParentFolders is an empty array or contains only nulls, set it to null
+    if (file.ParentFolders && (file.ParentFolders.length === 0 || file.ParentFolders.every(f => f === null))) {
+      file.ParentFolders = null;
+    }
+  });
+
+  return Folders;
+};

package/.worktrees/aicampaign-queue-group-id/models/FrontStoryChannel.js

@@ -0,0 +1,60 @@
+module.exports = (sequelize, DataTypes) => {
+    const FrontStoryChannel = sequelize.define(
+      "FrontStoryChannel",
+      {
+        channelId: {
+          type: DataTypes.STRING,
+          allowNull: false,
+          // Not setting as primary key or unique since duplicates are allowed
+        },
+        channelName: {
+          type: DataTypes.STRING,
+          allowNull: true,
+          comment: 'Human-readable name for the channel'
+        },
+        styleId: {
+          type: DataTypes.STRING,
+          allowNull: false,
+        },
+        status: {
+          type: DataTypes.STRING,
+          allowNull: false,
+          defaultValue: "free",
+          validate: {
+            isIn: [["free", "used", "archived"]],
+          },
+        },
+        connectedCampaigns: {
+          type: DataTypes.JSONB, // Use JSONB for better querying capabilities
+          allowNull: false,
+          defaultValue: [],
+        },
+      },
+      {
+        tableName: "front_story_channels",
+        timestamps: true,
+        // indexes: [
+        //   // Add a composite unique index on channelId and styleId if needed
+        //   {
+        //     unique: true,
+        //     fields: ["channelId", "styleId"],
+        //     name: "unique_front_story_channel_style",
+        //   },
+        // ],
+      }
+    );
+  
+    // Define associations without enforcing constraints
+    FrontStoryChannel.associate = (models) => {
+      if (models.RSOCFeedCampaign) {
+        FrontStoryChannel.hasMany(models.RSOCFeedCampaign, {
+          foreignKey: "channelId",
+          sourceKey: "channelId",
+          as: "RSOCFeedCampaigns",
+          constraints: false, // Disable FK constraint
+        });
+      }
+    };
+  
+    return FrontStoryChannel;
+  };

package/.worktrees/aicampaign-queue-group-id/models/FrontStoryChannelV2.js

@@ -0,0 +1,60 @@
+module.exports = (sequelize, DataTypes) => {
+    const FrontStoryChannelV2 = sequelize.define(
+      "FrontStoryChannelV2",
+      {
+        channelId: {
+          type: DataTypes.STRING,
+          allowNull: false,
+          // Not setting as primary key or unique since duplicates are allowed
+        },
+        channelName: {
+          type: DataTypes.STRING,
+          allowNull: true,
+          comment: 'Human-readable name for the channel'
+        },
+        styleId: {
+          type: DataTypes.STRING,
+          allowNull: false,
+        },
+        status: {
+          type: DataTypes.STRING,
+          allowNull: false,
+          defaultValue: "free",
+          validate: {
+            isIn: [["free", "used", "archived"]],
+          },
+        },
+        connectedCampaigns: {
+          type: DataTypes.JSONB, // Use JSONB for better querying capabilities
+          allowNull: false,
+          defaultValue: [],
+        },
+      },
+      {
+        tableName: "front_story_channels_v2",
+        timestamps: true,
+        // indexes: [
+        //   // Add a composite unique index on channelId and styleId if needed
+        //   {
+        //     unique: true,
+        //     fields: ["channelId", "styleId"],
+        //     name: "unique_front_story_channel_v2_style",
+        //   },
+        // ],
+      }
+    );
+  
+    // Define associations without enforcing constraints
+    FrontStoryChannelV2.associate = (models) => {
+      if (models.RSOCFeedCampaign) {
+        FrontStoryChannelV2.hasMany(models.RSOCFeedCampaign, {
+          foreignKey: "channelId",
+          sourceKey: "channelId",
+          as: "RSOCFeedCampaigns",
+          constraints: false, // Disable FK constraint
+        });
+      }
+    };
+  
+    return FrontStoryChannelV2;
+  };

package/.worktrees/aicampaign-queue-group-id/models/GenericFlowRequest.js

@@ -0,0 +1,115 @@
+// models/GenericFlowRequest.js
+module.exports = (sequelize, DataTypes) => {
+    const GenericFlowRequest = sequelize.define(
+      "GenericFlowRequest",
+      {
+        id: {
+          type: DataTypes.BIGINT,
+          autoIncrement: true,
+          primaryKey: true,
+        },
+        request_id: {
+            type: DataTypes.STRING, 
+            allowNull: false,
+            unique: true,
+            field: "request_id",
+          },
+        flow_type: {
+          type: DataTypes.ENUM("article", "texts", "keywords", "creative"),
+          allowNull: false,
+          field: "flow_type",
+        },
+        status: {
+          type: DataTypes.ENUM("pending", "processing", "completed", "failed", "retrying"),
+          defaultValue: "pending",
+          allowNull: false,
+        },
+        retry_count: {
+          type: DataTypes.INTEGER,
+          defaultValue: 0,
+          field: "retry_count",
+        },
+        max_retries: {
+          type: DataTypes.INTEGER,
+          defaultValue: 3,
+          field: "max_retries",
+        },
+        input_params: {
+          type: DataTypes.JSONB,
+          allowNull: true,
+          field: "input_params",
+        },
+        output_result: {
+          type: DataTypes.JSONB,
+          allowNull: true,
+          field: "output_result",
+        },
+        error_message: {
+          type: DataTypes.TEXT,
+          allowNull: true,
+          field: "error_message",
+        },
+        error_stack: {
+          type: DataTypes.TEXT,
+          allowNull: true,
+          field: "error_stack",
+        },
+        AGRS_CID: {
+            type: DataTypes.STRING, 
+            allowNull: true,
+            field: "AGRS_CID",
+          },
+          process_id: {
+            type: DataTypes.STRING, 
+            allowNull: true,
+            field: "process_id",
+          },
+          parent_request_id: {
+            type: DataTypes.STRING, 
+            allowNull: true,
+            field: "parent_request_id",
+          },
+        related_request_ids: {
+          type: DataTypes.JSONB,
+          allowNull: true,
+          field: "related_request_ids",
+        },
+        metadata: {
+          type: DataTypes.JSONB,
+          allowNull: true,
+        },
+        processing_time_ms: {
+          type: DataTypes.INTEGER,
+          allowNull: true,
+          field: "processing_time_ms",
+        },
+        started_at: {
+          type: DataTypes.DATE,
+          allowNull: true,
+          field: "started_at",
+        },
+        completed_at: {
+          type: DataTypes.DATE,
+          allowNull: true,
+          field: "completed_at",
+        },
+        failed_at: {
+          type: DataTypes.DATE,
+          allowNull: true,
+          field: "failed_at",
+        },
+        last_retry_at: {
+          type: DataTypes.DATE,
+          allowNull: true,
+          field: "last_retry_at",
+        },
+      },
+      {
+        tableName: "generic_flow_requests",
+        timestamps: true, // Adds createdAt and updatedAt
+        underscored: false, // We're using explicit field mappings
+      }
+    );
+  
+    return GenericFlowRequest;
+  };

package/.worktrees/aicampaign-queue-group-id/models/KeywordPerformance.js

@@ -0,0 +1,106 @@
+module.exports = (sequelize, DataTypes) => {
+  const KeywordPerformance = sequelize.define(
+    "KeywordPerformance",
+    {
+      Date: {
+        type: DataTypes.DATEONLY,
+        primaryKey: true,
+      },
+      adID: {
+        type: DataTypes.STRING,
+        references: {
+          model: "Ad",
+          key: "AdID",
+        },
+        foreignKey: true,
+        primaryKey: true,
+      },
+      Keyword: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        primaryKey: true,
+      },
+      Revenue: {
+        type: DataTypes.FLOAT,
+        allowNull: false,
+      },
+      Clicks: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+      },
+      TemplatedKeyword: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      FirstAppearanceDate: {
+        type: DataTypes.DATEONLY,
+        allowNull: true,
+      },
+      Country: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+    },
+
+    {
+      tableName: "KeywordPerformance",
+      indexes: [
+        {
+          unique: true,
+          fields: ["adID", "Date", "Keyword"], // Composite unique index for fast lookups
+        },
+        {
+          fields: ["Date"], // Index for date filtering
+        },
+        {
+          fields: ["adID"], // Index for faster joins on adID
+        },
+        {
+          fields: ["Keyword"], // Index for faster searches on Keyword
+        },
+        {
+          fields: ["Revenue"], // Index to optimize sorting/filtering on Revenue
+        },
+        {
+          fields: ["Clicks"], // Index to optimize sorting/filtering on Clicks
+        },
+        {
+          fields: ["Country"], // Index for country filtering/grouping
+        },
+      ],
+      hooks: {
+        beforeCreate: async (record, options) => {
+          try {
+            const existingKeyword =
+              await sequelize.models.KeywordPerformance.findOne({
+                where: {
+                  Keyword: sequelize.where(
+                    sequelize.fn("LOWER", sequelize.col("Keyword")),
+                    sequelize.fn("LOWER", record.Keyword)
+                  ),
+                },
+                attributes: ["FirstAppearanceDate"],
+                transaction: options.transaction,
+              });
+
+            // If keyword exists, use its FirstAppearanceDate
+            // If not, use the current record's Date
+            record.FirstAppearanceDate =
+              existingKeyword?.FirstAppearanceDate || record.Date;
+          } catch (error) {
+            console.error("Error in FirstAppearanceDate hook:", error);
+            throw error;
+          }
+        },
+      },
+    }
+  );
+
+  KeywordPerformance.associate = (models) => {
+    KeywordPerformance.belongsTo(models.Ad, {
+      foreignKey: "adID",
+    });
+  };
+
+  return KeywordPerformance;
+};

package/.worktrees/aicampaign-queue-group-id/models/KeywordRotationState.js

@@ -0,0 +1,51 @@
+// models/KeywordRotationState.js
+const { DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  const KeywordRotationState = sequelize.define("KeywordRotationState", {
+    campaignId: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      primaryKey: true,
+    },
+    staticKeywords: {
+      type: DataTypes.ARRAY(DataTypes.STRING),
+      allowNull: false,
+      defaultValue: [], // Default to empty array if no static keywords are provided
+    },
+    rotatingKeywords: {
+      type: DataTypes.ARRAY(DataTypes.STRING),
+      allowNull: false,
+      defaultValue: [], // Default to empty array if no rotating keywords are provided
+    },
+    dynamic: {
+      type: DataTypes.ARRAY(DataTypes.STRING),
+      allowNull: false,
+      defaultValue: [], // Default to empty array if no dynamic keywords are provided
+    },
+    offset: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      defaultValue: 0,
+    },
+    rotationTime: {
+      type: DataTypes.STRING, // in minutes
+      allowNull: false,
+    },
+    rotatingKeywordSlots: {
+      type: DataTypes.INTEGER, // Number of keyword slots assigned to rotation
+      allowNull: false,
+    },
+    lastRotationTime: {
+      type: DataTypes.DATE,
+      allowNull: true,
+    },
+    status: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      defaultValue: "Not Set", // Default to started when first created
+    },
+  });
+
+  return KeywordRotationState;
+};

package/.worktrees/aicampaign-queue-group-id/models/MidoWebChannel.js

@@ -0,0 +1,47 @@
+module.exports = (sequelize, DataTypes) => {
+  const MidoWebChannel = sequelize.define(
+    "MidoWebChannel",
+    {
+      channelId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true,
+      },
+      styleId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      status: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        defaultValue: "free",
+        validate: {
+          isIn: [["free", "used", "archived"]],
+        },
+      },
+      connectedCampaigns: {
+        type: DataTypes.JSONB, // Use JSONB for better querying capabilities
+        allowNull: false,
+        defaultValue: [],
+      },
+    },
+    {
+      tableName: "mido_web_channels",
+      timestamps: true,
+    }
+  );
+
+  // Define associations without enforcing constraints
+  MidoWebChannel.associate = (models) => {
+    if (models.RSOCFeedCampaign) {
+      MidoWebChannel.hasMany(models.RSOCFeedCampaign, {
+        foreignKey: "channelId",
+        sourceKey: "channelId",
+        as: "RSOCFeedCampaigns",
+        constraints: false, // Disable FK constraint
+      });
+    }
+  };
+
+  return MidoWebChannel;
+};

package/.worktrees/aicampaign-queue-group-id/models/MineChannel.js

@@ -0,0 +1,43 @@
+module.exports = (sequelize, DataTypes) => {
+    const MineChannel = sequelize.define(
+      "MineChannel",
+      {
+        channelId: {
+          type: DataTypes.STRING,
+          allowNull: false,
+          // Not setting as primary key or unique since duplicates are allowed
+        },
+        status: {
+          type: DataTypes.STRING,
+          allowNull: false,
+          defaultValue: "free",
+          validate: {
+            isIn: [["free", "used", "archived"]],
+          },
+        },
+        connectedCampaigns: {
+          type: DataTypes.JSONB, // Use JSONB for better querying capabilities
+          allowNull: false,
+          defaultValue: [],
+        },
+      },
+      {
+        tableName: "mine_channels",
+        timestamps: true,
+      }
+    );
+  
+    // Define associations without enforcing constraints
+    MineChannel.associate = (models) => {
+      if (models.RSOCFeedCampaign) {
+        MineChannel.hasMany(models.RSOCFeedCampaign, {
+          foreignKey: "channelId",
+          sourceKey: "channelId",
+          as: "RSOCFeedCampaigns",
+          constraints: false, // Disable FK constraint
+        });
+      }
+    };
+  
+    return MineChannel;
+  };