From 9248d7dfec0951a9ce6a5d59e7c436a89c673d2e Mon Sep 17 00:00:00 2001 From: Giancarlo Panichi Date: Fri, 30 May 2014 13:41:40 +0000 Subject: [PATCH] Minor Update git-svn-id: https://svn.d4science.research-infrastructures.eu/gcube/trunk/portlets/user/tabular-data-column-widget@96330 82a268e6-3cf1-43bd-a215-b396298e98cf --- .../client/create/AddColumnPanel.java | 787 ++++++++++++++---- 1 file changed, 612 insertions(+), 175 deletions(-) diff --git a/src/main/java/org/gcube/portlets/user/td/columnwidget/client/create/AddColumnPanel.java b/src/main/java/org/gcube/portlets/user/td/columnwidget/client/create/AddColumnPanel.java index 8b29e32..1166110 100644 --- a/src/main/java/org/gcube/portlets/user/td/columnwidget/client/create/AddColumnPanel.java +++ b/src/main/java/org/gcube/portlets/user/td/columnwidget/client/create/AddColumnPanel.java @@ -2,21 +2,39 @@ package org.gcube.portlets.user.td.columnwidget.client.create; import java.util.ArrayList; +import org.gcube.portlets.user.td.columnwidget.client.dimension.CodelistSelectionDialog; +import org.gcube.portlets.user.td.columnwidget.client.dimension.CodelistSelectionListener; +import org.gcube.portlets.user.td.columnwidget.client.progress.AddColumnProgressDialog; +import org.gcube.portlets.user.td.columnwidget.client.progress.ProgressDialogListener; +import org.gcube.portlets.user.td.columnwidget.client.properties.ColumnDataPropertiesCombo; +import org.gcube.portlets.user.td.columnwidget.client.properties.ColumnDataTypeProperties; import org.gcube.portlets.user.td.columnwidget.client.properties.ColumnTypeCodeProperties; import org.gcube.portlets.user.td.columnwidget.client.properties.LocaleTypeProperties; -import org.gcube.portlets.user.td.columnwidget.client.resources.ResourceBundle; +import org.gcube.portlets.user.td.columnwidget.client.properties.TabResourceProperties; +import org.gcube.portlets.user.td.columnwidget.client.properties.TimeDimensionTypeProperties; +import org.gcube.portlets.user.td.columnwidget.client.store.ColumnDataTypeElement; +import org.gcube.portlets.user.td.columnwidget.client.store.ColumnDataTypeStore; import org.gcube.portlets.user.td.columnwidget.client.store.ColumnTypeCodeElement; import org.gcube.portlets.user.td.columnwidget.client.store.ColumnTypeCodeStore; import org.gcube.portlets.user.td.columnwidget.client.store.LocaleTypeElement; +import org.gcube.portlets.user.td.columnwidget.client.store.TimeDimensionTypeElement; +import org.gcube.portlets.user.td.columnwidget.client.store.TimeDimensionTypeStore; import org.gcube.portlets.user.td.columnwidget.client.utils.UtilsGXT3; import org.gcube.portlets.user.td.gwtservice.client.rpc.TDGWTServiceAsync; import org.gcube.portlets.user.td.gwtservice.shared.exception.TDGWTSessionExpiredException; +import org.gcube.portlets.user.td.gwtservice.shared.tr.ColumnData; import org.gcube.portlets.user.td.gwtservice.shared.tr.DefNewColumn; +import org.gcube.portlets.user.td.gwtservice.shared.tr.TabResource; +import org.gcube.portlets.user.td.gwtservice.shared.tr.column.AddColumnSession; +import org.gcube.portlets.user.td.widgetcommonevent.client.event.ChangeTableRequestEvent; import org.gcube.portlets.user.td.widgetcommonevent.client.event.SessionExpiredEvent; +import org.gcube.portlets.user.td.widgetcommonevent.client.type.ChangeTableRequestType; +import org.gcube.portlets.user.td.widgetcommonevent.client.type.ChangeTableWhy; import org.gcube.portlets.user.td.widgetcommonevent.client.type.SessionExpiredType; import org.gcube.portlets.user.td.widgetcommonevent.shared.TRId; -import org.gcube.portlets.user.td.widgetcommonevent.shared.tr.TableType; +import org.gcube.portlets.user.td.widgetcommonevent.shared.tr.column.ColumnDataType; import org.gcube.portlets.user.td.widgetcommonevent.shared.tr.column.ColumnTypeCode; +import org.gcube.portlets.user.td.widgetcommonevent.shared.tr.column.TimeDimensionType; import com.allen_sauer.gwt.log.client.Log; import com.google.gwt.core.client.GWT; @@ -26,23 +44,18 @@ import com.google.gwt.event.logical.shared.SelectionEvent; import com.google.gwt.event.logical.shared.SelectionHandler; import com.google.gwt.user.client.rpc.AsyncCallback; import com.google.web.bindery.event.shared.EventBus; -import com.sencha.gxt.cell.core.client.ButtonCell.IconAlign; import com.sencha.gxt.cell.core.client.form.ComboBoxCell.TriggerAction; -import com.sencha.gxt.core.client.dom.ScrollSupport.ScrollMode; import com.sencha.gxt.core.client.util.Margins; import com.sencha.gxt.data.shared.LabelProvider; import com.sencha.gxt.data.shared.ListStore; import com.sencha.gxt.widget.core.client.FramedPanel; import com.sencha.gxt.widget.core.client.button.TextButton; -import com.sencha.gxt.widget.core.client.container.BoxLayoutContainer.BoxLayoutData; -import com.sencha.gxt.widget.core.client.container.BoxLayoutContainer.BoxLayoutPack; -import com.sencha.gxt.widget.core.client.container.HBoxLayoutContainer; -import com.sencha.gxt.widget.core.client.container.HBoxLayoutContainer.HBoxLayoutAlign; -import com.sencha.gxt.widget.core.client.container.SimpleContainer; import com.sencha.gxt.widget.core.client.container.VerticalLayoutContainer; import com.sencha.gxt.widget.core.client.container.VerticalLayoutContainer.VerticalLayoutData; import com.sencha.gxt.widget.core.client.event.SelectEvent; import com.sencha.gxt.widget.core.client.event.SelectEvent.SelectHandler; +import com.sencha.gxt.widget.core.client.event.TriggerClickEvent; +import com.sencha.gxt.widget.core.client.event.TriggerClickEvent.TriggerClickHandler; import com.sencha.gxt.widget.core.client.form.ComboBox; import com.sencha.gxt.widget.core.client.form.FieldLabel; import com.sencha.gxt.widget.core.client.form.TextField; @@ -53,31 +66,47 @@ import com.sencha.gxt.widget.core.client.info.Info; * @author "Giancarlo Panichi" * */ -public class AddColumnPanel extends FramedPanel { +public class AddColumnPanel extends FramedPanel implements + CodelistSelectionListener, ProgressDialogListener { protected static final String WIDTH = "640px"; protected static final String HEIGHT = "520px"; - protected static final String FIELDWIDTH = "436px"; - protected static final String FIELDSHEIGHT = "130px"; protected EventBus eventBus; protected AddColumnDialog parent; protected TRId trId; - - protected TableType tableType; - + + protected AddColumnPanel thisPanel; + protected ComboBox comboColumnTypeCode = null; protected FieldLabel comboColumnTypeCodeLabel; + protected ComboBox comboMeasureType = null; + protected FieldLabel comboMeasureTypeLabel; + + protected ComboBox comboAttributeType = null; + protected FieldLabel comboAttributeTypeLabel; + + protected ComboBox comboDimensionType = null; + protected FieldLabel comboDimensionTypeLabel; + + protected ComboBox comboColumnReferenceType = null; + protected FieldLabel comboColumnReferenceTypeLabel; + protected ListStore storeComboColumnReferenceType; + + protected ComboBox comboTimeDimensionType = null; + protected FieldLabel comboTimeDimensionTypeLabel; + protected ComboBox comboLocaleType = null; protected FieldLabel comboLocaleTypeLabel; protected ListStore storeComboLocaleType; - private TextButton btnSave; - private TextButton btnClose; - private SimpleContainer form; - private VerticalLayoutContainer formLayout; - private TextField label; - private TextField defaultValue; + protected AddColumnSession addColumnSession; + protected AddColumnProgressDialog addColumnProgressDialog; + + protected TextButton btnSave; + + protected TextField label; + protected TextField defaultValue; /** * @@ -86,35 +115,14 @@ public class AddColumnPanel extends FramedPanel { */ public AddColumnPanel(AddColumnDialog parent, TRId trId, EventBus eventBus) { super(); - Log.debug("CreateDefColumnPanel[parent: "+parent+", trId: "+trId); + Log.debug("CreateDefColumnPanel[parent: " + parent + ", trId: " + trId); + this.thisPanel = this; this.parent = parent; this.eventBus = eventBus; - this.trId=trId; - retriveTableType(); - } - - private void retriveTableType() { - String tableT=trId.getTableType(); - if(tableT.compareTo(TableType.CODELIST.toString())==0){ - tableType=TableType.CODELIST; - } else { - if(tableT.compareTo(TableType.GENERIC.toString())==0){ - tableType=TableType.GENERIC; - } else { - if(tableT.compareTo(TableType.DATASET.toString())==0){ - tableType=TableType.DATASET; - } else { - UtilsGXT3.alert("Attention", "This tabular resource has type unknown"); - close(); - return; - } - } - } + this.trId = trId; init(); create(); } - - protected void init() { setWidth(WIDTH); @@ -122,42 +130,20 @@ public class AddColumnPanel extends FramedPanel { setHeaderVisible(false); setBodyBorder(false); } - - protected void create() { // Label label = new TextField(); - FieldLabel nameLabel = new FieldLabel(label, "Column Label"); // Default Value defaultValue = new TextField(); - FieldLabel defaultValueLabel = new FieldLabel(defaultValue, - "Default Value"); // comboColumnTypeCode ColumnTypeCodeProperties propsColumnTypeCode = GWT .create(ColumnTypeCodeProperties.class); ListStore storeComboTypeCode = new ListStore( propsColumnTypeCode.id()); - - switch (tableType) { - case CODELIST: - storeComboTypeCode.addAll(ColumnTypeCodeStore - .getColumnTypeCodesForCodelist()); - break; - case DATASET: - storeComboTypeCode.addAll(ColumnTypeCodeStore - .getColumnTypeCodesForDataset()); - break; - case GENERIC: - storeComboTypeCode.addAll(ColumnTypeCodeStore - .getColumnTypeCodesForGeneric()); - break; - default: - break; - - } + storeComboTypeCode.addAll(ColumnTypeCodeStore.getColumnTypeCodes(trId)); comboColumnTypeCode = new ComboBox( storeComboTypeCode, propsColumnTypeCode.label()); @@ -170,8 +156,46 @@ public class AddColumnPanel extends FramedPanel { comboColumnTypeCode.setTypeAhead(true); comboColumnTypeCode.setTriggerAction(TriggerAction.ALL); - comboColumnTypeCodeLabel = new FieldLabel(comboColumnTypeCode, - "Column Type"); + // comboMeasureType + ColumnDataTypeProperties propsMeasureType = GWT + .create(ColumnDataTypeProperties.class); + ListStore storeComboMeasureType = new ListStore( + propsMeasureType.id()); + storeComboMeasureType.addAll(ColumnDataTypeStore.getMeasureType()); + + comboMeasureType = new ComboBox( + storeComboMeasureType, propsMeasureType.label()); + Log.trace("ComboMeasureType created"); + + addHandlersForComboMeasureType(propsMeasureType.label()); + + comboMeasureType.setEmptyText("Select a measure type..."); + comboMeasureType.setWidth(191); + comboMeasureType.setTypeAhead(true); + comboMeasureType.setTriggerAction(TriggerAction.ALL); + + comboMeasureTypeLabel = new FieldLabel(comboMeasureType, "Measure Type"); + + // comboAttributeType + ColumnDataTypeProperties propsAttributeType = GWT + .create(ColumnDataTypeProperties.class); + ListStore storeComboAttributeType = new ListStore( + propsAttributeType.id()); + storeComboAttributeType.addAll(ColumnDataTypeStore.getAttributeType()); + + comboAttributeType = new ComboBox( + storeComboAttributeType, propsAttributeType.label()); + Log.trace("ComboAttributeType created"); + + addHandlersForComboAttributeType(propsAttributeType.label()); + + comboAttributeType.setEmptyText("Select a column type..."); + comboAttributeType.setWidth(191); + comboAttributeType.setTypeAhead(true); + comboAttributeType.setTriggerAction(TriggerAction.ALL); + + comboAttributeTypeLabel = new FieldLabel(comboAttributeType, + "Attribute Type"); // comboLocaleType LocaleTypeProperties propsLocaleType = GWT @@ -202,124 +226,109 @@ public class AddColumnPanel extends FramedPanel { comboLocaleTypeLabel = new FieldLabel(comboLocaleType, "Locale"); - // - form = new SimpleContainer(); - form.setWidth(FIELDWIDTH); - form.setHeight(FIELDSHEIGHT); + // comboDimensionType + TabResourceProperties propsDimensionType = GWT + .create(TabResourceProperties.class); + ListStore storeComboDimensionType = new ListStore( + propsDimensionType.id()); - formLayout = new VerticalLayoutContainer(); - formLayout.setScrollMode(ScrollMode.AUTO); + comboDimensionType = new ComboBox(storeComboDimensionType, + propsDimensionType.label()); + Log.trace("ComboDimensionType created"); - formLayout - .add(nameLabel, new VerticalLayoutData(1, -1, new Margins(0))); - formLayout.add(comboColumnTypeCodeLabel, new VerticalLayoutData(1, -1, - new Margins(0))); - formLayout.add(comboLocaleTypeLabel, new VerticalLayoutData(1, -1, - new Margins(0))); - formLayout.add(defaultValueLabel, new VerticalLayoutData(1, -1, - new Margins(0))); + addHandlersForComboDimensionType(propsDimensionType.label()); - form.add(formLayout); + comboDimensionType.setEmptyText("Select a Dimension..."); + comboDimensionType.setWidth(191); + comboDimensionType.setEditable(false); + comboDimensionType.setTriggerAction(TriggerAction.ALL); + comboDimensionTypeLabel = new FieldLabel(comboDimensionType, "Codelist"); + + // ColumnReferenceType + ColumnDataPropertiesCombo propsColumnReferenceType = GWT + .create(ColumnDataPropertiesCombo.class); + storeComboColumnReferenceType = new ListStore( + propsColumnReferenceType.id()); + + comboColumnReferenceType = new ComboBox( + storeComboColumnReferenceType, propsColumnReferenceType.label()); + Log.trace("ComboColumnReferenceType created"); + + addHandlersForComboColumnReferenceType(propsColumnReferenceType.label()); + + comboColumnReferenceType.setEmptyText("Select a Column Reference..."); + comboColumnReferenceType.setWidth(191); + comboColumnReferenceType.setEditable(false); + comboColumnReferenceType.setTriggerAction(TriggerAction.ALL); + + comboColumnReferenceTypeLabel = new FieldLabel( + comboColumnReferenceType, "Column"); + + // comboTimeDimensionType + TimeDimensionTypeProperties propsTimeDimensionType = GWT + .create(TimeDimensionTypeProperties.class); + ListStore storeComboTimeDimensionType = new ListStore( + propsTimeDimensionType.id()); + storeComboTimeDimensionType.addAll(TimeDimensionTypeStore + .getTimeDimensionType()); + comboTimeDimensionType = new ComboBox( + storeComboTimeDimensionType, propsTimeDimensionType.label()); + Log.trace("ComboTimeDimensionType created"); + + addHandlersForComboTimeDimensionType(propsTimeDimensionType.label()); + + comboTimeDimensionType.setEmptyText("Select a time dimension type..."); + comboTimeDimensionType.setWidth(191); + comboTimeDimensionType.setTypeAhead(true); + comboTimeDimensionType.setTriggerAction(TriggerAction.ALL); + + comboTimeDimensionTypeLabel = new FieldLabel(comboTimeDimensionType, + "Time Type"); + + // Save btnSave = new TextButton("Save"); - btnSave.setIcon(ResourceBundle.INSTANCE.save()); - btnSave.setIconAlign(IconAlign.RIGHT); - btnSave.setTitle("Save"); - btnSave.addSelectHandler(new SelectHandler() { + SelectHandler changeHandler = new SelectHandler() { public void onSelect(SelectEvent event) { - Log.debug("Pressed Save"); - btnSave.disable(); save(); } - }); + }; + btnSave.addSelectHandler(changeHandler); - btnClose = new TextButton("Close"); - btnClose.setIcon(ResourceBundle.INSTANCE.close()); - btnClose.setIconAlign(IconAlign.RIGHT); - btnClose.setTitle("Close"); - btnClose.addSelectHandler(new SelectHandler() { - - public void onSelect(SelectEvent event) { - Log.debug("Pressed Close"); - close(); - } - }); - - HBoxLayoutContainer flowButton = new HBoxLayoutContainer(); - flowButton.setHBoxLayoutAlign(HBoxLayoutAlign.MIDDLE); - flowButton.setPack(BoxLayoutPack.CENTER); - - flowButton.add(btnSave, new BoxLayoutData(new Margins(2, 4, 2, 4))); - flowButton.add(btnClose, new BoxLayoutData(new Margins(2, 4, 2, 4))); - - VerticalLayoutContainer vPanel = new VerticalLayoutContainer(); - vPanel.add(form, new VerticalLayoutData(1, -1)); - vPanel.add(flowButton, new VerticalLayoutData(1, -1, new Margins(1))); - add(vPanel); + VerticalLayoutContainer v = new VerticalLayoutContainer(); + v.add(new FieldLabel(label, "Label"), new VerticalLayoutData(1, -1, + new Margins(1))); + v.add(new FieldLabel(comboColumnTypeCode, "Column Type"), + new VerticalLayoutData(1, -1, new Margins(1))); + v.add(comboLocaleTypeLabel, new VerticalLayoutData(1, -1, + new Margins(1))); + v.add(comboMeasureTypeLabel, new VerticalLayoutData(1, -1, new Margins( + 1))); + v.add(comboAttributeTypeLabel, new VerticalLayoutData(1, -1, + new Margins(1))); + v.add(comboDimensionTypeLabel, new VerticalLayoutData(1, -1, + new Margins(1))); + v.add(comboColumnReferenceTypeLabel, new VerticalLayoutData(1, -1, + new Margins(1))); + v.add(comboTimeDimensionTypeLabel, new VerticalLayoutData(1, -1, + new Margins(1))); + v.add(new FieldLabel(defaultValue, "Default"), new VerticalLayoutData( + 1, -1, new Margins(1))); + v.add(btnSave, + new VerticalLayoutData(-1, -1, new Margins(10, 0, 10, 0))); + add(v, new VerticalLayoutData(-1, -1, new Margins(0))); + comboMeasureTypeLabel.setVisible(false); + comboAttributeTypeLabel.setVisible(false); + comboDimensionTypeLabel.setVisible(false); + comboColumnReferenceTypeLabel.setVisible(false); + comboTimeDimensionTypeLabel.setVisible(false); comboLocaleTypeLabel.setVisible(false); } - protected void save() { - ColumnTypeCode currentType = null; - String localeName = null; - - String lab = label.getCurrentValue(); - ColumnTypeCodeElement typeElement = comboColumnTypeCode - .getCurrentValue(); - LocaleTypeElement localeElement = comboLocaleType.getCurrentValue(); - String valueDefault = defaultValue.getCurrentValue(); - - Log.debug("CheckValue: label: " + lab + ", type: " + typeElement - + ", locale: " + localeElement + ", default: " + valueDefault); - if (lab == null || lab.isEmpty()) { - UtilsGXT3.alert("Attention", "Add a label"); - return; - } - - if (typeElement == null) { - UtilsGXT3.alert("Attention", "No type selected"); - return; - } else { - if (typeElement.getCode() == null) { - UtilsGXT3.alert("Attention", "No type selected"); - return; - } else { - currentType = typeElement.getCode(); - } - } - if (currentType != null && currentType == ColumnTypeCode.CODENAME) { - if (localeElement == null) { - UtilsGXT3.alert("Attention", "No locale selected"); - return; - } else { - if (localeElement.getLocaleName() == null - || localeElement.getLocaleName().isEmpty()) { - UtilsGXT3.alert("Attention", "No locale selected"); - return; - } else { - localeName = localeElement.getLocaleName(); - } - } - } - - - /* - DefNewColumn defNewColumn = new DefNewColumn(id, lab, currentType, - localeName, valueDefault); - Log.debug("DefNewColumn:" + defNewColumn); - */ - } - - public void close() { - if (parent != null) { - parent.close(); - } - } - protected void addHandlersForComboColumnTypeCode( final LabelProvider labelProvider) { comboColumnTypeCode @@ -343,6 +352,52 @@ public class AddColumnPanel extends FramedPanel { }); } + protected void addHandlersForComboMeasureType( + final LabelProvider labelProvider) { + comboMeasureType + .addSelectionHandler(new SelectionHandler() { + public void onSelection( + SelectionEvent event) { + Info.display( + "Measure Type Selected", + "You selected " + + (event.getSelectedItem() == null ? "nothing" + : labelProvider.getLabel(event + .getSelectedItem()) + + "!")); + Log.debug("ComboMeasureType selected: " + + event.getSelectedItem()); + ColumnDataTypeElement measureType = event + .getSelectedItem(); + updateMeasureType(measureType.getType()); + } + + }); + } + + protected void addHandlersForComboAttributeType( + final LabelProvider labelProvider) { + comboAttributeType + .addSelectionHandler(new SelectionHandler() { + public void onSelection( + SelectionEvent event) { + Info.display( + "Attribute Type Selected", + "You selected " + + (event.getSelectedItem() == null ? "nothing" + : labelProvider.getLabel(event + .getSelectedItem()) + + "!")); + Log.debug("ComboAttributeType selected: " + + event.getSelectedItem()); + ColumnDataTypeElement attributeType = event + .getSelectedItem(); + updateAttributeType(attributeType.getType()); + } + + }); + } + protected void addHandlersForComboLocaleType( final LabelProvider labelProvider) { comboLocaleType @@ -365,24 +420,366 @@ public class AddColumnPanel extends FramedPanel { }); } + protected void addHandlersForComboDimensionType( + final LabelProvider labelProvider) { + + comboDimensionType.addTriggerClickHandler(new TriggerClickHandler() { + + @Override + public void onTriggerClick(TriggerClickEvent event) { + Log.debug("ComboDimension TriggerClickEvent"); + callDialogCodelistSelection(); + comboDimensionType.collapse(); + + } + + }); + + } + + protected void addHandlersForComboColumnReferenceType( + final LabelProvider labelProvider) { + + comboColumnReferenceType + .addSelectionHandler(new SelectionHandler() { + public void onSelection(SelectionEvent event) { + Info.display( + "Column Reference Selected", + "You selected " + + (event.getSelectedItem() == null ? "nothing" + : labelProvider.getLabel(event + .getSelectedItem()) + + "!")); + Log.debug("ComboColumnReferenceType selected: " + + event.getSelectedItem()); + + } + + }); + + } + + protected void addHandlersForComboTimeDimensionType( + final LabelProvider labelProvider) { + comboTimeDimensionType + .addSelectionHandler(new SelectionHandler() { + public void onSelection( + SelectionEvent event) { + Info.display( + "Time Dimension Type Selected", + "You selected " + + (event.getSelectedItem() == null ? "nothing" + : labelProvider.getLabel(event + .getSelectedItem()) + + "!")); + Log.debug("ComboTimeDimensionType selected: " + + event.getSelectedItem()); + TimeDimensionTypeElement timeDimensionType = event + .getSelectedItem(); + updateTimeDimensionType(timeDimensionType.getType()); + } + + }); + } + protected void updateColumnType(ColumnTypeCode type) { Log.debug("Update ColumnTypeCode " + type.toString()); switch (type) { case CODENAME: comboLocaleTypeLabel.setVisible(true); - forceLayout(); + comboMeasureTypeLabel.setVisible(false); + comboAttributeTypeLabel.setVisible(false); + comboDimensionTypeLabel.setVisible(false); + comboColumnReferenceTypeLabel.setVisible(false); + comboTimeDimensionTypeLabel.setVisible(false); + break; + case ATTRIBUTE: + comboLocaleTypeLabel.setVisible(false); + comboMeasureTypeLabel.setVisible(false); + comboAttributeTypeLabel.setVisible(true); + comboDimensionTypeLabel.setVisible(false); + comboColumnReferenceTypeLabel.setVisible(false); + comboTimeDimensionTypeLabel.setVisible(false); + break; + case DIMENSION: + comboLocaleTypeLabel.setVisible(false); + comboMeasureTypeLabel.setVisible(false); + comboAttributeTypeLabel.setVisible(false); + comboDimensionTypeLabel.setVisible(true); + comboColumnReferenceTypeLabel.setVisible(false); + comboTimeDimensionTypeLabel.setVisible(false); + break; + case MEASURE: + comboLocaleTypeLabel.setVisible(false); + comboMeasureTypeLabel.setVisible(true); + comboAttributeTypeLabel.setVisible(false); + comboDimensionTypeLabel.setVisible(false); + comboColumnReferenceTypeLabel.setVisible(false); + comboTimeDimensionTypeLabel.setVisible(false); + break; + case TIMEDIMENSION: + comboLocaleTypeLabel.setVisible(false); + comboMeasureTypeLabel.setVisible(false); + comboAttributeTypeLabel.setVisible(false); + comboDimensionTypeLabel.setVisible(false); + comboColumnReferenceTypeLabel.setVisible(false); + comboTimeDimensionTypeLabel.setVisible(true); break; default: comboLocaleTypeLabel.setVisible(false); - forceLayout(); + comboMeasureTypeLabel.setVisible(false); + comboAttributeTypeLabel.setVisible(false); + comboDimensionTypeLabel.setVisible(false); + comboColumnReferenceTypeLabel.setVisible(false); + comboTimeDimensionTypeLabel.setVisible(false); break; } + + forceLayout(); + } + + protected void updateMeasureType(ColumnDataType type) { + + } + + protected void updateAttributeType(ColumnDataType type) { + } protected void updateLocaleType(LocaleTypeElement type) { } + protected void updateTimeDimensionType(TimeDimensionType type) { + + } + + public void update(TRId trId) { + this.trId = trId; + + } + + protected void save() { + DefNewColumn defNewColumn; + + String defaultV = defaultValue.getCurrentValue(); + String labelS = label.getCurrentValue(); + + if (labelS != null && !labelS.isEmpty()) { + ColumnTypeCodeElement columnTypeCodeElement = comboColumnTypeCode + .getCurrentValue(); + if (columnTypeCodeElement != null) { + ColumnTypeCode type = columnTypeCodeElement.getCode(); + ColumnDataTypeElement columnDataTypeElement; + switch (type) { + case MEASURE: + columnDataTypeElement = comboMeasureType.getCurrentValue(); + if (columnDataTypeElement != null) { + ColumnDataType dataType = columnDataTypeElement + .getType(); + if (dataType != null) { + defNewColumn = new DefNewColumn(labelS, type, + dataType, defaultV); + addColumnSession = new AddColumnSession(trId, + defNewColumn); + callAddColumm(); + } else { + UtilsGXT3.alert("Attention", + "Column data type not selected!"); + } + + } else { + UtilsGXT3.alert("Attention", + "Column data type not selected!"); + } + break; + case ATTRIBUTE: + columnDataTypeElement = comboAttributeType + .getCurrentValue(); + if (columnDataTypeElement != null) { + ColumnDataType dataType = columnDataTypeElement + .getType(); + if (dataType != null) { + defNewColumn = new DefNewColumn(labelS, type, + dataType, defaultV); + addColumnSession = new AddColumnSession(trId, + defNewColumn); + callAddColumm(); + + } else { + UtilsGXT3.alert("Attention", + "Column data type not selected!"); + } + } else { + UtilsGXT3.alert("Attention", + "Column data type not selected!"); + } + break; + case CODE: + defNewColumn = new DefNewColumn(labelS, type, defaultV); + addColumnSession = new AddColumnSession(trId, defNewColumn); + callAddColumm(); + break; + case CODENAME: + LocaleTypeElement locale = comboLocaleType + .getCurrentValue(); + if (locale != null) { + defNewColumn = new DefNewColumn(labelS, type, + locale.getLocaleName(), defaultV); + addColumnSession = new AddColumnSession(trId, + defNewColumn); + callAddColumm(); + } else { + UtilsGXT3.alert("Attention", "No locale selected!"); + } + break; + case CODEDESCRIPTION: + defNewColumn = new DefNewColumn(labelS, type, defaultV); + addColumnSession = new AddColumnSession(trId, defNewColumn); + callAddColumm(); + break; + case ANNOTATION: + defNewColumn = new DefNewColumn(labelS, type, defaultV); + addColumnSession = new AddColumnSession(trId, defNewColumn); + callAddColumm(); + break; + case DIMENSION: + ColumnData columnReference = comboColumnReferenceType + .getCurrentValue(); + if (columnReference != null) { + defNewColumn = new DefNewColumn(labelS, type, + columnReference, defaultV); + addColumnSession = new AddColumnSession(trId, + defNewColumn); + callAddColumm(); + } else { + UtilsGXT3.alert("Attention", + "No column reference selected!"); + } + break; + case TIMEDIMENSION: + TimeDimensionTypeElement timeDimensionTypeElement = comboTimeDimensionType + .getCurrentValue(); + if (timeDimensionTypeElement != null) { + TimeDimensionType timeDimensionType = timeDimensionTypeElement + .getType(); + if (timeDimensionType != null) { + defNewColumn = new DefNewColumn(labelS, type, + timeDimensionType, defaultV); + addColumnSession = new AddColumnSession(trId, + defNewColumn); + callAddColumm(); + } else { + UtilsGXT3.alert("Attention", + "Time Dimension type not selected!"); + } + + } else { + UtilsGXT3.alert("Attention", + "Time Dimension type not selected!"); + } + break; + default: + UtilsGXT3.alert("Attention", + "This column type is not supported now!"); + break; + } + } else { + UtilsGXT3.alert("Attention", "Select a column type!"); + } + } else { + UtilsGXT3.alert("Attntion", "Insert a valid label!"); + } + + } + + private void callAddColumm() { + Log.debug(addColumnSession.toString()); + TDGWTServiceAsync.INSTANCE.startAddColumn(addColumnSession, + new AsyncCallback() { + public void onFailure(Throwable caught) { + if (caught instanceof TDGWTSessionExpiredException) { + eventBus.fireEvent(new SessionExpiredEvent( + SessionExpiredType.EXPIREDONSERVER)); + } else { + Log.debug("Add Column Error: " + + caught.getLocalizedMessage()); + UtilsGXT3 + .alert("Add Column Error ", + "Error in invocation of add column operation!"); + } + } + + public void onSuccess(Void result) { + addColumnProgressDialog = new AddColumnProgressDialog( + eventBus); + addColumnProgressDialog + .addProgressDialogListener(thisPanel); + addColumnProgressDialog.show(); + } + + }); + + } + + protected void callDialogCodelistSelection() { + CodelistSelectionDialog dialogCodelistSelection = new CodelistSelectionDialog( + eventBus); + dialogCodelistSelection.addListener(this); + dialogCodelistSelection.show(); + } + + @Override + public void selected(TabResource tabResource) { + Log.debug("Selected Codelist: " + tabResource); + comboDimensionType.setValue(tabResource); + retrieveColumnData(tabResource); + } + + @Override + public void aborted() { + Log.debug("Select Codelist Aborted"); + + } + + @Override + public void failed(String reason, String detail) { + Log.error("Select Codelist Failed[reason: " + reason + " , detail:" + + detail + "]"); + + } + + protected void retrieveColumnData(TabResource tabResource) { + TDGWTServiceAsync.INSTANCE.getColumnsForDimension( + tabResource.getTrId(), + new AsyncCallback>() { + + @Override + public void onFailure(Throwable caught) { + if (caught instanceof TDGWTSessionExpiredException) { + eventBus.fireEvent(new SessionExpiredEvent( + SessionExpiredType.EXPIREDONSERVER)); + } else { + Log.debug("Error retrieving columns: " + + caught.getLocalizedMessage()); + UtilsGXT3.alert("Error retrieving columns", + "Error retrieving columns on server!"); + } + } + + @Override + public void onSuccess(ArrayList result) { + comboColumnReferenceType.reset(); + storeComboColumnReferenceType.clear(); + storeComboColumnReferenceType.addAll(result); + storeComboColumnReferenceType.commitChanges(); + comboColumnReferenceTypeLabel.setVisible(true); + forceLayout(); + } + }); + + } + protected void retriveLocales() { TDGWTServiceAsync.INSTANCE .getLocales(new AsyncCallback>() { @@ -410,11 +807,51 @@ public class AddColumnPanel extends FramedPanel { } storeComboLocaleType.addAll(locales); storeComboLocaleType.commitChanges(); + // comboColumnReferenceTypeLabel.setVisible(true); } }); } - + protected void setLocale(String locale) { + for (LocaleTypeElement loc : storeComboLocaleType.getAll()) { + if (loc.getLocaleName().compareTo(locale) == 0) { + comboLocaleType.setValue(loc); + break; + } + } + } + + public void close() { + if (parent != null) { + parent.close(); + } + } + + @Override + public void operationComplete(TRId trId) { + ChangeTableWhy why = ChangeTableWhy.TABLEUPDATED; + ChangeTableRequestEvent changeTableRequestEvent = new ChangeTableRequestEvent( + ChangeTableRequestType.ADDCOLUMN, trId, why); + eventBus.fireEvent(changeTableRequestEvent); + close(); + + } + + @Override + public void operationFailed(Throwable caught, String reason) { + UtilsGXT3.alert("Error in Add Column", reason); + close(); + } + + @Override + public void operationStopped(TRId trId, String reason, String details) { + ChangeTableWhy why = ChangeTableWhy.TABLECURATION; + ChangeTableRequestEvent changeTableRequestEvent = new ChangeTableRequestEvent( + ChangeTableRequestType.ADDCOLUMN, trId, why); + eventBus.fireEvent(changeTableRequestEvent); + close(); + } + }