@agnocon/piece-bexio 0.1.7

package/src/lib/actions/create-time-tracking.ts

@@ -0,0 +1,418 @@
+import { createAction, Property, OAuth2PropertyValue, DynamicPropsValue } from '@agnocon/pieces-framework';
+import { bexioAuth } from '../auth';
+import { BexioClient } from '../common/client';
+
+export const createTimeTrackingAction = createAction({
+  auth: bexioAuth,
+  name: 'create_time_tracking',
+  displayName: 'Create Time Tracking',
+  description: 'Create a new timesheet entry',
+  audience: 'both',
+  aiMetadata: { description: 'Logs a new timesheet entry in Bexio for a user against a client service/business activity, recording time either as a duration on a date or as a from/to range. Use to record worked or billable hours, optionally tying it to a contact, project, or milestone. Requires a user, client service, billable flag, and the tracking details for the chosen mode. Not idempotent: each call creates a separate entry.', idempotent: false },
+  props: {
+    user_id: Property.Dropdown({
+      auth: bexioAuth,
+      displayName: 'User',
+      description: 'User for this timesheet entry',
+      required: true,
+      refreshers: [],
+      options: async ({ auth }) => {
+        if (!auth) {
+          return {
+            disabled: true,
+            placeholder: 'Connect your Bexio account first',
+            options: [],
+          };
+        }
+
+        try { 
+          const client = new BexioClient(auth);
+          const users = await client.get<Array<{
+            id: number;
+            firstname?: string | null;
+            lastname?: string | null;
+            email: string;
+          }>>('/3.0/users');
+
+          return {
+            disabled: false,
+            options: users.map((user) => {
+              const name = user.firstname && user.lastname
+                ? `${user.firstname} ${user.lastname}`
+                : user.email;
+              return {
+                label: name,
+                value: user.id,
+              };
+            }),
+          };
+        } catch (error) {
+          return {
+            disabled: true,
+            placeholder: 'Failed to load users',
+            options: [],
+          };
+        }
+      },
+    }),
+    status_id: Property.Dropdown({
+      auth: bexioAuth,
+      displayName: 'Status',
+      description: 'Timesheet status',
+      required: false,
+      refreshers: [],
+      options: async ({ auth }) => {
+        if (!auth) {
+          return {
+            disabled: true,
+            placeholder: 'Connect your Bexio account first',
+            options: [],
+          };
+        }
+
+        try {
+          const client = new BexioClient(auth);
+          // TODO: Need to confirm endpoint - assuming /2.0/timesheet_status
+          const statuses = await client.get<Array<{ id: number; name: string }>>('/2.0/timesheet_status').catch(() => []);
+
+          return {
+            disabled: false,
+            options: statuses.map((status) => ({
+              label: status.name,
+              value: status.id,
+            })),
+          };
+        } catch (error) {
+          return {
+            disabled: true,
+            placeholder: 'Failed to load timesheet statuses',
+            options: [],
+          };
+        }
+      },
+    }),
+    client_service_id: Property.Dropdown({
+      auth: bexioAuth,
+      displayName: 'Client Service',
+      description: 'Business activity/client service',
+      required: true,
+      refreshers: [],
+      options: async ({ auth }) => {
+        if (!auth) {
+          return {
+            disabled: true,
+            placeholder: 'Connect your Bexio account first',
+            options: [],
+          };
+        }
+
+        try {
+          const client = new BexioClient(auth);
+          // TODO: Need to confirm endpoint - assuming /2.0/client_service
+          const services = await client.get<Array<{ id: number; name: string }>>('/2.0/client_service').catch(() => []);
+
+          return {
+            disabled: false,
+            options: services.map((service) => ({
+              label: service.name,
+              value: service.id,
+            })),
+          };
+        } catch (error) {
+          return {
+            disabled: true,
+            placeholder: 'Failed to load client services',
+            options: [],
+          };
+        }
+      },
+    }),
+    text: Property.LongText({
+      displayName: 'Description',
+      description: 'Description of the work performed',
+      required: false,
+    }),
+    allowable_bill: Property.Checkbox({
+      displayName: 'Allowable Bill',
+      description: 'Whether this time is billable',
+      required: true,
+      defaultValue: true,
+    }),
+    charge: Property.ShortText({
+      displayName: 'Charge',
+      description: 'Charge amount',
+      required: false,
+    }),
+    contact_id: Property.Dropdown({
+      auth: bexioAuth,
+      displayName: 'Contact',
+      description: 'Contact associated with this timesheet',
+      required: false,
+      refreshers: [],
+      options: async ({ auth }) => {
+        if (!auth) {
+          return {
+            disabled: true,
+            placeholder: 'Connect your Bexio account first',
+            options: [],
+          };
+        }
+
+        try {
+          const client = new BexioClient(auth);
+          const contacts = await client.get<Array<{
+            id: number;
+            contact_type_id: number;
+            name_1: string;
+            name_2?: string | null;
+            nr?: string | null;
+          }>>('/2.0/contact');
+
+          return {
+            disabled: false,
+            options: contacts.map((contact) => {
+              const name = contact.name_2
+                ? `${contact.name_2} ${contact.name_1}`
+                : contact.name_1;
+              const label = contact.nr ? `${name} (#${contact.nr})` : name;
+              return {
+                label,
+                value: contact.id,
+              };
+            }),
+          };
+        } catch (error) {
+          return {
+            disabled: true,
+            placeholder: 'Failed to load contacts',
+            options: [],
+          };
+        }
+      },
+    }),
+    sub_contact_id: Property.Dropdown({
+      auth: bexioAuth,
+      displayName: 'Sub Contact',
+      description: 'Sub contact (optional)',
+      required: false,
+      refreshers: [],
+      options: async ({ auth }) => {
+        if (!auth) {
+          return {
+            disabled: true,
+            placeholder: 'Connect your Bexio account first',
+            options: [],
+          };
+        }
+
+        try {
+          const client = new BexioClient(auth);
+          const contacts = await client.get<Array<{
+            id: number;
+            contact_type_id: number;
+            name_1: string;
+            name_2?: string | null;
+            nr?: string | null;
+          }>>('/2.0/contact');
+
+          return {
+            disabled: false,
+            options: contacts.map((contact) => {
+              const name = contact.name_2
+                ? `${contact.name_2} ${contact.name_1}`
+                : contact.name_1;
+              const label = contact.nr ? `${name} (#${contact.nr})` : name;
+              return {
+                label,
+                value: contact.id,
+              };
+            }),
+          };
+        } catch (error) {
+          return {
+            disabled: true,
+            placeholder: 'Failed to load contacts',
+            options: [],
+          };
+        }
+      },
+    }),
+    pr_project_id: Property.Dropdown({
+      auth: bexioAuth,
+      displayName: 'Project',
+      description: 'Project associated with this timesheet',
+      required: false,
+      refreshers: [],
+      options: async ({ auth }) => {
+        if (!auth) {
+          return {
+            disabled: true,
+            placeholder: 'Connect your Bexio account first',
+            options: [],
+          };
+        }
+
+        try {
+          const client = new BexioClient(auth);
+          const projects = await client.get<Array<{
+            id: number;
+            name: string;
+            nr?: string;
+          }>>('/2.0/pr_project');
+
+          return {
+            disabled: false,
+            options: projects.map((project) => ({
+              label: project.nr ? `${project.name} (#${project.nr})` : project.name,
+              value: project.id,
+            })),
+          };
+        } catch (error) {
+          return {
+            disabled: true,
+            placeholder: 'Failed to load projects',
+            options: [],
+          };
+        }
+      },
+    }),
+    pr_package_id: Property.Number({
+      displayName: 'Package ID',
+      description: 'Project package ID',
+      required: false,
+    }),
+    pr_milestone_id: Property.Number({
+      displayName: 'Milestone ID',
+      description: 'Project milestone ID',
+      required: false,
+    }),
+    estimated_time: Property.ShortText({
+      displayName: 'Estimated Time',
+      description: 'Estimated time (format: HH:MM)',
+      required: false,
+    }),
+    tracking_type: Property.StaticDropdown({
+      displayName: 'Tracking Type',
+      description: 'Type of time tracking',
+      required: true,
+      defaultValue: 'duration',
+      options: {
+        disabled: false,
+        options: [
+          { label: 'Duration', value: 'duration' },
+          { label: 'Range', value: 'range' },
+        ],
+      },
+    }),
+    tracking_details: Property.DynamicProperties({
+      auth: bexioAuth,  
+      displayName: 'Tracking Details',
+      description: 'Time tracking details',
+      required: true,
+      refreshers: ['tracking_type'],
+      props: async ({ tracking_type }) => {
+        const type = (tracking_type as unknown as string) || 'duration';
+        const dynamicProps: Record<string, any> = {};
+
+        if (type === 'duration') {
+          dynamicProps['date'] = Property.ShortText({
+            displayName: 'Date',
+            description: 'Date of the timesheet entry (YYYY-MM-DD)',
+            required: true,
+          });
+          dynamicProps['duration'] = Property.ShortText({
+            displayName: 'Duration',
+            description: 'Duration of time tracked (format: HH:MM)',
+            required: true,
+          });
+        } else {
+          // Range type
+          dynamicProps['from'] = Property.DateTime({
+            displayName: 'From',
+            description: 'Start date and time',
+            required: true,
+          });
+          dynamicProps['to'] = Property.DateTime({
+            displayName: 'To',
+            description: 'End date and time',
+            required: true,
+          });
+        }
+
+        return dynamicProps;
+      },
+    }),
+  },
+  async run({ auth, propsValue }) {
+    const client = new BexioClient(auth);
+    const props = propsValue;
+
+    const requestBody: Record<string, unknown> = {
+      user_id: props['user_id'],
+      client_service_id: props['client_service_id'],
+      allowable_bill: props['allowable_bill'],
+    };
+
+    if (props['status_id']) {
+      requestBody['status_id'] = props['status_id'];
+    }
+    if (props['text']) {
+      requestBody['text'] = props['text'];
+    }
+    if (props['charge']) {
+      requestBody['charge'] = props['charge'];
+    }
+    if (props['contact_id']) {
+      requestBody['contact_id'] = props['contact_id'];
+    }
+    if (props['sub_contact_id']) {
+      requestBody['sub_contact_id'] = props['sub_contact_id'];
+    }
+    if (props['pr_project_id']) {
+      requestBody['pr_project_id'] = props['pr_project_id'];
+    }
+    if (props['pr_package_id']) {
+      requestBody['pr_package_id'] = props['pr_package_id'];
+    }
+    if (props['pr_milestone_id']) {
+      requestBody['pr_milestone_id'] = props['pr_milestone_id'];
+    }
+    if (props['estimated_time']) {
+      requestBody['estimated_time'] = props['estimated_time'];
+    }
+
+    // Build tracking object
+    const trackingType = props['tracking_type'] as string;
+    const trackingDetails = props['tracking_details'] as DynamicPropsValue;
+    const tracking: Record<string, unknown> = {
+      type: trackingType,
+    };
+
+    if (trackingType === 'duration') {
+      tracking['date'] = trackingDetails['date'];
+      tracking['duration'] = trackingDetails['duration'];
+    } else {
+      // Range type
+      tracking['from'] = trackingDetails['from'];
+      tracking['to'] = trackingDetails['to'];
+    }
+
+    requestBody['tracking'] = tracking;
+
+    const response = await client.post<{
+      id: number;
+      user_id: number;
+      client_service_id: number;
+      tracking: {
+        type: string;
+        date?: string;
+        duration?: string;
+        from?: string;
+        to?: string;
+      };
+    }>('/2.0/timesheet', requestBody);
+
+    return response;
+  },
+});
+

package/src/lib/actions/export-invoice-pdf.ts

@@ -0,0 +1,104 @@
+import { createAction, Property, OAuth2PropertyValue } from '@agnocon/pieces-framework';
+import { bexioAuth } from '../auth';
+import { BexioClient } from '../common/client';
+
+export const exportInvoicePdfAction = createAction({
+  auth: bexioAuth,
+  name: 'export_invoice_pdf',
+  displayName: 'Export Invoice to PDF',
+  description: 'Export an existing sales invoice as a PDF document',
+  audience: 'both',
+  aiMetadata: { description: 'Renders an existing Bexio sales invoice as a PDF and returns the downloadable file, keyed by the invoice id. Use when an agent needs the document itself (to attach or store); pick Send Sales Invoice to email it to a recipient instead. Optionally toggle the letterhead. Read-only and idempotent: it generates the file without changing the invoice.', idempotent: true },
+  props: {
+    invoice_id: Property.Dropdown({
+      auth: bexioAuth,
+      displayName: 'Invoice',
+      description: 'Select the invoice to export',
+      required: true,
+      refreshers: [],
+      options: async ({ auth }) => {
+        if (!auth) {
+          return {
+            disabled: true,
+            placeholder: 'Connect your Bexio account first',
+            options: [],
+          };
+        }
+
+        try {
+          const client = new BexioClient(auth);
+          const invoices = await client.get<Array<{
+            id: number;
+            document_nr: string;
+            title?: string | null;
+            contact_id?: number | null;
+            total?: string;
+            kb_item_status_id?: number;
+          }>>('/2.0/kb_invoice');
+
+          return {
+            disabled: false,
+            options: invoices.map((invoice) => {
+              const label = invoice.title
+                ? `${invoice.document_nr} - ${invoice.title}`
+                : invoice.document_nr;
+              return {
+                label,
+                value: invoice.id,
+              };
+            }),
+          };
+        } catch (error) {
+          return {
+            disabled: true,
+            placeholder: 'Failed to load invoices',
+            options: [],
+          };
+        }
+      },
+    }),
+    logopaper: Property.StaticDropdown({
+      displayName: 'Letterhead',
+      description: 'Whether to include letterhead in the PDF',
+      required: false,
+      defaultValue: 1,
+      options: {
+        disabled: false,
+        options: [
+          { label: 'With Letterhead', value: 1 },
+          { label: 'Without Letterhead', value: 0 },
+        ],
+      },
+    }),
+  },
+  async run({ auth, propsValue, files }) {
+    const client = new BexioClient(auth);
+    const invoiceId = propsValue['invoice_id'] as number;
+    const logopaper = propsValue['logopaper'] as number | undefined;
+
+    const queryParams: Record<string, string> = {};
+    if (logopaper !== undefined) {
+      queryParams['logopaper'] = logopaper.toString();
+    }
+
+    const response = await client.get<{
+      name: string;
+      size: number;
+      mime: string;
+      content: string;
+    }>(`/2.0/kb_invoice/${invoiceId}/pdf`, queryParams);
+
+    const fileUrl = await files.write({
+      fileName: response.name || `invoice_${invoiceId}.pdf`,
+      data: Buffer.from(response.content, 'base64'),
+    });
+
+    return {
+      file: fileUrl,
+      fileName: response.name,
+      size: response.size,
+      mimeType: response.mime,
+    };
+  },
+});
+

package/src/lib/actions/find-account.ts

@@ -0,0 +1,114 @@
+import { createAction, Property, OAuth2PropertyValue } from '@agnocon/pieces-framework';
+import { bexioAuth } from '../auth';
+import { BexioClient } from '../common/client';
+
+export const findAccountAction = createAction({
+  auth: bexioAuth,
+  name: 'find_account',
+  displayName: 'Find Account',
+  description: 'Search for accounts using various criteria',
+  audience: 'both',
+  aiMetadata: { description: 'Searches the Bexio chart of accounts by number, name, type, or account group with operators such as contains, equals, or comparison, with paging. Use to resolve an account to its id before booking a manual entry or assigning an account on a product/position. Read-only and idempotent.', idempotent: true },
+  props: {
+    search_criteria: Property.Array({
+      displayName: 'Search Criteria',
+      description: 'Search criteria for finding accounts',
+      required: true,
+      properties: {
+        field: Property.StaticDropdown({
+          displayName: 'Search Field',
+          description: 'Field to search in',
+          required: true,
+          options: {
+            disabled: false,
+            options: [
+              { label: 'Account Number', value: 'account_no' },
+              { label: 'Account Name', value: 'name' },
+              { label: 'Account Type', value: 'account_type' },
+              { label: 'Account Group ID', value: 'fibu_account_group_id' },
+            ],
+          },
+        }),
+        value: Property.ShortText({
+          displayName: 'Search Value',
+          description: 'Value to search for',
+          required: true,
+        }),
+        criteria: Property.StaticDropdown({
+          displayName: 'Criteria',
+          description: 'Search criteria type',
+          required: false,
+          defaultValue: 'like',
+          options: {
+            disabled: false,
+            options: [
+              { label: 'Contains (like)', value: 'like' },
+              { label: 'Exact match (=)', value: '=' },
+              { label: 'Exact match (equal)', value: 'equal' },
+              { label: 'Not equal (!=)', value: '!=' },
+              { label: 'Not equal (not_equal)', value: 'not_equal' },
+              { label: 'Greater than (>)', value: '>' },
+              { label: 'Greater than (greater_than)', value: 'greater_than' },
+              { label: 'Greater or equal (>=)', value: '>=' },
+              { label: 'Greater or equal (greater_equal)', value: 'greater_equal' },
+              { label: 'Less than (<)', value: '<' },
+              { label: 'Less than (less_than)', value: 'less_than' },
+              { label: 'Less or equal (<=)', value: '<=' },
+              { label: 'Less or equal (less_equal)', value: 'less_equal' },
+              { label: 'Does not contain (not_like)', value: 'not_like' },
+              { label: 'Is NULL', value: 'is_null' },
+              { label: 'Is not NULL', value: 'not_null' },
+            ],
+          },
+        }),
+      },
+    }),
+    limit: Property.Number({
+      displayName: 'Limit',
+      description: 'Maximum number of results to return (max 2000)',
+      required: false,
+      defaultValue: 500,
+    }),
+    offset: Property.Number({
+      displayName: 'Offset',
+      description: 'Number of results to skip',
+      required: false,
+      defaultValue: 0,
+    }),
+  },
+  async run({ auth, propsValue }) {
+    const client = new BexioClient(auth);
+    const searchCriteria = propsValue['search_criteria'] as Array<Record<string, unknown>>;
+    const limit = propsValue['limit'] as number | undefined;
+    const offset = propsValue['offset'] as number | undefined;
+
+    const searchBody = searchCriteria.map((criteria) => ({
+      field: criteria['field'] as string,
+      value: criteria['value'] as string,
+      criteria: (criteria['criteria'] as string) || 'like',
+    }));
+
+    const queryParams: Record<string, string> = {};
+    if (limit !== undefined) {
+      queryParams['limit'] = limit.toString();
+    }
+    if (offset !== undefined) {
+      queryParams['offset'] = offset.toString();
+    }
+
+    const response = await client.post<Array<{
+      id: number;
+      uuid: string;
+      account_no: string;
+      name: string;
+      account_type: number;
+      tax_id?: number;
+      fibu_account_group_id?: number;
+      is_active: boolean;
+      is_locked: boolean;
+    }>>('/2.0/accounts/search', searchBody, queryParams);
+
+    return response;
+  },
+});
+