Simplify the solution and the asked methods so streams are not used.

Author: josealonso

exercises/concept/tim-from-marketing-2/.classpath

@@ -28,5 +28,5 @@
 	</classpathentry>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-17/"/>
 	<classpathentry kind="con" path="org.eclipse.buildship.core.gradleclasspathcontainer"/>
-	<classpathentry kind="output" path="bin"/>
+	<classpathentry kind="output" path="bin/default"/>
 </classpath>

exercises/concept/tim-from-marketing-2/.docs/instructions.md

@@ -6,6 +6,7 @@ Assume that the ID of the first employee is 0, the ID of the second employee is
 The class constructor receives a parameter of type List<Optional<Employee>>, which is populated in the tests.
 
 ## 1.- Print the names of all the employees
+
 Implement the `printAllEmployeesNames()` method to print the names of all the employees, together with their id. If the employee does not exist, print "[id] - No employee found".
 
 ```java

exercises/concept/tim-from-marketing-2/.docs/introduction.md.tpl

@@ -1,5 +1,3 @@
 # Introduction
 
 %{concept:optional-types}
-
-%{concept:flatMap-operation}

exercises/concept/tim-from-marketing-2/.meta/design.md

@@ -31,12 +31,11 @@ This Concept Exercise's prerequisites Concepts are:
 - `custom classes`.
 - `lists`.
 - `generic-types`.
-- `streams`.
 
 ## Analyzer
 
 This exercise could benefit from the following rules in the [analyzer]:
-- `actionable`: If the solution uses `null` in any method, encourage the student to use `Optional<T>` instead.
+- `essential`: If the solution uses `null` in any method, encourage the student to use `Optional<T>` instead.
 - `actionable`: If the solution uses the `get` or `isPresent` methods of the Optional<T> API, encourage the student to use `orElse`, `orElseThrow` or `ifPresentOrElse` instead. 
 - `informative`: TODO.
 

exercises/concept/tim-from-marketing-2/.meta/src/reference/java/Employee.java

@@ -2,7 +2,7 @@
 import java.util.Optional;
 
 class Employee {
-    private final int id;  
+    private final int id;
     private final String name;
     private final String department;
 
@@ -12,22 +12,24 @@ public Employee(int id, String name, String department) {
         this.department = department;
     }
 
-    public Optional<Integer> getNullableId() {
-        return Optional.ofNullable(id);
+    public int getId() {
+        return id;
     }
 
-    public Optional<String> getNullableName() {
-        return Optional.ofNullable(name);
+    public String getName() {
+        return name;
     }
 
-    public Optional<String> getNullableDepartment() {
-        return Optional.ofNullable(department);
+    public String getDepartment() {
+        return department;
     }
 
     @Override
     public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
         Employee employee = (Employee) o;
         return id == employee.id &&
                 Objects.equals(name, employee.name) && Objects.equals(department, employee.department);

exercises/concept/tim-from-marketing-2/.meta/src/reference/java/EmployeeService.java

@@ -0,0 +1,115 @@
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Optional;
+import java.util.Objects;
+
+public class Main {
+    public static void main(String[] args) {
+        List<Employee> employees = new ArrayList<>();
+        employees.add(new Employee(1, "Tim", "Marketing"));
+        employees.add(new Employee(2, "Joe", "Sales"));
+        employees.add(new Employee(3, "Jane", "IT"));
+        employees.add(new Employee(4, null, null));
+
+        StringBuilder stringBuilder = new StringBuilder();
+        EmployeeService employeeService = new EmployeeService(employees);
+
+        int employeeId = 1;
+        Optional<Employee> employee = employeeService.getEmployeeById(employeeId);
+        employee.ifPresentOrElse(
+                employee1 -> {
+                    Optional.ofNullable(employee1.getName())
+                            .ifPresentOrElse(name -> System.out.println(stringBuilder.append(employeeId).append(" - ")
+                                    .append(employee1.getName()).append(" - ")
+                                    .append(employee1.getDepartment()).toString()), () -> {
+                                        throw new RuntimeException("No employee found for id: " + employeeId);
+                                    });
+                },
+                () -> {
+                    throw new RuntimeException("No employee found for id: " + employeeId);
+                });
+    }
+
+}
+
+class Employee {
+    private final int id;
+    private final String name;
+    private final String department;
+
+    public Employee(int id, String name, String department) {
+        this.id = id;
+        this.name = name;
+        this.department = department;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getDepartment() {
+        return department;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        Employee employee = (Employee) o;
+        return id == employee.id && Objects.equals(name, employee.name)
+                && Objects.equals(department, employee.department);
+    }
+
+    @Override
+    public String toString() {
+        return "Employee{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                ", department='" + department + '\'' +
+                '}';
+    }
+
+}
+
+class EmployeeService {
+
+    // This list is populated in the tests
+    private List<Employee> employeesList = new ArrayList<>();
+
+    public EmployeeService(List<Employee> listOfEmployees) {
+        employeesList = listOfEmployees;
+    }
+
+    public Optional<Employee> getEmployeeById(int employeeId) {
+        for (Employee employee : employeesList) {
+            if (Objects.equals(employee.getId(), employeeId)) {
+                return Optional.of(employee);
+            }
+        }
+        return Optional.empty();
+    }
+
+    /*
+     * public String printEmployeeNameAndDepartmentById(int employeeId) {
+     * Optional<Employee> employee = getEmployeeById(employeeId);
+     * StringBuilder stringBuilder = new StringBuilder();
+     * stringBuilder.append(employeeId).append(" - ");
+     * // Handle Optional values
+     * employee.ifPresentOrElse(
+     * e -> {
+     * e.getNullableName().ifPresent(name -> e.getNullableDepartment()
+     * .ifPresent(department ->
+     * stringBuilder.append(name).append(" - ").append(department)));
+     * },
+     * () -> stringBuilder.append("No employee found"));
+     * return stringBuilder.toString();
+     * }
+     */
+
+}