@pipedream/redmine 0.0.1 → 0.2.0

package/README.md

@@ -0,0 +1,11 @@
+# Overview
+
+The Redmine API allows for integration with the Redmine project management tool, enabling the automation of tasks like issue tracking, project management, and time tracking. Using Pipedream, you can create workflows that trigger on specific Redmine events or perform actions in Redmine based on triggers from other apps. By harnessing the Redmine API on Pipedream, you can connect Redmine with a multitude of other apps and services to streamline your project management processes.
+
+# Example Workflows
+
+- **Sync Redmine Issues to Google Sheets**: Automatically export newly created or updated Redmine issues to a Google Sheets spreadsheet for advanced reporting or data analysis. This workflow can be set up to run periodically, ensuring your Sheets are always up-to-date with the latest issue data.
+
+- **Slack Notifications for Redmine Updates**: Set up a workflow where updates to issues or projects in Redmine trigger notifications in a designated Slack channel. This keeps your team informed in real-time about important changes, like status updates or newly assigned tasks.
+
+- **GitHub Commit Linked to Redmine Issues**: Whenever a new commit is pushed to a GitHub repository, search for Redmine issue IDs in the commit message and update the corresponding issue with the commit details. This helps maintain a clear link between code changes and project tasks.

package/actions/create-issue/create-issue.mjs

@@ -0,0 +1,74 @@
+import app from "../../redmine.app.mjs";
+import utils from "../../common/utils.mjs";
+
+export default {
+  key: "redmine-create-issue",
+  name: "Create Issue",
+  description: "Creates a new issue in Redmine. [See the documentation](https://www.redmine.org/projects/redmine/wiki/rest_issues#creating-an-issue)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: false,
+  },
+  type: "action",
+  props: {
+    app,
+    projectId: {
+      propDefinition: [
+        app,
+        "projectId",
+      ],
+    },
+    trackerId: {
+      propDefinition: [
+        app,
+        "trackerId",
+      ],
+    },
+    subject: {
+      type: "string",
+      label: "Subject",
+      description: "The subject of the issue",
+    },
+    description: {
+      type: "string",
+      label: "Description",
+      description: "The description of the issue",
+    },
+    statusId: {
+      propDefinition: [
+        app,
+        "statusId",
+      ],
+    },
+    priorityId: {
+      propDefinition: [
+        app,
+        "priorityId",
+      ],
+    },
+  },
+  methods: {
+    createIssue(args = {}) {
+      return this.app.post({
+        path: "/issues.json",
+        ...args,
+      });
+    },
+  },
+  run({ $: step }) {
+    const {
+      createIssue,
+      ...issue
+    } = this;
+
+    return createIssue({
+      step,
+      data: {
+        issue: utils.transformProps(issue),
+      },
+      summary: (response) => `Successfully created issue with ID: \`${response.issue?.id}\``,
+    });
+  },
+};

package/actions/delete-user/delete-user.mjs

@@ -0,0 +1,45 @@
+import app from "../../redmine.app.mjs";
+
+export default {
+  key: "redmine-delete-user",
+  name: "Delete User",
+  description: "Deletes a user from the Redmine platform. [See the documentation](https://www.redmine.org/projects/redmine/wiki/rest_users#delete)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: true,
+    openWorldHint: true,
+    readOnlyHint: false,
+  },
+  type: "action",
+  props: {
+    app,
+    userId: {
+      propDefinition: [
+        app,
+        "userId",
+      ],
+    },
+  },
+  methods: {
+    deleteUser({
+      userId, ...args
+    } = {}) {
+      return this.app.delete({
+        path: `/users/${userId}.json`,
+        ...args,
+      });
+    },
+  },
+  run({ $: step }) {
+    const {
+      deleteUser,
+      userId,
+    } = this;
+
+    return deleteUser({
+      step,
+      userId,
+      summary: () => "Successfully deleted user",
+    });
+  },
+};

package/actions/list-priority-id-options/list-priority-id-options.mjs

@@ -0,0 +1,24 @@
+import redmine from "../../redmine.app.mjs";
+
+export default {
+  key: "redmine-list-priority-id-options",
+  name: "List Priority ID Options",
+  description: "Retrieves available options for the Priority ID field.",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    redmine,
+  },
+  async run({ $ }) {
+    const options = await redmine.propDefinitions.priorityId.options.call(this.redmine);
+    $.export("$summary", `Successfully retrieved ${options.length} option${options.length === 1
+      ? ""
+      : "s"}`);
+    return options;
+  },
+};

package/actions/list-status-id-options/list-status-id-options.mjs

@@ -0,0 +1,24 @@
+import redmine from "../../redmine.app.mjs";
+
+export default {
+  key: "redmine-list-status-id-options",
+  name: "List Status ID Options",
+  description: "Retrieves available options for the Status ID field.",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    redmine,
+  },
+  async run({ $ }) {
+    const options = await redmine.propDefinitions.statusId.options.call(this.redmine);
+    $.export("$summary", `Successfully retrieved ${options.length} option${options.length === 1
+      ? ""
+      : "s"}`);
+    return options;
+  },
+};

package/actions/list-tracker-id-options/list-tracker-id-options.mjs

@@ -0,0 +1,24 @@
+import redmine from "../../redmine.app.mjs";
+
+export default {
+  key: "redmine-list-tracker-id-options",
+  name: "List Tracker ID Options",
+  description: "Retrieves available options for the Tracker ID field.",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    redmine,
+  },
+  async run({ $ }) {
+    const options = await redmine.propDefinitions.trackerId.options.call(this.redmine);
+    $.export("$summary", `Successfully retrieved ${options.length} option${options.length === 1
+      ? ""
+      : "s"}`);
+    return options;
+  },
+};

package/actions/update-project/update-project.mjs

@@ -0,0 +1,80 @@
+import app from "../../redmine.app.mjs";
+import utils from "../../common/utils.mjs";
+
+export default {
+  key: "redmine-update-project",
+  name: "Update Project",
+  description: "Updates an existing project in Redmine. [See the documentation](https://www.redmine.org/projects/redmine/wiki/rest_projects#updating-a-project)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: true,
+    openWorldHint: true,
+    readOnlyHint: false,
+  },
+  type: "action",
+  props: {
+    app,
+    projectId: {
+      propDefinition: [
+        app,
+        "projectId",
+      ],
+    },
+    name: {
+      type: "string",
+      label: "Name",
+      description: "The name of the project",
+      optional: true,
+    },
+    description: {
+      type: "string",
+      label: "Description",
+      description: "The description of the project",
+      optional: true,
+    },
+    homepage: {
+      type: "string",
+      label: "Homepage",
+      description: "The homepage of the project",
+      optional: true,
+    },
+    isPublic: {
+      type: "boolean",
+      label: "Is Public",
+      description: "Whether the project is public",
+      optional: true,
+    },
+    inheritMembers: {
+      type: "boolean",
+      label: "Inherit Members",
+      description: "Whether the project should inherit members from its parent",
+      optional: true,
+    },
+  },
+  methods: {
+    updateProject({
+      projectId, ...args
+    } = {}) {
+      return this.app.put({
+        path: `/projects/${projectId}.json`,
+        ...args,
+      });
+    },
+  },
+  run({ $: step }) {
+    const {
+      updateProject,
+      projectId,
+      ...project
+    } = this;
+
+    return updateProject({
+      step,
+      projectId,
+      data: {
+        project: utils.transformProps(project),
+      },
+      summary: () => "Successfully updated project",
+    });
+  },
+};

package/common/constants.mjs

@@ -0,0 +1,15 @@
+const SUMMARY_LABEL = "$summary";
+const DOMAIN_PLACEHOLDER = "{domain}";
+const BASE_URL = `https://${DOMAIN_PLACEHOLDER}`;
+const LAST_CREATED_AT = "lastCreatedAt";
+const DEFAULT_MAX = 600;
+const DEFAULT_LIMIT = 60;
+
+export default {
+  SUMMARY_LABEL,
+  DOMAIN_PLACEHOLDER,
+  BASE_URL,
+  DEFAULT_MAX,
+  DEFAULT_LIMIT,
+  LAST_CREATED_AT,
+};

package/common/utils.mjs

@@ -0,0 +1,43 @@
+function toSnakeCase(str) {
+  return str?.replace(/([A-Z])/g, "_$1").toLowerCase();
+}
+
+function keysToSnakeCase(data = {}) {
+  return Object.entries(data)
+    .reduce((acc, [
+      key,
+      value,
+    ]) => ({
+      ...acc,
+      [toSnakeCase(key)]: value,
+    }), {});
+}
+
+function transformProps(props) {
+  if (!props) {
+    return;
+  }
+
+  return keysToSnakeCase(
+    Object.fromEntries(
+      Object.entries(props)
+        .filter(([
+          key,
+          value,
+        ]) => typeof(value) !== "function" && key !== "app"),
+    ),
+  );
+}
+
+async function iterate(iterations) {
+  const items = [];
+  for await (const item of iterations) {
+    items.push(item);
+  }
+  return items;
+}
+
+export default {
+  transformProps,
+  iterate,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/redmine",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "Pipedream Redmine Components",
   "main": "redmine.app.mjs",
   "keywords": [

package/redmine.app.mjs

@@ -1,11 +1,226 @@
+import {
+  axios, ConfigurationError,
+} from "@pipedream/platform";
+import constants from "./common/constants.mjs";
+import utils from "./common/utils.mjs";
+
 export default {
   type: "app",
   app: "redmine",
-  propDefinitions: {},
+  propDefinitions: {
+    projectId: {
+      type: "integer",
+      label: "Project ID",
+      description: "The ID of the project",
+      async options() {
+        const response = await this.listProjects();
+        console.log(response);
+        const { projects } = response;
+        return projects.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    trackerId: {
+      type: "integer",
+      label: "Tracker ID",
+      description: "The ID of the tracker",
+      async options() {
+        const { trackers } = await this.listTrackers();
+        return trackers.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    statusId: {
+      type: "integer",
+      label: "Status ID",
+      description: "The ID of the status",
+      async options() {
+        const { issue_statuses: statuses } = await this.listIssueStatuses();
+        return statuses.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    priorityId: {
+      type: "integer",
+      label: "Priority ID",
+      description: "The ID of the priority",
+      async options() {
+        const { issue_priorities: priorities } = await this.listIssuePriorities();
+        return priorities.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    userId: {
+      type: "integer",
+      label: "User ID",
+      description: "The ID of the user",
+      async options() {
+        const { users } = await this.listUsers();
+        return users.map(({
+          id: value, login: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+  },
   methods: {
-    // this.$auth contains connected account data
-    authKeys() {
-      console.log(Object.keys(this.$auth));
+    exportSummary(step) {
+      if (!step?.export) {
+        throw new ConfigurationError("The summary method should be bind to the step object aka `$`");
+      }
+      return (msg = "") => step.export(constants.SUMMARY_LABEL, msg);
+    },
+    getUrl(path) {
+      const baseUrl = constants.BASE_URL
+        .replace(constants.DOMAIN_PLACEHOLDER, this.$auth.hostname);
+      return `${baseUrl}${path}`;
+    },
+    async makeRequest({
+      step = this, path, headers, summary, ...args
+    } = {}) {
+      const {
+        getUrl,
+        exportSummary,
+        $auth: { api_key: apiKey },
+      } = this;
+
+      const config = {
+        ...args,
+        url: getUrl(path),
+        headers: {
+          ...headers,
+          "X-Redmine-API-Key": apiKey,
+        },
+      };
+
+      const response = await axios(step, config);
+
+      if (typeof(summary) === "function") {
+        exportSummary(step)(summary(response));
+      }
+
+      return response || {
+        success: true,
+      };
+    },
+    post(args = {}) {
+      return this.makeRequest({
+        method: "post",
+        ...args,
+      });
+    },
+    put(args = {}) {
+      return this.makeRequest({
+        method: "put",
+        ...args,
+      });
+    },
+    delete(args = {}) {
+      return this.makeRequest({
+        method: "delete",
+        ...args,
+      });
+    },
+    listIssues(args = {}) {
+      return this.makeRequest({
+        path: "/issues.json",
+        ...args,
+      });
+    },
+    listProjects(args = {}) {
+      return this.makeRequest({
+        path: "/projects.json",
+        ...args,
+      });
+    },
+    listTrackers(args = {}) {
+      return this.makeRequest({
+        path: "/trackers.json",
+        ...args,
+      });
+    },
+    listIssueStatuses(args = {}) {
+      return this.makeRequest({
+        path: "/issue_statuses.json",
+        ...args,
+      });
+    },
+    listIssuePriorities(args = {}) {
+      return this.makeRequest({
+        path: "/enumerations/issue_priorities.json",
+        ...args,
+      });
+    },
+    listUsers(args = {}) {
+      return this.makeRequest({
+        path: "/users.json",
+        ...args,
+      });
+    },
+    async *getIterations({
+      resourceFn,
+      resourceFnArgs,
+      resourceName,
+      max = constants.DEFAULT_MAX,
+    }) {
+      let offset = 0;
+      let resourcesCount = 0;
+
+      while (true) {
+        const response =
+          await resourceFn({
+            ...resourceFnArgs,
+            params: {
+              offset,
+              limit: constants.DEFAULT_LIMIT,
+              ...resourceFnArgs?.params,
+            },
+          });
+
+        const nextResources = resourceName && response[resourceName] || response;
+
+        if (!nextResources?.length) {
+          console.log("No more resources found");
+          return;
+        }
+
+        for (const resource of nextResources) {
+          yield resource;
+          resourcesCount += 1;
+
+          if (resourcesCount >= max) {
+            return;
+          }
+        }
+
+        if (nextResources.length < constants.DEFAULT_LIMIT) {
+          console.log("Less resources than the limit found, no more resources to fetch");
+          return;
+        }
+
+        offset += constants.DEFAULT_LIMIT;
+      }
+    },
+    paginate(args = {}) {
+      return utils.iterate(this.getIterations(args));
     },
   },
-};
+};

package/sources/common/base.mjs

@@ -0,0 +1,14 @@
+import { ConfigurationError } from "@pipedream/platform";
+import app from "../../redmine.app.mjs";
+
+export default {
+  props: {
+    app,
+    db: "$.service.db",
+  },
+  methods: {
+    generateMeta() {
+      throw new ConfigurationError("generateMeta is not implemented");
+    },
+  },
+};

package/sources/common/polling.mjs

@@ -0,0 +1,58 @@
+import {
+  ConfigurationError,
+  DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
+} from "@pipedream/platform";
+import common from "./base.mjs";
+
+export default {
+  ...common,
+  props: {
+    ...common.props,
+    timer: {
+      type: "$.interface.timer",
+      label: "Polling schedule",
+      description: "How often to poll the API",
+      default: {
+        intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
+      },
+    },
+  },
+  methods: {
+    ...common.methods,
+    getResourceName() {
+      throw new ConfigurationError("getResourceName is not implemented");
+    },
+    getResourceFn() {
+      throw new ConfigurationError("getResourceFn is not implemented");
+    },
+    getResourceFnArgs() {
+      throw new ConfigurationError("getResourceFnArgs is not implemented");
+    },
+    processEvent(resource) {
+      const meta = this.generateMeta(resource);
+      this.$emit(resource, meta);
+    },
+    async processResources(resources) {
+      Array.from(resources)
+        .reverse()
+        .forEach(this.processEvent);
+    },
+  },
+  async run() {
+    const {
+      app,
+      getResourceFn,
+      getResourceFnArgs,
+      getResourceName,
+      processResources,
+    } = this;
+
+    const resources = await app.paginate({
+      resourceFn: getResourceFn(),
+      resourceFnArgs: getResourceFnArgs(),
+      resourceName: getResourceName(),
+    });
+
+    processResources(resources);
+  },
+};

package/sources/issue-created/issue-created.mjs

@@ -0,0 +1,34 @@
+import common from "../common/polling.mjs";
+
+export default {
+  ...common,
+  key: "redmine-issue-created",
+  name: "New Issue Created",
+  description: "Emit new event when a new issue is created in Redmine",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "unique",
+  methods: {
+    ...common.methods,
+    getResourceName() {
+      return "issues";
+    },
+    getResourceFn() {
+      return this.app.listIssues;
+    },
+    getResourceFnArgs() {
+      return {
+        params: {
+          sort: "created_on:desc",
+        },
+      };
+    },
+    generateMeta(resource) {
+      return {
+        id: resource.id,
+        summary: `New Issue: ${resource.subject}`,
+        ts: Date.parse(resource.created_on),
+      };
+    },
+  },
+};

package/sources/project-updated/project-updated.mjs

@@ -0,0 +1,35 @@
+import common from "../common/polling.mjs";
+
+export default {
+  ...common,
+  key: "redmine-project-updated",
+  name: "Project Updated",
+  description: "Emits an event whenever a project is updated in Redmine",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "unique",
+  methods: {
+    ...common.methods,
+    getResourceName() {
+      return "projects";
+    },
+    getResourceFn() {
+      return this.app.listProjects;
+    },
+    getResourceFnArgs() {
+      return {
+        params: {
+          sort: "updated_on:desc",
+        },
+      };
+    },
+    generateMeta(resource) {
+      const ts = Date.parse(resource.updated_on);
+      return {
+        id: `${resource.id}-${ts}`,
+        summary: `Project Updated: ${resource.name}`,
+        ts,
+      };
+    },
+  },
+};