@guayaba/workflow-piece-google-sheets 0.14.6

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

@@ -0,0 +1,135 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import {
+	areSheetIdsValid,
+	googleSheetsCommon,
+	labelToColumn,
+	mapRowsToHeaderNames,
+} from '../common/common';
+import { googleSheetsAuth } from '../common/common';
+import { z } from 'zod';
+import { propsValidation } from '@guayaba/workflows-common';
+import { columnNameProp, commonProps } from '../common/props';
+
+export const findRowsAction = createAction({
+	auth: googleSheetsAuth,
+	name: 'find_rows',
+description: 'Look up rows in a worksheet based on a column value.',
+	displayName: 'Find Rows',
+	props: {
+		...commonProps,
+		columnName: columnNameProp(),
+		searchValue: Property.ShortText({
+			displayName: 'Search Value',
+			description: 'The value to look for in the selected column. Leave empty to return all rows.',
+			required: false,
+		}),
+		matchCase: Property.Checkbox({
+			displayName: 'Exact Match',
+			description: 'Only return rows where the cell value exactly matches the search value.',
+			required: true,
+			defaultValue: false,
+		}),
+		startingRow: Property.Number({
+			displayName: 'Starting Row',
+			description: 'Start searching from this row number.',
+			required: false,
+		}),
+		numberOfRows: Property.Number({
+			displayName: 'Number of Rows',
+			description: 'How many rows to return. Defaults to 1 if not specified.',
+			required: false,
+			defaultValue: 1,
+		}),
+		headerRow: Property.Number({
+			displayName: 'Header Row',
+			description: 'The row number that contains the column names.',
+			required: true,
+			defaultValue: 1,
+		}),
+		useHeaderNames: Property.Checkbox({
+			displayName: 'Use Column Names',
+			description: 'Use column names as keys instead of A, B, C.',
+			required: false,
+			defaultValue: false,
+		}),
+	},
+	async run({ propsValue, auth }) {
+		await propsValidation.validateZod(propsValue, {
+			startingRow: z.number().min(1).optional(),
+			numberOfRows: z.number().min(1).optional(),
+		});
+
+		const spreadsheetId = propsValue.spreadsheetId;
+		const sheetId = propsValue.sheetId;
+		const startingRow = propsValue.startingRow ?? 1;
+		const numberOfRowsToReturn = propsValue.numberOfRows ?? 1;
+		const headerRow = propsValue.headerRow;
+		const useHeaderNames = propsValue.useHeaderNames as boolean;
+
+		if (!areSheetIdsValid(spreadsheetId, sheetId)) {
+			throw new Error('Please select a spreadsheet and sheet first.');
+		}
+
+		const rows = await googleSheetsCommon.getGoogleSheetRows({
+			spreadsheetId: spreadsheetId as string,
+			auth: auth,
+			sheetId: sheetId as number,
+			rowIndex_s: startingRow,
+			rowIndex_e: undefined,
+			headerRow: headerRow,
+		});
+
+		const values = rows.map((row) => {
+			return row.values;
+		});
+
+		const matchingRows: any[] = [];
+		const columnName = propsValue.columnName ? propsValue.columnName : 'A';
+		const columnNumber: number = labelToColumn(columnName);
+		const searchValue = propsValue.searchValue ?? '';
+
+		let matchedRowCount = 0;
+
+		for (let i = 0; i < values.length; i++) {
+			const row: Record<string, any> = values[i];
+
+			if (matchedRowCount === numberOfRowsToReturn) break;
+
+			if (searchValue === '') {
+				matchingRows.push(rows[i]);
+				matchedRowCount += 1;
+				continue;
+			}
+
+			const keys = Object.keys(row);
+			if (keys.length <= columnNumber) continue;
+			const entry_value = row[keys[columnNumber]];
+
+			if (entry_value === undefined) {
+				continue;
+			}
+			if (propsValue.matchCase) {
+				if (entry_value === searchValue) {
+					matchedRowCount += 1;
+					matchingRows.push(rows[i]);
+				}
+			} else {
+				if (entry_value.toLowerCase().includes(searchValue.toLowerCase())) {
+					matchedRowCount += 1;
+					matchingRows.push(rows[i]);
+				}
+			}
+		}
+
+		const finalRows = await mapRowsToHeaderNames(
+			matchingRows,
+			useHeaderNames,
+			spreadsheetId as string,
+			sheetId as number,
+			headerRow,
+			auth,
+		);
+
+		return finalRows;
+	},
+});

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

@@ -0,0 +1,83 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import {
+	httpClient,
+	HttpMethod,
+	AuthenticationType,
+	HttpRequest,
+} from '@guayaba/workflows-common';
+import { googleSheetsAuth } from '../common/common';
+import { includeTeamDrivesProp } from '../common/props';
+import { getAccessToken } from '../common/common';
+
+export const findSpreadsheets = createAction({
+	name: 'find_spreadsheets',
+	displayName: 'Find Spreadsheet(s)',
+	description: 'Find spreadsheet(s) by name.',
+	auth: googleSheetsAuth,
+	props: {
+		includeTeamDrives: includeTeamDrivesProp(),
+		spreadsheet_name: Property.ShortText({
+			displayName: 'Spreadsheet Name',
+			description: 'Enter the name of the spreadsheet to search for',
+			required: true,
+		}),
+		exact_match: Property.Checkbox({
+			displayName: 'Exact Match',
+			description:
+				'If true, only return spreadsheets that exactly match the name. If false, return spreadsheets that contain the name.',
+			required: false,
+			defaultValue: false,
+		}),
+	},
+	async run({ propsValue, auth }) {
+		const searchValue = propsValue.spreadsheet_name;
+		const queries = ["mimeType='application/vnd.google-apps.spreadsheet'", 'trashed=false'];
+
+		if (propsValue.exact_match) {
+			queries.push(`name = '${searchValue}'`);
+		} else {
+			queries.push(`name contains '${searchValue}'`);
+		}
+
+		const files = [];
+		let pageToken = null;
+
+		do {
+			const request: HttpRequest = {
+				method: HttpMethod.GET,
+				url: 'https://www.googleapis.com/drive/v3/files',
+				queryParams: {
+					q: queries.join(' and '),
+					includeItemsFromAllDrives: propsValue.includeTeamDrives ? 'true' : 'false',
+					supportsAllDrives: 'true',
+					fields: 'files(id,name,webViewLink,createdTime,modifiedTime),nextPageToken',
+				},
+				authentication: {
+					type: AuthenticationType.BEARER_TOKEN,
+					token: await getAccessToken(auth),
+				},
+			};
+			if (pageToken) {
+				if (request.queryParams !== undefined) {
+					request.queryParams['pageToken'] = pageToken;
+				}
+			}
+			try {
+				const response = await httpClient.sendRequest<{
+					files: { id: string; name: string }[];
+					nextPageToken: string;
+				}>(request);
+
+				files.push(...response.body.files);
+				pageToken = response.body.nextPageToken;
+			} catch (e) {
+				throw new Error(`Failed to get folders\nError:${e}`);
+			}
+		} while (pageToken);
+
+		return {
+			found: files.length > 0,
+			spreadsheets: files,
+		};
+	},
+});

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

@@ -0,0 +1,52 @@
+import { googleSheetsAuth } from '../common/common';
+import { createAction, Property } from '@guayaba/workflows-framework';
+import { google } from 'googleapis';
+import { includeTeamDrivesProp, spreadsheetIdProp } from '../common/props';
+import { createGoogleClient } from '../common/common';
+
+export const findWorksheetAction = createAction({
+	auth: googleSheetsAuth,
+	name: 'find-worksheet',
+	displayName: 'Find Worksheet(s)',
+	description: 'Finds a worksheet(s) by title.',
+	props: {
+		includeTeamDrives: includeTeamDrivesProp(),
+		spreadsheetId: spreadsheetIdProp('Spreadsheet', ''),
+		title: Property.ShortText({
+			displayName: 'Title',
+			required: true,
+		}),
+		exact_match: Property.Checkbox({
+			displayName: 'Exact Match',
+			description:
+				'If true, only return worksheets that exactly match the name. If false, return worksheets that contain the name.',
+			required: false,
+			defaultValue: false,
+		}),
+	},
+	async run(context) {
+		const spreadsheetId = context.propsValue.spreadsheetId;
+		const title = context.propsValue.title;
+		const exactMatch = context.propsValue.exact_match ?? false;
+
+		const authClient = await createGoogleClient(context.auth);
+
+		const sheets = google.sheets({ version: 'v4', auth: authClient });
+
+		const response = await sheets.spreadsheets.get({
+			spreadsheetId,
+		});
+
+		const sheetsData = response.data.sheets ?? [];
+
+		const matchedSheets = sheetsData.filter((sheet) => {
+			const sheetTitle = sheet.properties?.title ?? '';
+			return exactMatch ? sheetTitle === title : sheetTitle.includes(title);
+		});
+
+		return {
+			found: matchedSheets.length > 0,
+			worksheets: matchedSheets,
+		};
+	},
+});

package/src/lib/actions/format-spreadsheet-row.ts

@@ -0,0 +1,112 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import { areSheetIdsValid, createGoogleClient } from '../common/common';
+import { googleSheetsAuth } from '../common/common';
+import { commonProps } from '../common/props';
+import { google } from 'googleapis';
+import { isNil } from '@guayaba/workflows-shared';
+
+export const formatRowAction = createAction({
+	auth: googleSheetsAuth,
+	name: 'format-row',
+	description: 'Format one or multiple rows in specific spreadsheet.',
+	displayName: 'Format Row(s)',
+	props: {
+		...commonProps,
+		startingRow: Property.Number({
+			displayName: 'Starting row',
+			description: 'The first row number where formatting should begin.',
+			required: true,
+		}),
+		endingRow: Property.Number({
+			displayName: 'Ending row',
+			description:
+				'The last row number where formatting should stop (leave empty to format only the starting row).',
+			required: false,
+		}),
+		bgColor: Property.ShortText({
+			displayName: 'Background Color',
+			description: 'Provide a HEX color code (example: #FFD966)',
+			required: false,
+		}),
+		textColor: Property.ShortText({
+			displayName: 'Text Color',
+			description: 'Provide a HEX color code (example: #FFD966)',
+			required: false,
+		}),
+		bold: Property.Checkbox({
+			displayName: 'Make text bold',
+			required: false,
+		}),
+		italic: Property.Checkbox({
+			displayName: 'Make text Italic',
+			required: false,
+		}),
+		strikethrough: Property.Checkbox({
+			displayName: 'Make text Strikethrough',
+			required: false,
+		}),
+	},
+	async run(context) {
+		const { spreadsheetId, sheetId, startingRow,endingRow, bgColor, textColor, italic, bold, strikethrough } =
+			context.propsValue;
+
+		if (!areSheetIdsValid(spreadsheetId, sheetId)) {
+			throw new Error('Please select a spreadsheet and sheet first.');
+		}
+
+		const authClient = await createGoogleClient(context.auth);
+		const sheets = google.sheets({ version: 'v4', auth: authClient });
+
+		const response = await sheets.spreadsheets.batchUpdate({
+			spreadsheetId: context.propsValue.spreadsheetId,
+			requestBody: {
+				requests: [
+					{
+						repeatCell: {
+							range: {
+								sheetId,
+								startRowIndex: startingRow - 1,
+								endRowIndex: endingRow ? endingRow : startingRow,
+							},
+							cell: {
+								userEnteredFormat: {
+									backgroundColor: hexToRgb(bgColor),
+									textFormat: {
+										bold,
+										italic,
+										strikethrough,
+										foregroundColor: hexToRgb(textColor),
+									},
+								},
+							},
+							fields: 'userEnteredFormat(backgroundColor,textFormat)',
+						},
+					},
+				],
+			},
+		});
+
+		return {
+			success: true,
+			...response.data,
+		};
+	},
+});
+
+function hexToRgb(hex?: string) {
+	// Expand shorthand form (e.g. "03F") to full form (e.g. "0033FF")
+	if (isNil(hex)) return undefined;
+	const shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
+	hex = hex.replace(shorthandRegex, function (m, r, g, b) {
+		return r + r + g + g + b + b;
+	});
+
+	const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+	return result
+		? {
+				red: parseInt(result[1], 16),
+				green: parseInt(result[2], 16),
+				blue: parseInt(result[3], 16),
+		  }
+		: undefined;
+}

package/src/lib/actions/get-many-rows.ts

@@ -0,0 +1,42 @@
+import { createAction } from "@guayaba/workflows-framework";
+import { areSheetIdsValid, googleSheetsAuth, googleSheetsCommon, mapRowsToHeaderNames } from "../common/common";
+import { commonProps, isFirstRowHeaderProp } from "../common/props";
+
+export const getManyRowsAction = createAction({
+    name: 'get-many-rows',
+    auth: googleSheetsAuth,
+    displayName: 'Get All Rows',
+    description: 'Get all the rows from a specific sheet.',
+    props: {
+        ...commonProps,
+        first_row_headers: isFirstRowHeaderProp()
+    },
+    async run(context) { 
+        const {first_row_headers,sheetId,spreadsheetId} = context.propsValue;
+
+        if (!areSheetIdsValid(spreadsheetId, sheetId)) {
+                    throw new Error('Please select a spreadsheet and sheet first.');
+                }
+        const rows = await googleSheetsCommon.getGoogleSheetRows({
+            auth:context.auth,
+            sheetId: sheetId as number,
+            spreadsheetId: spreadsheetId as string,
+            rowIndex_s:undefined,
+            rowIndex_e:undefined,
+            headerRow: 1,
+          });
+
+        const useHeaderNames = first_row_headers;
+
+        const result = await mapRowsToHeaderNames(
+            rows,
+            useHeaderNames,
+            spreadsheetId as string,
+            sheetId as number,
+            1,
+            context.auth
+        )
+
+        return result
+    }
+})

package/src/lib/actions/get-rows.ts

@@ -0,0 +1,207 @@
+import {
+  PiecePropValueSchema,
+  Property,
+  Store,
+  StoreScope,
+  createAction,
+} from '@guayaba/workflows-framework';
+import { googleSheetsAuth } from '../common/common';
+import {
+  areSheetIdsValid,
+  GoogleSheetsAuthValue,
+  googleSheetsCommon,
+  mapRowsToHeaderNames,
+} from '../common/common';
+import { isNil } from '@guayaba/workflows-shared';
+import { HttpError } from '@guayaba/workflows-common';
+import { z } from 'zod';
+import { propsValidation } from '@guayaba/workflows-common';
+import { getWorkSheetGridSize } from '../triggers/helpers';
+import { commonProps } from '../common/props';
+
+async function getRows(
+  store: Store,
+  auth: GoogleSheetsAuthValue,
+  spreadsheetId: string,
+  sheetId: number,
+  memKey: string,
+  groupSize: number,
+  startRow: number,
+  headerRow: number,
+  useHeaderNames: boolean,
+  testing: boolean
+) {
+  const sheetGridRange = await getWorkSheetGridSize(auth,spreadsheetId,sheetId);
+  const existingGridRowCount = sheetGridRange.rowCount ??0;
+  const memVal = await store.get(memKey, StoreScope.FLOW);
+
+  let startingRow;
+  if (isNil(memVal) || memVal === '') startingRow = startRow || 1;
+  else {
+    startingRow = parseInt(memVal as string);
+    if (isNaN(startingRow)) {
+      throw Error(
+        'The value stored in memory key : ' +
+        memKey +
+        ' is ' +
+        memVal +
+        ' and it is not a number'
+      );
+    }
+  }
+
+  if (startingRow < 1)
+    throw Error('Starting row : ' + startingRow + ' is less than 1' + memVal);
+
+
+  if(startingRow > existingGridRowCount-1){
+    return [];
+  }
+
+  const endRow = Math.min(startingRow + groupSize,existingGridRowCount);
+
+  if (testing == false) await store.put(memKey, endRow, StoreScope.FLOW);
+
+  const row = await googleSheetsCommon.getGoogleSheetRows({
+    auth,
+    sheetId: sheetId,
+    spreadsheetId: spreadsheetId,
+    rowIndex_s: startingRow,
+    rowIndex_e: endRow - 1,
+    headerRow: headerRow,
+  });
+
+  if (row.length == 0) {
+    const allRows = await googleSheetsCommon.getGoogleSheetRows({
+      spreadsheetId: spreadsheetId,
+      auth,
+      sheetId: sheetId,
+      rowIndex_s: undefined,
+      rowIndex_e: undefined,
+      headerRow: headerRow,
+    });
+    const lastRow = allRows.length + 1;
+    if (testing == false) await store.put(memKey, lastRow, StoreScope.FLOW);
+  }
+
+  const finalRows = await mapRowsToHeaderNames(
+    row,
+    useHeaderNames,
+    spreadsheetId,
+    sheetId,
+    headerRow,
+    auth,
+  );
+  
+  return finalRows;
+}
+
+const notes = `
+**Notes:**
+
+- Memory key is used to remember where last row was processed and will be used in the following runs.
+- Republishing the flow **keeps** the memory key value, If you want to start over **change** the memory key.
+`
+export const getRowsAction = createAction({
+  auth: googleSheetsAuth,
+  name: 'get_next_rows',
+  description: 'Get next group of rows from a specifiec workheet',
+  displayName: 'Get next row(s)',
+  props: {
+    ...commonProps,
+    startRow: Property.Number({
+      displayName: 'Start Row',
+      description: 'Which row to start from?',
+      required: true,
+      defaultValue: 1,
+    }),
+    headerRow: Property.Number({
+      displayName: 'Header Row',
+      description: 'Which row contains the headers?',
+      required: true,
+      defaultValue: 1,
+    }),
+    useHeaderNames: Property.Checkbox({
+    displayName: 'Use header names for keys',
+    description: 'Map A/B/C… to the actual column headers (row specified above).',
+    required: false,
+    defaultValue: false,
+    }),
+    markdown: Property.MarkDown({
+      value: notes
+    }),
+    memKey: Property.ShortText({
+      displayName: 'Memory Key',
+      description: 'The key used to store the current row number in memory',
+      required: true,
+      defaultValue: 'row_number',
+    }),
+    groupSize: Property.Number({
+      displayName: 'Group Size',
+      description: 'The number of rows to get',
+      required: true,
+      defaultValue: 1,
+    }),
+  },
+  async run({ store, auth, propsValue }) {
+    const { startRow, groupSize, memKey, headerRow, spreadsheetId, sheetId, useHeaderNames} = propsValue;
+
+    if (!areSheetIdsValid(spreadsheetId, sheetId)) {
+			throw new Error('Please select a spreadsheet and sheet first.');
+		}
+
+    await propsValidation.validateZod(propsValue, {
+      startRow: z.number().min(1),
+      groupSize: z.number().min(1),
+    });
+
+    try {
+      return await getRows(
+        store,
+        auth,
+        spreadsheetId as string,
+        sheetId as number,
+        memKey,
+        groupSize,
+        startRow,
+        headerRow,
+        useHeaderNames as boolean,
+        false
+      );
+    } catch (error) {
+      if (error instanceof HttpError) {
+        const errorBody = error.response.body as any;
+        throw new Error(errorBody['error']['message']);
+      }
+      throw error;
+    }
+  },
+  async test({ store, auth, propsValue }) {
+    const { startRow, groupSize, memKey, headerRow, spreadsheetId, sheetId, useHeaderNames} = propsValue;
+
+    if (!areSheetIdsValid(spreadsheetId, sheetId)) {
+			throw new Error('Please select a spreadsheet and sheet first.');
+		}
+
+    try {
+      return await getRows(
+        store,
+        auth,
+        spreadsheetId as string,
+        sheetId as number,
+        memKey,
+        groupSize,
+        startRow,
+        headerRow,
+        useHeaderNames as boolean,
+        true
+      );
+    } catch (error) {
+      if (error instanceof HttpError) {
+        const errorBody = error.response.body as any;
+        throw new Error(errorBody['error']['message']);
+      }
+      throw error;
+    }
+  },
+});