Subversion Repositories SmartDukaan

Rev

Rev 192 | Blame | Last modification | View Log | RSS feed

package in.shop2020.hotspot.dashbaord.client.inbox;

import java.util.List;

import in.shop2020.hotspot.dashbaord.client.dispatch.DispatcherAsync;
import in.shop2020.hotspot.dashbaord.client.event.AcceptOrderEvent;
import in.shop2020.hotspot.dashbaord.client.event.AcceptOrderEventHandler;
import in.shop2020.hotspot.dashbaord.client.event.AddressLabelEvent;
import in.shop2020.hotspot.dashbaord.client.event.AddressLabelEventHandler;
import in.shop2020.hotspot.dashbaord.client.event.BilledOrderEvent;
import in.shop2020.hotspot.dashbaord.client.event.BilledOrderEventHandler;
import in.shop2020.hotspot.dashbaord.client.event.LoadAcceptedOrderListEvent;
import in.shop2020.hotspot.dashbaord.client.event.LoadAcceptedOrderListEventHandler;
import in.shop2020.hotspot.dashbaord.client.event.LoadAllOrdersListEvent;
import in.shop2020.hotspot.dashbaord.client.event.LoadAllOrdersListEventHandler;
import in.shop2020.hotspot.dashbaord.client.event.LoadBilledOrderListEvent;
import in.shop2020.hotspot.dashbaord.client.event.LoadBilledOrderListEventHandler;
import in.shop2020.hotspot.dashbaord.client.event.LoadOrderDetailsEvent;
import in.shop2020.hotspot.dashbaord.client.event.LoadOrderDetailsEventHandler;
import in.shop2020.hotspot.dashbaord.client.event.LoadOrderListEvent;
import in.shop2020.hotspot.dashbaord.client.event.LoadOrderListEventHandler;
import in.shop2020.hotspot.dashbaord.client.event.LoadShippedOrderListEvent;
import in.shop2020.hotspot.dashbaord.client.event.LoadShippedOrderListEventHandler;
import in.shop2020.hotspot.dashbaord.client.event.RefreshDetailsEvent;
import in.shop2020.hotspot.dashbaord.client.event.RefreshDetailsEventHandler;
import in.shop2020.hotspot.dashbaord.client.event.ShippedOrderEvent;
import in.shop2020.hotspot.dashbaord.client.event.ShippedOrderEventHandler;
import in.shop2020.hotspot.dashbaord.client.event.SignOutEvent;
import in.shop2020.hotspot.dashbaord.client.inbox.InboxPresenter.Display;
import in.shop2020.hotspot.dashbaord.shared.actions.AcceptOrderRequest;
import in.shop2020.hotspot.dashbaord.shared.actions.AcceptOrderResponse;
import in.shop2020.hotspot.dashbaord.shared.actions.AcceptedOrderListRequest;
import in.shop2020.hotspot.dashbaord.shared.actions.AcceptedOrderListResponse;
import in.shop2020.hotspot.dashbaord.shared.actions.AddressRequest;
import in.shop2020.hotspot.dashbaord.shared.actions.AddressResponse;
import in.shop2020.hotspot.dashbaord.shared.actions.AllOrderListRequest;
import in.shop2020.hotspot.dashbaord.shared.actions.AllOrderListResponse;
import in.shop2020.hotspot.dashbaord.shared.actions.BillOrderRequest;
import in.shop2020.hotspot.dashbaord.shared.actions.BillOrderResponse;
import in.shop2020.hotspot.dashbaord.shared.actions.BilledOrderListRequest;
import in.shop2020.hotspot.dashbaord.shared.actions.BilledOrderListResponse;
import in.shop2020.hotspot.dashbaord.shared.actions.DetailsMask;
import in.shop2020.hotspot.dashbaord.shared.actions.Order;
import in.shop2020.hotspot.dashbaord.shared.actions.OrderDetailsRequest;
import in.shop2020.hotspot.dashbaord.shared.actions.OrderDetailsResponse;
import in.shop2020.hotspot.dashbaord.shared.actions.OrderRequest;
import in.shop2020.hotspot.dashbaord.shared.actions.OrderResponse;
import in.shop2020.hotspot.dashbaord.shared.actions.OrderType;
import in.shop2020.hotspot.dashbaord.shared.actions.ShipOrderRequest;
import in.shop2020.hotspot.dashbaord.shared.actions.ShipOrderResponse;
import in.shop2020.hotspot.dashbaord.shared.actions.ShippedOrderListRequest;
import in.shop2020.hotspot.dashbaord.shared.actions.ShippedOrderListResponse;

import net.customware.gwt.dispatch.client.DispatchAsync;

import org.enunes.gwt.mvp.client.EventBus;
import org.enunes.gwt.mvp.client.presenter.BasePresenter;

import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.shared.EventHandler;
import com.google.gwt.event.shared.GwtEvent;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.SplitLayoutPanel;
import com.google.inject.Inject;

public class InboxPresenterImpl extends BasePresenter<InboxPresenter.Display> implements InboxPresenter{
        
        private final DispatchAsync dispatcher;
        private StatusDialog dialog;
        private GwtEvent<?> pollingEvent = null;
        private String user;

        @Inject
        public InboxPresenterImpl(EventBus eventBus, Display display, final DispatchAsync dispatcher) {
                super(eventBus, display);               
                this.dispatcher = dispatcher;
        }

        @Override
        public void initialize() {
                
                dialog = new StatusDialog();
                
                display.getNewOrdersAnchor().addClickHandler(new ClickHandler() {
                        
                        @Override
                        public void onClick(ClickEvent event) {
                                // TODO Auto-generated method stub
                                eventBus.fireEvent(new LoadOrderListEvent());
                                eventBus.fireEvent(new RefreshDetailsEvent());
                        }
                });
                
                display.getSignOutLink().addClickHandler(new ClickHandler() {
                        
                        @Override
                        public void onClick(ClickEvent event) {
                        
                                eventBus.fireEvent(new SignOutEvent());
                                eventBus.fireEvent(new RefreshDetailsEvent());
                        }
                });
                
                display.getAcceptedOrdersAnchor().addClickHandler(new ClickHandler() {
                        
                        @Override
                        public void onClick(ClickEvent event) {
                                
                                eventBus.fireEvent(new LoadAcceptedOrderListEvent());
                                eventBus.fireEvent(new RefreshDetailsEvent());
                        }
                });
                
                display.getBilledOrdersAnchor().addClickHandler(new ClickHandler() {
                        
                        @Override
                        public void onClick(ClickEvent event) {
                                eventBus.fireEvent(new LoadBilledOrderListEvent());
                                eventBus.fireEvent(new RefreshDetailsEvent());
                        }
                });
                
                display.getShippedOrdersAnchor().addClickHandler(new ClickHandler() {
                        
                        @Override
                        public void onClick(ClickEvent event) {
                                eventBus.fireEvent(new LoadShippedOrderListEvent());
                                eventBus.fireEvent(new RefreshDetailsEvent());
                        }
                });
                
                display.getAllOrdersAnchor().addClickHandler(new ClickHandler() {
                        
                        @Override
                        public void onClick(ClickEvent event) {
                                eventBus.fireEvent(new LoadAllOrdersListEvent());
                                eventBus.fireEvent(new RefreshDetailsEvent());
                        }
                });
                
                Timer t = new Timer() {
                        
                        @Override
                        public void run() {
                                if (pollingEvent != null){
                                        eventBus.fireEvent(pollingEvent);
                                }
                                
                        }
                };
                
                t.scheduleRepeating(15000);             
        }

        @Override
        public void refreshOrderList(List<Order> order) {
                display.updateOrderList(new OrderList(eventBus, order));
                
        }
        
        @Override
        public void bind(){
                super.bind();
                registerHandler(eventBus.addHandler(LoadOrderListEvent.getType(), new LoadOrderListEventHandler() {
                        
                        @Override
                        public void onLoadOrderList(LoadOrderListEvent event) {
                                dispatcher.execute(new OrderRequest(OrderType.ALL), new AsyncCallback<OrderResponse>() {

                                        @Override
                                        public void onFailure(Throwable caught) {
                                                // TODO Auto-generated method stub
                                                                                                
                                        }

                                        @Override
                                        public void onSuccess(OrderResponse result) {
                                                // TODO Auto-generated method stub
                                                refreshOrderList(result.getOrders());
                                                pollingEvent = new LoadOrderListEvent();
                                        }
                                });
                        }
                }));
                
                registerHandler(eventBus.addHandler(LoadOrderDetailsEvent.getType(), new LoadOrderDetailsEventHandler() {
                        
                        @Override
                        public void onLoadOrderDetails(final LoadOrderDetailsEvent event) {
                                // TODO Auto-generated method stub
                                dispatcher.execute(new OrderDetailsRequest(event.getOrder().getTransactionId()), new AsyncCallback<OrderDetailsResponse>() {

                                        @Override
                                        public void onFailure(Throwable caught) {
                                                // TODO Auto-generated method stub
                                                int i = 1;
                                                
                                        }

                                        @Override
                                        public void onSuccess(OrderDetailsResponse result) {
                                                // TODO Auto-generated method stub
                                                display.updateOrderDetails(new OrderDetails(eventBus, event.getOrder(), result.getOrder(), result.getMask(), user));
                                        }
                                });
                                //display.updateOrderDetails(new OrderDetails(eventBus, event.getOrder()));
                        }
                }));
                
                registerHandler(eventBus.addHandler(AcceptOrderEvent.getType(), new AcceptOrderEventHandler() {
                        
                        @Override
                        public void onAcceptOrder(AcceptOrderEvent event) {
                                //change status of this order.
                                dispatcher.execute(new AcceptOrderRequest(event.getOrder()), new AsyncCallback<AcceptOrderResponse>() {

                                        @Override
                                        public void onFailure(Throwable caught) {
                                                // TODO Auto-generated method stub
                                                
                                        }

                                        @Override
                                        public void onSuccess(AcceptOrderResponse result) {

                                                if(result == null){
                                                        dialog.setTitle("Could not fetch the value");
                                                        dialog.setText("Looks like server is unable to do anything here");
                                                        dialog.show();
                                                }
                                                
                                                if(result.isStatus()){
                                                        dialog.setTitle("Accepted Order");
                                                        dialog.setText("Order "+ result.getOrder().getTransactionId()+ " was accepted");
                                                        dialog.show();
                                                        eventBus.fireEvent(new LoadAcceptedOrderListEvent());
                                                        eventBus.fireEvent(new LoadOrderDetailsEvent(result.getOrder()));
                                                        //display.updateOrderDetails(new OrderDetails(eventBus, result.getOrder(), result.getOrder(), DetailsMask.ACCEPT, user));
                                                }else {
                                                        dialog.setTitle("Accept Order Failed");
                                                        dialog.setText("Order "+ result.getOrder().getTransactionId()+ " could not be accepted");
                                                        dialog.show();
                                                }
                                        }
                                });
                        }
                }));
                
                registerHandler(eventBus.addHandler(LoadAcceptedOrderListEvent.getType(), new LoadAcceptedOrderListEventHandler() {
                        
                        @Override
                        public void onLoadAcceptOrderList(LoadAcceptedOrderListEvent event) {
                                dispatcher.execute(new AcceptedOrderListRequest(OrderType.ACCEPTED), new AsyncCallback<AcceptedOrderListResponse>() {

                                        @Override
                                        public void onFailure(Throwable caught) {
                                                // TODO Auto-generated method stub
                                                
                                        }

                                        @Override
                                        public void onSuccess(AcceptedOrderListResponse result) {
                                                // TODO Auto-generated method stub
                                                refreshOrderList(result.getOrders());
                                                
                                                pollingEvent = new LoadAcceptedOrderListEvent();
                                        }
                                });
                        }
                }));
                
                registerHandler(eventBus.addHandler(LoadAllOrdersListEvent.getType(), new LoadAllOrdersListEventHandler() {
                        
                        @Override
                        public void onLoadAllOrdersEvent(LoadAllOrdersListEvent event) {
                                // TODO Auto-generated method stub
                                dispatcher.execute(new AllOrderListRequest(OrderType.ALL), new AsyncCallback< AllOrderListResponse >() {

                                        @Override
                                        public void onFailure(Throwable caught) {
                                                // TODO Auto-generated method stub
                                                
                                        }

                                        @Override
                                        public void onSuccess(AllOrderListResponse result) {
                                                // TODO Auto-generated method stub
                                                refreshOrderList(result.getOrders());
                                                pollingEvent = new LoadAllOrdersListEvent();
                                        }
                                });                             
                        }
                }));
                
                registerHandler(eventBus.addHandler(LoadBilledOrderListEvent.getType(), new LoadBilledOrderListEventHandler() {
                        
                        @Override
                        public void onLoadBilledOrderList(LoadBilledOrderListEvent event) {
                                dispatcher.execute(new BilledOrderListRequest(OrderType.BILLED), new AsyncCallback<BilledOrderListResponse>() {
                                
                                        @Override
                                        public void onFailure(Throwable caught) {
                                                // TODO Auto-generated method stub
                                                
                                        }

                                        @Override
                                        public void onSuccess(BilledOrderListResponse result) {
                                                // TODO Auto-generated method stub
                                                refreshOrderList(result.getOrders());
                                                pollingEvent = new LoadBilledOrderListEvent();
                                        }

                        
                                });
                        }
                }));

                registerHandler(eventBus.addHandler(LoadShippedOrderListEvent.getType(), new LoadShippedOrderListEventHandler() {
                        
                        @Override
                        public void onLoadShippedOrderList(LoadShippedOrderListEvent event) {
                                dispatcher.execute(new ShippedOrderListRequest(OrderType.SHIPPED), new AsyncCallback<ShippedOrderListResponse>() {
                                        
                                        @Override
                                        public void onFailure(Throwable caught) {
                                                // TODO Auto-generated method stub
                                                
                                        }

                                        @Override
                                        public void onSuccess(ShippedOrderListResponse result) {
                                                // TODO Auto-generated method stub
                                                refreshOrderList(result.getOrders());
                                                pollingEvent = new LoadShippedOrderListEvent();
                                        }

                        
                                });

                                
                        }
                }));
                
                registerHandler(eventBus.addHandler(AddressLabelEvent.getType(), new AddressLabelEventHandler() {
                        
                        @Override
                        public void onAddressRequest(AddressLabelEvent event) {
                                // TODO Auto-generated method stub
                                dispatcher.execute(new AddressRequest(event.getOrder()), new AsyncCallback<AddressResponse>() {

                                        @Override
                                        public void onFailure(Throwable caught) {
                                                // TODO Auto-generated method stub
                                                
                                        }

                                        @Override
                                        public void onSuccess(AddressResponse result) {
                                                // TODO Auto-generated method stub
                                                AddressWidget adialog = new AddressWidget(result.getAddress());
                                                adialog.center();
                                        }
                                });
                        }
                }));
                
                registerHandler(eventBus.addHandler(ShippedOrderEvent.getType(), new ShippedOrderEventHandler() {
                        
                        @Override
                        public void onShippedOrder(ShippedOrderEvent event) {
                                dispatcher.execute(new ShipOrderRequest(event.getOrder(), event.getAirwayBillNumber(), event.getTracker(), event.getProvider(), event.isInfo()), new AsyncCallback<ShipOrderResponse>() {

                                        @Override
                                        public void onFailure(Throwable caught) {
                                                // TODO Auto-generated method stub
                                                
                                        }

                                        @Override
                                        public void onSuccess(ShipOrderResponse result) {
                                                if(result.isInfo()){
                                                        StatusDialog dialog = new StatusDialog();
                                                        
                                                        dialog.setTitle("Order Shipped");
                                                        dialog.setText("Order shipment status "+ result.isStatus()+"\n"+result.getStatusMessage());
                                                        dialog.center();
                                                        eventBus.fireEvent(new LoadOrderDetailsEvent(result.getOrder()));
                                                }else{
                                                        if(result.isStatus()){
                                                                eventBus.fireEvent(new LoadShippedOrderListEvent());
                                                                eventBus.fireEvent(new LoadOrderDetailsEvent(result.getOrder()));
                                                        }
                                                        else{
                                                                StatusDialog dialog = new StatusDialog();
                                                                
                                                                dialog.setTitle("Order Cannot be shipped");
                                                                dialog.setText("Order shipment status "+ result.isStatus()+"\n"+result.getStatusMessage());
                                                                dialog.center();
                                                        }
                                                }
                                        }
                                });
                                
                        }
                }));
                
                registerHandler(eventBus.addHandler(BilledOrderEvent.getType(), new BilledOrderEventHandler() {
                        
                        @Override
                        public void onBillingOrder(BilledOrderEvent event) {
                                dispatcher.execute(new BillOrderRequest(event.getOrder(), event.getBillNumber(), event.getCreatedBy()), new AsyncCallback<BillOrderResponse>() {

                                        @Override
                                        public void onFailure(Throwable caught) {
                                                // TODO Auto-generated method stub
                                                
                                        }

                                        @Override
                                        public void onSuccess(BillOrderResponse result) {
                                                if (result.isStatus()){
                                                        eventBus.fireEvent(new LoadBilledOrderListEvent());
                                                        eventBus.fireEvent(new LoadOrderDetailsEvent(result.getOrder()));
                                                }else{
                                                        StatusDialog dialog = new StatusDialog();
                                                        
                                                        dialog.setTitle("Order Billing");
                                                        dialog.setText("Order billing status "+ result.isStatus()+"\n"+result.getStatusMessage());
                                                        dialog.center();
                                                        eventBus.fireEvent(new LoadOrderDetailsEvent(result.getOrder()));
                                                }                                               
                                        }
                                });
                                
                        }
                }));
        
                registerHandler(eventBus.addHandler(RefreshDetailsEvent.getType(), new RefreshDetailsEventHandler() {
                        
                        @Override
                        public void onRefresh(RefreshDetailsEvent event) {
                                display.removeDetailsPane();                            
                        }
                }));
        }
        
        public void setUsername(String name){
                this.user = name;
        }
}