proca 2.2.1 → 2.5.0

package/src/commands/campaign/status.mjs

@@ -8,8 +8,7 @@ export default class CampaignStatus extends Command {
   static aliases = ["campaign:close"];
 
   static examples = [
-    "<%= config.bin %> <%= command.id %> -name <campaign>",
-    "<%= config.bin %> <%= command.id %> -i <campaign_id>",
+    "<%= config.bin %> <%= command.id %> -name <campaign> --end=2025-01-02 --status=close",
   ];
 
   static isCloseCommand =
@@ -18,46 +17,72 @@ export default class CampaignStatus extends Command {
     this.id?.includes("close");
 
   static flags = {
+    ...this.flagify({ name: "campaign" }),
     status: Flags.string({
-      ...this.flagify({ multiid: true }),
       description: "Status to set",
       required: true,
       default: this.isCloseCommand ? "close" : undefined,
       options: ["draft", "live", "closed", "ignored"],
     }),
+    start: Flags.string({
+      description: "start date of the campaign",
+      helpValue: "YYYY-MM-DD",
+      parse: async (input) => {
+        const date = new Date(input);
+        if (Number.isNaN(date.getTime())) {
+          throw new Error(`Invalid date: ${input}`);
+        }
+        return date;
+      },
+    }),
+    end: Flags.string({
+      description: "end date of the campaign",
+      helpValue: "YYYY-MM-DD",
+      parse: async (input) => {
+        const date = new Date(input);
+        if (Number.isNaN(date.getTime())) {
+          throw new Error(`Invalid date: ${input}`);
+        }
+        return date;
+      },
+    }),
   };
 
   updateStatus = async (props) => {
     const Query = gql`
 mutation (
-$id: Int,
+$id: Int
 $name: String
-$status: String!
+$input: CampaignInput!
 ) {
-  updateCampaign (id:$id, input: { name: $name,status: $status }) {
+  updateCampaign (id:$id, name: $name, input: $input) {
     name
     org {name}
     status
+    start
+    end
     title
   }
-}
-    `;
+}`;
+    const input = {
+      status: props.status.toUpperCase(),
+    };
 
     const result = await mutation(Query, {
       //			org: props.org,
       id: props.id,
       name: props.name,
-      status: props.status.toUpperCase(),
+      input: input,
     });
 
-    console.log("result", result);
     return result.updateCampaign;
   };
 
   async run() {
-    const { args, flags } = await this.parse();
+    const { flags } = await this.parse();
 
     const data = await this.updateStatus(flags);
-    return this.output(data);
+
+    return this.output(data, { single: true });
   }
 }

package/src/commands/contact/delete.mjs

@@ -0,0 +1,43 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import { formatDistanceToNowStrict } from "date-fns";
+import Command from "#src/procaCommand.mjs";
+import {
+  FragmentOrg,
+  FragmentStats,
+  FragmentSummary,
+} from "#src/queries/campaign.mjs";
+import { gql, mutation } from "#src/urql.mjs";
+
+export default class Delete extends Command {
+  static flags = {
+    ...this.flagify({ name: "org", char: "o" }),
+    ref: Flags.string({
+      char: "c",
+      required: true,
+      description: "contact reference",
+      helpValue: "from contact get",
+    }),
+  };
+
+  delete = async (ref, org) => {
+    const DeleteDocument = gql`mutation delete($ref: String!, $org: String!) {
+  deleteContact (contactRef: $ref, orgName: $org) 
+}`;
+
+    const r = await mutation(DeleteDocument, {
+      ref,
+      org,
+    });
+    if (r.errors) {
+      throw new Error(r.errors[0].message || "can't delete");
+    }
+    return r;
+  };
+
+  async run() {
+    const { flags } = await this.parse();
+    const data = await this.delete(flags.ref, flags.name);
+    return this.output(data);
+  }
+}

package/src/commands/contact/get.mjs

@@ -0,0 +1,137 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import { formatDistanceToNowStrict } from "date-fns";
+import Command from "#src/procaCommand.mjs";
+import {
+  FragmentOrg,
+  FragmentStats,
+  FragmentSummary,
+} from "#src/queries/campaign.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class Get extends Command {
+  static flags = {
+    ...this.flagify({ name: "org", char: "o" }),
+    email: Flags.string({
+      char: "e",
+      required: true,
+      description: "email of the supporter",
+      helpValue: "<supporter@example.org>",
+    }),
+    utm: Flags.boolean({
+      description: "display the utm tracking parameters",
+      default: true,
+      allowNo: true,
+      exclusive: ["simplify"],
+    }),
+    comment: Flags.boolean({
+      description: "display the comment",
+      default: true,
+      allowNo: true,
+      exclusive: ["simplify"],
+    }),
+  };
+
+  fetch = async (flags) => {
+    const Document = gql`
+      query (
+        $orgName: String!
+        $email: String!
+      ) {
+        contacts(
+          orgName: $orgName
+          email: $email
+        ) {
+          actionId
+          actionPage {
+            id
+            locale
+            name
+          }
+          actionType
+          campaign {
+            name
+          }
+          contact {
+            contactRef
+            payload
+            nonce
+            publicKey {
+              public
+            }
+          }
+          createdAt
+          customFields
+          privacy {
+            emailStatus
+            emailStatusChanged
+            givenAt
+            optIn
+            withConsent
+          }
+          tracking {
+            campaign
+            content
+            medium
+            source
+          }
+        }
+      }
+    `;
+    const result = await query(Document, {
+      orgName: flags.name,
+      email: flags.email,
+    });
+    return result.contacts.map((d) => {
+      d.customFields = JSON.parse(d.customFields);
+      if (!d.contact.publicKey) {
+        const ref = d.contact.contactRef;
+        d.contact = JSON.parse(d.contact.payload);
+        d.contact.contactRef = ref;
+      } else {
+        this.error(
+          `encrypted contact we need the private key for ${d.contact.publicKey.public}`,
+        );
+      }
+      return d;
+    });
+    //		return result.exportActions;
+  };
+
+  simplify = (d) => {
+    const result = {
+      contactRef: d.contact.contactRef,
+      firstname: d.contact.firstName,
+      country: d.contact.country,
+      email: d.contact.email,
+      type: d.actionType,
+      date: formatDistanceToNowStrict(d.createdAt),
+      campaign: !this.flags.campaign && d.campaign.name,
+      widget_id: d.actionPage.id,
+      widget: d.actionPage.name,
+      //            customFields
+    };
+    if (this.flags.comment && d.customFields?.comment)
+      result.comment = d.customFields.comment;
+    if (this.flags.utm && d.tracking) {
+      result.utm_medium =
+        d.tracking.medium === "unknown" ? undefined : d.tracking.medium;
+      result.utm_source =
+        d.tracking.source === "unknown" ? undefined : d.tracking.source;
+      result.utm_campaign =
+        d.tracking.campaign === "unknown" ? undefined : d.tracking.campaign;
+      if (d.tracking.content)
+        result.utm_content =
+          d.tracking.content === "unknown" ? undefined : d.tracking.content;
+    }
+    if (d.customFields?.emailProvider)
+      result.provider = d.customFields.emailProvider;
+    return result;
+  };
+
+  async run() {
+    const { flags } = await this.parse();
+    const data = await this.fetch(flags);
+    return this.output(data, { single: true });
+  }
+}

package/src/commands/contact/list.mjs

@@ -12,18 +12,9 @@ import { gql, query } from "#src/urql.mjs";
 export default class List extends Command {
   actionTypes = new Set();
 
-  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)",
-      required: true,
-      //			exactlyOne: ["org", "title"],
-      helpValue: "<organisation name>",
-    }),
+    ...this.flagify({ name: "org", char: "o" }),
     campaign: Flags.string({
       char: "c",
       description: "name of the campaign, % for wildchar",
@@ -138,7 +129,7 @@ export default class List extends Command {
       limit: flags.limit,
       onlyDoubleOptIn: flags.doi,
       onlyOptIn: flags.optin,
-      orgName: flags.org,
+      orgName: flags.name,
       start: flags.start,
     });
     return result.contacts.map((d) => {

package/src/commands/org/get.mjs

@@ -18,13 +18,7 @@ export default class OrgGet extends Command {
 
   static flags = {
     // flag with no value (-f, --force)
-    ...this.flagify({ multiid: false }),
-    name: Flags.string({
-      char: "n",
-      charAliases: ["o"],
-      description: "name of the org",
-      helpValue: "<org name>",
-    }),
+    ...this.flagify({ multiid: false, name: "org", char: "o" }),
     config: Flags.boolean({
       description: "display the config",
       default: false,
@@ -113,8 +107,10 @@ export default class OrgGet extends Command {
   simplify = (d) => {
     const result = {
       id: d.id,
-      Name: d.name,
-      Title: d.title,
+      name: d.name,
+      title: d.title,
+      url: d.config?.url,
+      logo: d.config?.logo,
       "can targets reply?": d.replyEnabled ? true : undefined,
       "confirm actions?": d.supporterConfirm
         ? d.supporterConfirmTemplate
@@ -142,9 +138,7 @@ export default class OrgGet extends Command {
   };
 
   async run() {
-    console.log("starting");
     const { flags } = await this.parse();
-    console.log("flags", this.Flags);
 
     const data = await this.fetch(flags);
     return this.output(data);

package/src/commands/org/logo.js

@@ -0,0 +1,116 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+//import {FragmentSummary,} from "#src/queries/org.mjs";
+import { gql, mutation } from "#src/urql.mjs";
+import { getOrg } from "./get.mjs";
+
+export default class OrgLogo extends Command {
+  static description = "add a logo to the org";
+
+  static examples = ["<%= config.bin %> <%= command.id %> <name of the ngo>"];
+
+  static args = this.multiid();
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...this.flagify({ multiid: false, name: "org", char: "o" }),
+    url: Flags.string({
+      description: "use that url (and update it)",
+    }),
+    update: Flags.boolean({
+      default: true,
+      allowNo: true,
+      description: "use that url (and update it)",
+    }),
+  };
+
+  toProxyUrl = (pic) => {
+    const url = new URL(pic);
+    if (!url.hostname.endsWith("gstatic.com")) return googleUrl;
+    const sub = url.hostname.split(".")[0];
+    const domain = new URL(url.searchParams.get("url")).hostname;
+    return `https://pic.proca.app/favicon/${sub}/${domain}`;
+  };
+
+  fetchLogoUrl = async (domain) => {
+    const res = await fetch(
+      `https://www.google.com/s2/favicons?sz=128&domain=${domain}`,
+      { redirect: "manual" }, // don't follow — we want the Location header
+    );
+    const location = res.headers.get("location");
+    if (!location) throw new Error(`No redirect for ${domain}`);
+    return this.toProxyUrl(location);
+  };
+  update = async ({ name, config }) => {
+    const input = {};
+
+    input.config = typeof config === "string" ? config : JSON.stringify(config);
+
+    const Document = gql`
+      mutation update(
+        $orgName: String!
+        $input: OrgInput!
+      ) {
+        updateOrg(
+          name: $orgName
+          input: $input
+        ) {
+          id, name, config
+        }
+      }
+    `;
+
+    try {
+      console.log({
+        orgName: name,
+        input,
+      });
+      const r = await mutation(Document, {
+        orgName: name,
+        input,
+      });
+      return { id: r.updateOrg };
+    } catch (e) {
+      const err = e.graphQLErrors?.[0];
+
+      if (err?.extensions?.code === "permission_denied") {
+        this.error(`permission denied to update org ${name}`);
+      }
+      throw new Error(err?.message ?? "failed to update org");
+    }
+  };
+
+  table = (r) => {
+    super.table(r, null, null);
+    if (this.flags.config) {
+      r.config.locales = undefined;
+      this.prettyJson(r.config);
+    }
+  };
+
+  async run() {
+    const { flags } = await this.parse();
+    let logo;
+    let org;
+    if (flags.url) {
+      logo = await this.fetchLogoUrl(flags.url);
+    }
+    try {
+      org = await getOrg(flags);
+    } catch (e) {
+      this.output({ error: "user not a member of org", org: flags.name, logo });
+      return;
+    }
+    if (!logo) logo = await this.fetchLogoUrl(org.config.url);
+    org.config.logo = logo;
+    if (flags.update) {
+      if (!org.config.url) {
+        org.config.url = flags.url;
+      }
+      const r = this.update({ name: flags.name, config: org.config });
+      return this.output(r);
+    }
+    return this.output({ logo, name: flags.name });
+  }
+}

package/src/commands/service/add.mjs

@@ -1,6 +1,6 @@
 import { Flags } from "@oclif/core";
 import Command from "#src/procaCommand.mjs";
-import { gql, mutation, query } from "#src/urql.mjs";
+import { gql, mutation } from "#src/urql.mjs";
 
 const SERVICE_NAMES = [
   "MAILJET",
@@ -14,9 +14,19 @@ const SERVICE_NAMES = [
   "SMTP",
 ].map((d) => d.toLowerCase());
 
-export default class OrgEmail extends Command {
+export default class ServiceAdd extends Command {
   static description =
-    "Set service, usually email backend for an org, the specific meaning of each param is dependant on the service";
+    "Set service, usually email backend for an org. the specific meaning of each param is dependant on the service. \nIf a service from that type exists, it will replace it";
+
+  // examples to add to help
+  // <%= config.bin %> resolves to the executable name
+  // <%= command.id %> resolves to the command name
+  static examples = [
+    // Examples can be simple strings
+    "<%= config.bin %> <%= command.id %> -o example_org --type system",
+    '<%= config.bin %> <%= command.id %> -o example_org --host=tls://mail.example.org:587 --user=login --password "secret" --type smtp',
+    '<%= config.bin %> <%= command.id %> -o example_org --host=ssl://mail.example.org:465 --user=login --password "secret" --type smtp',
+  ];
 
   static flags = {
     ...super.globalFlags,
@@ -29,7 +39,6 @@ export default class OrgEmail extends Command {
       description: "type of the service",
       options: SERVICE_NAMES,
       required: true,
-      default: "system",
     }),
     user: Flags.string({
       description: "credential of the account on the service",
@@ -37,7 +46,7 @@ export default class OrgEmail extends Command {
     password: Flags.string({
       description: "credential of the account on the service",
     }),
-    host: Flags.string({
+    host: Flags.url({
       description: "server of the service",
     }),
     path: Flags.string({

package/src/commands/user/join.mjs

@@ -8,22 +8,19 @@ export default class UserJoinOrg extends Command {
 
   static examples = ["<%= config.bin %> <%= command.id %>"];
 
+  static args = this.multiid();
+
   static flags = {
-    ...super.globalFlags,
+    // flag with no value (-f, --force)
+    ...this.flagify({ multiid: false, name: "org", char: "o" }),
     role: Flags.string({
       description: "permission level in that org",
       default: "campaigner",
       options: ["owner", "campaigner", "coordinator", "translator"],
     }),
-    org: Flags.string({
-      char: "o",
-      required: true,
-      description: "name of the org",
-      helpValue: "<org name>",
-    }),
     user: Flags.string({
       char: "u",
-      description: "email",
+      description: "email, default current user",
       helpValue: "<user email>",
     }),
   };
@@ -58,7 +55,7 @@ mutation ($org: String!, $user: String!, $role: String = "campaigner") {
     `;
     const result = await mutation(Document, {
       user: params.user,
-      org: params.org,
+      org: params.name,
       role: params.role,
     });
     return result.addOrgUser;
@@ -69,10 +66,10 @@ mutation ($org: String!, $user: String!, $role: String = "campaigner") {
   };
 
   async run() {
-    const { args, flags } = await this.parse();
+    const { flags } = await this.parse();
     let data = undefined;
     if (!flags.user) {
-      data = await this.join(flags.org);
+      data = await this.join(flags.name);
     } else {
       data = await this.mutate(flags);
     }

package/src/commands/widget/external/cron.js

@@ -0,0 +1,63 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Flags } from "@oclif/core";
+import { update } from "#src/commands/widget/external/index.mjs";
+import Command from "#src/procaCommand.mjs";
+
+export default class CounterExternal extends Command {
+  static description =
+    "Pull all external counters and save it into a widget extra Supporter. symlink the widget json into config/counter";
+
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+
+  static flags = {
+    "dry-run": Flags.boolean({
+      description: "just fetch, don't update",
+    }),
+  };
+
+  async monitored() {
+    const dir = path.join(this.config.procaConfig.folder, "/counter");
+    try {
+      await fs.access(dir);
+    } catch {
+      this.error(`create the folder ${dir}`);
+    }
+    const entries = await fs.readdir(dir);
+    const results = await Promise.all(
+      entries.map(async (entry) => {
+        const file = entry.split(".");
+        if (file.length !== 2) {
+          this.warn(`invalid file ${entry}`);
+          return;
+        }
+        if (file[1] !== "json") {
+          this.warn(`should be a json file ${entry}`);
+          return;
+        }
+        const content = JSON.parse(
+          await fs.readFile(path.join(dir, entry), "utf-8"),
+        );
+        return {
+          id: Number.parseInt(file[0]),
+          name: content.filename,
+          url: content.component.counter?.url,
+          path: content.component.counter?.path,
+        };
+      }),
+    );
+    return results.flat();
+  }
+
+  async run() {
+    const { flags } = await this.parse(CounterExternal);
+    const widgets = await this.monitored();
+    if (flags["dry-run"]) return this.output(widgets);
+    const updated = await Promise.all(
+      widgets.map(async (widget) => {
+        return await update(widget);
+      }),
+    );
+    return this.output(updated);
+  }
+}