@chanaka_nakandala/integration-agent 1.0.0

package/templates/authenticate/java.template

@@ -0,0 +1,155 @@
+/**
+ * @description Grubtech API Authentication - Java (Spring Boot)
+ * @author Grubtech Integration Team
+ * @version 1.0.0
+ *
+ * This example demonstrates how to authenticate with the Grubtech API
+ * using an API key to obtain an access token.
+ *
+ * Prerequisites:
+ * - Java 17+
+ * - Spring Boot 3.x
+ * - Spring WebFlux (for WebClient)
+ *
+ * Dependencies (Maven):
+ * <dependency>
+ *   <groupId>org.springframework.boot</groupId>
+ *   <artifactId>spring-boot-starter-webflux</artifactId>
+ * </dependency>
+ *
+ * Replace the following placeholders:
+ * - {{API_KEY}}: Your Grubtech API key
+ * - {{PARTNER_ID}}: Your partner identifier
+ */
+
+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.HashMap;
+import java.util.Map;
+
+public class GrubtechAuthentication {
+
+    private static final String API_KEY = "{{API_KEY}}";
+    private static final String PARTNER_ID = "{{PARTNER_ID}}";
+    private static final String BASE_URL = "https://api.grubtech.io";
+
+    private final WebClient webClient;
+
+    public GrubtechAuthentication() {
+        this.webClient = WebClient.builder()
+                .baseUrl(BASE_URL)
+                .build();
+    }
+
+    /**
+     * Authenticate with Grubtech API and obtain access token
+     *
+     * @return Access token for API requests
+     * @throws RuntimeException if authentication fails
+     */
+    public String authenticate() {
+        try {
+            // Construct authentication request body
+            Map<String, String> requestBody = new HashMap<>();
+            requestBody.put("partnerId", PARTNER_ID);
+            requestBody.put("grantType", "api_key");
+
+            // Make authentication request
+            AuthResponse response = webClient.post()
+                    .uri("/v1/auth/token")
+                    .header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
+                    .header("x-api-key", API_KEY)
+                    .bodyValue(requestBody)
+                    .retrieve()
+                    .onStatus(
+                            status -> !status.is2xxSuccessful(),
+                            clientResponse -> clientResponse.bodyToMono(String.class)
+                                    .flatMap(errorBody -> Mono.error(
+                                            new RuntimeException(
+                                                    "Authentication failed: " +
+                                                    clientResponse.statusCode() +
+                                                    " - " + errorBody
+                                            )
+                                    ))
+                    )
+                    .bodyToMono(AuthResponse.class)
+                    .block();
+
+            if (response == null || response.getToken() == null) {
+                throw new RuntimeException("No token received from authentication");
+            }
+
+            System.out.println("Authentication successful!");
+            System.out.println("Token expires in: " + response.getExpiresIn() + " seconds");
+
+            return response.getToken();
+
+        } catch (Exception e) {
+            System.err.println("Authentication error: " + e.getMessage());
+            throw e;
+        }
+    }
+
+    /**
+     * Example: Use token in subsequent API requests
+     *
+     * @param token Access token from authenticate()
+     * @return API response
+     */
+    public Map<String, Object> exampleApiCall(String token) {
+        return webClient.get()
+                .uri("/v1/menus")
+                .header(HttpHeaders.AUTHORIZATION, "Bearer " + token)
+                .header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
+                .retrieve()
+                .onStatus(
+                        status -> !status.is2xxSuccessful(),
+                        clientResponse -> Mono.error(
+                                new RuntimeException("API call failed: " + clientResponse.statusCode())
+                        )
+                )
+                .bodyToMono(Map.class)
+                .block();
+    }
+
+    /**
+     * Response model for authentication endpoint
+     */
+    public static class AuthResponse {
+        private String token;
+        private int expiresIn;
+        private String tokenType;
+
+        // Getters and setters
+        public String getToken() { return token; }
+        public void setToken(String token) { this.token = token; }
+
+        public int getExpiresIn() { return expiresIn; }
+        public void setExpiresIn(int expiresIn) { this.expiresIn = expiresIn; }
+
+        public String getTokenType() { return tokenType; }
+        public void setTokenType(String tokenType) { this.tokenType = tokenType; }
+    }
+
+    // Main method for testing
+    public static void main(String[] args) {
+        try {
+            GrubtechAuthentication auth = new GrubtechAuthentication();
+
+            // Authenticate and get token
+            String token = auth.authenticate();
+
+            // Use token for API calls
+            Map<String, Object> menus = auth.exampleApiCall(token);
+            System.out.println("Menus: " + menus);
+
+        } catch (Exception e) {
+            System.exit(1);
+        }
+    }
+}

package/templates/authenticate/python.template

@@ -0,0 +1,111 @@
+"""
+@description Grubtech API Authentication - Python
+@author Grubtech Integration Team
+@version 1.0.0
+
+This example demonstrates how to authenticate with the Grubtech API
+using an API key to obtain an access token.
+
+Prerequisites:
+- Python 3.8+
+- requests library (pip install requests)
+- Valid Grubtech API key
+
+Replace the following placeholders:
+- {{API_KEY}}: Your Grubtech API key
+- {{PARTNER_ID}}: Your partner identifier
+"""
+
+import requests
+import sys
+from typing import Dict, Any
+
+API_KEY = '{{API_KEY}}'
+PARTNER_ID = '{{PARTNER_ID}}'
+BASE_URL = 'https://api.grubtech.io'
+
+
+def authenticate() -> str:
+    """
+    Authenticate with Grubtech API and obtain access token
+
+    Returns:
+        str: Access token for API requests
+
+    Raises:
+        Exception: If authentication fails
+    """
+    try:
+        # Construct authentication request
+        url = f'{BASE_URL}/v1/auth/token'
+        headers = {
+            'Content-Type': 'application/json',
+            'x-api-key': API_KEY,
+        }
+        payload = {
+            'partnerId': PARTNER_ID,
+            'grantType': 'api_key',
+        }
+
+        # Make authentication request
+        response = requests.post(url, json=payload, headers=headers, timeout=10)
+
+        # Check for errors
+        if not response.ok:
+            raise Exception(
+                f'Authentication failed: {response.status_code} - {response.text}'
+            )
+
+        # Extract token from response
+        data: Dict[str, Any] = response.json()
+        token = data['token']
+        expires_in = data.get('expiresIn', 'unknown')
+
+        print(f'Authentication successful!')
+        print(f'Token expires in: {expires_in} seconds')
+
+        return token
+
+    except requests.RequestException as e:
+        print(f'Authentication error: {e}', file=sys.stderr)
+        raise
+    except Exception as e:
+        print(f'Unexpected error: {e}', file=sys.stderr)
+        raise
+
+
+def example_api_call(token: str) -> Dict[str, Any]:
+    """
+    Example: Use token in subsequent API requests
+
+    Args:
+        token: Access token from authenticate()
+
+    Returns:
+        API response data
+    """
+    url = f'{BASE_URL}/v1/menus'
+    headers = {
+        'Authorization': f'Bearer {token}',
+        'Content-Type': 'application/json',
+    }
+
+    response = requests.get(url, headers=headers, timeout=10)
+
+    if not response.ok:
+        raise Exception(f'API call failed: {response.status_code}')
+
+    return response.json()
+
+
+if __name__ == '__main__':
+    try:
+        # Authenticate and get token
+        access_token = authenticate()
+
+        # Use token for API calls
+        menus = example_api_call(access_token)
+        print(f'Menus: {menus}')
+
+    except Exception as e:
+        sys.exit(1)

package/templates/authenticate/typescript.template

@@ -0,0 +1,98 @@
+/**
+ * @description Grubtech API Authentication - TypeScript
+ * @author Grubtech Integration Team
+ * @version 1.0.0
+ *
+ * This example demonstrates how to authenticate with the Grubtech API
+ * using an API key to obtain an access token.
+ *
+ * Prerequisites:
+ * - Node.js 18+ with fetch API support
+ * - Valid Grubtech API key
+ *
+ * Replace the following placeholders:
+ * - {{API_KEY}}: Your Grubtech API key
+ * - {{PARTNER_ID}}: Your partner identifier
+ */
+
+const API_KEY = '{{API_KEY}}';
+const PARTNER_ID = '{{PARTNER_ID}}';
+const BASE_URL = 'https://api.grubtech.io';
+
+interface AuthResponse {
+  token: string;
+  expiresIn: number;
+  tokenType: string;
+}
+
+/**
+ * Authenticate with Grubtech API and obtain access token
+ */
+async function authenticate(): Promise<string> {
+  try {
+    // Construct authentication request
+    const response = await fetch(`${BASE_URL}/v1/auth/token`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': API_KEY,
+      },
+      body: JSON.stringify({
+        partnerId: PARTNER_ID,
+        grantType: 'api_key',
+      }),
+    });
+
+    // Check for errors
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(
+        `Authentication failed: ${response.status} - ${errorBody}`
+      );
+    }
+
+    // Extract token from response
+    const data: AuthResponse = await response.json();
+    const token = data.token;
+
+    console.log('Authentication successful!');
+    console.log(`Token expires in: ${data.expiresIn} seconds`);
+
+    return token;
+  } catch (error) {
+    console.error('Authentication error:', error);
+    throw error;
+  }
+}
+
+/**
+ * Example: Use token in subsequent API requests
+ */
+async function exampleApiCall(token: string) {
+  const response = await fetch(`${BASE_URL}/v1/menus`, {
+    method: 'GET',
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`API call failed: ${response.status}`);
+  }
+
+  return response.json();
+}
+
+// Main execution
+(async () => {
+  try {
+    const token = await authenticate();
+
+    // Use token for API calls
+    const menus = await exampleApiCall(token);
+    console.log('Menus:', menus);
+  } catch (error) {
+    process.exit(1);
+  }
+})();

package/templates/create_menu/curl.template

@@ -0,0 +1,145 @@
+#!/bin/bash
+
+# Grubtech Menu Sync - cURL
+#
+# This example demonstrates how to push menu data to Grubtech API.
+#
+# 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
+# - {{MENU_DATA}}: Your menu data in the required format
+
+AUTH_TOKEN="{{AUTH_TOKEN}}"
+BASE_URL="https://api.grubtech.io"
+
+# Example menu data (replace with your actual menu)
+MENU_DATA='{
+  "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
+create_menu() {
+    echo "Creating menu in Grubtech..."
+
+    # Make menu creation request
+    RESPONSE=$(curl -s -w "\n%{http_code}" -X POST \
+        "${BASE_URL}/v1/menus" \
+        -H "Authorization: Bearer ${AUTH_TOKEN}" \
+        -H "Content-Type: application/json" \
+        -d "${MENU_DATA}")
+
+    # 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 ] && [ "$HTTP_CODE" -ne 201 ]; then
+        echo "❌ Menu creation failed: HTTP $HTTP_CODE"
+        echo "Response: $BODY"
+        return 1
+    fi
+
+    # Extract menu ID from response
+    if command -v jq &> /dev/null; then
+        MENU_ID=$(echo "$BODY" | jq -r '.menuId')
+        STATUS=$(echo "$BODY" | jq -r '.status')
+
+        echo "✅ Menu created successfully!"
+        echo "Menu ID: ${MENU_ID}"
+        echo "Status: ${STATUS}"
+    else
+        # Fallback: manual parsing
+        MENU_ID=$(echo "$BODY" | grep -o '"menuId":"[^"]*' | cut -d'"' -f4)
+        echo "✅ Menu created successfully!"
+        echo "Menu ID: ${MENU_ID}"
+        echo "Note: Install jq for better JSON parsing"
+    fi
+
+    echo "$MENU_ID"
+}
+
+# Update existing menu
+update_menu() {
+    local MENU_ID=$1
+
+    echo "Updating menu ${MENU_ID}..."
+
+    curl -s -X PUT \
+        "${BASE_URL}/v1/menus/${MENU_ID}" \
+        -H "Authorization: Bearer ${AUTH_TOKEN}" \
+        -H "Content-Type: application/json" \
+        -d "${MENU_DATA}"
+
+    if [ $? -eq 0 ]; then
+        echo "✅ Menu updated successfully!"
+    else
+        echo "❌ Menu update failed"
+        return 1
+    fi
+}
+
+# Main execution
+main() {
+    # Create menu
+    MENU_ID=$(create_menu)
+
+    if [ -z "$MENU_ID" ]; then
+        echo "Failed to create menu"
+        exit 1
+    fi
+
+    echo ""
+    echo "Menu created with ID: ${MENU_ID}"
+
+    # Optionally update the menu
+    # update_menu "$MENU_ID"
+}
+
+# Run main function
+main