tave init

Author: luancazarine

components/tave/actions/create-contact/create-contact.mjs

@@ -0,0 +1,23 @@
+import tave from "../../tave.app.mjs";
+
+export default {
+  key: "tave-create-contact",
+  name: "Create Contact",
+  description: "Creates a new contact in the Tave system. [See the documentation](https://tave.io/v2)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    tave,
+    contact: {
+      propDefinition: [
+        tave,
+        "contact",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.tave.createContact(this.contact);
+    $.export("$summary", `Successfully created contact with name: ${response.name}`);
+    return response;
+  },
+};

components/tave/actions/create-job/create-job.mjs

@@ -0,0 +1,48 @@
+import tave from "../../tave.app.mjs";
+import { axios } from "@pipedream/platform";
+
+export default {
+  key: "tave-create-job",
+  name: "Create Job",
+  description: "Creates a new job in the Táve system with associated items typically linked with a job. [See the documentation](https://tave.io/v2)",
+  version: "0.0.{{ts}}",
+  type: "action",
+  props: {
+    tave,
+    jobDetails: {
+      propDefinition: [
+        tave,
+        "jobDetails",
+      ],
+    },
+    additionalItems: {
+      type: "string",
+      label: "Additional Items",
+      description: "Additional items for the job",
+      optional: true,
+    },
+    notes: {
+      type: "string",
+      label: "Notes",
+      description: "Additional notes for the job",
+      optional: true,
+    },
+    instructions: {
+      type: "string",
+      label: "Instructions",
+      description: "Additional instructions for the job",
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+    const response = await this.tave.createJob({
+      ...this.jobDetails,
+      additionalItems: this.additionalItems,
+      notes: this.notes,
+      instructions: this.instructions,
+    });
+
+    $.export("$summary", `Successfully created job with specifics: ${this.jobDetails.specifics}`);
+    return response;
+  },
+};

components/tave/actions/find-contact/find-contact.mjs

@@ -0,0 +1,24 @@
+import tave from "../../tave.app.mjs";
+import { axios } from "@pipedream/platform";
+
+export default {
+  key: "tave-find-contact",
+  name: "Find Contact",
+  description: "Searches for an existing contact in the Tave system. [See the documentation](https://tave.io/v2)",
+  version: "0.0.{{ts}}",
+  type: "action",
+  props: {
+    tave,
+    searchContact: {
+      propDefinition: [
+        tave,
+        "searchContact",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.tave.searchContact(this.searchContact);
+    $.export("$summary", `Successfully found contact(s) based on the query: ${this.searchContact}`);
+    return response;
+  },
+};

components/tave/package.json

@@ -12,4 +12,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

components/tave/sources/new-contact-instant/new-contact-instant.mjs

@@ -0,0 +1,64 @@
+import tave from "../../tave.app.mjs";
+import { axios } from "@pipedream/platform";
+
+export default {
+  key: "tave-new-contact-instant",
+  name: "New Contact Created",
+  description: "Emit new event when a contact is created. [See the documentation](https://tave.io/v2)",
+  version: "0.0.{{ts}}",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    tave,
+    http: {
+      type: "$.interface.http",
+      customResponse: false,
+    },
+    db: "$.service.db",
+    clientId: {
+      propDefinition: [
+        tave,
+        "clientId",
+      ],
+    },
+  },
+  methods: {
+    async _emitWebhookEvent(contact) {
+      this.$emit(contact, {
+        id: contact.id,
+        summary: `New contact created: ${contact.name}`,
+        ts: contact.createdAt
+          ? Date.parse(contact.createdAt)
+          : Date.now(),
+      });
+    },
+    _getWebhookId() {
+      return this.db.get("webhookId");
+    },
+    _setWebhookId(id) {
+      this.db.set("webhookId", id);
+    },
+  },
+  hooks: {
+    async deploy() {
+      const events = await this.tave.emitNewContactEvent(this.clientId);
+      for (const event of events) {
+        this._emitWebhookEvent(event);
+      }
+    },
+    async activate() {
+      const hookId = await this.tave.emitNewContactEvent(this.clientId);
+      this._setWebhookId(hookId);
+    },
+    async deactivate() {
+      const hookId = this._getWebhookId();
+      if (hookId) {
+        await this.tave.emitNewContactEvent(this.clientId); // Assuming the method handles the deletion
+      }
+    },
+  },
+  async run(event) {
+    const contact = event.body;
+    this._emitWebhookEvent(contact);
+  },
+};

components/tave/sources/new-order-booked-instant/new-order-booked-instant.mjs

@@ -0,0 +1,94 @@
+import tave from "../../tave.app.mjs";
+import { axios } from "@pipedream/platform";
+
+export default {
+  key: "tave-new-order-booked-instant",
+  name: "New Order Booked",
+  description: "Emit new event when an order is booked, including manually booked orders in manager and electronic bookings in client access. [See the documentation](https://tave.io/v2)",
+  version: "0.0.{{ts}}",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    tave,
+    http: {
+      type: "$.interface.http",
+      customResponse: true,
+    },
+    db: "$.service.db",
+    orderId: {
+      propDefinition: [
+        tave,
+        "orderId",
+      ],
+    },
+    managerId: {
+      propDefinition: [
+        tave,
+        "managerId",
+      ],
+    },
+    clientId: {
+      propDefinition: [
+        tave,
+        "clientId",
+      ],
+    },
+  },
+  methods: {
+    _getWebhookId() {
+      return this.db.get("webhookId");
+    },
+    _setWebhookId(id) {
+      this.db.set("webhookId", id);
+    },
+  },
+  hooks: {
+    async deploy() {
+      const events = await this.tave.emitNewOrderEvent(this.orderId, this.managerId, this.clientId);
+      for (const event of events.slice(-50)) {
+        this.$emit(event, {
+          id: event.id,
+          summary: `New order booked with ID ${event.id}`,
+          ts: Date.parse(event.createdAt),
+        });
+      }
+    },
+    async activate() {
+      const hookId = await this.tave.emitNewOrderEvent(this.orderId, this.managerId, this.clientId);
+      this._setWebhookId(hookId);
+    },
+    async deactivate() {
+      const id = this._getWebhookId();
+      if (id) {
+        await this.tave._makeRequest({
+          method: "DELETE",
+          path: `/webhooks/${id}`,
+        });
+      }
+    },
+  },
+  async run(event) {
+    const { body } = event;
+    const expectedSignature = {}; // Add logic to compute expected signature
+    const webhookSignature = event.headers["x-webhook-signature"];
+
+    if (webhookSignature !== expectedSignature) {
+      this.http.respond({
+        status: 401,
+        body: "Unauthorized",
+      });
+      return;
+    }
+
+    this.http.respond({
+      status: 200,
+      body: "OK",
+    });
+
+    this.$emit(body, {
+      id: body.orderId,
+      summary: `Order booked: ${body.orderId}`,
+      ts: Date.parse(body.createdAt),
+    });
+  },
+};

components/tave/sources/new-payment-instant/new-payment-instant.mjs

@@ -0,0 +1,67 @@
+import tave from "../../tave.app.mjs";
+import { axios } from "@pipedream/platform";
+
+export default {
+  key: "tave-new-payment-instant",
+  name: "New Payment Created",
+  description: "Emit new event when a new payment is created. [See the documentation](https://tave.io/v2/docs)",
+  version: "0.0.{{ts}}",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    tave,
+    http: {
+      type: "$.interface.http",
+      customResponse: false,
+    },
+    db: "$.service.db",
+    paymentId: {
+      propDefinition: [
+        tave,
+        "paymentId",
+      ],
+    },
+    orderId: {
+      propDefinition: [
+        tave,
+        "orderId",
+      ],
+      optional: true,
+    },
+  },
+  methods: {
+    _getWebhookId() {
+      return this.db.get("webhookId");
+    },
+    _setWebhookId(id) {
+      this.db.set("webhookId", id);
+    },
+  },
+  hooks: {
+    async deploy() {
+      const events = await this.tave.emitNewPaymentEvent(this.paymentId, this.orderId);
+      for (const event of events) {
+        this.$emit(event, {
+          id: event.id,
+          summary: `Historical payment event for payment ID: ${event.id}`,
+          ts: Date.now(),
+        });
+      }
+    },
+    async activate() {
+      const hookId = await this.tave.emitNewPaymentEvent(this.paymentId, this.orderId);
+      this._setWebhookId(hookId);
+    },
+    async deactivate() {
+      const hookId = this._getWebhookId();
+      // Implement the logic to delete the webhook, if supported by the API
+    },
+  },
+  async run(event) {
+    this.$emit(event.body, {
+      id: event.body.paymentId,
+      summary: `New payment created with ID: ${event.body.paymentId}`,
+      ts: Date.now(),
+    });
+  },
+};