Woody Woodpécore

.gitignore

@@ -1,3 +1,4 @@
 /.idea/
 /target/
 /tags
+

README.md

@@ -0,0 +1,17 @@
+# Woody Woodpécore
+
+* Jean-Philippe Bourdais
+* Sonny Chaprier
+* Maxence Deschamps
+* Robin Oger
+
+## Ficher output.csv
+Le fichier nettoie les données et enlève les doublons
+des volontaires qui ont complétement les mêmes données ou
+par rapport aux données des emails et des téléphones.
+
+## Fichier outputUnique.csv
+Le fichier reprend les même données du fichier output.csv et en
+plus pour tous les volontaires qui ont le même prénom, le même
+nom et le même pseudo les données des emails et des téléphones
+sont concaténées si elles sont différentes.

pom.xml

@@ -20,6 +20,12 @@
             <version>5.8.2</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.testng</groupId>
+            <artifactId>testng</artifactId>
+            <version>RELEASE</version>
+            <scope>compile</scope>
+        </dependency>
     </dependencies>
 
     <build>

src/main/java/App.java

@@ -25,10 +25,23 @@ public static void main(String[] args) throws IOException {
             .map(tokens -> new Volunteer(tokens.get(0), tokens.get(1), tokens.get(2), tokens.get(3), tokens.get(4)))
             .collect(toList());
 
-        List<Volunteer> outputVolunteers = Cleaner.cleanUp(inputVolunteers);
+        List<Volunteer> inputVolunteersForUnique = Files.readAllLines(Paths.get(args[0])).stream()
+                .map(string -> Arrays.stream(string.split(";", -1))
+                        .map(token -> quotes.matcher(token).replaceAll("$1"))
+                        .collect(toList()))
+                .map(tokens -> new Volunteer(tokens.get(0), tokens.get(1), tokens.get(2), tokens.get(3), tokens.get(4)))
+                .collect(toList());
 
+        List<Volunteer> outputVolunteers = Cleaner.cleanUp(inputVolunteers);
+        List<Volunteer> outputVolunteersUnique = Cleaner.cleanUpUniqueContact(inputVolunteersForUnique);
+        System.out.println(outputVolunteers);
+        System.out.println(outputVolunteersUnique);
         PrintWriter writer = new PrintWriter(new FileWriter("src/main/resources/output.csv"));
+        PrintWriter writerUnique = new PrintWriter(new FileWriter("src/main/resources/outputUnique.csv"));
+
         outputVolunteers.forEach(writer::println);
+        outputVolunteersUnique.forEach(writerUnique::println);
         writer.close();
+        writerUnique.close();
     }
 }

src/main/java/org/example/volunteers/Cleaner.java

@@ -4,9 +4,81 @@
 import java.util.List;
 
 public class Cleaner {
+    private static final String[][] UMLAUT_REPLACEMENTS = { { "É", "E" }, { "é", "e" }, { "È", "E" }, { "è", "e" } };
+
     public static List<Volunteer> cleanUp(List<Volunteer> volunteers) {
-        // This function should contain your dark magic.
-        // For now, it simply returns a copy of the initial list.
-        return new ArrayList<>(volunteers);
+        volunteers = removeAccents(volunteers);
+        volunteers = sanitizeEmailInsteadOfPhone(volunteers);
+        volunteers = Email.cleanupMailAddresses(volunteers);
+        volunteers = Phone.cleanupPhoneNumber(volunteers);
+        volunteers = updateCaseInNames(volunteers);
+        volunteers = Duplicate.removeDuplicateFirstNameLastNamePseudoMailPhone(volunteers);
+        volunteers = Duplicate.removeDuplicateMailPhone(volunteers);
+        return new ArrayList<Volunteer>(volunteers);
+    }
+    public static List<Volunteer> cleanUpUniqueContact(List<Volunteer> volunteers) {
+        volunteers = removeAccents(volunteers);
+        volunteers = sanitizeEmailInsteadOfPhone(volunteers);
+        volunteers = Email.cleanupMailAddresses(volunteers);
+        volunteers = Phone.cleanupPhoneNumber(volunteers);
+        volunteers = updateCaseInNames(volunteers);
+        volunteers = Duplicate.removeDuplicateFirstNameLastNamePseudoMailPhone(volunteers);
+        volunteers = Duplicate.concatDuplicateMailPhone(volunteers);
+        return new ArrayList<Volunteer>(volunteers);
+    }
+
+    public static List<Volunteer> removeAccents(List<Volunteer> volunteers) {
+        List<Volunteer> cleanedVolunteers = new ArrayList<>();
+
+        for (Volunteer volunteer: volunteers) {
+            String firstName = volunteer.firstName;
+            String lastName = volunteer.lastName;
+            String nickName = volunteer.nickName;
+
+            for (String[] umlautReplacement : UMLAUT_REPLACEMENTS) {
+                firstName = firstName.replaceAll(umlautReplacement[0], umlautReplacement[1]);
+                lastName = lastName.replaceAll(umlautReplacement[0], umlautReplacement[1]);
+                nickName = nickName.replaceAll(umlautReplacement[0], umlautReplacement[1]);
+            }
+
+            cleanedVolunteers.add(new Volunteer(firstName, lastName, nickName, volunteer.eMail, volunteer.phone));
+        }
+
+        return cleanedVolunteers;
+    }
+
+    public static List<Volunteer> sanitizeEmailInsteadOfPhone(List<Volunteer> volunteers) {
+        for (Volunteer volunteer: volunteers) {
+            if (Phone.isValidPhoneNumber(volunteer.eMail)) {
+                String oldMailHasPhone = volunteer.eMail;
+                String oldPhoneHasMail = volunteer.phone;
+                volunteer.phone = oldMailHasPhone;
+                volunteer.eMail = oldPhoneHasMail;
+            }
+        }
+
+        return volunteers;
+    }
+
+    public static List<Volunteer> updateCaseInNames(List<Volunteer> volunteers) {
+        List<Volunteer> cleanedVolunteers = new ArrayList<>();
+
+        List<String> characters = new ArrayList<>();
+
+        for (Volunteer volunteer: volunteers) {
+            String cleanedVolunteerFirstName = volunteer.firstName.length() > 1
+                    ? volunteer.firstName.substring(0, 1).toUpperCase() + volunteer.firstName.substring(1).toLowerCase()
+                    : volunteer.firstName.toLowerCase();
+
+            String cleanedVolunteerLastName = volunteer.lastName.length() > 1
+                    ? volunteer.lastName.substring(0, 1).toUpperCase() + volunteer.lastName.substring(1).toLowerCase()
+                    : volunteer.lastName.toLowerCase();
+
+            String cleanedVolunteerNickName = volunteer.nickName.toLowerCase();
+
+            cleanedVolunteers.add(new Volunteer(cleanedVolunteerFirstName, cleanedVolunteerLastName, cleanedVolunteerNickName, volunteer.eMail, volunteer.phone));
+        }
+
+        return cleanedVolunteers;
     }
 }

src/main/java/org/example/volunteers/Duplicate.java

@@ -0,0 +1,66 @@
+package org.example.volunteers;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class Duplicate {
+    public static List<Volunteer> removeDuplicateFirstNameLastNamePseudoMailPhone(List<Volunteer> volunteers) {
+        List<Volunteer> uniqueVolunteers = new ArrayList<>();
+        LinkedHashSet<String> linkedsetVolunteers = new LinkedHashSet<String>();
+
+        for (Volunteer volunteer: volunteers) {
+            Volunteer reversedVolunteer = new Volunteer(volunteer.lastName, volunteer.firstName, volunteer.nickName, volunteer.eMail, volunteer.phone);
+            if(!(linkedsetVolunteers.contains(volunteer.toString()) || linkedsetVolunteers.contains(reversedVolunteer.toString()))) {
+                linkedsetVolunteers.add(volunteer.toString());
+                uniqueVolunteers.add(volunteer);
+            }
+        }
+
+        return uniqueVolunteers;
+    }
+
+    public static List<Volunteer> removeDuplicateMailPhone(List<Volunteer> volunteers) {
+        List<Volunteer> uniqueVolunteers = new ArrayList<>();
+        LinkedHashSet<String> linkedsetVolunteers = new LinkedHashSet<String>();
+
+        for (Volunteer volunteer: volunteers) {
+            String volunteerStringTest = volunteer.eMail + ";" + volunteer.phone;
+
+            if (!linkedsetVolunteers.contains(volunteerStringTest)) {
+                linkedsetVolunteers.add(volunteerStringTest);
+                uniqueVolunteers.add(volunteer);
+            }
+        }
+
+        return uniqueVolunteers;
+    }
+
+    public static List<Volunteer> concatDuplicateMailPhone(List<Volunteer> volunteers) {
+        List<Volunteer> uniqueVolunteers = new ArrayList<>();
+
+        for (Volunteer volunteer: volunteers) {
+            List<Volunteer> findedVolunteers = uniqueVolunteers.stream().filter(
+                (Volunteer v) -> (Objects.equals(v.firstName, volunteer.firstName)
+                            && Objects.equals(v.lastName, volunteer.lastName)
+                            && Objects.equals(v.nickName, volunteer.nickName))
+            ).collect(Collectors.toList());
+
+            if (findedVolunteers.size() == 0) {
+                uniqueVolunteers.add(volunteer);
+            } else {
+                Volunteer volunteerConcact = findedVolunteers.get(0);
+                if (!volunteerConcact.eMail.contains(volunteer.eMail) && !volunteerConcact.eMail.isEmpty()) {
+                    volunteerConcact.setEMail(volunteerConcact.eMail + "," + volunteer.eMail);
+                }
+                if (!volunteerConcact.phone.contains(volunteer.phone) && !volunteerConcact.phone.isEmpty()) {
+                    volunteerConcact.setPhone(volunteerConcact.phone + "," + volunteer.phone);
+                }
+            }
+        }
+
+        return uniqueVolunteers;
+    }
+}

src/main/java/org/example/volunteers/Email.java

@@ -0,0 +1,46 @@
+package org.example.volunteers;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+public class Email {
+    public static Boolean isValidEmail(String email) {
+        return Pattern.matches("^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$", email);
+    }
+
+    public static String cleanEmailAddress(String email) {
+        email = email.toLowerCase();
+        email = email.replaceAll("é", "e");
+        email = email.replaceAll("è", "e");
+        email = email.replaceAll("ê", "e");
+        email = email.replaceAll("œ", "oe");
+        email = email.replaceAll("ë", "e");
+        email = email.replaceAll("à", "a");
+        email = email.replaceAll("ä", "a");
+        email = email.replaceAll("â", "a");
+        email = email.replaceAll("î", "i");
+        email = email.replaceAll("ï", "i");
+        email = email.replaceAll("ì", "i");
+        email = email.replaceAll("û", "u");
+        email = email.replaceAll("ù", "u");
+        email = email.replaceAll("ü", "u");
+        email = email.replaceAll("ô", "o");
+        email = email.replaceAll("ò", "o");
+        email = email.replaceAll("ö", "o");
+        return email;
+    }
+
+    public static List<Volunteer> cleanupMailAddresses(List<Volunteer> volunteers) {
+        List<Volunteer> cleanedVolunteers = new ArrayList<>();
+        for(Volunteer volunteer: volunteers) {
+            String cleanEmail = "";
+            String sanitizedEmail = cleanEmailAddress(volunteer.eMail);
+            if (isValidEmail(sanitizedEmail)) {
+                cleanEmail = sanitizedEmail;
+            }
+            cleanedVolunteers.add(new Volunteer(volunteer.firstName, volunteer.lastName, volunteer.nickName, cleanEmail, volunteer.phone));
+        }
+        return cleanedVolunteers;
+    }
+}

src/main/java/org/example/volunteers/Phone.java

@@ -0,0 +1,47 @@
+package org.example.volunteers;
+
+import java.util.regex.Pattern;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class Phone {
+
+    // Phone
+    public static List<Volunteer> cleanupPhoneNumber(List<Volunteer> volunteers) {
+        List<Volunteer> cleanedVolunteers = new ArrayList<>();
+        for(Volunteer volunteer: volunteers) {
+            String cleanPhoneNumber = "";
+            String sanitizedPhoneNumber = cleanPhoneNumber(volunteer.phone);
+            if (isValidPhoneNumber(sanitizedPhoneNumber)) {
+                cleanPhoneNumber = sanitizedPhoneNumber;
+            }
+            cleanedVolunteers.add(new Volunteer(volunteer.firstName, volunteer.lastName, volunteer.nickName, volunteer.eMail, cleanPhoneNumber));
+        }
+        return cleanedVolunteers;
+    }
+
+    public static Boolean isValidPhoneNumber(String phoneNumber) {
+        return Pattern.matches("^[\\+][1-9][0-9]?[0-9]?[0-9]{9}$", phoneNumber);
+    }
+
+    public static String cleanPhoneNumber(String phoneNumber) {
+        // Remove Characters
+        phoneNumber = phoneNumber.replace("-", "");
+        phoneNumber = phoneNumber.replace(".", "");
+        phoneNumber = phoneNumber.replace(" ", "");
+        phoneNumber = phoneNumber.replace("(0)", "");
+        phoneNumber = phoneNumber.replace("(", "").replace(")", "");
+
+        // Change Beginning and add default country code
+        if (phoneNumber.length() == 10) {
+            if (phoneNumber.charAt(0) == '0') {
+                phoneNumber = phoneNumber.replaceFirst("0", "+33");
+            }
+        } else if (phoneNumber.length() == 9 && phoneNumber.charAt(0) != '+') {
+            phoneNumber = "+33" + phoneNumber;
+        }
+        return phoneNumber;
+    }
+}

src/main/java/org/example/volunteers/Volunteer.java

@@ -8,8 +8,17 @@ public final class Volunteer {
     public final String firstName;
     public final String lastName;
     public final String nickName;
-    public final String eMail;
-    public final String phone;
+
+    public void setEMail(String eMail) {
+        this.eMail = eMail;
+    }
+
+    public void setPhone(String phone) {
+        this.phone = phone;
+    }
+
+    public String eMail;
+    public String phone;
 
     public Volunteer(
         String firstName,