Java 类com.google.gwt.user.client.rpc.AsyncCallback 实例源码

/**
 * Jump to a oozie instance( which need to synchronize current oozie job actions before jumping）
 * 
 * @param oozJobId   oozie job id
 * @param message page url
 */
public void goToOozInstance(final String oozJobId,final String message)
{
    jobSrv.updateJobActionStatus(oozJobId, new AsyncCallback<Void>(){

        @Override
        public void onFailure(Throwable caught) {
            // TODO Auto-generated method stub
            logger.warning("Synchronize current oozie instance actions status failed! Oozie job id ="+oozJobId);
        }

        @Override
        public void onSuccess(Void result) {
            // TODO Auto-generated method stub
            eventBus.fireEvent(new ToMonitorEvent(message));
        }
    });
}

public void returnSuggestions(final List<Chip> chips, final String text, final List<Suggestion> suggestions, final AsyncCallback<Collection<Suggestion>> callback) {
    if (iNext == null)
        callback.onSuccess(suggestions);
    else
        iNext.getSuggestions(chips, text, new AsyncCallback<Collection<Suggestion>>() {

            @Override
            public void onFailure(Throwable caught) {
                callback.onSuccess(suggestions);
            }

            @Override
            public void onSuccess(Collection<Suggestion> result) {
                if (result != null) suggestions.addAll(result);
                callback.onSuccess(suggestions);
            }
        });
}

public void showMenu() {
    if (iLoaded) showMenuPopup();
    else {
        RPC.execute(new MenuInterface.MenuRpcRequest(), new AsyncCallback<GwtRpcResponseList<MenuInterface>>() {
            @Override
            public void onSuccess(GwtRpcResponseList<MenuInterface> result) {
                initMenu(result);
                showMenuPopup();
            }
            @Override
            public void onFailure(Throwable caught) {
                UniTimeNotifications.error(caught.getMessage(), caught);
            }
        });
    }
}

public void setCompany(Integer company) {
    this.company = company;

    companyService.getCompany(company, new AsyncCallback<CompanyInfo>() {

        @Override
        public void onFailure(Throwable caught) {
            Window.alert(caught.getMessage());
        }

        @Override
        public void onSuccess(CompanyInfo result) {
            resetFaultMessages();
            name.setText(result.getName());
            total.setText(Double.toString(result.getTotal()));
        }
    });
}

protected void ensureInitialized(final AsyncCallback<Boolean> callback) {
    if (iClassifications != null)
        callback.onSuccess(true);
    iCurriculaService.loadAcademicClassifications(new AsyncCallback<TreeSet<AcademicClassificationInterface>>() {
        @Override
        public void onSuccess(TreeSet<AcademicClassificationInterface> result) {
            iClassifications = result;
            if (callback != null) callback.onSuccess(true);
        }

        @Override
        public void onFailure(Throwable caught) {
            iHeader.setErrorMessage(MESSAGES.failedToLoadClassifications(caught.getMessage()));
            UniTimeNotifications.error(MESSAGES.failedToLoadClassifications(caught.getMessage()), caught);
            if (callback != null) callback.onFailure(caught);
        }
    });
}

@Override
public void requestSuggestions(final Request request, final Callback callback) {
    if (!request.getQuery().isEmpty()) {
        iFilter.getWidget().getSuggestionsProvider().getSuggestions(iFilter.getWidget().getChips(null), request.getQuery(), new AsyncCallback<Collection<FilterBox.Suggestion>>() {

            @Override
            public void onFailure(Throwable caught) {
            }

            @Override
            public void onSuccess(Collection<FilterBox.Suggestion> result) {
                if (result == null) return;
                List<CourseSuggestion> suggestions = new ArrayList<CourseSuggestion>();
                for (FilterBox.Suggestion suggestion: result) {
                    if (suggestion.getChipToAdd() != null && "course".equals(suggestion.getChipToAdd().getCommand())) {
                        suggestions.add(new CourseSuggestion(suggestion));
                    }
                }
                callback.onSuggestionsReady(request, new Response(suggestions));
            }
        });
    }
}

public SolverStatus() {
    super("unitime-SolverStatus");
    iStatus = new P("status-label");
    iIcon = new Image(RESOURCES.helpIcon()); iIcon.addStyleName("status-icon");
    iIcon.setVisible(false);
    add(iStatus); add(iIcon);
    RPC.execute(new PageNameRpcRequest("Solver Status"), new AsyncCallback<PageNameInterface>() {
        @Override
        public void onFailure(Throwable caught) {}
        @Override
        public void onSuccess(final PageNameInterface result) {
            iIcon.setTitle(MESSAGES.pageHelp(result.getName()));
            iIcon.setVisible(true);
            iIcon.addClickHandler(new ClickHandler() {
                @Override
                public void onClick(ClickEvent event) {
                    if (result.getHelpUrl() == null || result.getHelpUrl().isEmpty()) return;
                    UniTimeFrameDialog.openDialog(MESSAGES.pageHelp(result.getName()), result.getHelpUrl());
                }
            });
        }
    });
}

public void insert(final RootPanel panel, Long eventAvailability) {
    String[] ids = panel.getElement().getInnerHTML().trim().split(":");
    Long locationId = Long.valueOf(ids[0]);
    Long examTypeId = Long.valueOf(ids[1]);
    RPC.execute(RoomInterface.PeriodPreferenceRequest.load(locationId, examTypeId), new AsyncCallback<PeriodPreferenceModel>() {
        @Override
        public void onFailure(Throwable caught) {
            UniTimeNotifications.error(MESSAGES.failedToLoadPeriodPreferences(caught.getMessage()));
        }

        @Override
        public void onSuccess(PeriodPreferenceModel result) {
            panel.getElement().setInnerText(null);
            setModel(result);
            panel.add(PeriodPreferencesWidget.this);
            panel.setVisible(true);
        }
    });
}

private void drawEnvelope(final VectorFeature... vectorFeatures) {
    final WKT wktFormat = new WKT();
    final List<String> wktElements = new ArrayList<String>();
    for (final VectorFeature feature : vectorFeatures) {
        wktElements.add(wktFormat.write(feature));
    }

    JTS_SERVICE_ASYNC.getEnvelope(wktElements, new AsyncCallback<List<String>>() {
        public void onFailure(final Throwable caught) {
            progressBar.hide();
            messageDialogBuilder.createError(UIMessages.INSTANCE.fail(), "Error: " + caught.getMessage()).show();
        }

        public void onSuccess(final List<String> wktEnvelopes) {
            final VectorLayer vector = getEnvelopeLayer();
            for (final String wktEnvelope : wktEnvelopes) {
                final VectorFeature newVectorFeature = new VectorFeature(Geometry.fromWKT(wktEnvelope));
                vector.addFeature(newVectorFeature);
            }
            progressBar.hide();
        }
    });
}

private void execute(final int index, final AsyncCallback<Boolean> callback) {
    if (index >= iInitializations.length) {
        callback.onSuccess(true);
    } else {
        iInitializations[index].execute(new AsyncCallback<Boolean>() {
            @Override
            public void onFailure(Throwable caught) {
                callback.onFailure(caught);
            }
            @Override
            public void onSuccess(Boolean result) {
                if (result) {
                    execute(1 + index, callback);
                } else {
                    callback.onSuccess(false);
                }
            }
        });
    }
}

/**
 * Enables or disables buttons based on whether the user has an android.keystore file.
 */
public void updateKeystoreFileMenuButtons() {
  Ode.getInstance().getUserInfoService().hasUserFile(StorageUtil.ANDROID_KEYSTORE_FILENAME,
      new AsyncCallback<Boolean>() {
        @Override
        public void onSuccess(Boolean keystoreFileExists) {
          isKeystoreCached = true;
          isKeystorePresent = keystoreFileExists;
          fileDropDown.setItemEnabled(MESSAGES.deleteKeystoreMenuItem(), keystoreFileExists);
          fileDropDown.setItemEnabled(MESSAGES.downloadKeystoreMenuItem(), keystoreFileExists);
        }

        @Override
        public void onFailure(Throwable caught) {
          // Enable the MenuItems. If they are clicked, we'll check again if the keystore exists.
          fileDropDown.setItemEnabled(MESSAGES.deleteKeystoreMenuItem(), true);
          fileDropDown.setItemEnabled(MESSAGES.downloadKeystoreMenuItem(), true);
        }
      });
}

public void showInstructorDetail(Long id) {
    iAssignmentTable.clearTable(1);
    LoadingWidget.getInstance().show(MESSAGES.waitLoadTeachingRequestDetail());
    ToolBox.setMaxHeight(iScroll.getElement().getStyle(), Math.round(0.9 * Window.getClientHeight()) + "px");
    RPC.execute(new TeachingAssignmentsDetailRequest(id), new AsyncCallback<InstructorInfo>() {
        @Override
        public void onFailure(Throwable caught) {
            LoadingWidget.getInstance().hide();
            UniTimeNotifications.error(MESSAGES.failedToLoadTeachingRequestDetail(caught.getMessage()), caught);
            ToolBox.checkAccess(caught);
        }

        @Override
        public void onSuccess(InstructorInfo result) {
            LoadingWidget.getInstance().hide();
            populate(null, null, result);
            GwtHint.hideHint();
            center();
            RootPanel.getBodyElement().getStyle().setOverflow(Overflow.HIDDEN);
        }
    });
}

protected AsyncCallback<List<String>> getDefaultAsyncCallback() {

    return new AsyncCallback<List<String>>() {

        @Override
        public void onFailure(final Throwable caught) {
            finishProgressbar();        
            onError(caught.getMessage());               
        }

        public void onSuccess(final List<String> wktElements) {
            finishProgressbar();
            onSucess(getResultLayer(wktElements));              
        }
    };
}

protected void init() {
    RPC.execute(new NotAssignedClassesFilterRequest(), new AsyncCallback<NotAssignedClassesFilterResponse>() {
        @Override
        public void onFailure(Throwable caught) {
            iFilter.getFooter().setErrorMessage(MESSAGES.failedToInitialize(caught.getMessage()));
            UniTimeNotifications.error(MESSAGES.failedToInitialize(caught.getMessage()), caught);
            ToolBox.checkAccess(caught);
        }

        @Override
        public void onSuccess(NotAssignedClassesFilterResponse result) {
            iLegend = new PreferenceLegend(result.getPreferences());
            iFilter.getFooter().clearMessage();
            iFilter.setValue(result);
            iFilter.getFooter().setEnabled("search", true);
            createTriggers();
            if (iFilter.getHeader().isCollapsible() != null && !iFilter.getHeader().isCollapsible())
                search(null);
        }
    });
}

@Override
public void requestSuggestions(final Request request, final Callback callback) {
    if (!request.getQuery().isEmpty()) {
        iFilter.getWidget().getSuggestionsProvider().getSuggestions(iFilter.getWidget().getChips(null), request.getQuery(), new AsyncCallback<Collection<FilterBox.Suggestion>>() {

            @Override
            public void onFailure(Throwable caught) {
            }

            @Override
            public void onSuccess(Collection<FilterBox.Suggestion> result) {
                if (result == null) return;
                List<RequestedBySuggestion> suggestions = new ArrayList<RequestedBySuggestion>();
                for (FilterBox.Suggestion suggestion: result) {
                    if (suggestion.getChipToAdd() != null && "requested".equals(suggestion.getChipToAdd().getCommand())) {
                        suggestions.add(new RequestedBySuggestion(suggestion));
                    }
                }
                callback.onSuggestionsReady(request, new Response(suggestions));
            }
        });
    }
}

public static void showHint(final Element relativeObject, final Long locationId, final Long examTypeId) {
    sLastLocationId = locationId;
    sShowHint = true;
    RPC.execute(RoomInterface.PeriodPreferenceRequest.load(locationId, examTypeId), new AsyncCallback<RoomInterface.PeriodPreferenceModel>() {
        @Override
        public void onFailure(Throwable caught) {
        }

        @Override
        public void onSuccess(RoomInterface.PeriodPreferenceModel result) {
            if (locationId.equals(sLastLocationId) && sShowHint && result != null && !result.getPeriods().isEmpty())
                GwtHint.showHint(relativeObject, content(result));
        }
    });
}

@Override
public void execute(final AsyncCallback<Boolean> callback) {
    RPC.execute(new ReservationDefaultExpirationDatesRpcRequest(), new AsyncCallback<DefaultExpirationDates>() {
        @Override
        public void onFailure(Throwable caught) {
            callback.onFailure(caught);
        }

        @Override
        public void onSuccess(DefaultExpirationDates result) {
            iExpirations = result;
            callback.onSuccess(true);
        }
    });
}

public static void showHint(final Element relativeObject, final long locationId, boolean eventAvailability) {
    sLastLocationId = locationId;
    sShowHint = true;
    RPC.execute(RoomInterface.RoomSharingRequest.load(locationId, eventAvailability), new AsyncCallback<RoomInterface.RoomSharingModel>() {
        @Override
        public void onFailure(Throwable caught) {
        }

        @Override
        public void onSuccess(RoomInterface.RoomSharingModel result) {
            if (locationId == sLastLocationId && sShowHint && result != null)
                GwtHint.showHint(relativeObject, content(result));
        }
    });
}

public void refresh() {
    int level = iLevel.getSelectedIndex();
    SolverCookie.getInstance().setLogLevel(level);
    iHeader.showLoading();
    iTimer.cancel();
    RPC.execute(new SolverLogPageRequest(iType, ProgressLogLevel.values()[level], null), new AsyncCallback<SolverLogPageResponse>() {
        @Override
        public void onFailure(Throwable caught) {
            iHeader.setErrorMessage(caught.getMessage());
        }

        @Override
        public void onSuccess(SolverLogPageResponse result) {
            iHeader.clearMessage();
            for (int row = getRowCount() - 1; row > iLevelRow; row--)
                removeRow(row);
            if (result.hasLog()) {
                iLog = new ProgressLog(result.getLog());
                addRow(iLog);
                addBottomRow(iFooter);
                iTimer.scheduleRepeating(1000);
            } else if (result.hasSolutionLogs()) {
                for (SolutionLog log: result.getSolutionLogs()) {
                    if (log.hasLog()) {
                        addHeaderRow(log.getOwner());
                        addRow(new ProgressLog(log.getLog()));
                    }
                }
                addBottomRow(iFooter);
            }
        }
    });
}

@Override
public void reset() {
    super.reset();
    RPC.execute(new FileUploadRpcRequest(true), new AsyncCallback<FileUploadRpcResponse>() {
        @Override
        public void onFailure(Throwable caught) {
            UniTimeNotifications.error(caught);
        }

        @Override
        public void onSuccess(FileUploadRpcResponse result) {
        }
    });
}

private void drawCentroid(final VectorFeature... vectorFeatures) {
    final WKT wktFormat = new WKT();
    final List<String> wktElements = new ArrayList<String>();
    for (final VectorFeature feature : vectorFeatures) {
        wktElements.add(wktFormat.write(feature));
    }

    JTS_SERVICE_ASYNC.getCentroid(wktElements,
            new AsyncCallback<List<String>>() {
                public void onFailure(final Throwable caught) {
                    progressBar.hide();
                    messageDialogBuilder.createError(UIMessages.INSTANCE.fail(),
                            "Error: " + caught.getMessage()).show();
                }

                public void onSuccess(final List<String> wktEnvelopes) {

                    VectorLayer layer = getCentroidLayer();
                    for (String wktEnvelope : wktEnvelopes) {
                        VectorFeature newVectorFeature = new VectorFeature(
                                Geometry.fromWKT(wktEnvelope));
                        layer.addFeature(newVectorFeature);
                    }
                    progressBar.hide();
                }
            });
}

public void refreshSuggestions() {
    if (getSuggestionsProvider() == null) return;
    if (isFilterPopupShowing()) return;
    if (!isEnabled()) return;
    String value = getValue();
    if (value.equals(iLastValue)) return;
    iLastValue = value;
    final String query = iFilter.getText();
    getSuggestionsProvider().getSuggestions(getChips(null), query, new AsyncCallback<Collection<Suggestion>>() {
        @Override
        public void onFailure(Throwable caught) {
            if (iSuggestionsPopup.isShowing()) iSuggestionsPopup.hide();
        }

        @Override
        public void onSuccess(Collection<Suggestion> result) {
            if (!query.equals(iFilter.getText())) return; // old request
            if (result != null && !result.isEmpty()) {
                updateSuggestions(result);
                iSuggestionsPopup.setWidth(getElement().getClientWidth() + "px");
                iSuggestionsPopup.showRelativeTo(FilterBox.this);
            } else {
                if (iSuggestionsPopup.isShowing()) iSuggestionsPopup.hide();
            }
        }
    });
}

/**
 * User information is initialized
 */
public void init(){
    if(AppController.power.startsWith("0")){            //Authority code starts with 0, general user have no authority to visit background management.
        accountView.getAdminAnchor().setVisible(false);
        accountView.getAdminAnchor().setEnabled(false);
    }
    accountView.setAccount(AppController.username, AppController.email);
    Account account = new Account();
    account.setUsername(AppController.username);
    account.setEmail(AppController.email);
    accountService.getAccountInfo(account, new AsyncCallback<Account>(){

        @Override
        public void onFailure(Throwable caught) {
            // TODO Auto-generated method stub
            accountView.getVererrorLabel().setText(caught.getMessage());
        }

        @Override
        public void onSuccess(Account result) {
            // TODO Auto-generated method stub
            accountView.getUsrBox().setValue(result.getUsername());
            accountView.getCmpBox().setValue(result.getCompany());
            accountView.getPstBox().setValue(result.getPosition());
        }

    });
}

/**
 * Load search result and reset paging control 
 */ 
private void searchResult(){
    adminView.getDataPage().clear();                            
    adminView.getDataPage().add(page);
    datasetService.search(searchDataset, searchStart, searchEnd, 0, 0, new AsyncCallback<List<Dataset>>(){

        @Override
        public void onFailure(Throwable caught) {
            // TODO Auto-generated method stub
            searchAlert.setContent(caught.getMessage());
            searchAlert.show();
        }

        @Override
        public void onSuccess(List<Dataset> result) {
            // TODO Auto-generated method stub
            if(result.size() == 0){
                searchAlert.setContent( Constants.adminUIMsg.searchNoResult());
                searchAlert.show();
            }else{
                resultSize = result.size();                     
                pageSize = (int)Math.ceil((double)result.size()/13);
                lastPage = pageSize;
                currentPage = 1;
                pagination = new Pagination(page, pageSize, Pagination.PageType.LARGE);
                pagination.load();
                reload();                                   
            }
        }

    });
}

protected void sendPin() {
    final String pin = iPin.getText();
    hide();
    LoadingWidget.getInstance().show(MESSAGES.waitEligibilityCheck());
    sSectioningService.checkEligibility(iOnline, iSectioning, iSessionId, iStudentId, pin, new AsyncCallback<EligibilityCheck>() {

        @Override
        public void onSuccess(EligibilityCheck result) {
            LoadingWidget.getInstance().hide();
            iCallback.onMessage(result);
            if (result.hasFlag(OnlineSectioningInterface.EligibilityCheck.EligibilityFlag.PIN_REQUIRED)) {
                center();
                Scheduler.get().scheduleDeferred(new ScheduledCommand() {
                    @Override
                    public void execute() {
                        iPin.selectAll();
                        iPin.setFocus(true);
                    }
                });
            } else {
                iCallback.onSuccess(result);
            }
        }

        @Override
        public void onFailure(Throwable caught) {
            LoadingWidget.getInstance().hide();
            iCallback.onFailure(caught);
        }
    });
}

private void refreshQueue(Long deleteId, final Long selectId) {
    RPC.execute(new ScriptInterface.GetQueueTableRpcRequest(deleteId), new AsyncCallback<GwtRpcResponseList<QueueItemInterface>>() {
        @Override
        public void onFailure(Throwable caught) {
            UniTimeNotifications.error(MESSAGES.failedLoadData(caught.getMessage()), caught);
        }

        @Override
        public void onSuccess(GwtRpcResponseList<QueueItemInterface> result) {
            populate(result, selectId);
        }
    });
}

private void checkEligibility(final Callback<EligibilityCheck> callback) {
    debug("checkEligibility()");    
    iSectioningService.checkEligibility(true, true, iSessionId, iStudentId, iPin.getWidget().getText(),  new AsyncCallback<EligibilityCheck>() {
        @Override
        public void onSuccess(EligibilityCheck result) {
            callback.execute(result, null);
        }
        @Override
        public void onFailure(Throwable caught) {
            warn("&nbsp;&nbsp;checkEligibility() failed: " + caught.getMessage());
            callback.execute(null, caught);
        }
    });

}

private void exportData(String format) {
    String query = "output=assigned-classes." + format + iFilter.getQuery() + "&sort=" + SolverCookie.getInstance().getAssignedClassesSort();
    RPC.execute(EncodeQueryRpcRequest.encode(query), new AsyncCallback<EncodeQueryRpcResponse>() {
        @Override
        public void onFailure(Throwable caught) {
        }
        @Override
        public void onSuccess(EncodeQueryRpcResponse result) {
            ToolBox.open(GWT.getHostPageBaseURL() + "export?q=" + result.getQuery());
        }
    });
}

protected void export(String format) {
    RPC.execute(EncodeQueryRpcRequest.encode(query(format)), new AsyncCallback<EncodeQueryRpcResponse>() {
        @Override
        public void onFailure(Throwable caught) {
        }
        @Override
        public void onSuccess(EncodeQueryRpcResponse result) {
            ToolBox.open(GWT.getHostPageBaseURL() + "export?q=" + result.getQuery());
        }
    });
}

public void loadQueries(final Long select, final boolean reload) {
    if (!LoadingWidget.getInstance().isShowing())
        LoadingWidget.getInstance().show(MESSAGES.waitLoadingReports());
    RPC.execute(new PITDQueriesRpcRequest(), new AsyncCallback<GwtRpcResponseList<Report>>() {
        @Override
        public void onFailure(Throwable caught) {
            iHeader.setErrorMessage(caught.getMessage());
            LoadingWidget.getInstance().hide();
        }
        @Override
        public void onSuccess(GwtRpcResponseList<Report> result) {
            String selected = (select == null ? null : select.toString());
            if (selected == null && iReportSelector.getWidget().getSelectedIndex() >= 0) {
                selected = iReportSelector.getWidget().getValue(iReportSelector.getWidget().getSelectedIndex());
            }
            iReportSelector.getWidget().clear();
            if (result.isEmpty()) {
                iHeader.setErrorMessage(MESSAGES.errorNoReportsAvailable());
            } else {
                iReportSelector.getWidget().addItem(MESSAGES.itemSelect(), "-1");
                iReports = result;
                for (int i = 0; i < result.size(); i++) {
                    iReportSelector.getWidget().addItem(result.get(i).getName(), result.get(i).getId().toString());
                    if (selected != null && selected.equals(result.get(i).getId().toString()))
                        iReportSelector.getWidget().setSelectedIndex(1 + i);
                }
                queryChanged();
            }
            LoadingWidget.getInstance().hide();
            if (reload) reload(History.getToken());
        }
    });
}

public void loadQueries(final Long select, final boolean reload) {
    if (!LoadingWidget.getInstance().isShowing())
        LoadingWidget.getInstance().show(MESSAGES.waitLoadingReports());
    RPC.execute(new HQLQueriesRpcRequest(iAppearance), new AsyncCallback<GwtRpcResponseList<Query>>() {
        @Override
        public void onFailure(Throwable caught) {
            iHeader.setErrorMessage(caught.getMessage());
            LoadingWidget.getInstance().hide();
        }
        @Override
        public void onSuccess(GwtRpcResponseList<Query> result) {
            String selected = (select == null ? null : select.toString());
            if (selected == null && iQuerySelector.getWidget().getSelectedIndex() >= 0) {
                selected = iQuerySelector.getWidget().getValue(iQuerySelector.getWidget().getSelectedIndex());
            }
            iQuerySelector.getWidget().clear();
            if (result.isEmpty()) {
                iHeader.setErrorMessage(MESSAGES.errorNoReportsAvailable());
            } else {
                iQuerySelector.getWidget().addItem(MESSAGES.itemSelect(), "-1");
                iQueries = result;
                for (int i = 0; i < result.size(); i++) {
                    iQuerySelector.getWidget().addItem(result.get(i).getName(), result.get(i).getId().toString());
                    if (selected != null && selected.equals(result.get(i).getId().toString()))
                        iQuerySelector.getWidget().setSelectedIndex(1 + i);
                }
                queryChanged();
            }
            LoadingWidget.getInstance().hide();
            if (reload) reload(History.getToken());
        }
    });
}

private void exportData() {
    int tab = iTabIndex;
    if (tab < 0)
        tab = SectioningStatusCookie.getInstance().getTab(iOnline);

    String query = "output=student-dashboard.csv&online=" + (iOnline ? 1 : 0) + "&tab=" + tab + "&sort=" + SectioningStatusCookie.getInstance().getSortBy(iOnline, tab);
    if (tab == 0)
        for (Long courseId: iSelectedCourseIds)
            query += "&c=" + courseId;
    query += "&query=" + URL.encodeQueryString(iFilter.getValue());
    FilterRpcRequest req = iFilter.getElementsRequest();
    if (req.hasOptions()) {
        for (Map.Entry<String, Set<String>> option: req.getOptions().entrySet()) {
            for (String value: option.getValue()) {
                query += "&f:" + option.getKey() + "=" + URL.encodeQueryString(value);
            }
        }
    }
    if (req.getText() != null && !req.getText().isEmpty()) {
        query += "&f:text=" + URL.encodeQueryString(req.getText());
    }

    RPC.execute(EncodeQueryRpcRequest.encode(query), new AsyncCallback<EncodeQueryRpcResponse>() {
        @Override
        public void onFailure(Throwable caught) {
        }
        @Override
        public void onSuccess(EncodeQueryRpcResponse result) {
            ToolBox.open(GWT.getHostPageBaseURL() + "export?q=" + result.getQuery());
        }
    });
}

public static MenuItem create(final ProgramLeaf node) {
    Command command = new MenuItemCommand(node) {
        @Override
        public void execute() {
            String id = node.getModule().getId();
            boolean y = Window.confirm("Are you ready to deprecate " + node.getModule().getName() + "？");
            if (y) {
                ProgramServiceAsync svc = GWT.create(ProgramService.class);
                svc.deprecate(id, new AsyncCallback<Void>() {

                    @Override
                    public void onFailure(Throwable caught) {
                        Window.alert(caught.getMessage());
                    }

                    @Override
                    public void onSuccess(Void result) {
                        node.delete();
                    }

                });
            }
            this.component.getContextMenu().hide();
        }

    };

    MenuItem item = new MenuItem("deprecate", command);
    return item;
}

@Override
public void getData(String source, AsyncCallback<List<FreeTime>> callback) {
    try {
        callback.onSuccess(parseFreeTime(source));
    } catch (IllegalArgumentException e) {
        callback.onFailure(e);
    }
}

@Override
public void getValues(List<Chip> chips, String text, AsyncCallback<Collection<Chip>> callback) {
    callback.onSuccess(iValues);
}

void cutEmployee(String employeeName, Double salary,
AsyncCallback<Double> callback);

protected ComponentRenameWizard(final String defaultTypeName, long projectId, final List<ProjectNode> compNodes) {
    super(MESSAGES.componentRenameWizardCaption(), true, false);

    this.defaultTypeName = defaultTypeName;
    this.defaultName = getDefaultName(defaultTypeName);
    this.destinationProjectId = projectId;
    this.nodes = compNodes;

    setStylePrimaryName("ode-DialogBox");

    renameTextBox = new LabeledTextBox(MESSAGES.componentNameLabel());
    renameTextBox.getTextBox().addKeyDownHandler(new KeyDownHandler() {
        @Override
        public void onKeyDown(KeyDownEvent event) {
            int keyCode = event.getNativeKeyCode();
            if (keyCode == KeyCodes.KEY_ENTER) {
                handleOkClick();
            } else if (keyCode == KeyCodes.KEY_ESCAPE) {
                handleCancelClick();
            }
        }
    });

    renameTextBox.setText(defaultName);

    VerticalPanel page = new VerticalPanel();

    page.add(renameTextBox);
    addPage(page);

    // Create finish command (rename Extension)
    initFinishCommand(new Command() {
        @Override
        public void execute() {
            String newName = renameTextBox.getText();

            if (TextValidators.checkNewComponentName(newName)) {
                ode.getComponentService().renameImportedComponent(defaultTypeName, newName, destinationProjectId, new RenameComponentCallback());

            } else {
                show();
                center();
                renameTextBox.setFocus(true);
                renameTextBox.selectAll();
                return;
            }
        }
    });
    // Create cancel command (delete component files)
    initCancelCommand(new Command() {
        @Override
        public void execute() {
            ode.getComponentService().deleteImportedComponent(defaultTypeName, destinationProjectId, new AsyncCallback<Void>() {
                @Override
                public void onFailure(Throwable throwable) {

                }

                @Override
                public void onSuccess(Void aVoid) {

                }
            });
        }
    });
}

public void open(CourseRequestInterface request, ArrayList<ClassAssignmentInterface.ClassAssignment> rows, RequestedCourse course, boolean useGwtConfirmations, AsyncCallback<ClassAssignmentInterface> callback) {
    LoadingWidget.getInstance().show(MESSAGES.suggestionsLoadingChoices());
    iAssignment = null;
    iCurrent = rows;
    iRequest = request;
    iIndex = -1;
    iHintId = null;
    iUseGwtConfirmations = useGwtConfirmations;
    iSource = course.getCourseName();
    setText(MESSAGES.suggestionsChoices(iSource));
    iSuggestions.setSelectedRow(-1);
    iSuggestions.clearData(true);
    iSuggestions.setEmptyMessage(MESSAGES.suggestionsLoadingChoices());
    iLegend.setHTML(MESSAGES.suggestionsLegendOnNewCourse(course.getCourseName()));
    iMessages.setHTML("");
    iFilter.setText("");
    iQuickDrop.setVisible(false); iQuickDrop.setEnabled(false);
    request.addCourse(course);
    iCustomCallback = callback;
    iSectioningService.computeSuggestions(iOnline, request, rows, -1, iFilter.getText(), new AsyncCallback<Collection<ClassAssignmentInterface>>() {
        @Override
        public void onSuccess(Collection<ClassAssignmentInterface> result) {
            if (result == null || result.isEmpty()) {
                LoadingWidget.getInstance().hide();
                iCustomCallback.onFailure(new SectioningException(MESSAGES.suggestionsNoChoices(iSource)));
            } else if (result.size() == 1) {
                ClassAssignmentInterface a = result.iterator().next();
                if (a.getCourseAssignments().isEmpty()) {
                    LoadingWidget.getInstance().hide(); 
                    if (a.hasMessages())
                        iCustomCallback.onFailure(new SectioningException(a.getMessages(", ")));
                    else
                        iCustomCallback.onFailure(new SectioningException(MESSAGES.suggestionsNoChoices(iSource)));
                } else {
                    iCallback.onSuccess(result);
                }
            } else {
                iCallback.onSuccess(result);
            }
        }
        @Override
        public void onFailure(Throwable caught) {
            LoadingWidget.getInstance().hide();
            iCustomCallback.onFailure(caught);
        }
    });
}

private void execute() {
    iHeader.setEnabled("print", false);

    if (iReportSelector.getWidget().getSelectedIndex() <= 0) {
        iHeader.setErrorMessage(MESSAGES.errorNoReportSelected());
        return;
    }

    ReportType type = ReportType.valueOf(iReportSelector.getWidget().getValue(iReportSelector.getWidget().getSelectedIndex()));
    iLastHistory = type.name();
    iTable.clearTable();
    iTableHeader.clearMessage();
    iHeader.clearMessage();
    LoadingWidget.getInstance().show(MESSAGES.waitExecuting(type.getName()));
    History.newItem(iLastHistory + ":" + iFirstLine + ":" + iLastSort, false);

    SectioningReportRpcRequest request = new SectioningReportRpcRequest();
    request.setParameter("report", type.getImplementation());
    request.setParameter("online", iOnline ? "true" : "false");
    for (int i = 0; i + 1 < type.getParameters().length; i += 2)
        request.setParameter(type.getParameters()[i], type.getParameters()[i + 1]);

    RPC.execute(request, new AsyncCallback<SectioningReportRpcResponse>() {
        @Override
        public void onFailure(Throwable caught) {
            iTableHeader.setErrorMessage(caught.getMessage());
            LoadingWidget.getInstance().hide();
        }
        @Override
        public void onSuccess(SectioningReportRpcResponse result) {
            iData.clear();
            RowData prev = null;
            for (int i = 0; i < result.getReport().size(); i ++) {
                String[] row = result.getReport().get(i);
                if (row.length == 0) continue;
                RowData data = new RowData(row);
                while (prev != null) {
                    if (data.getNrBlanks() > prev.getNrBlanks()) break;
                    prev = prev.getParent();
                }
                if (prev != null)
                    data.setParent(prev);
                if (i == 0) {
                    iHead = data;
                } else {
                    iData.add(data);
                    prev = data;
                }
            }
            populate(true);
            LoadingWidget.getInstance().hide();
        }
    });
}

public UniTimeFilterBox(AcademicSessionProvider session) {
    iFilter = new UniTimeWidget<FilterBox>(new FilterBox());
    iFilter.addStyleName("unitime-FilterBoxContainer");

    iFilter.getWidget().setSuggestionsProvider(new SuggestionsProvider() {
        @Override
        public void getSuggestions(List<Chip> chips, String text, final AsyncCallback<Collection<Suggestion>> callback) {
            Long sessionId = (iAcademicSession == null ? null : iAcademicSession.getAcademicSessionId());
            if (sessionId == null && iAcademicSession != null) {
                callback.onSuccess(null);
                return;
            }
            RPC.execute(createRpcRequest(FilterRpcRequest.Command.SUGGESTIONS, iAcademicSession == null ? null : iAcademicSession.getAcademicSessionId(), chips, text), new AsyncCallback<FilterRpcResponse>() {

                @Override
                public void onFailure(Throwable caught) {
                    callback.onFailure(caught);
                }

                @Override
                public void onSuccess(FilterRpcResponse result) {
                    List<FilterBox.Suggestion> suggestions = new ArrayList<FilterBox.Suggestion>();
                    if (result.hasSuggestions()) {
                        for (FilterRpcResponse.Entity s: result.getSuggestions())
                            addSuggestion(suggestions, s);
                    }
                    callback.onSuccess(suggestions);
                }

            });
        }
    });

    initWidget(iFilter);

    iAcademicSession = session;

    if (iAcademicSession != null)
        iAcademicSession.addAcademicSessionChangeHandler(new AcademicSessionChangeHandler() {
            @Override
            public void onAcademicSessionChange(AcademicSessionChangeEvent event) {
                if (event.isChanged()) init(true, event.getNewAcademicSessionId(), null);
            }
        });

    Scheduler.get().scheduleDeferred(new ScheduledCommand() {
        @Override
        public void execute() {
            init(true, iAcademicSession == null ? null : iAcademicSession.getAcademicSessionId(), null);
        }
    });
}