mirror of
https://github.com/pacnpal/thrilltrack-explorer.git
synced 2025-12-20 18:51:11 -05:00
Reverted to commit cd76e30ed9
This commit is contained in:
gpt-engineer-app[bot]
@@ -97,7 +97,7 @@ export async function detectDependencyConflicts(
|
||||
});
|
||||
}
|
||||
|
||||
// Suggest linking to existing entity based on type
|
||||
// Suggest linking to existing entity
|
||||
if (parent.item_type === 'park') {
|
||||
const { data: parks } = await supabase
|
||||
.from('parks')
|
||||
@@ -112,35 +112,6 @@ export async function detectDependencyConflicts(
|
||||
entityId: park.id,
|
||||
});
|
||||
});
|
||||
} else if (['manufacturer', 'operator', 'property_owner', 'designer'].includes(parent.item_type)) {
|
||||
const { data: companies } = await supabase
|
||||
.from('companies')
|
||||
.select('id, name')
|
||||
.eq('company_type', parent.item_type)
|
||||
.ilike('name', `%${parent.item_data.name}%`)
|
||||
.limit(3);
|
||||
|
||||
companies?.forEach(company => {
|
||||
suggestions.push({
|
||||
action: 'link_existing',
|
||||
label: `Link to existing ${parent.item_type}: ${company.name}`,
|
||||
entityId: company.id,
|
||||
});
|
||||
});
|
||||
} else if (parent.item_type === 'ride_model') {
|
||||
const { data: models } = await supabase
|
||||
.from('ride_models')
|
||||
.select('id, name')
|
||||
.ilike('name', `%${parent.item_data.name}%`)
|
||||
.limit(3);
|
||||
|
||||
models?.forEach(model => {
|
||||
suggestions.push({
|
||||
action: 'link_existing',
|
||||
label: `Link to existing ride model: ${model.name}`,
|
||||
entityId: model.id,
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
suggestions.push({
|
||||
@@ -150,7 +121,7 @@ export async function detectDependencyConflicts(
|
||||
|
||||
conflicts.push({
|
||||
itemId: item.id,
|
||||
type: parent.status === 'rejected' ? 'rejected_parent' : 'missing_parent',
|
||||
type: 'missing_parent',
|
||||
message: `Cannot approve ${item.item_type} without its parent ${parent.item_type}`,
|
||||
suggestions,
|
||||
});
|
||||
@@ -158,301 +129,9 @@ export async function detectDependencyConflicts(
|
||||
}
|
||||
}
|
||||
|
||||
// Check for circular dependencies
|
||||
const circularDeps = detectCircularDependencies(items);
|
||||
circularDeps.forEach(itemId => {
|
||||
conflicts.push({
|
||||
itemId,
|
||||
type: 'circular_dependency',
|
||||
message: 'Circular dependency detected in submission items',
|
||||
suggestions: [
|
||||
{
|
||||
action: 'escalate',
|
||||
label: 'Escalate for manual review',
|
||||
},
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
return conflicts;
|
||||
}
|
||||
|
||||
/**
|
||||
* Detect circular dependencies
|
||||
*/
|
||||
function detectCircularDependencies(items: SubmissionItemWithDeps[]): string[] {
|
||||
const circular: string[] = [];
|
||||
const visited = new Set<string>();
|
||||
const recursionStack = new Set<string>();
|
||||
|
||||
function hasCycle(itemId: string): boolean {
|
||||
visited.add(itemId);
|
||||
recursionStack.add(itemId);
|
||||
|
||||
const item = items.find(i => i.id === itemId);
|
||||
if (item?.depends_on) {
|
||||
if (!visited.has(item.depends_on)) {
|
||||
if (hasCycle(item.depends_on)) {
|
||||
return true;
|
||||
}
|
||||
} else if (recursionStack.has(item.depends_on)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
recursionStack.delete(itemId);
|
||||
return false;
|
||||
}
|
||||
|
||||
items.forEach(item => {
|
||||
if (!visited.has(item.id) && hasCycle(item.id)) {
|
||||
circular.push(item.id);
|
||||
}
|
||||
});
|
||||
|
||||
return circular;
|
||||
}
|
||||
|
||||
/**
|
||||
* Link submission item to existing entity
|
||||
*/
|
||||
export async function linkToExistingEntity(
|
||||
itemId: string,
|
||||
entityId: string,
|
||||
entityType: string
|
||||
): Promise<void> {
|
||||
const { data: item, error: fetchError } = await supabase
|
||||
.from('submission_items')
|
||||
.select('*')
|
||||
.eq('id', itemId)
|
||||
.single();
|
||||
|
||||
if (fetchError || !item) throw fetchError || new Error('Item not found');
|
||||
|
||||
// Update item_data to mark it as linked to existing entity
|
||||
const currentItemData = (item.item_data as any) || {};
|
||||
const updatedItemData = {
|
||||
...currentItemData,
|
||||
_linked_entity_id: entityId,
|
||||
_skip_creation: true,
|
||||
};
|
||||
|
||||
const { error: updateError } = await supabase
|
||||
.from('submission_items')
|
||||
.update({
|
||||
item_data: updatedItemData,
|
||||
approved_entity_id: entityId,
|
||||
updated_at: new Date().toISOString(),
|
||||
})
|
||||
.eq('id', itemId);
|
||||
|
||||
if (updateError) throw updateError;
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve conflicts based on user selections
|
||||
*/
|
||||
export async function resolveConflicts(
|
||||
conflicts: DependencyConflict[],
|
||||
resolutions: Record<string, string>,
|
||||
items: SubmissionItemWithDeps[],
|
||||
userId: string
|
||||
): Promise<{ updatedItems: SubmissionItemWithDeps[]; newConflicts: DependencyConflict[] }> {
|
||||
if (!userId) {
|
||||
throw new Error('User authentication required to resolve conflicts');
|
||||
}
|
||||
|
||||
const updatedItems = [...items];
|
||||
const newConflicts: DependencyConflict[] = [];
|
||||
|
||||
for (const conflict of conflicts) {
|
||||
const resolution = resolutions[conflict.itemId];
|
||||
if (!resolution) continue;
|
||||
|
||||
const suggestion = conflict.suggestions.find(s => s.action === resolution);
|
||||
if (!suggestion) continue;
|
||||
|
||||
try {
|
||||
switch (suggestion.action) {
|
||||
case 'create_parent': {
|
||||
// Add parent item to be approved along with child
|
||||
const item = items.find(i => i.id === conflict.itemId);
|
||||
if (item?.depends_on) {
|
||||
const parent = items.find(i => i.id === item.depends_on);
|
||||
if (parent && parent.status === 'pending') {
|
||||
// Mark parent for approval (will be handled in approval flow)
|
||||
const idx = updatedItems.findIndex(i => i.id === parent.id);
|
||||
if (idx >= 0) {
|
||||
updatedItems[idx] = {
|
||||
...updatedItems[idx],
|
||||
status: 'pending' as const
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case 'link_existing': {
|
||||
// Link to existing entity
|
||||
if (suggestion.entityId) {
|
||||
const item = items.find(i => i.id === conflict.itemId);
|
||||
if (item?.depends_on) {
|
||||
await linkToExistingEntity(item.depends_on, suggestion.entityId, item.item_type);
|
||||
|
||||
// Update local copy
|
||||
const parentIdx = updatedItems.findIndex(i => i.id === item.depends_on);
|
||||
if (parentIdx >= 0) {
|
||||
updatedItems[parentIdx] = {
|
||||
...updatedItems[parentIdx],
|
||||
approved_entity_id: suggestion.entityId,
|
||||
item_data: {
|
||||
...updatedItems[parentIdx].item_data,
|
||||
_linked_entity_id: suggestion.entityId,
|
||||
_skip_creation: true,
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case 'escalate': {
|
||||
// Escalate submission for admin review
|
||||
const item = items.find(i => i.id === conflict.itemId);
|
||||
if (item?.submission_id) {
|
||||
await escalateSubmission(
|
||||
item.submission_id,
|
||||
`Dependency conflict: ${conflict.message}`,
|
||||
userId
|
||||
);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case 'cascade_reject': {
|
||||
// This would reject the item and its dependents
|
||||
const item = items.find(i => i.id === conflict.itemId);
|
||||
if (item) {
|
||||
await rejectSubmissionItems(
|
||||
[item],
|
||||
'Rejected due to parent dependency conflict',
|
||||
userId,
|
||||
true
|
||||
);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
console.error(`Error resolving conflict for item ${conflict.itemId}:`, error);
|
||||
newConflicts.push({
|
||||
...conflict,
|
||||
message: `Failed to resolve: ${error instanceof Error ? error.message : 'Unknown error'}`,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return { updatedItems, newConflicts };
|
||||
}
|
||||
|
||||
/**
|
||||
* Edit a submission item
|
||||
* Moderators can edit directly, regular users trigger auto-escalation
|
||||
*/
|
||||
export async function editSubmissionItem(
|
||||
itemId: string,
|
||||
newData: any,
|
||||
userId: string
|
||||
): Promise<void> {
|
||||
// Check user permissions
|
||||
const { data: userRoles } = await supabase
|
||||
.from('user_roles')
|
||||
.select('role')
|
||||
.eq('user_id', userId);
|
||||
|
||||
const isModerator = userRoles?.some(r =>
|
||||
['moderator', 'admin', 'superuser'].includes(r.role)
|
||||
);
|
||||
|
||||
// Get current item
|
||||
const { data: currentItem, error: fetchError } = await supabase
|
||||
.from('submission_items')
|
||||
.select('*')
|
||||
.eq('id', itemId)
|
||||
.single();
|
||||
|
||||
if (fetchError || !currentItem) {
|
||||
throw new Error('Failed to fetch submission item');
|
||||
}
|
||||
|
||||
// Preserve original data if not already saved
|
||||
const originalData = currentItem.original_data || currentItem.item_data;
|
||||
|
||||
if (isModerator) {
|
||||
// Moderators can edit directly
|
||||
const { error } = await supabase
|
||||
.from('submission_items')
|
||||
.update({
|
||||
item_data: newData,
|
||||
original_data: originalData,
|
||||
updated_at: new Date().toISOString()
|
||||
})
|
||||
.eq('id', itemId);
|
||||
|
||||
if (error) {
|
||||
console.error('Error updating submission item:', error);
|
||||
throw new Error(`Failed to update item: ${error.message}`);
|
||||
}
|
||||
|
||||
// Log the edit
|
||||
await supabase
|
||||
.from('admin_audit_log')
|
||||
.insert({
|
||||
admin_user_id: userId,
|
||||
target_user_id: currentItem.submission_id,
|
||||
action: 'edit_submission_item',
|
||||
details: {
|
||||
item_id: itemId,
|
||||
item_type: currentItem.item_type,
|
||||
changes: newData
|
||||
}
|
||||
});
|
||||
} else {
|
||||
// Regular users trigger auto-escalation
|
||||
const { data: submission } = await supabase
|
||||
.from('content_submissions')
|
||||
.select('id, status')
|
||||
.eq('id', currentItem.submission_id)
|
||||
.single();
|
||||
|
||||
if (submission && submission.status !== 'escalated') {
|
||||
await escalateSubmission(
|
||||
currentItem.submission_id,
|
||||
`User requested edit for ${currentItem.item_type} item`,
|
||||
userId
|
||||
);
|
||||
}
|
||||
|
||||
// Update item with edit request
|
||||
const { error } = await supabase
|
||||
.from('submission_items')
|
||||
.update({
|
||||
item_data: newData,
|
||||
original_data: originalData,
|
||||
status: 'pending',
|
||||
updated_at: new Date().toISOString()
|
||||
})
|
||||
.eq('id', itemId);
|
||||
|
||||
if (error) {
|
||||
console.error('Error updating submission item:', error);
|
||||
throw new Error(`Failed to update item: ${error.message}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Update individual submission item status
|
||||
*/
|
||||
@@ -482,45 +161,29 @@ export async function approveSubmissionItems(
|
||||
// Sort by dependency order (parents first)
|
||||
const sortedItems = topologicalSort(items);
|
||||
|
||||
// Track entity ID mappings for dependency resolution
|
||||
const entityIdMap = new Map<string, string>();
|
||||
|
||||
for (const item of sortedItems) {
|
||||
let entityId: string | null = null;
|
||||
|
||||
// Check if item is linked to existing entity (skip creation)
|
||||
if (item.item_data._skip_creation && item.item_data._linked_entity_id) {
|
||||
entityId = item.item_data._linked_entity_id;
|
||||
entityIdMap.set(item.id, entityId);
|
||||
} else {
|
||||
// Resolve dependencies using entityIdMap
|
||||
const resolvedItemData = resolveDependencies(item.item_data, entityIdMap);
|
||||
|
||||
// Create the entity based on type
|
||||
switch (item.item_type) {
|
||||
case 'park':
|
||||
entityId = await createPark(resolvedItemData);
|
||||
break;
|
||||
case 'ride':
|
||||
entityId = await createRide(resolvedItemData);
|
||||
break;
|
||||
case 'manufacturer':
|
||||
case 'operator':
|
||||
case 'property_owner':
|
||||
case 'designer':
|
||||
entityId = await createCompany(resolvedItemData, item.item_type);
|
||||
break;
|
||||
case 'ride_model':
|
||||
entityId = await createRideModel(resolvedItemData);
|
||||
break;
|
||||
case 'photo':
|
||||
entityId = await approvePhotos(resolvedItemData);
|
||||
break;
|
||||
}
|
||||
|
||||
if (entityId) {
|
||||
entityIdMap.set(item.id, entityId);
|
||||
}
|
||||
// Create the entity based on type
|
||||
switch (item.item_type) {
|
||||
case 'park':
|
||||
entityId = await createPark(item.item_data);
|
||||
break;
|
||||
case 'ride':
|
||||
entityId = await createRide(item.item_data);
|
||||
break;
|
||||
case 'manufacturer':
|
||||
case 'operator':
|
||||
case 'property_owner':
|
||||
case 'designer':
|
||||
entityId = await createCompany(item.item_data, item.item_type);
|
||||
break;
|
||||
case 'ride_model':
|
||||
entityId = await createRideModel(item.item_data);
|
||||
break;
|
||||
case 'photo':
|
||||
entityId = await approvePhotos(item.item_data);
|
||||
break;
|
||||
}
|
||||
|
||||
// Update item status
|
||||
@@ -531,31 +194,6 @@ export async function approveSubmissionItems(
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve dependencies in item data using entity ID mappings
|
||||
*/
|
||||
function resolveDependencies(itemData: any, entityIdMap: Map<string, string>): any {
|
||||
const resolved = { ...itemData };
|
||||
|
||||
// Map common dependency fields
|
||||
const dependencyFields = [
|
||||
'park_id',
|
||||
'manufacturer_id',
|
||||
'operator_id',
|
||||
'property_owner_id',
|
||||
'designer_id',
|
||||
'ride_model_id',
|
||||
];
|
||||
|
||||
dependencyFields.forEach(field => {
|
||||
if (resolved[field] && entityIdMap.has(resolved[field])) {
|
||||
resolved[field] = entityIdMap.get(resolved[field]);
|
||||
}
|
||||
});
|
||||
|
||||
return resolved;
|
||||
}
|
||||
|
||||
/**
|
||||
* Topological sort for dependency-ordered processing
|
||||
*/
|
||||
|
||||
Reference in New Issue
Block a user