@chanaka_nakandala/integration-agent 1.0.0

package/templates/update_order_status/java.template

@@ -0,0 +1,202 @@
+/**
+ * Grubtech Order Status Update - Java (Spring Boot)
+ *
+ * This example demonstrates how to update order status in Grubtech.
+ *
+ * Prerequisites:
+ * - Java 17+
+ * - Spring Boot 3.x
+ * - Spring WebFlux (for WebClient)
+ *
+ * Replace the following placeholders:
+ * - {{AUTH_TOKEN}}: Access token from authentication step
+ * - {{ORDER_ID}}: The Grubtech order ID to update
+ * - {{NEW_STATUS}}: The new status value
+ */
+
+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.Map;
+
+@Service
+public class GrubtechOrderStatusService {
+
+    private static final String AUTH_TOKEN = "{{AUTH_TOKEN}}";
+    private static final String BASE_URL = "https://api.grubtech.io";
+
+    private final WebClient webClient;
+
+    /**
+     * Valid order status values
+     */
+    public enum OrderStatus {
+        ACCEPTED("accepted"),
+        PREPARING("preparing"),
+        READY("ready"),
+        DELIVERED("delivered"),
+        CANCELLED("cancelled");
+
+        private final String value;
+
+        OrderStatus(String value) {
+            this.value = value;
+        }
+
+        public String getValue() {
+            return value;
+        }
+    }
+
+    public GrubtechOrderStatusService() {
+        this.webClient = WebClient.builder()
+                .baseUrl(BASE_URL)
+                .build();
+    }
+
+    /**
+     * Update order status in Grubtech
+     *
+     * @param orderId   The Grubtech order ID
+     * @param newStatus The new status value
+     * @param notes     Optional notes about the status change
+     * @return Status update response
+     */
+    public StatusUpdateResponse updateOrderStatus(
+            String orderId,
+            OrderStatus newStatus,
+            String notes
+    ) {
+        try {
+            // Construct status update payload
+            Map<String, Object> payload = new HashMap<>();
+            payload.put("orderId", orderId);
+            payload.put("status", newStatus.getValue());
+            payload.put("timestamp", Instant.now().toString());
+
+            if (notes != null && !notes.isEmpty()) {
+                payload.put("notes", notes);
+            }
+
+            System.out.println("Updating order " + orderId + " to status: " + newStatus.getValue());
+
+            // Make status update request
+            StatusUpdateResponse response = webClient.put()
+                    .uri("/v1/orders/" + orderId + "/status")
+                    .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(
+                                                    "Status update failed: " +
+                                                    clientResponse.statusCode() +
+                                                    " - " + errorBody
+                                            )
+                                    ))
+                    )
+                    .bodyToMono(StatusUpdateResponse.class)
+                    .block();
+
+            if (response == null) {
+                throw new RuntimeException("No response received from status update");
+            }
+
+            System.out.println("✅ Order status updated successfully!");
+            System.out.println("Order ID: " + response.getOrderId());
+            System.out.println("New Status: " + response.getStatus());
+            System.out.println("Updated At: " + response.getUpdatedAt());
+
+            return response;
+
+        } catch (Exception e) {
+            System.err.println("❌ Status update error: " + e.getMessage());
+            throw e;
+        }
+    }
+
+    /**
+     * Example: Update order through typical workflow
+     *
+     * @param orderId The Grubtech order ID
+     */
+    public void orderWorkflowExample(String orderId) {
+        try {
+            // Step 1: Accept the order
+            updateOrderStatus(orderId, OrderStatus.ACCEPTED, "Order confirmed");
+
+            // Step 2: Start preparing
+            updateOrderStatus(orderId, OrderStatus.PREPARING, "Chef started cooking");
+
+            // Step 3: Mark as ready
+            updateOrderStatus(orderId, OrderStatus.READY, "Order ready for pickup");
+
+            // Step 4: Mark as delivered
+            updateOrderStatus(orderId, OrderStatus.DELIVERED, "Order delivered to customer");
+
+            System.out.println("✅ Order workflow completed!");
+
+        } catch (Exception e) {
+            System.err.println("❌ Workflow error: " + e.getMessage());
+
+            // If something goes wrong, cancel the order
+            updateOrderStatus(orderId, OrderStatus.CANCELLED, "Unable to fulfill order");
+        }
+    }
+
+    /**
+     * Response model for status update
+     */
+    public static class StatusUpdateResponse {
+        private boolean success;
+        private String orderId;
+        private String status;
+        private String updatedAt;
+        private String message;
+
+        // Getters and setters
+        public boolean isSuccess() { return success; }
+        public void setSuccess(boolean success) { this.success = success; }
+
+        public String getOrderId() { return orderId; }
+        public void setOrderId(String orderId) { this.orderId = orderId; }
+
+        public String getStatus() { return status; }
+        public void setStatus(String status) { this.status = status; }
+
+        public String getUpdatedAt() { return updatedAt; }
+        public void setUpdatedAt(String updatedAt) { this.updatedAt = updatedAt; }
+
+        public String getMessage() { return message; }
+        public void setMessage(String message) { this.message = message; }
+    }
+
+    // Main method for testing
+    public static void main(String[] args) {
+        try {
+            GrubtechOrderStatusService service = new GrubtechOrderStatusService();
+
+            String orderId = "{{ORDER_ID}}";
+            OrderStatus newStatus = OrderStatus.PREPARING; // Change to {{NEW_STATUS}}
+
+            // Single status update
+            service.updateOrderStatus(orderId, newStatus, "Status update from POS");
+
+            // Or run through full workflow
+            // service.orderWorkflowExample(orderId);
+
+        } catch (Exception e) {
+            System.exit(1);
+        }
+    }
+}

package/templates/update_order_status/python.template

@@ -0,0 +1,142 @@
+"""
+Grubtech Order Status Update - Python
+
+This example demonstrates how to update order status in Grubtech.
+
+Prerequisites:
+- Python 3.8+
+- requests library (pip install requests)
+- Valid access token from authentication
+
+Replace the following placeholders:
+- {{AUTH_TOKEN}}: Access token from authentication step
+- {{ORDER_ID}}: The Grubtech order ID to update
+- {{NEW_STATUS}}: The new status value
+"""
+
+import requests
+import sys
+from datetime import datetime
+from enum import Enum
+from typing import Dict, Any, Optional
+
+AUTH_TOKEN = '{{AUTH_TOKEN}}'
+BASE_URL = 'https://api.grubtech.io'
+
+
+class OrderStatus(Enum):
+    """Valid order status values"""
+    ACCEPTED = 'accepted'
+    PREPARING = 'preparing'
+    READY = 'ready'
+    DELIVERED = 'delivered'
+    CANCELLED = 'cancelled'
+
+
+def update_order_status(
+    order_id: str,
+    new_status: OrderStatus,
+    notes: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Update order status in Grubtech
+
+    Args:
+        order_id: The Grubtech order ID
+        new_status: The new status value
+        notes: Optional notes about the status change
+
+    Returns:
+        Dict: Response from API
+
+    Raises:
+        Exception: If status update fails
+    """
+    try:
+        # Construct status update payload
+        payload = {
+            'orderId': order_id,
+            'status': new_status.value,
+            'timestamp': datetime.utcnow().isoformat() + 'Z',
+        }
+
+        if notes:
+            payload['notes'] = notes
+
+        print(f'Updating order {order_id} to status: {new_status.value}')
+
+        # Make status update request
+        url = f'{BASE_URL}/v1/orders/{order_id}/status'
+        headers = {
+            'Authorization': f'Bearer {AUTH_TOKEN}',
+            'Content-Type': 'application/json',
+        }
+
+        response = requests.put(url, json=payload, headers=headers, timeout=10)
+
+        # Check for errors
+        if not response.ok:
+            raise Exception(
+                f'Status update failed: {response.status_code} - {response.text}'
+            )
+
+        # Parse response
+        data = response.json()
+
+        print(f'✅ Order status updated successfully!')
+        print(f'Order ID: {data["orderId"]}')
+        print(f'New Status: {data["status"]}')
+        print(f'Updated At: {data["updatedAt"]}')
+
+        return data
+
+    except requests.RequestException as e:
+        print(f'❌ Status update error: {e}', file=sys.stderr)
+        raise
+    except Exception as e:
+        print(f'❌ Unexpected error: {e}', file=sys.stderr)
+        raise
+
+
+def order_workflow_example(order_id: str) -> None:
+    """
+    Example: Update order through typical workflow
+
+    Args:
+        order_id: The Grubtech order ID
+    """
+    try:
+        # Step 1: Accept the order
+        update_order_status(order_id, OrderStatus.ACCEPTED, 'Order confirmed')
+
+        # Step 2: Start preparing
+        update_order_status(order_id, OrderStatus.PREPARING, 'Chef started cooking')
+
+        # Step 3: Mark as ready
+        update_order_status(order_id, OrderStatus.READY, 'Order ready for pickup')
+
+        # Step 4: Mark as delivered
+        update_order_status(order_id, OrderStatus.DELIVERED, 'Order delivered to customer')
+
+        print('✅ Order workflow completed!')
+
+    except Exception as e:
+        print(f'❌ Workflow error: {e}', file=sys.stderr)
+
+        # If something goes wrong, cancel the order
+        update_order_status(order_id, OrderStatus.CANCELLED, 'Unable to fulfill order')
+
+
+if __name__ == '__main__':
+    try:
+        order_id = '{{ORDER_ID}}'
+        new_status = OrderStatus.PREPARING  # Change to {{NEW_STATUS}}
+
+        # Single status update
+        update_order_status(order_id, new_status, 'Status update from POS')
+
+        # Or run through full workflow
+        # order_workflow_example(order_id)
+
+    except Exception as e:
+        sys.exit(1)

package/templates/update_order_status/typescript.template

@@ -0,0 +1,139 @@
+/**
+ * Grubtech Order Status Update - TypeScript
+ *
+ * This example demonstrates how to update order status in Grubtech.
+ *
+ * Prerequisites:
+ * - Node.js 18+ with fetch API
+ * - Valid access token from authentication
+ *
+ * Replace the following placeholders:
+ * - {{AUTH_TOKEN}}: Access token from authentication step
+ * - {{ORDER_ID}}: The Grubtech order ID to update
+ * - {{NEW_STATUS}}: The new status value
+ */
+
+const AUTH_TOKEN = '{{AUTH_TOKEN}}';
+const BASE_URL = 'https://api.grubtech.io';
+
+enum OrderStatus {
+  ACCEPTED = 'accepted',
+  PREPARING = 'preparing',
+  READY = 'ready',
+  DELIVERED = 'delivered',
+  CANCELLED = 'cancelled',
+}
+
+interface StatusUpdatePayload {
+  orderId: string;
+  status: OrderStatus;
+  timestamp: string;
+  notes?: string;
+}
+
+interface StatusUpdateResponse {
+  success: boolean;
+  orderId: string;
+  status: string;
+  updatedAt: string;
+  message?: string;
+}
+
+/**
+ * Update order status in Grubtech
+ */
+async function updateOrderStatus(
+  orderId: string,
+  newStatus: OrderStatus,
+  notes?: string
+): Promise<StatusUpdateResponse> {
+  try {
+    // Validate status value
+    if (!Object.values(OrderStatus).includes(newStatus)) {
+      throw new Error(`Invalid status: ${newStatus}`);
+    }
+
+    // Construct status update payload
+    const payload: StatusUpdatePayload = {
+      orderId,
+      status: newStatus,
+      timestamp: new Date().toISOString(),
+      notes,
+    };
+
+    console.log(`Updating order ${orderId} to status: ${newStatus}`);
+
+    // Make status update request
+    const response = await fetch(`${BASE_URL}/v1/orders/${orderId}/status`, {
+      method: 'PUT',
+      headers: {
+        'Authorization': `Bearer ${AUTH_TOKEN}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(payload),
+    });
+
+    // Check for errors
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(
+        `Status update failed: ${response.status} - ${errorBody}`
+      );
+    }
+
+    // Parse response
+    const data: StatusUpdateResponse = await response.json();
+
+    console.log('✅ Order status updated successfully!');
+    console.log(`Order ID: ${data.orderId}`);
+    console.log(`New Status: ${data.status}`);
+    console.log(`Updated At: ${data.updatedAt}`);
+
+    return data;
+  } catch (error) {
+    console.error('❌ Status update error:', error);
+    throw error;
+  }
+}
+
+/**
+ * Example: Update order through typical workflow
+ */
+async function orderWorkflowExample(orderId: string) {
+  try {
+    // Step 1: Accept the order
+    await updateOrderStatus(orderId, OrderStatus.ACCEPTED, 'Order confirmed');
+
+    // Step 2: Start preparing
+    await updateOrderStatus(orderId, OrderStatus.PREPARING, 'Chef started cooking');
+
+    // Step 3: Mark as ready
+    await updateOrderStatus(orderId, OrderStatus.READY, 'Order ready for pickup');
+
+    // Step 4: Mark as delivered (or picked up)
+    await updateOrderStatus(orderId, OrderStatus.DELIVERED, 'Order delivered to customer');
+
+    console.log('✅ Order workflow completed!');
+  } catch (error) {
+    console.error('❌ Workflow error:', error);
+
+    // If something goes wrong, cancel the order
+    await updateOrderStatus(orderId, OrderStatus.CANCELLED, 'Unable to fulfill order');
+  }
+}
+
+// Main execution
+(async () => {
+  try {
+    const orderId = '{{ORDER_ID}}';
+    const newStatus = OrderStatus.PREPARING; // Change this to {{NEW_STATUS}}
+
+    // Single status update
+    await updateOrderStatus(orderId, newStatus, 'Status update from POS');
+
+    // Or run through full workflow
+    // await orderWorkflowExample(orderId);
+  } catch (error) {
+    process.exit(1);
+  }
+})();