FindNoCase

<cfset stringToSearch = "The quick brown fox jumped over the lazy dog."> 
stringToSearch = <cfoutput>#stringToSearch#</cfoutput><br> 
<p> 
Find Function:<br> 
Find("the",stringToSearch) returns <cfoutput>#find("the",stringToSearch)#</cfoutput><br> 
<p> 
FindNoCase Function:<br> 
FindNoCase("the",stringToSearch) returns <cfoutput>#FindNoCase("the",stringToSearch)#</cfoutput>

<cfscript>
    // Product database simulation
    products = [
        {id: 1, name: "Apple iPhone 15 Pro", category: "Electronics"},
        {id: 2, name: "Samsung Galaxy S24", category: "Electronics"}, 
        {id: 3, name: "MacBook Pro 16-inch", category: "Computers"},
        {id: 4, name: "iPad Air 5th Generation", category: "Tablets"},
        {id: 5, name: "AirPods Pro 2nd Gen", category: "Audio"}
    ];
    
    // User search queries in different cases
    searchQueries = ["iphone", "SAMSUNG", "macbook", "AirPods", "pro"];
    
    writeOutput("<h2>Product Search Results</h2>");
    
    for (query in searchQueries) {
        writeOutput("<h3>Search: '" & query & "'</h3>");
        foundProducts = [];
        
        for (product in products) {
            // Case-insensitive search in product name
            if (FindNoCase(query, product.name) > 0) {
                // Also check position for highlighting
                position = FindNoCase(query, product.name);
                arrayAppend(foundProducts, {
                    product: product,
                    position: position
                });
            }
        }
        
        if (arrayLen(foundProducts) > 0) {
            writeOutput("<ul>");
            for (found in foundProducts) {
                // Highlight the found term in the product name
                productName = found.product.name;
                highlightedName = replace(productName, mid(productName, found.position, len(query)), 
                                        "<mark>" & mid(productName, found.position, len(query)) & "</mark>", "one");
                
                writeOutput("<li>" & highlightedName & " - " & found.product.category & "</li>");
            }
            writeOutput("</ul>");
        } else {
            writeOutput("<p><em>No products found</em></p>");
        }
    }
</cfscript>

<cfscript>
    // User data from different sources with inconsistent casing
    users = [
        {username: "john.smith", roles: "Admin,Editor,Viewer"},
        {username: "jane.doe", roles: "EDITOR,viewer"}, 
        {username: "bob.jones", roles: "Viewer"},
        {username: "alice.wong", roles: "admin,MODERATOR,editor"}
    ];
    
    // Permission requirements (case variations common in config files)
    requiredPermissions = [
        {resource: "user_management", requiredRole: "admin"},
        {resource: "content_editing", requiredRole: "editor"},
        {resource: "view_reports", requiredRole: "viewer"},
        {resource: "moderate_content", requiredRole: "moderator"}
    ];
    
    function hasPermission(userRoles, requiredRole) {
        // Case-insensitive role checking
        return FindNoCase(requiredRole, userRoles) > 0;
    }
    
    writeOutput("<h2>User Access Control Report</h2>");
    writeOutput("<table border='1' cellpadding='8'>");
    writeOutput("<tr><th>User</th><th>Roles</th><th>User Management</th><th>Content Editing</th><th>View Reports</th><th>Moderate Content</th></tr>");
    
    for (user in users) {
        writeOutput("<tr>");
        writeOutput("<td>" & user.username & "</td>");
        writeOutput("<td>" & user.roles & "</td>");
        
        // Check each permission
        for (permission in requiredPermissions) {
            if (hasPermission(user.roles, permission.requiredRole)) {
                writeOutput("<td style='color: green; text-align: center;'>✅</td>");
            } else {
                writeOutput("<td style='color: red; text-align: center;'>❌</td>");
            }
        }
        writeOutput("</tr>");
    }
    writeOutput("</table>");
    
    // Detailed permission analysis
    writeOutput("<h3>Permission Analysis</h3>");
    for (user in users) {
        //writeOutput("<div style='margin: 10px; padding: 10px; border: 1px solid #ccc;'>");
        writeOutput("<strong>" & user.username & "</strong><br>");
        
        for (permission in requiredPermissions) {
            position = FindNoCase(permission.requiredRole, user.roles);
            if (position > 0) {
                writeOutput("• Can access <strong>" & permission.resource & "</strong> ('" & 
                           permission.requiredRole & "' found at position " & position & ")<br>");
            }
        }
        writeOutput("</div>");
    }
</cfscript>

<cfscript>
    // Incoming emails with mixed case domains (real-world scenario)
    incomingEmails = [
        {from: "support@MICROSOFT.COM", subject: "License renewal notice"},
        {from: "noreply@github.com", subject: "Pull request merged"},
        {from: "alerts@AWS.Amazon.com", subject: "Service health notification"},
        {from: "team@SALESFORCE.org", subject: "Meeting invitation"},
        {from: "suspicious@tempmail.NET", subject: "You won a prize!"},
        {from: "admin@company-internal.com", subject: "Internal memo"}
    ];
    
    // Email filtering rules
    trustedDomains = ["microsoft.com", "github.com", "amazon.com", "salesforce.com"];
    suspiciousDomains = ["tempmail", "10minutemail", "guerrillamail", "throwaway"];
    internalDomains = ["company-internal.com", "corp.local"];
    
    function checkEmailSecurity(emailAddress) {
        result = {
            status: "unknown",
            reason: "",
            action: "review"
        };
        
        // Check for trusted domains (case-insensitive)
        for (domain in trustedDomains) {
            if (FindNoCase(domain, emailAddress) > 0) {
                result.status = "trusted";
                result.reason = "From trusted domain: " & domain;
                result.action = "allow";
                return result;
            }
        }
        
        // Check for suspicious domains
        for (suspicious in suspiciousDomains) {
            if (FindNoCase(suspicious, emailAddress) > 0) {
                result.status = "suspicious";
                result.reason = "Contains suspicious pattern: " & suspicious;
                result.action = "block";
                return result;
            }
        }
        
        // Check for internal domains
        for (internal in internalDomains) {
            if (FindNoCase(internal, emailAddress) > 0) {
                result.status = "internal";
                result.reason = "Internal domain: " & internal;
                result.action = "priority";
                return result;
            }
        }
        
        return result;
    }
    
    writeOutput("<h2>Email Security Filtering</h2>");
    writeOutput("<table border='1' cellpadding='8'>");
    writeOutput("<tr><th>From</th><th>Subject</th><th>Status</th><th>Reason</th><th>Action</th></tr>");
    
    for (email in incomingEmails) {
        security = checkEmailSecurity(email.from);
        
        // Color coding based on status
        statusColors = {
            "trusted": "green",
            "internal": "blue", 
            "suspicious": "red",
            "unknown": "orange"
        };
        
        statusColor = statusColors[security.status] ?: "black";
        
        writeOutput("<tr>");
        writeOutput("<td>" & email.from & "</td>");
        writeOutput("<td>" & email.subject & "</td>");
        writeOutput("<td style='color: " & statusColor & ";'><strong>" & UCase(security.status) & "</strong></td>");
        writeOutput("<td>" & security.reason & "</td>");
        writeOutput("<td><strong>" & UCase(security.action) & "</strong></td>");
        writeOutput("</tr>");
    }
    writeOutput("</table>");
    
    // Statistics
    stats = {trusted: 0, suspicious: 0, internal: 0, unknown: 0};
    for (email in incomingEmails) {
        security = checkEmailSecurity(email.from);
        stats[security.status]++;
    }
    
    writeOutput("<h3>Filtering Statistics</h3>");
    writeOutput("<ul>");
    for (status in stats) {
        writeOutput("<li>" & UCase(status) & ": " & stats[status] & " emails</li>");
    }
    writeOutput("</ul>");
</cfscript>

<cfscript>
    // Configuration files from different sources
    configSources = [
        {
            source: "main.conf",
            content: "DATABASE_HOST=localhost; CACHE_ENABLED=true; DEBUG_MODE=false; SSL_REQUIRED=TRUE"
        },
        {
            source: "environment.conf", 
            content: "database_port=3306; cache_timeout=300; Debug_Level=INFO; ssl_certificate=/path/to/cert"
        },
        {
            source: "user.conf",
            content: "Max_Connections=100; Connection_Pool=enabled; backup_enabled=YES; SSL_Port=443"
        }
    ];
    
    // Configuration parser
    function parseConfig(configContent, settingName) {
        result = {
            found: false,
            value: "",
            position: 0
        };
        
        // Look for setting name (case-insensitive)
        position = FindNoCase(settingName, configContent);
        if (position > 0) {
            result.found = true;
            result.position = position;
            
            // Find the equals sign after the setting name
            equalsPos = find("=", configContent, position);
            if (equalsPos > 0) {
                // Find the end of the value (semicolon or end of string)
                semicolonPos = find(";", configContent, equalsPos);
                if (semicolonPos == 0) {
                    semicolonPos = len(configContent) + 1;
                }
                
                // Extract and clean the value
                result.value = trim(mid(configContent, equalsPos + 1, semicolonPos - equalsPos - 1));
            }
        }
        
        return result;
    }
    
    // Settings to look for
    requiredSettings = [
        "database_host",
        "cache_enabled", 
        "debug_mode",
        "ssl_required",
        "max_connections",
        "backup_enabled"
    ];
    
    writeOutput("<h2>Configuration Analysis</h2>");
    writeOutput("<table border='1' cellpadding='8'>");
    writeOutput("<tr><th>Setting</th><th>Source File</th><th>Value</th><th>Status</th></tr>");
    
    configSummary = {};
    
    for (setting in requiredSettings) {
        //writeOutput("<tr style='background-color: #f5f5f5;'>");
        writeOutput("<td colspan='4'><strong>" & UCase(setting) & "</strong></td>");
        writeOutput("</tr>");
        
        settingFound = false;
        for (config in configSources) {
            result = parseConfig(config.content, setting);
            
            if (result.found) {
                settingFound = true;
                statusColor = "green";
                statusText = "✅ Found";
                
                // Store in summary
                configSummary[setting] = result.value;
            } else {
                statusColor = "lightgray";
                statusText = "❌ Not found";
            }
            
            writeOutput("<tr>");
            writeOutput("<td style='padding-left: 20px;'>" & setting & "</td>");
            writeOutput("<td>" & config.source & "</td>");
            writeOutput("<td>" & (result.found ? result.value : "-") & "</td>");
            writeOutput("<td style='color: " & (result.found ? "green" : "red") & ";'>" & statusText & "</td>");
            writeOutput("</tr>");
        }
        
        if (!settingFound) {
            writeOutput("<tr>");
            writeOutput("<td colspan='4' style='color: red; font-style: italic; text-align: center;'>⚠ Setting not found in any configuration file</td>");
            writeOutput("</tr>");
        }
    }
    writeOutput("</table>");
    
    // Final configuration summary
    writeOutput("<h3>Final Configuration Summary</h3>");
    //writeOutput("<div style='background-color: #f0f8ff; padding: 15px; border: 1px solid #ccc;'>");
    
    if (structCount(configSummary) > 0) {
        for (setting in configSummary) {
            writeOutput("<p><strong>" & UCase(setting) & ":</strong> " & configSummary[setting] & "</p>");
        }
    } else {
        writeOutput("<p style='color: red;'>⚠ No valid configuration settings found</p>");
    }
    writeOutput("</div>");
</cfscript>