agrs-sequelize-sdk 1.2.68 → 1.2.70

package/models/RsocKeywordPerformance.js

@@ -1,111 +1,111 @@
-module.exports = (sequelize, DataTypes) => {
-    const RsocKeywordPerformance = sequelize.define('RsocKeywordPerformance', {
-        id: {
-            type: DataTypes.INTEGER,
-            primaryKey: true,
-            autoIncrement: true,
-            allowNull: false
-        },
-        ts: {
-            type: DataTypes.DATE,
-            allowNull: false,
-            comment: 'Timestamp of the record'
-        },
-        channel_id: {
-            type: DataTypes.STRING,
-            allowNull: false,
-            comment: 'Channel identifier'
-        },
-        style_id: {
-            type: DataTypes.STRING,
-            allowNull: true,
-            comment: 'Style identifier'
-        },
-        country_code: {
-            type: DataTypes.STRING(2),
-            allowNull: true,
-            comment: 'Country code (ISO 2-letter)'
-        },
-        custom_query: {
-            type: DataTypes.TEXT,
-            allowNull: true,
-            comment: 'Custom search query'
-        },
-        query: {
-            type: DataTypes.TEXT,
-            allowNull: true,
-            comment: 'Standard search query'
-        },
-        funnel_page_views: {
-            type: DataTypes.INTEGER,
-            allowNull: true,
-            defaultValue: 0,
-            comment: 'Number of funnel page views'
-        },
-        funnel_impressions: {
-            type: DataTypes.INTEGER,
-            allowNull: true,
-            defaultValue: 0,
-            comment: 'Number of funnel impressions'
-        },
-        funnel_clicks: {
-            type: DataTypes.INTEGER,
-            allowNull: true,
-            defaultValue: 0,
-            comment: 'Number of funnel clicks'
-        },
-        page_views: {
-            type: DataTypes.INTEGER,
-            allowNull: true,
-            defaultValue: 0,
-            comment: 'Number of page views'
-        },
-        impressions: {
-            type: DataTypes.INTEGER,
-            allowNull: true,
-            defaultValue: 0,
-            comment: 'Number of impressions'
-        },
-        clicks: {
-            type: DataTypes.INTEGER,
-            allowNull: true,
-            defaultValue: 0,
-            comment: 'Number of clicks'
-        },
-        agrs_cid: {
-            type: DataTypes.STRING,
-            allowNull: true,
-            comment: 'AGRS campaign identifier linking to campaign data'
-        }
-    }, {
-        tableName: 'rsoc_keyword_performance',
-        timestamps: true, // Adds createdAt and updatedAt columns
-        indexes: [
-            {
-                fields: ['channel_id', 'ts'],
-                name: 'idx_rsoc_keyword_channel_time'
-            },
-            {
-                fields: ['style_id'],
-                name: 'idx_rsoc_keyword_style'
-            },
-            {
-                fields: ['country_code'],
-                name: 'idx_rsoc_keyword_country'
-            },
-            {
-                fields: ['agrs_cid'],
-                name: 'idx_rsoc_keyword_agrs_cid'
-            }
-        ]
-    });
-
-    // Define associations if needed
-    RsocKeywordPerformance.associate = (models) => {
-        // Add associations here if your table needs to reference other tables
-        // For example:
-        // RsocKeywordPerformance.belongsTo(models.Channel, { foreignKey: 'channel_id' });
-    };
-
-    return RsocKeywordPerformance;
+module.exports = (sequelize, DataTypes) => {
+    const RsocKeywordPerformance = sequelize.define('RsocKeywordPerformance', {
+        id: {
+            type: DataTypes.INTEGER,
+            primaryKey: true,
+            autoIncrement: true,
+            allowNull: false
+        },
+        ts: {
+            type: DataTypes.DATE,
+            allowNull: false,
+            comment: 'Timestamp of the record'
+        },
+        channel_id: {
+            type: DataTypes.STRING,
+            allowNull: false,
+            comment: 'Channel identifier'
+        },
+        style_id: {
+            type: DataTypes.STRING,
+            allowNull: true,
+            comment: 'Style identifier'
+        },
+        country_code: {
+            type: DataTypes.STRING(2),
+            allowNull: true,
+            comment: 'Country code (ISO 2-letter)'
+        },
+        custom_query: {
+            type: DataTypes.TEXT,
+            allowNull: true,
+            comment: 'Custom search query'
+        },
+        query: {
+            type: DataTypes.TEXT,
+            allowNull: true,
+            comment: 'Standard search query'
+        },
+        funnel_page_views: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of funnel page views'
+        },
+        funnel_impressions: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of funnel impressions'
+        },
+        funnel_clicks: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of funnel clicks'
+        },
+        page_views: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of page views'
+        },
+        impressions: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of impressions'
+        },
+        clicks: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of clicks'
+        },
+        agrs_cid: {
+            type: DataTypes.STRING,
+            allowNull: true,
+            comment: 'AGRS campaign identifier linking to campaign data'
+        }
+    }, {
+        tableName: 'rsoc_keyword_performance',
+        timestamps: true, // Adds createdAt and updatedAt columns
+        indexes: [
+            {
+                fields: ['channel_id', 'ts'],
+                name: 'idx_rsoc_keyword_channel_time'
+            },
+            {
+                fields: ['style_id'],
+                name: 'idx_rsoc_keyword_style'
+            },
+            {
+                fields: ['country_code'],
+                name: 'idx_rsoc_keyword_country'
+            },
+            {
+                fields: ['agrs_cid'],
+                name: 'idx_rsoc_keyword_agrs_cid'
+            }
+        ]
+    });
+
+    // Define associations if needed
+    RsocKeywordPerformance.associate = (models) => {
+        // Add associations here if your table needs to reference other tables
+        // For example:
+        // RsocKeywordPerformance.belongsTo(models.Channel, { foreignKey: 'channel_id' });
+    };
+
+    return RsocKeywordPerformance;
 };

package/models/Rule.js

@@ -1,39 +1,178 @@
-module.exports = (sequelize, DataTypes) => {
-  const Rule = sequelize.define("Rule", {
-    ruleName: {
-      type: DataTypes.STRING,
-      allowNull: false,
-    },
-    timeUnit: {
-      type: DataTypes.ENUM("minutes", "hours", "days"),
-      allowNull: false,
-    },
-    timeValue: {
-      type: DataTypes.INTEGER,
-      allowNull: false,
-    },
-    daysAndTimes: {
-      type: DataTypes.JSONB, // Store days, time ranges, and conditions as a JSON object
-      allowNull: true,
-    },
-    filters: {
-      type: DataTypes.JSONB,
-      allowNull: true,
-    },
-    triggers: {
-      type: DataTypes.JSONB,
-      allowNull: false,
-    },
-    actions: {
-      type: DataTypes.JSONB,
-      allowNull: false,
-    },
-    status: {
-      type: DataTypes.ENUM("active", "paused"),
-      allowNull: false,
-      defaultValue: "active",
+const { DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  const Rule = sequelize.define(
+    "Rule",
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+      name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: "Rule name for identification",
+      },
+      code: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true,
+        comment: "Unique code for the rule",
+      },
+      permissions: {
+        type: DataTypes.ARRAY(DataTypes.STRING),
+        allowNull: false,
+        defaultValue: [],
+        comment: "Permissions required for this rule",
+      },
+      feature: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: "Feature this rule belongs to",
+      },
+      parentId: {
+        type: DataTypes.UUID,
+        allowNull: true,
+        references: {
+          model: "Rules",
+          key: "id",
+        },
+        onDelete: "CASCADE",
+        comment: "Parent rule ID for hierarchical rules",
+      },
+      // Additional fields for the new rules system
+      description: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: "Optional description of what this rule does",
+      },
+      isActive: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: true,
+        allowNull: false,
+        comment: "Whether the rule is currently active",
+      },
+      ruleType: {
+        type: DataTypes.ENUM("PAUSE", "BUDGET", "BID", "STATUS", "CUSTOM"),
+        allowNull: true,
+        comment: "Type of rule - determines the action category",
+      },
+      targetLevel: {
+        type: DataTypes.ENUM("CAMPAIGN", "ADSET", "AD"),
+        allowNull: true,
+        comment: "Level at which the rule operates",
+      },
+      scheduleType: {
+        type: DataTypes.ENUM("INTERVAL", "CRON", "MANUAL"),
+        allowNull: true,
+        defaultValue: "MANUAL",
+        comment: "How the rule is triggered",
+      },
+      scheduleConfig: {
+        type: DataTypes.JSONB,
+        allowNull: true,
+        comment:
+          "Schedule configuration (interval minutes, cron expression, etc.)",
+      },
+      gcpJobName: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        comment: "GCP Cloud Scheduler job name for this rule",
+      },
+      lastExecuted: {
+        type: DataTypes.DATE,
+        allowNull: true,
+        comment: "When the rule was last executed",
+      },
+      nextExecution: {
+        type: DataTypes.DATE,
+        allowNull: true,
+        comment: "When the rule is scheduled to run next",
+      },
+      executionCount: {
+        type: DataTypes.INTEGER,
+        defaultValue: 0,
+        allowNull: false,
+        comment: "Number of times this rule has been executed",
+      },
+      successCount: {
+        type: DataTypes.INTEGER,
+        defaultValue: 0,
+        allowNull: false,
+        comment: "Number of successful executions",
+      },
+      failureCount: {
+        type: DataTypes.INTEGER,
+        defaultValue: 0,
+        allowNull: false,
+        comment: "Number of failed executions",
+      },
+      createdBy: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        comment: "User who created this rule",
+      },
+      updatedBy: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        comment: "User who last updated this rule",
+      },
     },
-  });
+    {
+      tableName: "RulesValues", // Use the existing table name
+      timestamps: true,
+      indexes: [
+        {
+          fields: ["code"],
+        },
+        {
+          fields: ["feature"],
+        },
+        {
+          fields: ["parentId"],
+        },
+        {
+          fields: ["isActive"],
+        },
+        {
+          fields: ["ruleType"],
+        },
+        {
+          fields: ["targetLevel"],
+        },
+        {
+          fields: ["scheduleType"],
+        },
+        {
+          fields: ["nextExecution"],
+        },
+      ],
+    }
+  );
+
+  Rule.associate = (models) => {
+    // A rule has many conditions
+    Rule.hasMany(models.RuleCondition, {
+      foreignKey: "ruleId",
+      as: "conditions",
+      onDelete: "CASCADE",
+    });
+
+    // A rule has many actions
+    Rule.hasMany(models.RuleAction, {
+      foreignKey: "ruleId",
+      as: "actions",
+      onDelete: "CASCADE",
+    });
+
+    // A rule has many execution logs
+    Rule.hasMany(models.RuleExecution, {
+      foreignKey: "ruleId",
+      as: "executions",
+      onDelete: "CASCADE",
+    });
+  };
 
   return Rule;
-};
+};

package/models/RuleAction.js

@@ -0,0 +1,97 @@
+const { DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  const RuleAction = sequelize.define(
+    "RuleAction",
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+      ruleId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: "RulesValues",
+          key: "id",
+        },
+        comment: "Reference to the parent rule",
+      },
+      actionType: {
+        type: DataTypes.ENUM(
+          // Campaign level actions
+          "PAUSE_CAMPAIGN",
+          "ACTIVATE_CAMPAIGN",
+          "CHANGE_CAMPAIGN_BUDGET",
+          "CHANGE_CAMPAIGN_BID_STRATEGY",
+
+          // AdSet level actions
+          "PAUSE_ADSET",
+          "ACTIVATE_ADSET",
+          "CHANGE_ADSET_BUDGET",
+          "CHANGE_ADSET_BID",
+          "CHANGE_ADSET_BID_STRATEGY",
+
+          // Ad level actions
+          "PAUSE_AD",
+          "ACTIVATE_AD",
+
+          // Custom actions
+          "CUSTOM_ACTION"
+        ),
+        allowNull: false,
+        comment: "Type of action to perform",
+      },
+      actionConfig: {
+        type: DataTypes.JSONB,
+        allowNull: true,
+        comment:
+          "Configuration for the action (budget amount, bid strategy, etc.)",
+      },
+      order: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+        comment: "Order of this action within the rule",
+      },
+      isActive: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: true,
+        allowNull: false,
+        comment: "Whether this action is active",
+      },
+      delayMinutes: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        defaultValue: 0,
+        comment: "Delay in minutes before executing this action",
+      },
+    },
+    {
+      tableName: "RuleActions",
+      timestamps: true,
+      indexes: [
+        {
+          fields: ["ruleId"],
+        },
+        {
+          fields: ["actionType"],
+        },
+        {
+          fields: ["order"],
+        },
+      ],
+    }
+  );
+
+  RuleAction.associate = (models) => {
+    // An action belongs to a rule
+    RuleAction.belongsTo(models.Rule, {
+      foreignKey: "ruleId",
+      as: "rule",
+    });
+  };
+
+  return RuleAction;
+};

package/models/RuleCondition.js

@@ -0,0 +1,99 @@
+const { DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  const RuleCondition = sequelize.define(
+    "RuleCondition",
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+      ruleId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: "RulesValues",
+          key: "id",
+        },
+        comment: "Reference to the parent rule",
+      },
+      field: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+        comment: "Field to evaluate (e.g., roi, ctr, campaign_name)",
+      },
+      operator: {
+        type: DataTypes.ENUM(
+          "EQUALS",
+          "NOT_EQUALS",
+          "GREATER_THAN",
+          "LESS_THAN",
+          "GREATER_THAN_OR_EQUAL",
+          "LESS_THAN_OR_EQUAL",
+          "BETWEEN",
+          "IN",
+          "NOT_IN",
+          "CONTAINS",
+          "NOT_CONTAINS",
+          "IS_NULL",
+          "IS_NOT_NULL"
+        ),
+        allowNull: false,
+        comment: "Comparison operator",
+      },
+      value: {
+        type: DataTypes.JSONB,
+        allowNull: true,
+        comment:
+          "Value(s) to compare against (can be array for BETWEEN, IN, etc.)",
+      },
+      logicalOperator: {
+        type: DataTypes.ENUM("AND", "OR"),
+        allowNull: false,
+        defaultValue: "AND",
+        comment: "How this condition connects to the next one",
+      },
+      order: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+        comment: "Order of this condition within the rule",
+      },
+      isActive: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: true,
+        allowNull: false,
+        comment: "Whether this condition is active",
+      },
+    },
+    {
+      tableName: "RuleConditions",
+      timestamps: true,
+      indexes: [
+        {
+          fields: ["ruleId"],
+        },
+        {
+          fields: ["field"],
+        },
+        {
+          fields: ["operator"],
+        },
+        {
+          fields: ["order"],
+        },
+      ],
+    }
+  );
+
+  RuleCondition.associate = (models) => {
+    // A condition belongs to a rule
+    RuleCondition.belongsTo(models.Rule, {
+      foreignKey: "ruleId",
+      as: "rule",
+    });
+  };
+
+  return RuleCondition;
+};