proca 1.7.3 → 1.7.5

package/README.md

@@ -209,24 +209,24 @@ EXAMPLES
 ```
 USAGE
   $ proca action list [TITLE] -o <organisation name> [--json | --human | --csv] [--env
-    <value>] [-c <campaign title>] [--limit <value>] [--today | --after 2025-04-09] [--optin] [--testing] [--doi] [--utm
+    <value>] [-c <campaign name>] [--limit <value>] [--today | --after 2025-04-09] [--optin] [--testing] [--doi] [--utm
     | --simplify] [--comment | ]
 
 ARGUMENTS
   TITLE  name of the campaign, % for wildchar
 
 FLAGS
-  -c, --campaign=<campaign title>  name of the campaign, % for wildchar
-  -o, --org=<organisation name>    (required) campaigns of the organisation (coordinator or partner)
-      --after=2025-04-09           only actions after a date
-      --[no-]comment               display the comment
-      --doi                        only export the double optin actions
-      --env=<value>                [default: default] allow to switch between configurations (server or users)
-      --limit=<value>              max number of actions
-      --optin                      only export the optin actions
-      --testing                    also export the test actions
-      --today                      only actions today
-      --[no-]utm                   display the utm tracking parameters
+  -c, --campaign=<campaign name>  name of the campaign, % for wildchar
+  -o, --org=<organisation name>   (required) campaigns of the organisation (coordinator or partner)
+      --after=2025-04-09          only actions after a date
+      --[no-]comment              display the comment
+      --doi                       only export the double optin actions
+      --env=<value>               [default: default] allow to switch between configurations (server or users)
+      --limit=<value>             max number of actions
+      --optin                     only export the optin actions
+      --testing                   also export the test actions
+      --today                     only actions today
+      --[no-]utm                  display the utm tracking parameters
 
 OUTPUT FLAGS
   --csv            Format output as csv
@@ -262,18 +262,28 @@ EXAMPLES
 
 ## `proca action requeue`
 
-requeue an action
+requeue actions
 
 ```
 USAGE
-  $ proca action requeue --id <value> -o <org name> -q <user email> [--json | --human |
-    --csv] [--env <value>] [--simplify]
+  $ proca action requeue -o <org name> -q
+    CUSTOM_ACTION_CONFIRM|CUSTOM_ACTION_DELIVER|CUSTOM_SUPPORTER_CONFIRM|EMAIL_SUPPORTER|SQS|WEBHOOK [--json | --human |
+    --csv] [--env <value>] [--simplify] [-c <campaign name>] [--limit <value>] [--today | --after 2025-04-09] [--optin]
+    [--testing] [--doi]
 
 FLAGS
-  -o, --org=<org name>      (required) name of the org
-  -q, --queue=<user email>  (required) queue to redeliver to
-      --env=<value>         [default: default] allow to switch between configurations (server or users)
-      --id=<value>          (required) action id
+  -c, --campaign=<campaign name>  name of the campaign, % for wildchar
+  -o, --org=<org name>            (required) name of the org
+  -q, --queue=<option>            (required) [default: CUSTOM_ACTION_DELIVER] queue to redeliver to
+                                  <options: CUSTOM_ACTION_CONFIRM|CUSTOM_ACTION_DELIVER|CUSTOM_SUPPORTER_CONFIRM|EMAIL_S
+                                  UPPORTER|SQS|WEBHOOK>
+      --after=2025-04-09          only actions after a date
+      --doi                       only export the double optin actions
+      --env=<value>               [default: default] allow to switch between configurations (server or users)
+      --limit=<value>             [default: 1000] how many actions per page
+      --optin                     only export the optin actions
+      --testing                   also export the test actions
+      --today                     only actions today
 
 OUTPUT FLAGS
   --csv            Format output as csv
@@ -282,7 +292,7 @@ OUTPUT FLAGS
   --[no-]simplify  flatten and filter to output only the most important attributes, mostly relevant for json
 
 DESCRIPTION
-  requeue an action
+  requeue actions
 
 EXAMPLES
   $ proca action requeue
@@ -435,20 +445,22 @@ set the mail to target (mtt) params
 
 ```
 USAGE
-  $ proca campaign mtt [ID_NAME_DXID] --from <value> --to <value> [--json | --human |
-    --csv] [--env <value>] [--simplify] [-i <value> | -n <the_short_name> | -x <value>] [--template <value>] [--period
-    <value>] [--email <value>]
+  $ proca campaign mtt [ID_NAME_DXID] [--json | --human | --csv] [--env <value>]
+    [--simplify] [-i <value> | -n <the_short_name> | -x <value>] [--from <value>] [--to <value>] [--template <value>]
+    [--period <value>] [--email <value>] [--cc <value>] [--sender]
 
 FLAGS
   -i, --id=<value>
   -n, --name=<the_short_name>  name
   -x, --dxid=<value>           dxid
+      --cc=<value>             comma-separated list of CC email addresses
       --email=<value>          test email address
       --env=<value>            [default: default] allow to switch between configurations (server or users)
-      --from=<value>           (required) start date (yyyy-mm-dd)
+      --from=<value>           start date (yyyy-mm-dd)
       --period=<value>         [default: 09:09-18:18] period of the day (HH:HH-HH:HH)
+      --sender                 add sender to CC
       --template=<value>       mtt template to use
-      --to=<value>             (required) end date (yyyy-mm-dd)
+      --to=<value>             end date (yyyy-mm-dd)
 
 OUTPUT FLAGS
   --csv            Format output as csv

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "proca",
 	"description": "Access the proca api",
-	"version": "1.7.3",
+	"version": "1.7.5",
 	"author": "Xavier",
 	"bin": {
 		"proca": "proca-cli"

package/src/commands/action/list.mjs

@@ -30,7 +30,7 @@ export default class List extends Command {
 		campaign: Flags.string({
 			char: "c",
 			description: "name of the campaign, % for wildchar",
-			helpValue: "<campaign title>",
+			helpValue: "<campaign name>",
 		}),
 		limit: Flags.string({
 			description: "max number of actions",

package/src/commands/action/replay.mjs

@@ -48,6 +48,8 @@ options: [
 		const { args, flags } = await this.parse();
 		let data = [];
 		const ids = [];
+		this.fatal("not implemented yet");
+		process.exit(1);
 		data = await this.mutate(flags.org, ids, flags.queue);
 		return this.output(data);
 	}

package/src/commands/action/requeue.mjs

@@ -1,50 +1,147 @@
 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";
+import { gql, mutation, query } from "#src/urql.mjs";
 
 export default class ActionRequeue extends Command {
-	static description = "requeue an action";
+	static description = "requeue actions";
 
 	static examples = ["<%= config.bin %> <%= command.id %>"];
 
 	static flags = {
 		...super.globalFlags,
-		id: Flags.string({
-			description: "action id",
-			parse: (input) => Number.parseInt(input, 10),
-			required: true,
-		}),
 		org: Flags.string({
 			char: "o",
 			required: true,
 			description: "name of the org",
 			helpValue: "<org name>",
 		}),
+		campaign: Flags.string({
+			char: "c",
+			description: "name of the campaign, % for wildchar",
+			helpValue: "<campaign name>",
+		}),
 		queue: Flags.string({
 			char: "q",
 			required: true,
 			description: "queue to redeliver to",
-			helpValue: "<user email>",
+			default: "CUSTOM_ACTION_DELIVER",
+			options: [
+				"CUSTOM_ACTION_CONFIRM",
+				"CUSTOM_ACTION_DELIVER",
+				"CUSTOM_SUPPORTER_CONFIRM",
+				"EMAIL_SUPPORTER",
+				"SQS",
+				"WEBHOOK",
+			],
+		}),
+		limit: Flags.string({
+			description: "how many actions per page",
+			default: 1000,
+			parse: (input) => Number.parseInt(input, 10),
+		}),
+		after: Flags.string({
+			description: "only actions after a date",
+			helpValue: "2025-04-09",
+			parse: (input) => new Date(input).toISOString(),
+		}),
+		today: Flags.boolean({
+			description: "only actions today",
+			exclusive: ["after"],
+			parse: (input) => `${new Date().toISOString().split("T")[0]}T00:00:00Z`,
+		}),
+		optin: Flags.boolean({
+			description: "only export the optin actions",
+			default: false,
+		}),
+		testing: Flags.boolean({
+			description: "also export the test actions",
+			default: false,
 		}),
+		doi: Flags.boolean({
+			description: "only export the double optin actions",
+			default: false,
+		}),
+	};
+
+	process = async (flags) => {
+		let page = 0;
+		let actions = 0;
+		let requeued = 0;
+		let error = 0;
+		while (true) {
+			const ids = await this.fetch(flags);
+			if (ids.length === 0) break;
+			const result = await this.requeue(flags.org, flags.queue, ids);
+			requeued += result.count;
+			error += result.failed;
+			flags.start = ids[ids.length - 1] + 1;
+			process.stdout.write(`\rrequeued ${requeued}, id> ${flags.start}`);
+			page += 1;
+			actions += ids.length;
+		}
+		process.stdout.write("\r\x1b[K");
+		return { pages: page, actions, requeued, error };
 	};
 
-	mutate = async (org) => {
+	fetch = async (flags) => {
 		const Document = gql`
-mutation ($user: String!, $role: String!, $org: String!, message: String) {
-  inviteOrgUser(orgName: $org,  message: $message, input :{ email: $user, role: $role}) {
-      objectId
-      code
-  }
-}
+      query (
+        $after: DateTime
+        $campaignId: Int
+        $campaignName: String
+        $includeTesting: Boolean
+        $limit: Int
+        $onlyDoubleOptIn: Boolean
+        $onlyOptIn: Boolean
+        $orgName: String!
+        $start: Int
+      ) {
+        actions (
+          after: $after
+          campaignId: $campaignId
+          campaignName: $campaignName
+          includeTesting: $includeTesting
+          limit: $limit
+          onlyDoubleOptIn: $onlyDoubleOptIn
+          onlyOptIn: $onlyOptIn
+          orgName: $orgName
+          start: $start
+        ) {
+          actionId
+          }
+      }
     `;
+		const result = await query(Document, {
+			after: flags.after,
+			campaignName: flags.campaign,
+			includeTesting: flags.testing,
+			limit: flags.limit,
+			onlyDoubleOptIn: flags.doi,
+			onlyOptIn: flags.optin,
+			orgName: flags.org,
+			start: flags.start,
+		});
+		const ids = [];
+		result.actions.forEach((d) => ids.push(d.actionId));
+		return ids;
+	};
+
+	requeue = async (org, queue, ids) => {
+		const Document = gql`
+mutation ($ids: [Int!], $org: String!, $queue: Queue!) {
+  requeueActions(ids: $ids, orgName: $org, queue: $queue) {
+    count
+    failed
+  }
+}`;
 		const result = await mutation(Document, {
 			org,
-			role,
-			user,
+			queue,
+			ids,
 		});
 		//return result.users.map (d => {d.config = JSON.parse(d.config); return d});
-		return result.inviteOrg;
+		return result.requeueActions;
 	};
 
 	table = (r) => {
@@ -52,9 +149,8 @@ mutation ($user: String!, $role: String!, $org: String!, message: String) {
 	};
 
 	async run() {
-		throw new Error("NOT IMPLEMENTED");
 		const { args, flags } = await this.parse();
-		const data = await this.mutate(flag);
+		const data = await this.process(flags);
 		this.output(data);
 	}
 }

package/src/commands/campaign/get.mjs

@@ -83,6 +83,8 @@ export default class CampaignGet extends Command {
 			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;
 		}
 		if (this.flags.stats) {
 			result["#Supporters"] = d.stats.supporterCount;

package/src/commands/campaign/mtt.mjs

@@ -17,11 +17,11 @@ export default class CampaignMtt extends Command {
 		...this.flagify({ multiid: true }),
 		from: Flags.string({
 			description: "start date (yyyy-mm-dd)",
-			required: true,
+			required: false,
 		}),
 		to: Flags.string({
 			description: "end date (yyyy-mm-dd)",
-			required: true,
+			required: false,
 		}),
 		template: Flags.string({
 			description: "mtt template to use",
@@ -33,6 +33,13 @@ export default class CampaignMtt extends Command {
 		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,
+		}),
 	};
 
 	updateMtt = async (flags) => {
@@ -45,53 +52,67 @@ $mtt: CampaignMttInput!
   updateCampaign (id:$id, name: $name, input: { mtt: $mtt }) {
     id, name
           ...Mtt
-  }
-      ${FragmentMtt}
-}
+        }
+        ${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 startAt = new Date(flags.from);
-		startAt.setHours(startHour, startMinute, 0, 0);
+		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;
 
-		const endAt = new Date(flags.to);
-		endAt.setHours(endHour, endMinute, 0, 0);
+		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, {
-			//			org: props.org,
 			id: flags.id,
 			name: flags.name,
-			mtt: {
-				startAt: startAt.toISOString(),
-				endAt: endAt.toISOString(),
-				messageTemplate: flags.template,
-				testEmail: testEmail,
-			},
+			mtt,
 		});
-
 		return result.updateCampaign;
 	};
 
 	simplify = (d) => {
-		const result = {
-			id: d.id,
-			Name: d.name,
-		};
+		const result = { id: d.id, Name: d.name };
 		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)}`;
+		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.template;
+		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;
 	};
 
@@ -101,7 +122,6 @@ $mtt: CampaignMttInput!
 
 	async run() {
 		const { args, flags } = await this.parse();
-
 		const result = await this.updateMtt(flags);
 		this.output(result);
 	}

package/src/commands/widget/add.mjs

@@ -60,6 +60,9 @@ export default class WidgetAdd extends Command {
 				const campapi = new CampaignGet();
 				campaign = await campapi.fetch({ name: flag.campaign });
 				flag.org = campaign.org.name;
+				if (!flag.name) {
+					flag.name = `${campaign.name}/${flag.lang}`;
+				}
 			} catch (e) {
 				console.log("error", e);
 				throw e;
@@ -70,6 +73,9 @@ export default class WidgetAdd extends Command {
 			throw new Error(`campaign not found: ${flag.campaign}`);
 		}
 
+		if (!flag.name) {
+			flag.name = `${flag.campaign}/${flag.org}/${flag.lang}`;
+		}
 		try {
 			const r = await mutation(addWidgetDocument, flag);
 			return { id: r.addActionPage.id };

package/src/queries/campaign.mjs

@@ -9,6 +9,8 @@ export const FragmentMtt = gql`
           endAt
           messageTemplate
           testEmail
+          ccContacts
+          ccSender
         }
       }
     `;