⚗️ Implement bot v2 MVP (#194)

Closes #190

apps/viewer/src/features/blocks/integrations/googleSheets/api/utils/getRow.ts

@@ -1,9 +1,16 @@
-import { SessionState, GoogleSheetsGetOptions, VariableWithValue } from 'models'
-import { saveErrorLog, saveSuccessLog } from '@/features/logs/api'
+import {
+  SessionState,
+  GoogleSheetsGetOptions,
+  VariableWithValue,
+  ComparisonOperators,
+  LogicalOperator,
+} from 'models'
+import { saveErrorLog } from '@/features/logs/api'
 import { getAuthenticatedGoogleDoc } from './helpers'
-import { parseVariables, updateVariables } from '@/features/variables'
-import { isNotEmpty, byId } from 'utils'
+import { updateVariables } from '@/features/variables'
+import { isNotEmpty, byId, isDefined } from 'utils'
 import { ExecuteIntegrationResponse } from '@/features/chat'
+import type { GoogleSpreadsheetRow } from 'google-spreadsheet'
 
 export const getRow = async (
   state: SessionState,
@@ -12,56 +19,51 @@ export const getRow = async (
     options,
   }: { outgoingEdgeId?: string; options: GoogleSheetsGetOptions }
 ): Promise<ExecuteIntegrationResponse> => {
-  const { sheetId, cellsToExtract, referenceCell } = options
+  const { sheetId, cellsToExtract, referenceCell, filter } = options
   if (!cellsToExtract || !sheetId || !referenceCell) return { outgoingEdgeId }
 
   const variables = state.typebot.variables
-  const resultId = state.result.id
+  const resultId = state.result?.id
 
   const doc = await getAuthenticatedGoogleDoc({
     credentialsId: options.credentialsId,
     spreadsheetId: options.spreadsheetId,
   })
 
-  const parsedReferenceCell = {
-    column: referenceCell.column,
-    value: parseVariables(variables)(referenceCell.value),
-  }
-
-  const extractingColumns = cellsToExtract
-    .map((cell) => cell.column)
-    .filter(isNotEmpty)
-
   try {
     await doc.loadInfo()
     const sheet = doc.sheetsById[sheetId]
     const rows = await sheet.getRows()
-    const row = rows.find(
-      (row) =>
-        row[parsedReferenceCell.column as string] === parsedReferenceCell.value
+    const filteredRows = rows.filter((row) =>
+      referenceCell
+        ? row[referenceCell.column as string] === referenceCell.value
+        : matchFilter(row, filter)
     )
-    if (!row) {
+    if (filteredRows.length === 0) {
       await saveErrorLog({
         resultId,
         message: "Couldn't find reference cell",
       })
       return { outgoingEdgeId }
     }
-    const data: { [key: string]: string } = {
-      ...extractingColumns.reduce(
-        (obj, column) => ({ ...obj, [column]: row[column] }),
-        {}
-      ),
-    }
-    await saveSuccessLog({
-      resultId,
-      message: 'Succesfully fetched spreadsheet data',
-    })
+    const randomIndex = Math.floor(Math.random() * filteredRows.length)
+    const extractingColumns = cellsToExtract
+      .map((cell) => cell.column)
+      .filter(isNotEmpty)
+    const selectedRow = filteredRows
+      .map((row) =>
+        extractingColumns.reduce<{ [key: string]: string }>(
+          (obj, column) => ({ ...obj, [column]: row[column] }),
+          {}
+        )
+      )
+      .at(randomIndex)
+    if (!selectedRow) return { outgoingEdgeId }
 
     const newVariables = options.cellsToExtract.reduce<VariableWithValue[]>(
       (newVariables, cell) => {
         const existingVariable = variables.find(byId(cell.variableId))
-        const value = data[cell.column ?? ''] ?? null
+        const value = selectedRow[cell.column ?? ''] ?? null
         if (!existingVariable) return newVariables
         return [
           ...newVariables,
@@ -87,3 +89,56 @@ export const getRow = async (
   }
   return { outgoingEdgeId }
 }
+
+const matchFilter = (
+  row: GoogleSpreadsheetRow,
+  filter: GoogleSheetsGetOptions['filter']
+) => {
+  return filter.logicalOperator === LogicalOperator.AND
+    ? filter.comparisons.every(
+        (comparison) =>
+          comparison.column &&
+          matchComparison(
+            row[comparison.column],
+            comparison.comparisonOperator,
+            comparison.value
+          )
+      )
+    : filter.comparisons.some(
+        (comparison) =>
+          comparison.column &&
+          matchComparison(
+            row[comparison.column],
+            comparison.comparisonOperator,
+            comparison.value
+          )
+      )
+}
+
+const matchComparison = (
+  inputValue?: string,
+  comparisonOperator?: ComparisonOperators,
+  value?: string
+) => {
+  if (!inputValue || !comparisonOperator || !value) return false
+  switch (comparisonOperator) {
+    case ComparisonOperators.CONTAINS: {
+      return inputValue.toLowerCase().includes(value.toLowerCase())
+    }
+    case ComparisonOperators.EQUAL: {
+      return inputValue === value
+    }
+    case ComparisonOperators.NOT_EQUAL: {
+      return inputValue !== value
+    }
+    case ComparisonOperators.GREATER: {
+      return parseFloat(inputValue) > parseFloat(value)
+    }
+    case ComparisonOperators.LESS: {
+      return parseFloat(inputValue) < parseFloat(value)
+    }
+    case ComparisonOperators.IS_SET: {
+      return isDefined(inputValue) && inputValue.length > 0
+    }
+  }
+}

apps/viewer/src/features/blocks/integrations/googleSheets/api/utils/insertRow.ts

@@ -23,16 +23,18 @@ export const insertRow = async (
     await doc.loadInfo()
     const sheet = doc.sheetsById[options.sheetId]
     await sheet.addRow(parsedValues)
-    await saveSuccessLog({
-      resultId: result.id,
-      message: 'Succesfully inserted row',
-    })
+    result &&
+      (await saveSuccessLog({
+        resultId: result.id,
+        message: 'Succesfully inserted row',
+      }))
   } catch (err) {
-    await saveErrorLog({
-      resultId: result.id,
-      message: "Couldn't fetch spreadsheet data",
-      details: err,
-    })
+    result &&
+      (await saveErrorLog({
+        resultId: result.id,
+        message: "Couldn't fetch spreadsheet data",
+        details: err,
+      }))
   }
   return { outgoingEdgeId }
 }

apps/viewer/src/features/blocks/integrations/googleSheets/api/utils/updateRow.ts

@@ -45,16 +45,18 @@ export const updateRow = async (
       rows[updatingRowIndex][key] = parsedValues[key]
     }
     await rows[updatingRowIndex].save()
-    await saveSuccessLog({
-      resultId: result.id,
-      message: 'Succesfully updated row',
-    })
+    result &&
+      (await saveSuccessLog({
+        resultId: result.id,
+        message: 'Succesfully updated row',
+      }))
   } catch (err) {
-    await saveErrorLog({
-      resultId: result.id,
-      message: "Couldn't fetch spreadsheet data",
-      details: err,
-    })
+    result &&
+      (await saveErrorLog({
+        resultId: result.id,
+        message: "Couldn't fetch spreadsheet data",
+        details: err,
+      }))
   }
   return { outgoingEdgeId }
 }