@agnocon/piece-bigin-by-zoho 0.1.6

package/src/lib/actions/search-company-record.ts

@@ -0,0 +1,57 @@
+import { biginAuth } from '../auth';
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { biginApiService } from '../common/request';
+
+export const searchCompanyRecord = createAction({
+  auth: biginAuth,
+  name: 'searchCompanyRecord',
+  displayName: 'Search Company Record',
+  description: 'Searches companies by full name (criteria) or word',
+  audience: 'both',
+  aiMetadata: { description: 'Searches company (account) records in Bigin CRM and returns matches. Choose between Criteria mode (matches the Account Name with equals or starts-with) and Word mode (a free-text word search across the module). Use to find a company by name before referencing or updating it. Idempotent: read-only, repeating the search returns the same matches.', idempotent: true },
+  props: {
+    mode: Property.StaticDropdown({
+      displayName: 'Search Mode',
+      required: true,
+      defaultValue: 'criteria',
+      options: {
+        options: [
+          { label: 'Criteria (full name)', value: 'criteria' },
+          { label: 'Word', value: 'word' },
+        ],
+      },
+    }),
+    companyName: Property.ShortText({
+      displayName: 'Search Term',
+      description: 'Company full name (criteria) or word',
+      required: true,
+    }),
+  },
+  async run({ auth, propsValue }) {
+    const { companyName, mode } = propsValue;
+
+    const { access_token, data } = auth;
+    const api_domain = data['api_domain'];
+
+    try {
+      const response = await biginApiService.searchRecords(
+        access_token,
+        api_domain,
+        'Accounts',
+        mode === 'word'
+          ? { key: 'word', value: companyName }
+          : {
+              key: 'criteria',
+              value: `(Account_Name:equals:${companyName})OR(Account_Name:starts_with:${companyName})`,
+            }
+      );
+
+      return {
+        message: 'Company record search completed successfully',
+        data: response.data,
+      };
+    } catch (error: any) {
+      throw new Error(`Error searching company record: ${error.message}`);
+    }
+  },
+});

package/src/lib/actions/search-contact-record.ts

@@ -0,0 +1,79 @@
+import { biginAuth } from '../auth';
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { biginApiService } from '../common/request';
+
+export const searchContactRecord = createAction({
+  auth: biginAuth,
+  name: 'searchContactRecord',
+  displayName: 'Search Contact Record',
+  description: 'Searches contacts by criteria, email, phone, or word',
+  audience: 'both',
+  aiMetadata: { description: 'Searches contact (person) records in Bigin CRM and returns matches. The search mode selects what the term is matched against: Criteria (name/email/mobile with equals or starts-with), a dedicated Email lookup, a dedicated Phone lookup, or a free-text Word search. Use to find a person by name, email, or phone before referencing or updating them. Idempotent: read-only, repeating the search returns the same matches.', idempotent: true },
+  props: {
+    mode: Property.StaticDropdown({
+      displayName: 'Search Mode',
+      description: 'Choose how to search Contacts',
+      required: true,
+      defaultValue: 'criteria',
+      options: {
+        options: [
+          { label: 'Criteria (name/email/mobile)', value: 'criteria' },
+          { label: 'Email', value: 'email' },
+          { label: 'Phone', value: 'phone' },
+          { label: 'Word', value: 'word' },
+        ],
+      },
+    }),
+    searchTerm: Property.ShortText({
+      displayName: 'Search Term',
+      description: 'Text, email, phone, or word based on the selected mode',
+      required: true,
+    }),
+  },
+  async run({ auth, propsValue }) {
+    const { searchTerm, mode } = propsValue;
+
+    const { access_token, data } = auth;
+    const api_domain = data['api_domain'];
+
+    let queryKey = 'criteria';
+    let queryValue = '';
+    if (mode === 'email') {
+      queryKey = 'email';
+      queryValue = searchTerm;
+    } else if (mode === 'phone') {
+      queryKey = 'phone';
+      queryValue = searchTerm;
+    } else if (mode === 'word') {
+      queryKey = 'word';
+      queryValue = searchTerm;
+    } else {
+      queryValue = ['First_Name', 'Last_Name', 'Email', 'Mobile']
+        .flatMap((key) => [
+          `${key}:equals:${searchTerm}`,
+          `${key}:starts_with:${searchTerm}`,
+        ])
+        .map((condition) => `(${condition})`)
+        .join('OR');
+    }
+
+    try {
+      const response = await biginApiService.searchRecords(
+        access_token,
+        api_domain,
+        'Contacts',
+        {
+          key: queryKey,
+          value: queryValue,
+        }
+      );
+
+      return {
+        message: 'Contact record search completed successfully',
+        data: response.data,
+      };
+    } catch (error: any) {
+      throw new Error(`Error searching contact record: ${error.message}`);
+    }
+  },
+});

package/src/lib/actions/search-pipeline-records.ts

@@ -0,0 +1,52 @@
+import { biginAuth } from '../auth';
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { biginApiService } from '../common/request';
+
+export const searchPipelineRecord = createAction({
+  auth: biginAuth,
+  name: 'searchPipelineRecord',
+  displayName: 'Search Pipeline Record',
+  description: 'Searches deals by name via criteria or word',
+  audience: 'both',
+  aiMetadata: { description: 'Searches pipeline records (deals) in Bigin CRM and returns matches. Choose between Criteria mode (matches the Deal Name with equals or starts-with) and Word mode (a free-text word search across the module). Use to find a deal by name before referencing or updating it. Idempotent: read-only, repeating the search returns the same matches.', idempotent: true },
+  props: {
+    mode: Property.StaticDropdown({
+      displayName: 'Search Mode',
+      required: true,
+      defaultValue: 'criteria',
+      options: {
+        options: [
+          { label: 'Criteria (Deal Name)', value: 'criteria' },
+          { label: 'Word', value: 'word' },
+        ],
+      },
+    }),
+    dealName: Property.ShortText({
+      displayName: 'Search Term',
+      description: 'Deal Name (criteria) or word',
+      required: true,
+    }),
+  },
+  async run({ auth, propsValue }) {
+    const { dealName, mode } = propsValue;
+
+    const { access_token, data } = auth;
+    const api_domain = data['api_domain'];
+
+    try {
+      const response = await biginApiService.searchRecords(
+        access_token,
+        api_domain,
+        'Pipelines',
+        mode === 'word' ? { key: 'word', value: dealName } : { key: 'criteria', value: `(Deal_Name:equals:${dealName})OR(Deal_Name:starts_with:${dealName})` }
+      );
+
+      return {
+        message: 'Pipeline record search completed successfully',
+        data: response.data,
+      };
+    } catch (error: any) {
+      throw new Error(`Error searching pipeline record: ${error.message}`);
+    }
+  },
+});

package/src/lib/actions/search-product.ts

@@ -0,0 +1,60 @@
+import { biginAuth } from '../auth';
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { biginApiService } from '../common/request';
+
+export const searchProductRecord = createAction({
+  auth: biginAuth,
+  name: 'searchProductRecord',
+  displayName: 'Search Product Record',
+  description: 'Searches products by name/code via criteria or word',
+  audience: 'both',
+  aiMetadata: { description: 'Searches product records in Bigin CRM and returns matches. Choose between Criteria mode (matches Product Name or Product Code with equals or starts-with) and Word mode (a free-text word search across the module). Use to find a product by name or code before associating it with a deal. Idempotent: read-only, repeating the search returns the same matches.', idempotent: true },
+  props: {
+    mode: Property.StaticDropdown({
+      displayName: 'Search Mode',
+      required: true,
+      defaultValue: 'criteria',
+      options: {
+        options: [
+          { label: 'Criteria (name/code)', value: 'criteria' },
+          { label: 'Word', value: 'word' },
+        ],
+      },
+    }),
+    searchTerm: Property.ShortText({
+      displayName: 'Search Term',
+      description: 'Product name/code (criteria) or word',
+      required: true,
+    }),
+  },
+  async run({ auth, propsValue }) {
+    const { searchTerm, mode } = propsValue;
+
+    const { access_token, data } = auth;
+    const api_domain = data['api_domain'];
+
+    const criteriaValue = ['Product_Name', 'Product_Code']
+      .flatMap((key) => [
+        `${key}:equals:${searchTerm}`,
+        `${key}:starts_with:${searchTerm}`,
+      ])
+      .map((condition) => `(${condition})`)
+      .join('OR');
+
+    try {
+      const response = await biginApiService.searchRecords(
+        access_token,
+        api_domain,
+        'Products',
+        mode === 'word' ? { key: 'word', value: searchTerm } : { key: 'criteria', value: criteriaValue }
+      );
+
+      return {
+        message: 'Product record search completed successfully',
+        data: response.data,
+      };
+    } catch (error: any) {
+      throw new Error(`Error searching product record: ${error.message}`);
+    }
+  },
+});

package/src/lib/actions/search-user.ts

@@ -0,0 +1,70 @@
+import { biginAuth } from '../auth';
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { biginApiService } from '../common/request';
+
+export const searchUser = createAction({
+  auth: biginAuth,
+  name: 'searchUser',
+  displayName: 'Search User',
+  description: 'Locate users by email.',
+  audience: 'both',
+  aiMetadata: { description: 'Finds Bigin CRM org users whose email contains the given term (case-insensitive substring match), filtering client-side over the user list; an optional user-type filter (e.g. active, admin, current user) and pagination narrow the fetched set. Use to resolve a user id for assigning records as owner. Idempotent: read-only, repeating the search returns the same matches.', idempotent: true },
+  props: {
+    email: Property.ShortText({
+      displayName: 'Email',
+      description: 'User email address (full or partial, case-insensitive match)',
+      required: true,
+    }),
+    type: Property.StaticDropdown({
+      displayName: 'User Type (optional)',
+      required: false,
+      options: {
+        options: [
+          { label: 'All Users', value: 'AllUsers' },
+          { label: 'Active Users', value: 'ActiveUsers' },
+          { label: 'Deactive Users', value: 'DeactiveUsers' },
+          { label: 'Confirmed Users', value: 'ConfirmedUsers' },
+          { label: 'Not Confirmed Users', value: 'NotConfirmedUsers' },
+          { label: 'Deleted Users', value: 'DeletedUsers' },
+          { label: 'Active Confirmed Users', value: 'ActiveConfirmedUsers' },
+          { label: 'Admin Users', value: 'AdminUsers' },
+          { label: 'Active Confirmed Admins', value: 'ActiveConfirmedAdmins' },
+          { label: 'Current User', value: 'CurrentUser' },
+        ],
+      },
+    }),
+    page: Property.Number({
+      displayName: 'Page',
+      required: false,
+      description: 'Page index (default 1)',
+    }),
+    per_page: Property.Number({
+      displayName: 'Per Page',
+      required: false,
+      description: 'Records per page (max 200, default 200)',
+    }),
+  },
+  async run({ auth, propsValue }) {
+    const { access_token, data } = auth;
+    const api_domain = data['api_domain'];
+    const emailTerm = String(propsValue.email || '').toLowerCase();
+
+    const params: any = {};
+    if (propsValue.type) params.type = propsValue.type as string;
+    if (propsValue.page) params.page = Number(propsValue.page);
+    if (propsValue.per_page) params.per_page = Number(propsValue.per_page);
+
+    const resp = await biginApiService.fetchUsers(access_token, api_domain, params);
+
+    const users = Array.isArray(resp.users) ? resp.users : [];
+    const filtered = users.filter((u: any) => String(u.email || '').toLowerCase().includes(emailTerm));
+
+    return {
+      message: 'User search completed successfully',
+      count: filtered.length,
+      data: filtered,
+    };
+  },
+});
+
+

package/src/lib/actions/update-company.ts

@@ -0,0 +1,235 @@
+import { biginAuth } from '../auth';
+import {
+  createAction,
+  InputPropertyMap,
+  Property,
+} from '@agnocon/pieces-framework';
+import { tagsDropdown, usersDropdown } from '../common/props';
+import { biginApiService } from '../common/request';
+import { handleDropdownError } from '../common/helpers';
+
+export const updateCompany = createAction({
+  auth: biginAuth,
+  name: 'updateCompany',
+  displayName: 'Update Company',
+  description:
+    'Updates an existing Company and prepopulates its fields for editing.',
+  audience: 'both',
+  aiMetadata: { description: 'Updates an existing company (account) record in Bigin CRM, identified by selecting the company; its current fields are prepopulated and any you set are overwritten (owner, tags, billing address, and module-defined fields). Use to modify an organization that already exists. Idempotent: re-sending the same field values leaves the record in the same state.', idempotent: true },
+  props: {
+    companyId: Property.Dropdown({
+      auth: biginAuth,
+      displayName: 'Select Company',
+      description: 'Choose a company to update',
+      required: true,
+      refreshers: ['auth'],
+      options: async (context: any) => {
+        if (!context.auth)
+          return handleDropdownError('Please connect your account first');
+
+        const response = await biginApiService.fetchCompanies(
+          context.auth.access_token,
+          context.auth.data['api_domain']
+        );
+
+        return {
+          options: response.data.map((company: any) => ({
+            label: company.Account_Name,
+            value: JSON.stringify(company),
+          })),
+        };
+      },
+    }),
+    owner: usersDropdown,
+    companyDetails: Property.DynamicProperties({
+      auth: biginAuth,
+      displayName: 'Company Details',
+      description: 'These fields will be prepopulated with company data',
+      refreshers: ['companyId', 'auth'],
+      required: true,
+      props: async ({ companyId, auth }: any): Promise<InputPropertyMap> => {
+        if (!companyId) return {};
+        const company = JSON.parse(companyId);
+        const { access_token, data } = auth;
+        const api_domain = data['api_domain'];
+
+        const [fieldsResp, usersResp] = await Promise.all([
+          biginApiService.fetchModuleFields(access_token, api_domain, 'Accounts'),
+          biginApiService.fetchUsers(access_token, api_domain),
+        ]);
+
+        const usersOptions = (usersResp.users || []).map((u: any) => ({
+          label: `${u.first_name ?? ''} ${u.last_name ?? ''}`.trim(),
+          value: u.id,
+        }));
+
+        const props: InputPropertyMap = {};
+        const fields = (fieldsResp.fields || []) as any[];
+        for (const f of fields) {
+          const apiName = f.api_name as string;
+
+          if (f.read_only || f.field_read_only) continue;
+          if (!f.view_type || f.view_type.edit !== true) continue;
+          if (apiName === 'Tag' || apiName === 'id') continue;
+
+          let defaultValue: any = company[apiName] ?? undefined;
+          if (apiName === 'Owner') defaultValue = company.Owner?.id;
+
+          switch ((f.data_type as string)?.toLowerCase()) {
+            case 'picklist': {
+              const options = (f.pick_list_values || []).map((pl: any) => ({
+                label: pl.display_value,
+                value: pl.actual_value,
+              }));
+              props[apiName] = Property.StaticDropdown({
+                displayName: f.display_label || f.field_label || apiName,
+                description: f.tooltip || undefined,
+                required: false,
+                defaultValue,
+                options: { options },
+              });
+              break;
+            }
+            case 'multiselectpicklist': {
+              const options = (f.pick_list_values || []).map((pl: any) => ({
+                label: pl.display_value,
+                value: pl.actual_value,
+              }));
+              props[apiName] = Property.StaticMultiSelectDropdown({
+                displayName: f.display_label || f.field_label || apiName,
+                description: f.tooltip || undefined,
+                required: false,
+                defaultValue,
+                options: { options },
+              });
+              break;
+            }
+            case 'boolean': {
+              props[apiName] = Property.Checkbox({
+                displayName: f.display_label || f.field_label || apiName,
+                description: f.tooltip || undefined,
+                required: false,
+                defaultValue: Boolean(defaultValue),
+              });
+              break;
+            }
+            case 'date': {
+              props[apiName] = Property.ShortText({
+                displayName: f.display_label || f.field_label || apiName,
+                description: f.tooltip || undefined,
+                required: false,
+                defaultValue,
+              });
+              break;
+            }
+            case 'datetime': {
+              props[apiName] = Property.DateTime({
+                displayName: f.display_label || f.field_label || apiName,
+                description: f.tooltip || undefined,
+                required: false,
+                defaultValue,
+              });
+              break;
+            }
+            case 'integer':
+            case 'long':
+            case 'double':
+            case 'decimal':
+            case 'currency':
+            case 'percent': {
+              props[apiName] = Property.Number({
+                displayName: f.display_label || f.field_label || apiName,
+                description: f.tooltip || undefined,
+                required: false,
+                defaultValue,
+              });
+              break;
+            }
+            default: {
+              if (apiName === 'Owner') {
+                props[apiName] = Property.StaticDropdown({
+                  displayName: 'Owner',
+                  description: f.tooltip || undefined,
+                  required: false,
+                  defaultValue,
+                  options: { options: usersOptions },
+                });
+                break;
+              }
+              if (apiName === 'Description') {
+                props[apiName] = Property.LongText({
+                  displayName: 'Description',
+                  description: f.tooltip || undefined,
+                  required: false,
+                  defaultValue,
+                });
+                break;
+              }
+              props[apiName] = Property.ShortText({
+                displayName: f.display_label || f.field_label || apiName,
+                description: f.tooltip || undefined,
+                required: false,
+                defaultValue: typeof defaultValue === 'string' ? defaultValue : undefined,
+              });
+            }
+          }
+        }
+
+        return props;
+      },
+    }),
+    tag: tagsDropdown('Accounts'),
+  },
+
+  async run(context) {
+    try {
+      const company = JSON.parse(context.propsValue.companyId);
+      const companyId = company.id;
+      const updates = context.propsValue.companyDetails as Record<string, any>;
+
+      const body: Record<string, any> = { id: companyId };
+
+      for (const [apiName, value] of Object.entries(updates || {})) {
+        if (
+          value === undefined ||
+          value === null ||
+          (typeof value === 'string' && value.trim() === '')
+        ) {
+          continue;
+        }
+        if (apiName === 'Owner') {
+          body['Owner'] = { id: value };
+        } else if (apiName === 'Tag') {
+          body['Tag'] = (value as any[]).map((t: any) => ({ name: t }));
+        } else {
+          body[apiName] = value;
+        }
+      }
+
+      if (context.propsValue.owner) {
+        body['Owner'] = { id: context.propsValue.owner };
+      }
+      if (
+        context.propsValue.tag &&
+        Array.isArray(context.propsValue.tag) &&
+        context.propsValue.tag.length > 0
+      ) {
+        body['Tag'] = context.propsValue.tag.map((t: any) => ({ name: t }));
+      }
+
+      const response = await biginApiService.updateCompany(
+        context.auth.access_token,
+        (context.auth as any).api_domain,
+        { data: [body] }
+      );
+
+      return {
+        message: 'Company updated successfully',
+        data: response.data[0],
+      };
+    } catch (error: any) {
+      console.error('Error updating company:', error);
+      throw new Error(error);
+    }
+  },
+});