Coverage Report - org.kuali.student.common.ui.client.widgets.table.summary.SummaryTableSection
 
Classes in this File Line Coverage Branch Coverage Complexity
SummaryTableSection
0%
0/265
0%
0/152
4.16
SummaryTableSection$1
0%
0/7
N/A
4.16
 
 1  
 package org.kuali.student.common.ui.client.widgets.table.summary;
 2  
 
 3  
 import java.util.ArrayList;
 4  
 import java.util.Iterator;
 5  
 import java.util.List;
 6  
 import java.util.Map;
 7  
 
 8  
 import org.kuali.student.common.assembly.data.Data;
 9  
 import org.kuali.student.common.assembly.data.MetadataInterrogator;
 10  
 import org.kuali.student.common.assembly.data.QueryPath;
 11  
 import org.kuali.student.common.assembly.data.Data.Property;
 12  
 import org.kuali.student.common.ui.client.application.Application;
 13  
 import org.kuali.student.common.ui.client.configurable.mvc.FieldDescriptor;
 14  
 import org.kuali.student.common.ui.client.configurable.mvc.FieldDescriptorReadOnly;
 15  
 import org.kuali.student.common.ui.client.configurable.mvc.SectionTitle;
 16  
 import org.kuali.student.common.ui.client.configurable.mvc.binding.ModelWidgetBinding;
 17  
 import org.kuali.student.common.ui.client.configurable.mvc.multiplicity.MultiplicityConfiguration;
 18  
 import org.kuali.student.common.ui.client.configurable.mvc.multiplicity.MultiplicityFieldConfiguration;
 19  
 import org.kuali.student.common.ui.client.configurable.mvc.sections.Section;
 20  
 import org.kuali.student.common.ui.client.configurable.mvc.sections.VerticalSection;
 21  
 import org.kuali.student.common.ui.client.mvc.Controller;
 22  
 import org.kuali.student.common.ui.client.mvc.DataModel;
 23  
 import org.kuali.student.common.ui.client.mvc.ModelRequestCallback;
 24  
 import org.kuali.student.common.validation.dto.ValidationResultInfo;
 25  
 import org.kuali.student.common.validation.dto.ValidationResultInfo.ErrorLevel;
 26  
 
 27  
 import com.google.gwt.core.client.GWT;
 28  
 import com.google.gwt.user.client.ui.Widget;
 29  
 
 30  0
 public class SummaryTableSection extends VerticalSection {
 31  0
     SummaryTable summaryTable = new SummaryTable();
 32  0
     SummaryTableModel summaryTableModel = new SummaryTableModel();
 33  
     Controller controller;
 34  0
     DataModel comparisonModel = null;
 35  0
     List<ShowRowConditionCallback> showRowCallbacks = new ArrayList<ShowRowConditionCallback>();
 36  
 
 37  
     public SummaryTableSection(Controller controller) {
 38  0
         super();
 39  0
         this.controller = controller;
 40  0
         this.addWidget(summaryTable);
 41  0
         summaryTable.setModel(summaryTableModel);
 42  0
     }
 43  
 
 44  
     public SummaryTableSection(Controller controller, SectionTitle title) {
 45  0
         super(title);
 46  0
         this.controller = controller;
 47  0
         this.addWidget(summaryTable);
 48  0
         summaryTable.setModel(summaryTableModel);
 49  0
     }
 50  
 
 51  
     public void setContentColumnHeader1(String title) {
 52  0
         summaryTableModel.setContentColumnHeader1(title);
 53  0
     }
 54  
 
 55  
     public void setContentColumnHeader2(String title) {
 56  0
         summaryTableModel.setContentColumnHeader2(title);
 57  0
     }
 58  
 
 59  
     public String getContentColumnHeader1() {
 60  0
         return summaryTableModel.getContentColumnHeader1();
 61  
     }
 62  
 
 63  
     public String getContentColumnHeader2() {
 64  0
         return summaryTableModel.getContentColumnHeader2();
 65  
     }
 66  
 
 67  
     public void setEditable(boolean bool) {
 68  0
         summaryTableModel.setEditable(bool);
 69  0
         summaryTable.doLayout();
 70  0
         summaryTable.markDiffs("rowDiffHighlight");
 71  0
     }
 72  
     
 73  
     public void addShowRowCallback(ShowRowConditionCallback callback){
 74  0
             this.showRowCallbacks.add(callback);
 75  0
     }
 76  
     
 77  
     private void processShowConditions(SummaryTableFieldRow row, DataModel model, DataModel comparisonModel){
 78  0
             for(int i =0; i < showRowCallbacks.size(); i++){
 79  0
                     showRowCallbacks.get(i).processShowConditions(row, model, comparisonModel);
 80  
             }
 81  0
     }
 82  
 
 83  
     public void addSummaryTableFieldBlock(SummaryTableFieldBlock section) {
 84  0
         summaryTableModel.addSection(section);
 85  0
     }
 86  
     
 87  
     @Override
 88  
     public ErrorLevel processValidationResults(
 89  
                     List<ValidationResultInfo> results) {
 90  
             
 91  0
             ErrorLevel status = ErrorLevel.OK;
 92  0
             for(int i = 0; i < results.size(); i++){
 93  0
                     if(summaryTable.containsKey(results.get(i).getElement())){
 94  0
                             System.out.println(results.get(i).getElement() + " *** " + results.get(i).getErrorLevel() + " *** " + results.get(i).getMessage());
 95  0
                             if(results.get(i).getLevel().getLevel() > status.getLevel()){
 96  0
                                     status = results.get(i).getLevel();
 97  
                             }
 98  0
                             if(this.isValidationEnabled){
 99  0
                                 summaryTable.highlightRow(results.get(i).getElement(), "rowHighlight");
 100  
                         }
 101  
                     }
 102  
             }
 103  
             
 104  0
             List<ValidationResultInfo> warnings = Application.getApplicationContext().getValidationWarnings();
 105  0
             ValidationResultInfo tempVr = new ValidationResultInfo();
 106  0
             tempVr.setElement("");
 107  0
             for(int i = 0; i < warnings.size(); i++){
 108  
                     //Reformat the validation element path based on how it can be referenced in sumaryTable rowMap
 109  0
                     String element = warnings.get(i).getElement();                    
 110  0
                     if (element.startsWith("/")){                            
 111  
                             //Remove leading '/' since paths aren't stored this way in rowMap
 112  0
                             element = element.substring(1);
 113  0
                     } else if (element.matches(".*/[0-9]+")){
 114  
                             //Validation warnings returns path to individual items of simple multiplicity, 
 115  
                             //stripping of the item index to highlight the entire field. 
 116  0
                             element = element.substring(0, element.lastIndexOf("/")); 
 117  
                     }
 118  
                     
 119  0
                     if(summaryTable.containsKey(element)){
 120  0
                             if(warnings.get(i).getLevel().getLevel() > status.getLevel()){
 121  0
                                     status = warnings.get(i).getLevel();
 122  
                             }
 123  
                             
 124  0
                                summaryTable.highlightRow(element, "warning");
 125  
                     }
 126  
             }
 127  
             
 128  0
             return status;
 129  
     }
 130  
     
 131  
     @Override
 132  
     public ErrorLevel processValidationResults(List<ValidationResultInfo> results, boolean clearErrors) {
 133  0
             if(clearErrors){
 134  0
                     this.removeValidationHighlighting();
 135  
             }
 136  0
             return this.processValidationResults(results);
 137  
     }
 138  
     
 139  
     public void removeValidationHighlighting(){
 140  0
             summaryTable.clearHighlightedRows("rowHighlight");
 141  0
     }
 142  
     
 143  
     private int buildMultiplicityRows(DataModel model, DataModel compModel, SummaryTableMultiplicityFieldRow parentRow, 
 144  
                     List<SummaryTableRow> rowList, int styleLevel, Integer parentNum){
 145  0
             MultiplicityConfiguration config = parentRow.getConfig();
 146  0
             int index = rowList.indexOf(parentRow) + 1;
 147  0
             int fieldRowsCreated = 0;
 148  0
             int number = 0;
 149  0
             String path = parentRow.getConfig().getParentFd().getFieldKey();
 150  0
             if(parentNum != null){
 151  0
                     path = path.replace("*", "" + parentNum);
 152  
             }
 153  0
             Data data = null;
 154  0
             if(model != null && model.isValidPath(path)){
 155  0
                     data = model.get(QueryPath.parse(path));
 156  
             }
 157  0
                 Data compData = null;
 158  0
                 if(compModel != null && compModel.isValidPath(path)){
 159  0
                         compData = compModel.get(QueryPath.parse(path));
 160  
                 }
 161  0
             if((data != null && data.size() > 0) || (compData != null && compData.size() > 0)){
 162  0
                     Iterator<Property> itr = null;
 163  0
                     if(data != null && compData != null){
 164  0
                             if(data.size() >= compData.size()){
 165  0
                                     itr = data.iterator();
 166  
                             }
 167  
                             else{
 168  0
                                     itr = compData.iterator();
 169  
                             }
 170  
                     }
 171  0
                     else if(data != null){
 172  0
                             itr = data.iterator();
 173  
                     }
 174  
                     else{
 175  0
                             itr = compData.iterator();
 176  
                     }
 177  0
                     SummaryTableMultiplicityFieldRow currentMultiplicityRow = parentRow;
 178  0
             while (itr.hasNext()) {
 179  0
                 Property p = (Property) itr.next();
 180  0
                 if (p.getKey() instanceof Integer){
 181  0
                         number = (Integer)p.getKey();
 182  
                 }
 183  0
                         if(config.getItemLabel() != null && !config.getItemLabel().isEmpty()){
 184  0
                                 currentMultiplicityRow.setTitle(config.getItemLabel() + " "+ (number + 1));
 185  0
                                 currentMultiplicityRow.setKey(path);
 186  0
                             if(MetadataInterrogator.isRequired(config.getMetaData()) || 
 187  
                                         MetadataInterrogator.isRequiredForNextState(config.getMetaData())){
 188  0
                                     currentMultiplicityRow.setRequired(true);
 189  
                             }
 190  0
                             currentMultiplicityRow.addTitleCellStyleName("summary-table-multiplicity-level-" + styleLevel);
 191  
                         }
 192  
                         else{
 193  0
                                 currentMultiplicityRow.setShown(false);
 194  
                         }
 195  
                             //set has-data/requires data style here
 196  0
                             Map<Integer, List<MultiplicityFieldConfiguration>> fieldsCopy = config.getFields();
 197  0
                                 for(int i = 0; i < config.getFields().size(); i++){
 198  0
                                         for(int j = 0; j < config.getFields().get(i).size(); j++){
 199  
                                                 //TODO handle custom widgets (multiplicity field widget initializer)
 200  0
                                                 MultiplicityFieldConfiguration field = fieldsCopy.get(i).get(j);
 201  0
                                             String fieldKey = translatePath(field.getFieldPath(), path, number);
 202  0
                                             FieldDescriptorReadOnly fd1 = new FieldDescriptorReadOnly(fieldKey, field.getMessageKeyInfo(), field.getMetadata());
 203  0
                                             fd1.setOptional(field.isOptional());
 204  0
                                             if(field.getModelWidgetBinding() != null){
 205  0
                                                     fd1.setWidgetBinding(field.getModelWidgetBinding());
 206  
                                             }
 207  0
                                             FieldDescriptorReadOnly fd2 = new FieldDescriptorReadOnly(fieldKey, field.getMessageKeyInfo(), field.getMetadata());
 208  0
                                             fd2.setOptional(field.isOptional());
 209  0
                                             if(field.getModelWidgetBinding() != null){
 210  0
                                                     fd2.setWidgetBinding(field.getModelWidgetBinding());
 211  
                                             }
 212  0
                                             SummaryTableFieldRow row = new SummaryTableFieldRow(fd1, fd2);
 213  0
                                             row.setTemporaryRowFlag(true);
 214  0
                                             rowList.add(index, row);
 215  0
                                             index++;
 216  0
                                             fieldRowsCreated++;
 217  
                                     }
 218  
                                 }
 219  
                                 
 220  0
                             if(config.getNestedConfig() != null){
 221  0
                                     MultiplicityConfiguration nestedConfig = config.getNestedConfig();
 222  0
                                     nestedConfig.getParentFd().getFieldKey().replace(config.getParentFd().getFieldKey(), path);
 223  0
                                     SummaryTableMultiplicityFieldRow mRow = new SummaryTableMultiplicityFieldRow(nestedConfig);
 224  0
                                     mRow.setTemporaryRowFlag(true);
 225  0
                                     rowList.add(index, mRow);
 226  0
                                     index++;
 227  0
                                     fieldRowsCreated++;
 228  0
                                     int result = buildMultiplicityRows(model, compModel, mRow, rowList, styleLevel + 1, number);
 229  0
                                     index = index + result;
 230  
                                     
 231  
                             }
 232  
                             
 233  0
                             if(itr.hasNext()){
 234  0
                                     SummaryTableMultiplicityFieldRow mRow = new SummaryTableMultiplicityFieldRow(config);
 235  0
                                     mRow.setTemporaryRowFlag(true);
 236  0
                                     rowList.add(index, mRow);
 237  0
                                     index++;
 238  0
                                     fieldRowsCreated++;
 239  0
                                     currentMultiplicityRow = mRow;
 240  
                             }
 241  0
             }
 242  0
             }
 243  
             else{
 244  0
                 if(MetadataInterrogator.isRequired(config.getMetaData()) || 
 245  
                                 MetadataInterrogator.isRequiredForNextState(config.getMetaData())){
 246  0
                         if(config.getItemLabel() != null && !config.getItemLabel().isEmpty()){
 247  0
                                 parentRow.setTitle(config.getItemLabel() + " "+ (number + 1));
 248  0
                                 parentRow.setKey(path);
 249  0
                             parentRow.setRequired(true);
 250  0
                             parentRow.addTitleCellStyleName("summary-table-multiplicity-level-" + styleLevel);
 251  
                         }
 252  
                         else{
 253  0
                                 parentRow.setShown(false);
 254  
                         }
 255  
                         //set has-data/requires data style here
 256  0
                         Map<Integer, List<MultiplicityFieldConfiguration>> fields = config.getFields();
 257  0
                                 for(int i = 0; i < fields.size(); i++){
 258  0
                                         for(int j = 0; j < fields.get(i).size(); j++){
 259  
                                                 //TODO handle custom widgets (multiplicity field widget initializer)
 260  0
                                                 MultiplicityFieldConfiguration field = fields.get(i).get(j);
 261  0
                                             String fieldKey = translatePath(field.getFieldPath(), path, number);
 262  0
                                             FieldDescriptorReadOnly fd1 = new FieldDescriptorReadOnly(fieldKey, field.getMessageKeyInfo(), field.getMetadata());
 263  0
                                             fd1.setOptional(field.isOptional());
 264  0
                                             if(field.getModelWidgetBinding() != null){
 265  0
                                                     fd1.setWidgetBinding(field.getModelWidgetBinding());
 266  
                                             }
 267  0
                                             FieldDescriptorReadOnly fd2 = new FieldDescriptorReadOnly(fieldKey, field.getMessageKeyInfo(), field.getMetadata());
 268  0
                                             fd2.setOptional(field.isOptional());
 269  0
                                             if(field.getModelWidgetBinding() != null){
 270  0
                                                     fd2.setWidgetBinding(field.getModelWidgetBinding());
 271  
                                             }
 272  0
                                             SummaryTableFieldRow row = new SummaryTableFieldRow(fd1, fd2);
 273  0
                                             row.setTemporaryRowFlag(true);
 274  0
                                             rowList.add(index, row);
 275  0
                                             index++;
 276  0
                                             fieldRowsCreated++;
 277  
                                     }
 278  
                                 }
 279  
                                 
 280  
                             
 281  0
                             if(config.getNestedConfig() != null){
 282  0
                                     MultiplicityConfiguration nestedConfig = config.getNestedConfig();
 283  0
                                     nestedConfig.getParentFd().getFieldKey().replace(config.getParentFd().getFieldKey(), path);
 284  0
                                     SummaryTableMultiplicityFieldRow mRow = new SummaryTableMultiplicityFieldRow(nestedConfig);
 285  0
                                     mRow.setTemporaryRowFlag(true);
 286  0
                                     rowList.add(index, mRow);
 287  0
                                     index++;
 288  0
                                     fieldRowsCreated++;
 289  0
                                     buildMultiplicityRows(null, null, mRow, rowList, styleLevel + 1, number);
 290  
                             }
 291  0
                 }
 292  
                 else{
 293  
                         //Alternate label possibly here
 294  0
                         parentRow.setTitle(config.getItemLabel());
 295  0
                         parentRow.setRequired(false);
 296  0
                         parentRow.setKey(config.getParentFd().getFieldKey());
 297  
                         //set unrequired style here
 298  
                 }
 299  
             }
 300  0
             return fieldRowsCreated;
 301  
     }
 302  
     
 303  
     public String translatePath(String path, String parentPath, int num) {
 304  
         String fieldPath;
 305  0
         if (parentPath != null) {
 306  0
             QueryPath parent = QueryPath.concat(parentPath);
 307  0
             int i = parent.size();
 308  
 
 309  0
             QueryPath subPath = QueryPath.concat(path);
 310  0
             String itemPath =  subPath.subPath(i, subPath.size()).toString();
 311  
 
 312  0
             QueryPath qp = QueryPath.concat(parentPath, itemPath);
 313  0
             fieldPath = qp.toString();
 314  0
         }
 315  
         else {
 316  0
             fieldPath = path;
 317  
         }
 318  
 
 319  0
         fieldPath = fieldPath.replace("*", "" + num);
 320  0
         return fieldPath;
 321  
     }
 322  
     
 323  
     @Override
 324  
     public void updateWidgetData(final DataModel model) {
 325  
             
 326  0
         controller.requestModel("ComparisonModel", new ModelRequestCallback<DataModel>() {
 327  
             @Override
 328  
             public void onModelReady(DataModel otherModel) {
 329  0
                 comparisonModel = otherModel;
 330  0
                 updateTableData(model);
 331  0
             }
 332  
 
 333  
             @Override
 334  
             public void onRequestFail(Throwable cause) {
 335  0
                     comparisonModel = null;
 336  0
                     updateTableData(model);
 337  
                 //GWT.log("ComparisonModel cannot be found. " + cause.getLocalizedMessage(), null);
 338  0
             }
 339  
         });
 340  0
     }
 341  
     
 342  
     private void resetSummaryTableRows(SummaryTableFieldBlock fieldBlock){
 343  0
             List<SummaryTableRow> rowList = fieldBlock.getSectionRowList();
 344  0
             List<SummaryTableRow> removeList = new ArrayList<SummaryTableRow>();
 345  0
         for (int j = 0; j < rowList.size(); j++) {
 346  0
                  SummaryTableFieldRow fieldRow = (SummaryTableFieldRow) rowList.get(j);
 347  0
                  if(fieldRow.isTemporaryRow()){
 348  0
                          removeList.add(fieldRow);
 349  
                  }
 350  0
                  if(!fieldRow.isShown()){
 351  0
                          fieldRow.setShown(true);
 352  
                  }
 353  
         }
 354  0
         rowList.removeAll(removeList);
 355  0
     }
 356  
     
 357  
     private void buildSummaryTableMultiplicity(DataModel model, DataModel compModel, SummaryTableFieldBlock fieldBlock){
 358  0
             List<SummaryTableMultiplicityFieldRow> mRows = fieldBlock.getMultiplicityList();
 359  0
             for(int i = 0; i < mRows.size(); i++){
 360  0
                     SummaryTableMultiplicityFieldRow mRow = mRows.get(i);
 361  
                     
 362  0
                     buildMultiplicityRows(model, compModel, mRow, fieldBlock.getSectionRowList(), 1, null);
 363  
             }
 364  0
     }
 365  
     
 366  
     @SuppressWarnings("unchecked")
 367  
         private void updateTableData(DataModel model){
 368  0
             List<SummaryTableBlock> sectionList = summaryTableModel.getSectionList();
 369  0
         for (int i = 0; i < sectionList.size(); i++) {
 370  0
             SummaryTableFieldBlock fieldBlock = (SummaryTableFieldBlock) sectionList.get(i);
 371  0
             resetSummaryTableRows(fieldBlock);
 372  0
             if(!fieldBlock.getMultiplicityList().isEmpty()){
 373  0
                     buildSummaryTableMultiplicity(model, comparisonModel, fieldBlock);
 374  
             }
 375  0
             List<SummaryTableRow> rowList = fieldBlock.getSectionRowList();
 376  
             
 377  0
             for (int j = 0; j < rowList.size(); j++) {
 378  0
                 SummaryTableFieldRow fieldRow = (SummaryTableFieldRow) rowList.get(j);
 379  0
                 FieldDescriptor field = fieldRow.getFieldDescriptor1();
 380  0
                 final FieldDescriptor field2 = fieldRow.getFieldDescriptor2();
 381  0
                 boolean optional = false;
 382  0
                 boolean firstValueEmpty = true;
 383  0
                 boolean secondValueEmpty = true;
 384  
                 // for the first column
 385  0
                 if(field != null){
 386  
                         
 387  0
                         if(field instanceof FieldDescriptorReadOnly){
 388  0
                                 optional = ((FieldDescriptorReadOnly)field).isOptional();
 389  
                         }
 390  0
                         String fieldPath = QueryPath.getPathSeparator() + field.getFieldKey();
 391  0
                         if(model.isValidPath(fieldPath)){
 392  
                         
 393  0
                                 Object value = model.get(QueryPath.parse(fieldPath));
 394  0
                                 if(value != null){
 395  0
                                     if(value instanceof String && ((String)value).isEmpty()){
 396  0
                                                 firstValueEmpty = true;
 397  
                                         }
 398  0
                                     else if(value instanceof Data && ((Data) value).size() == 0){
 399  0
                                             firstValueEmpty = true;
 400  
                                     }
 401  
                                     else{
 402  0
                                             firstValueEmpty = false;
 403  
                                     }
 404  
                                 }
 405  
                                 
 406  
                                 
 407  0
                                 ModelWidgetBinding binding = field.getModelWidgetBinding();
 408  
                         
 409  0
                                 if (binding != null) {
 410  0
                                     Widget w = field.getFieldWidget();
 411  0
                                     binding.setWidgetValue(w, model, fieldPath);
 412  0
                                 } else {
 413  0
                                     GWT.log(field.getFieldKey() + " has no widget binding.", null);
 414  
                                 }
 415  
                         }
 416  
                         
 417  
                 }
 418  
 
 419  
                 // the second column
 420  0
                 if (comparisonModel == null) {
 421  0
                         if(fieldRow.getContentCellCount() == 2){
 422  0
                                 fieldRow.setContentCellCount(1);
 423  
                         }
 424  
                 }else{
 425  0
                         summaryTableModel.setContentColumnHeader1(model.getModelName());
 426  0
                         summaryTableModel.setContentColumnHeader2(comparisonModel.getModelName());
 427  0
                         if(fieldRow.getContentCellCount() == 1){
 428  0
                                 fieldRow.setContentCellCount(2);
 429  
                         }
 430  0
                         if(field2 != null){
 431  
                             
 432  0
                             String fieldPath2 = QueryPath.getPathSeparator() + field2.getFieldKey();
 433  0
                             if(comparisonModel.isValidPath(fieldPath2)){
 434  
                                     
 435  0
                                     Object value = model.get(QueryPath.parse(fieldPath2));
 436  0
                                     if(value != null){
 437  0
                                             if(value instanceof String && ((String)value).isEmpty()){
 438  0
                                                         secondValueEmpty = true;
 439  
                                                 }
 440  0
                                             else if(value instanceof Data && ((Data) value).size() == 0){
 441  0
                                                     secondValueEmpty = true;
 442  
                                             }
 443  
                                             else{
 444  0
                                                     secondValueEmpty = false;
 445  
                                             }
 446  
                                         }
 447  
                                     
 448  0
                                     ModelWidgetBinding binding2 = field2.getModelWidgetBinding();
 449  
                                     
 450  0
                                     if (binding2 != null) {
 451  0
                                         Widget w = field2.getFieldWidget();
 452  0
                                         binding2.setWidgetValue(w, comparisonModel, fieldPath2);
 453  0
                                     } else {
 454  0
                                         GWT.log(field2.getFieldKey() + " has no widget binding for the ComparisonModel.", null);
 455  
                                     }
 456  
                             }
 457  
                         }
 458  
                 }
 459  
                 
 460  0
                 if(firstValueEmpty && secondValueEmpty && optional){
 461  0
                         fieldRow.setShown(false);
 462  
                 }
 463  0
                 processShowConditions(fieldRow, model, comparisonModel);
 464  
             }
 465  
             
 466  
         }
 467  
 
 468  0
         summaryTable.doLayout();
 469  0
         summaryTable.markDiffs("rowDiffHighlight");
 470  0
     }
 471  
 
 472  
     @Override
 473  
     public String addField(FieldDescriptor fieldDescriptor) {
 474  0
         GWT.log("addField(FieldDescriptor fieldDescriptor) method not supported");
 475  0
         throw new UnsupportedOperationException("SummaryTableSection.addField(FieldDescriptor fieldDescriptor) method not supported");
 476  
     }
 477  
 
 478  
     @Override
 479  
     public String addSection(Section section) {
 480  0
         GWT.log("addSection(Section section) method not supported");
 481  0
         throw new UnsupportedOperationException("SummaryTableSection.addSection(Section section) method not supported");
 482  
     }
 483  
 
 484  
     @Override
 485  
     public String addSection(String key, Section section) {
 486  0
         GWT.log("addSection(String key, Section section) method not supported");
 487  0
         throw new UnsupportedOperationException("SummaryTableSection.addSection(String key, Section section) method not supported");
 488  
     }
 489  
 
 490  
     public SummaryTable getSummaryTable() {
 491  0
         return summaryTable;
 492  
     }
 493  
 
 494  
 }