Building a Voice-Based Pizza Ordering Service with Twilio, OpenAI, and Google Maps

const { Client } = require("@googlemaps/google-maps-services-js");
const placesClient = new Client({});
async function validateAndFindNearestAddress(addr) {  
	/* 
	Initialize the request parameters for Google Maps Autocomplete API.
	This will take the user's input and attempt to find valid address matches.
	*/
	const autocompleteRequest = {  
		params: {  
			input: addr,
			types: "address",
			key: process.env.GOOGLE_MAPS_PLACES_API_KEY,
		},  
	};
	try {  
		/* 
		Send the autocomplete request to Google Maps API.
		If no predictions are returned, throw an error to indicate the address was invalid.
		*/
		const autocompleteResponse = await placesClient.placeAutocomplete(autocompleteRequest);
		if (!autocompleteResponse?.data?.predictions?.length) {  
			throw new Error("Could not find a valid or approximate match for the address.");  
		}
		/*
		Extract the place ID from the first prediction. 
		This ID is used to fetch detailed information about the address.
		*/
		const placeId = autocompleteResponse.data.predictions[0].place_id;
		/*
		Use the place ID to retrieve detailed address components, 
		such as street number, route, city, region, and postal code.
		*/
		const placeDetails = await placesClient.placeDetails({  
			params: {  
				place_id: placeId,
				key: process.env.GOOGLE_MAPS_PLACES_API_KEY,
				fields: ["address_components"],
			},  
		});  
		/* 
		Extract specific components from the address details. 
		If a component is missing, default values are provided to avoid errors.
		*/
		const components = placeDetails.data.result.address_components;
		const streetNumber = components.find((comp) => comp.types.includes("street_number"))?.long_name
							 || "0000";
		const route = components.find((comp) => comp.types.includes("route"))?.long_name || "";  
		const city = components.find((comp) => comp.types.includes("locality"))?.long_name || "";  
		const region = components.find((comp) => 
						comp.types.includes("administrative_area_level_1"))?.short_name || "";  
		const postalCode = components.find((comp) => comp.types.includes("postal_code"))?.long_name || "";
		/* 
		Return the address in a standardized format.
		This ensures the address meets the requirements of downstream APIs.
		*/
		return {  
			street: `${streetNumber} ${route}`.trim(),  
			city,  
			region,  
			postalCode,  
		};  
	} catch (error) {  
		/* 
		Handle errors gracefully by logging them and returning null. 
		This prevents the application from crashing due to invalid inputs.
		*/
		console.error("Error finding nearest valid address:", error);  
		return null;  
	}  
}

const OpenAI = require("openai");  
const client = new OpenAI({  
	apiKey: process.env.OPENAI_API_KEY,
});
async function getOrderDetails({ menu, prompt }) {  
	/* 
	Define a prompt for the AI model that includes the store's menu and the user's request.
	The goal is to extract a valid item code based on the user's description.
	*/
	const chatCompletion = await client.chat.completions.create({  
		messages: [{  
			role: "user",  
			content: `
Menu for this store:  
${menu}
User wants: ${prompt}
Output the most qualified CODE for what the user wants.  
Must be from the menu. DO NOT CHOOSE ITEMS THAT REQUIRE OPTIONS.  
OUTPUT NOTHING BUT THE CODE. NO QUOTES. ALWAYS OUTPUT SOMETHING,  
NEVER RETURN EMPTY.`, 
		}],  
		model: "gpt-4o-mini",
	});
	/* 
	Check the response from the AI model. If the response is empty, return null.
	Otherwise, extract the item code from the response content.
	*/
	if (!chatCompletion.choices[0].message.content) return null;  
	return {  
		code: chatCompletion.choices[0].message.content,  
	};  
}

const dominos = await import('dominos');
Object.assign(global, dominos);

const { canada, useInternational } = require("dominos/utils/urls.js");
useInternational(canada);

function getClosestStore(stores) {  
	/* 
	Initialize variables to track the closest store.
	Set a high initial distance to ensure the first valid store is selected.
	*/
	let storeID = 0;  
	let distance = 100; 
	/* 
	Iterate through the list of stores to find one that is:
	1. Capable of processing online orders.
	2. Open for delivery.
	3. Closest to the user.
	*/
	for (const store of stores) {  
		if (store.IsOnlineCapable && 
			store.IsDeliveryStore && 
			store.IsOpen && 
			store.ServiceIsOpen.Delivery && 
			store.MinDistance < distance
		) {  
			distance = store.MinDistance;  
			storeID = store.StoreID;  
		}  
	}
	/* 
	Return the closest store's ID.
	If no stores match the criteria, default to the first store in the list.
	*/
	return storeID || stores[0].StoreID;  
}

async function createOrder({ address, fullName, phone, prompt }) {
    // Validate and format the user's address
    const formattedAddress = new Address(await validateAndFindNearestAddress(address));
    // Retrieve nearby Dominos stores
    const nearbyStores = await new NearbyStores(formattedAddress);
    // If no stores are found, return null to indicate failure
    if (!nearbyStores.stores.length) return null;
    // Create a customer profile using the provided details
    const customer = new Customer({
        address: formattedAddress,
        firstName: fullName.split(" ")[0],
        lastName: fullName.split(" ")[1] || "",
        phone,
        email: "dummy@email.com",
    });
    // Determine the closest store and initialize an order
    const storeID = getClosestStore(nearbyStores.stores);
    const order = new Order(customer);

const menu = await new Menu(storeID);

/* 
Prepare the menu in a compact format for the AI model.
Each item is represented by its name and code to minimize unnecessary details.
*/
const itemDetails = await getOrderDetails({  
	menu: JSON.stringify(Array.from(
		Object.values(menu.menu.variants).map(item => ({
			name: item.name,
			code: item.code,
		}))
	)),
	prompt, // The user's input describing their order.
});

/* 
If the AI model fails to provide a valid item code, stop further processing.
*/
if (!itemDetails) return null;
/* 
Create a new item object using the returned item code and add it to the order.
This step links the user's request to a specific item in the store's menu.
*/
const pizza = new Item(itemDetails);  
order.storeID = storeID;  
order.addItem(pizza);
try {  
	/* 
	Validate the structure of the order.
	Calculate the total price based on the item's details and store pricing.
	*/
	await order.validate();  
	await order.price();  
} catch {  
	/* 
	If validation or pricing fails, return null.
	This ensures invalid orders are not processed further.
	*/
	return null;  
}
return order;
}

const order = await createOrder({  
	address: event.address,  
	fullName: event.name,  
	phone: event.phone,  
	prompt: event.prompt,  
});
/* 
If order creation fails, set a 404 status code and return an error response.
*/
if (!order) {  
	response.statusCode = 404;  
	return callback(null, response);  
}
/* 
If order creation succeeds, prepare a response containing all relevant order details.
This includes the total cost, estimated wait time, and delivery address.
*/
response.statusCode = 200;  
response.body = {  
	currency: order.formatted.Currency,  
	estWaitMinutes: order.formatted.EstimatedWaitMinutes,  
	priceAmount: order.formatted.AmountsBreakdown.customer,  
	orderID: order.products[0].code,
	storeID: order.storeID,  
	address: {  
		street: order.address.street,  
		city: order.address.city,  
		region: order.address.region,  
		postalCode: order.address.postalCode  
	}  
};
return callback(null, response);

prompt: {{widgets.get_food.SpeechResult}}  
name: {{widgets.get_name.SpeechResult}}  
address: {{widgets.get_address.SpeechResult}}  
phone: {{trigger.call.From}}

You will be charged {{widgets.get_price.parsed.body.priceAmount}} {{widgets.get_price.parsed.body.currency}}.

function generateTokenId() {  
	return `tok_${[...Array(32)].map(() => Math.floor(Math.random() * 16).toString(16)).join('')}`;  
}

const dominos = await import('dominos');  
Object.assign(global, dominos);
/*
This function creates a new Dominos order based on the provided user details and order code.
It initializes a customer object, assigns an address, and adds the desired item to the order.
The order is validated and priced before returning.
*/
async function createOrder({ street, city, region, postalCode, fullName, phoneNumber, orderCode, storeID }) {  
	const customer = new Customer({  
		address: new Address({  
			street,
			city,
			region,
			postalCode,
		}),  
		firstName: fullName.split(" ")[0], // Extract the first name
		lastName: fullName.split(" ")[1] || "", // Extract the last name, default to empty if not provided
		phone: phoneNumber,
		email: "dummy@email.com", // Placeholder email for demo purposes
	});
	const order = new Order(customer);  
	/*
	Add the desired item to the order using the provided item code. 
	Store ID is assigned to ensure the order is linked to the correct location.
	*/
	const pizza = new Item({ code: orderCode });  
	order.storeID = storeID;  
	order.addItem(pizza);  
	try {  
		await order.validate(); // Check the order structure and contents
		await order.price(); // Calculate the total price based on the menu and item details
	} catch {  
		return null; // If validation or pricing fails, return null to indicate the error
	}
	return order; // Return the completed order object
}

/*
Create a new order using parameters received from the event.
Each parameter corresponds to user-provided information, such as address, name, and order details.
*/
const order = await createOrder({  
	street: event.parameters.street,
	city: event.parameters.city,
	region: event.parameters.region,
	postalCode: event.parameters.postal_code,
	fullName: event.parameters.fullname,
	phoneNumber: event.parameters.phonenumber,
	orderCode: event.parameters.order,
	storeID: event.parameters.storeid,
});

{
	"transaction_id": "transaction_id",
	"cardnumber": "4111111111111111",
	"cvv": "123",
	"expiry_month": "08",
	"expiry_year": "27",
	"description": "pizza",
	"amount": "10.0",
	"currency_code": "USD",
	"postal_code": "94111",
	"method": "charge",
	"parameters": {
		"customer_defined_key_1": "customer_defined_value_1",
		"customer_defined_key_2": "customer_defined_value_2"
	}
}

{
	"token_id": "tok_abcdef0123456789abcdef0123456789",
	"error_code": null,
	"error_message": null
}

{
	"charge_id": "ch_abcdef0123456789abcdef0123456789",
	"parameters": {
		"gateway_key_returned_1": "gateway_value_returned_1",
		"gateway_key_returned_2": "gateway_value_returned_2",
		"gateway_key_returned_3": "gateway_value_returned_3"
	},
	"error_code": null,
	"error_message": null
}

/*
This response is part of Twilio's payment workflow. 
It handles both success and failure scenarios for order creation.
*/
const response = new Twilio.Response();
if (!order) {  
	response.setStatusCode(404); // Set status to indicate the order creation failed
	response.setBody({ error: "Order creation failed" }); // Provide an error message
	return callback(null, response); // Return the response and stop further execution
}

/*
Create a payment card object using the user's payment details.
This includes the card number, expiry date, CVV, and postal code.
*/
const card = new Payment({  
	amount: order.amountsBreakdown.customer, // The total cost for the user
	number: event.cardnumber, // The credit card number
	expiration: `${event.expiry_month.padStart(2, "0")}/${event.expiry_year}`, // Expiry in MM/YYYY format
	securityCode: event.cvv, // CVV (security code)
	postalCode: event.postal_code, // User's postal code for verification
	tipAmount: 0, // Optional: Tip amount, set to 0 here
});
/*
Add the payment card to the order's payments list.
This links the payment method to the current order.
*/
order.payments.push(card);

/*
Process the payment request and deliver the appropriate response.
This includes simulating delays for testing and handling both charge and tokenize methods.
*/
try {  
	await new Promise(res => setTimeout(res, 1500)); // Simulate a processing delay
	if (event.method === "charge") {  
		// Respond with a successful charge result
		response.setStatusCode(200);
		response.appendHeader('Content-Type', 'application/json');  
		response.setBody({  
			charge_id: "ch_abcdef0123456789abcdef0123456789", // Mock charge ID for testing
			parameters: null,  
			error_code: null,  
			error_message: null,
		});  
	} else if (event.method === "tokenize") {  
		// Respond with a successful tokenization result
		const tokenId = generateTokenId();  
		response.setStatusCode(200);
		response.appendHeader('Content-Type', 'application/json');  
		response.setBody({  
			token_id: tokenId,
			error_code: null,  
			error_message: null,
		});  
	} else {  
		// Handle invalid payment methods
		response.setStatusCode(400);  
		response.setBody({ error: "Invalid method" });  
	}
	return callback(null, response);
} catch (err) {  
	/*
	If an error occurs during payment processing, return a failure response.
	This ensures the user is notified of the issue.
	*/
	response.setStatusCode(403);  
	response.appendHeader('Content-Type', 'application/json');  
	response.setBody({  
		error_code: "PAYMENT_FAILED",  
		error_message: "Payment processing failed."
	});
	return callback(null, response);
}

{{widgets.get_price.parsed.body.priceAmount}}

order: {{widgets.get_price.parsed.body.orderID}}  
phonenumber: {{trigger.call.From}}  
storeid: {{widgets.get_price.parsed.body.storeID}}  
fullname: {{widgets.get_name.SpeechResult}}  
street: {{widgets.get_price.parsed.body.address.street}}  
city: {{widgets.get_price.parsed.body.address.city}}  
region: {{widgets.get_price.parsed.body.address.region}}