@proca/cli 3.4.5 → 3.8.3

package/src/commands/campaign/get.mjs

@@ -0,0 +1,132 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import {
+  FragmentMtt,
+  FragmentOrg,
+  FragmentStats,
+  FragmentSummary,
+} from "#src/queries/campaign.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export const getCampaign = (params) => {
+  const d = new CampaignGet([]);
+  return d.fetch(params);
+};
+
+export default class CampaignGet extends Command {
+  actionTypes = new Set();
+
+  static args = this.multiid();
+
+  static description = "view a campaign";
+
+  static examples = ["<%= config.bin %> <%= command.id %> -i 42"];
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...this.flagify({ multiid: true }),
+    config: Flags.boolean({
+      description: "display the config",
+      default: false,
+      allowNo: true,
+    }),
+    stats: Flags.boolean({
+      description: "display the stats",
+      default: true,
+      allowNo: true,
+    }),
+    locale: Flags.string({
+      description: "display a locale",
+    }),
+  };
+
+  fetch = async ({ id, name }) => {
+    const GetCampaignDocument = gql`
+      query GetCampaign($id: Int, $name: String, $withStats: Boolean = false) {
+        campaign (name: $name, id: $id) {
+          ...Summary
+          ...Org
+          config
+          ...Stats @include(if: $withStats)
+          ...Mtt
+        }
+      }
+      ${FragmentStats}
+      ${FragmentSummary}
+      ${FragmentOrg}
+      ${FragmentMtt}
+    `;
+    const result = await query(GetCampaignDocument, {
+      id: id,
+      name: name,
+      withStats: this.flags.stats,
+    });
+    return result.campaign;
+  };
+
+  simplify = (d) => {
+    const result = {
+      id: d.id,
+      Name: d.name,
+      Title: d.title,
+      Org: d.org.name,
+      Status: d.status,
+      locales: d.config.locales && Object.keys(d.config.locales).join(" "),
+      journey: d.config.journey?.join(" → "),
+    };
+    if (d.mtt) {
+      // we have an mtt
+      const hhmm = (date) =>
+        new Date(date).toLocaleTimeString(undefined, {
+          hour: "2-digit",
+          minute: "2-digit",
+          hour12: false,
+        });
+      result.from = d.mtt.startAt.substring(0, 10);
+      result.to = d.mtt.endAt.substring(0, 10);
+      result.period = `${hhmm(d.mtt.startAt)}↔${hhmm(d.mtt.endAt)}`;
+      result["test email"] = d.mtt.testEmail;
+      result["mtt template"] = d.mtt.template;
+      result["cc contacts"] = d.mtt.ccContacts?.join(", ");
+      result["cc sender"] = d.mtt.ccSender;
+      result["drip delivery"] = d.mtt.dripDelivery;
+    }
+    if (this.flags.stats) {
+      result["#Supporters"] = d.stats.supporterCount;
+
+      this.actionTypes.forEach((type) => {
+        const action = d.stats.actionCount.find(
+          (action) => action.actionType === type,
+        );
+        if (action) result[`#${type}`] = action.count;
+      });
+    }
+    return result;
+  };
+
+  table = (r) => {
+    r.config = JSON.parse(r.config);
+    super.table(r, null, null);
+    if (this.flags.locale) {
+      this.prettyJson(r.config?.locales[this.flags.locale]);
+    }
+    if (this.flags.config) {
+      r.config.locales = undefined;
+      this.prettyJson(r.config);
+    }
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+
+    const data = await this.fetch({ id: flags.id, name: flags.name });
+    if (this.flags.stats) {
+      data.stats.actionCount.forEach((d) => {
+        //skip share_confirmed?
+        this.actionTypes.add(d.actionType);
+      });
+    }
+    return this.output(data);
+  }
+}

package/src/commands/campaign/list.mjs

@@ -0,0 +1,161 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import {
+  FragmentOrg,
+  FragmentStats,
+  FragmentSummary,
+} from "#src/queries/campaign.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export const getCampaignList = (params) => {
+  const d = new CampaignList([]);
+  return d.fetch(params);
+};
+
+export default class CampaignList extends Command {
+  actionTypes = new Set();
+
+  static args = {
+    title: Args.string({ description: "name of the campaign, % for wildchar" }),
+  };
+
+  static description = "list all the campaigns";
+
+  static examples = ["<%= config.bin %> <%= command.id %> %pizza%"];
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...super.globalFlags,
+    org: Flags.string({
+      char: "o",
+      description: "campaigns of the organisation (coordinator or partner)",
+      exactlyOne: ["org", "title"],
+      helpValue: "<organisation name>",
+    }),
+    title: Flags.string({
+      char: "t",
+      description: "name of the campaign, % for wildchar",
+      helpValue: "<campaign title>",
+    }),
+    stats: Flags.boolean({
+      description: "display the stats",
+      default: true,
+      allowNo: true,
+    }),
+  };
+
+  OrgSearch = async (name) => {
+    const SearchCampaignsDocument = gql`
+      query SearchCampaigns($org: String!, $withStats: Boolean = false) {
+        org (name:$org) {
+        campaigns {
+          ...Summary
+          ...Org
+          ...Stats @include(if: $withStats)
+        }
+        }
+      }
+      ${FragmentStats}
+      ${FragmentOrg}
+      ${FragmentSummary}
+    `;
+    const result = await query(SearchCampaignsDocument, {
+      org: name,
+      withStats: this.flags.stats,
+    });
+    return result.org.campaigns;
+    //return result.campaigns.map (d => {d.config = JSON.parse(d.config); return d});
+  };
+
+  Search = async (title) => {
+    const SearchCampaignsDocument = gql`
+      query SearchCampaigns($title: String!, $withStats: Boolean = false) {
+        campaigns(title: $title) {
+          ...Summary
+          ...Org
+          ...Stats @include(if: $withStats)
+        }
+      }
+      ${FragmentStats}
+      ${FragmentOrg}
+      ${FragmentSummary}
+    `;
+    const result = await query(SearchCampaignsDocument, {
+      title: title,
+      withStats: this.flags.stats,
+    });
+    return result.campaigns;
+    //return result.campaigns.map (d => {d.config = JSON.parse(d.config); return d});
+  };
+
+  simplify = (d) => {
+    const result = {
+      id: d.id,
+      Name: d.name,
+      Title: d.title,
+      Org: d.org.name,
+      Status: d.status,
+    };
+    if (this.flags.stats) {
+      result["#Supporters"] = d.stats.supporterCount;
+
+      this.actionTypes.forEach((type) => {
+        const action = d.stats.actionCount.find(
+          (action) => action.actionType === type,
+        );
+        if (action) result[`#${type}`] = action.count;
+      });
+    }
+    return result;
+  };
+
+  table = (r) => {
+    super.table(r, null, (table) => table.sort(["id|des"]).toString());
+  };
+
+  async run() {
+    const { args, flags } = await this.parse(CampaignList);
+    let data = [];
+
+    if (args.title && flags.title) {
+      throw new Error(
+        `${this.id} EITHER [title of the campaign] OR --title [title of the campaign]`,
+      );
+    }
+    if (args.title) {
+      flags.title = args.title;
+    }
+
+    if (!flags.title && !flags.org) {
+      throw new Error(
+        `${this.id} -t [title of the campaign] or -o [organisation]`,
+      );
+    }
+
+    if (flags.title) {
+      data = await this.Search(flags.title);
+      if (this.flags.stats) {
+        data.forEach((d) => {
+          d.stats.actionCount.forEach((d) => {
+            //skip share_confirmed?
+            this.actionTypes.add(d.actionType);
+          });
+        });
+      }
+    }
+
+    if (flags.org) {
+      data = await this.OrgSearch(flags.org);
+      if (this.flags.stats) {
+        data.forEach((d) => {
+          d.stats.actionCount.forEach((d) => {
+            //skip share_confirmed?
+            this.actionTypes.add(d.actionType);
+          });
+        });
+      }
+    }
+    return this.output(data);
+  }
+}

package/src/commands/campaign/mtt.mjs

@@ -0,0 +1,131 @@
+import { Flags } from "@oclif/core";
+import Command from "#src/procaCommand.mjs";
+import { FragmentMtt } from "#src/queries/campaign.mjs";
+import { gql, mutation } from "#src/urql.mjs";
+
+export default class CampaignMtt extends Command {
+  static args = this.multiid();
+
+  static description = "set the mail to target (mtt) params";
+
+  static examples = [
+    "<%= config.bin %> <%= command.id %> -n <test-mtt-campaign>",
+  ];
+
+  static flags = {
+    ...this.flagify({ multiid: true }),
+    from: Flags.string({
+      description: "start date (yyyy-mm-dd)",
+      required: false,
+    }),
+    to: Flags.string({
+      description: "end date (yyyy-mm-dd)",
+      required: false,
+    }),
+    template: Flags.string({
+      description: "mtt template to use",
+    }),
+    period: Flags.string({
+      description: "period of the day (HH:HH-HH:HH)",
+      default: "09:09-18:18",
+    }),
+    email: Flags.string({
+      description: "test email address",
+    }),
+    cc: Flags.string({
+      description: "comma-separated list of CC email addresses",
+    }),
+    sender: Flags.boolean({
+      description: "add sender to CC",
+      default: false,
+    }),
+    drip: Flags.boolean({
+      description: "drip delivery or deliver as fast as possible",
+      default: false,
+    }),
+  };
+
+  updateMtt = async (flags) => {
+    const Query = gql`
+mutation (
+$id: Int,
+$name: String
+$mtt: CampaignMttInput!
+) {
+  updateCampaign (id:$id, name: $name, input: { mtt: $mtt }) {
+    id, name
+          ...Mtt
+        }
+        ${FragmentMtt}
+      }
+    `;
+
+    const testEmail = flags.email || `campaign+${flags.name}@proca.app`;
+
+    const [startPeriod, endPeriod] = flags.period.split("-");
+    const [startHour, startMinute] = startPeriod.split(":");
+    const [endHour, endMinute] = endPeriod.split(":");
+
+    const mtt = {
+      testEmail,
+    };
+
+    if (flags.template) mtt.messageTemplate = flags.template;
+    if (flags.email) mtt.testEmail = testEmail;
+    if (flags.cc) mtt.ccContacts = flags.cc.split(",").map((e) => e.trim());
+    if (flags.sender) mtt.ccSender = flags.sender;
+
+    if (flags.from) {
+      const startAt = new Date(flags.from);
+      startAt.setHours(startHour, startMinute, 0, 0);
+      mtt.startAt = startAt.toISOString();
+    }
+
+    if (flags.to) {
+      const endAt = new Date(flags.to);
+      endAt.setHours(endHour, endMinute, 0, 0);
+      mtt.endAt = endAt.toISOString();
+    }
+
+    const result = await mutation(Query, {
+      id: flags.id,
+      name: flags.name,
+      mtt,
+    });
+    return result.updateCampaign;
+  };
+
+  simplify = (d) => {
+    const result = { id: d.id, Name: d.name };
+    const hhmm = (date) =>
+      new Date(date).toLocaleTimeString(undefined, {
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+      });
+    if (d.mtt.startAt && d.mtt.endAt) {
+      result.from = d.mtt.startAt.substring(0, 10);
+      result.to = d.mtt.endAt.substring(0, 10);
+      result.period = `${hhmm(d.mtt.startAt)}↔${hhmm(d.mtt.endAt)}`;
+    }
+    result["test email"] = d.mtt.testEmail;
+    result["mtt template"] = d.mtt.messageTemplate;
+    if (d.mtt.ccContacts?.length)
+      result["cc contacts"] = d.mtt.ccContacts.join(", ");
+    if (typeof d.mtt.ccSender !== "undefined") {
+      result["cc sender"] = d.mtt.ccSender ? "yes" : "no";
+    }
+
+    return result;
+  };
+
+  table = (r) => {
+    super.table(r, null, null);
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+    const result = await this.updateMtt(flags);
+    this.output(result);
+  }
+}

package/src/commands/campaign/queries.graphql

@@ -0,0 +1,19 @@
+query SearchCampaigns($name: String!) {
+  campaigns(name: $name) {
+    id
+    name
+    title
+    config
+  }
+}
+
+query GetOrgCampaigns($org: String!) {
+  org(name: $org) {
+    campaigns {
+      id
+      name
+      title
+      config
+    }
+  }
+}

package/src/commands/campaign/status.mjs

@@ -0,0 +1,63 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import { gql, mutation } from "#src/urql.mjs";
+
+export default class CampaignStatus extends Command {
+  static args = this.multiid();
+  static aliases = ["campaign:close"];
+
+  static examples = [
+    "<%= config.bin %> <%= command.id %> -name <campaign>",
+    "<%= config.bin %> <%= command.id %> -i <campaign_id>",
+  ];
+
+  static isCloseCommand =
+    process.argv.includes("close") ||
+    this.commandPath?.includes("close") ||
+    this.id?.includes("close");
+
+  static flags = {
+    status: Flags.string({
+      ...this.flagify({ multiid: true }),
+      description: "Status to set",
+      required: true,
+      default: this.isCloseCommand ? "close" : undefined,
+      options: ["draft", "live", "closed", "ignored"],
+    }),
+  };
+
+  updateStatus = async (props) => {
+    const Query = gql`
+mutation (
+$id: Int,
+$name: String
+$status: String!
+) {
+  updateCampaign (id:$id, input: { name: $name,status: $status }) {
+    name
+    org {name}
+    status
+    title
+  }
+}
+    `;
+
+    const result = await mutation(Query, {
+      //			org: props.org,
+      id: props.id,
+      name: props.name,
+      status: props.status.toUpperCase(),
+    });
+
+    console.log("result", result);
+    return result.updateCampaign;
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+
+    const data = await this.updateStatus(flags);
+    return this.output(data);
+  }
+}

package/src/commands/campaign/widget/archive.mjs

@@ -0,0 +1,124 @@
+import { Flags } from "@oclif/core";
+import prompts from "prompts";
+import CampaignGet from "#src/commands/campaign/get.mjs";
+import WidgetList from "#src/commands/widget/list.mjs";
+import WidgetUpdate from "#src/commands/widget/update.mjs";
+import Command from "#src/procaCommand.mjs";
+
+export default class CampaignWidgetArchive extends Command {
+  static args = this.multiid(); // Add this!
+
+  static description = "Archive all widgets in the campaign by adding suffix";
+
+  static examples = [
+    "<%= config.bin %> <%= command.id %> old_campaign",
+    "<%= config.bin %> <%= command.id %> -n old_campaign --suffix _backup",
+    "<%= config.bin %> <%= command.id %> old_campaign --dry-run",
+  ];
+
+  static flags = {
+    ...this.flagify({ multiid: true }),
+    suffix: Flags.string({
+      char: "s",
+      description: "custom suffix to append (default: _archive)",
+      helpValue: "<suffix>",
+      default: "_archive",
+    }),
+    "dry-run": Flags.boolean({
+      description: "preview changes without executing",
+      default: false,
+    }),
+  };
+
+  fetchCampaign = async ({ id, name }) => {
+    const campaignGet = new CampaignGet([], this.config);
+    return await campaignGet.fetch({ id, name });
+  };
+
+  fetchWidgets = async (campaignName) => {
+    const widgetList = new WidgetList([], this.config);
+    widgetList.flags = { campaign: campaignName, config: true };
+    return await widgetList.fetchCampaign(campaignName);
+  };
+
+  async run() {
+    const { flags } = await this.parse();
+    const { id, name, suffix, "dry-run": dryRun } = flags;
+
+    this.log(`Fetching source campaign: ${name || id}`);
+    const campaign = await this.fetchCampaign({ id, name });
+
+    if (!campaign) {
+      this.error("Campaign not found");
+      return;
+    }
+
+    this.log(`Fetching widgets for campaign: ${campaign.name}`);
+    const widgets = await this.fetchWidgets(campaign.name);
+
+    if (!widgets || widgets.length === 0) {
+      this.warn("No widgets found for this campaign");
+      return;
+    }
+
+    this.log(`Found ${widgets.length} widgets`);
+
+    const renameList = widgets.map((widget) => ({
+      id: widget.id,
+      oldName: widget.name,
+      newName: `${widget.name}${suffix}`,
+      locale: widget.locale,
+    }));
+
+    this.log("\nArchive plan:");
+    this.table(renameList);
+
+    if (dryRun) {
+      this.log("\n[DRY RUN] No changes made");
+      return renameList;
+    }
+
+    // Confirm before proceeding
+    const response = await prompts({
+      type: "confirm",
+      name: "proceed",
+      message: `Archive ${renameList.length} widgets by adding suffix "${suffix}"?`,
+      initial: false,
+    });
+
+    if (!response.proceed) {
+      this.log("Cancelled");
+      return;
+    }
+
+    const widgetUpdate = new WidgetUpdate([], this.config);
+    const results = [];
+
+    for (const item of renameList) {
+      try {
+        this.log(`Archiving: ${item.oldName} → ${item.newName}`);
+        const input = {
+          name: item.newName,
+          locale: item.locale,
+        };
+        const result = await widgetUpdate.update(item.id, input);
+        results.push({
+          id: result.id,
+          name: result.name,
+          status: "success",
+        });
+      } catch (error) {
+        this.error(`Failed to archive ${item.oldName}: ${error.message}`);
+        results.push({
+          id: item.id,
+          name: item.oldName,
+          status: "failed",
+          error: error.message,
+        });
+      }
+    }
+
+    this.log("\nArchive complete!");
+    return this.output(results);
+  }
+}