String+Ext - Validation and ect. things

String+Ext.swift

import var CommonCrypto.CC_MD5_DIGEST_LENGTH
import func CommonCrypto.CC_MD5
import typealias CommonCrypto.CC_LONG

import Foundation
import UIKit

enum UserCredentialError: Error, LocalizedError {
    
    case invalidEmail
    case invalidUserName
    case invalidPassword
    case invalidUserNameEmail
    case notMatchingPassword
    case currentPasswordNotMatch
    
    var description: String {
        switch self {
            
        case .invalidEmail:
            return Localizable.inputErrorEmail()
        case .invalidUserName:
            return Localizable.inputErrorUsername()
        case .invalidUserNameEmail:
            return Localizable.inputErrorEmailOrUsername()
        case .invalidPassword:
            return Localizable.inputErrorPassword()
        case .notMatchingPassword:
            return Localizable.inputErrorPasswordMismatch()
        case .currentPasswordNotMatch:
            return Localizable.inputErrorPasswordInvalid()
        }
    }
    
    var errorDescription: String? {
        return self.description
    }
    
}

extension String {
    
    func isValidWithRegEx(_ regEx: String) -> Bool {
        let pred = NSPredicate(format: "SELF MATCHES %@", regEx)
        return pred.evaluate(with: self)
    }
    
    func isValidEmail() -> Bool {
        let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
        let emailTest = NSPredicate(format: "SELF MATCHES %@", emailRegex)
        return emailTest.evaluate(with: self)
    }
    
    func isValidUserName() -> Bool {
        
        let string = self.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)
        return string.isAlphanumeric
    }
    
    func isValidPassword() -> Bool {
        return self.count >= 5
    }
    
    func validateEmail() throws {
        let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
        let emailTest = NSPredicate(format: "SELF MATCHES %@", emailRegex)
        if !emailTest.evaluate(with: self) {
            throw UserCredentialError.invalidEmail
        }
    }
    
    func isValidURL() -> Bool {
        // (http|https)://((\\w)|([0-9])|([-|]))+([\\.|/]((\\w)|([0-9])|([-|])))+[\\w-\\._~:/?#\\[\\]@!\\$&'\\(\\)\\*\\+,;=.]+

        // https?://(www.)?((?!-)[a-zA-Z0-9-]{2,63}(?<!-))\\.?((?:[a-zA-Z0-9]{2,})?(?:\\.[a-zA-Z0-9]{2,})?)+[\\w-\\._~:/?#\\[\\]@!\\$&'\\(\\)\\*\\+,;=.]+

        // ((https?://(www.)?)|(www.))[-a-zA-Z0-9@:%.+#=]{1,256}.[a-zA-Z0-9()]{1,6}b([-a-zA-Z0-9()@:%+.#?&/=])
        let urlRegEx = "((?:http|https)://)?(?:www\\.)?[\\w\\d-_]+\\.\\w{2,3}(\\.\\w{2})?(/(?<=/)(?:[\\w\\d\\-./_]+)?)?"
        return NSPredicate(format: "SELF MATCHES %@", urlRegEx).evaluate(with: self)
    }
    
    func validateUserName() throws {
        do {
            let string = self.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)
            if string.isEmpty || !string.isAlphanumeric() {
                throw UserCredentialError.invalidUserName
            }
        }
    }
    
    func validatePassword() throws {
        if self.count <= 5 {
            throw UserCredentialError.invalidPassword
        }
    }
    
    var isAlphanumeric: Bool {
        return !isEmpty && range(of: "[^a-zA-Z0-9]", options: .regularExpression) == nil
    }
    
    func isAlphanumeric(ignoreDiacritics: Bool = false) -> Bool {
        if ignoreDiacritics {
            return self.range(of: "[^a-zA-Z0-9]", options: .regularExpression) == nil && self != ""
        } else {
            return self.isAlphanumeric
        }
    }
    
    // MARK: Random data generation, required for testing
    /**
     returns a random email as string
     */
    static func randomEmail() -> String {
        let nameLength = Int.random(in: 5..<10)
        let domainLength = Int.random(in: 5..<10)
        let domainSuffixes = ["com", "net", "org", "io"]
        let name = String.randomString(length: nameLength, isLowercase: true)
        let domain = String.randomString(length: domainLength, isLowercase: true)
        let randomDomainSuffixIndex = Int(arc4random_uniform(UInt32(domainSuffixes.count)))
        let domainSuffix = domainSuffixes[randomDomainSuffixIndex]
        let text = name + "@" + domain + "." + domainSuffix
        return text
    }
    
    private static func randomString(length: Int, isLowercase: Bool) -> String {
        let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        let resultString = String((0..<length).map{ _ in letters.randomElement() ?? " " })
        if isLowercase {
            return resultString.lowercased()
        } else {
            return resultString
        }
    }
    
    func trimmed() -> String {
        return self.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)
    }
    
    func trimSpace() -> String {
        return self.replacingOccurrences(of: " ", with: "", options: NSString.CompareOptions.literal, range: nil)
    }
    
    func sha256My() -> String{
        var result = ""
        if let stringData = self.data(using: String.Encoding.utf8) {
            result = hexStringFromData(input: digest(input: stringData as NSData))
        }
        return result
    }
    
    private func digest(input: NSData) -> NSData {
        let digestLength = Int(CC_SHA256_DIGEST_LENGTH)
        var hash = [UInt8](repeating: 0, count: digestLength)
        CC_SHA256(input.bytes, UInt32(input.length), &hash)
        return NSData(bytes: hash, length: digestLength)
    }
    
    private  func hexStringFromData(input: NSData) -> String {
        var bytes = [UInt8](repeating: 0, count: input.length)
        input.getBytes(&bytes, length: input.length)
        var hexString = ""
        for byte in bytes {
            hexString += String(format: "%02x", UInt8(byte))
        }
        
        return hexString
    }
}