proca 0.8.1 → 1.1.5

package/src/commands/org/add.mjs

@@ -0,0 +1,66 @@
+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 { getTwitter } from "#src/util/twitter.mjs";
+
+export default class OrgAdd extends Command {
+	static args = {};
+
+	static examples = [
+		"<%= config.bin %> <%= command.id %> --twitter <twitter of the organisation>",
+	];
+
+	static flags = {
+		// flag with no value (-f, --force)
+		...super.globalFlags,
+		twitter: Flags.string({
+			description: "twitter account",
+			helpValue: "<screen name>",
+		}),
+		name: Flags.string({
+			char: "n",
+			description: "name of the org",
+			helpValue: "<org name>",
+		}),
+	};
+
+	create = async (_org) => {
+		const org = { ..._org, config: JSON.stringify(_org.config) };
+		console.log(org);
+
+		const AddOrgDocument = gql`
+mutation ($org: OrgInput!) {
+  addOrg(input: $org) {
+    config
+    name
+    title
+  }
+}
+    `;
+		const result = await mutation(AddOrgDocument, {
+			org,
+		});
+		if (!result.addOrg) {
+			console.log(result);
+			return result;
+		}
+		return result?.addOrg;
+	};
+
+	async run() {
+		const { args, flags } = await this.parse();
+		if (!flags.name && !flags.twitter) {
+			this.error("You must provide either --name or --twitter");
+		}
+
+		const org = { name: flags.twitter || flags.name, config: {} };
+
+		if (flags.twitter) {
+			await getTwitter(org);
+		}
+
+		const data = await this.create(org);
+		return this.output(data);
+	}
+}

package/src/commands/org/crm.mjs

@@ -0,0 +1,88 @@
+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, query } from "#src/urql.mjs";
+
+export default class OrgCRM extends Command {
+	static description = "view a org crm synchroniser";
+
+	static flags = {
+		// flag with no value (-f, --force)
+		...super.globalFlags,
+		name: Flags.string({
+			char: "n",
+			charAliases: ["o"],
+			required: true,
+			description: "name of the org",
+			helpValue: "<org name>",
+		}),
+		synchronize: Flags.boolean({
+			//     default: undefined,
+			aliases: ["deliver", "enable"],
+			description: "enable or disable the synchronisation queue",
+			allowNo: true,
+		}),
+	};
+
+	fetch = async (params) => {
+		const GetOrgDocument = gql`
+      query GetOrg($name: String!) {
+        org (name: $name) {
+          id name title
+          processing { customActionDeliver }
+        }
+      }
+    `;
+		const result = await query(GetOrgDocument, {
+			name: params.name,
+		});
+		return result.org;
+	};
+
+	mutate = async (name, deliver) => {
+		const Document = gql`
+mutation ($name: String!, $deliver: Boolean!) {
+  updateOrgProcessing (name: $name,customActionDeliver: $deliver) {
+    id, name, title, processing {customActionDeliver}
+  }
+}
+    `;
+		console.log("deliver", deliver);
+		const result = await mutation(Document, {
+			name: name,
+			deliver: deliver,
+		});
+		console.log("deliver", deliver);
+		return result.updateOrgProcessing;
+	};
+
+	simplify = (d) => {
+		const result = {
+			id: d.id,
+			name: d.name,
+			title: d.title,
+			deliver: d.processing.customActionDeliver,
+			queue: d.processing.customActionDeliver
+				? `cus.${d.id}.deliver`
+				: "call with --synchronize to enable",
+		};
+		return result;
+	};
+
+	table = (r) => {
+		super.table(r, null, null);
+	};
+
+	async run() {
+		const { args, flags } = await this.parse();
+		if (typeof flags.synchronize === "boolean") {
+			const data = await this.mutate(flags.name, flags.synchronize);
+			return this.output(data);
+		}
+		const data = await this.fetch(flags);
+		if (!data.processing.customActionDeliver)
+			this.info("actions aren't delivered, call with --synchronize to enable");
+		return this.output(data);
+	}
+}

package/src/commands/org/delete.mjs

@@ -0,0 +1,48 @@
+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 OrgDelete extends Command {
+	static examples = [
+		"<%= config.bin %> <%= command.id %>  <organisation_name>",
+	];
+	static args = this.multiid();
+
+	static flags = {
+		// flag with no value (-f, --force)
+		...this.flagify({ multiid: true }),
+		name: Flags.string({
+			char: "n",
+			description: "name of the org",
+			helpValue: "<org name>",
+		}),
+	};
+
+	delete = async (org) => {
+		console.log(org);
+
+		const DeleteOrgDocument = gql`
+mutation ($org: String!) {
+  deleteOrg(name: $org) 
+  
+}
+    `;
+		const result = await mutation(DeleteOrgDocument, {
+			org,
+		});
+		console.log(result);
+		if (!result.deleteOrg) {
+			console.log(result);
+			return result;
+		}
+		return result?.deleteOrg;
+	};
+
+	async run() {
+		const { args, flags } = await this.parse();
+
+		const data = await this.delete(flags.name);
+		return data;
+	}
+}

package/src/commands/org/get.mjs

@@ -0,0 +1,97 @@
+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, query } from "#src/urql.mjs";
+
+export default class OrgGet extends Command {
+	static description = "view a 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: Flags.string({
+			char: "n",
+			charAliases: ["o"],
+			description: "name of the org",
+			helpValue: "<org name>",
+		}),
+		config: Flags.boolean({
+			description: "display the config",
+			default: false,
+			allowNo: true,
+		}),
+		keys: Flags.boolean({
+			default: true,
+			allowNo: true,
+		}),
+		campaigns: Flags.boolean({
+			default: false,
+			allowNo: true,
+		}),
+		widgets: Flags.boolean({
+			default: true,
+			allowNo: true,
+		}),
+		users: Flags.boolean({
+			default: true,
+			allowNo: true,
+		}),
+	};
+
+	fetch = async (params) => {
+		const GetOrgDocument = gql`
+      query GetOrg($name: String!, $withCampaigns: Boolean = true) {
+        org (name: $name) {
+          id name title
+          config
+          campaigns @include(if: $withCampaigns) {id, name, title, org {name}}
+        }
+      }
+    `;
+		const result = await query(GetOrgDocument, {
+			name: params.name,
+			withCampaigns: params.campaigns,
+		});
+		//    result.org.config = JSON.parse (result.org.config);
+		return result.org;
+	};
+
+	simplify = (d) => {
+		const result = {
+			id: d.id,
+			Name: d.name,
+			Title: d.title,
+		};
+		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.config) {
+			r.config.locales = undefined;
+			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/org/join.mjs

@@ -0,0 +1,77 @@
+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 UserJoinOrg extends Command {
+	static description = "let a user join an organisation with a role";
+
+	static examples = ["<%= config.bin %> <%= command.id %>"];
+
+	static flags = {
+		...super.globalFlags,
+		user: Flags.string({ description: "user email" }),
+		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>",
+		}),
+	};
+
+	join = async (org) => {
+		const Document = gql`
+mutation ($name: String!) {
+  joinOrg(name: $name) {
+    org {
+      config
+      name
+      title
+    }
+    status
+  }
+}
+    `;
+		const result = await mutation(Document, {
+			name: org,
+		});
+		console.log(result);
+		return result.status;
+		//return result.users.map (d => {d.config = JSON.parse(d.config); return d});
+	};
+
+	mutate = async (params) => {
+		const Document = gql`
+mutation ($org: String!, $user: String!, $role: String = "campaigner") {
+  addOrgUser (orgName: $org, input : { email: $user, role: $role }) {
+    status
+  }
+}
+    `;
+		const result = await mutation(Document, {
+			user: params.user,
+			org: params.org,
+			role: params.role,
+		});
+		console.log(result);
+		return result.status;
+		//return result.users.map (d => {d.config = JSON.parse(d.config); return d});
+	};
+
+	async run() {
+		console.log("WIP, probably not working");
+		const { args, flags } = await this.parse();
+
+		if (!flags.user) {
+			data = await this.join(flags.org);
+		} else {
+			data = await this.mutate(flags);
+		}
+		console.log(data);
+	}
+}

package/src/commands/supporter/count.mjs

@@ -0,0 +1,96 @@
+import { Args, Flags } from "@oclif/core";
+import Command from "#src/procaCommand.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class CounterGet extends Command {
+	static description = "counter of supporters";
+
+	static examples = [
+		"<%= config.bin %> <%= command.id %> --id <id of the campaign>",
+		"<%= config.bin %> <%= command.id %> --name <name of the campaign>",
+	];
+
+	static args = this.multiid();
+	static flags = {
+		// flag with no value (-f, --force)
+		...this.flagify({ multiid: true }),
+		org: Flags.boolean({
+			description: "segment by partner",
+			default: false,
+		}),
+		area: Flags.boolean({
+			description: "segment by area",
+			default: false,
+		}),
+		without: Flags.string({
+			description: "total to add to the partner's counter",
+		}),
+		number: Flags.boolean({
+			description: "just return the number to add to the partner's counter",
+			dependsOn: ["without"],
+		}),
+	};
+
+	fetchExcluding = async (params) => {
+		const GetCounterDocument = gql`
+query GetCounter($name: String, $id: Int, $without: String!) {
+  campaign(name: $name, id: $id) {
+    stats {
+      supporterCount
+      supporterCountByOthers (orgName: $without) 
+    }
+  }
+}`;
+
+		const result = await query(GetCounterDocument, params);
+		return result.campaign.stats;
+	};
+
+	fetch = async (params) => {
+		const GetCounterDocument = gql`
+query GetCounter($name: String, $id: Int, $org: Boolean = false, $area: Boolean = false) {
+  campaign(name: $name, id: $id) {
+    stats {
+      supporterCount
+      supporterCountByOrg @include(if: $org) { org { name } count }
+      supporterCountByArea @include(if: $area) { area count }
+    }
+  }
+}`;
+
+		const result = await query(GetCounterDocument, params);
+		return result.campaign.stats;
+	};
+
+	simplify = (d) => {
+		const result = { total: d.supporterCount };
+		d.supporterCountByOrg
+			?.sort((a, b) => b.count - a.count)
+			.forEach((org) => {
+				result[org.org.name] = org.count;
+			});
+		d.supporterCountByArea
+			?.sort((a, b) => b.count - a.count)
+			.forEach((area) => {
+				result[area.area] = area.count;
+			});
+		if (d.supporterCountByOthers) {
+			result[`without ${this.flags.without}`] = d.supporterCountByOthers;
+		}
+		return result;
+	};
+	table = (r) => {
+		super.table(r, null, null);
+	};
+
+	async run() {
+		const { args, flags } = await this.parse();
+		if (flags.without) {
+			const data = await this.fetchExcluding(flags);
+			if (flags.number) return console.log(data.supporterCountByOthers);
+			return this.output(data);
+		}
+		const data = await this.fetch(flags);
+		return this.output(data);
+	}
+}

package/src/commands/user/get.mjs

@@ -0,0 +1,91 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class UserList extends Command {
+	static description = "fetch the information about a user";
+
+	static examples = ["<%= config.bin %> <%= command.id %>"];
+
+	static flags = {
+		...super.globalFlags,
+		email: Flags.string({ description: "user email" }),
+		org: Flags.string({
+			char: "o",
+			description: "name of the org",
+			exactlyOne: ["email", "id", "org"],
+			helpValue: "<org name>",
+		}),
+		id: Flags.string({
+			char: "i",
+			parse: (input) => {
+				return Number.parseInt(input, 10);
+			},
+			description: "id of the user",
+		}),
+	};
+
+	fetch = async (params) => {
+		const Document = gql`
+query ($email: String, $org: String, $id: Int) {
+  users (select: {email: $email, orgName: $org, id: $id}) {
+    apiToken {
+      expiresAt
+    }
+    email
+    id
+    isAdmin
+    jobTitle
+    phone
+    pictureUrl
+    roles {
+      role org {name}
+    }
+  }
+}
+    `;
+		const result = await query(Document, {
+			org: params.org,
+			id: params.id,
+			email: params.email,
+		});
+		return result.users[0];
+	};
+
+	simplify = (d) => {
+		const result = {
+			id: d.id,
+			email: d.email,
+		};
+		if (d.apiToken) {
+			result.tokenExpire = d.apiToken.expire;
+		}
+		if (d.isAdmin) {
+			result.admin = true;
+		}
+		const roles = d.roles.reduce((acc, item) => {
+			if (!acc[item.role]) {
+				acc[item.role] = [];
+			}
+			acc[item.role].push(item.org.name);
+			return acc;
+		}, {});
+		for (const role in roles) {
+			result[role] = roles[role].join(",");
+		}
+		return result;
+	};
+
+	table = (r) => {
+		super.table(r, null, null);
+	};
+
+	async run() {
+		const { args, flags } = await this.parse();
+		let data = [];
+
+		data = await this.fetch(flags);
+		return this.output(data);
+	}
+}

package/src/commands/user/leave.mjs

@@ -0,0 +1,52 @@
+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 OrgLeave extends Command {
+	actionTypes = new Set();
+
+	static args = {};
+
+	static description = "leave a org";
+
+	static examples = ["<%= config.bin %> <%= command.id %> -i 42"];
+
+	static flags = {
+		// flag with no value (-f, --force)
+		...super.globalFlags,
+		email: Flags.string({
+			description: "email",
+			required: true,
+			helpValue: "<user email>",
+		}),
+		org: Flags.string({
+			char: "o",
+			description: "name of the org",
+			required: true,
+			helpValue: "<org name>",
+		}),
+	};
+
+	mutate = async ({ email, org }) => {
+		const Document = gql`
+mutation ($email: String!, $org: String!) {
+  deleteOrgUser(email: $email, orgName: $org) { status }
+}`;
+		const result = await mutation(Document, {
+			email: email,
+			org: org,
+		});
+		return result.deleteOrgUser.status;
+	};
+
+	table = (r) => {
+		super.table(r, null, null);
+	};
+
+	async run() {
+		const { args, flags } = await this.parse();
+		const data = await this.mutate(flags);
+		return data;
+	}
+}

package/src/commands/user/list.mjs

@@ -0,0 +1,71 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class UserList extends Command {
+	actionTypes = new Set();
+
+	static description = "list all the users";
+
+	static examples = ["<%= config.bin %> <%= command.id %> %pizza%"];
+
+	static flags = {
+		// flag with no value (-f, --force)
+		...super.globalFlags,
+		org: Flags.string({
+			char: "o",
+			description: "organisation",
+			required: true,
+		}),
+	};
+
+	fetch = async (org) => {
+		const SearchUsersDocument = gql`
+query ($org: String!) {
+  users(select: {orgName: $org}) {
+    apiToken {
+      expiresAt
+    }
+    email
+    id
+    isAdmin
+    jobTitle
+    phone
+    pictureUrl
+    roles {
+      role org {name}
+    }
+  }
+}
+    `;
+		const result = await query(SearchUsersDocument, { org: org });
+		return result.users;
+		//return result.users.map (d => {d.config = JSON.parse(d.config); return d});
+	};
+
+	simplify = (d) => {
+		const result = {
+			id: d.id,
+			email: d.email,
+		};
+		result.role = d.roles.filter((d) => d.org.name === this.flags.org)[0].role;
+		if (d.isAdmin) {
+			result.superadmin = true;
+		}
+		if (d.apiToken) {
+			result.tokenExpire = d.apiToken.tokenExpire;
+		}
+
+		return result;
+	};
+
+	async run() {
+		const { args, flags } = await this.parse(UserList);
+		let data = [];
+
+		data = await this.fetch(flags.org);
+
+		return this.output(data);
+	}
+}