proca 0.8.1 → 1.1.5

package/src/commands/widget/add.mjs

@@ -0,0 +1,101 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import CampaignGet from "#src/commands/campaign/get.mjs";
+import Command from "#src/procaCommand.mjs";
+import { gql, mutation } from "#src/urql.mjs";
+
+export default class WidgetAdd extends Command {
+	//static args = { path: { description: "" } };
+
+	static flags = {
+		// flag with no value (-f, --force)
+		...super.globalFlags,
+		campaign: Flags.string({
+			char: "c",
+			required: true,
+			description: "name of the campaign",
+			helpValue: "<campaign name>",
+		}),
+		org: Flags.string({
+			char: "o",
+			description: "organisation",
+			helpValue: "<en>",
+		}),
+		lang: Flags.string({
+			char: "l",
+			description: "language",
+			default: "en",
+			helpValue: "<en>",
+		}),
+		name: Flags.string({
+			char: "n",
+			description: "url slug",
+			helpValue: "by default  <campaign>/<org>/<lang>",
+		}),
+	};
+
+	create = async (flag) => {
+		const orgName = flag.org;
+		let campaign = { org: { name: orgName } }; // no need to fetch the campaign if the orgName is specified
+
+		const addWidgetDocument = gql`
+      mutation addPage(
+        $campaign: String!
+        $org: String!
+        $name: String!
+        $lang: String!
+      ) {
+        addActionPage(
+          campaignName: $campaign
+          orgName: $org
+          input: { name: $name, locale: $lang }
+        ) {
+          id
+        }
+      }
+    `;
+
+		if (!orgName) {
+			try {
+				const campapi = new CampaignGet();
+				campaign = await campapi.fetch({ name: flag.campaign });
+				flag.org = campaign.org.name;
+			} catch (e) {
+				console.log("error", e);
+				throw e;
+			}
+		}
+
+		if (!campaign) {
+			throw new Error(`campaign not found: ${flag.campaign}`);
+		}
+
+		try {
+			const r = await mutation(addWidgetDocument, flag);
+			return r;
+		} catch (e) {
+			const errors = e.graphQLErrors;
+			console.log(errors, flag, addWidgetDocument);
+			if (errors[0].path[1] === "name") {
+				this.error(`invalid name (already taken?): ${flag.name}`);
+				throw new Error(errors[0].message);
+			}
+			if (errors[0].extensions?.code === "permission_denied") {
+				console.error("permission denied to create", name, campaign?.org.name);
+				throw new Error(errors[0].message);
+			}
+			const page = await fetchByName(name);
+			console.warn("duplicate of widget", page.id);
+			throw new Error(errors[0].message);
+		}
+	};
+
+	async run() {
+		const { args, flags } = await this.parse();
+
+		//		const org = { name: flags.twitter || flags.name, config: {} };
+
+		const data = await this.create(flags);
+		return this.output(data);
+	}
+}

package/src/commands/widget/cache.mjs

@@ -0,0 +1,29 @@
+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/widget.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class WidgetGet extends Command {
+	static description = "clear the cdn cache of a widget";
+
+	static examples = [
+		"<%= config.bin %> <%= command.id %> --url https://cdn.proca.app/d/[campaign]/[org]/[locale]",
+		"<%= config.bin %> <%= command.id %> --name [campaign]/[org]/[locale]",
+	];
+	static args = this.multiid();
+
+	static flags = {
+		// flag with no value (-f, --force)
+		...this.flagify({ multiid: true }),
+		url: Flags.string ({
+			description: "url of the widget on the CDN",
+		}),
+	};
+
+	async run() {
+		const { args, flags } = await this.parse();
+console.log(flags);
+	}
+}
+

package/src/commands/widget/get.mjs

@@ -0,0 +1,59 @@
+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/widget.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class WidgetGet extends Command {
+	static description = "view a widget";
+
+	static examples = [
+		"<%= config.bin %> <%= command.id %> <path of the widget>",
+	];
+	static args = this.multiid();
+
+	static flags = {
+		// flag with no value (-f, --force)
+		...this.flagify({ multiid: true }),
+		config: Flags.boolean({
+			description: "display the config",
+			default: true,
+			allowNo: true,
+		}),
+	};
+
+	fetch = async (params) => {
+		const GetWidgetDocument = gql`
+      query GetWidget($name: String, $id: Int, $config: Boolean = true) {
+        actionPage(name: $name, id: $id) {
+          ...Summary
+          org {
+            name
+          }
+          campaign {
+            name
+          }
+          thankYouTemplate
+          config @include(if: $config)
+        }
+      }
+      ${FragmentSummary}
+    `;
+		const result = await query(GetWidgetDocument, params);
+		return result.actionPage;
+	};
+
+	table = (r) => {
+		super.table(r, null, null);
+		if (this.flags.config) {
+			r.config = JSON.parse(r.config);
+			this.prettyJson(r.config);
+		}
+	};
+
+	async run() {
+		const { args, flags } = await this.parse();
+		const data = await this.fetch(flags);
+		return this.output(data);
+	}
+}

package/src/commands/widget/list.mjs

@@ -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/widget.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class WidgetList extends Command {
+	static description = "list all the widgets of an org or campaign";
+
+	static examples = ["<%= config.bin %> <%= command.id %> -o <organisation>"];
+
+	static flags = {
+		// flag with no value (-f, --force)
+		...super.globalFlags,
+		org: Flags.string({
+			char: "o",
+			exactlyOne: ["campaign", "org"],
+			description: "widgets of the organisation (coordinator or partner)",
+			helpValue: "<organisation name>",
+			//      required: true,
+		}),
+		campaign: Flags.string({
+			char: "c",
+			description: "widgets of the campaign (coordinator or partner)",
+			helpValue: "<campaign name>",
+			//      required: true,
+		}),
+		config: Flags.boolean({
+			description: "get the config",
+			default: false,
+			allowNo: true,
+		}),
+	};
+	fetchCampaign = async (name) => {
+		const Document = gql`
+query SearchWidgets($campaign: String!, $withConfig: Boolean!) {
+  campaign (name:$campaign) { ...on PrivateCampaign {
+    actionPages {
+      ...Summary
+      config @include(if: $withConfig)
+      thankYouTemplate
+      thankYouTemplateRef
+      ...on PrivateActionPage {
+        supporterConfirmTemplate
+      }
+    }}
+  }
+${FragmentSummary}
+}`;
+		const result = await query(Document, {
+			campaign: name,
+			withConfig: this.flags.config,
+		});
+		return result.campaign.actionPages;
+	};
+
+	fetchOrg = async (name) => {
+		const Document = gql`
+query SearchWidgets($org: String!, $withConfig: Boolean!) {
+  org (name:$org) {
+    actionPages {
+      ...Summary
+      config @include(if: $withConfig)
+      thankYouTemplate
+      thankYouTemplateRef
+      ...on PrivateActionPage {
+        supporterConfirmTemplate
+      }
+    }
+  }
+${FragmentSummary}
+}`;
+		const result = await query(Document, {
+			org: name,
+			withConfig: this.flags.config,
+		});
+		return result.org.actionPages;
+	};
+
+	simplify = (d) => {
+		const result = {
+			id: d.id,
+			name: d.name,
+			locale: d.locale,
+			status: d.status.toLowerCase(),
+			location: d.location?.startsWith("https://widget.proca.app")
+				? undefined
+				: d.location || undefined,
+			//			live: d.live,
+
+			//      thankYouTemplate: d.thankYouTemplate || undefined,
+			//      thankYouTemplateRef: d.thankYouTemplateRef || undefined,
+			// supporterConfirmTemplate: d.supporterConfirmTemplate || undefined,
+		};
+		if (d.extraSupporters > 0) {
+			result.extra = d.extraSupporters;
+		}
+		if (d.journey) result.journey = d.journey.join(" → ");
+
+		if (this.flags.config) {
+		}
+		return result;
+	};
+
+	table = (r) => {
+		super.table(r, null, (table) => table.sort(["id|des"]).toString());
+	};
+
+	async run() {
+		const { flags, args } = await this.parse(WidgetList);
+		let data = [];
+		if (flags.org) data = await this.fetchOrg(flags.org);
+		if (flags.campaign) data = await this.fetchCampaign(flags.campaign);
+		return this.output(data);
+	}
+}

package/src/config.mjs

@@ -0,0 +1,36 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { config as dotenv } from "dotenv";
+
+export const getFilename = (folder, env = "default") =>
+	join(folder, `${env}.env`);
+
+export const load = (folder, env = "default") => {
+	const file = getFilename(folder, env);
+	const config = dotenv({ path: file });
+	return {
+		token: config.parsed.PROCA_TOKEN,
+		url: config.parsed.REACT_APP_API_URL,
+		folder: process.env.PROCA_CONFIG_FOLDER,
+	};
+};
+
+export const get = (file, parsed = false) => {
+	try {
+		if (parsed) {
+			const config = dotenv({ path: file });
+			return config.parsed;
+		}
+		const userConfig = readFileSync(file, "utf8");
+		return userConfig;
+	} catch (e) {
+		if (e.code === "ENOENT") {
+			return undefined;
+		}
+		throw e;
+	}
+};
+
+export const write = (file, content) => {
+	writeFileSync(file, content);
+};