@chanaka_nakandala/integration-agent 1.0.0

package/templates/create_menu/java.template

@@ -0,0 +1,285 @@
+/**
+ * Grubtech Menu Sync - Java (Spring Boot)
+ *
+ * This example demonstrates how to push menu data to Grubtech API.
+ *
+ * Prerequisites:
+ * - Java 17+
+ * - Spring Boot 3.x
+ * - Spring WebFlux (for WebClient)
+ *
+ * Replace the following placeholders:
+ * - {{AUTH_TOKEN}}: Access token from authentication step
+ * - {{MENU_DATA}}: Your menu data in the required format
+ */
+
+package com.example.grubtech;
+
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.web.reactive.function.client.WebClient;
+import reactor.core.publisher.Mono;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class GrubtechMenuSync {
+
+    private static final String AUTH_TOKEN = "{{AUTH_TOKEN}}";
+    private static final String BASE_URL = "https://api.grubtech.io";
+
+    private final WebClient webClient;
+
+    public GrubtechMenuSync() {
+        this.webClient = WebClient.builder()
+                .baseUrl(BASE_URL)
+                .build();
+    }
+
+    /**
+     * Push menu data to Grubtech API
+     *
+     * @param menuData Menu data object
+     * @return Menu ID from response
+     */
+    public String createMenu(MenuData menuData) {
+        try {
+            // Validate menu data
+            if (menuData.getCategories() == null || menuData.getCategories().isEmpty()) {
+                throw new IllegalArgumentException("Menu must have at least one category");
+            }
+
+            // Make menu creation request
+            MenuResponse response = webClient.post()
+                    .uri("/v1/menus")
+                    .header(HttpHeaders.AUTHORIZATION, "Bearer " + AUTH_TOKEN)
+                    .header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
+                    .bodyValue(menuData)
+                    .retrieve()
+                    .onStatus(
+                            status -> !status.is2xxSuccessful(),
+                            clientResponse -> clientResponse.bodyToMono(String.class)
+                                    .flatMap(errorBody -> Mono.error(
+                                            new RuntimeException(
+                                                    "Menu creation failed: " +
+                                                    clientResponse.statusCode() +
+                                                    " - " + errorBody
+                                            )
+                                    ))
+                    )
+                    .bodyToMono(MenuResponse.class)
+                    .block();
+
+            if (response == null || response.getMenuId() == null) {
+                throw new RuntimeException("No menu ID received from response");
+            }
+
+            System.out.println("✅ Menu created successfully!");
+            System.out.println("Menu ID: " + response.getMenuId());
+            System.out.println("Status: " + response.getStatus());
+
+            return response.getMenuId();
+
+        } catch (Exception e) {
+            System.err.println("❌ Menu creation error: " + e.getMessage());
+            throw e;
+        }
+    }
+
+    /**
+     * Update existing menu
+     *
+     * @param menuId   ID of the menu to update
+     * @param menuData Updated menu data
+     */
+    public void updateMenu(String menuId, MenuData menuData) {
+        try {
+            webClient.put()
+                    .uri("/v1/menus/" + menuId)
+                    .header(HttpHeaders.AUTHORIZATION, "Bearer " + AUTH_TOKEN)
+                    .header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
+                    .bodyValue(menuData)
+                    .retrieve()
+                    .onStatus(
+                            status -> !status.is2xxSuccessful(),
+                            clientResponse -> Mono.error(
+                                    new RuntimeException("Menu update failed: " + clientResponse.statusCode())
+                            )
+                    )
+                    .toBodilessEntity()
+                    .block();
+
+            System.out.println("✅ Menu updated successfully!");
+
+        } catch (Exception e) {
+            System.err.println("❌ Menu update error: " + e.getMessage());
+            throw e;
+        }
+    }
+
+    /**
+     * Create example menu data
+     */
+    private static MenuData createExampleMenuData() {
+        MenuData menu = new MenuData();
+        menu.setName("Restaurant Menu");
+        menu.setDescription("Main menu with categories and items");
+
+        List<MenuCategory> categories = new ArrayList<>();
+
+        // Appetizers category
+        MenuCategory appetizers = new MenuCategory();
+        appetizers.setId("cat-1");
+        appetizers.setName("Appetizers");
+        appetizers.setDescription("Start your meal right");
+        appetizers.setSortOrder(1);
+
+        MenuItem springRolls = new MenuItem();
+        springRolls.setId("item-1");
+        springRolls.setName("Spring Rolls");
+        springRolls.setDescription("Crispy vegetable spring rolls");
+        springRolls.setPrice(8.99);
+        springRolls.setAvailable(true);
+
+        Modifier extraSauce = new Modifier();
+        extraSauce.setId("mod-1");
+        extraSauce.setName("Extra Sauce");
+        extraSauce.setPrice(1.50);
+        extraSauce.setAvailable(true);
+
+        springRolls.setModifiers(List.of(extraSauce));
+        appetizers.setItems(List.of(springRolls));
+
+        // Main courses category
+        MenuCategory mainCourses = new MenuCategory();
+        mainCourses.setId("cat-2");
+        mainCourses.setName("Main Courses");
+        mainCourses.setDescription("Delicious entrees");
+        mainCourses.setSortOrder(2);
+
+        MenuItem chicken = new MenuItem();
+        chicken.setId("item-2");
+        chicken.setName("Grilled Chicken");
+        chicken.setDescription("Tender chicken with herbs");
+        chicken.setPrice(15.99);
+        chicken.setAvailable(true);
+        chicken.setModifiers(new ArrayList<>());
+
+        mainCourses.setItems(List.of(chicken));
+
+        categories.add(appetizers);
+        categories.add(mainCourses);
+        menu.setCategories(categories);
+
+        return menu;
+    }
+
+    // Data models
+    public static class MenuData {
+        private String name;
+        private String description;
+        private List<MenuCategory> categories;
+
+        // Getters and setters
+        public String getName() { return name; }
+        public void setName(String name) { this.name = name; }
+        public String getDescription() { return description; }
+        public void setDescription(String description) { this.description = description; }
+        public List<MenuCategory> getCategories() { return categories; }
+        public void setCategories(List<MenuCategory> categories) { this.categories = categories; }
+    }
+
+    public static class MenuCategory {
+        private String id;
+        private String name;
+        private String description;
+        private int sortOrder;
+        private List<MenuItem> items;
+
+        // Getters and setters omitted for brevity
+        public String getId() { return id; }
+        public void setId(String id) { this.id = id; }
+        public String getName() { return name; }
+        public void setName(String name) { this.name = name; }
+        public String getDescription() { return description; }
+        public void setDescription(String description) { this.description = description; }
+        public int getSortOrder() { return sortOrder; }
+        public void setSortOrder(int sortOrder) { this.sortOrder = sortOrder; }
+        public List<MenuItem> getItems() { return items; }
+        public void setItems(List<MenuItem> items) { this.items = items; }
+    }
+
+    public static class MenuItem {
+        private String id;
+        private String name;
+        private String description;
+        private double price;
+        private boolean available;
+        private List<Modifier> modifiers;
+
+        // Getters and setters omitted for brevity
+        public String getId() { return id; }
+        public void setId(String id) { this.id = id; }
+        public String getName() { return name; }
+        public void setName(String name) { this.name = name; }
+        public String getDescription() { return description; }
+        public void setDescription(String description) { this.description = description; }
+        public double getPrice() { return price; }
+        public void setPrice(double price) { this.price = price; }
+        public boolean isAvailable() { return available; }
+        public void setAvailable(boolean available) { this.available = available; }
+        public List<Modifier> getModifiers() { return modifiers; }
+        public void setModifiers(List<Modifier> modifiers) { this.modifiers = modifiers; }
+    }
+
+    public static class Modifier {
+        private String id;
+        private String name;
+        private double price;
+        private boolean available;
+
+        // Getters and setters omitted for brevity
+        public String getId() { return id; }
+        public void setId(String id) { this.id = id; }
+        public String getName() { return name; }
+        public void setName(String name) { this.name = name; }
+        public double getPrice() { return price; }
+        public void setPrice(double price) { this.price = price; }
+        public boolean isAvailable() { return available; }
+        public void setAvailable(boolean available) { this.available = available; }
+    }
+
+    public static class MenuResponse {
+        private String menuId;
+        private String status;
+        private String message;
+
+        // Getters and setters
+        public String getMenuId() { return menuId; }
+        public void setMenuId(String menuId) { this.menuId = menuId; }
+        public String getStatus() { return status; }
+        public void setStatus(String status) { this.status = status; }
+        public String getMessage() { return message; }
+        public void setMessage(String message) { this.message = message; }
+    }
+
+    // Main method for testing
+    public static void main(String[] args) {
+        try {
+            GrubtechMenuSync menuSync = new GrubtechMenuSync();
+
+            // Create example menu data
+            MenuData menuData = createExampleMenuData();
+
+            // Create menu
+            String menuId = menuSync.createMenu(menuData);
+
+            // Optionally update the menu
+            // menuSync.updateMenu(menuId, menuData);
+
+        } catch (Exception e) {
+            System.exit(1);
+        }
+    }
+}

package/templates/create_menu/python.template

@@ -0,0 +1,159 @@
+"""
+Grubtech Menu Sync - Python
+
+This example demonstrates how to push menu data to Grubtech API.
+
+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
+- {{MENU_DATA}}: Your menu data in the required format
+"""
+
+import requests
+import sys
+from typing import Dict, Any, List
+
+AUTH_TOKEN = '{{AUTH_TOKEN}}'
+BASE_URL = 'https://api.grubtech.io'
+
+# Example menu data structure
+# Replace this with your actual menu data
+MENU_DATA: Dict[str, Any] = {
+    'name': 'Restaurant Menu',
+    'description': 'Main menu with categories and items',
+    'categories': [
+        {
+            'id': 'cat-1',
+            'name': 'Appetizers',
+            'description': 'Start your meal right',
+            'sortOrder': 1,
+            'items': [
+                {
+                    'id': 'item-1',
+                    'name': 'Spring Rolls',
+                    'description': 'Crispy vegetable spring rolls',
+                    'price': 8.99,
+                    'available': True,
+                    'modifiers': [
+                        {
+                            'id': 'mod-1',
+                            'name': 'Extra Sauce',
+                            'price': 1.50,
+                            'available': True,
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            'id': 'cat-2',
+            'name': 'Main Courses',
+            'description': 'Delicious entrees',
+            'sortOrder': 2,
+            'items': [
+                {
+                    'id': 'item-2',
+                    'name': 'Grilled Chicken',
+                    'description': 'Tender chicken with herbs',
+                    'price': 15.99,
+                    'available': True,
+                    'modifiers': [],
+                },
+            ],
+        },
+    ],
+}
+
+
+def create_menu(menu_data: Dict[str, Any]) -> str:
+    """
+    Push menu data to Grubtech API
+
+    Args:
+        menu_data: Menu data dictionary
+
+    Returns:
+        str: Menu ID from response
+
+    Raises:
+        Exception: If menu creation fails
+    """
+    try:
+        # Validate menu data before sending
+        if not menu_data.get('categories') or len(menu_data['categories']) == 0:
+            raise ValueError('Menu must have at least one category')
+
+        # Make menu creation request
+        url = f'{BASE_URL}/v1/menus'
+        headers = {
+            'Authorization': f'Bearer {AUTH_TOKEN}',
+            'Content-Type': 'application/json',
+        }
+
+        response = requests.post(url, json=menu_data, headers=headers, timeout=30)
+
+        # Check for errors
+        if not response.ok:
+            raise Exception(
+                f'Menu creation failed: {response.status_code} - {response.text}'
+            )
+
+        # Extract menu ID from response
+        data: Dict[str, Any] = response.json()
+        menu_id = data['menuId']
+
+        print(f'✅ Menu created successfully!')
+        print(f'Menu ID: {menu_id}')
+        print(f'Status: {data.get("status", "unknown")}')
+
+        return menu_id
+
+    except requests.RequestException as e:
+        print(f'❌ Menu creation error: {e}', file=sys.stderr)
+        raise
+    except Exception as e:
+        print(f'❌ Unexpected error: {e}', file=sys.stderr)
+        raise
+
+
+def update_menu(menu_id: str, menu_data: Dict[str, Any]) -> None:
+    """
+    Update existing menu
+
+    Args:
+        menu_id: ID of the menu to update
+        menu_data: Updated menu data
+    """
+    try:
+        url = f'{BASE_URL}/v1/menus/{menu_id}'
+        headers = {
+            'Authorization': f'Bearer {AUTH_TOKEN}',
+            'Content-Type': 'application/json',
+        }
+
+        response = requests.put(url, json=menu_data, headers=headers, timeout=30)
+
+        if not response.ok:
+            raise Exception(f'Menu update failed: {response.status_code} - {response.text}')
+
+        print(f'✅ Menu updated successfully!')
+
+    except Exception as e:
+        print(f'❌ Menu update error: {e}', file=sys.stderr)
+        raise
+
+
+if __name__ == '__main__':
+    try:
+        # Create new menu
+        menu_id = create_menu(MENU_DATA)
+
+        # Optionally update the menu
+        # update_menu(menu_id, MENU_DATA)
+
+    except Exception as e:
+        sys.exit(1)

package/templates/create_menu/typescript.template

@@ -0,0 +1,184 @@
+/**
+ * Grubtech Menu Sync - TypeScript
+ *
+ * This example demonstrates how to push menu data to Grubtech API.
+ *
+ * Prerequisites:
+ * - Node.js 18+ with fetch API
+ * - Valid access token from authentication
+ *
+ * Replace the following placeholders:
+ * - {{AUTH_TOKEN}}: Access token from authentication step
+ * - {{MENU_DATA}}: Your menu data in the required format
+ */
+
+const AUTH_TOKEN = '{{AUTH_TOKEN}}';
+const BASE_URL = 'https://api.grubtech.io';
+
+interface MenuItem {
+  id: string;
+  name: string;
+  description: string;
+  price: number;
+  available: boolean;
+  modifiers?: Modifier[];
+}
+
+interface Modifier {
+  id: string;
+  name: string;
+  price: number;
+  available: boolean;
+}
+
+interface MenuCategory {
+  id: string;
+  name: string;
+  description: string;
+  sortOrder: number;
+  items: MenuItem[];
+}
+
+interface MenuData {
+  name: string;
+  description: string;
+  categories: MenuCategory[];
+}
+
+interface MenuResponse {
+  menuId: string;
+  status: string;
+  message: string;
+}
+
+/**
+ * Example menu data structure
+ * Replace this with your actual menu data
+ */
+const MENU_DATA: MenuData = {
+  name: 'Restaurant Menu',
+  description: 'Main menu with categories and items',
+  categories: [
+    {
+      id: 'cat-1',
+      name: 'Appetizers',
+      description: 'Start your meal right',
+      sortOrder: 1,
+      items: [
+        {
+          id: 'item-1',
+          name: 'Spring Rolls',
+          description: 'Crispy vegetable spring rolls',
+          price: 8.99,
+          available: true,
+          modifiers: [
+            {
+              id: 'mod-1',
+              name: 'Extra Sauce',
+              price: 1.50,
+              available: true,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      id: 'cat-2',
+      name: 'Main Courses',
+      description: 'Delicious entrees',
+      sortOrder: 2,
+      items: [
+        {
+          id: 'item-2',
+          name: 'Grilled Chicken',
+          description: 'Tender chicken with herbs',
+          price: 15.99,
+          available: true,
+          modifiers: [],
+        },
+      ],
+    },
+  ],
+};
+
+/**
+ * Push menu data to Grubtech API
+ */
+async function createMenu(menuData: MenuData): Promise<string> {
+  try {
+    // Validate menu data before sending
+    if (!menuData.categories || menuData.categories.length === 0) {
+      throw new Error('Menu must have at least one category');
+    }
+
+    // Make menu creation request
+    const response = await fetch(`${BASE_URL}/v1/menus`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${AUTH_TOKEN}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(menuData),
+    });
+
+    // Check for errors
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(
+        `Menu creation failed: ${response.status} - ${errorBody}`
+      );
+    }
+
+    // Extract menu ID from response
+    const data: MenuResponse = await response.json();
+    const menuId = data.menuId;
+
+    console.log('✅ Menu created successfully!');
+    console.log(`Menu ID: ${menuId}`);
+    console.log(`Status: ${data.status}`);
+
+    return menuId;
+  } catch (error) {
+    console.error('❌ Menu creation error:', error);
+    throw error;
+  }
+}
+
+/**
+ * Update existing menu
+ */
+async function updateMenu(menuId: string, menuData: MenuData): Promise<void> {
+  try {
+    const response = await fetch(`${BASE_URL}/v1/menus/${menuId}`, {
+      method: 'PUT',
+      headers: {
+        'Authorization': `Bearer ${AUTH_TOKEN}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(menuData),
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Menu update failed: ${response.status} - ${errorBody}`);
+    }
+
+    console.log('✅ Menu updated successfully!');
+  } catch (error) {
+    console.error('❌ Menu update error:', error);
+    throw error;
+  }
+}
+
+// Main execution
+(async () => {
+  try {
+    // Create new menu
+    const menuId = await createMenu(MENU_DATA);
+
+    // Optionally update the menu
+    // await updateMenu(menuId, MENU_DATA);
+  } catch (error) {
+    process.exit(1);
+  }
+})();