Tips & Tricks

How to build an AI travel SaaS With Tape as backend

Thaha

App Builder & Automation Expert

Last updated Tuesday, April 01, 2025

Stay Updated with ProcFu!

Subscribe to our newsletter for the latest tips, updates, and automation insights.

What if you could turn an idea into a revenue-ready SaaS in a few hours? I did just that with ProcFu, a low-code platform, building an AI-powered travel itinerary generator. From a simple form to OpenAI integration, Stripe payments, and email delivery, it’s live and customer-ready—proof that you can spin up a project fast and focus on sales. Here’s how I did it, complete with the code, so you can build it too.

The Vision: AI Meets Travel Planning

The app lets users input travel details - destination, dates, preferences, budget—and get a personalized itinerary. You get a free summary for free and if you like it, you can pay 3$ to get the whole itenary.

It’s a digital travel agent, built to sell. With ProcFu, I went from concept to working SaaS in hours, not months.

Step 1: ProcFu - Tape integration

You can quickly integrate your Tape account with ProcFu through the integrations page. Simply retrieve your Tape API key and enter it into the API key field within ProcFu.

ProcFu also offers several wrappers for Tape API, making it easier to make API calls from ProcFu to Tape and extract information efficiently.

We need to create three apps in Tape for this project:

Users App: Stores user information, including name, email, password, and a "Last Request" field. An automation will update this field with the latest itinerary request for easy access.

Itinerary Request App: Linked to the Users app, this stores all form submission details. It also includes two fields for AI-generated itineraries: a summary and a full itinerary.

Payments App: Connected to both the User and Itinerary Request apps, this stores payment information retrieved from Stripe, including transaction details.

Additionally, we'll use a Tape automation to update the user's record with the latest itinerary request ID.

Step 2: The Homepage

ProcFu App Builder Interface

Screen Type: Generic HTML Form

Screen Visibility: Public

Purpose: This is where users start, they see the form and enters their travel details to kick off the process.

ProcFu’s form builder and scripting let me craft a polished UI without backend headaches. The data flows straight into the next step.

Header Section:

Adds the title to the form and required styles.

Header section of the homepage with the code to style

Content Section:

We create a multi-step HTML form with a clean, styled layout. It’s split into four steps: destination/dates, travelers/interests, budget/pace, and name/email.

Next/Prev Buttons: Clicking "Next" hides the current step and shows the next one; "Back" reverses it. JavaScript in the On-Render section handles this seamlessly.

Content Section of the homepage with the form code

On-Render Section

This section enables the Next/Prev buttons to show or hide form steps.

JS code in the On Render section to power the next/previous buttons

Before-Submit Section

On submit, ProcFu validates required fields (marked with *), creates a user in an SQL database if new, logs the request, and redirects to the payment screen.

You must Integrate your database to ProcFu in the integrations page.

Before Submit section of the home page - Part 1 of the code

Before Submit section of the home page - Part 2 of the code

Step 2: The Payments Page

Screen Type: Text Information

Screen Visibility: Public

Purpose: This screen shows a free trip summary generated by AI and offers the option to pay $3 for the full itinerary.

Content Section:

On Load, a loading spinner displays while an AJAX call fetches a summary from the backend.

Once the summary arrives, the spinner hides, and the formatted summary appears. JavaScript styles it into readable HTML.

Clicking "Buy Now" redirects to a Stripe payment link.

Content Section of the payment page

Header Section:

Sets up the layout and styles for the summary display and payment button.

Header section of the payment page with the code to style

On-Render Section:

Triggers an AJAX call to fetch the summary, displays it by hiding the spinner, and sets up the payment redirect.

JS code in the On Render section to make AJAX request and display the summary when ready

Step 3: The Ajax Page

Screen Type: Text Information

Screen Visibility: Private (backend only)

Purpose: This screen shows a free trip summary generated by AI and offers the option to pay $3 for the full itinerary.

Before-Process Section:

ProcFu sends a POST request to OpenAI with the user’s input, gets a summary, stores it in the database, and returns it to the payment screen.

ProcFu’s remote_curl and MySQL integration make API calls and data storage effortless, keeping the flow smooth.

Before Process section of the AJAX screen where the summary generation happens

Step 4: The Success Page

Screen Type: Text Information

Screen Visibility: Public

Purpose: Confirms payment success and informs the user their full itinerary is on its way. A simple, clear UI reassures users while the backend handles the heavy lifting.

Header Section:

Styles the confirmation message with a success theme.

Header section of the success page with the code to style

Content Section:

Displays a checkmark and a message about email delivery.

Content section of the payment page showing success message

Step 5: The Stripe Webhook

Screen Type: Code Block (Webhook)

Purpose: Processes the Stripe webhook, generates the full itinerary, and emails it to the user. The script verifies the payment, generates the full itinerary with OpenAI, updates the database, and emails the user.

WebHook Stripe triggers a Webhook to a unique ProcFu URL (Auto generated when the script mode is set to HTTP - via URL) when payment completes.

Code Block to handle the Stripe Webhook

Step 6: Setting up ProcFu URL in Stripe for Webhook

Purpose: This step connects the Stripe payment system to ProcFu by setting up a webhook URL, ensuring payment events trigger the itinerary generation and delivery process.

Locate the Webhook URL in ProcFu:

In ProcFu, go to the "Code Blocks" section where you created the Stripe webhook (Step 5).

After saving the code block, ProcFu generates a unique URL (e.g., https://procfu.com/widgets/code/YOUR_WEBHOOK_ID). Copy this URL.

Set Up the Webhook in Stripe:

Navigate to Developers > Webhooks in the left sidebar.

Click + Add Endpoint.

Paste the ProcFu webhook URL into the "Endpoint URL" field.

Select the event checkout.session.completed to listen for successful payments.

Click Add Endpoint.

This step ensures Stripe notifies ProcFu when a $3 payment is completed, triggering the full itinerary delivery.

Code Block to handle the Stripe Webhook

Why It Matters: A Starting Point with Endless Potential

This entire SaaS—form, AI, payments, delivery—took hours, not months. ProcFu’s low-code power let me focus on the product, not the plumbing. It’s live, it’s sellable, and now it’s about getting customers.

But this is just the beginning. It could be fleshed out in countless ways—add user accounts, itinerary customization, multi-language support, or even a subscription model. The power lies in how fast you can go from idea to revenue-ready product, letting you focus on growth, not grunt work. What’s your twist on this? Let’s connect and explore.

The Real Punchline: Building’s Easy, Cashing In’s the Circus

So, there you have it - I slapped together this $3 AI travel itinerary SaaS in a few hours with ProcFu’s low-code wizardry and Tape's impressive backend, proving building stuff has become a breeze. Now comes the hard work of distribution, marketing and selling.

Download Code

To add this app to your ProcFu account:

Create a new app in ProcFu.
In the right sidebar of the Application Configuration page, click Import from Data.
Paste the code below into the popup and click Import.
After importing, you'll see a screen named "code". Its "Before-Process" event contains the Stripe Webhook handling code.
Open the Code Editor, create a new script, and paste in the code from the code screen. Set the mode to HTTP - via URL. This script will handle Stripe Webhooks.
Once the script is created, you can safely delete the code screen. It’s no longer needed for the app to function.
Do not forget to update the Stripe API key in the "code" screen and the "ajax" screen.

Code

{
  "pkApps": "10148",
  "appName": "AI Travel Itenary Generator",
  "niceSlug": "",
  "fkUsers": "2419",
  "authType": "",
  "extId": "9qRMjx7xUduk",
  "appDescription": "",
  "tags": "",
  "icon": "",
  "lastSave": "2025-03-25 11:26:14",
  "data": {
    "version": 3,
    "appName": "AI Travel Itenary Generator",
    "authType": "",
    "description": "",
    "niceSlug": "",
    "https": 1,
    "screens": [
      {
        "name": "start",
        "public": "1",
        "screenType": "auth",
        "config": { "authType": "n", "onSubmit": "1" }
      },
      {
        "public": "1",
        "name": "homepage",
        "screenType": "form",
        "scrMkdHead": "<h2>Generate Personalised Iternary with AI just for you.</h2>\n<style>\nbody { font-family: Arial, sans-serif; background: #f0f8ff; display: flex; justify-content: center; align-items: center; height: 100vh; }\nh2 { text-align: center; color: #007bff; }\nlabel { display: block; margin: 10px 0 5px; }\ninput, select, textarea { width: 100%; padding: 8px; margin-bottom: 15px; border: 1px solid #ddd; border-radius: 5px; }\nbutton:hover { background: #0056b3; }\n.next-step { width: 100%; background: #007bff; color: white; padding: 10px; border: none; border-radius: 5px; cursor: pointer; }\n.prev-step { display: inline-block; color: #007bff; text-decoration: none; font-weight: bold; padding: 8px 12px; border-radius: 5px; transition: color 0.3s ease-in-out; }\n.prev-step:hover { color: #0056b3;  text-decoration: underline; }\n.container { background: white; padding: 20px; border-radius: 10px; box-shadow: 0 4px 10px rgba(0, 0, 0, 0.1); width: 350px; }\n.pf-form {  background: transparent !important;  border: none; }\n</style>",
        "scrMkdFoot": "",
        "intnotes": "",
        "config": {
          "html": "<div class=\"container\">\n    <div class=\"form-step\">\n    <label for=\"destination\">Where are you traveling?*</label>\n    <input type=\"text\" id=\"destination\" name=\"destination\" placeholder=\"e.g., Paris, France\">\n    \n    <label for=\"startDate\">Start Date*</label>\n    <input type=\"date\" id=\"startDate\" name=\"startDate\">\n    \n    <label for=\"endDate\">End Date*</label>\n    <input type=\"date\" id=\"endDate\" name=\"endDate\">\n    \n    <button type=\"button\" class=\"next-step\">Next</button>\n    </div>\n    \n    <div class=\"form-step\" style=\"display: none;\">\n    <label for=\"travelers\">Number of Travelers*</label>\n    <input type=\"number\" id=\"travelers\" name=\"travelers\">\n    \n    <label>What's your travel style?</label>\n    <div class=\"checkbox-group\">\n    <label><input type=\"checkbox\" name=\"interests\" value=\"Adventure\"> Adventure</label>\n    <label><input type=\"checkbox\" name=\"interests\" value=\"Culture\"> Culture</label>\n    <label><input type=\"checkbox\" name=\"interests\" value=\"Food\"> Food</label>\n    <label><input type=\"checkbox\" name=\"interests\" value=\"Nature\"> Nature</label>\n    <label><input type=\"checkbox\" name=\"interests\" value=\"Relaxation\"> Relaxation</label>\n    <label><input type=\"checkbox\" name=\"interests\" value=\"Nightlife\"> Nightlife</label>\n    </div>\n    \n    <button type=\"button\" class=\"next-step\">Next</button>\n    <button type=\"button\" class=\"prev-step\">Back</button>\n    </div>\n    \n    <div class=\"form-step\" style=\"display: none;\">\n    <label for=\"budget\">Budget Level*</label>\n    <select id=\"budget\" name=\"budget\">\n    <option value=\"Budget\">Budget</option>\n    <option value=\"Mid-range\">Mid-range</option>\n    <option value=\"Luxury\">Luxury</option>\n    </select>\n    \n    <label for=\"pace\">Preferred Pace</label>\n    <select id=\"pace\" name=\"pace\">\n    <option value=\"Relaxed\">Relaxed</option>\n    <option value=\"Balanced\">Balanced</option>\n    <option value=\"Fast-Paced\">Fast-Paced</option>\n    </select>\n    \n    <label for=\"dietary\">Dietary Preferences</label>\n    <select id=\"dietary\" name=\"dietary\">\n    <option value=\"No Restrictions\">No Restrictions</option>\n    <option value=\"Vegetarian\">Vegetarian</option>\n    <option value=\"Vegan\">Vegan</option>\n    <option value=\"Allergies\">Allergies</option>\n    </select>\n    \n    <label for=\"specialRequests\">Special Requests</label>\n    <textarea id=\"specialRequests\" name=\"specialRequests\" placeholder=\"Any must-see places or requirements\" rows=\"5\"></textarea>\n    \n    <button type=\"button\" class=\"next-step\">Next</button>\n    <button type=\"button\" class=\"prev-step\">Back</button>\n    </div>\n    \n    <div class=\"form-step\" style=\"display: none;\">\n    \n    <label for=\"name\">Your name</label>\n    <input type=\"text\" id=\"name\" name=\"name\">\n    \n    <label for=\"email\">Your Email</label>\n    <input type=\"email\" id=\"email\" name=\"email\">\n    \n    <button type=\"submit\">Generate Itinerary</button>\n    <button type=\"button\" class=\"prev-step\">Back</button>\n    </div>\n    </div>",
          "onSubmit": "2"
        },
        "bhvOnRender": "// JavaScript runs whenever data is rendered\n// NB: this is JavaScript and NOT ProcScript\n// target = jquery DOM wrapper of the current screen\n// my_variables = {foo:\"bar\",etc} - cannot be changed here\nlet step = 0;\n$(\".next-step\").click(function() {\n\t$(\".form-step\").eq(step).hide();\n\tstep++;\n\t$(\".form-step\").eq(step).show();\n});\n\n$(\".prev-step\").click(function() {\n\t$(\".form-step\").eq(step).hide();\n\tstep--;\n\t$(\".form-step\").eq(step).show();\n});",
        "bhvBeforeSubmitValidation": "$missingFields = [];\n\nif (empty(form_values[\"email\"])) { $missingFields[] = \"email\"; } \nif (empty(form_values[\"name\"])) { $missingFields[] = \"name\"; } \nif (empty(form_values[\"destination\"])) { $missingFields[] = \"destination\"; }\nif (empty(form_values[\"startDate\"]) || empty($form_values[\"endDate\"])) { $missingFields[] = \"trip dates\"; }\nif (empty(form_values[\"travelers\"])) { $missingFields[] = \"number of travelers\"; }\nif (empty(form_values[\"budget\"])) { $missingFields[] = \"budget preference\"; }\n\n\nif (!empty($missingFields)) {\n    return \"You must fill in the following fields: \" + implode(\", \", $missingFields) + \" to proceed.\";\n}\n\n//Generate user if does not exist\nquery1 = \"SELECT id FROM `users` WHERE email = ?\";\nuser = mysql_query(query1, [form_values[\"email\"]], \"ai_itinerary_generator\")\n\n// If user does not exist, create them\nif (!user) {\n    query2 = \"INSERT INTO `users` (name, email, password, created_at) VALUES (?, ?, ?, NOW())\";\t\n    hashed_password = md5(\"default123\", false);\n    mysql_query(query2, [form_values[\"name\"],form_values[\"email\"], hashed_password], \"ai_itinerary_generator\");\n\n    // Get the newly created user ID\n    user = mysql_query(query1, [form_values[\"email\"]], \"ai_itinerary_generator\")\n}\n\n//Make DB entry\nquery3 = \"INSERT INTO `itinerary_requests` (user_id, destination, `start_date`, `end_date`, travelers, interests, budget, pace, dietary, `special_requests`, `created_at`) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NOW())\"\nparams = [\n    user[\"id\"], \n    form_values[\"destination\"], \n    form_values[\"startDate\"], \n    form_values[\"endDate\"], \n    form_values[\"travelers\"], \n    form_values[\"interests\"], \n    form_values[\"budget\"], \n    form_values[\"pace\"], \n    form_values[\"dietary\"], \n    form_values[\"specialRequests\"]\n]\n\nmysql_command(query3, params, \"ai_itinerary_generator\")\n\nquery4 = \"SELECT * FROM `itinerary_requests` WHERE user_id = ? ORDER BY created_at DESC LIMIT 1\";\nrequest = mysql_query(query4, [user[\"id\"]], \"ai_itinerary_generator\")\n\ncustom_tokens.user_id = user[\"id\"];\ncustom_tokens.request_id = request[\"id\"];\ncustom_tokens.request.destination = request[\"destination\"];\ncustom_tokens.request.startDate = request[\"start_date\"];\ncustom_tokens.request.endDate = request[\"end_date\"];\ncustom_tokens.request.travelers = request[\"travelers\"];\ncustom_tokens.request.interests = request[\"interests\"];\ncustom_tokens.request.budget = request[\"budget\"];\ncustom_tokens.request.pace = request[\"pace\"];\ncustom_tokens.request.dietary = request[\"dietary\"];\ncustom_tokens.request.specialRequests = request[\"specialRequests\"];\n\n\n",
        "bhvAfterSubmit": "// ProcScript runs after saving an item\n// form_action = create/update/delete\n// item_id\n// form_values = {title:\"foo\", etc}\n// my_variables = {foo:\"bar\",etc} - these are yours to change\n// custom_tokens = {} (eg custom_tokens.foo = \"bar\" - then use @[pf_custom:foo]\n\n",
        "bhvBeforeProcess": "// ProcScript runs before screen initializes\n// translations = {\"Title\":\"Heading\", etc}\n// location = \"https://procdu.com/mcapp/id?params\" - change to redirect\n// url_parameters = {}\n// my_variables = {foo:\"bar\",etc} - these are yours to change\n// custom_tokens = {} (eg custom_tokens.foo = \"bar\" - then use @[pf_custom:foo]\n// is_logged_in = true/false\n// auth_item {item_id:1234, fields:[...], etc} - raw podio item or null\n// auth_item_values {title:\"foo\", number:2, etc} or null\ncustom_tokens = null;"
      },
      {
        "public": "1",
        "name": "payment_screen",
        "screenType": "text",
        "scrMkdHead": "<style>\n    body { font-family: Arial, sans-serif;max-width: 600px;margin: 50px auto;text-align: center; }\n    .summary-box { background: #f8f9fa;text-align: left;padding: 20px;border-radius: 10px;box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);margin-bottom: 20px;min-height: 50px; }\n    .loading-spinner { border: 4px solid #f3f3f3;border-top: 4px solid #007bff;border-radius: 50%;width: 30px;height: 30px;animation: spin 1s linear infinite;margin: 0 auto;display: block; }\n    @keyframes spin { 0% { transform: rotate(0deg); } 100% { transform: rotate(360deg); } }\n    .btn { display: inline-block;margin-top: 15px;padding: 10px 20px;background: #007bff;color: white;border: none;cursor: pointer;border-radius: 5px;font-size: 16px;text-decoration: none; }\n    .btn:hover {background: #0056b3; }\n    .reminder {font-size: 14px;color: #555;margin-top: 10px; }\n</style>",
        "scrMkdFoot": "",
        "intnotes": "",
        "config": {
          "mkdText": "<h2>Your Trip Summary</h2>\n<div class=\"summary-box\">\n    <div id=\"loading-spinner\" class=\"loading-spinner\"></div>\n    <p id=\"trip-summary\" style=\"display: none;\"></p>\n</div>\n\n<p class=\"reminder\">⚠️ Please use the **same email in Stripe**. Your full itinerary will be sent to that email within 5 minutes.</p>\n\n<button id=\"buy-now\" class=\"btn\">Buy Full Personalised Itenary - $3</button>"
        },
        "bhvBeforeProcess": "// ProcScript runs before screen initializes\n// translations = {\"Title\":\"Heading\", etc}\n// location = \"https://procdu.com/mcapp/id?params\" - change to redirect\n// url_parameters = {}\n// my_variables = {foo:\"bar\",etc} - these are yours to change\n// custom_tokens = {} (eg custom_tokens.foo = \"bar\" - then use @[pf_custom:foo]\n// is_logged_in = true/false\n// auth_item {item_id:1234, fields:[...], etc} - raw podio item or null\n// auth_item_values {title:\"foo\", number:2, etc} or null\n",
        "bhvOnRender": "function successFunc(data) {\n  if (data) {\n    $(\"#loading-spinner\").hide(); // Hide loading spinner\n    $(\"#trip-summary\").html(data).show(); // Show summary\n  }\n}\n\nfunction errFunc() {\n  console.log(\"Error\");\n}\n\nPfJs.ajaxCall(\"ajax\", {}, successFunc, errFunc);\n\n$(\"#buy-now\").click(function () {\n  let stripeLink = \"STRIPE_LINK\";\n  window.location.href = stripeLink;\n});\n"
      },
      {
        "public": "1",
        "name": "ajax",
        "screenType": "text",
        "scrMkdHead": "",
        "scrMkdFoot": "",
        "intnotes": "",
        "config": { "mkdText": "" },
        "bhvBeforeProcess": "$key = \"STRIPE_API_KEY\";\n\n// OpenAI API URL\n$url = \"https://api.openai.com/v1/chat/completions\";\n// API Headers (Replace YOUR_API_KEY with your actual OpenAI key)\n$headers = \"Content-Type: application/json , Authorization: Bearer \"+$key;\n// OpenAI Request Body\n$request_body = [\n    \"model\" => \"gpt-4o-mini-2024-07-18\",\n    \"messages\" => [\n        [\"role\" => \"system\", \"content\" => \"You are a travel planner. Generate a short summary for a trip itinerary.\"],\n        [\"role\" => \"user\", \"content\" => json_encode(custom_tokens.request)]\n    ],\n    \"temperature\" => 0.7\n];\n\n// Send API request\n$output =  remote_curl($url, \"POST\", $headers, $request_body, 0);\n$decoded_output = json_decode($output,true);\n$summary = $decoded_output[\"choices\"][0][\"message\"][\"content\"];\n\nquery = \"INSERT INTO `itineraries` (user_id, request_id, `partial_itinerary`,`generated_at`) VALUES (?, ?, ?, NOW())\"\nparams = [\n    custom_tokens[\"user_id\"], \n\tcustom_tokens[\"request_id\"], \n\t$summary \n]\n\nmysql_command(query, params, \"ai_itinerary_generator\")\n\t\nprint markdown_to_html($summary)"
      },
      {
        "public": "1",
        "name": "success",
        "screenType": "text",
        "scrMkdHead": "<style>\nbody { font-family: Arial, sans-serif; text-align: center; background: #f8f9fa; padding: 50px; }\nh2 { color: #28a745; }\np { color: #555; font-size: 16px; }\n.container { background: white; padding: 30px; border-radius: 10px; box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1); max-width: 500px; margin: auto; }\n.success-icon { font-size: 50px; color: #28a745; margin-bottom: 10px; }\n.btn { width: 100%; background: #007bff; color: white; padding: 10px; border: none; border-radius: 5px; cursor: pointer; }\n.btn:hover { background: #0056b3; }\n</style>",
        "scrMkdFoot": "",
        "intnotes": "",
        "config": {
          "mkdText": "<div class=\"container\">\n    <div class=\"success-icon\">✅</div>\n    <h2>Payment Successful!</h2>\n    <p>Your full itinerary will be sent to your email within 5 minutes. </p>\n    <p>Please check your inbox (and spam folder just in case).</p>\n</div>"
        }
      },
      {
        "public": null,
        "name": "code",
        "screenType": "text",
        "scrMkdHead": "",
        "scrMkdFoot": "",
        "intnotes": "",
        "config": { "mkdText": "" },
        "bhvBeforeProcess": "// ProcScript runs before screen initializes\n// translations = {\"Title\":\"Heading\", etc}\n// location = \"https://procdu.com/mcapp/id?params\" - change to redirect\n// url_parameters = {}\n// my_variables = {foo:\"bar\",etc} - these are yours to change\n// custom_tokens = {} (eg custom_tokens.foo = \"bar\" - then use @[pf_custom:foo]\n// is_logged_in = true/false\n// auth_item {item_id:1234, fields:[...], etc} - raw podio item or null\n// auth_item_values {title:\"foo\", number:2, etc} or null\n\n// name this code block\ndecoded_payload = json_decode(payload,false)\n$event = json_decode(decoded_payload[\"STDIN\"],false)\n$type = \"SQL\";\n\nif ($event[\"type\"] === \"checkout.session.completed\" && $type = \"SQL\") {\n    $session = $event[\"data\"][\"object\"];\t\n\t\t\n\t$amount = $session[\"amount_total\"] / 100;\n\t$currency = strtoupper($session[\"currency\"]);\n\t$status = ($session[\"payment_status\"] === \"paid\") ? \"completed\" : \"failed\";\n    $transaction_id = $session[\"payment_intent\"];\n\t$email = $session[\"customer_details\"][\"email\"];\t\n\t\n\t//FIND USER\n\tquery1 = \"SELECT * FROM `users` WHERE email = ?\";\n\tuser = mysql_query(query1, [$email], \"ai_itinerary_generator\");\n\t\n\t//FIND ITENARY REQUEST\n\tquery2 = \"SELECT * FROM `itinerary_requests` WHERE user_id = (SELECT id FROM users WHERE email = ?) ORDER BY created_at DESC LIMIT 1\";\n\titinerary_request = mysql_query(query2, [$email], \"ai_itinerary_generator\");\n   \n    //FIND PAYMENT. IF NO, CREATE PAYMENT\n\t$query5 = \"SELECT * FROM `payments` WHERE transaction_id = ? LIMIT 1\";\n\t$payment = mysql_query(query5, [$transaction_id], \"ai_itinerary_generator\");\n\tif(!$payment) {\n\t\t$sql = \"INSERT INTO payments (user_id, amount, currency, status, transaction_id, itinerary_request_id, created_at) VALUES (?, ?, ?, ?, ?, ?, NOW())\";    \n\t\t$params = [user[\"id\"], $amount, $currency, $status, $transaction_id, itinerary_request[\"id\"]];\n\t\tmysql_command($sql, $params,\"ai_itinerary_generator\");\n\t}\n\t\n\t//FIND PAYMENT. IF NO, CREATE PAYMENT\n\tcustom_tokens.request.destination = itinerary_request[\"destination\"];\n\tcustom_tokens.request.startDate = itinerary_request[\"start_date\"];\n\tcustom_tokens.request.endDate = itinerary_request[\"end_date\"];\n\tcustom_tokens.request.travelers = itinerary_request[\"travelers\"];\n\tcustom_tokens.request.interests = itinerary_request[\"interests\"];\n\tcustom_tokens.request.budget = itinerary_request[\"budget\"];\n\tcustom_tokens.request.pace = itinerary_request[\"pace\"];\n\tcustom_tokens.request.dietary = itinerary_request[\"dietary\"];\n\tcustom_tokens.request.specialRequests = itinerary_request[\"specialRequests\"];\n\t\t\n\t$key = \"STRIPE_API_KEY\";\n\t$url = \"https://api.openai.com/v1/chat/completions\";\n\t$headers = \"Content-Type: application/json , Authorization: Bearer \"+$key;\n\t$request_body = [\n\t\t\"model\" => \"gpt-4o-mini-2024-07-18\",\n\t\t\"messages\" => [\n\t\t\t[\"role\" => \"system\", \"content\" => \"You are a travel planner. Generate a detailed itinerary for the following trip.\"],\n\t\t\t[\"role\" => \"user\", \"content\" => json_encode(custom_tokens.request)]\n\t\t],\n\t\t\"temperature\" => 0.7\n\t];\n\t$output =  remote_curl($url, \"POST\", $headers, $request_body, 0);\n\t$decoded_output = json_decode($output,true)\n\t$itenary = $decoded_output[\"choices\"][0][\"message\"][\"content\"];\n\t\n\t$query3 = \"SELECT * FROM `itineraries` WHERE request_id = ? ORDER BY generated_at DESC LIMIT 1\";\n\t$itinerary_entry = mysql_query(query3, [itinerary_request[\"id\"]], \"ai_itinerary_generator\");\n\t\n\tif ($itinerary_entry) {\n\t\t$update_query = \"UPDATE `itineraries` SET `full_itinerary` = ?, `generated_at` = NOW() WHERE id = ?\";\n\t\tmysql_command($update_query, [$itenary, $itinerary_entry[\"id\"]], \"ai_itinerary_generator\");\n\t} else {\n\t\t$insert_query = \"INSERT INTO `itineraries` (user_id, request_id, `full_itinerary`, `generated_at`) VALUES (?, ?, ?, NOW())\";\n\t\tmysql_command($insert_query, [user[\"id\"], itinerary_request[\"id\"], $full_itinerary], \"ai_itinerary_generator\");\n\t}\n\t\n\t$subject = \"Your Full Itinerary for \" + custom_tokens.request.destination + \" is Ready!\";\n\t$body = \"\"\"\n\t\t<html>\n\t\t<head>\n\t\t\t<style>\n\t\t\t\tbody { font-family: Arial, sans-serif; line-height: 1.6; color: #333; }\n\t\t\t\t.container { max-width: 600px; margin: 0 auto; padding: 20px; border: 1px solid #ddd; border-radius: 8px; }\n\t\t\t\th2 { color: #007bff; }\n\t\t\t\t.footer { font-size: 12px; color: #777; margin-top: 20px; }\n\t\t\t</style>\n\t\t</head>\n\t\t<body>\n\t\t\t<div class='container'>\n\t\t\t\t<h2>Your Itinerary for '\"\"\" + custom_tokens.request.destination + \"\"\"' is Ready!</h2>\n\t\t\t\t<p>Dear \"\"\" + user[\"name\"] + \"\"\",</p>\n\t\t\t\t<p>Thank you for your payment! Your full itinerary is now available.</p>\n\t\t\t\t<h3>Trip Details:</h3>\n\t\t\t\t<p><strong>Destination:</strong> '\"\"\" + custom_tokens.request.destination + \"\"\"'</p>\n\t\t\t\t<p><strong>Dates:</strong> '\"\"\" + custom_tokens.request.startDate + \"\"\"' to '\"\"\" + custom_tokens.request.endDate + \"\"\"'</p>\n\t\t\t\t<p><strong>Travelers:</strong> '\"\"\" + custom_tokens.request.travelers + \"\"\"'</p>\n\t\t\t\t<p><strong>Budget:</strong> '\"\"\" + custom_tokens.request.budget + \"\"\"'</p>\n\t\t\t\t<p><strong>Interests:</strong> '\"\"\" + custom_tokens.request.interests + \"\"\"'</p>\n\t\t\t\t<h3>Your Itinerary:</h3>\n\t\t\t\t<p>'\"\"\" + markdown_to_html($itenary) + \"\"\"'</p>\n\t\t\t\t<p>We hope you have an amazing trip! If you have any questions, feel free to reach out.</p>\n\t\t\t\t<p>Safe travels,</p>\n\t\t\t\t<p><strong>The Travel Planner Team</strong></p>\n\t\t\t\t<div class='footer'>\n\t\t\t\t\t<p>This email was sent automatically. If you did not request this itinerary, please ignore this message.</p>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t</body>\n\t\t</html>\n\t\"\"\";\n\t\n\temail_send_conn(\"globi\", $email, $subject, $body, \"\", \"thaha@globi.ca\", \"\", []);\n\t\n}\n"
      }
    ],
    "publicScreens": [0, 1, 2, 3, 4],
    "publicStart": "0"
  },
  "version": 3,
  "meta": {
    "lastping": {
      "user": "thaha@theworkingweb.com",
      "tabid": "px5kj1sycs2qrm8q50v84",
      "time": 1743094612
    }
  },
  "publicStart": "0"
}
