1.6.0 for Android and 1.1.0 for iOS - Finalizing Export and Import

formats :)

ios/OpenClimb/Utils/ImageNamingUtils.swift

@@ -0,0 +1,176 @@
+//
+//  ImageNamingUtils.swift
+
+import CryptoKit
+import Foundation
+
+/// Utility for creating consistent image filenames across iOS and Android platforms.
+/// Uses deterministic naming based on problem ID and timestamp to ensure sync compatibility.
+class ImageNamingUtils {
+
+    private static let imageExtension = ".jpg"
+    private static let hashLength = 12  // First 12 chars of SHA-256
+
+    /// Generates a deterministic filename for a problem image.
+    /// Format: "problem_{hash}_{index}.jpg"
+    ///
+    /// - Parameters:
+    ///   - problemId: The ID of the problem this image belongs to
+    ///   - timestamp: ISO8601 timestamp when the image was created
+    ///   - imageIndex: The index of this image for the problem (0, 1, 2, etc.)
+    /// - Returns: A consistent filename that will be the same across platforms
+    static func generateImageFilename(problemId: String, timestamp: String, imageIndex: Int)
+        -> String
+    {
+        // Create a deterministic hash from problemId + timestamp + index
+        let input = "\(problemId)_\(timestamp)_\(imageIndex)"
+        let hash = createHash(from: input)
+
+        return "problem_\(hash)_\(imageIndex)\(imageExtension)"
+    }
+
+    /// Generates a deterministic filename for a problem image using current timestamp.
+    ///
+    /// - Parameters:
+    ///   - problemId: The ID of the problem this image belongs to
+    ///   - imageIndex: The index of this image for the problem (0, 1, 2, etc.)
+    /// - Returns: A consistent filename
+    static func generateImageFilename(problemId: String, imageIndex: Int) -> String {
+        let timestamp = ISO8601DateFormatter().string(from: Date())
+        return generateImageFilename(
+            problemId: problemId, timestamp: timestamp, imageIndex: imageIndex)
+    }
+
+    /// Extracts problem ID from an image filename created by this utility.
+    /// Returns nil if the filename doesn't match our naming convention.
+    ///
+    /// - Parameter filename: The image filename
+    /// - Returns: The hash identifier or nil if not a valid filename
+    static func extractProblemIdFromFilename(_ filename: String) -> String? {
+        guard filename.hasPrefix("problem_") && filename.hasSuffix(imageExtension) else {
+            return nil
+        }
+
+        // Format: problem_{hash}_{index}.jpg
+        let nameWithoutExtension = String(filename.dropLast(imageExtension.count))
+        let parts = nameWithoutExtension.components(separatedBy: "_")
+
+        guard parts.count == 3 && parts[0] == "problem" else {
+            return nil
+        }
+
+        // Return the hash as identifier
+        return parts[1]
+    }
+
+    /// Validates if a filename follows our naming convention.
+    ///
+    /// - Parameter filename: The filename to validate
+    /// - Returns: true if it matches our convention, false otherwise
+    static func isValidImageFilename(_ filename: String) -> Bool {
+        guard filename.hasPrefix("problem_") && filename.hasSuffix(imageExtension) else {
+            return false
+        }
+
+        let nameWithoutExtension = String(filename.dropLast(imageExtension.count))
+        let parts = nameWithoutExtension.components(separatedBy: "_")
+
+        return parts.count == 3 && parts[0] == "problem" && parts[1].count == hashLength
+            && Int(parts[2]) != nil
+    }
+
+    /// Migrates an existing UUID-based filename to our naming convention.
+    /// This is used during sync to rename downloaded images.
+    ///
+    /// - Parameters:
+    ///   - oldFilename: The existing filename (UUID-based)
+    ///   - problemId: The problem ID this image belongs to
+    ///   - imageIndex: The index of this image
+    /// - Returns: The new filename following our convention
+    static func migrateFilename(oldFilename: String, problemId: String, imageIndex: Int) -> String {
+        // If it's already using our convention, keep it
+        if isValidImageFilename(oldFilename) {
+            return oldFilename
+        }
+
+        // Generate new deterministic name
+        // Use current timestamp to maintain some consistency
+        let timestamp = ISO8601DateFormatter().string(from: Date())
+        return generateImageFilename(
+            problemId: problemId, timestamp: timestamp, imageIndex: imageIndex)
+    }
+
+    /// Creates a deterministic hash from input string.
+    /// Uses SHA-256 and takes first 12 characters for filename safety.
+    ///
+    /// - Parameter input: The input string to hash
+    /// - Returns: First 12 characters of SHA-256 hash in lowercase
+    private static func createHash(from input: String) -> String {
+        let inputData = Data(input.utf8)
+        let hashed = SHA256.hash(data: inputData)
+        let hashString = hashed.compactMap { String(format: "%02x", $0) }.joined()
+        return String(hashString.prefix(hashLength))
+    }
+
+    /// Batch renames images for a problem to use our naming convention.
+    /// Returns a mapping of old filename -> new filename.
+    ///
+    /// - Parameters:
+    ///   - problemId: The problem ID
+    ///   - existingFilenames: List of current image filenames for this problem
+    /// - Returns: Dictionary mapping old filename to new filename
+    static func batchRenameForProblem(problemId: String, existingFilenames: [String]) -> [String:
+        String]
+    {
+        var renameMap: [String: String] = [:]
+
+        for (index, oldFilename) in existingFilenames.enumerated() {
+            let newFilename = migrateFilename(
+                oldFilename: oldFilename, problemId: problemId, imageIndex: index)
+            if newFilename != oldFilename {
+                renameMap[oldFilename] = newFilename
+            }
+        }
+
+        return renameMap
+    }
+
+    /// Validates that a collection of filenames follow our naming convention.
+    ///
+    /// - Parameter filenames: Array of filenames to validate
+    /// - Returns: Dictionary with validation results
+    static func validateFilenames(_ filenames: [String]) -> ImageValidationResult {
+        var validImages: [String] = []
+        var invalidImages: [String] = []
+
+        for filename in filenames {
+            if isValidImageFilename(filename) {
+                validImages.append(filename)
+            } else {
+                invalidImages.append(filename)
+            }
+        }
+
+        return ImageValidationResult(
+            totalImages: filenames.count,
+            validImages: validImages,
+            invalidImages: invalidImages
+        )
+    }
+}
+
+/// Result of image filename validation
+struct ImageValidationResult {
+    let totalImages: Int
+    let validImages: [String]
+    let invalidImages: [String]
+
+    var isAllValid: Bool {
+        return invalidImages.isEmpty
+    }
+
+    var validPercentage: Double {
+        guard totalImages > 0 else { return 100.0 }
+        return (Double(validImages.count) / Double(totalImages)) * 100.0
+    }
+}