first commit

Author: gabriel-logan

README.md

@@ -0,0 +1,8 @@
+> [!NOTE]
+> I accept help to make the version of the other programming languages.
+
+# Multiform-validator
+
+## KOTLIN
+
+In coming ...

src/main/java/io/multiform_validator/Ascii.java

@@ -0,0 +1,26 @@
+package io.multiform_validator;
+
+import org.jetbrains.annotations.NotNull;
+
+public class Ascii {
+    private static final String INPUT_VALUE_CANNOT_BE_EMPTY = "Input value cannot be empty.";
+
+    private Ascii() {
+        throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
+    }
+
+    /**
+     * Check if a string is ASCII.
+     *
+     * @param value The string to check.
+     * @return True if the string is ASCII, false otherwise.
+     * @throws IllegalArgumentException If the input value is empty.
+     */
+    public static boolean isAscii(@NotNull String value) {
+        if (value.isBlank()) {
+            throw new IllegalArgumentException(INPUT_VALUE_CANNOT_BE_EMPTY);
+        }
+
+        return value.chars().allMatch(c -> c < 128);
+    }
+}

src/main/java/io/multiform_validator/Base64.java

@@ -0,0 +1,27 @@
+package io.multiform_validator;
+
+import org.jetbrains.annotations.NotNull;
+
+public class Base64 {
+
+    private static final String INPUT_VALUE_CANNOT_BE_EMPTY = "Input value cannot be empty.";
+
+    private Base64() {
+        throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
+    }
+
+    /**
+     * Check if a string is Base64.
+     *
+     * @param value The string to check.
+     * @return True if the string is Base64, false otherwise.
+     * @throws IllegalArgumentException If the input value is empty.
+     */
+    public static boolean isBase64(@NotNull String value) {
+        if (value.isBlank()) {
+            throw new IllegalArgumentException(INPUT_VALUE_CANNOT_BE_EMPTY);
+        }
+
+        return value.matches("^[a-zA-Z0-9+/]*={0,2}$");
+    }
+}

src/main/java/io/multiform_validator/CEP.java

@@ -0,0 +1,35 @@
+package io.multiform_validator;
+
+import org.jetbrains.annotations.NotNull;
+
+public class CEP {
+    private CEP() {
+        throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
+    }
+
+    /**
+     * Verifica se um CEP é válido.
+     *
+     * @param cep CEP a ser verificado.
+     * @return true se o CEP é válido, false caso contrário.
+     */
+    public static boolean isCEP(@NotNull String cep) {
+        if (cep.length() < 8 || cep.length() > 10) {
+            return false;
+        }
+
+        final String cepString = cep.replaceAll("\\D", "");
+
+        if (cepString.length() != 8) {
+            return false;
+        }
+
+        try {
+            Integer.parseInt(cepString);
+        } catch (NumberFormatException e) {
+            return false;
+        }
+
+        return true;
+    }
+}

src/main/java/io/multiform_validator/Cnpj.kt

@@ -0,0 +1,67 @@
+package io.multiform_validator
+
+import java.util.*
+
+class Cnpj private constructor() {
+    init {
+        throw IllegalStateException("Utility class")
+    }
+
+    companion object {
+        private const val INPUT_VALUE_CANNOT_BE_EMPTY = "Input value cannot be empty."
+
+        /**
+         * Validate CNPJ
+         *
+         * @param cnpj CNPJ to be validated
+         * @return true if CNPJ is valid, false otherwise
+         */
+        fun isValid(cnpj: String): Boolean {
+            require(!cnpj.isBlank()) { INPUT_VALUE_CANNOT_BE_EMPTY }
+
+            if (cnpj.length != 14 && cnpj.length != 18) {
+                return false
+            }
+
+            try {
+                val cnpjClean = cnpj.replace("\\D".toRegex(), "")
+
+                val cnpjArray = cnpjClean.chars().map { codePoint: Int -> Character.getNumericValue(codePoint) }.toArray()
+
+                val firstVerifier = calculateFirstVerifier(Arrays.copyOfRange(cnpjArray, 0, 12))
+                val secondVerifier = calculateSecondVerifier(Arrays.copyOfRange(cnpjArray, 0, 13), firstVerifier)
+
+                return cnpjArray[12] == firstVerifier && cnpjArray[13] == secondVerifier
+            } catch (e: Exception) {
+                return false
+            }
+        }
+
+        private fun calculateFirstVerifier(cnpjBase: IntArray): Int {
+            var sum = 0
+            val weights = intArrayOf(5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2)
+
+            for (i in 0..11) {
+                sum += cnpjBase[i] * weights[i]
+            }
+
+            val remainder = sum % 11
+
+            return if (remainder < 2) 0 else 11 - remainder
+        }
+
+        private fun calculateSecondVerifier(cnpjBase: IntArray, firstVerifier: Int): Int {
+            var sum = 0
+            val weights = intArrayOf(6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2)
+
+            for (i in 0..12) {
+                sum += cnpjBase[i] * weights[i]
+            }
+
+            sum += firstVerifier * weights[12]
+            val remainder = sum % 11
+
+            return if (remainder < 2) 0 else 11 - remainder
+        }
+    }
+}

src/main/java/io/multiform_validator/Cpf.kt

@@ -0,0 +1,74 @@
+package io.multiform_validator
+
+class Cpf private constructor() {
+    init {
+        throw IllegalStateException("Utility class")
+    }
+
+    companion object {
+        private const val INPUT_VALUE_CANNOT_BE_EMPTY = "Input value cannot be empty."
+
+        /**
+         * Validate a CPF number.
+         *
+         * @param cpf The CPF number to be validated.
+         * @return True if the CPF number is valid, false otherwise.
+         */
+        fun isValid(cpf: String): Boolean {
+            require(!cpf.isBlank()) { INPUT_VALUE_CANNOT_BE_EMPTY }
+
+            try {
+                var baseNumber = 10
+                var baseNumber2 = 11
+
+                var somaTotal = 0
+                var somaTotal2 = 0
+
+                if (cpf.length != 11 && cpf.length != 14) {
+                    return false
+                }
+
+                val cpfClean = cpf.replace("\\D".toRegex(), "")
+
+                if (cpfClean.chars().allMatch { c: Int -> c == cpfClean[0].code }) {
+                    return false
+                }
+
+                var firstVerifier = 0
+                var secondVerifier = 0
+
+                val ninthCharAsInt = cpfClean[9].toString().toInt()
+                val tenthCharAsInt = cpfClean[10].toString().toInt()
+
+                for (repeater in 0..10) {
+                    val currentCharAsInt = cpfClean[repeater].toString().toInt()
+
+                    val multiplicative = currentCharAsInt * baseNumber
+
+                    baseNumber--
+                    somaTotal += multiplicative
+
+                    val multiplicative2 = currentCharAsInt * baseNumber2
+
+                    baseNumber2--
+                    somaTotal2 += multiplicative2
+
+                    val verificationValue = somaTotal - ninthCharAsInt
+                    val verificationValue2 = somaTotal2 - tenthCharAsInt
+                    firstVerifier = 11 - (verificationValue % 11)
+                    secondVerifier = 11 - (verificationValue2 % 11)
+                }
+                if (firstVerifier > 9) {
+                    firstVerifier = 0
+                }
+                if (secondVerifier > 9) {
+                    secondVerifier = 0
+                }
+
+                return firstVerifier == ninthCharAsInt && secondVerifier == tenthCharAsInt
+            } catch (e: Exception) {
+                return false
+            }
+        }
+    }
+}

src/main/java/io/multiform_validator/CreditCard.java

@@ -0,0 +1,86 @@
+package io.multiform_validator;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Pattern;
+import org.jetbrains.annotations.NotNull;
+
+public class CreditCard {
+    private static final String INPUT_VALUE_CANNOT_BE_EMPTY = "Input value cannot be empty.";
+
+    private CreditCard() {
+        throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
+    }
+
+    /**
+     * Validate a credit card number.
+     *
+     * @param cardNumber The credit card number to be validated.
+     * @return True if the credit card number is valid, false otherwise.
+     */
+    public static boolean isCreditCardValid(@NotNull String cardNumber) {
+        if (cardNumber.isBlank()) {
+            throw new IllegalArgumentException(INPUT_VALUE_CANNOT_BE_EMPTY);
+        }
+
+        final String cleanedCreditCardInput = cardNumber.replaceAll("\\D", "");
+
+        if (cleanedCreditCardInput.isBlank() || !Number.isNumber(cleanedCreditCardInput)) {
+            return false;
+        }
+
+        final int[] creditCardDigits =
+                cleanedCreditCardInput.chars().map(Character::getNumericValue).toArray();
+        final int creditCardLength = creditCardDigits.length;
+
+        int sum = 0;
+        boolean isEven = false;
+
+        for (int i = creditCardLength - 1; i >= 0; i--) {
+            int digit = creditCardDigits[i];
+
+            if (isEven) {
+                digit *= 2;
+
+                if (digit > 9) {
+                    digit -= 9;
+                }
+            }
+
+            sum += digit;
+            isEven = !isEven;
+        }
+
+        return sum % 10 == 0;
+    }
+
+    /**
+     * Identify the flag of a credit card.
+     *
+     * @param cardNumber The credit card number to be identified.
+     * @return The flag of the credit card.
+     */
+    public static String identifyFlagCard(@NotNull String cardNumber) {
+        if (cardNumber.isBlank()) {
+            throw new IllegalArgumentException(INPUT_VALUE_CANNOT_BE_EMPTY);
+        }
+
+        Map<String, Pattern> flags = new HashMap<>();
+        flags.put("Visa", Pattern.compile("^4"));
+        flags.put("Mastercard", Pattern.compile("^5[1-5]"));
+        flags.put("American Express", Pattern.compile("^3[47]"));
+        flags.put("Discover", Pattern.compile("^6(?:011|5)"));
+        flags.put("JCB", Pattern.compile("^(?:2131|1800|35\\d{3})"));
+        flags.put("Diners Club", Pattern.compile("^3(?:0[0-5]|[68])"));
+        flags.put("Maestro", Pattern.compile("^(?:5[0678]\\d\\d|6304|6390|67\\d\\d)"));
+        flags.put("UnionPay", Pattern.compile("^(62|88)"));
+        flags.put("Elo", Pattern.compile("^63[789]"));
+        flags.put("Hipercard", Pattern.compile("^(3841|60)"));
+
+        return flags.entrySet().stream()
+                .filter(flag -> flag.getValue().matcher(cardNumber).find())
+                .findFirst()
+                .map(Map.Entry::getKey)
+                .orElse("Unknown");
+    }
+}

src/main/java/io/multiform_validator/Date.java

@@ -0,0 +1,33 @@
+package io.multiform_validator;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.time.format.DateTimeParseException;
+import java.util.regex.Pattern;
+
+public class Date {
+    private static final String INPUT_VALUE_CANNOT_BE_EMPTY = "Input value cannot be empty";
+
+    private Date() {
+        throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
+    }
+
+    /**
+     * Check if the given string is a valid date
+     *
+     * @param date The date string to be validated
+     * @return true if the given string is a valid date, false otherwise
+     */
+    public static boolean isDate(@NotNull String date) {
+        if (date.isBlank()) {
+            throw new IllegalArgumentException(INPUT_VALUE_CANNOT_BE_EMPTY);
+        }
+
+        try {
+            final Pattern dateStringRegex = Pattern.compile("^\\d{4}-\\d{2}-\\d{2}$");
+            return dateStringRegex.matcher(date).matches();
+        } catch (DateTimeParseException e) {
+            return false;
+        }
+    }
+}