1210249f54
Update all SQL queries, query result references, and ColdFusion code to match
the renamed database schema. Tables use plural CamelCase, PKs are all `ID`,
column prefixes stripped (e.g. BusinessName→Name, UserFirstName→FirstName).
Key changes:
- Strip table-name prefixes from all column references (Businesses, Users,
Addresses, Hours, Menus, Categories, Items, Stations, Orders,
OrderLineItems, Tasks, TaskCategories, TaskRatings, QuickTaskTemplates,
ScheduledTaskDefinitions, ChatMessages, Beacons, ServicePoints, Employees,
VisitorTrackings, ApiPerfLogs, tt_States, tt_Days, tt_AddressTypes,
tt_OrderTypes, tt_TaskTypes)
- Rename PK references from {TableName}ID to ID in all queries
- Rewrite 7 admin beacon files to use ServicePoints.BeaconID instead of
dropped lt_Beacon_Businesses_ServicePoints link table
- Rewrite beacon assignment files (list, save, delete) for new schema
- Fix FK references incorrectly changed to ID (OrderLineItems.OrderID,
Categories.MenuID, Tasks.CategoryID, ServicePoints.BeaconID)
- Update Addresses: AddressLat→Latitude, AddressLng→Longitude
- Update Users: UserPassword→Password, UserIsEmailVerified→IsEmailVerified,
UserIsActive→IsActive, UserBalance→Balance, etc.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
394 lines
17 KiB
Text
394 lines
17 KiB
Text
<cfscript>
|
|
// Save menu data from the builder UI (OPTIMIZED)
|
|
// Input: BusinessID, Menu (JSON structure)
|
|
// Output: { OK: true }
|
|
|
|
response = { "OK": false };
|
|
|
|
// Track which templates we've already saved options for (to avoid duplicate saves)
|
|
savedTemplates = {};
|
|
|
|
// Recursive function to save options/modifiers at any depth
|
|
function saveOptionsRecursive(options, parentID, businessID) {
|
|
if (!isArray(options) || arrayLen(options) == 0) return;
|
|
|
|
var optSortOrder = 0;
|
|
for (var opt in options) {
|
|
var optDbId = structKeyExists(opt, "dbId") ? val(opt.dbId) : 0;
|
|
var requiresSelection = (structKeyExists(opt, "requiresSelection") && opt.requiresSelection) ? 1 : 0;
|
|
var maxSelections = structKeyExists(opt, "maxSelections") ? val(opt.maxSelections) : 0;
|
|
var isDefault = (structKeyExists(opt, "isDefault") && opt.isDefault) ? 1 : 0;
|
|
var optionID = 0;
|
|
|
|
if (optDbId > 0) {
|
|
optionID = optDbId;
|
|
queryExecute("
|
|
UPDATE Items
|
|
SET Name = :name,
|
|
Price = :price,
|
|
IsCheckedByDefault = :isDefault,
|
|
SortOrder = :sortOrder,
|
|
RequiresChildSelection = :requiresSelection,
|
|
MaxNumSelectionReq = :maxSelections,
|
|
ParentItemID = :parentID
|
|
WHERE ItemID = :optID
|
|
", {
|
|
optID: optDbId,
|
|
parentID: parentID,
|
|
name: opt.name,
|
|
price: val(opt.price ?: 0),
|
|
isDefault: isDefault,
|
|
sortOrder: optSortOrder,
|
|
requiresSelection: requiresSelection,
|
|
maxSelections: maxSelections
|
|
});
|
|
} else {
|
|
queryExecute("
|
|
INSERT INTO Items (
|
|
BusinessID, ParentItemID, Name, Price,
|
|
IsCheckedByDefault, SortOrder, IsActive, AddedOn,
|
|
RequiresChildSelection, MaxNumSelectionReq, CategoryID
|
|
) VALUES (
|
|
:businessID, :parentID, :name, :price,
|
|
:isDefault, :sortOrder, 1, NOW(),
|
|
:requiresSelection, :maxSelections, 0
|
|
)
|
|
", {
|
|
businessID: businessID,
|
|
parentID: parentID,
|
|
name: opt.name,
|
|
price: val(opt.price ?: 0),
|
|
isDefault: isDefault,
|
|
sortOrder: optSortOrder,
|
|
requiresSelection: requiresSelection,
|
|
maxSelections: maxSelections
|
|
});
|
|
|
|
var result = queryExecute("SELECT LAST_INSERT_ID() as newID");
|
|
optionID = result.newID;
|
|
}
|
|
|
|
if (structKeyExists(opt, "options") && isArray(opt.options) && arrayLen(opt.options) > 0) {
|
|
saveOptionsRecursive(opt.options, optionID, businessID);
|
|
}
|
|
|
|
optSortOrder++;
|
|
}
|
|
}
|
|
|
|
try {
|
|
requestBody = toString(getHttpRequestData().content);
|
|
|
|
if (!len(requestBody)) {
|
|
throw("Request body is required");
|
|
}
|
|
|
|
jsonData = deserializeJSON(requestBody);
|
|
businessID = val(jsonData.BusinessID ?: 0);
|
|
menu = jsonData.Menu ?: {};
|
|
|
|
if (businessID == 0) {
|
|
throw("BusinessID is required");
|
|
}
|
|
|
|
if (!structKeyExists(menu, "categories") || !isArray(menu.categories)) {
|
|
throw("Menu categories are required");
|
|
}
|
|
|
|
// Check if new schema is active
|
|
newSchemaActive = false;
|
|
try {
|
|
qCheck = queryExecute("
|
|
SELECT 1 FROM Items
|
|
WHERE BusinessID = :businessID AND BusinessID > 0
|
|
LIMIT 1
|
|
", { businessID: businessID });
|
|
newSchemaActive = (qCheck.recordCount > 0);
|
|
} catch (any e) {
|
|
newSchemaActive = false;
|
|
}
|
|
|
|
// Wrap everything in a transaction for speed and consistency
|
|
transaction {
|
|
catSortOrder = 0;
|
|
for (cat in menu.categories) {
|
|
categoryID = 0;
|
|
categoryDbId = structKeyExists(cat, "dbId") ? val(cat.dbId) : 0;
|
|
|
|
if (newSchemaActive) {
|
|
if (categoryDbId > 0) {
|
|
categoryID = categoryDbId;
|
|
queryExecute("
|
|
UPDATE Items
|
|
SET Name = :name,
|
|
SortOrder = :sortOrder
|
|
WHERE ItemID = :categoryID
|
|
AND BusinessID = :businessID
|
|
", {
|
|
categoryID: categoryID,
|
|
businessID: businessID,
|
|
name: cat.name,
|
|
sortOrder: catSortOrder
|
|
});
|
|
} else {
|
|
queryExecute("
|
|
INSERT INTO Items (
|
|
BusinessID, Name, Description,
|
|
ParentItemID, Price, IsActive,
|
|
SortOrder, AddedOn, CategoryID
|
|
) VALUES (
|
|
:businessID, :name, '',
|
|
0, 0, 1,
|
|
:sortOrder, NOW(), 0
|
|
)
|
|
", {
|
|
businessID: businessID,
|
|
name: cat.name,
|
|
sortOrder: catSortOrder
|
|
});
|
|
|
|
result = queryExecute("SELECT LAST_INSERT_ID() as newID");
|
|
categoryID = result.newID;
|
|
}
|
|
} else {
|
|
// Get menu ID from category if provided
|
|
categoryMenuId = structKeyExists(cat, "menuId") ? val(cat.menuId) : 0;
|
|
categoryMenuIdParam = categoryMenuId > 0 ? categoryMenuId : javaCast("null", "");
|
|
|
|
if (categoryDbId > 0) {
|
|
categoryID = categoryDbId;
|
|
queryExecute("
|
|
UPDATE Categories
|
|
SET Name = :name,
|
|
SortOrder = :sortOrder,
|
|
MenuID = :menuId
|
|
WHERE CategoryID = :categoryID
|
|
", {
|
|
categoryID: categoryID,
|
|
name: cat.name,
|
|
sortOrder: catSortOrder,
|
|
menuId: categoryMenuIdParam
|
|
});
|
|
} else {
|
|
queryExecute("
|
|
INSERT INTO Categories (BusinessID, MenuID, Name, SortOrder, AddedOn)
|
|
VALUES (:businessID, :menuId, :name, :sortOrder, NOW())
|
|
", {
|
|
businessID: businessID,
|
|
menuId: categoryMenuIdParam,
|
|
name: cat.name,
|
|
sortOrder: catSortOrder
|
|
});
|
|
|
|
result = queryExecute("SELECT LAST_INSERT_ID() as newID");
|
|
categoryID = result.newID;
|
|
}
|
|
}
|
|
|
|
// Process items
|
|
if (structKeyExists(cat, "items") && isArray(cat.items)) {
|
|
itemSortOrder = 0;
|
|
for (item in cat.items) {
|
|
itemID = 0;
|
|
itemDbId = structKeyExists(item, "dbId") ? val(item.dbId) : 0;
|
|
|
|
if (itemDbId > 0) {
|
|
itemID = itemDbId;
|
|
|
|
if (newSchemaActive) {
|
|
queryExecute("
|
|
UPDATE Items
|
|
SET Name = :name,
|
|
Description = :description,
|
|
Price = :price,
|
|
ParentItemID = :categoryID,
|
|
SortOrder = :sortOrder
|
|
WHERE ItemID = :itemID
|
|
", {
|
|
itemID: itemID,
|
|
name: item.name,
|
|
description: item.description ?: "",
|
|
price: val(item.price ?: 0),
|
|
categoryID: categoryID,
|
|
sortOrder: itemSortOrder
|
|
});
|
|
} else {
|
|
queryExecute("
|
|
UPDATE Items
|
|
SET Name = :name,
|
|
Description = :description,
|
|
Price = :price,
|
|
CategoryID = :categoryID,
|
|
SortOrder = :sortOrder
|
|
WHERE ItemID = :itemID
|
|
", {
|
|
itemID: itemID,
|
|
name: item.name,
|
|
description: item.description ?: "",
|
|
price: val(item.price ?: 0),
|
|
categoryID: categoryID,
|
|
sortOrder: itemSortOrder
|
|
});
|
|
}
|
|
} else {
|
|
if (newSchemaActive) {
|
|
queryExecute("
|
|
INSERT INTO Items (
|
|
BusinessID, ParentItemID, Name, Description,
|
|
Price, SortOrder, IsActive, AddedOn, CategoryID
|
|
) VALUES (
|
|
:businessID, :categoryID, :name, :description,
|
|
:price, :sortOrder, 1, NOW(), 0
|
|
)
|
|
", {
|
|
businessID: businessID,
|
|
categoryID: categoryID,
|
|
name: item.name,
|
|
description: item.description ?: "",
|
|
price: val(item.price ?: 0),
|
|
sortOrder: itemSortOrder
|
|
});
|
|
} else {
|
|
queryExecute("
|
|
INSERT INTO Items (
|
|
BusinessID, CategoryID, Name, Description,
|
|
Price, SortOrder, IsActive, ParentItemID, AddedOn
|
|
) VALUES (
|
|
:businessID, :categoryID, :name, :description,
|
|
:price, :sortOrder, 1, 0, NOW()
|
|
)
|
|
", {
|
|
businessID: businessID,
|
|
categoryID: categoryID,
|
|
name: item.name,
|
|
description: item.description ?: "",
|
|
price: val(item.price ?: 0),
|
|
sortOrder: itemSortOrder
|
|
});
|
|
}
|
|
|
|
result = queryExecute("SELECT LAST_INSERT_ID() as newID");
|
|
itemID = result.newID;
|
|
}
|
|
|
|
// Handle modifiers
|
|
if (structKeyExists(item, "modifiers") && isArray(item.modifiers) && arrayLen(item.modifiers) > 0) {
|
|
// Clear existing template links for this item
|
|
queryExecute("DELETE FROM lt_ItemID_TemplateItemID WHERE ItemID = :itemID", { itemID: itemID });
|
|
|
|
modSortOrder = 0;
|
|
for (mod in item.modifiers) {
|
|
modDbId = structKeyExists(mod, "dbId") ? val(mod.dbId) : 0;
|
|
requiresSelection = (structKeyExists(mod, "requiresSelection") && mod.requiresSelection) ? 1 : 0;
|
|
maxSelections = structKeyExists(mod, "maxSelections") ? val(mod.maxSelections) : 0;
|
|
|
|
if (structKeyExists(mod, "isTemplate") && mod.isTemplate && modDbId > 0) {
|
|
// This is a template reference - create link
|
|
queryExecute("
|
|
INSERT INTO lt_ItemID_TemplateItemID (ItemID, TemplateItemID, SortOrder)
|
|
VALUES (:itemID, :templateID, :sortOrder)
|
|
ON DUPLICATE KEY UPDATE SortOrder = :sortOrder
|
|
", {
|
|
itemID: itemID,
|
|
templateID: modDbId,
|
|
sortOrder: modSortOrder
|
|
});
|
|
|
|
// Update template's selection rules
|
|
queryExecute("
|
|
UPDATE Items
|
|
SET RequiresChildSelection = :requiresSelection,
|
|
MaxNumSelectionReq = :maxSelections
|
|
WHERE ItemID = :modID
|
|
", {
|
|
modID: modDbId,
|
|
requiresSelection: requiresSelection,
|
|
maxSelections: maxSelections
|
|
});
|
|
|
|
// Only save template options ONCE (first time we encounter this template)
|
|
if (!structKeyExists(savedTemplates, modDbId)) {
|
|
savedTemplates[modDbId] = true;
|
|
if (structKeyExists(mod, "options") && isArray(mod.options)) {
|
|
saveOptionsRecursive(mod.options, modDbId, businessID);
|
|
}
|
|
}
|
|
} else if (modDbId > 0) {
|
|
// Direct modifier (not a template) - update it
|
|
queryExecute("
|
|
UPDATE Items
|
|
SET Name = :name,
|
|
Price = :price,
|
|
IsCheckedByDefault = :isDefault,
|
|
SortOrder = :sortOrder,
|
|
RequiresChildSelection = :requiresSelection,
|
|
MaxNumSelectionReq = :maxSelections,
|
|
ParentItemID = :parentID
|
|
WHERE ItemID = :modID
|
|
", {
|
|
modID: modDbId,
|
|
parentID: itemID,
|
|
name: mod.name,
|
|
price: val(mod.price ?: 0),
|
|
isDefault: (mod.isDefault ?: false) ? 1 : 0,
|
|
sortOrder: modSortOrder,
|
|
requiresSelection: requiresSelection,
|
|
maxSelections: maxSelections
|
|
});
|
|
|
|
if (structKeyExists(mod, "options") && isArray(mod.options)) {
|
|
saveOptionsRecursive(mod.options, modDbId, businessID);
|
|
}
|
|
} else {
|
|
// New direct modifier - insert it
|
|
queryExecute("
|
|
INSERT INTO Items (
|
|
BusinessID, ParentItemID, Name, Price,
|
|
IsCheckedByDefault, SortOrder, IsActive, AddedOn,
|
|
RequiresChildSelection, MaxNumSelectionReq, CategoryID
|
|
) VALUES (
|
|
:businessID, :parentID, :name, :price,
|
|
:isDefault, :sortOrder, 1, NOW(),
|
|
:requiresSelection, :maxSelections, 0
|
|
)
|
|
", {
|
|
businessID: businessID,
|
|
parentID: itemID,
|
|
name: mod.name,
|
|
price: val(mod.price ?: 0),
|
|
isDefault: (mod.isDefault ?: false) ? 1 : 0,
|
|
sortOrder: modSortOrder,
|
|
requiresSelection: requiresSelection,
|
|
maxSelections: maxSelections
|
|
});
|
|
|
|
modResult = queryExecute("SELECT LAST_INSERT_ID() as newModID");
|
|
newModID = modResult.newModID;
|
|
if (structKeyExists(mod, "options") && isArray(mod.options)) {
|
|
saveOptionsRecursive(mod.options, newModID, businessID);
|
|
}
|
|
}
|
|
modSortOrder++;
|
|
}
|
|
}
|
|
itemSortOrder++;
|
|
}
|
|
}
|
|
catSortOrder++;
|
|
}
|
|
}
|
|
|
|
response = { "OK": true, "SCHEMA": newSchemaActive ? "unified" : "legacy" };
|
|
|
|
} catch (any e) {
|
|
response = {
|
|
"OK": false,
|
|
"ERROR": e.message,
|
|
"DETAIL": e.detail ?: "",
|
|
"TYPE": e.type ?: ""
|
|
};
|
|
}
|
|
|
|
cfheader(name="Content-Type", value="application/json");
|
|
writeOutput(serializeJSON(response));
|
|
</cfscript>
|