| /* |
| * Copyright 2010 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package com.google.gwt.sample.expenses.client; |
| |
| import com.google.gwt.activity.shared.Activity; |
| import com.google.gwt.cell.client.AbstractInputCell; |
| import com.google.gwt.cell.client.Cell; |
| import com.google.gwt.cell.client.DateCell; |
| import com.google.gwt.cell.client.FieldUpdater; |
| import com.google.gwt.cell.client.NumberCell; |
| import com.google.gwt.cell.client.TextCell; |
| import com.google.gwt.cell.client.ValueUpdater; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.dom.client.Document; |
| import com.google.gwt.dom.client.Element; |
| import com.google.gwt.dom.client.NativeEvent; |
| import com.google.gwt.dom.client.SelectElement; |
| import com.google.gwt.event.dom.client.BlurEvent; |
| import com.google.gwt.event.dom.client.BlurHandler; |
| import com.google.gwt.event.dom.client.ClickEvent; |
| import com.google.gwt.event.dom.client.ClickHandler; |
| import com.google.gwt.event.dom.client.KeyCodes; |
| import com.google.gwt.event.dom.client.KeyUpEvent; |
| import com.google.gwt.event.dom.client.KeyUpHandler; |
| import com.google.gwt.event.logical.shared.CloseEvent; |
| import com.google.gwt.event.logical.shared.CloseHandler; |
| import com.google.gwt.event.shared.EventBus; |
| import com.google.gwt.i18n.client.DateTimeFormat; |
| import com.google.gwt.i18n.client.NumberFormat; |
| import com.google.gwt.resources.client.ImageResource; |
| import com.google.gwt.safehtml.client.SafeHtmlTemplates; |
| import com.google.gwt.safehtml.shared.SafeHtml; |
| import com.google.gwt.safehtml.shared.SafeHtmlBuilder; |
| import com.google.gwt.safehtml.shared.SafeHtmlUtils; |
| import com.google.gwt.sample.expenses.client.place.ReportListPlace; |
| import com.google.gwt.sample.expenses.client.place.ReportPlace; |
| import com.google.gwt.sample.expenses.client.style.Styles; |
| import com.google.gwt.sample.expenses.shared.EmployeeProxy; |
| import com.google.gwt.sample.expenses.shared.ExpenseProxy; |
| import com.google.gwt.sample.expenses.shared.ExpenseRequest; |
| import com.google.gwt.sample.expenses.shared.ExpensesRequestFactory; |
| import com.google.gwt.sample.expenses.shared.ReportProxy; |
| import com.google.gwt.sample.expenses.shared.ReportRequest; |
| import com.google.gwt.uibinder.client.UiBinder; |
| import com.google.gwt.uibinder.client.UiField; |
| import com.google.gwt.user.cellview.client.CellTable; |
| import com.google.gwt.user.cellview.client.Column; |
| import com.google.gwt.user.client.Timer; |
| import com.google.gwt.user.client.ui.AbstractImagePrototype; |
| import com.google.gwt.user.client.ui.AcceptsOneWidget; |
| import com.google.gwt.user.client.ui.Anchor; |
| import com.google.gwt.user.client.ui.Button; |
| import com.google.gwt.user.client.ui.Composite; |
| import com.google.gwt.user.client.ui.HasHorizontalAlignment; |
| import com.google.gwt.user.client.ui.Label; |
| import com.google.gwt.user.client.ui.PopupPanel; |
| import com.google.gwt.user.client.ui.TextBox; |
| import com.google.gwt.user.client.ui.VerticalPanel; |
| import com.google.gwt.user.client.ui.Widget; |
| import com.google.gwt.view.client.ListDataProvider; |
| import com.google.web.bindery.requestfactory.gwt.ui.client.EntityProxyKeyProvider; |
| import com.google.web.bindery.requestfactory.shared.EntityProxyChange; |
| import com.google.web.bindery.requestfactory.shared.EntityProxyId; |
| import com.google.web.bindery.requestfactory.shared.Receiver; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * Details about the current expense report on the right side of the app, |
| * including the list of expenses. |
| */ |
| public class ExpenseReportDetails extends Composite implements Activity { |
| |
| interface Binder extends UiBinder<Widget, ExpenseReportDetails> { |
| } |
| |
| /** |
| * Fetches an employee and a report in parallel. A fine example of the kind of |
| * thing that will no longer be necessary when RequestFactory provides server |
| * side method chaining. |
| */ |
| class EmployeeReportFetcher { |
| ReportProxy fetchedReport; |
| EmployeeProxy fetchedEmployee; |
| |
| void Run(EntityProxyId<EmployeeProxy> employeeId, |
| EntityProxyId<ReportProxy> reportId, |
| final Receiver<EmployeeReportFetcher> callback) { |
| expensesRequestFactory.find(employeeId).fire( |
| new Receiver<EmployeeProxy>() { |
| @Override |
| public void onSuccess(EmployeeProxy response) { |
| fetchedEmployee = response; |
| if (fetchedReport != null) { |
| callback.onSuccess(EmployeeReportFetcher.this); |
| } |
| } |
| }); |
| expensesRequestFactory.find(reportId).fire(new Receiver<ReportProxy>() { |
| @Override |
| public void onSuccess(ReportProxy response) { |
| fetchedReport = response; |
| if (fetchedEmployee != null) { |
| callback.onSuccess(EmployeeReportFetcher.this); |
| } |
| } |
| }); |
| } |
| } |
| |
| /** |
| * The resources applied to the table. |
| */ |
| interface TableResources extends CellTable.Resources { |
| @Source({CellTable.Style.DEFAULT_CSS, "ExpenseDetailsCellTable.css"}) |
| TableStyle cellTableStyle(); |
| } |
| |
| /** |
| * The styles applied to the table. |
| */ |
| interface TableStyle extends CellTable.Style { |
| } |
| |
| interface Template extends SafeHtmlTemplates { |
| @Template("<select style=\"background-color:white;border:1px solid " |
| + "#707172;width:10em;margin-right:10px;\" disabled=\"true\" tabindex=\"-1\">" |
| + "<option></option>{0}{1}</select>") |
| SafeHtml disabled(SafeHtml approvedOption, SafeHtml deniedOption); |
| |
| @Template("<select style=\"background-color:white;border:1px solid " |
| + "#707172;width:10em;margin-right:10px;\" tabindex=\"-1\">" |
| + "<option></option>{0}{1}</select>") |
| SafeHtml enabled(SafeHtml approvedOption, SafeHtml deniedOption); |
| } |
| |
| /** |
| * The cell used for approval status. |
| */ |
| private class ApprovalCell extends |
| AbstractInputCell<String, ApprovalViewData> { |
| |
| private final String approvedText = Approval.APPROVED.getText(); |
| private final String deniedText = Approval.DENIED.getText(); |
| private final SafeHtml errorIconHtml; |
| private final SafeHtml pendingIconHtml; |
| |
| public ApprovalCell() { |
| super("change", "click"); |
| if (template == null) { |
| template = GWT.create(Template.class); |
| } |
| |
| // Cache the html string for the error icon. |
| ImageResource errorIcon = Styles.resources().errorIcon(); |
| AbstractImagePrototype errorImg = AbstractImagePrototype.create(errorIcon); |
| errorIconHtml = SafeHtmlUtils.fromTrustedString(errorImg.getHTML()); |
| |
| // Cache the html string for the pending icon. |
| ImageResource pendingIcon = Styles.resources().pendingCommit(); |
| AbstractImagePrototype pendingImg = AbstractImagePrototype.create(pendingIcon); |
| pendingIconHtml = SafeHtmlUtils.fromTrustedString(pendingImg.getHTML()); |
| } |
| |
| @Override |
| public boolean isEditing(Context context, Element parent, String value) { |
| return super.isEditing(context, parent, value) || denialPopup.isShowing(); |
| } |
| |
| @Override |
| public void onBrowserEvent(Context context, Element parent, String value, |
| NativeEvent event, ValueUpdater<String> valueUpdater) { |
| super.onBrowserEvent(context, parent, value, event, valueUpdater); |
| |
| Object key = context.getKey(); |
| String type = event.getType(); |
| ApprovalViewData viewData = getViewData(key); |
| if ("change".equals(type)) { |
| // Disable the select box. |
| SelectElement select = parent.getFirstChild().cast(); |
| select.setDisabled(true); |
| |
| // Add the pending icon if it isn't already visible. |
| if (viewData == null) { |
| Element tmpElem = Document.get().createDivElement(); |
| tmpElem.setInnerHTML(pendingIconHtml.asString()); |
| parent.appendChild(tmpElem.getFirstChildElement()); |
| } |
| |
| // Remember which value is now selected. |
| int index = select.getSelectedIndex(); |
| String pendingValue = select.getOptions().getItem(index).getValue(); |
| viewData = new ApprovalViewData(pendingValue); |
| setViewData(key, viewData); |
| finishEditing(parent, pendingValue, key, valueUpdater); |
| |
| // Update the value updater. |
| if (valueUpdater != null) { |
| valueUpdater.update(pendingValue); |
| } |
| } else if ("click".equals(type) && viewData != null |
| && parent.getChildCount() >= 3) { |
| // Alert the user of the error |
| Element img = parent.getChild(1).cast(); |
| Element anchor = img.getNextSiblingElement(); |
| if (anchor.isOrHasChild(Element.as(event.getEventTarget().cast()))) { |
| // Alert the user of the error. |
| showErrorPopup(viewData.getRejectionText()); |
| |
| // Clear the view data now that we've viewed the message. |
| clearViewData(key); |
| parent.removeChild(anchor); |
| parent.removeChild(img); |
| } |
| } |
| } |
| |
| @Override |
| public void render(Context context, String value, SafeHtmlBuilder sb) { |
| // Get the view data. |
| Object key = context.getKey(); |
| ApprovalViewData viewData = getViewData(key); |
| if (viewData != null && viewData.getPendingApproval().equals(value)) { |
| clearViewData(key); |
| viewData = null; |
| } |
| |
| boolean isRejected = false; |
| boolean isDisabled = false; |
| String pendingValue = null; |
| String renderValue = value; |
| if (viewData != null) { |
| isRejected = viewData.isRejected(); |
| pendingValue = viewData.getPendingApproval(); |
| if (!isRejected) { |
| renderValue = pendingValue; |
| // If there is a delta value that has not been rejected, then the |
| // combo box should remain disabled. |
| isDisabled = true; |
| } |
| } |
| boolean isApproved = approvedText.equals(renderValue); |
| boolean isDenied = deniedText.equals(renderValue); |
| |
| SafeHtml approvedOption = createOption(isApproved, approvedText); |
| SafeHtml deniedOption = createOption(isDenied, deniedText); |
| // Create the select element. |
| if (isDisabled) { |
| sb.append(template.disabled(approvedOption, deniedOption)); |
| } else { |
| sb.append(template.enabled(approvedOption, deniedOption)); |
| } |
| |
| // Add an icon indicating the commit state. |
| if (isRejected) { |
| // Add error icon if viewData does not match. |
| sb.append(errorIconHtml); |
| sb.appendHtmlConstant("<a style='padding-left:3px;color:red;' href='javascript:;'>Error!</a>"); |
| } else if (pendingValue != null) { |
| // Add refresh icon if pending. |
| sb.append(pendingIconHtml); |
| } |
| } |
| |
| private SafeHtml createOption(boolean selected, String text) { |
| SafeHtmlBuilder builder = new SafeHtmlBuilder(); |
| if (selected) { |
| builder.appendHtmlConstant("<option selected=\"selected\">"); |
| } else { |
| builder.appendHtmlConstant("<option>"); |
| } |
| builder.appendEscaped(text); |
| builder.appendHtmlConstant("</option>"); |
| return builder.toSafeHtml(); |
| } |
| } |
| |
| /** |
| * The ViewData associated with the {@link ApprovalCell}. |
| */ |
| private static class ApprovalViewData { |
| private final String pendingApproval; |
| private String rejectionText; |
| |
| public ApprovalViewData(String approval) { |
| this.pendingApproval = approval; |
| } |
| |
| public String getPendingApproval() { |
| return pendingApproval; |
| } |
| |
| public String getRejectionText() { |
| return rejectionText; |
| } |
| |
| public boolean isRejected() { |
| return rejectionText != null; |
| } |
| |
| public void reject(String text) { |
| this.rejectionText = text; |
| } |
| } |
| |
| private static Template template; |
| |
| /** |
| * The maximum amount that can be approved for a given report. |
| */ |
| private static final int MAX_COST = 250; |
| |
| /** |
| * The auto refresh interval in milliseconds. |
| */ |
| private static final int REFRESH_INTERVAL = 5000; |
| |
| private static Binder uiBinder = GWT.create(Binder.class); |
| |
| @UiField Element approvedLabel; |
| |
| @UiField Element costLabel; |
| |
| @UiField Element notes; |
| |
| @UiField TextBox notesBox; |
| |
| @UiField Anchor notesEditLink; |
| |
| @UiField Element notesEditLinkWrapper; |
| |
| @UiField Element notesPending; |
| |
| @UiField Element reportName; |
| |
| @UiField Anchor reportsLink; |
| |
| @UiField(provided = true) |
| CellTable<ExpenseProxy> table; |
| |
| @UiField |
| Element unreconciledLabel; |
| |
| private final List<SortableHeader> allHeaders = new ArrayList<SortableHeader>(); |
| |
| private ApprovalCell approvalCell; |
| |
| /** |
| * The default {@link Comparator} used for sorting. |
| */ |
| private Comparator<ExpenseProxy> defaultComparator; |
| |
| /** |
| * The popup used when something is denied. |
| */ |
| private final DenialPopup denialPopup = new DenialPopup(); |
| |
| /** |
| * The popup used to display errors to the user. |
| */ |
| private final PopupPanel errorPopup = new PopupPanel(false, true); |
| |
| /** |
| * The label inside the error popup. |
| */ |
| private final Label errorPopupMessage = new Label(); |
| |
| private final ExpensesRequestFactory expensesRequestFactory; |
| |
| /** |
| * The data provider that provides expense items. |
| */ |
| private final ListDataProvider<ExpenseProxy> items; |
| |
| /** |
| * The set of Expense keys that we have seen. When a new key is added, we |
| * compare it to the list of known keys to determine if it is new. |
| */ |
| private Map<Object, ExpenseProxy> knownExpenseKeys = null; |
| |
| private Comparator<ExpenseProxy> lastComparator; |
| |
| /** |
| * Keep track of the last receiver so we can ignore stale responses. |
| */ |
| private Receiver<List<ExpenseProxy>> lastReceiver; |
| |
| /** |
| * The {@link Timer} used to periodically refresh the table. |
| */ |
| private final Timer refreshTimer = new Timer() { |
| @Override |
| public void run() { |
| requestExpenses(); |
| } |
| }; |
| |
| /** |
| * The current report being displayed. |
| */ |
| private ReportProxy report; |
| |
| /** |
| * The total amount that has been approved. |
| */ |
| private double totalApproved; |
| |
| private ReportPlace place; |
| |
| public ExpenseReportDetails(ExpensesRequestFactory expensesRequestFactory) { |
| this.expensesRequestFactory = expensesRequestFactory; |
| createErrorPopup(); |
| initTable(); |
| initWidget(uiBinder.createAndBindUi(this)); |
| items = new ListDataProvider<ExpenseProxy>( |
| new EntityProxyKeyProvider<ExpenseProxy>()); |
| items.addDataDisplay(table); |
| |
| // Switch to edit notes. |
| notesEditLink.addClickHandler(new ClickHandler() { |
| public void onClick(ClickEvent event) { |
| setNotesEditState(true, false, report.getNotes()); |
| } |
| }); |
| |
| // Switch to view mode. |
| notesBox.addBlurHandler(new BlurHandler() { |
| public void onBlur(BlurEvent event) { |
| // The text box will be blurred on cancel, so only save the notes if |
| // it is visible. |
| if (notesBox.isVisible()) { |
| saveNotes(); |
| } |
| } |
| }); |
| notesBox.addKeyUpHandler(new KeyUpHandler() { |
| public void onKeyUp(KeyUpEvent event) { |
| int keyCode = event.getNativeKeyCode(); |
| switch (keyCode) { |
| case KeyCodes.KEY_ENTER: |
| saveNotes(); |
| break; |
| case KeyCodes.KEY_ESCAPE: |
| // Cancel the edit. |
| setNotesEditState(false, false, report.getNotes()); |
| break; |
| } |
| } |
| }); |
| } |
| |
| public ReportListPlace getReportListPlace() { |
| ReportListPlace listPlace = place.getListPlace(); |
| return listPlace == null ? ReportListPlace.ALL : listPlace; |
| } |
| |
| public Anchor getReportsLink() { |
| return reportsLink; |
| } |
| |
| public String mayStop() { |
| return null; |
| } |
| |
| public void onCancel() { |
| } |
| |
| public void onExpenseRecordChanged(EntityProxyChange<ExpenseProxy> event) { |
| final EntityProxyId<ExpenseProxy> proxyId = event.getProxyId(); |
| |
| int index = 0; |
| final List<ExpenseProxy> list = items.getList(); |
| for (ExpenseProxy r : list) { |
| if (items.getKey(r).equals(proxyId)) { |
| final int i = index; |
| expensesRequestFactory.find(proxyId).fire(new Receiver<ExpenseProxy>() { |
| @Override |
| public void onSuccess(ExpenseProxy newRecord) { |
| list.set(i, newRecord); |
| |
| // Update the view data if the approval has been updated. |
| ApprovalViewData avd = approvalCell.getViewData(proxyId); |
| if (avd != null |
| && avd.getPendingApproval().equals(newRecord.getApproval())) { |
| syncCommit(newRecord, null); |
| } |
| } |
| }); |
| } |
| index++; |
| } |
| |
| refreshCost(); |
| if (lastComparator != null) { |
| sortExpenses(list, lastComparator); |
| } |
| } |
| |
| public void onReportChanged(EntityProxyChange<ReportProxy> event) { |
| EntityProxyId<ReportProxy> changed = event.getProxyId(); |
| if (report != null && report.getId().equals(changed)) { |
| // Request the updated report. |
| expensesRequestFactory.reportRequest().findReport(report.getId()).fire( |
| new Receiver<ReportProxy>() { |
| @Override |
| public void onSuccess(ReportProxy response) { |
| report = response; |
| setNotesEditState(false, false, response.getNotes()); |
| } |
| }); |
| } |
| } |
| |
| public void onStop() { |
| } |
| |
| public void start(AcceptsOneWidget panel, EventBus eventBus) { |
| final ReportListPlace listPlace = place.getListPlace(); |
| |
| if (listPlace.getEmployeeId() == null) { |
| expensesRequestFactory.find(place.getReportId()).fire( |
| new Receiver<ReportProxy>() { |
| @Override |
| public void onSuccess(ReportProxy response) { |
| setReportRecord(response, listPlace.getDepartment(), null); |
| } |
| }); |
| } else { |
| new EmployeeReportFetcher().Run(listPlace.getEmployeeId(), |
| place.getReportId(), |
| new Receiver<ExpenseReportDetails.EmployeeReportFetcher>() { |
| @Override |
| public void onSuccess(EmployeeReportFetcher response) { |
| setReportRecord(response.fetchedReport, |
| listPlace.getDepartment(), response.fetchedEmployee); |
| } |
| }); |
| } |
| |
| EntityProxyChange.registerForProxyType(eventBus, ExpenseProxy.class, |
| new EntityProxyChange.Handler<ExpenseProxy>() { |
| public void onProxyChange(EntityProxyChange<ExpenseProxy> event) { |
| onExpenseRecordChanged(event); |
| } |
| }); |
| |
| EntityProxyChange.registerForProxyType(eventBus, ReportProxy.class, |
| new EntityProxyChange.Handler<ReportProxy>() { |
| public void onProxyChange(EntityProxyChange<ReportProxy> event) { |
| onReportChanged(event); |
| } |
| }); |
| |
| panel.setWidget(this); |
| } |
| |
| /** |
| * In this application, called by {@link ExpensesActivityMapper} each time a |
| * ReportListPlace is posted. In a more typical set up, this would be a |
| * constructor argument to a one shot activity, perhaps managing a shared |
| * widget view instance. |
| */ |
| public void updateForPlace(final ReportPlace place) { |
| this.place = place; |
| } |
| |
| /** |
| * Add a column of a {@link Comparable} type using default comparators. |
| * |
| * @param <C> the column type |
| * @param table the table |
| * @param text the header text |
| * @param cell the cell used to render values |
| * @param getter the {@link GetValue} used to retrieve cell values |
| * @return the new column |
| */ |
| private <C extends Comparable<C>> Column<ExpenseProxy, C> addColumn( |
| final CellTable<ExpenseProxy> table, final String text, |
| final Cell<C> cell, final GetValue<ExpenseProxy, C> getter) { |
| return addColumn(table, text, cell, getter, |
| createColumnComparator(getter, false), |
| createColumnComparator(getter, true)); |
| } |
| |
| /** |
| * Add a column with the specified comparators. |
| * |
| * @param <C> the column type |
| * @param table the table |
| * @param text the header text |
| * @param cell the cell used to render values |
| * @param getter the {@link GetValue} used to retrieve cell values |
| * @param ascComparator the comparator used to sort ascending |
| * @param descComparator the comparator used to sort ascending |
| * @return the new column |
| */ |
| private <C> Column<ExpenseProxy, C> addColumn( |
| final CellTable<ExpenseProxy> table, final String text, |
| final Cell<C> cell, final GetValue<ExpenseProxy, C> getter, |
| final Comparator<ExpenseProxy> ascComparator, |
| final Comparator<ExpenseProxy> descComparator) { |
| |
| // Create the column. |
| final Column<ExpenseProxy, C> column = new Column<ExpenseProxy, C>(cell) { |
| @Override |
| public C getValue(ExpenseProxy object) { |
| return getter.getValue(object); |
| } |
| }; |
| final SortableHeader header = new SortableHeader(text); |
| allHeaders.add(header); |
| |
| // Hook up sorting. |
| header.setUpdater(new ValueUpdater<String>() { |
| public void update(String value) { |
| header.setSorted(true); |
| header.toggleReverseSort(); |
| |
| for (SortableHeader otherHeader : allHeaders) { |
| if (otherHeader != header) { |
| otherHeader.setSorted(false); |
| otherHeader.setReverseSort(true); |
| } |
| } |
| |
| sortExpenses(items.getList(), header.getReverseSort() ? descComparator |
| : ascComparator); |
| table.redrawHeaders(); |
| } |
| }); |
| table.addColumn(column, header); |
| return column; |
| } |
| |
| /** |
| * Create a comparator for the column. |
| * |
| * @param <C> the column type |
| * @param getter the {@link GetValue} used to get the cell value |
| * @param descending true if descending, false if ascending |
| * @return the comparator |
| */ |
| private <C extends Comparable<C>> Comparator<ExpenseProxy> createColumnComparator( |
| final GetValue<ExpenseProxy, C> getter, final boolean descending) { |
| return new Comparator<ExpenseProxy>() { |
| public int compare(ExpenseProxy o1, ExpenseProxy o2) { |
| // Null check the row object. |
| if (o1 == null && o2 == null) { |
| return 0; |
| } else if (o1 == null) { |
| return descending ? 1 : -1; |
| } else if (o2 == null) { |
| return descending ? -1 : 1; |
| } |
| |
| // Compare the column value. |
| C c1 = getter.getValue(o1); |
| C c2 = getter.getValue(o2); |
| if (c1 == null && c2 == null) { |
| return 0; |
| } else if (c1 == null) { |
| return descending ? 1 : -1; |
| } else if (c2 == null) { |
| return descending ? -1 : 1; |
| } |
| int comparison = c1.compareTo(c2); |
| return descending ? -comparison : comparison; |
| } |
| }; |
| } |
| |
| /** |
| * Create the error message popup. |
| */ |
| private void createErrorPopup() { |
| errorPopup.setGlassEnabled(true); |
| errorPopup.setStyleName(Styles.common().popupPanel()); |
| errorPopupMessage.addStyleName(Styles.common().expenseDetailsErrorPopupMessage()); |
| |
| Button closeButton = new Button("Dismiss", new ClickHandler() { |
| public void onClick(ClickEvent event) { |
| errorPopup.hide(); |
| } |
| }); |
| |
| // Organize the widgets in the popup. |
| VerticalPanel layout = new VerticalPanel(); |
| layout.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_CENTER); |
| layout.add(errorPopupMessage); |
| layout.add(closeButton); |
| errorPopup.setWidget(layout); |
| } |
| |
| /** |
| * Return a formatted currency string. |
| * |
| * @param amount the amount in dollars |
| * @return a formatted string |
| */ |
| private String formatCurrency(double amount) { |
| boolean negative = amount < 0; |
| if (negative) { |
| amount = -amount; |
| } |
| int dollars = (int) amount; |
| int cents = (int) ((amount * 100) % 100); |
| |
| StringBuilder sb = new StringBuilder(); |
| if (negative) { |
| sb.append("-"); |
| } |
| sb.append("$"); |
| sb.append(dollars); |
| sb.append('.'); |
| if (cents < 10) { |
| sb.append('0'); |
| } |
| sb.append(cents); |
| return sb.toString(); |
| } |
| |
| /** |
| * Get the columns displayed in the expense table. |
| */ |
| private String[] getExpenseColumns() { |
| return new String[] { |
| "amount", "approval", "category", "created", "description", |
| "reasonDenied"}; |
| } |
| |
| private CellTable<ExpenseProxy> initTable() { |
| CellTable.Resources resources = GWT.create(TableResources.class); |
| table = new CellTable<ExpenseProxy>(100, resources, |
| new EntityProxyKeyProvider<ExpenseProxy>()); |
| Styles.Common common = Styles.common(); |
| |
| table.addColumnStyleName(0, common.spacerColumn()); |
| table.addColumnStyleName(1, common.expenseDetailsDateColumn()); |
| table.addColumnStyleName(3, common.expenseDetailsCategoryColumn()); |
| table.addColumnStyleName(4, common.expenseDetailsAmountColumn()); |
| table.addColumnStyleName(5, common.expenseDetailsApprovalColumn()); |
| table.addColumnStyleName(6, common.spacerColumn()); |
| |
| // Spacer column. |
| table.addColumn(new SpacerColumn<ExpenseProxy>()); |
| |
| // Created column. |
| GetValue<ExpenseProxy, Date> createdGetter = new GetValue<ExpenseProxy, Date>() { |
| public Date getValue(ExpenseProxy object) { |
| return object.getCreated(); |
| } |
| }; |
| defaultComparator = createColumnComparator(createdGetter, false); |
| Comparator<ExpenseProxy> createdDesc = createColumnComparator( |
| createdGetter, true); |
| addColumn(table, "Created", |
| new DateCell(DateTimeFormat.getFormat("MMM dd yyyy")), createdGetter, |
| defaultComparator, createdDesc); |
| lastComparator = defaultComparator; |
| |
| // Description column. |
| addColumn(table, "Description", new TextCell(), |
| new GetValue<ExpenseProxy, String>() { |
| public String getValue(ExpenseProxy object) { |
| return object.getDescription(); |
| } |
| }); |
| |
| // Category column. |
| addColumn(table, "Category", new TextCell(), |
| new GetValue<ExpenseProxy, String>() { |
| public String getValue(ExpenseProxy object) { |
| return object.getCategory(); |
| } |
| }); |
| |
| // Amount column. |
| final GetValue<ExpenseProxy, Double> amountGetter = new GetValue<ExpenseProxy, Double>() { |
| public Double getValue(ExpenseProxy object) { |
| return object.getAmount(); |
| } |
| }; |
| Comparator<ExpenseProxy> amountAsc = createColumnComparator(amountGetter, |
| false); |
| Comparator<ExpenseProxy> amountDesc = createColumnComparator(amountGetter, |
| true); |
| addColumn(table, "Amount", |
| new NumberCell(NumberFormat.getCurrencyFormat()), |
| new GetValue<ExpenseProxy, Number>() { |
| public Number getValue(ExpenseProxy object) { |
| return amountGetter.getValue(object); |
| } |
| }, amountAsc, amountDesc); |
| |
| // Dialog box to obtain a reason for a denial |
| denialPopup.addCloseHandler(new CloseHandler<PopupPanel>() { |
| public void onClose(CloseEvent<PopupPanel> event) { |
| String reasonDenied = denialPopup.getReasonDenied(); |
| ExpenseProxy record = denialPopup.getExpenseRecord(); |
| if (reasonDenied == null || reasonDenied.length() == 0) { |
| // Clear the view data. |
| final Object key = items.getKey(record); |
| approvalCell.clearViewData(key); |
| |
| // We need to redraw the table to reset the select box. |
| syncCommit(record, null); |
| } else { |
| updateExpenseRecord(record, "Denied", reasonDenied); |
| } |
| |
| // Return focus to the table. |
| table.setFocus(true); |
| } |
| }); |
| |
| // Approval column. |
| approvalCell = new ApprovalCell(); |
| Column<ExpenseProxy, String> approvalColumn = addColumn(table, |
| "Approval Status", approvalCell, new GetValue<ExpenseProxy, String>() { |
| public String getValue(ExpenseProxy object) { |
| return object.getApproval(); |
| } |
| }); |
| approvalColumn.setFieldUpdater(new FieldUpdater<ExpenseProxy, String>() { |
| public void update(int index, final ExpenseProxy object, String value) { |
| if ("Denied".equals(value)) { |
| denialPopup.setExpenseRecord(object); |
| denialPopup.setReasonDenied(object.getReasonDenied()); |
| denialPopup.popup(); |
| } else { |
| updateExpenseRecord(object, value, ""); |
| } |
| } |
| }); |
| |
| // Spacer column. |
| table.addColumn(new SpacerColumn<ExpenseProxy>()); |
| |
| return table; |
| } |
| |
| /** |
| * Refresh the total cost and approved amount. |
| */ |
| private void refreshCost() { |
| double totalCost = 0; |
| totalApproved = 0; |
| List<ExpenseProxy> records = items.getList(); |
| for (ExpenseProxy record : records) { |
| double cost = record.getAmount(); |
| totalCost += cost; |
| if (Approval.APPROVED.is(record.getApproval())) { |
| totalApproved += cost; |
| } |
| } |
| double unreconciled = totalCost - totalApproved; |
| costLabel.setInnerText(formatCurrency(totalCost)); |
| approvedLabel.setInnerText(formatCurrency(totalApproved)); |
| unreconciledLabel.setInnerText(formatCurrency(unreconciled)); |
| } |
| |
| /** |
| * Request the expenses. |
| */ |
| private void requestExpenses() { |
| // Cancel the timer since we are about to send a request. |
| refreshTimer.cancel(); |
| lastReceiver = new Receiver<List<ExpenseProxy>>() { |
| @Override |
| public void onSuccess(List<ExpenseProxy> newValues) { |
| if (this == lastReceiver) { |
| List<ExpenseProxy> list = new ArrayList<ExpenseProxy>(newValues); |
| if (lastComparator != null) { |
| sortExpenses(list, lastComparator); |
| } |
| items.setList(list); |
| refreshCost(); |
| |
| // Add the new keys and changed values to the known keys. |
| boolean isInitialData = knownExpenseKeys == null; |
| if (knownExpenseKeys == null) { |
| knownExpenseKeys = new HashMap<Object, ExpenseProxy>(); |
| } |
| for (ExpenseProxy value : newValues) { |
| Object key = items.getKey(value); |
| if (!isInitialData) { |
| ExpenseProxy existing = knownExpenseKeys.get(key); |
| if (existing == null |
| || !value.getAmount().equals(existing.getAmount()) |
| || !value.getDescription().equals(existing.getDescription()) |
| || !value.getCategory().equals(existing.getCategory())) { |
| (new PhaseAnimation.CellTablePhaseAnimation<ExpenseProxy>( |
| table, value, items)).run(); |
| } |
| } |
| knownExpenseKeys.put(key, value); |
| } |
| } |
| |
| // Reschedule the timer. |
| refreshTimer.schedule(REFRESH_INTERVAL); |
| } |
| }; |
| |
| expensesRequestFactory.expenseRequest().findExpensesByReport(report.getId()).with( |
| getExpenseColumns()).fire(lastReceiver); |
| } |
| |
| /** |
| * Save the notes that the user entered in the notes box. |
| */ |
| private void saveNotes() { |
| // Early exit if the notes haven't changed. |
| final String pendingNotes = notesBox.getText(); |
| if (pendingNotes.equals(report.getNotes())) { |
| setNotesEditState(false, false, pendingNotes); |
| return; |
| } |
| |
| // Switch to the pending view. |
| setNotesEditState(false, true, pendingNotes); |
| |
| // Submit the delta. |
| ReportRequest editRequest = expensesRequestFactory.reportRequest(); |
| ReportProxy editableReport = editRequest.edit(report); |
| editableReport.setNotes(pendingNotes); |
| editRequest.persist().using(editableReport).fire(new Receiver<Void>() { |
| @Override |
| public void onSuccess(Void ignore) { |
| } |
| }); |
| } |
| |
| /** |
| * Set the state of the notes section. |
| * |
| * @param editable true for edit state, false for view state |
| * @param pending true if changes are pending, false if not |
| * @param notesText the current notes |
| */ |
| private void setNotesEditState(boolean editable, boolean pending, |
| String notesText) { |
| notesBox.setText(notesText); |
| notes.setInnerText(notesText); |
| |
| notesBox.setVisible(editable && !pending); |
| setVisible(notes, !editable); |
| setVisible(notesEditLinkWrapper, !editable && !pending); |
| setVisible(notesPending, pending); |
| notesBox.setFocus(editable); |
| } |
| |
| /** |
| * Set the {@link ReportProxy} to show. |
| * |
| * @param report the {@link ReportProxy} |
| * @param department the selected department, or "" |
| * @param employee the selected employee, or null |
| */ |
| private void setReportRecord(ReportProxy report, String department, |
| EmployeeProxy employee) { |
| this.report = report; |
| knownExpenseKeys = null; |
| reportName.setInnerText(report.getPurpose()); |
| costLabel.setInnerText(""); |
| approvedLabel.setInnerText(""); |
| unreconciledLabel.setInnerText(""); |
| setNotesEditState(false, false, report.getNotes()); |
| items.getList().clear(); |
| totalApproved = 0; |
| |
| // Update the breadcrumb. |
| reportsLink.setText(ExpenseReportList.getBreadcrumb(department, employee)); |
| |
| // Reset sorting state of table |
| lastComparator = defaultComparator; |
| if (allHeaders.size() > 0) { |
| for (SortableHeader header : allHeaders) { |
| header.setSorted(false); |
| header.setReverseSort(true); |
| } |
| allHeaders.get(0).setSorted(true); |
| allHeaders.get(0).setReverseSort(false); |
| table.redrawHeaders(); |
| } |
| |
| // Request the expenses. |
| requestExpenses(); |
| } |
| |
| /** |
| * Show the error popup. |
| * |
| * @param errorMessage the error message |
| */ |
| private void showErrorPopup(String errorMessage) { |
| errorPopupMessage.setText(errorMessage); |
| errorPopup.center(); |
| } |
| |
| private void sortExpenses(List<ExpenseProxy> list, |
| final Comparator<ExpenseProxy> comparator) { |
| lastComparator = comparator; |
| Collections.sort(list, comparator); |
| } |
| |
| /** |
| * Update the state of a pending approval change. |
| * |
| * @param record the {@link ExpenseProxy} to sync |
| * @param message the error message if rejected, or null if accepted |
| */ |
| private void syncCommit(ExpenseProxy record, String message) { |
| final Object key = items.getKey(record); |
| if (message != null) { |
| final ApprovalViewData avd = approvalCell.getViewData(key); |
| if (avd != null) { |
| avd.reject(message); |
| } |
| } |
| |
| // Redraw the table so the changes are applied. |
| table.redraw(); |
| } |
| |
| private void updateExpenseRecord(final ExpenseProxy record, String approval, |
| String reasonDenied) { |
| // Verify that the total is under the cap. |
| if (Approval.APPROVED.is(approval) |
| && !Approval.APPROVED.is(record.getApproval())) { |
| double amount = record.getAmount(); |
| if (amount + totalApproved > MAX_COST) { |
| syncCommit(record, |
| "The total approved amount for an expense report cannot exceed $" |
| + MAX_COST + "."); |
| return; |
| } |
| } |
| |
| // Create a delta and sync with the value store. |
| ExpenseRequest editRequest = expensesRequestFactory.expenseRequest(); |
| ExpenseProxy editableRecord = editRequest.edit(record); |
| editableRecord.setApproval(approval); |
| editableRecord.setReasonDenied(reasonDenied); |
| editRequest.persist().using(editableRecord).fire(new Receiver<Void>() { |
| @Override |
| public void onSuccess(Void ignore) { |
| } |
| |
| // TODO: use onViolations for checking constraint violations. |
| }); |
| } |
| } |
