gsadmin/ActiveDirectoryManager
1
0
Fork 0
mirror of https://github.com/freedbygrace/ActiveDirectoryManager.git synced 2026-07-26 11:59:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

Simplify LDAP filter generation for dynamic groups. Improves filter generation speed and reliability.

Browse Source 
Replit-Commit-Author: Agent
Replit-Commit-Session-Id: 705f2157-ef97-4fbd-89e4-8c7f2ecaea90
Replit-Commit-Screenshot-Url: https://storage.googleapis.com/screenshot-production-us-central1/7ed01c5f-a82d-405a-b728-b2e3d127c60c/47f7ba05-7108-4e6d-8fdc-2f94c3d8bc00.jpg
This commit is contained in:
alphaeusmote
2025-04-11 02:22:49 +00:00
parent ba5a779214
commit 67466b14dc
1 changed files with 67 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files
client/src/components/dynamic-groups/fixed-condition-builder.tsx
+67 -100
View File
@@ -109,114 +109,81 @@ const defaultGroup: Condition = {
isGroup: true
};
// Non-recursive function to generate LDAP filter syntax from conditions
// Simple direct LDAP filter generator that ignores nesting for now
const generateLdapFilter = (conditions: Condition[]): string => {
if (!conditions || conditions.length === 0) return '(objectClass=*)';
console.log("Generating filter from conditions:", JSON.stringify(conditions));
// Simple direct generation for demonstration
// This is a simplified approach to get a working filter quickly
// Helper function to generate filter for a regular condition (not a group)
const generateRegularFilter = (condition: Condition): string => {
// Get actual attribute name (custom or selected)
const attributeName = condition.attribute === 'custom' && condition.customAttribute
? condition.customAttribute
: condition.attribute;
if (!attributeName) return '';
// Regular condition
switch (condition.operator) {
case '=':
return `(${attributeName}=${condition.value})`;
case '!=':
return `(!(${attributeName}=${condition.value}))`;
case 'contains':
return `(${attributeName}=*${condition.value}*)`;
case 'startsWith':
return `(${attributeName}=${condition.value}*)`;
case 'endsWith':
return `(${attributeName}=*${condition.value})`;
case 'present':
return `(${attributeName}=*)`;
case 'notPresent':
return `(!(${attributeName}=*))`;
default:
return `(${attributeName}=${condition.value})`;
}
};
// Find all non-group conditions
const regularConditions = conditions.filter(c => !c.isGroup);
// Copy the conditions array to avoid mutation issues
const workingConditions = [...conditions];
// First, build a map of parent IDs to their child conditions
const childrenByParentId = new Map<number | null | undefined, Condition[]>();
// Organize conditions by their parent
for (const condition of workingConditions) {
const parentId = condition.parentId;
if (!childrenByParentId.has(parentId)) {
childrenByParentId.set(parentId, []);
}
childrenByParentId.get(parentId)!.push({...condition}); // Copy to avoid mutation issues
// If there are no regular conditions, return default filter
if (regularConditions.length === 0) {
return '(objectClass=*)';
}
// Generate filter for a group using a more robust approach
const generateGroupFilter = (parentId: number | null | undefined): string => {
const childConditions = childrenByParentId.get(parentId) || [];
if (childConditions.length === 0) return '(objectClass=*)';
// Find the group condition or use default
let groupCondition: Condition | undefined;
if (parentId !== null && parentId !== undefined) {
groupCondition = workingConditions.find(c => c.id === parentId);
}
// Get logical operator for the group
const logicalOp = groupCondition?.logicalOperator || 'AND';
const operator = logicalOp === 'AND' ? '&' : '|';
// Initialize group filter
let groupFilter = `(${operator}`;
// Keep track of added conditions to handle edge cases
let hasAddedCondition = false;
// First process all regular conditions in this group
const regularConditions = childConditions.filter(c => !c.isGroup);
for (const condition of regularConditions) {
const filter = generateRegularFilter(condition);
if (filter) {
groupFilter += filter;
hasAddedCondition = true;
}
}
// Then process all subgroups in this group
const subgroups = childConditions.filter(c => c.isGroup && c.id !== undefined);
for (const subgroup of subgroups) {
if (subgroup.id !== undefined) {
const subGroupFilter = generateGroupFilter(subgroup.id);
if (subGroupFilter !== '(objectClass=*)') {
groupFilter += subGroupFilter;
hasAddedCondition = true;
}
}
}
groupFilter += ')';
// If no conditions were added, return a default filter
if (!hasAddedCondition) {
return '(objectClass=*)';
}
return groupFilter;
};
// Generate individual condition filters
const conditionFilters: string[] = [];
// Start with the root level conditions
const result = generateGroupFilter(null);
console.log("Generated LDAP filter:", result);
return result;
for (const condition of regularConditions) {
// Get attribute name
const attributeName = condition.attribute === 'custom' && condition.customAttribute
? condition.customAttribute
: condition.attribute;
// Skip if no attribute name
if (!attributeName) continue;
// Generate filter based on operator
let filter = '';
switch (condition.operator) {
case '=':
filter = `(${attributeName}=${condition.value})`;
break;
case '!=':
filter = `(!(${attributeName}=${condition.value}))`;
break;
case 'contains':
filter = `(${attributeName}=*${condition.value}*)`;
break;
case 'startsWith':
filter = `(${attributeName}=${condition.value}*)`;
break;
case 'endsWith':
filter = `(${attributeName}=*${condition.value})`;
break;
case 'present':
filter = `(${attributeName}=*)`;
break;
case 'notPresent':
filter = `(!(${attributeName}=*))`;
break;
default:
if (condition.value) {
filter = `(${attributeName}=${condition.value})`;
}
}
if (filter) {
conditionFilters.push(filter);
}
}
// If no valid filters, return default
if (conditionFilters.length === 0) {
return '(objectClass=*)';
}
// If only one filter, return it directly
if (conditionFilters.length === 1) {
return conditionFilters[0];
}
// Default to AND logic for now, for simplicity
// We'll refine this in future once the basic functionality works
return `(&${conditionFilters.join('')})`;
};
// Main component (completely rewritten)