src/main/java/at/ac/tuwien/sbc/valesriegler/xvsm/PizzeriaAgentXVSM.java

   1 package at.ac.tuwien.sbc.valesriegler.xvsm;
   2
   3 import java.io.Serializable;
   4 import java.util.Arrays;
   5 import java.util.List;
   6
   7 import javax.swing.SwingUtilities;
   8
   9 import at.ac.tuwien.sbc.valesriegler.common.OrderId;
  10 import org.mozartspaces.core.MzsConstants.RequestTimeout;
  11 import org.mozartspaces.notifications.Notification;
  12 import org.mozartspaces.notifications.NotificationListener;
  13 import org.mozartspaces.notifications.Operation;
  14 import org.slf4j.Logger;
  15 import org.slf4j.LoggerFactory;
  16
  17 import at.ac.tuwien.sbc.valesriegler.common.Util;
  18 import at.ac.tuwien.sbc.valesriegler.pizzeria.PizzeriaAgent;
  19 import at.ac.tuwien.sbc.valesriegler.types.GroupData;
  20 import at.ac.tuwien.sbc.valesriegler.types.Pizza;
  21 import at.ac.tuwien.sbc.valesriegler.types.PizzaOrder;
  22 import at.ac.tuwien.sbc.valesriegler.types.Table;
  23
  24 public class PizzeriaAgentXVSM extends AbstractXVSMConnector {
  25         private static final Logger log = LoggerFactory.getLogger(PizzeriaAgentXVSM.class);
  26
  27         public PizzeriaAgentXVSM(int port) {
  28                 super(port);
  29                 tableAssignedContainer = useContainer(Util.TABLE_ASSIGNED) ;
  30                 freeTablesContainer = useContainer(Util.FREE_TABLES);
  31                 pizzaInProgressContainer = useContainer(Util.PIZZAS_IN_PROGRESS) ;
  32                 orderCompleteContainer = useContainer(Util.ORDER_COMPLETE) ;
  33                 deliverPizzasContainer = useContainer(Util.DELIVER_PIZZAS);
  34                 paymentDoneContainer = useContainer(Util.PAYMENT_DONE) ;
  35                 orderTakenContainer = useContainer(Util.ORDER_TAKEN);
  36                 assignTableContainer = useContainer(Util.ASSIGN_TABLE);
  37         pizzeriaInfoContainer = useContainer(Util.PIZZERIA_INFO);
  38         }
  39
  40         public void listenForOccupiedTables() {
  41                 NotificationListener tablesListener = new NotificationListener() {
  42             @Override
  43             public void entryOperationFinished(final Notification notification, final Operation operation, final List<? extends Serializable> entries) {
  44                 log.info("A new group was assigned to a table!");
  45
  46                 final List<Table> tables = castEntries(entries);
  47
  48                 if(tables.size() != 1) {
  49                         throw new RuntimeException("Only one table can get free at once!");
  50                 }
  51                 final Table table = tables.get(0);
  52
  53                 SwingUtilities.invokeLater(new Runnable() {
  54                                         @Override
  55                                         public void run() {
  56                                                 PizzeriaAgent.getInstance().getTablesModel().addItems(Arrays.asList(table));
  57                                                 PizzeriaAgent.getInstance().getGroupModel().removeGroup(table.getGroupId());
  58                                         }
  59                                 });
  60             }
  61         };
  62         try {
  63                 notificationMgr.createNotification(tableAssignedContainer, tablesListener, Operation.WRITE);
  64                 log.info("Created tableAssigned notification for pizzeria!");
  65         } catch (Exception e) {
  66             handleSpaceErrorAndTerminate(e);
  67         }
  68         }
  69
  70         public void listenForFreeTables() {
  71                 NotificationListener tablesListener = new NotificationListener() {
  72             @Override
  73             public void entryOperationFinished(final Notification notification, final Operation operation, final List<? extends Serializable> entries) {
  74                 log.info("A table has become free");
  75
  76                 final List<Table> tables = castEntries(entries);
  77
  78                 SwingUtilities.invokeLater(new Runnable() {
  79                                         @Override
  80                                         public void run() {
  81                                                 PizzeriaAgent.getInstance().getTablesModel().addItems(tables);
  82                                         }
  83                                 });
  84             }
  85         };
  86         try {
  87                 notificationMgr.createNotification(freeTablesContainer, tablesListener, Operation.WRITE);
  88         } catch (Exception e) {
  89             handleSpaceErrorAndTerminate(e);
  90         }
  91         }
  92
  93         public void listenForWaitingGroups() {
  94
  95         NotificationListener groupsListener = new NotificationListener() {
  96             @Override
  97             public void entryOperationFinished(final Notification notification, final Operation operation, final List<? extends Serializable> entries) {
  98                 final List<GroupData> groups = castEntries(entries);
  99
 100                 SwingUtilities.invokeLater(new Runnable() {
 101                                         @Override
 102                                         public void run() {
 103                                                 PizzeriaAgent.getInstance().getGroupModel().addItems(groups);
 104                                         }
 105                                 });
 106
 107             }
 108         };
 109           try {
 110                 notificationMgr.createNotification(assignTableContainer, groupsListener, Operation.WRITE);
 111         } catch (Exception e) {
 112            handleSpaceErrorAndTerminate(e);
 113         }
 114         }
 115
 116 public void listenForTakenOrders() {
 117
 118         NotificationListener orderTakenListener = new NotificationListener() {
 119             @Override
 120             public void entryOperationFinished(final Notification notification, final Operation operation, final List<? extends Serializable> entries) {
 121                 final List<GroupData> groups = castEntries(entries);
 122
 123                 if(groups.size() != 1) {
 124                         throw new RuntimeException("Only one order per table!");
 125                 }
 126                 final GroupData group = groups.get(0);
 127
 128                 SwingUtilities.invokeLater(new Runnable() {
 129                                         @Override
 130                                         public void run() {
 131                                                 PizzeriaAgent.getInstance().getOrdersModel().addItems(Arrays.asList(group));
 132                                         }
 133                                 });
 134
 135             }
 136         };
 137           try {
 138                 notificationMgr.createNotification(orderTakenContainer, orderTakenListener, Operation.WRITE);
 139         } catch (Exception e) {
 140            handleSpaceErrorAndTerminate(e);
 141         }
 142         }
 143
 144         public void listenForPizzasInPreparation() {
 145                 NotificationListener pizzasInProgress = new NotificationListener() {
 146             @Override
 147             public void entryOperationFinished(final Notification notification, final Operation operation, final List<? extends Serializable> entries) {
 148                 final List<Pizza> pizzas = castEntries(entries);
 149
 150                 log.info("{} pizzas in progress changes!", pizzas.size());
 151                 for (PizzaOrder pizza : pizzas) {
 152                         log.info(pizza.toString());
 153                                 }
 154
 155                 SwingUtilities.invokeLater(new Runnable() {
 156                                         @Override
 157                                         public void run() {
 158                                                 PizzeriaAgent.getInstance().getOrdersModel().updatePizzasInPreparation(pizzas);
 159                                         }
 160                                 });
 161
 162             }
 163         };
 164           try {
 165                 notificationMgr.createNotification(pizzaInProgressContainer, pizzasInProgress, Operation.WRITE);
 166         } catch (Exception e) {
 167            handleSpaceErrorAndTerminate(e);
 168         }
 169         }
 170
 171         public void listenForDeliveredOrders() {
 172                 NotificationListener deliveredOrders = new NotificationListener() {
 173             @Override
 174             public void entryOperationFinished(final Notification notification, final Operation operation, final List<? extends Serializable> entries) {
 175                 final List<GroupData> groups = castEntries(entries);
 176
 177                 log.info("{} order was delivered!", groups.size());
 178                 if(groups.size() != 1) {
 179                         throw new RuntimeException("A waiter should only deliver one order at once!");
 180                 }
 181                 final GroupData group = groups.get(0);
 182
 183                 SwingUtilities.invokeLater(new Runnable() {
 184                                         @Override
 185                                         public void run() {
 186                                                 PizzeriaAgent.getInstance().getOrdersModel().updateStatusOfOrder(group);
 187                                         }
 188                                 });
 189
 190             }
 191         };
 192           try {
 193                 notificationMgr.createNotification(orderCompleteContainer, deliveredOrders, Operation.WRITE);
 194         } catch (Exception e) {
 195            handleSpaceErrorAndTerminate(e);
 196         }
 197         }
 198
 199         public void listenForPreparedPizzas() {
 200                 NotificationListener preparedPizzasListener = new NotificationListener() {
 201             @Override
 202             public void entryOperationFinished(final Notification notification, final Operation operation, final List<? extends Serializable> entries) {
 203
 204                List<Pizza> pizzas = castEntries(entries);
 205                if(pizzas.size() != 1) throw new RuntimeException("Multiple pizzas in one notification?! That should not happen! A cook can only prepare one at the same time!");
 206
 207                final Pizza pizza = pizzas.get(0);
 208
 209                SwingUtilities.invokeLater(new Runnable() {
 210                                         @Override
 211                                         public void run() {
 212                                                 PizzeriaAgent.getInstance().getOrdersModel().updateStatusOfPizzasDone(pizza);
 213                                         }
 214                         });
 215
 216             }
 217                 };
 218
 219         try {
 220                         notificationMgr.createNotification(deliverPizzasContainer, preparedPizzasListener, Operation.WRITE);
 221                         log.info("Created deliverPizzasContainer notification for the pizzeria");
 222                 } catch (Exception e) {
 223                         handleSpaceErrorAndTerminate(e);
 224                 }
 225         }
 226
 227         public void listenForPayment() {
 228                 NotificationListener isGoneListener = new NotificationListener() {
 229             @Override
 230             public void entryOperationFinished(final Notification notification, final Operation operation, final List<? extends Serializable> entries) {
 231                 final List<GroupData> groups = castEntries(entries);
 232
 233                 final GroupData group = groups.get(0);
 234                 log.info("Group {} is gone", group.getId());
 235
 236                 final int tableId = PizzeriaAgent.getInstance().getTablesModel().getTableIdOfGroup(group);
 237                 SwingUtilities.invokeLater(new Runnable() {
 238
 239                                         @Override
 240                                         public void run() {
 241                                                 PizzeriaAgent.getInstance().getOrdersModel().updatePaymentWaiter(group);
 242                                                 PizzeriaAgent.getInstance().getTablesModel().makeTableFree(tableId);
 243                                         }
 244                                 });
 245
 246                                 Table table = new Table(tableId);
 247
 248                                 sendItemsToContainer(Arrays.asList(table), freeTablesContainer, RequestTimeout.DEFAULT, null);
 249             }
 250         };
 251           try {
 252                 notificationMgr.createNotification(paymentDoneContainer, isGoneListener, Operation.WRITE);
 253         } catch (Exception e) {
 254            handleSpaceErrorAndTerminate(e);
 255         }
 256         }
 257
 258         public void sendFreeTablesToContainer(List<Table> tables) {
 259                 sendItemsToContainer(tables, freeTablesContainer, RequestTimeout.DEFAULT, null);
 260         }
 261
 262
 263     public void initializeOrderId() {
 264         sendItemsToContainer(Arrays.asList(new OrderId(0)), pizzeriaInfoContainer, RequestTimeout.DEFAULT, null);
 265     }
 266
 267     public void notifyGroupAgent() {
 268         sendItemsToContainer(Arrays.asList(new PizzeriaRegistration(port)), useContainerOfSpaceWithPort(Util.GROUP_AGENT_INFO, Util.GROUP_AGENT_PORT), RequestTimeout.DEFAULT, null);
 269     }
 270 }