add client for EventService and add log() method

services/src/main/java/ch/hepia/event/EventService.java

 package ch.hepia.event;
 
-import java.util.List;
-import java.util.stream.Collectors;
-import java.util.ArrayList;
+import java.util.*;
+
+import javax.jms.Connection;
+import javax.jms.DeliveryMode;
+import javax.jms.Destination;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageListener;
+import javax.jms.MessageProducer;
+import javax.jms.ObjectMessage;
+import javax.jms.Session;
+import javax.jms.TextMessage;
+import javax.lang.model.util.ElementScanner6;
+
+import org.apache.activemq.ActiveMQConnectionFactory;
 
 public class EventService{
     private List<Event> events;
+    private static int ackMode;
+    private static String clientQueueName;
+    private boolean transacted = false;
 
-    public EventService(){
-        this.events = new ArrayList<>();
-    }
+    private Optional<Session> maybeSession;
+    private Optional<MessageProducer> maybeProducer;
 
-    public void add(Event e){
-        this.events.add(e);
+    static {
+        clientQueueName = "client.messages";
+        ackMode = Session.AUTO_ACKNOWLEDGE;
     }
 
-    public List<Event> getCreditRefused(){
-        return getEventsOfThis(EventCreditRefused.class);
-    }
+    public EventService(final String ipBroker){
+        this.events = new ArrayList<>();
+        final String brokerUrl = "tcp://" + ipBroker + ":61616";
 
-    public List<Event> getCreditWithdrawn(){
-        return getEventsOfThis(EventCreditWithdrawn.class);
-    }
+        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(brokerUrl);
+        try {
+            Connection connection = connectionFactory.createConnection();
+            connection.start();
 
-    public List<Event> getOrderCancelled(){
-        return getEventsOfThis(EventOrderCancelled.class);
-    }
+            Session session = connection.createSession(transacted, ackMode);
+            maybeSession = Optional.of(session);
 
-    public List<Event> getOrderCreated(){
-        return getEventsOfThis(EventOrderCreated.class);
-    }
+            Destination mainTopic = session.createTopic(clientQueueName);
 
-    public List<Event> getOrderPlaced(){
-        return getEventsOfThis(EventOrderPlaced.class);
-    }
+            //Setup a message producer to send message to the queue the server is consuming from
+            MessageProducer producer = session.createProducer(mainTopic);
+            producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
+            maybeProducer = Optional.of(producer);
+
+            MessageConsumer responseConsumer = session.createConsumer(mainTopic);
 
-    public List<Event> getOrderPrepared(){
-        return getEventsOfThis(EventOrderPrepared.class);
+            responseConsumer.setMessageListener(new MessageListener() {
+                public void onMessage(Message message) {
+                    try {
+                        if (message instanceof ObjectMessage) {
+                            ObjectMessage objMessage = (ObjectMessage) message;
+                            Object obj = objMessage.getObject();
+                            //------------------------------------------
+                            if (obj instanceof EventAccountCreated){
+                                add((EventAccountCreated) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventAccountCredited){
+                                add((EventAccountCredited) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventAccountDoesntExist){
+                                add((EventAccountDoesntExist) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventAddProductQuantity){
+                                add((EventAddProductQuantity) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventCreateAccount){
+                                add((EventCreateAccount) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventCreateProduct){
+                                add((EventCreateProduct) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventCreditAccepted){
+                                add((EventCreditAccepted) obj);
                             }
+                            //------------------------------------------
+                            if (obj instanceof EventCreditAnAccount){
+                                add((EventCreditAnAccount) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventCreditRefused){
+                                add((EventCreditRefused) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventCreditWithdrawn){
+                                add((EventCreditWithdrawn) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventOrderCancelled){
+                                add((EventOrderCancelled) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventOrderCreated){
+                                add((EventOrderCreated) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventOrderPlaced){
+                                add((EventOrderPlaced) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventOrderPrepared){
+                                add((EventOrderPrepared) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventOrderSent){
+                                add((EventOrderSent) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventProductCreated){
+                                add((EventProductCreated) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventProductDoesntExist){
+                                add((EventProductDoesntExist) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventProductOutOfStock){
+                                add((EventProductOutOfStock) obj);
+                            }
+                            //------------------------------------------
+                            if (obj instanceof EventProductQuantityAdded){
+                                add((EventProductQuantityAdded) obj);
+                            }
+                        }
+                    } catch (JMSException e) {
+                        e.printStackTrace();
+                    }
+                }
+            });
 
-    public List<Event> getOrderSent(){
-        return getEventsOfThis(EventOrderPlaced.class);
+        } catch (JMSException e) {
+            e.printStackTrace();
+        }
     }
     
-    private List<Event> getEventsOfThis(Class c){
-        return this.events.stream().filter(e -> e.getClass().equals(c)).collect(Collectors.toList());
+    private void add(Event e){
+        this.events.add(e);
     }
 
-    public void display(){
-        this.events.stream().forEach(System.out::println);
+    public void log(int id){
+        this.events.stream().filter(e -> e.id() == id).sorted((e1,e2) -> {
+            if(e1.date().before(e2.date()))
+                return -1;
+            else if(e1.date().after(e2.date()))
+                return 1;
+            else
+                return 0;
+        }).forEach(System.out::println);
     }
 }
\ No newline at end of file