@chanaka_nakandala/integration-agent 1.1.1 → 2.0.1

package/templates/receive_order/java.template

@@ -1,263 +0,0 @@
-/**
- * Grubtech Order Receive Webhook - Java (Spring Boot)
- *
- * This example demonstrates how to receive orders from Grubtech
- * via webhook and process them in your system.
- *
- * Prerequisites:
- * - Java 17+
- * - Spring Boot 3.x
- *
- * Replace the following placeholders:
- * - {{WEBHOOK_SECRET}}: Your webhook secret for signature verification
- * - {{ORDER_PROCESSING_LOGIC}}: Your business logic to process the order
- */
-
-package com.example.grubtech;
-
-import org.springframework.boot.SpringApplication;
-import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-
-import javax.crypto.Mac;
-import javax.crypto.spec.SecretKeySpec;
-import java.nio.charset.StandardCharsets;
-import java.security.InvalidKeyException;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
-import java.time.Instant;
-import java.time.temporal.ChronoUnit;
-import java.util.List;
-import java.util.Map;
-
-@SpringBootApplication
-@RestController
-@RequestMapping("/webhooks/grubtech")
-public class GrubtechOrderWebhook {
-
-    private static final String WEBHOOK_SECRET = "{{WEBHOOK_SECRET}}";
-
-    /**
-     * Verify webhook signature using HMAC-SHA256
-     */
-    private boolean verifySignature(String body, String signature) {
-        if (signature == null || signature.isEmpty()) {
-            System.err.println("❌ No signature provided");
-            return false;
-        }
-
-        try {
-            Mac sha256Hmac = Mac.getInstance("HmacSHA256");
-            SecretKeySpec secretKey = new SecretKeySpec(
-                    WEBHOOK_SECRET.getBytes(StandardCharsets.UTF_8),
-                    "HmacSHA256"
-            );
-            sha256Hmac.init(secretKey);
-
-            byte[] hash = sha256Hmac.doFinal(body.getBytes(StandardCharsets.UTF_8));
-            String expectedSignature = bytesToHex(hash);
-
-            // Constant-time comparison
-            boolean isValid = MessageDigest.isEqual(
-                    signature.getBytes(StandardCharsets.UTF_8),
-                    expectedSignature.getBytes(StandardCharsets.UTF_8)
-            );
-
-            if (!isValid) {
-                System.err.println("❌ Invalid signature");
-            }
-
-            return isValid;
-
-        } catch (NoSuchAlgorithmException | InvalidKeyException e) {
-            System.err.println("❌ Signature verification error: " + e.getMessage());
-            return false;
-        }
-    }
-
-    /**
-     * Convert byte array to hex string
-     */
-    private String bytesToHex(byte[] bytes) {
-        StringBuilder result = new StringBuilder();
-        for (byte b : bytes) {
-            result.append(String.format("%02x", b));
-        }
-        return result.toString();
-    }
-
-    /**
-     * Process order (replace with your business logic)
-     */
-    private WebhookResponse processOrder(Order order) {
-        try {
-            System.out.println("📦 Processing order: " + order.getOrderId());
-            System.out.println("Customer: " + order.getCustomer().get("name"));
-            System.out.println("Items: " + order.getItems().size());
-            System.out.println("Total: $" + order.getTotals().get("total"));
-
-            // {{ORDER_PROCESSING_LOGIC}}
-            // Example: Save to database, notify kitchen, etc.
-
-            // Simulate processing
-            Thread.sleep(100);
-
-            // Calculate estimated ready time (30 minutes from now)
-            String readyTime = Instant.now()
-                    .plus(30, ChronoUnit.MINUTES)
-                    .toString();
-
-            return new WebhookResponse(
-                    true,
-                    order.getOrderId(),
-                    "POS-" + System.currentTimeMillis(),
-                    "Order accepted successfully",
-                    readyTime
-            );
-
-        } catch (Exception e) {
-            System.err.println("❌ Order processing error: " + e.getMessage());
-
-            return new WebhookResponse(
-                    false,
-                    order.getOrderId(),
-                    null,
-                    "Order rejected: " + e.getMessage(),
-                    null
-            );
-        }
-    }
-
-    /**
-     * Webhook endpoint to receive orders from Grubtech
-     */
-    @PostMapping("/orders")
-    public ResponseEntity<WebhookResponse> receiveOrder(
-            @RequestBody String body,
-            @RequestHeader(value = "X-Grubtech-Signature", required = false) String signature
-    ) {
-        try {
-            // Verify signature
-            if (!verifySignature(body, signature)) {
-                return ResponseEntity
-                        .status(HttpStatus.UNAUTHORIZED)
-                        .body(new WebhookResponse(
-                                false,
-                                null,
-                                null,
-                                "Invalid signature",
-                                null
-                        ));
-            }
-
-            // Parse order (using Jackson ObjectMapper in real implementation)
-            // For simplicity, this example uses a simplified approach
-            Order order = parseOrder(body);
-
-            // Validate order data
-            if (order.getOrderId() == null || order.getItems() == null || order.getItems().isEmpty()) {
-                return ResponseEntity
-                        .status(HttpStatus.BAD_REQUEST)
-                        .body(new WebhookResponse(
-                                false,
-                                null,
-                                null,
-                                "Invalid order data",
-                                null
-                        ));
-            }
-
-            // Process order
-            WebhookResponse response = processOrder(order);
-
-            // Send response
-            HttpStatus status = response.isAccepted() ? HttpStatus.OK : HttpStatus.BAD_REQUEST;
-            return ResponseEntity.status(status).body(response);
-
-        } catch (Exception e) {
-            System.err.println("❌ Webhook error: " + e.getMessage());
-            return ResponseEntity
-                    .status(HttpStatus.INTERNAL_SERVER_ERROR)
-                    .body(new WebhookResponse(
-                            false,
-                            null,
-                            null,
-                            "Internal server error",
-                            null
-                    ));
-        }
-    }
-
-    /**
-     * Parse order from JSON (simplified - use ObjectMapper in production)
-     */
-    private Order parseOrder(String body) {
-        // In production, use Jackson ObjectMapper:
-        // return objectMapper.readValue(body, Order.class);
-        return new Order(); // Placeholder
-    }
-
-    /**
-     * Health check endpoint
-     */
-    @GetMapping("/health")
-    public Map<String, String> healthCheck() {
-        return Map.of("status", "ok");
-    }
-
-    // Data models
-    public static class Order {
-        private String orderId;
-        private Map<String, String> customer;
-        private Map<String, Object> delivery;
-        private List<Map<String, Object>> items;
-        private Map<String, Double> totals;
-        private Map<String, String> payment;
-
-        // Getters and setters
-        public String getOrderId() { return orderId; }
-        public void setOrderId(String orderId) { this.orderId = orderId; }
-        public Map<String, String> getCustomer() { return customer; }
-        public void setCustomer(Map<String, String> customer) { this.customer = customer; }
-        public Map<String, Object> getDelivery() { return delivery; }
-        public void setDelivery(Map<String, Object> delivery) { this.delivery = delivery; }
-        public List<Map<String, Object>> getItems() { return items; }
-        public void setItems(List<Map<String, Object>> items) { this.items = items; }
-        public Map<String, Double> getTotals() { return totals; }
-        public void setTotals(Map<String, Double> totals) { this.totals = totals; }
-        public Map<String, String> getPayment() { return payment; }
-        public void setPayment(Map<String, String> payment) { this.payment = payment; }
-    }
-
-    public static class WebhookResponse {
-        private boolean accepted;
-        private String orderId;
-        private String partnerOrderId;
-        private String message;
-        private String estimatedReadyTime;
-
-        public WebhookResponse(boolean accepted, String orderId, String partnerOrderId,
-                               String message, String estimatedReadyTime) {
-            this.accepted = accepted;
-            this.orderId = orderId;
-            this.partnerOrderId = partnerOrderId;
-            this.message = message;
-            this.estimatedReadyTime = estimatedReadyTime;
-        }
-
-        // Getters
-        public boolean isAccepted() { return accepted; }
-        public String getOrderId() { return orderId; }
-        public String getPartnerOrderId() { return partnerOrderId; }
-        public String getMessage() { return message; }
-        public String getEstimatedReadyTime() { return estimatedReadyTime; }
-    }
-
-    public static void main(String[] args) {
-        SpringApplication.run(GrubtechOrderWebhook.class, args);
-        System.out.println("✅ Webhook server started");
-        System.out.println("Webhook URL: http://localhost:8080/webhooks/grubtech/orders");
-    }
-}

package/templates/receive_order/python.template

@@ -1,157 +0,0 @@
-"""
-Grubtech Order Receive Webhook - Python (Flask)
-
-This example demonstrates how to receive orders from Grubtech
-via webhook and process them in your system.
-
-Prerequisites:
-- Python 3.8+
-- Flask (pip install flask)
-
-Replace the following placeholders:
-- {{WEBHOOK_SECRET}}: Your webhook secret for signature verification
-- {{ORDER_PROCESSING_LOGIC}}: Your business logic to process the order
-"""
-
-from flask import Flask, request, jsonify
-import hmac
-import hashlib
-import time
-from datetime import datetime, timedelta
-from typing import Dict, Any, List
-
-app = Flask(__name__)
-WEBHOOK_SECRET = '{{WEBHOOK_SECRET}}'
-
-
-def verify_signature(data: bytes, signature: str) -> bool:
-    """
-    Verify webhook signature using HMAC-SHA256
-
-    Args:
-        data: Raw request body
-        signature: Signature from X-Grubtech-Signature header
-
-    Returns:
-        bool: True if signature is valid
-    """
-    if not signature:
-        print('❌ No signature provided')
-        return False
-
-    # Calculate expected signature
-    expected_signature = hmac.new(
-        WEBHOOK_SECRET.encode('utf-8'),
-        data,
-        hashlib.sha256
-    ).hexdigest()
-
-    # Constant-time comparison
-    is_valid = hmac.compare_digest(signature, expected_signature)
-
-    if not is_valid:
-        print('❌ Invalid signature')
-
-    return is_valid
-
-
-def process_order(order: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Process order (replace with your business logic)
-
-    Args:
-        order: Order data from webhook
-
-    Returns:
-        Dict: Response to send back to Grubtech
-    """
-    try:
-        order_id = order['orderId']
-        customer_name = order['customer']['name']
-        items_count = len(order['items'])
-        total = order['totals']['total']
-
-        print(f'📦 Processing order: {order_id}')
-        print(f'Customer: {customer_name}')
-        print(f'Items: {items_count}')
-        print(f'Total: ${total}')
-
-        # {{ORDER_PROCESSING_LOGIC}}
-        # Example: Save to database, notify kitchen, etc.
-
-        # Simulate processing
-        time.sleep(0.1)
-
-        # Calculate estimated ready time (30 minutes from now)
-        ready_time = (datetime.utcnow() + timedelta(minutes=30)).isoformat() + 'Z'
-
-        return {
-            'accepted': True,
-            'orderId': order_id,
-            'partnerOrderId': f'POS-{int(time.time())}',
-            'message': 'Order accepted successfully',
-            'estimatedReadyTime': ready_time,
-        }
-
-    except Exception as e:
-        print(f'❌ Order processing error: {e}')
-
-        return {
-            'accepted': False,
-            'orderId': order.get('orderId', 'unknown'),
-            'message': f'Order rejected: {str(e)}',
-        }
-
-
-@app.route('/webhooks/grubtech/orders', methods=['POST'])
-def receive_order():
-    """
-    Webhook endpoint to receive orders from Grubtech
-    """
-    try:
-        # Get raw request data and signature
-        raw_data = request.get_data()
-        signature = request.headers.get('X-Grubtech-Signature', '')
-
-        # Verify signature
-        if not verify_signature(raw_data, signature):
-            return jsonify({
-                'accepted': False,
-                'message': 'Invalid signature',
-            }), 401
-
-        # Parse order data
-        order = request.get_json()
-
-        # Validate order data
-        if not order.get('orderId') or not order.get('items') or len(order['items']) == 0:
-            return jsonify({
-                'accepted': False,
-                'message': 'Invalid order data',
-            }), 400
-
-        # Process order
-        response = process_order(order)
-
-        # Send response
-        status_code = 200 if response['accepted'] else 400
-        return jsonify(response), status_code
-
-    except Exception as e:
-        print(f'❌ Webhook error: {e}')
-        return jsonify({
-            'accepted': False,
-            'message': 'Internal server error',
-        }), 500
-
-
-@app.route('/health', methods=['GET'])
-def health_check():
-    """Health check endpoint"""
-    return jsonify({'status': 'ok'})
-
-
-if __name__ == '__main__':
-    print('✅ Webhook server starting...')
-    print('Webhook URL: http://localhost:5000/webhooks/grubtech/orders')
-    app.run(host='0.0.0.0', port=5000, debug=True)

package/templates/receive_order/typescript.template

@@ -1,194 +0,0 @@
-/**
- * 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`);
-});