@pipedream/harvest 0.0.1

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2020 Pipedream, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/actions/create-timesheet-entry/create-timesheet-entry.mjs

@@ -0,0 +1,93 @@
+import { ConfigurationError } from "@pipedream/platform";
+import harvest from "../../harvest.app.mjs";
+import {
+  isValidDate, isValidTime, removeNullEntries,
+} from "../../common/utils.mjs";
+
+export default {
+  key: "harvest-create-timesheet-entry",
+  name: "Create Timesheet Entry",
+  description: `Creates a new time entry object. 
+  [Create a time entry via duration documentation](https://help.getharvest.com/api-v2/timesheets-api/timesheets/time-entries/#create-a-time-entry-via-duration),
+  [Create a time entry via start and end time documentation](https://help.getharvest.com/api-v2/timesheets-api/timesheets/time-entries/#create-a-time-entry-via-start-and-end-time)`,
+  version: "0.0.1",
+  type: "action",
+  props: {
+    harvest,
+    projectId: {
+      propDefinition: [
+        harvest,
+        "projectId",
+      ],
+    },
+    taskId: {
+      propDefinition: [
+        harvest,
+        "taskId",
+      ],
+    },
+    spentDate: {
+      type: "string",
+      label: "Spent date (YYYY-MM-DD)",
+      description: "The ISO 8601 formatted date on which the time entry was spent. Example: 2019-07-26",
+    },
+    userId: {
+      propDefinition: [
+        harvest,
+        "userId",
+      ],
+    },
+    specifyStartEndTime: {
+      type: "boolean",
+      label: "Specify start and end time",
+      description: "Specify start and end time",
+      reloadProps: true,
+    },
+  },
+  async additionalProps() {
+    const props = {};
+    if (this.specifyStartEndTime === true) {
+      props.startedTime = {
+        type: "string",
+        label: "Start time(H:MM am/pm)",
+        description: "The time the entry started. Defaults to the current time. Example: 8:00am.",
+      };
+      props.endedTime = {
+        type: "string",
+        label: "End time(H:MM am/pm)",
+        description: "The time the entry ended. Defaults to the current time. Example: 8:00am.",
+        optional: true,
+      };
+    }
+    return props;
+  },
+  async run({ $ }) {
+
+    if (this.spentDate && !isValidDate(this.spentDate)) {
+      throw new ConfigurationError("Invalid spent date. Ensure format is YYYY-MM-DD");
+    }
+
+    if (this.startedTime && !isValidTime(this.startedTime)) {
+      throw new ConfigurationError("Invalid start time. Ensure format is (H:MM am/pm)");
+    }
+
+    if (this.endedTime && !isValidTime(this.endedTime)) {
+      throw new ConfigurationError("Invalid end time. Ensure format is (H:MM am/pm)");
+    }
+
+    const params = removeNullEntries({
+      project_id: this.projectId,
+      task_id: this.taskId,
+      user_id: this.userId,
+      spent_date: this.spentDate,
+      started_time: this.startedTime.replace(/\s/g, ""),
+      ended_time: this.endedTime.replace(/\s/g, ""),
+    });
+    const response = await this.harvest.createTimeEntry({
+      $,
+      params,
+    });
+    response && $.export("$summary", "Successfully created time entry");
+    return response;
+  },
+};

package/actions/start-timer/start-timer.mjs

@@ -0,0 +1,29 @@
+import harvest from "../../harvest.app.mjs";
+
+export default {
+  key: "harvest-start-timer",
+  name: "Start Time Entry",
+  description: "Restart a stopped timer entry. [See docs here](https://help.getharvest.com/api-v2/timesheets-api/timesheets/time-entries/#restart-a-stopped-time-entry)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    harvest,
+    timeEntryId: {
+      propDefinition: [
+        harvest,
+        "timeEntryId",
+        () => ({
+          isRunning: false,
+        }),
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.harvest.restartTimeEntry({
+      $,
+      id: this.timeEntryId,
+    });
+    response && $.export("$summary", "Successfully started the time entry");
+    return response;
+  },
+};

package/actions/stop-timer/stop-timer.mjs

@@ -0,0 +1,29 @@
+import harvest from "../../harvest.app.mjs";
+
+export default {
+  key: "harvest-start-timer",
+  name: "Stop Time Entry",
+  description: "Stop a timer entry. [See docs here](https://help.getharvest.com/api-v2/timesheets-api/timesheets/time-entries/#stop-a-running-time-entry)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    harvest,
+    timeEntryId: {
+      propDefinition: [
+        harvest,
+        "timeEntryId",
+        () => ({
+          isRunning: true,
+        }),
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.harvest.stopTimeEntry({
+      $,
+      id: this.timeEntryId,
+    });
+    response && $.export("$summary", "Successfully ended the time entry");
+    return response;
+  },
+};

package/common/constants.mjs

@@ -0,0 +1,12 @@
+export default {
+  HTTP_PROTOCOL: "https://",
+  BASE_URL: "api.harvestapp.com",
+  VERSION_PATH: "/v2",
+  PAGE_SIZE: 100,
+  retriableStatusCodes: [
+    408,
+    429,
+    500,
+  ],
+  DB_LAST_DATE_CHECK: "DB_LAST_DATE_CHECK",
+};

package/common/utils.mjs

@@ -0,0 +1,66 @@
+const removeNullEntries = (obj) =>
+  obj && Object.entries(obj).reduce((acc, [
+    key,
+    value,
+  ]) => {
+    const isNumber = typeof value === "number";
+    const isBoolean = typeof value === "boolean";
+    const isNotEmpyString = typeof value === "string" && value.trim() !== "";
+    const isNotEmptyArray = Array.isArray(value) && value.length;
+    const isNotEmptyObject =
+      typeof value === "object" &&
+      value !== null &&
+      !Array.isArray(value) &&
+      Object.keys(value).length !== 0;
+    isNotEmptyObject && (value = removeNullEntries(value));
+    return ((value || value === false) &&
+      (isNotEmpyString || isNotEmptyArray || isNotEmptyObject || isBoolean || isNumber))
+      ? {
+        ...acc,
+        [key]: value,
+      }
+      : acc;
+  }, {});
+
+/* This function checks for date strings with the format YYYY-MM-DD
+    examples
+    2022-09-28
+    2021-12-10
+*/
+const isValidDate = (dateString) => {
+  const regex = /^\d{4}-\d{2}-\d{2}$/;
+  const date = new Date(dateString);
+  if (!dateString) {
+    return false;
+  }
+  if (dateString.match(regex) === null) {
+    return false;
+  }
+  const timestamp = date.getTime();
+  if (typeof timestamp !== "number" || Number.isNaN(timestamp)) {
+    return false;
+  }
+  return date.toISOString().startsWith(dateString);
+};
+
+/* This function checks for time strings with the format HH:MM AM/PM
+    examples
+    11:45PM
+    11:45 PM
+    11:45 pm
+    11:45pm
+    11:45AM
+    11:45 AM
+    11:45 am
+    11:45am
+*/
+const isValidTime = (timeString) => {
+  const regex = /([0-9]|0[0-9]|1[0-9]|2[0-3]):([0-5][0-9])\s*([AaPp][Mm])$/;
+  return timeString
+    ? timeString.match(regex)
+    : false;
+};
+
+export {
+  removeNullEntries, isValidDate, isValidTime,
+};

package/harvest.app.mjs

@@ -0,0 +1,307 @@
+import constants from "./common/constants.mjs";
+import {
+  axios, ConfigurationError,
+} from "@pipedream/platform";
+import retry from "async-retry";
+
+export default {
+  type: "app",
+  app: "harvest",
+  propDefinitions: {
+    projectId: {
+      type: "string",
+      label: "Project ID",
+      description: "The ID of the project to associate with the time entry",
+      useQuery: true,
+      async options({ page }) {
+        const response = await this.listProjects({
+          perPage: constants.PAGE_SIZE,
+          page: page + 1,
+        });
+        return response.projects.map((project) => ({
+          label: project.name,
+          value: project.id,
+        }));
+      },
+    },
+    taskId: {
+      type: "string",
+      label: "Task ID",
+      description: "The ID of the task to associate with the time entry",
+      useQuery: true,
+      async options({ page }) {
+        const response = await this.listTasks({
+          perPage: constants.PAGE_SIZE,
+          page: page + 1,
+        });
+        return response.tasks.map((task) => ({
+          label: task.name,
+          value: task.id,
+        }));
+      },
+    },
+    userId: {
+      type: "string",
+      label: "User ID",
+      description: "The ID of the user to associate with the time entry",
+      useQuery: true,
+      optional: true,
+      async options({ page }) {
+        const response = await this.listUsers({
+          perPage: constants.PAGE_SIZE,
+          page: page + 1,
+        });
+        return response.users.map((user) => ({
+          label: `${user.first_name} ${user.last_name}`,
+          value: user.id,
+        }));
+      },
+    },
+    clientId: {
+      type: "string",
+      label: "Client ID",
+      description: "The ID of the client to associate with time entries",
+      useQuery: true,
+      optional: true,
+      async options({ page }) {
+        const response = await this.listClients({
+          perPage: constants.PAGE_SIZE,
+          page: page + 1,
+        });
+        return response.clients.map((client) => ({
+          label: client.name,
+          value: client.id,
+        }));
+      },
+    },
+    timeEntryId: {
+      type: "string",
+      label: "Time entry ID",
+      description: "The ID of the time entry.",
+      useQuery: true,
+      async options({
+        page, isRunning,
+      }) {
+        const response = await this.listTimeEntries({
+          perPage: constants.PAGE_SIZE,
+          page: page + 1,
+          is_running: isRunning,
+        });
+        return response.time_entries.map((entry) => ({
+          label: `Project: ${entry.project.name}, Task: ${entry.task.name}, Spend date: ${entry.spent_date} ${entry.started_time || ""} ${entry.ended_time
+            ? " to " + entry.ended_time
+            : ""}`,
+          value: entry.id,
+        }));
+      },
+    },
+  },
+  methods: {
+    setLastDateChecked(db, value) {
+      db && db.set(constants.DB_LAST_DATE_CHECK, value);
+    },
+    getLastDateChecked(db) {
+      return db && db.get(constants.DB_LAST_DATE_CHECK);
+    },
+    _getHeaders() {
+      return {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.$auth.oauth_access_token}`,
+        "Harvest-Account-Id": this.$auth.account_id,
+      };
+    },
+    _getUrl(path) {
+      const {
+        BASE_URL,
+        HTTP_PROTOCOL,
+        VERSION_PATH,
+      } = constants;
+      return `${HTTP_PROTOCOL}${BASE_URL}${VERSION_PATH}${path}`;
+    },
+    async _makeRequest(args = {}) {
+      const {
+        $,
+        method = "get",
+        path,
+        params,
+        data,
+      } = args;
+      const config = {
+        method,
+        url: this._getUrl(path),
+        headers: this._getHeaders(),
+        params,
+        data,
+      };
+      return axios($ ?? this, config);
+    },
+    _isRetriableStatusCode(statusCode) {
+      constants.retriableStatusCodes.includes(statusCode);
+    },
+    async _withRetries(apiCall) {
+      const retryOpts = {
+        retries: 5,
+        factor: 2,
+      };
+      return retry(async (bail) => {
+        try {
+          const data = await apiCall();
+
+          return data;
+        } catch (err) {
+          const { status = 500 } = err;
+          if (!this._isRetriableStatusCode(status)) {
+            bail(`
+              Unexpected error (status code: ${status}):
+              ${JSON.stringify(err.response)}
+            `);
+          }
+          throw new ConfigurationError("Could not get data");
+        }
+      }, retryOpts);
+    },
+    async *listTimeEntriesPaginated({
+      page, updatedSince,
+    }) {
+      do {
+        const response = await this._withRetries(
+          () => this.listTimeEntries({
+            per_page: constants.PAGE_SIZE,
+            page,
+            updated_since: updatedSince,
+          }),
+        );
+
+        if (response.time_entries.length === 0) {
+          return;
+        }
+        for (const entry of response.time_entries) {
+          yield entry;
+        }
+        if (!response.next_page) {
+          return;
+        }
+        page += 1;
+      } while (true);
+    },
+    async *listInvoicesPaginated({
+      page, updatedSince,
+    }) {
+      do {
+        const response = await this._withRetries(
+          () => this.listInvoices({
+            per_page: constants.PAGE_SIZE,
+            page,
+            updated_since: updatedSince,
+          }),
+        );
+
+        if (response.invoices.length === 0) {
+          return;
+        }
+        for (const invoice of response.invoices) {
+          yield invoice;
+        }
+        if (!response.next_page) {
+          return;
+        }
+        page += 1;
+      } while (true);
+    },
+    async listProjects({
+      $, perPage, page,
+    }) {
+      return this._makeRequest({
+        $,
+        path: "/projects",
+        params: {
+          per_page: perPage,
+          page,
+        },
+      });
+    },
+    async listTasks({
+      $, perPage, page,
+    }) {
+      return this._makeRequest({
+        $,
+        path: "/tasks",
+        params: {
+          per_page: perPage,
+          page,
+        },
+      });
+    },
+    async listUsers({
+      $, perPage, page,
+    }) {
+      return this._makeRequest({
+        $,
+        path: "/users",
+        params: {
+          per_page: perPage,
+          page,
+        },
+      });
+    },
+    async listClients({
+      $, perPage, page,
+    }) {
+      return this._makeRequest({
+        $,
+        path: "/clients",
+        params: {
+          per_page: perPage,
+          page,
+        },
+      });
+    },
+    async createTimeEntry({
+      $, params,
+    }) {
+      return this._makeRequest({
+        $,
+        path: "/time_entries",
+        params,
+        method: "post",
+      });
+    },
+    async listTimeEntries({
+      $, ...params
+    }) {
+
+      return this._makeRequest({
+        $,
+        path: "/time_entries",
+        params,
+      });
+    },
+    async restartTimeEntry({
+      $, id,
+    }) {
+      return this._makeRequest({
+        $,
+        path: `/time_entries/${id}/restart`,
+        method: "patch",
+      });
+    },
+    async stopTimeEntry({
+      $, id,
+    }) {
+      return this._makeRequest({
+        $,
+        path: `/time_entries/${id}/stop`,
+        method: "patch",
+      });
+    },
+    async listInvoices({
+      $, ...params
+    }) {
+      return this._makeRequest({
+        $,
+        path: "/invoices",
+        params,
+      });
+    },
+  },
+};

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@pipedream/harvest",
+  "version": "0.0.1",
+  "description": "Pipedream Harvest Components",
+  "main": "harvest.app.mjs",
+  "keywords": [
+    "pipedream",
+    "harvest"
+  ],
+  "homepage": "https://pipedream.com/apps/harvest",
+  "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@pipedream/platform": "^0.9.0",
+    "moment": "^2.29.3",
+    "async-retry": "^1.3.3"
+  }
+}

package/sources/new-invoice-entry/new-invoice-entry.mjs

@@ -0,0 +1,45 @@
+import harvest from "../../harvest.app.mjs";
+
+export default {
+  key: "harvest-new-invoice-entry",
+  name: "New Invoice Entry",
+  description: "Emit new notifications when a new invoice is created",
+  version: "0.0.1",
+  type: "source",
+  props: {
+    harvest,
+    timer: {
+      label: "Polling interval",
+      description: "Pipedream will poll Harvest API on this schedule",
+      type: "$.interface.timer",
+      default: {
+        intervalSeconds: 60 * 15,
+      },
+    },
+    db: "$.service.db",
+  },
+  dedupe: "unique",
+  async run() {
+    const data = [];
+    let lastDateChecked = this.harvest.getLastDateChecked(this.db);
+    if (!lastDateChecked) {
+      lastDateChecked = new Date().toISOString();
+      this.harvest.setLastDateChecked(this.db, lastDateChecked);
+    }
+    const invoices = await this.harvest.listInvoicesPaginated({
+      page: 1,
+      updatedSince: lastDateChecked,
+    });
+    for await (const invoice of invoices) {
+      data.push(invoice);
+    }
+    data && data.reverse().forEach((invoice) => {
+      this.harvest.setLastDateChecked(this.db, invoice.updated_at);
+      this.$emit(invoice,
+        {
+          id: invoice.id,
+          summary: `Invoice number: ${invoice.number}`,
+        });
+    });
+  },
+};

package/sources/new-timesheet-entry/new-timesheet-entry.mjs

@@ -0,0 +1,47 @@
+import harvest from "../../harvest.app.mjs";
+
+export default {
+  key: "harvest-new-timesheet-entry",
+  name: "New Timesheet Entry",
+  description: "Emit new notifications when a new timesheet is created",
+  version: "0.0.1",
+  type: "source",
+  props: {
+    harvest,
+    timer: {
+      label: "Polling interval",
+      description: "Pipedream will poll Harvest API on this schedule",
+      type: "$.interface.timer",
+      default: {
+        intervalSeconds: 60 * 15,
+      },
+    },
+    db: "$.service.db",
+  },
+  dedupe: "unique",
+  async run() {
+    const data = [];
+    let lastDateChecked = this.harvest.getLastDateChecked(this.db);
+    if (!lastDateChecked) {
+      lastDateChecked = new Date().toISOString();
+      this.harvest.setLastDateChecked(this.db, lastDateChecked);
+    }
+    const entries = await this.harvest.listTimeEntriesPaginated({
+      page: 1,
+      updatedSince: lastDateChecked,
+    });
+    for await (const entry of entries) {
+      data.push(entry);
+    }
+    data && data.reverse().forEach((entry) => {
+      this.harvest.setLastDateChecked(this.db, entry.updated_at);
+      this.$emit(entry,
+        {
+          id: entry.id,
+          summary: `Task: ${entry.task.name} - ${entry.spent_date} ${entry.started_time || ""} ${entry.ended_time
+            ? " to " + entry.ended_time
+            : ""}`,
+        });
+    });
+  },
+};