StockService.java

package ch.hepia.stock;

import ch.hepia.account.*;
import ch.hepia.event.*;
import ch.hepia.order.*;

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 org.apache.activemq.ActiveMQConnectionFactory;

public class StockService {
    private StockDatabase stockDB;
    private ProductDatabase productsDB;
    private static int ackMode;
    private static String clientQueueName;
    private boolean transacted = false;

    private Optional<Session> maybeSession;
    private Optional<MessageProducer> maybeProducer;

    static {
        clientQueueName = "client.messages";
        ackMode = Session.AUTO_ACKNOWLEDGE;
    }

    public StockService(final String ipBroker) {
        this.stockDB = new StockDatabase();
        this.productsDB = new ProductDatabase();
        final String brokerUrl = "tcp://" + ipBroker + ":61616";

        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(brokerUrl);
        try {
            Connection connection = connectionFactory.createConnection();
            connection.start();

            Session session = connection.createSession(transacted, ackMode);
            maybeSession = Optional.of(session);

            Destination mainTopic = session.createTopic(clientQueueName);

            // 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);

            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 EventCreateProduct) {
                                EventCreateProduct e = (EventCreateProduct) obj;
                                int idProduct = productsDB.nextID();
                                productsDB.addProduct(new Product(idProduct, e.name(), e.price())); // ajout dans la bdd
                                // des produits
                                stockDB.addQuantity(idProduct, 0); // ajout au stock avec quantité 0
                                send(new EventProductCreated(e.id(), "The product is created"));
                                System.out.println(e.toString());
                                // productsDB.database.forEach(i -> System.out.println(i.name() + i.price()));
                            }
                            // ------------------------------------------
                            if (obj instanceof EventProductDoesntExist) {
                                EventProductDoesntExist e = (EventProductDoesntExist) obj;
                                System.out.println(e.toString());
                                send(new EventOrderCancelled(e.id(), "Products in order don't exist"));
                            }
                            // ------------------------------------------
                            if (obj instanceof EventProductCreated) {
                                EventProductCreated e = (EventProductCreated) obj;
                                System.out.println(e.toString());
                            }
                            // ------------------------------------------
                            if (obj instanceof EventAddProductQuantity) {
                                EventAddProductQuantity e = (EventAddProductQuantity) obj;
                                stockDB.addQuantity(e.idProduct(), e.quantity());
                                send(new EventProductQuantityAdded(e.id(), "Quantity added to the stock"));
                                System.out.println(e.toString());
                            }

                            if(obj instanceof EventProductQuantityAdded){
                                EventProductQuantityAdded e = (EventProductQuantityAdded) obj;
                                System.out.println(e.toString());
                            }

                            // ------------------------------------------
                            if (obj instanceof EventOrderCreated) {
                                EventOrderCreated e = (EventOrderCreated) obj;
                                if (productsDB.doProductsExist(e.products())) {
                                    double price = stockDB.getTotalPrice(e.products(), productsDB);
                                    send(new EventOrderPlaced(e.id(), "Order is placed", e.idAccount(), e.products(),
                                            price));
                                } else {
                                    send(new EventProductDoesntExist(e.id(), "Product doesn't exist"));
                                }
                            }
                            // ------------------------------------------
                            if (obj instanceof EventCreditAccepted) {
                                EventCreditAccepted e = (EventCreditAccepted) obj;
                                if (stockDB.removeQuantityOfProducts(e.products())) // s'il y assez de produits
                                    send(new EventOrderPrepared(e.id(), "Order is prepared", e.idAccount(), e.price()));
                                else
                                    send(new EventProductOutOfStock(e.id(), "We are out of stock"));
                                System.out.println(e.toString());

                            }
                        }
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }
            });
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }

    public void send(Event event) {
        maybeProducer.ifPresent(p -> maybeSession.ifPresent(s -> {
            try {
                ObjectMessage obj = s.createObjectMessage(event);
                p.send(obj);
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }));
    }
}