Subversion Repositories SmartDukaan

package in.shop2020.catalog.dashboard.client;

import in.shop2020.catalog.dashboard.shared.Item;
import in.shop2020.catalog.dashboard.shared.Utils;

import com.google.gwt.core.client.GWT;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.uibinder.client.UiBinder;
import com.google.gwt.uibinder.client.UiField;
import com.google.gwt.uibinder.client.UiHandler;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.ResizeComposite;
import com.google.gwt.user.client.ui.Widget;

public class ItemActions extends ResizeComposite{

    interface ItemActionsUiBinder extends UiBinder<Widget, ItemActions> {}
    private static ItemActionsUiBinder uiBinder = GWT.create(ItemActionsUiBinder.class);
    private final CatalogServiceAsync catalogService = GWT.create(CatalogService.class);
    
    private ItemDetails itemDetails;
    
    @UiField Button addItem, updateItem, phaseoutItem, activateItem, markAliveItem, pauseItem;
    
    public ItemActions(){
        initWidget(uiBinder.createAndBindUi(this));
    }
    
    @UiHandler("updateItem")
    void updateItem(ClickEvent event) {
        itemDetails.updateItem();
    }
    
    @UiHandler("addItem")
    void addItem(ClickEvent event) {
        ItemForm itemForm = new ItemForm();
        itemForm.center();
        itemForm.show();
    }
    
    @UiHandler("phaseoutItem")
    void phaseoutItem(ClickEvent event) {
        final long itemId = validateStatusChange(Utils.PHASED_OUT);
        if(itemId <= 0) {
            return;
        }
        catalogService.phaseoutItem(itemId, new AsyncCallback<Void>() {
            @Override
            public void onSuccess(Void result) {
                Window.alert("Item marked as PHASED OUT");
            }
            @Override
            public void onFailure(Throwable caught) {
                Window.alert("Error while marking item " + itemId + " PHASED OUT");
            }
        });
    }
    
    @UiHandler("activateItem")
    void activateItem(ClickEvent event) {
        final long itemId = validateStatusChange(Utils.ACTIVE);
        if(itemId <= 0) {
            return;
        }
        catalogService.activateItem(itemId, new AsyncCallback<Void>() {
            @Override
            public void onSuccess(Void result) {
                Window.alert("Item marked as ACTIVE");
            }
            @Override
            public void onFailure(Throwable caught) {
                Window.alert("Error while marking item " + itemId + " ACTIVE");
            }
        });
    }

    @UiHandler("pauseItem")
    void pauseItem(ClickEvent event) {
        final long itemId = validateStatusChange(Utils.PAUSED);
        if(itemId <= 0) {
            return;
        }
        catalogService.pauseItem(itemId, new AsyncCallback<Void>() {
            @Override
            public void onSuccess(Void result) {
                Window.alert("Item marked as PAUSED");
            }
            @Override
            public void onFailure(Throwable caught) {
                Window.alert("Error while marking item " + itemId + " PAUSED");
            }
        });
    }
    
    @UiHandler("markAliveItem")
    void markAsAlive(ClickEvent event) {
        final long itemId = validateStatusChange(Utils.IN_PROCESS);
        if(itemId <= 0) {
            return;
        }
        catalogService.markInProcess(itemId, new AsyncCallback<Void>() {
            @Override
            public void onSuccess(Void result) {
                Window.alert("Item marked as IN PROCESS");
            }
            @Override
            public void onFailure(Throwable caught) {
                Window.alert("Error while marking item " + itemId + " IN PROCESS");
            }
        });
    }
    
    public void setItemDetails(ItemDetails itemDetails) {
        this.itemDetails = itemDetails;
    }
    
    private long validateStatusChange(int toStatus) {
        final Item item = itemDetails.getItem();
        if(item == null) {
            Window.alert(getAlertString(toStatus)[0]);
            return -1;
        }
        if(!Utils.validateStatusChange(item.getItemStatusValue(), toStatus)) {
            Window.alert(getAlertString(toStatus)[1]);
            return -1;
        }
        return item.getId();
    }
    
    private String[] getAlertString(int toStatus) {
        String[] alertStr = {"", ""};
        switch(toStatus) {
        case Utils.PAUSED: {
            alertStr[0] = "Please select an ACTIVE item to mark PAUSED";
            alertStr[1] = "Cannot mark this item as PAUSED";
            break;
        }
        case Utils.IN_PROCESS: {
            alertStr[0] = "Please select a PHASED OUT item to mark IN PROCESS";
            alertStr[1] = "Cannot mark this item as IN PROCESS";
            break;
        }
        case Utils.ACTIVE: {
            alertStr[0] = "Please select a PAUSED item to mark ACTIVE";
            alertStr[1] = "Cannot mark this item as ACTIVE";
            break;
        }
        case Utils.PHASED_OUT: {
            alertStr[0] = "Please select an item to mark PHASED OUT";
            alertStr[1] = "Cannot mark this item as PHASED OUT";
            break;
        }
        }
        return alertStr;
    }
}