Enhanced PHP File Manager

⬆️ Go Up (..)

📊 Server Information

Server:

LiteSpeed

System:

Linux 5.14.0-503.34.1.el9_5.x86_64

PHP Version:

8.2.30

User:

u329947844

Directory:

/home/u329947844/domains/hifi11.in/public_html/ecom

Free Space:

10.28 TB

🔧 Quick Actions

✏️ Editing: search_results.php

<?php
header("Content-Type: application/json");
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: GET");
header("Access-Control-Allow-Headers: Content-Type");

// Database configuration
$host = 'localhost';
$dbname = 'u329947844_ranjith';
$username = 'u329947844_ranjith';
$password = 'Ariharan@2025';

// Function to handle word variations (plurals, common misspellings)
function normalizeWord($word) {
    // Common word endings to remove (for handling plurals)
    $endings = ['s', 'es', 'ies'];
    
    // First try the word as-is
    $variations = [strtolower($word)];
    
    // Generate variations by removing common plural endings
    foreach ($endings as $ending) {
        if (str_ends_with($word, $ending)) {
            $variations[] = strtolower(substr($word, 0, -strlen($ending)));
        }
    }
    
    // Add common misspellings for known brands/products
    $commonMisspellings = [
        'infinix' => ['infinx', 'infnix', 'infenix'],
        'samsung' => ['samsng', 'samsing', 'samnsung'],
        'mobile' => ['mobl', 'moble', 'mobail']
    ];
    
    foreach ($commonMisspellings as $correct => $misspellings) {
        if (in_array(strtolower($word), $misspellings)) {
            $variations[] = $correct;
        }
    }
    
    return array_unique($variations);
}

try {
    $pdo = new PDO("mysql:host=$host;dbname=$dbname", $username, $password);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

// Get and sanitize search parameters
    $rawQuery = isset($_GET['q']) ? trim($_GET['q']) : '';
    $page = isset($_GET['page']) ? max(1, intval($_GET['page'])) : 1;
    $categoryId = isset($_GET['category']) ? intval($_GET['category']) : null;
    $limit = 20;
    $offset = ($page - 1) * $limit;

// Parse the search query for special patterns
    $priceFilter = extractPriceRange($rawQuery);
    $brandFilter = findClosestBrand($rawQuery, $pdo);
    $cleanedQuery = cleanSearchQuery($rawQuery);
    
    // Generate search variations for the query
    $queryWords = explode(' ', $cleanedQuery);
    $queryVariations = [''];
    
    foreach ($queryWords as $word) {
        $newVariations = [];
        $wordVariations = normalizeWord($word);
        
        foreach ($queryVariations as $variation) {
            foreach ($wordVariations as $wordVar) {
                $newVariations[] = trim("$variation $wordVar");
            }
        }
        
        $queryVariations = $newVariations;
    }
    
    // Remove empty variations
    $queryVariations = array_filter($queryVariations);

// Build base query
    $query = "
        SELECT 
            p.id,
            p.title,
            p.description,
            p.price,
            p.compare_price,
            p.vendor as brand,
            p.average_rating,
            p.rating_count,
            p.product_type,
            p.tags,
            (
                SELECT image_path 
                FROM product_variant_images pvi
                JOIN product_variants pv ON pvi.variant_id = pv.id
                WHERE pv.product_id = p.id
                LIMIT 1
            ) as image,
            (
                SELECT SUM(pv.stock)
                FROM product_variants pv 
                WHERE pv.product_id = p.id
            ) as total_stock,
            (
                SELECT GROUP_CONCAT(c.title SEPARATOR ', ')
                FROM categories c
                WHERE FIND_IN_SET(c.id, REPLACE(REPLACE(REPLACE(p.category, '[', ''), ']', ''), '\"', ''))
            ) as categories
        FROM products p
        WHERE (p.status = 'published' OR p.status = 'active')
    ";

$params = [];
    $conditions = [];

// Handle category filter
    if (!empty($categoryId)) {
        $conditions[] = "FIND_IN_SET(:category_id, REPLACE(REPLACE(REPLACE(p.category, '[', ''), ']', ''), '\"', ''))";
        $params[':category_id'] = $categoryId;
    }

// Handle different search patterns with variations
    if (!empty($queryVariations)) {
        $likeConditions = [];
        $soundexConditions = [];
        
        foreach ($queryVariations as $index => $variation) {
            if (empty($variation)) continue;
            
            // Exact match
            $conditions[] = "(p.title = :exact_title_$index OR p.product_type = :exact_type_$index)";
            $params[":exact_title_$index"] = $variation;
            $params[":exact_type_$index"] = $variation;
            
            // Partial matches with LIKE
            $likeConditions[] = "p.title LIKE :contains_title_$index";
            $likeConditions[] = "p.description LIKE :contains_desc_$index";
            $params[":contains_title_$index"] = "%$variation%";
            $params[":contains_desc_$index"] = "%$variation%";
            
            // Start with matches
            $likeConditions[] = "p.title LIKE :starts_with_$index";
            $params[":starts_with_$index"] = "$variation%";
            
            // Soundex matching
            $soundexConditions[] = "SOUNDEX(p.title) = SOUNDEX(:soundex_title_$index)";
            $soundexConditions[] = "SOUNDEX(p.product_type) = SOUNDEX(:soundex_type_$index)";
            $params[":soundex_title_$index"] = $variation;
            $params[":soundex_type_$index"] = $variation;
        }
        
        if (!empty($likeConditions)) {
            $conditions[] = "(" . implode(" OR ", $likeConditions) . ")";
        }
        if (!empty($soundexConditions)) {
            $conditions[] = "(" . implode(" OR ", $soundexConditions) . ")";
        }
    }

// Apply brand filter if detected
    if (!empty($brandFilter)) {
        $conditions[] = "p.vendor LIKE :brand";
        $params[':brand'] = "%$brandFilter%";
    }

// Apply price range if detected
    if ($priceFilter['min'] !== null || $priceFilter['max'] !== null) {
        if ($priceFilter['min'] !== null) {
            $conditions[] = "p.price >= :min_price";
            $params[':min_price'] = $priceFilter['min'];
        }
        if ($priceFilter['max'] !== null) {
            $conditions[] = "p.price <= :max_price";
            $params[':max_price'] = $priceFilter['max'];
        }
    }

// Combine conditions
    if (!empty($conditions)) {
        $query .= " AND (" . implode(" OR ", $conditions) . ")";
    }

// Add sorting - prioritize exact matches first
    $orderConditions = [];
    foreach ($queryVariations as $index => $variation) {
        if (empty($variation)) continue;
        
        $orderConditions[] = "WHEN p.title = :exact_title_$index THEN 1";
        $orderConditions[] = "WHEN p.product_type = :exact_type_$index THEN 2";
        $orderConditions[] = "WHEN p.title LIKE :starts_with_$index THEN 3";
        $orderConditions[] = "WHEN SOUNDEX(p.title) = SOUNDEX(:soundex_title_$index) THEN 4";
    }
    
    $query .= " ORDER BY CASE " . implode(" ", $orderConditions) . " ELSE 5 END, p.rating_count DESC, p.average_rating DESC";

// Add pagination
    $query .= " LIMIT :limit OFFSET :offset";
    $params[':limit'] = $limit;
    $params[':offset'] = $offset;

// Prepare and execute query
    $stmt = $pdo->prepare($query);
    foreach ($params as $key => $value) {
        $stmt->bindValue($key, $value, is_int($value) ? PDO::PARAM_INT : PDO::PARAM_STR);
    }
    $stmt->execute();
    $products = $stmt->fetchAll(PDO::FETCH_ASSOC);

// Get total count for pagination
    $countQuery = "SELECT COUNT(*) as total FROM products p WHERE (p.status = 'published' OR p.status = 'active')";
    if (!empty($conditions)) {
        $countQuery .= " AND (" . implode(" OR ", $conditions) . ")";
    }
    $countStmt = $pdo->prepare($countQuery);
    foreach ($params as $key => $value) {
        if ($key !== ':limit' && $key !== ':offset') {
            $countStmt->bindValue($key, $value, is_int($value) ? PDO::PARAM_INT : PDO::PARAM_STR);
        }
    }
    $countStmt->execute();
    $totalCount = $countStmt->fetchColumn();

// Format response
    $formattedProducts = array_map(function($product) {
        $tags = json_decode($product['tags'] ?? '[]', true) ?: [];
        
        return [
            'id' => (int)$product['id'],
            'title' => $product['title'],
            'description' => $product['description'],
            'price' => [
                'current' => (float)$product['price'],
                'original' => $product['compare_price'] ? (float)$product['compare_price'] : null,
                'discount' => $product['compare_price'] 
                    ? round((($product['compare_price'] - $product['price']) / $product['compare_price'] * 100))
                    : null
            ],
            'image' => $product['image'] ?? 'default-product.jpg',
            'rating' => [
                'average' => (float)$product['average_rating'],
                'count' => (int)$product['rating_count']
            ],
            'brand' => $product['brand'],
            'inStock' => $product['total_stock'] > 0,
            'categories' => $product['categories'],
            'type' => $product['product_type'],
            'tags' => $tags
        ];
    }, $products);

// Get available filters based on results
    $filters = getAvailableFilters($pdo, $rawQuery, $categoryId, $priceFilter, $brandFilter);

echo json_encode([
        'status' => 'success',
        'data' => [
            'products' => $formattedProducts,
            'filters' => $filters,
            'pagination' => [
                'total' => (int)$totalCount,
                'per_page' => $limit,
                'current_page' => $page,
                'last_page' => ceil($totalCount / $limit)
            ],
            'search_meta' => [
                'original_query' => $rawQuery,
                'cleaned_query' => $cleanedQuery,
                'query_variations' => array_values($queryVariations),
                'detected_brand' => $brandFilter,
                'detected_price_range' => $priceFilter
            ]
        ]
    ]);

} catch (PDOException $e) {
    http_response_code(500);
    echo json_encode([
        'status' => 'error',
        'message' => 'Database error: ' . $e->getMessage()
    ]);
}

/**
 * Find closest brand name using fuzzy matching
 */
function findClosestBrand($query, $pdo) {
    // Get all brands from database
    $stmt = $pdo->query("SELECT DISTINCT vendor FROM products WHERE vendor IS NOT NULL");
    $brands = $stmt->fetchAll(PDO::FETCH_COLUMN);
    
    $bestMatch = '';
    $shortestDistance = -1;
    
    foreach ($brands as $brand) {
        // Calculate similarity
        similar_text(strtolower($query), strtolower($brand), $percent);
        
        // Find the closest match (minimum 60% similarity)
        if ($percent > 60 && ($percent > $shortestDistance || $shortestDistance < 0)) {
            $shortestDistance = $percent;
            $bestMatch = $brand;
        }
    }
    
    return $bestMatch;
}

/**
 * Extract price range from search query (e.g., "mobiles under 20000")
 */
function extractPriceRange($query) {
    $result = ['min' => null, 'max' => null];
    
    // Patterns to match
    $patterns = [
        '/under\s+(\d+)/i' => function($matches) use (&$result) { $result['max'] = $matches[1]; },
        '/above\s+(\d+)/i' => function($matches) use (&$result) { $result['min'] = $matches[1]; },
        '/between\s+(\d+)\s+and\s+(\d+)/i' => function($matches) use (&$result) { 
            $result['min'] = min($matches[1], $matches[2]);
            $result['max'] = max($matches[1], $matches[2]);
        },
        '/(\d+)\s*-\s*(\d+)/' => function($matches) use (&$result) { 
            $result['min'] = min($matches[1], $matches[2]);
            $result['max'] = max($matches[1], $matches[2]);
        }
    ];
    
    foreach ($patterns as $pattern => $callback) {
        if (preg_match($pattern, $query, $matches)) {
            $callback($matches);
        }
    }
    
    return $result;
}

/**
 * Clean search query by removing price ranges and other special patterns
 */
function cleanSearchQuery($query) {
    // Remove price-related phrases
    $query = preg_replace('/under\s+\d+/i', '', $query);
    $query = preg_replace('/above\s+\d+/i', '', $query);
    $query = preg_replace('/between\s+\d+\s+and\s+\d+/i', '', $query);
    $query = preg_replace('/\d+\s*-\s*\d+/', '', $query);
    
    // Remove extra spaces and trim
    $query = preg_replace('/\s+/', ' ', $query);
    return trim($query);
}

/**
 * Get available filters based on search results
 */
function getAvailableFilters($pdo, $query, $categoryId, $priceFilter, $brandFilter) {
    $filters = [];
    
    // Price range
    $priceQuery = "SELECT MIN(price) as min_price, MAX(price) as max_price FROM products WHERE status IN ('published', 'active')";
    $priceParams = [];
    
    $conditions = [];
    if (!empty($query)) {
        $cleanedQuery = cleanSearchQuery($query);
        $conditions[] = "(title LIKE :query OR description LIKE :query OR product_type LIKE :query)";
        $priceParams[':query'] = "%$cleanedQuery%";
    }
    if (!empty($categoryId)) {
        $conditions[] = "FIND_IN_SET(:category_id, REPLACE(REPLACE(REPLACE(category, '[', ''), ']', ''), '\"', ''))";
        $priceParams[':category_id'] = $categoryId;
    }
    if (!empty($brandFilter)) {
        $conditions[] = "vendor LIKE :brand";
        $priceParams[':brand'] = "%$brandFilter%";
    }
    
    if (!empty($conditions)) {
        $priceQuery .= " AND " . implode(" AND ", $conditions);
    }
    
    $priceStmt = $pdo->prepare($priceQuery);
    foreach ($priceParams as $key => $value) {
        $priceStmt->bindValue($key, $value);
    }
    $priceStmt->execute();
    $priceRange = $priceStmt->fetch(PDO::FETCH_ASSOC);
    
    $filters['price_range'] = [
        'min' => (float)$priceRange['min_price'],
        'max' => (float)$priceRange['max_price'],
        'applied_min' => $priceFilter['min'],
        'applied_max' => $priceFilter['max']
    ];

// Categories
    $categoryQuery = "
        SELECT c.id, c.title, COUNT(p.id) as product_count
        FROM categories c
        JOIN products p ON FIND_IN_SET(c.id, REPLACE(REPLACE(REPLACE(p.category, '[', ''), ']', ''), '\"', ''))
        WHERE p.status IN ('published', 'active')
    ";
    
    $categoryParams = [];
    if (!empty($query)) {
        $cleanedQuery = cleanSearchQuery($query);
        $categoryQuery .= " AND (p.title LIKE :query OR p.description LIKE :query OR p.product_type LIKE :query)";
        $categoryParams[':query'] = "%$cleanedQuery%";
    }
    if (!empty($brandFilter)) {
        $categoryQuery .= " AND p.vendor LIKE :brand";
        $categoryParams[':brand'] = "%$brandFilter%";
    }
    
    $categoryQuery .= " GROUP BY c.id ORDER BY product_count DESC LIMIT 10";
    
    $categoryStmt = $pdo->prepare($categoryQuery);
    foreach ($categoryParams as $key => $value) {
        $categoryStmt->bindValue($key, $value);
    }
    $categoryStmt->execute();
    $filters['categories'] = $categoryStmt->fetchAll(PDO::FETCH_ASSOC);

// Brands
    $brandQuery = "
        SELECT vendor as brand, COUNT(*) as product_count
        FROM products
        WHERE status IN ('published', 'active')
    ";
    
    $brandParams = [];
    if (!empty($query)) {
        $cleanedQuery = cleanSearchQuery($query);
        $brandQuery .= " AND (title LIKE :query OR description LIKE :query OR product_type LIKE :query)";
        $brandParams[':query'] = "%$cleanedQuery%";
    }
    if (!empty($categoryId)) {
        $brandQuery .= " AND FIND_IN_SET(:category_id, REPLACE(REPLACE(REPLACE(category, '[', ''), ']', ''), '\"', ''))";
        $brandParams[':category_id'] = $categoryId;
    }
    
    $brandQuery .= " GROUP BY vendor ORDER BY product_count DESC LIMIT 10";
    
    $brandStmt = $pdo->prepare($brandQuery);
    foreach ($brandParams as $key => $value) {
        $brandStmt->bindValue($key, $value);
    }
    $brandStmt->execute();
    $filters['brands'] = $brandStmt->fetchAll(PDO::FETCH_ASSOC);

return $filters;
}

❌ Cancel

🗂️ Enhanced PHP File Manager

📊 Server Information

🔧 Quick Actions

✏️ Editing: search_results.php

📤 Upload File

📁 Create Folder

📄 Create File

✏️ Rename Item

🗑️ Delete Confirmation