@chanaka_nakandala/integration-agent 1.0.0

package/templates/receive_order/typescript.template

@@ -0,0 +1,194 @@
+/**
+ * Grubtech Order Receive Webhook - TypeScript (Express.js)
+ *
+ * This example demonstrates how to receive orders from Grubtech
+ * via webhook and process them in your system.
+ *
+ * Prerequisites:
+ * - Node.js 18+
+ * - Express.js (npm install express)
+ * - crypto module (built-in)
+ *
+ * Replace the following placeholders:
+ * - {{WEBHOOK_SECRET}}: Your webhook secret for signature verification
+ * - {{ORDER_PROCESSING_LOGIC}}: Your business logic to process the order
+ */
+
+import express, { Request, Response } from 'express';
+import crypto from 'crypto';
+
+const app = express();
+const PORT = 3000;
+const WEBHOOK_SECRET = '{{WEBHOOK_SECRET}}';
+
+// Middleware to parse JSON and preserve raw body for signature verification
+app.use(
+  express.json({
+    verify: (req: any, res, buf) => {
+      req.rawBody = buf.toString('utf8');
+    },
+  })
+);
+
+interface OrderItem {
+  id: string;
+  name: string;
+  quantity: number;
+  price: number;
+  modifiers?: Array<{ id: string; name: string; price: number }>;
+}
+
+interface Order {
+  orderId: string;
+  partnerOrderId?: string;
+  status: string;
+  createdAt: string;
+  customer: {
+    name: string;
+    phone: string;
+    email?: string;
+  };
+  delivery: {
+    type: 'delivery' | 'pickup';
+    address?: string;
+    city?: string;
+    instructions?: string;
+  };
+  items: OrderItem[];
+  totals: {
+    subtotal: number;
+    tax: number;
+    deliveryFee: number;
+    total: number;
+  };
+  payment: {
+    method: string;
+    status: string;
+  };
+}
+
+interface WebhookResponse {
+  accepted: boolean;
+  orderId?: string;
+  partnerOrderId?: string;
+  message?: string;
+  estimatedReadyTime?: string;
+}
+
+/**
+ * Verify webhook signature
+ */
+function verifySignature(req: any): boolean {
+  const signature = req.headers['x-grubtech-signature'];
+
+  if (!signature) {
+    console.error('❌ No signature provided');
+    return false;
+  }
+
+  // Calculate expected signature using HMAC-SHA256
+  const expectedSignature = crypto
+    .createHmac('sha256', WEBHOOK_SECRET)
+    .update(req.rawBody)
+    .digest('hex');
+
+  // Constant-time comparison to prevent timing attacks
+  const isValid = crypto.timingSafeEqual(
+    Buffer.from(signature),
+    Buffer.from(expectedSignature)
+  );
+
+  if (!isValid) {
+    console.error('❌ Invalid signature');
+  }
+
+  return isValid;
+}
+
+/**
+ * Process order (replace with your business logic)
+ */
+async function processOrder(order: Order): Promise<WebhookResponse> {
+  try {
+    console.log(`📦 Processing order: ${order.orderId}`);
+    console.log(`Customer: ${order.customer.name}`);
+    console.log(`Items: ${order.items.length}`);
+    console.log(`Total: $${order.totals.total}`);
+
+    // {{ORDER_PROCESSING_LOGIC}}
+    // Example: Save to database, notify kitchen, etc.
+
+    // Simulate processing time
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Calculate estimated ready time (example: 30 minutes from now)
+    const readyTime = new Date(Date.now() + 30 * 60 * 1000).toISOString();
+
+    return {
+      accepted: true,
+      orderId: order.orderId,
+      partnerOrderId: `POS-${Date.now()}`,
+      message: 'Order accepted successfully',
+      estimatedReadyTime: readyTime,
+    };
+  } catch (error) {
+    console.error('❌ Order processing error:', error);
+
+    return {
+      accepted: false,
+      orderId: order.orderId,
+      message: `Order rejected: ${error}`,
+    };
+  }
+}
+
+/**
+ * Webhook endpoint to receive orders from Grubtech
+ */
+app.post('/webhooks/grubtech/orders', async (req: Request, res: Response) => {
+  try {
+    // Verify signature
+    if (!verifySignature(req)) {
+      return res.status(401).json({
+        accepted: false,
+        message: 'Invalid signature',
+      });
+    }
+
+    const order: Order = req.body;
+
+    // Validate order data
+    if (!order.orderId || !order.items || order.items.length === 0) {
+      return res.status(400).json({
+        accepted: false,
+        message: 'Invalid order data',
+      });
+    }
+
+    // Process order
+    const response = await processOrder(order);
+
+    // Send response
+    const statusCode = response.accepted ? 200 : 400;
+    return res.status(statusCode).json(response);
+  } catch (error) {
+    console.error('❌ Webhook error:', error);
+    return res.status(500).json({
+      accepted: false,
+      message: 'Internal server error',
+    });
+  }
+});
+
+/**
+ * Health check endpoint
+ */
+app.get('/health', (req: Request, res: Response) => {
+  res.json({ status: 'ok' });
+});
+
+// Start server
+app.listen(PORT, () => {
+  console.log(`✅ Webhook server listening on port ${PORT}`);
+  console.log(`Webhook URL: http://localhost:${PORT}/webhooks/grubtech/orders`);
+});

package/templates/update_item_availability/curl.template

@@ -0,0 +1,143 @@
+#!/bin/bash
+
+# Grubtech Item Availability Update - cURL
+#
+# This example demonstrates how to update menu item availability in Grubtech.
+#
+# Prerequisites:
+# - curl command-line tool
+# - jq (for JSON parsing, optional)
+# - Valid access token from authentication
+#
+# Replace the following placeholders:
+# - {{AUTH_TOKEN}}: Access token from authentication step
+# - {{ITEM_ID}}: The menu item ID to update
+# - {{AVAILABLE_STATUS}}: Boolean availability status (true/false)
+
+AUTH_TOKEN="{{AUTH_TOKEN}}"
+ITEM_ID="{{ITEM_ID}}"
+AVAILABLE_STATUS={{AVAILABLE_STATUS}}  # true or false
+BASE_URL="https://api.grubtech.io"
+
+# Update single item availability
+update_item_availability() {
+    local item_id=$1
+    local available=$2
+    local reason=$3
+
+    echo "Updating item ${item_id}: available=${available}"
+
+    # Construct payload
+    TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    PAYLOAD=$(cat <<EOF
+{
+  "itemId": "${item_id}",
+  "available": ${available},
+  "timestamp": "${TIMESTAMP}",
+  "reason": "${reason}"
+}
+EOF
+)
+
+    # Make availability update request
+    RESPONSE=$(curl -s -w "\n%{http_code}" -X PUT \
+        "${BASE_URL}/v1/items/${item_id}/availability" \
+        -H "Authorization: Bearer ${AUTH_TOKEN}" \
+        -H "Content-Type: application/json" \
+        -d "$PAYLOAD")
+
+    # Extract HTTP status code and body
+    HTTP_CODE=$(echo "$RESPONSE" | tail -n 1)
+    BODY=$(echo "$RESPONSE" | sed '$d')
+
+    # Check for errors
+    if [ "$HTTP_CODE" -ne 200 ]; then
+        echo "❌ Availability update failed: HTTP $HTTP_CODE"
+        echo "Response: $BODY"
+        return 1
+    fi
+
+    echo "✅ Item availability updated successfully!"
+    echo "$BODY" | jq '.' 2>/dev/null || echo "$BODY"
+}
+
+# Update multiple items in bulk
+update_bulk_availability() {
+    echo "Updating multiple items availability..."
+
+    # Construct bulk payload
+    TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    PAYLOAD=$(cat <<'EOF'
+{
+  "updates": [
+    {
+      "itemId": "item-123",
+      "available": false,
+      "reason": "Out of stock"
+    },
+    {
+      "itemId": "item-456",
+      "available": true,
+      "reason": "Back in stock"
+    },
+    {
+      "itemId": "item-789",
+      "available": true,
+      "reason": "In stock"
+    }
+  ],
+  "timestamp": "TIMESTAMP_PLACEHOLDER"
+}
+EOF
+)
+
+    # Replace timestamp placeholder
+    PAYLOAD=$(echo "$PAYLOAD" | sed "s/TIMESTAMP_PLACEHOLDER/$TIMESTAMP/")
+
+    # Make bulk availability update request
+    RESPONSE=$(curl -s -w "\n%{http_code}" -X PUT \
+        "${BASE_URL}/v1/items/availability/bulk" \
+        -H "Authorization: Bearer ${AUTH_TOKEN}" \
+        -H "Content-Type: application/json" \
+        -d "$PAYLOAD")
+
+    # Extract HTTP status code and body
+    HTTP_CODE=$(echo "$RESPONSE" | tail -n 1)
+    BODY=$(echo "$RESPONSE" | sed '$d')
+
+    # Check for errors
+    if [ "$HTTP_CODE" -ne 200 ]; then
+        echo "❌ Bulk availability update failed: HTTP $HTTP_CODE"
+        echo "Response: $BODY"
+        return 1
+    fi
+
+    echo "✅ Bulk availability updated successfully!"
+    echo "$BODY" | jq '.' 2>/dev/null || echo "$BODY"
+}
+
+# Helper functions
+mark_out_of_stock() {
+    update_item_availability "$1" false "Out of stock"
+}
+
+mark_in_stock() {
+    update_item_availability "$1" true "Back in stock"
+}
+
+# Main execution
+main() {
+    # Example 1: Single item update
+    update_item_availability "$ITEM_ID" "$AVAILABLE_STATUS" "Inventory sync"
+
+    echo ""
+
+    # Example 2: Mark item out of stock
+    # mark_out_of_stock "item-123"
+
+    # Example 3: Bulk update
+    # update_bulk_availability
+}
+
+# Run main function
+main

package/templates/update_item_availability/java.template

@@ -0,0 +1,279 @@
+/**
+ * Grubtech Item Availability Update - Java (Spring Boot)
+ *
+ * This example demonstrates how to update menu item availability in Grubtech
+ * to keep items in sync with your inventory status.
+ *
+ * Prerequisites:
+ * - Java 17+
+ * - Spring Boot 3.x
+ * - Spring WebFlux (for WebClient)
+ *
+ * Replace the following placeholders:
+ * - {{AUTH_TOKEN}}: Access token from authentication step
+ * - {{ITEM_ID}}: The menu item ID to update
+ * - {{AVAILABLE_STATUS}}: Boolean availability status (true/false)
+ */
+
+package com.example.grubtech;
+
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Service;
+import org.springframework.web.reactive.function.client.WebClient;
+import reactor.core.publisher.Mono;
+
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Service
+public class GrubtechItemAvailabilityService {
+
+    private static final String AUTH_TOKEN = "{{AUTH_TOKEN}}";
+    private static final String BASE_URL = "https://api.grubtech.io";
+
+    private final WebClient webClient;
+
+    public GrubtechItemAvailabilityService() {
+        this.webClient = WebClient.builder()
+                .baseUrl(BASE_URL)
+                .build();
+    }
+
+    /**
+     * Update single item availability
+     *
+     * @param itemId    The menu item ID
+     * @param available True if in stock, False if out of stock
+     * @param reason    Optional reason for status change
+     * @return Availability update response
+     */
+    public AvailabilityResponse updateItemAvailability(
+            String itemId,
+            boolean available,
+            String reason
+    ) {
+        try {
+            // Construct payload
+            Map<String, Object> payload = new HashMap<>();
+            payload.put("itemId", itemId);
+            payload.put("available", available);
+            payload.put("timestamp", Instant.now().toString());
+
+            if (reason != null && !reason.isEmpty()) {
+                payload.put("reason", reason);
+            }
+
+            System.out.println("Updating item " + itemId + ": available=" + available);
+
+            // Make availability update request
+            AvailabilityResponse response = webClient.put()
+                    .uri("/v1/items/" + itemId + "/availability")
+                    .header(HttpHeaders.AUTHORIZATION, "Bearer " + AUTH_TOKEN)
+                    .header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
+                    .bodyValue(payload)
+                    .retrieve()
+                    .onStatus(
+                            status -> !status.is2xxSuccessful(),
+                            clientResponse -> clientResponse.bodyToMono(String.class)
+                                    .flatMap(errorBody -> Mono.error(
+                                            new RuntimeException(
+                                                    "Availability update failed: " +
+                                                    clientResponse.statusCode() +
+                                                    " - " + errorBody
+                                            )
+                                    ))
+                    )
+                    .bodyToMono(AvailabilityResponse.class)
+                    .block();
+
+            if (response == null) {
+                throw new RuntimeException("No response received");
+            }
+
+            System.out.println("✅ Item availability updated successfully!");
+            System.out.println("Item ID: " + response.getItemId());
+            System.out.println("Available: " + available);
+
+            return response;
+
+        } catch (Exception e) {
+            System.err.println("❌ Availability update error: " + e.getMessage());
+            throw e;
+        }
+    }
+
+    /**
+     * Update multiple items availability in bulk
+     *
+     * @param updates List of item availability updates
+     * @return Bulk availability update response
+     */
+    public BulkAvailabilityResponse updateBulkAvailability(
+            List<ItemUpdate> updates
+    ) {
+        try {
+            // Construct bulk payload
+            Map<String, Object> payload = new HashMap<>();
+            payload.put("updates", updates);
+            payload.put("timestamp", Instant.now().toString());
+
+            System.out.println("Updating " + updates.size() + " items availability");
+
+            // Make bulk availability update request
+            BulkAvailabilityResponse response = webClient.put()
+                    .uri("/v1/items/availability/bulk")
+                    .header(HttpHeaders.AUTHORIZATION, "Bearer " + AUTH_TOKEN)
+                    .header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
+                    .bodyValue(payload)
+                    .retrieve()
+                    .onStatus(
+                            status -> !status.is2xxSuccessful(),
+                            clientResponse -> Mono.error(
+                                    new RuntimeException(
+                                            "Bulk availability update failed: " +
+                                            clientResponse.statusCode()
+                                    )
+                            )
+                    )
+                    .bodyToMono(BulkAvailabilityResponse.class)
+                    .block();
+
+            if (response == null) {
+                throw new RuntimeException("No response received");
+            }
+
+            System.out.println("✅ Bulk availability updated successfully!");
+            System.out.println("Updated: " + response.getUpdatedCount() + " items");
+
+            // Report any errors
+            if (response.getErrors() != null && !response.getErrors().isEmpty()) {
+                System.out.println("⚠️  " + response.getErrors().size() + " items had errors:");
+                response.getErrors().forEach(err ->
+                        System.out.println("  - " + err.getItemId() + ": " + err.getError())
+                );
+            }
+
+            return response;
+
+        } catch (Exception e) {
+            System.err.println("❌ Bulk availability update error: " + e.getMessage());
+            throw e;
+        }
+    }
+
+    /**
+     * Mark item as out of stock
+     */
+    public AvailabilityResponse markOutOfStock(String itemId) {
+        return updateItemAvailability(itemId, false, "Out of stock");
+    }
+
+    /**
+     * Mark item as back in stock
+     */
+    public AvailabilityResponse markInStock(String itemId) {
+        return updateItemAvailability(itemId, true, "Back in stock");
+    }
+
+    /**
+     * Sync inventory with Grubtech
+     */
+    public BulkAvailabilityResponse syncInventory(Map<String, Boolean> inventory) {
+        List<ItemUpdate> updates = inventory.entrySet().stream()
+                .map(entry -> new ItemUpdate(
+                        entry.getKey(),
+                        entry.getValue(),
+                        entry.getValue() ? "In stock" : "Out of stock"
+                ))
+                .collect(Collectors.toList());
+
+        return updateBulkAvailability(updates);
+    }
+
+    // Data models
+    public static class ItemUpdate {
+        private String itemId;
+        private boolean available;
+        private String reason;
+
+        public ItemUpdate(String itemId, boolean available, String reason) {
+            this.itemId = itemId;
+            this.available = available;
+            this.reason = reason;
+        }
+
+        // Getters
+        public String getItemId() { return itemId; }
+        public boolean isAvailable() { return available; }
+        public String getReason() { return reason; }
+    }
+
+    public static class AvailabilityResponse {
+        private boolean success;
+        private String itemId;
+        private String message;
+
+        // Getters and setters
+        public boolean isSuccess() { return success; }
+        public void setSuccess(boolean success) { this.success = success; }
+        public String getItemId() { return itemId; }
+        public void setItemId(String itemId) { this.itemId = itemId; }
+        public String getMessage() { return message; }
+        public void setMessage(String message) { this.message = message; }
+    }
+
+    public static class BulkAvailabilityResponse {
+        private boolean success;
+        private int updatedCount;
+        private List<ItemError> errors;
+
+        // Getters and setters
+        public boolean isSuccess() { return success; }
+        public void setSuccess(boolean success) { this.success = success; }
+        public int getUpdatedCount() { return updatedCount; }
+        public void setUpdatedCount(int updatedCount) { this.updatedCount = updatedCount; }
+        public List<ItemError> getErrors() { return errors; }
+        public void setErrors(List<ItemError> errors) { this.errors = errors; }
+    }
+
+    public static class ItemError {
+        private String itemId;
+        private String error;
+
+        // Getters and setters
+        public String getItemId() { return itemId; }
+        public void setItemId(String itemId) { this.itemId = itemId; }
+        public String getError() { return error; }
+        public void setError(String error) { this.error = error; }
+    }
+
+    // Main method for testing
+    public static void main(String[] args) {
+        try {
+            GrubtechItemAvailabilityService service = new GrubtechItemAvailabilityService();
+
+            String itemId = "{{ITEM_ID}}";
+            boolean available = {{AVAILABLE_STATUS}}; // true or false
+
+            // Example 1: Single item update
+            service.updateItemAvailability(itemId, available, "Inventory sync");
+
+            // Example 2: Mark item out of stock
+            // service.markOutOfStock("item-123");
+
+            // Example 3: Bulk update from inventory
+            // service.syncInventory(Map.of(
+            //     "item-123", false,  // Out of stock
+            //     "item-456", true,   // In stock
+            //     "item-789", true    // In stock
+            // ));
+
+        } catch (Exception e) {
+            System.exit(1);
+        }
+    }
+}