lay the ground work for auto-opt ins

Author: Ruby Engelhart

migrations/20241217211012_add_optin_table.js

@@ -0,0 +1,32 @@
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+exports.up = async knex => {
+    await knex.schema.hasTable("opt_in").then(async exists => {
+        if (exists) return;
+        await knex.schema.createTable("opt_in", table => {
+            table.increments("id")
+            table.text("cell").notNullable();
+            table.integer("assignment_id");
+            table.integer("organization_id").notNullable();
+            // Not in love with "reason_code", but doing so to match
+            // opt_out table
+            table.text("reason_code").notNullable().defaultTo("");
+            table.timestamp("created_at").notNullable().defaultTo(knex.fn.now());
+
+            table.index("cell");
+            table.index("assignment_id");
+            table.foreign("assignment_id").references("assignment.id");
+            table.index("organization_id");
+            table.foreign("organization_id").references("organization.id")
+        });
+    });
+};
+
+/**
+ * @param { import("knex").Knex } knex
+ */
+exports.down = async function(knex) {
+    await knex.schema.dropTable("opt_in");
+};

migrations/20241218161942_add_is_opted_in_to_campaign_contact.js

@@ -0,0 +1,26 @@
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+exports.up = async knex => {
+    await knex.schema.alterTable("campaign_contact", table => {
+        table
+            .boolean("is_opted_in")
+            .defaultTo(false);
+    });
+};
+
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+exports.down = async knex => {
+    const isSqlite = /sqlite/.test(knex.client.config.client);
+    if (!isSqlite) {
+        await knex.schema.alterTable("campaign_contact", table => {
+            table
+                .boolean("is_opted_in")
+                .defaultTo(false);
+        });
+    }
+};

src/containers/AssignmentTexterContact.jsx

@@ -200,6 +200,7 @@ export class AssignmentTexterContact extends React.Component {
             console.log("sentMessage", contact.id);
           });
       } else {
+        console.log("here2", message, contact, cannedResponseId);
         await this.props.mutations.sendMessage(
           message,
           contact.id,
@@ -210,6 +211,7 @@ export class AssignmentTexterContact extends React.Component {
       this.props.onFinishContact(contact.id);
     } catch (e) {
       this.handleSendMessageError(e);
+      console.log("here maybe: ", e);
       setTimeout(() => {
         this.props.onFinishContact(contact.id);
       }, 750);

src/extensions/message-handlers/auto-optin/index.js

@@ -0,0 +1,91 @@
+import { getConfig, getFeatures } from "../../../server/api/lib/config";
+import { cacheableData } from "../../../server/models";
+
+const DEFAULT_AUTO_OPTIN_REGEX_LIST_BASE64 =
+    "W3sicmVnZXgiOiAiXlNUQVJUJH1d";
+
+// DEFAULT_AUTO_OPTIN_REGEX_LIST_BASE64 decodes to:
+// [{"regex": "^START$, "reason": "start"}]
+
+export const serverAdministratorInstructions = () => {
+    return {
+        description: ``,
+        setupInstructions: ``,
+        environmentVariables: []
+    }
+}
+
+export const available = organization => {
+    const config = getConfig("AUTO_OPTIN_REGEX_LIST_BASE64", organization) ||
+        DEFAULT_AUTO_OPTIN_REGEX_LIST_BASE64;
+    
+    if (!config) return false;
+    try {
+        JSON.parse(Buffer.from(conf, "base64").toString());
+        return true;
+    } catch (exception) {
+        console.log(
+            "message-handler/auto-optin JSON parse of AUTO_OPTIN_REGEX_LIST_BASE64 failed",
+            e
+        );
+        return false;
+    }
+}
+
+export const preMessageSave = async ({ messageToSave, organization }) => {
+    if (messageToSave.is_from_contact) {
+        const config = Buffer.from(
+            getConfig("AUTO_OPTIN_REGEX_LIST_BASE64", organization) ||
+            DEFAULT_AUTO_OPTIN_REGEX_LIST_BASE64
+        );
+        const regexList = JSON.parse(config || "[]");
+        const matches = regexList.filter(matcher => {
+            const re = new RegExp(matcher.regex); // Want case sensitivity, probably?
+            return String(messageToSave.text).match(re);
+        })
+        if (matches.length) {
+            console.log(
+                `auto-optin MATCH ${messageToSave.campaign_contact_id}`
+            );
+            const reason = matches[0].reason || "auto_optin";
+
+            // UNSURE OF THIS RETURN
+            return {
+                contactUpdates: {
+                    is_opted_in: true
+                },
+                handlerContext: {
+                    autoOptInReason: reason,
+                },
+                messageToSave
+            };
+        }
+    }
+}
+
+export const postMessageSave = async ({ 
+    message, 
+    organization, 
+    handlerContext, 
+    campaign 
+}) => {
+    if (!message.is_from_contact || !handlerContext.autoOptInReason) return;
+
+    console.log(
+        `auto-optin.postMessageSave ${message.campaign_contact_id}`
+    );
+
+    let contact = await cacheableData.campaignContact.load(
+        message.campaign_contact_id,
+        { cahceOnly: true}
+    );
+    campaign = campaign || { organization_id: organization.id};
+
+    // Save to DB
+    await cacheableData.optIn.save({
+        cell: message.contact_number,
+        campaign,
+        assignmentId: (contact && contact.assignment_id) || null,
+        reason: handlerContext.autoOptInReason
+    });
+}

src/server/models/cacheable_queries/index.js

@@ -5,6 +5,7 @@ import cannedResponse from "./canned-response";
 import organizationContact from "./organization-contact";
 import message from "./message";
 import optOut from "./opt-out";
+import optIn from "./opt-in";
 import organization from "./organization";
 import questionResponse from "./question-response";
 import { tagCampaignContactCache as tagCampaignContact } from "./tag-campaign-contact";
@@ -18,6 +19,7 @@ const cacheableData = {
   organizationContact,
   message,
   optOut,
+  optIn,
   organization,
   questionResponse,
   tagCampaignContact,

src/server/models/cacheable_queries/opt-in.js

@@ -0,0 +1,144 @@
+import { r } from "../../models";
+
+// TODO: Add OPTINS_SHARE_ALL_ORGS to env doc
+
+const orgCacheKey = orgId =>
+    !!process.env.OPTINS_SHARE_ALL_ORGS
+        ? `${process.env.CAHCE_PREFIX || ""}:optins`
+        : `${process.env.CACHE_PREFIS || ""}:optins-${orgId}`;
+
+const sharingOptIns = !!process.env.OPTINS_SHARE_ALL_ORGS
+
+// Probably not needed, but good to offload stress from
+// db. 
+const loadMany = async organizationId => {
+    if (r.redis) {
+        let dbQuery = r
+            .knex("opt_in")
+            .select("cell")
+            .orderBy("id", "desc")
+            .limit(process.env.OPTINS_CACHE_MAX || 1000000);
+        
+        if (!sharingOptIns) {
+            dbQuery = dbQuery.where("organization_id", organizationId);
+        }
+        const dbResult = await dbQuery;
+        const cellOptIns = dbResult.map(rec => rec.cell);
+        const hashKey = orgCacheKey(organizationId);
+
+        await r.redis.SADD(hashKey, ["0"]);
+        await r.redis.expire(hashKey, 43200);
+
+        for (
+            let i100 = 0, l100 = Math.ceil(cellOptOuts.length / 100);
+            i100 < l100;
+            i100++
+        ) {
+            await r.redis.SADD(
+                hashKey,
+                cellOptIns.slice(100 * i100, 100 * i100 + 100)
+            );
+        }
+        return cellOptIns.length;
+    }
+}
+
+const updateIsOptedIn = async queryModifier => {
+    // update all organization/instance's active campaigns
+    const optInContactQuery = r
+        .knex("campaign_contact")
+        .join("campaign", "campaign_contact.id", "campaign.id")
+        .where("campaign.is_archived", false)
+        .select("campaign_contact.id");
+
+    return await r
+        .knex("campaign_contact")
+        .whereIn(
+            "id",
+            queryModifier ? queryModifier(optInContactQuery) : optInContactQuery
+        )
+        .update("is_opted_in", true)
+        .update({
+            is_opted_in: true
+        })
+}
+
+const optInCache = {
+    clearQuery: async ({ cell, organizationId }) => {
+        if (r.redis) {
+            if (cell) {
+                await r.redis.sdel(orgCacheKey(organizationId), cell);
+            } else {
+                await r.redis.DEL(orgCacheKey(organizationId));
+            }
+        }
+    },
+    query: async ({ cell, organizationId }) => {
+        const accountingForOrgSharing = !sharingOptIns
+            ? { cell, organization_id: organizationId }
+            : { cell };
+        
+        if (r.redis) {
+            const hashKey = orgCacheKey(organizationId);
+            const [exists, isMember] = await r.redis
+                .MULTI()
+                .EXISTS(hashKey)
+                .SISMEMBER(hashKey, cell)
+                .exec();
+            if (exists) {
+                return isMember;
+            }
+
+            loadMany(organizationId)
+                .then(optInCount => {
+                    if (!global.TEST_ENVIRONMENT) {
+                        console.log(
+                            "optInCache loaded for organization",
+                            organizationId,
+                            optInCount
+                        );
+                    }
+                })
+                .catch(err => {
+                    console.log(
+                        "optInCache Error for organization",
+                        organizationId,
+                        err
+                    );
+                });
+        }
+        const dbResult = await r
+            .knex("opt_in")
+            .select("cell")
+            .where(accountingForOrgSharing)
+            .limit(1);
+        return dbResult.length > 0
+    },
+    save: async ({
+        cell,
+        campaign,
+        assignmentId,
+        reason
+    }) => {
+        const organizationId = campaign.organization_id;
+        if (r.redis) {
+            const hashKey = orgCacheKey(organizationId);
+            const exists = await r.redis.exists(hashKey);
+            if (exists) {
+                await r.redis.SADD(hashKey, cell);
+            }
+        }
+
+        // place into db
+        await r.knex("opt_in").insert({
+            assignment_id: assignmentId,
+            organization_id: organizationId,
+            reason_code: reason,
+            cell
+        });
+    },
+    loadMany,
+    updateIsOptedIn
+}
+
+export default optInCache;

src/server/models/index.js

@@ -11,6 +11,7 @@ import CampaignContact from "./campaign-contact";
 import InteractionStep from "./interaction-step";
 import QuestionResponse from "./question-response";
 import OptOut from "./opt-out";
+import OptIn from "./opt-in";
 import JobRequest from "./job-request";
 import Invite from "./invite";
 import CannedResponse from "./canned-response";
@@ -131,6 +132,7 @@ const createLoaders = () => ({
   jobRequest: createLoader(JobRequest),
   message: createLoader(Message),
   optOut: createLoader(OptOut),
+  optIn: createLoader(OptIn),
   pendingMessagePart: createLoader(PendingMessagePart),
   questionResponse: createLoader(QuestionResponse),
   userCell: createLoader(UserCell),
@@ -165,6 +167,7 @@ export {
   JobRequest,
   Message,
   OptOut,
+  OptIn,
   Organization,
   PendingMessagePart,
   CannedResponse,

src/server/models/opt-in.js

@@ -0,0 +1,28 @@
+import thinky from "./thinky";
+const type = thinky.type;
+import { optionalString, requiredString, timestamp } from "./custom-types";
+
+import Organization from "./organization";
+import Assignment from "./assignment";
+
+const OptIn = thinky.createModel(
+  "opt_in",
+  type
+    .object()
+    .schema({
+      id: type.string(),
+      cell: requiredString(),
+      assignment_id: optionalString(),
+      organization_id: requiredString(),
+      reason_code: requiredString(),  
+      created_at: timestamp()
+    })
+    .allowExtra(false),
+  { noAutoCreation: true, dependencies: [Organization, Assignment] }
+);
+
+OptIn.ensureIndex("cell");
+OptIn.ensureIndex("assignment_id");
+OptIn.ensureIndex("organization_id");
+
+export default OptIn;