gerrit.onap Code Review - portal/sdk.git/blob

   1 /*
   2  * ============LICENSE_START==========================================
   3  * ONAP Portal SDK
   4  * ===================================================================
   5  * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
   6  * ===================================================================
   7  *
   8  * Unless otherwise specified, all software contained herein is licensed
   9  * under the Apache License, Version 2.0 (the "License");
  10  * you may not use this software except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *             http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  * Unless otherwise specified, all documentation contained herein is licensed
  22  * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
  23  * you may not use this documentation except in compliance with the License.
  24  * You may obtain a copy of the License at
  25  *
  26  *             https://creativecommons.org/licenses/by/4.0/
  27  *
  28  * Unless required by applicable law or agreed to in writing, documentation
  29  * distributed under the License is distributed on an "AS IS" BASIS,
  30  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  31  * See the License for the specific language governing permissions and
  32  * limitations under the License.
  33  *
  34  * ============LICENSE_END============================================
  35  *
  36  *
  37  */
  38 package org.onap.portalsdk.analytics.model.definition;
  39
  40 import java.io.Serializable;
  41 import java.sql.Connection;
  42 import java.util.Calendar;
  43 import java.util.Collections;
  44 import java.util.Iterator;
  45 import java.util.List;
  46 import java.util.StringTokenizer;
  47 import java.util.Vector;
  48 import java.util.regex.Matcher;
  49 import java.util.regex.Pattern;
  50
  51 import javax.servlet.http.HttpServletRequest;
  52 import javax.xml.bind.JAXBException;
  53 import javax.xml.datatype.DatatypeConfigurationException;
  54 import javax.xml.datatype.DatatypeFactory;
  55
  56 import org.onap.portalsdk.analytics.controller.WizardSequence;
  57 import org.onap.portalsdk.analytics.controller.WizardSequenceCrossTab;
  58 import org.onap.portalsdk.analytics.controller.WizardSequenceDashboard;
  59 import org.onap.portalsdk.analytics.controller.WizardSequenceLinear;
  60 import org.onap.portalsdk.analytics.controller.WizardSequenceSQLBasedCrossTab;
  61 import org.onap.portalsdk.analytics.controller.WizardSequenceSQLBasedHive;
  62 import org.onap.portalsdk.analytics.controller.WizardSequenceSQLBasedLinear;
  63 import org.onap.portalsdk.analytics.controller.WizardSequenceSQLBasedLinearDatamining;
  64 import org.onap.portalsdk.analytics.error.RaptorException;
  65 import org.onap.portalsdk.analytics.model.DataCache;
  66 import org.onap.portalsdk.analytics.model.ReportLoader;
  67 import org.onap.portalsdk.analytics.model.base.OrderBySeqComparator;
  68 import org.onap.portalsdk.analytics.model.base.OrderSeqComparator;
  69 import org.onap.portalsdk.analytics.model.base.ReportWrapper;
  70 import org.onap.portalsdk.analytics.model.runtime.FormField;
  71 import org.onap.portalsdk.analytics.system.AppUtils;
  72 import org.onap.portalsdk.analytics.system.DbUtils;
  73 import org.onap.portalsdk.analytics.system.Globals;
  74 import org.onap.portalsdk.analytics.util.AppConstants;
  75 import org.onap.portalsdk.analytics.util.DataSet;
  76 import org.onap.portalsdk.analytics.util.RemDbInfo;
  77 import org.onap.portalsdk.analytics.util.Utils;
  78 import org.onap.portalsdk.analytics.xmlobj.ChartAdditionalOptions;
  79 import org.onap.portalsdk.analytics.xmlobj.ChartDrillOptions;
  80 import org.onap.portalsdk.analytics.xmlobj.ColFilterType;
  81 import org.onap.portalsdk.analytics.xmlobj.CustomReportType;
  82 import org.onap.portalsdk.analytics.xmlobj.DataColumnList;
  83 import org.onap.portalsdk.analytics.xmlobj.DataColumnType;
  84 import org.onap.portalsdk.analytics.xmlobj.DataSourceType;
  85 import org.onap.portalsdk.analytics.xmlobj.DataminingOptions;
  86 import org.onap.portalsdk.analytics.xmlobj.FormFieldList;
  87 import org.onap.portalsdk.analytics.xmlobj.FormFieldType;
  88 import org.onap.portalsdk.analytics.xmlobj.FormatList;
  89 import org.onap.portalsdk.analytics.xmlobj.FormatType;
  90 import org.onap.portalsdk.analytics.xmlobj.JavascriptItemType;
  91 import org.onap.portalsdk.analytics.xmlobj.ObjectFactory;
  92 import org.onap.portalsdk.analytics.xmlobj.PredefinedValueList;
  93 import org.onap.portalsdk.analytics.xmlobj.SemaphoreType;
  94 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
  95 import org.springframework.beans.factory.annotation.Autowired;
  96 import org.springframework.stereotype.Component;
  97
  98 /**<HR/>
  99  * This class is part of <B><I>RAPTOR (Rapid Application Programming Tool for OLAP Reporting)</I></B><BR/>
 100  * <HR/>
 101  *
 102  * --------------------------------------------------------------------------------------------------<BR/>
 103  * <B>ReportDefinition.java</B> - This involves in creating and modifying RAPTOR reports.
 104  * --------------------------------------------------------------------------------------------------<BR/>
 105  *
 106  *
 107  * <U>Change Log</U><BR/><BR/>
 108  *
 109  * 18-Aug-2009 : Version 8.5.1 (Sundar);<UL><LI> request Object is passed to prevent caching user/roles - Datamining/Hosting. </LI></UL>
 110  * 27-Jul-2009 : Version 8.4 (Sundar); <UL><LI>userIsAuthorizedToSeeLog is checked for Admin User instead of Super User.</LI></UL>
 111  * 22-Jun-2009 : Version 8.4 (Sundar); <UL><LI>A new type ChartAdditionalOptions is introduced in RAPTOR XSD.
 112  * For this type a create procedure is added to this class.</LI></UL>
 113  *
 114  */
 115
 116 @Component
 117 public class ReportDefinition extends ReportWrapper implements Serializable {
 118
 119         private static transient final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ReportDefinition.class);
 120
 121         protected static RemDbInfo remDbInfo;
 122
 123         @SuppressWarnings("static-access")
 124         @Autowired
 125     public void setRemDbInfo(RemDbInfo remDbInfo) {
 126                 this.remDbInfo = remDbInfo;
 127         }
 128
 129         private ReportSchedule reportSchedule = null;
 130
 131         private WizardSequence wizardSequence = null;
 132
 133
 134         private boolean reportUpdateLogged = false; // Used to avoid multiple
 135                                                                                                 // entries in the report log
 136                                                                                                 // when persisting report on
 137                                                                                                 // each step
 138
 139         public ReportDefinition() {
 140                 super();
 141         }
 142
 143         private ReportDefinition(CustomReportType crType, String reportID, String ownerID,
 144                         String createID, String createDate, String updateID, String updateDate,
 145                         String menuID, boolean menuApproved, HttpServletRequest request) throws RaptorException {
 146                 super(crType, reportID, ownerID, createID, createDate, updateID, updateDate, menuID,
 147                                 menuApproved);
 148         if("-1".equals(reportID))
 149                 reportSchedule = new ReportSchedule(getReportID(), getOwnerID(), false, request);
 150         else
 151                 reportSchedule = new ReportSchedule(getReportID(), getOwnerID(), true, request);
 152                 generateWizardSequence(null);
 153         } // ReportDefinition
 154
 155         public ReportDefinition(ReportWrapper rw, HttpServletRequest request)throws RaptorException {
 156                 super(rw);
 157
 158                 reportSchedule = new ReportSchedule(reportID, rw.getOwnerID(),false, request);
 159                 generateWizardSequence(null);
 160         } // ReportDefinition
 161
 162         private void setReportID(String reportID) {
 163                 this.reportID = reportID;
 164                 reportSchedule.setReportID(reportID);
 165                 reportSchedule.setScheduleUserID(getOwnerID());
 166         } // setReportID
 167
 168         public ReportSchedule getReportSchedule() {
 169                 return reportSchedule;
 170         }
 171
 172         public static ReportDefinition unmarshal(String reportXML, String reportID, HttpServletRequest request)
 173                         throws RaptorException {
 174                 ReportDefinition rn = null;
 175                 CustomReportType crType = ReportWrapper.unmarshalCR(reportXML);
 176
 177                         logger.debug(EELFLoggerDelegate.debugLogger, ("[DEBUG MESSAGE FROM RAPTOR] Report [" + reportID + "]: XML unmarshalled"));
 178
 179                         rn = new ReportDefinition(crType, reportID, null, null, null, null, null, null, false, request);
 180                         return rn;
 181         } // unmarshal
 182
 183         public static ReportDefinition createBlank(HttpServletRequest request) throws RaptorException {
 184                 String curTime = Utils.getCurrentDateTime();
 185                 String userID = AppUtils.getUserID(request);
 186                 return new ReportDefinition(ReportWrapper.createBlankCR(userID), "-1",
 187                                 userID, userID, curTime, userID, curTime, "", false, request);
 188         } // ReportDefinition
 189
 190         public void setAsCopy(HttpServletRequest request) throws RaptorException  {
 191                 verifySQLBasedReportAccess(request);
 192
 193                 replaceCustomReportWithClone();
 194
 195                 setReportID("-1");
 196                 setReportName("Copy: " + getReportName());
 197         } // setAsCopy
 198
 199         public WizardSequence getWizardSequence() {
 200                 return wizardSequence;
 201         } // getWizardSequence
 202
 203         public void generateWizardSequence(HttpServletRequest request) throws RaptorException {
 204                 boolean userIsAuthorizedToSeeLog = false;
 205                 String userId = null;
 206                 if(request!=null) {
 207                         userId = AppUtils.getUserID(request);
 208                 if (userId != null)
 209                         userIsAuthorizedToSeeLog = AppUtils.isAdminUser(request);
 210                 }
 211                 if (getReportType().equals(AppConstants.RT_LINEAR)){
 212                         if (getReportDefType().equals(AppConstants.RD_SQL_BASED))
 213                                 wizardSequence = new WizardSequenceSQLBasedLinear(userIsAuthorizedToSeeLog);
 214                         else if (getReportDefType().equals(AppConstants.RD_SQL_BASED_DATAMIN))
 215                                 wizardSequence = new WizardSequenceSQLBasedLinearDatamining(userIsAuthorizedToSeeLog);
 216                         else
 217                                 wizardSequence = new WizardSequenceLinear(userIsAuthorizedToSeeLog);
 218                 } else if (getReportType().equals(AppConstants.RT_CROSSTAB)) {
 219                         if (getReportDefType().equals(AppConstants.RD_SQL_BASED))
 220                                 wizardSequence = new WizardSequenceSQLBasedCrossTab(userIsAuthorizedToSeeLog);
 221                         else
 222                                 wizardSequence = new WizardSequenceCrossTab(userIsAuthorizedToSeeLog);
 223                 } else if (getReportType().equals(AppConstants.RT_DASHBOARD)) {
 224                         wizardSequence = new WizardSequenceDashboard(userIsAuthorizedToSeeLog);
 225                 } else if (getReportType().equals(AppConstants.RT_HIVE)) {
 226                         wizardSequence = new WizardSequenceSQLBasedHive(userIsAuthorizedToSeeLog);
 227                 } else
 228                         wizardSequence = new WizardSequence();
 229         } // generateWizardSequence
 230
 231         private boolean canPersistDashboard() {
 232
 233            return nvl(getDashboardLayoutJSON()).length() > 0;
 234         } //canPersistDashboard
 235
 236         private boolean canPersistLinearReport() {
 237                 logger.debug(EELFLoggerDelegate.debugLogger,"&&&&&&&&&&&&&&&&&&&&&& canPersistLinearReport");
 238                 boolean visibleColExist = false;
 239
 240                 if (!getDataSourceList().getDataSource().isEmpty()) {
 241                         for (Iterator iter = getAllColumns().iterator(); iter.hasNext();) {
 242                                 DataColumnType dct = (DataColumnType) iter.next();
 243
 244                                 if (dct.isVisible()) {
 245                                         visibleColExist = true;
 246                                         break;
 247                                 }
 248                         } // for
 249                 } // if
 250
 251                 logger.debug(EELFLoggerDelegate.debugLogger,"&&&&&&&&&&&&&&&&&&&&&& visibleColExist " + visibleColExist);
 252                 return visibleColExist;
 253         } // canPersistLinearReport
 254
 255         private boolean canPersistCrossTabReport() {
 256                 boolean rowColExist = false;
 257                 boolean colColExist = false;
 258                 boolean valColExist = false;
 259
 260                 if (!getDataSourceList().getDataSource().isEmpty()) {
 261                         for (Iterator iter = getAllColumns().iterator(); iter.hasNext();) {
 262                                 DataColumnType dct = (DataColumnType) iter.next();
 263
 264                                 if (nvl(dct.getCrossTabValue()).equals(AppConstants.CV_ROW))
 265                                         rowColExist = true;
 266                                 if (nvl(dct.getCrossTabValue()).equals(AppConstants.CV_COLUMN))
 267                                         colColExist = true;
 268                                 if (nvl(dct.getCrossTabValue()).equals(AppConstants.CV_VALUE))
 269                                         valColExist = true;
 270                         } // for
 271                 } // if
 272
 273                 return rowColExist && colColExist && valColExist;
 274         } // canPersistCrossTabReport
 275
 276         private boolean canPersistReport() {
 277                 String reportType  = getReportType();
 278                 return getReportType().equals(AppConstants.RT_CROSSTAB) ? canPersistCrossTabReport()
 279                                 : (getReportType().equals(AppConstants.RT_LINEAR)? canPersistLinearReport()
 280                                                 :(getReportType().equals(AppConstants.RT_HIVE)? canPersistLinearReport()
 281                                                                 :canPersistDashboard()));
 282         } // canPersistReport
 283
 284         public void persistReport(HttpServletRequest request) throws RaptorException {
 285                 if (!canPersistReport()) {
 286                         logger.debug(EELFLoggerDelegate.debugLogger,"&&&&&&&&&&&&&&&&&&&&&& In !canPersistReport ReportType: " + getReportType());
 287                         return;
 288                 } else {
 289                         logger.debug(EELFLoggerDelegate.debugLogger,"&&&&&&&&&&&&&&&&&&&&&&  Not In !canPersistReport");
 290                 }
 291
 292                 Connection connection = null;
 293                 try {
 294                         String userID = AppUtils.getUserID(request);
 295                         String reportXML = marshal();
 296                         logger.debug(EELFLoggerDelegate.debugLogger, ("Ocurring during Schedule "));
 297                         logger.debug(EELFLoggerDelegate.debugLogger,"&&&&&&&&&&&&&&&&&&&&&&  Report ID " + reportID);
 298                         if ("-1".equals(nvl(reportID, "-1"))) {
 299                 connection = DbUtils.startTransaction();
 300                                 // Add report
 301                 String sql = "";
 302                 if (nvl(Globals.getAdhocReportSequence()).length()> 0 && nvl(Globals.getAdhocUserRoldId()).length() > 0 && AppUtils.isUserInRole(request, Globals.getAdhocUserRoldId()) && !AppUtils.isAdminUser(request)) {
 303                         sql = Globals.getPersistReportAdhoc();
 304                         sql = sql.replace("[Globals.getAdhocReportSequence()]", Globals.getAdhocReportSequence());
 305
 306                 } else{
 307                         sql = Globals.getNewReportData();
 308                 }
 309                 DataSet ds = DbUtils.executeQuery(connection,sql);
 310                                 setReportID(ds.getString(0, 0));
 311
 312                                 //Start - Added new code
 313                                 ReportDefinition rdef = (ReportDefinition) request.getSession().getAttribute(AppConstants.SI_REPORT_DEFINITION);
 314                                 if(rdef != null) {
 315                                         rdef.setReportID(ds.getString(0, 0));
 316                                 }
 317                                 request.getSession().setAttribute(AppConstants.SI_REPORT_DEFINITION, rdef);
 318                                 //End - Added new code
 319
 320                                 reportSecurity.reportCreate(reportID, userID, isPublic());
 321                                 ReportLoader.createCustomReportRec(connection, this, reportXML);
 322                                 ReportLoader.createReportLogEntry(connection, reportID, userID,
 323                                                 AppConstants.RLA_CREATE, "", "");
 324                                 reportUpdateLogged = true;
 325                                 logger.debug(EELFLoggerDelegate.debugLogger, ("[DEBUG MESSAGE FROM RAPTOR] DB insert report " + reportID + " succesfull"));
 326                         } else {
 327                                 // Update report
 328                                 verifySQLBasedReportAccess(request);
 329                                 reportSecurity.reportUpdate(request);
 330                 connection = DbUtils.startTransaction();
 331                                 ReportLoader.updateCustomReportRec(connection, this, reportXML);
 332                                 if (!reportUpdateLogged) {
 333                                         ReportLoader.createReportLogEntry(connection, reportID, userID,
 334                                                         AppConstants.RLA_UPDATE,"","");
 335                                         reportUpdateLogged = true;
 336                                 } // if
 337                                 logger.debug(EELFLoggerDelegate.debugLogger, ("[DEBUG MESSAGE FROM RAPTOR] DB update report " + reportID + " succesfull"));
 338                         }
 339
 340                         getReportSchedule().persistScheduleData(connection, request);
 341
 342                         DbUtils.commitTransaction(connection);
 343                 } catch (RaptorException e) {
 344                     logger.debug(EELFLoggerDelegate.errorLogger, "RaptorException in persistReport", e);
 345                         DbUtils.rollbackTransaction(connection);
 346                         throw e;
 347                 } finally {
 348                 DbUtils.clearConnection(connection);
 349         }
 350         } // persistReport
 351
 352         public String getCrossTabDisplayValue(String crossTabValue) {
 353                 return nvl(crossTabValue).equals(AppConstants.CV_ROW) ? "Row headings" : (nvl(
 354                                 crossTabValue).equals(AppConstants.CV_COLUMN) ? "Column headings" : (nvl(
 355                                 crossTabValue).equals(AppConstants.CV_VALUE) ? "Report values" : "Invisible/Filter"));
 356         } // getCrossTabDisplayValue
 357
 358         public String getCrossTabDisplayValue(DataColumnType dct) {
 359                 return getCrossTabDisplayValue(dct.getCrossTabValue());
 360         } // getCrossTabDisplayValue
 361
 362         public String getColumnLabel(DataColumnType dct) throws Exception {
 363                 String tableName = getTableById(dct.getTableId()).getTableName();
 364                 Vector dbColumns = null;
 365                 dbColumns = DataCache.getReportTableDbColumns(tableName, cr.getDbInfo());
 366                 if (dbColumns != null)
 367                         for (int i = 0; i < dbColumns.size(); i++) {
 368                                 DBColumnInfo dbCol = (DBColumnInfo) dbColumns.get(i);
 369                                 if (dct.getDbColName().equals(dbCol.getColName()))
 370                                         return dbCol.getLabel();
 371                         } // for
 372
 373                 return "";
 374         } // getCrossTabDisplayValue
 375
 376         public String getFilterLabel(ColFilterType cft) {
 377                 StringBuffer fLabel = new StringBuffer();
 378
 379                 fLabel.append(cft.getExpression());
 380                 fLabel.append(" ");
 381                 if (cft.getArgType() != null)
 382                         if (cft.getArgType().equals(AppConstants.AT_FORMULA)) {
 383                                 fLabel.append("[" + cft.getArgValue() + "]");
 384                         } else if (cft.getArgType().equals(AppConstants.AT_VALUE)) {
 385                                 fLabel.append(cft.getArgValue());
 386                         } else if (cft.getArgType().equals(AppConstants.AT_LIST)) {
 387                                 fLabel.append("(" + cft.getArgValue() + ")");
 388                         } else if (cft.getArgType().equals(AppConstants.AT_COLUMN)) {
 389                                 DataColumnType dctFilter = getColumnById(cft.getArgValue());
 390                                 fLabel.append("[" + dctFilter.getDisplayName() + "]");
 391                         } else if (cft.getArgType().equals(AppConstants.AT_FORM)) {
 392                                 fLabel.append("[Form Field]");
 393                         }
 394
 395                 return fLabel.toString();
 396         } // getFilterLabel
 397
 398         public Vector getReportUsers(HttpServletRequest request) throws RaptorException {
 399                 return reportSecurity.getReportUsers(request);
 400         } // getReportUsers
 401
 402         public Vector getReportRoles(HttpServletRequest request) throws RaptorException {
 403                 return reportSecurity.getReportRoles(request);
 404         } // getReportRoles
 405
 406         /** ************************************************************************************************* */
 407
 408         public void clearAllDrillDowns() {
 409                 List reportCols = getAllColumns();
 410                 for (int i = 0; i < reportCols.size(); i++) {
 411                         DataColumnType dct = (DataColumnType) reportCols.get(i);
 412                         dct.setDrillDownURL(null);
 413                         dct.setDrillDownParams(null);
 414                         dct.setDrillDownType(null);
 415                 } // for
 416         } // clearAllDrillDowns
 417
 418         public void setOuterJoin(DataSourceType curTable, String joinType) {
 419                 String refDefinition = nvl(curTable.getRefDefinition());
 420                 int outerJoinIdx = refDefinition.indexOf(" (+)");
 421                 if (outerJoinIdx >= 0)
 422                         // Clear existing outer join
 423                         if (outerJoinIdx == (refDefinition.length() - 4))
 424                                 refDefinition = refDefinition.substring(0, outerJoinIdx);
 425                         else
 426                                 refDefinition = refDefinition.substring(0, outerJoinIdx)
 427                                                 + refDefinition.substring(outerJoinIdx + 4);
 428
 429                 int equalSignIdx = refDefinition.indexOf("=");
 430                 if (equalSignIdx < 0)
 431                         // Ref. definition not present
 432                         return;
 433
 434                 if (refDefinition.indexOf(curTable.getTableId()) < equalSignIdx) {
 435                         // Cur. table is on the left side
 436                         if (nvl(joinType).equals(AppConstants.OJ_CURRENT))
 437                                 refDefinition = refDefinition.substring(0, equalSignIdx) + " (+)"
 438                                                 + refDefinition.substring(equalSignIdx);
 439                         else if (nvl(joinType).equals(AppConstants.OJ_JOINED))
 440                                 refDefinition = refDefinition + " (+)";
 441                 } else {
 442                         // Joined table is on the left side
 443                         if (nvl(joinType).equals(AppConstants.OJ_CURRENT))
 444                                 refDefinition = refDefinition + " (+)";
 445                         else if (nvl(joinType).equals(AppConstants.OJ_JOINED))
 446                                 refDefinition = refDefinition.substring(0, equalSignIdx) + " (+)"
 447                                                 + refDefinition.substring(equalSignIdx);
 448                 }
 449
 450                 curTable.setRefDefinition(refDefinition);
 451         } // setOuterJoin
 452
 453         public void addDataSourceType(ObjectFactory objFactory, String tableId, String tableName,
 454                         String tablePK, String displayName, String refTableId, String refDefinition,
 455                         String comment) throws RaptorException {
 456                 DataSourceType dst = objFactory.createDataSourceType();
 457
 458                 dst.setTableId(tableId);
 459                 dst.setTableName(tableName);
 460                 dst.setTablePK(tablePK);
 461                 dst.setDisplayName(displayName);
 462                 if (nvl(refTableId).length() > 0)
 463                         dst.setRefTableId(refTableId);
 464                 if (nvl(refDefinition).length() > 0)
 465                         dst.setRefDefinition(refDefinition);
 466                 if (nvl(comment).length() > 0)
 467                         dst.setComment(comment);
 468
 469                 DataColumnList dataColumnList = objFactory.createDataColumnList();
 470                 dst.setDataColumnList(dataColumnList);
 471
 472                 getDataSourceList().getDataSource().add(dst);
 473
 474                 resetCache(true);
 475         } // addDataSourceType
 476
 477         public void deleteDataSourceType(String tableId) {
 478                 super.deleteDataSourceType(tableId);
 479         } // deleteDataSourceType
 480
 481         public String getUniqueColumnId(String colName) {
 482                 String colId = "";
 483
 484                 int colIdN = getAllColumns().size() + 1;
 485                 do {
 486                         colId = colName.substring(0, 2).toLowerCase() + (colIdN++);
 487                 } while (getColumnById(colId) != null);
 488
 489                 return colId;
 490         } // getUniqueColumnId
 491
 492         public DataColumnType addDataColumnType(ObjectFactory objFactory, String colId,
 493                         String tableId, // Table to which the new column belongs
 494                         String dbColName, String crossTabValue, String colName, String displayName,
 495                         int displayWidth, String displayAlignment, int orderSeq, boolean visible,
 496                         boolean calculated, String colType, String colFormat, boolean groupBreak,
 497                         int orderBySeq, String orderByAscDesc, String displayTotal, String colOnChart,
 498                         int chartSeq, String drillDownType, String drillDownURL, String drillDownParams,
 499                         String semaphoreId, String comment) throws RaptorException {
 500                 DataColumnType dct = null;
 501                         dct = objFactory.createDataColumnType();
 502
 503                         dct.setColId(colId);
 504                         dct.setTableId(tableId);
 505                         dct.setDbColName(dbColName);
 506                         if (nvl(crossTabValue).length() > 0)
 507                                 dct.setCrossTabValue(crossTabValue);
 508                         dct.setColName(colName);
 509                         dct.setDisplayName(displayName);
 510                         if (displayWidth > 0)
 511                                 dct.setDisplayWidth(displayWidth);
 512                         if (nvl(displayAlignment).length() > 0)
 513                                 dct.setDisplayAlignment(displayAlignment);
 514                         if (orderSeq > 0)
 515                                 dct.setOrderSeq(orderSeq);
 516                         else
 517                                 dct.setOrderSeq(getAllColumns().size() + 1);
 518                         dct.setVisible(visible);
 519                         dct.setCalculated(calculated);
 520                         if (nvl(colFormat).length() > 0)
 521                                 dct.setColFormat(colFormat);
 522                         dct.setGroupBreak(groupBreak);
 523                         if (orderBySeq > 0)
 524                                 dct.setOrderBySeq(orderBySeq);
 525                         if (nvl(orderByAscDesc).length() > 0)
 526                                 dct.setOrderByAscDesc(orderByAscDesc);
 527                         if (nvl(displayTotal).length() > 0)
 528                                 dct.setDisplayTotal(displayTotal);
 529                         if (nvl(colOnChart).length() > 0)
 530                                 dct.setColOnChart(colOnChart);
 531                         if (chartSeq > 0)
 532                                 dct.setChartSeq(chartSeq);
 533                         if (nvl(drillDownType).length() > 0)
 534                                 dct.setDrillDownType(drillDownType);
 535                         if (nvl(drillDownURL).length() > 0)
 536                                 dct.setDrillDownURL(drillDownURL);
 537                         if (nvl(drillDownParams).length() > 0)
 538                                 dct.setDrillDownParams(drillDownParams);
 539                         if (nvl(semaphoreId).length() > 0)
 540                                 dct.setSemaphoreId(semaphoreId);
 541                         if (nvl(comment).length() > 0)
 542                                 dct.setComment(comment);
 543
 544                         dct.setDbColType(colType);
 545                         adjustColumnType(dct);
 546
 547                         getTableById(tableId).getDataColumnList().getDataColumn().add(dct);
 548
 549                         resetCache(false);
 550
 551                 return dct;
 552         } // addDataColumnType
 553
 554         public void deleteDataColumnType(String colId) {
 555                 int colOrder = getColumnById(colId).getOrderSeq();
 556
 557                 List dcList = getColumnTableById(colId).getDataColumnList().getDataColumn();
 558                 for (Iterator iterC = dcList.iterator(); iterC.hasNext();) {
 559                         DataColumnType dct = (DataColumnType) iterC.next();
 560
 561                         if (dct.getColId().equals(colId) && dct.getOrderSeq() == colOrder)
 562                                 iterC.remove();
 563                         else if (dct.getOrderSeq() > colOrder)
 564                                 dct.setOrderSeq(dct.getOrderSeq() - 1);
 565                 } // for
 566
 567                 if (getFormFieldList() != null)
 568                         for (Iterator iter = getFormFieldList().getFormField().iterator(); iter.hasNext();) {
 569                                 FormFieldType fft = (FormFieldType) iter.next();
 570                                 if (nvl(fft.getColId()).equals(colId)) {
 571                                         fft.setColId("");
 572                                         fft.setFieldType(FormField.FFT_TEXT);
 573                                         if (nvl(fft.getDefaultValue()).equals(AppConstants.FILTER_MAX_VALUE)
 574                                                         || nvl(fft.getDefaultValue())
 575                                                                         .equals(AppConstants.FILTER_MIN_VALUE))
 576                                                 fft.setDefaultValue("");
 577                                 } // if
 578                         } // for
 579
 580                 resetCache(false);
 581                 resetColumnOrderValues();
 582         } // deleteDataColumnType
 583
 584         public void shiftColumnOrderUp(String colId) {
 585                 List reportCols = getAllColumns();
 586                 for (int i = 0; i < reportCols.size(); i++) {
 587                         DataColumnType dct = (DataColumnType) reportCols.get(i);
 588
 589                         if (dct.getColId().equals(colId) && (i > 0)) {
 590                                 DataColumnType dctUp = (DataColumnType) reportCols.get(i - 1);
 591                                 dctUp.setOrderSeq(dctUp.getOrderSeq() + 1);
 592                                 dct.setOrderSeq(dct.getOrderSeq() - 1);
 593                                 break;
 594                         } // if
 595                 } // for
 596
 597                 Collections.sort(reportCols, new OrderSeqComparator());
 598                 resetCache(true);
 599                 resetColumnOrderValues();
 600         } // shiftColumnOrderUp
 601
 602         public void shiftColumnOrderDown(String colId) {
 603                 List reportCols = getAllColumns();
 604                 for (int i = 0; i < reportCols.size(); i++) {
 605                         DataColumnType dct = (DataColumnType) reportCols.get(i);
 606
 607                         if (dct.getColId().equals(colId) && (i < reportCols.size() - 1)) {
 608                                 DataColumnType dctDown = (DataColumnType) reportCols.get(i + 1);
 609                                 dctDown.setOrderSeq(dctDown.getOrderSeq() - 1);
 610                                 dct.setOrderSeq(dct.getOrderSeq() + 1);
 611                                 break;
 612                         } // if
 613                 } // for
 614
 615                 Collections.sort(reportCols, new OrderSeqComparator());
 616                 resetCache(true);
 617                 resetColumnOrderValues();
 618         } // shiftColumnOrderDown
 619
 620         public void resetColumnOrderValues() {
 621                 List reportCols = getAllColumns();
 622
 623                 int colOrder = 0;
 624                 for (Iterator iter = reportCols.iterator(); iter.hasNext();) {
 625                         DataColumnType dct = (DataColumnType) iter.next();
 626                         dct.setOrderSeq(++colOrder);
 627                 } // for
 628
 629                 Collections.sort(reportCols, new OrderSeqComparator());
 630         } // resetColumnOrderValues
 631
 632         public void addColFilterType(ObjectFactory objFactory, String colId, // Column
 633                                                                                                                                                         // to
 634                                                                                                                                                         // which
 635                                                                                                                                                         // the
 636                                                                                                                                                         // new
 637                                                                                                                                                         // filter
 638                                                                                                                                                         // belongs
 639                         String joinCondition, String openBrackets, String expression, String argType,
 640                         String argValue, String closeBrackets, String comment) throws RaptorException {
 641                         ColFilterType cft = objFactory.createColFilterType();
 642
 643                         cft.setColId(colId);
 644                         cft.setJoinCondition(nvl(joinCondition, "AND"));
 645                         if (nvl(openBrackets).length() > 0)
 646                                 cft.setOpenBrackets(openBrackets);
 647                         cft.setExpression(expression);
 648                         if (nvl(argType).length() > 0)
 649                                 cft.setArgType(argType);
 650                         if (nvl(argValue).length() > 0)
 651                                 cft.setArgValue(argValue);
 652                         if (nvl(closeBrackets).length() > 0)
 653                                 cft.setCloseBrackets(closeBrackets);
 654                         if (nvl(comment).length() > 0)
 655                                 cft.setComment(comment);
 656
 657                         DataColumnType dct = getColumnById(colId);
 658                         if (dct != null) {
 659                                 if (dct.getColFilterList() == null)
 660                                         dct.setColFilterList(objFactory.createColFilterList());
 661
 662                                 cft.setFilterSeq(dct.getColFilterList().getColFilter().size());
 663                                 dct.getColFilterList().getColFilter().add(cft);
 664                         } // if
 665
 666                         resetCache(true);
 667         } // addColFilterType
 668
 669         public void removeColumnFilter(String colId, int filterPos) {
 670                 DataColumnType dct = getColumnById(colId);
 671
 672                 if (dct.getColFilterList() != null)
 673                         try {
 674                                 dct.getColFilterList().getColFilter().remove(filterPos);
 675                         } catch (IndexOutOfBoundsException e) {
 676                             logger.debug(EELFLoggerDelegate.errorLogger, "IndexOutOfBoundsException in removeColumnFilter", e);
 677                         }
 678
 679                 resetCache(true);
 680         } // removeColumnFilter
 681
 682         public void addColumnSort(String colId, String ascDesc) {
 683                 addColumnSort(colId, ascDesc, -1);
 684         } // addColumnSort
 685
 686         public void addColumnSort(String colId, String ascDesc, int sortOrder) {
 687                 if (sortOrder <= 0) {
 688                         sortOrder = 1;
 689                         List reportCols = getAllColumns();
 690                         for (Iterator iter = reportCols.iterator(); iter.hasNext();)
 691                                 if (((DataColumnType) iter.next()).getOrderBySeq() > 0)
 692                                         sortOrder++;
 693                 } // if
 694
 695                 DataColumnType dct = getColumnById(colId);
 696                 dct.setOrderBySeq(sortOrder);
 697                 dct.setOrderByAscDesc(ascDesc);
 698
 699                 resetCache(true);
 700         } // addColumnSort
 701
 702         public void removeColumnSort(String colId) {
 703                 DataColumnType dct = getColumnById(colId);
 704                 int sortOrder = dct.getOrderBySeq();
 705
 706                 dct.setOrderBySeq(0);
 707                 dct.setOrderByAscDesc(null);
 708
 709                 if (sortOrder > 0) {
 710                         List reportCols = getAllColumns();
 711                         for (Iterator iter = reportCols.iterator(); iter.hasNext();) {
 712                                 DataColumnType dct2 = (DataColumnType) iter.next();
 713
 714                                 if (dct2.getOrderBySeq() > sortOrder)
 715                                         dct2.setOrderBySeq(dct2.getOrderBySeq() - 1);
 716                         } // for
 717                 } // if
 718
 719                 resetCache(true);
 720         } // removeColumnSort
 721
 722         public void shiftColumnSortUp(String colId) {
 723                 List reportCols = getAllColumns();
 724                 Collections.sort(reportCols, new OrderBySeqComparator());
 725
 726                 for (int i = 0; i < reportCols.size(); i++) {
 727                         DataColumnType dct = (DataColumnType) reportCols.get(i);
 728
 729                         if (dct.getColId().equals(colId) && (dct.getOrderBySeq() > 0)) {
 730                                 DataColumnType dctUp = (DataColumnType) reportCols.get(i - 1);
 731                                 if (dctUp.getOrderBySeq() > 0)
 732                                         dctUp.setOrderBySeq(dctUp.getOrderBySeq() + 1);
 733                                 dct.setOrderBySeq(dct.getOrderBySeq() - 1);
 734                                 break;
 735                         } // if
 736                 } // for
 737
 738                 Collections.sort(reportCols, new OrderSeqComparator());
 739                 resetCache(true);
 740         } // shiftColumnSortUp
 741
 742         public void shiftColumnSortDown(String colId) {
 743                 List reportCols = getAllColumns();
 744                 Collections.sort(reportCols, new OrderBySeqComparator());
 745
 746                 for (int i = 0; i < reportCols.size(); i++) {
 747                         DataColumnType dct = (DataColumnType) reportCols.get(i);
 748
 749                         if (dct.getColId().equals(colId) && (dct.getOrderBySeq() > 0)) {
 750                                 DataColumnType dctDown = (DataColumnType) reportCols.get(i + 1);
 751                                 if (dctDown.getOrderBySeq() > 0)
 752                                         dctDown.setOrderBySeq(dctDown.getOrderBySeq() - 1);
 753                                 dct.setOrderBySeq(dct.getOrderBySeq() + 1);
 754                                 break;
 755                         } // if
 756                 } // for
 757
 758                 Collections.sort(reportCols, new OrderSeqComparator());
 759                 resetCache(true);
 760         } // shiftColumnSortDown
 761
 762         /** ************************************************************************************************* */
 763
 764         public String generateNewSemaphoreId() {
 765                 if (getSemaphoreList() == null)
 766                         return "sem1";
 767
 768                 String semaphoreId = null;
 769                 boolean idExists = true;
 770                 for (int i = 1; idExists; i++) {
 771                         semaphoreId = "sem" + i;
 772                         idExists = false;
 773                         for (Iterator iter = getSemaphoreList().getSemaphore().iterator(); iter.hasNext();)
 774                                 if (semaphoreId.equals(((SemaphoreType) iter.next()).getSemaphoreId())) {
 775                                         idExists = true;
 776                                         break;
 777                                 }
 778                 } // for
 779
 780                 return semaphoreId;
 781         } // generateNewSemaphoreId
 782
 783         public SemaphoreType addSemaphore(ObjectFactory objFactory, SemaphoreType semaphoreType)
 784                         throws RaptorException {
 785                 SemaphoreType sem =  null;
 786                 try {
 787                 if (getSemaphoreList() == null)
 788                         setSemaphoreList(objFactory.createSemaphoreList());
 789
 790                 String semaphoreName = null;
 791                 boolean nameExists = true;
 792                 for (int i = 1; nameExists; i++) {
 793                         semaphoreName = semaphoreType.getSemaphoreName() + ((i > 1) ? (" v" + i) : "");
 794                         nameExists = false;
 795                         for (Iterator iter2 = getSemaphoreList().getSemaphore().iterator(); iter2
 796                                         .hasNext();)
 797                                 if (semaphoreName.equals(((SemaphoreType) iter2.next()).getSemaphoreName())) {
 798                                         nameExists = true;
 799                                         break;
 800                                 }
 801                 } // for
 802
 803                 sem = cloneSemaphoreType(objFactory, semaphoreType);
 804                 getSemaphoreList().getSemaphore().add(sem);
 805
 806                 sem.setSemaphoreId(generateNewSemaphoreId());
 807                 sem.setSemaphoreName(semaphoreName);
 808                 } catch (JAXBException ex) {
 809                     logger.debug(EELFLoggerDelegate.errorLogger, "JAXBException in addSemaphore", ex);
 810                         throw new RaptorException(ex.getMessage(), ex.getCause());
 811                 }
 812
 813                 return sem;
 814         } // addSemaphore
 815
 816         public SemaphoreType addSemaphoreType(ObjectFactory objFactory, String semaphoreName,
 817                         String semaphoreType, String comment) throws RaptorException {
 818                 SemaphoreType sem =  null;
 819                         if (getSemaphoreList() == null)
 820                                 setSemaphoreList(objFactory.createSemaphoreList());
 821
 822                         sem = objFactory.createSemaphoreType();
 823                         getSemaphoreList().getSemaphore().add(sem);
 824
 825                         sem.setSemaphoreId(generateNewSemaphoreId());
 826                         sem.setSemaphoreName(semaphoreName);
 827                         sem.setSemaphoreType(nvl(semaphoreType));
 828                         if (nvl(comment).length() > 0)
 829                                 sem.setComment(comment);
 830
 831                         FormatList formatList = objFactory.createFormatList();
 832                         sem.setFormatList(formatList);
 833                 return sem;
 834         } // addSemaphoreType
 835
 836
 837         public String getNextIdForJavaScriptElement (ObjectFactory objFactory, String fieldId) throws RaptorException {
 838                 String id = "";
 839                 JavascriptItemType jit = null;
 840                 int incr = 0;
 841                         if (getJavascriptList() == null) {
 842                                 setJavascriptList(objFactory.createJavascriptList());
 843                                 return fieldId + "|1";
 844                         } else {
 845                                 if(getJavascriptList().getJavascriptItem().iterator().hasNext()) {
 846                                 for (Iterator iter = getJavascriptList().getJavascriptItem().iterator(); iter.hasNext();) {
 847                                         jit = (JavascriptItemType) iter.next();
 848                                         logger.debug(EELFLoggerDelegate.debugLogger, ("^^^^^JAVASCRIPTITEMTYPE " + jit.getFieldId() + " " + fieldId + " " + id));
 849                                         if(nvl(jit.getFieldId()).length()>0 && jit.getFieldId().equals(fieldId)) {
 850                                                 ++incr;
 851                                         }
 852                                 } // for
 853                                 return fieldId + "|"+incr;
 854                                 } else {
 855                                         return fieldId + "|1";
 856                                 }
 857
 858                         }
 859         }
 860
 861         public JavascriptItemType addJavascriptType(ObjectFactory objFactory, String id) throws RaptorException {
 862                 JavascriptItemType javascriptItemType =  null;
 863                 int flag = 0; // checking whether id existing in the list
 864                         if (getJavascriptList() == null) {
 865                                 setJavascriptList(objFactory.createJavascriptList());
 866                                 javascriptItemType = objFactory.createJavascriptItemType();
 867                                 getJavascriptList().getJavascriptItem().add(javascriptItemType);
 868                                 return javascriptItemType;
 869                         } else {
 870
 871                                 for (Iterator iter = getJavascriptList().getJavascriptItem().iterator(); iter.hasNext();) {
 872                                         javascriptItemType  = (JavascriptItemType)iter.next();
 873                                         if(javascriptItemType.getId().equals(id) && !id.startsWith("-1")) {
 874                                                 flag = 1;
 875                                                 break;
 876                                         }
 877                                 }
 878                                 if(flag == 1)
 879                                         return javascriptItemType;
 880                                 else {
 881                                         javascriptItemType = objFactory.createJavascriptItemType();
 882                                         getJavascriptList().getJavascriptItem().add(javascriptItemType);
 883                                         return javascriptItemType;
 884                                 }
 885                         }
 886
 887         } // addSemaphoreType
 888
 889         public boolean deleteJavascriptType(String id) throws RaptorException {
 890                 JavascriptItemType javascriptType =  null;
 891                 if (getJavascriptList() == null)
 892                         return true;
 893                 for (Iterator iter = getJavascriptList().getJavascriptItem().iterator(); iter.hasNext();) {
 894                         javascriptType  = (JavascriptItemType)iter.next();
 895                         if(javascriptType.getId().equals(id)) {
 896                                 iter.remove();
 897                                 return true;
 898                         }
 899                 }
 900                 return false;
 901         } // addSemaphoreType
 902
 903         public static FormatType addEmptyFormatType(ObjectFactory objFactory,
 904                         SemaphoreType semaphore) throws RaptorException {
 905                 FormatType fmt = null;
 906                         fmt = objFactory.createFormatType();
 907                         semaphore.getFormatList().getFormat().add(fmt);
 908
 909                         String formatId = null;
 910                         boolean idExists = true;
 911                         for (int i = 1; idExists; i++) {
 912                                 formatId = semaphore.getSemaphoreId() + "_fmt" + i;
 913                                 idExists = false;
 914                                 for (Iterator iter = semaphore.getFormatList().getFormat().iterator(); iter
 915                                                 .hasNext();)
 916                                         if (formatId.equals(((FormatType) iter.next()).getFormatId())) {
 917                                                 idExists = true;
 918                                                 break;
 919                                         }
 920                         } // for
 921                         fmt.setFormatId(formatId);
 922                 return fmt;
 923         } // addEmptyFormatType
 924
 925         public static void deleteFormatType(SemaphoreType semaphore, String formatId) {
 926                 for (Iterator iter = semaphore.getFormatList().getFormat().iterator(); iter.hasNext();)
 927                         if (formatId.equals(((FormatType) iter.next()).getFormatId())) {
 928                                 iter.remove();
 929                                 break;
 930                         } // if
 931         } // deleteFormatType
 932
 933         public FormFieldType addFormFieldType(ObjectFactory objFactory, String fieldName,
 934                         String colId, String fieldType, String validationType, String mandatory,
 935                         String defaultValue, String fieldSQL, String comment, Calendar rangeStartDate, Calendar rangeEndDate,
 936                         String rangeStartDateSQL, String rangeEndDateSQL) throws RaptorException {
 937                 FormFieldType fft = null;
 938                         fft = objFactory.createFormFieldType();
 939
 940                         fft.setFieldName(fieldName);
 941                         fft.setColId(colId);
 942                         fft.setFieldType(fieldType);
 943                         fft.setValidationType(validationType);
 944                         fft.setMandatory(nvl(mandatory, "N"));
 945                         fft.setDefaultValue(nvl(defaultValue));
 946                         fft.setOrderBySeq((getFormFieldList() == null) ? 1 : getFormFieldList().getFormField()
 947                                         .size() + 1);
 948                         fft.setFieldSQL(fieldSQL);
 949             try {
 950                 fft.setRangeStartDate(DatatypeFactory.newInstance()
 951                         .newXMLGregorianCalendar(rangeStartDate.YEAR, rangeStartDate.MONTH, rangeStartDate.DAY_OF_WEEK, rangeStartDate.HOUR, rangeStartDate.MINUTE, rangeStartDate.SECOND, rangeStartDate.MILLISECOND, rangeStartDate.ZONE_OFFSET));
 952                 fft.setRangeStartDate(DatatypeFactory.newInstance()
 953                         .newXMLGregorianCalendar(rangeEndDate.YEAR, rangeEndDate.MONTH, rangeEndDate.DAY_OF_WEEK, rangeEndDate.HOUR, rangeEndDate.MINUTE, rangeEndDate.SECOND, rangeEndDate.MILLISECOND, rangeEndDate.ZONE_OFFSET));
 954             } catch (DatatypeConfigurationException ex) {
 955                 logger.debug(EELFLoggerDelegate.errorLogger, "DatatypeConfigurationException in addFormFieldType", ex);
 956             }
 957
 958                         fft.setRangeStartDateSQL(rangeStartDateSQL);
 959                         fft.setRangeEndDateSQL(rangeEndDateSQL);
 960                         if (nvl(comment).length() > 0)
 961                                 fft.setComment(comment);
 962
 963                         String fieldId = null;
 964                         boolean idExists = true;
 965                         for (int i = 1; idExists; i++) {
 966                                 fieldId = "ff" + i;
 967                                 idExists = false;
 968                                 if (getFormFieldList() != null)
 969                                         for (Iterator iter = getFormFieldList().getFormField().iterator(); iter
 970                                                         .hasNext();)
 971                                                 if (fieldId.equals(((FormFieldType) iter.next()).getFieldId())) {
 972                                                         idExists = true;
 973                                                         break;
 974                                                 }
 975                         } // for
 976                         fft.setFieldId(fieldId);
 977
 978                         if (getFormFieldList() == null) {
 979                                 FormFieldList formFieldList = objFactory.createFormFieldList();
 980                                 setFormFieldList(formFieldList);
 981                         }
 982
 983                         getFormFieldList().getFormField().add(fft);
 984                 return fft;
 985         } // addFormFieldType
 986
 987         //addCustomizedTextForParameters
 988         public void addCustomizedTextForParameters(String comment) throws RaptorException {
 989                         getFormFieldList().setComment(comment);
 990         }
 991
 992         public FormFieldType addFormFieldBlank(ObjectFactory objFactory) throws RaptorException {
 993                 FormFieldType fft = null;
 994                         fft = objFactory.createFormFieldType();
 995
 996                         fft.setFieldName("BLANK");
 997                 fft.setColId("bk");
 998                 fft.setFieldType(FormField.FFT_BLANK);
 999                 fft.setOrderBySeq((getFormFieldList() == null) ? 1 : getFormFieldList().getFormField()
1000                                         .size() + 1);
1001                         String fieldId = null;
1002                         boolean idExists = true;
1003                         for (int i = 1; idExists; i++) {
1004                                 fieldId = "ff" + i;
1005                                 idExists = false;
1006                                 if (getFormFieldList() != null)
1007                                         for (Iterator iter = getFormFieldList().getFormField().iterator(); iter
1008                                                         .hasNext();)
1009                                                 if (fieldId.equals(((FormFieldType) iter.next()).getFieldId())) {
1010                                                         idExists = true;
1011                                                         break;
1012                                                 }
1013                         } // for
1014                         fft.setFieldId(fieldId);
1015
1016                         if (getFormFieldList() == null) {
1017                                 FormFieldList formFieldList = objFactory.createFormFieldList();
1018                                 setFormFieldList(formFieldList);
1019                         }
1020
1021                         getFormFieldList().getFormField().add(fft);
1022                 return fft;
1023         } // addFormFieldBlank
1024
1025         public void replaceFormFieldReferences(String fieldName, String replaceWith) {
1026                 if (fieldName.equals(replaceWith))
1027                         return;
1028
1029                 for (Iterator iter = getAllColumns().iterator(); iter.hasNext();) {
1030                         DataColumnType dct = (DataColumnType) iter.next();
1031
1032                         if (dct.isCalculated() && dct.getColName().indexOf(fieldName) >= 0)
1033                                 dct.setColName(Utils.replaceInString(dct.getColName(), fieldName, nvl(
1034                                                 replaceWith, "NULL")));
1035
1036                         if (dct.getColFilterList() != null)
1037                                 for (Iterator iter2 = dct.getColFilterList().getColFilter().iterator(); iter2
1038                                                 .hasNext();) {
1039                                         ColFilterType cft = (ColFilterType) iter2.next();
1040
1041                                         if (nvl(cft.getArgType()).equals(AppConstants.AT_FORM)
1042                                                         && nvl(cft.getArgValue()).equals(fieldName))
1043                                                 cft.setArgValue(replaceWith);
1044                                 } // for
1045                 } // for
1046         } // replaceFormFieldReferences
1047
1048         public void deleteFormField(String fieldId) {
1049                 String fieldDisplayName = null;
1050
1051                 int orderBySeq = Integer.MAX_VALUE;
1052                 if (getFormFieldList() != null)
1053                         for (Iterator iter = getFormFieldList().getFormField().iterator(); iter.hasNext();) {
1054                                 FormFieldType fft = (FormFieldType) iter.next();
1055
1056                                 if (fieldId.equals(fft.getFieldId())) {
1057                                         fieldDisplayName = getFormFieldDisplayName(fft);
1058                                         iter.remove();
1059                                 } else if (fft.getOrderBySeq()!=null && (fft.getOrderBySeq().intValue() > orderBySeq))
1060                                         fft.setOrderBySeq(fft.getOrderBySeq() - 1);
1061                         } // for
1062
1063                 if (fieldDisplayName != null)
1064                         replaceFormFieldReferences(fieldDisplayName, "");
1065         } // deleteFormField
1066
1067         public void shiftFormFieldUp(String fieldId) {
1068                 if (getFormFieldList() == null)
1069                         return;
1070
1071                 for (int i = 0; i < getFormFieldList().getFormField().size(); i++) {
1072                         FormFieldType fft = (FormFieldType) getFormFieldList().getFormField().get(i);
1073
1074                         if (fft.getFieldId().equals(fieldId) && (i > 0)) {
1075                                 FormFieldType prevFft = (FormFieldType) getFormFieldList().getFormField().get(
1076                                                 i - 1);
1077                                 prevFft.setOrderBySeq(prevFft.getOrderBySeq() + 1);
1078                                 fft.setOrderBySeq((fft.getOrderBySeq() == null)?0:fft.getOrderBySeq() - 1);
1079
1080                                 getFormFieldList().getFormField().remove(i);
1081                                 getFormFieldList().getFormField().add(i - 1, fft);
1082                                 return;
1083                         } // if
1084                 } // for
1085         } // shiftFormFieldUp
1086
1087         public void shiftFormFieldDown(String fieldId) {
1088                 if (getFormFieldList() == null)
1089                         return;
1090
1091                 for (int i = 0; i < getFormFieldList().getFormField().size(); i++) {
1092                         FormFieldType fft = (FormFieldType) getFormFieldList().getFormField().get(i);
1093
1094                         if (fft.getFieldId().equals(fieldId)
1095                                         && (i < getFormFieldList().getFormField().size() - 1)) {
1096                                 FormFieldType nextFft = (FormFieldType) getFormFieldList().getFormField().get(
1097                                                 i + 1);
1098                                 nextFft.setOrderBySeq((nextFft.getOrderBySeq() == null)?0:nextFft.getOrderBySeq() - 1);
1099                                 fft.setOrderBySeq((fft.getOrderBySeq() == null)?0:fft.getOrderBySeq() + 1);
1100
1101                                 getFormFieldList().getFormField().remove(i + 1);
1102                                 getFormFieldList().getFormField().add(i, nextFft);
1103                                 return;
1104                         } // if
1105                 } // for
1106         } // shiftFormFieldDown
1107
1108         public static void addFormFieldPredefinedValue(ObjectFactory objFactory,
1109                         FormFieldType formField, String predefinedValue) throws RaptorException {
1110                         if (formField.getPredefinedValueList() == null) {
1111                                 PredefinedValueList predefinedValueList = objFactory.createPredefinedValueList();
1112                                 formField.setPredefinedValueList(predefinedValueList);
1113                         } // if
1114
1115                         if (predefinedValue.length() > 0) {
1116                                 formField.getPredefinedValueList().getPredefinedValue().add(predefinedValue);
1117                                 Collections.sort(formField.getPredefinedValueList().getPredefinedValue());
1118                         } // if
1119         } // addFormFieldPredefinedValue
1120
1121         public static void deleteFormFieldPredefinedValue(FormFieldType formField,
1122                         String predefinedValue) {
1123                 if (formField != null && formField.getPredefinedValueList() != null
1124                                 && predefinedValue.length() > 0)
1125                         for (Iterator iter = formField.getPredefinedValueList().getPredefinedValue()
1126                                         .iterator(); iter.hasNext();)
1127                                 if (predefinedValue.equals((String) iter.next())) {
1128                                         iter.remove();
1129                                         break;
1130                                 } // if
1131         } // deleteFormFieldPredefinedValue
1132
1133         /** ************************************************************************************************* */
1134
1135         private int curSQLParsePos = 0;
1136
1137         private String getNextSQLParseToken(String sql, boolean updateParsePos) {
1138                 int braketCount = 0;
1139                 boolean isInsideQuote = false;
1140                 StringBuffer nextToken = new StringBuffer();
1141                 for (int idxNext = curSQLParsePos; idxNext < sql.length(); idxNext++) {
1142                         char ch = sql.charAt(idxNext);
1143
1144                         if (Character.isWhitespace(ch) || ch == ',') {
1145                                 if (ch == ',')
1146                                         nextToken.append(ch);
1147
1148                                 if (nextToken.length() == 0)
1149                                         continue;
1150                                 else if (braketCount == 0 && (!isInsideQuote)) {
1151                                         if (updateParsePos)
1152                                                 curSQLParsePos = idxNext + ((ch == ',') ? 1 : 0);
1153                                         break;
1154                                 } else if (ch != ',' && nextToken.charAt(nextToken.length() - 1) != ' ')
1155                                         nextToken.append(' ');
1156                         } else {
1157                                 nextToken.append(ch);
1158
1159                                 if (ch == '(' || ch == '[')
1160                                         braketCount++;
1161                                 else if (ch == ')' || ch == ']')
1162                                         braketCount--;
1163                                 else if (ch == '\''/* ||ch=='\"' */)
1164                                         isInsideQuote = (!isInsideQuote);
1165                         } // else
1166                 } // for
1167
1168                 return nextToken.toString();
1169         } // getNextSQLParseToken
1170
1171         private boolean isParseSQLColID(String token) {
1172                 if (nvl(token).length() == 0)
1173                         return false;
1174
1175                 for (int i = 0; i < token.length(); i++) {
1176                         char ch = token.charAt(i);
1177
1178                         if (i == 0 && ch == '_')
1179                                 return false;
1180
1181                         if (!(Character.isLetterOrDigit(ch) || ch == '_'))
1182                                 return false;
1183                 } // for
1184
1185                 return true;
1186         } // isParseSQLColID
1187
1188         private DataColumnType getParseSQLDataColumn(String sqlExpression, String colId,
1189                         StringBuffer parsedSQL, Vector updatedReportCols, boolean isCYMBALScript) throws RaptorException {
1190                 DataColumnType dct = null;
1191
1192                 if (colId != null) {
1193                         if (!isParseSQLColID(colId))
1194                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1195                                                 "["
1196                                                                 + colId
1197                                                                 + "] must either be a valid column id consisting only of letters, numbers, and underscores, or there must be a comma in front of it.");
1198
1199                         dct = getColumnById(colId);
1200                 } else {
1201                         // Getting unique column id
1202                         colId = "";
1203                         int colIdN = 0;
1204                         for (int i = 0; (i < sqlExpression.length()) && (colIdN < 2); i++)
1205                                 if (Character.isLetter(sqlExpression.charAt(i))) {
1206                                         colId += sqlExpression.toLowerCase().charAt(i);
1207                                         colIdN++;
1208                                 } // if
1209
1210                         colIdN = getAllColumns().size() + updatedReportCols.size();
1211                         for (boolean idAlreadyUsed = true; idAlreadyUsed; colIdN++) {
1212                                 String newColId = colId + colIdN;
1213                                 idAlreadyUsed = false;
1214
1215                                 for (Iterator iter = getAllColumns().iterator(); iter.hasNext();)
1216                                         if (newColId.equals(((DataColumnType) iter.next()).getColId())) {
1217                                                 idAlreadyUsed = true;
1218                                                 break;
1219                                         }
1220
1221                                 if (!idAlreadyUsed)
1222                                         for (Iterator iter = updatedReportCols.iterator(); iter.hasNext();)
1223                                                 if (newColId.equals(((DataColumnType) iter.next()).getColId())) {
1224                                                         idAlreadyUsed = true;
1225                                                         break;
1226                                                 }
1227                         } // for
1228
1229                         colId += (colIdN - 1);
1230                 } // else
1231
1232                 if (dct == null) {
1233                         dct = (new ObjectFactory()).createDataColumnType();
1234                         dct.setColId(colId);
1235                         dct.setDisplayWidth(10);
1236                         dct.setDisplayAlignment("Left");
1237                         dct.setVisible(true);
1238                         dct.setGroupBreak(false); // ???
1239                         if(!isCYMBALScript) {
1240                                 boolean isValidIdentifier = Character.isLetterOrDigit(sqlExpression.charAt(0));
1241                                 for (int i = 0; i < sqlExpression.length(); i++)
1242                                         if (!(Character.isLetterOrDigit(sqlExpression.charAt(i))
1243                                                         || (sqlExpression.charAt(i) == '_') || (sqlExpression.charAt(i) == '$'))) {
1244                                                 isValidIdentifier = false;
1245                                                 break;
1246                                         } // if
1247
1248                                 if (isValidIdentifier) {
1249                                         dct.setDisplayName(sqlExpression);
1250                                 } else {
1251                                         dct.setDisplayName(colId);
1252                                 } // else
1253                         } else dct.setDisplayName(colId);
1254                 } // if
1255                  if(!isCYMBALScript)
1256                 sqlExpression = sqlExpression.replaceAll(", '", ",'");
1257                 dct.setDbColName(sqlExpression);
1258                 dct.setColName(sqlExpression);
1259                 dct.setCalculated(true);
1260                 dct.setColType(AppConstants.CT_CHAR);
1261                 dct.setDbColType(AppConstants.CT_CHAR);
1262                 adjustColumnType(dct); // ???
1263                 if(!isCYMBALScript) {
1264                         if (parsedSQL.toString().equals("SELECT ")
1265                                         || parsedSQL.toString().equals("SELECT DISTINCT "))
1266                                 parsedSQL.append("\n\t");
1267                         else
1268                                 parsedSQL.append(", \n\t");
1269                         parsedSQL.append(sqlExpression);
1270                         parsedSQL.append(" ");
1271                         parsedSQL.append(colId);
1272                 }
1273
1274                 return dct;
1275         } // getParseSQLDataColumn
1276
1277         public void parseReportSQL(String sql) throws RaptorException {
1278                 StringBuffer parsedSQL = new StringBuffer();
1279
1280                 Vector updatedReportCols = new Vector();
1281
1282                 curSQLParsePos = 0;
1283                 int lastParsePos = curSQLParsePos;
1284                 String lastToken = null;
1285                 String nextToken = getNextSQLParseToken(sql, true);
1286
1287         String  dbInfo          = getDBInfo();
1288         boolean isCYMBALScript = false;
1289                 if (!isNull(dbInfo) && (!dbInfo.equals(AppConstants.DB_LOCAL))) {
1290                         try {
1291                          String dbType = remDbInfo.getDBType(dbInfo);
1292                          if (dbType.equals("DAYTONA") && !(nextToken.toUpperCase().equals("SELECT"))) {
1293                                  isCYMBALScript = true;
1294                          }
1295                         } catch (Exception ex) {
1296                    throw new RaptorException(ex);
1297                         }
1298                 }
1299                 if ( isCYMBALScript == false ) {
1300                         while (nextToken.length() > 0) {
1301                                 if (parsedSQL.length() == 0) {
1302                                         if (nextToken.toUpperCase().equals("SELECT"))
1303                                                 parsedSQL.append("SELECT ");
1304                                         else
1305                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1306                                                                 "The SQL must start with the SELECT keyword.");
1307                                 } else if (nextToken.toUpperCase().equals("DISTINCT")
1308                                                 && parsedSQL.toString().equals("SELECT ")) {
1309                                         parsedSQL.append("DISTINCT ");
1310                                 } else if (nextToken.equals("*")
1311                                                 && (parsedSQL.toString().equals("SELECT ") || parsedSQL.toString().equals(
1312                                                                 "SELECT DISTINCT "))) {
1313                                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1314                                                         "You cannot use \"SELECT *\". Please specify select columns/expressions.");
1315                                 } else if (nextToken.toUpperCase().equals("FROM")) {
1316                                         if (lastToken != null) {
1317                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null, parsedSQL,
1318                                                                 updatedReportCols, false));
1319                                                 lastToken = null;
1320                                         }
1321
1322                                         parsedSQL.append(" \n");
1323                                         while (lastParsePos < sql.length()
1324                                                         && Character.isWhitespace(sql.charAt(lastParsePos)))
1325                                                 lastParsePos++;
1326                                         parsedSQL.append(sql.substring(lastParsePos));
1327                                         break;
1328                                 } else {
1329                                         if (nextToken.charAt(nextToken.length() - 1) == ',') {
1330                                                 // The token ends with ,
1331                                                 nextToken = nextToken.substring(0, nextToken.length() - 1);
1332
1333                                                 if (nextToken.length() == 0) {
1334                                                         if (lastToken != null) {
1335                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null,
1336                                                                                 parsedSQL, updatedReportCols, false));
1337                                                                 lastToken = null;
1338                                                         } // else just comma => ignore it
1339                                                 } else {
1340                                                         if (lastToken != null) {
1341                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1342                                                                                 parsedSQL, updatedReportCols, false));
1343                                                                 lastToken = null;
1344                                                         } else
1345                                                                 updatedReportCols.add(getParseSQLDataColumn(nextToken, null,
1346                                                                                 parsedSQL, updatedReportCols, false));
1347                                                 }
1348                                         } else {
1349                                                 // The token doesn't end with ,
1350                                                 if (lastToken == null)
1351                                                         lastToken = nextToken;
1352                                                 else {
1353                                                         String token = getNextSQLParseToken(sql, false);
1354                                                         if (!token.toUpperCase().equals("FROM"))
1355                                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1356                                                                                 "|FROM keyword or a comma expected after [" + nextToken
1357                                                                                                 + "].");
1358
1359                                                         updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1360                                                                         parsedSQL, updatedReportCols, false));
1361                                                         lastToken = null;
1362                                                 } // else
1363                                         } // else
1364                                 } // else
1365
1366                                 lastParsePos = curSQLParsePos;
1367                                 nextToken = getNextSQLParseToken(sql, true);
1368                         } // while
1369                 } else { // if CYMBAL Script
1370                         curSQLParsePos = 0;
1371                         Pattern re                      = null;
1372                         Matcher matcher         = null;
1373                         String extracted        = null;
1374                         nextToken = getNextCYMBALSQLParseToken(sql,true);
1375                         while (nextToken.length() > 0) {
1376                                 if (lastToken == null)
1377                                         lastToken = nextToken;
1378
1379                                 if( lastToken.toUpperCase().startsWith("DO DISPLAY")) {
1380                                         re              = Pattern.compile("each(.*)\\[.(.*?)\\]");   //\\[(.*?)\\]
1381                                         matcher = re.matcher(nextToken);
1382                                         if (matcher.find()) {
1383                                                 extracted = matcher.group();
1384                                                 re              = Pattern.compile("\\[(.*?)\\]");
1385                                         matcher = re.matcher(nextToken);
1386                                         if(matcher.find()) {
1387                                                 extracted = matcher.group();
1388                                                 extracted = extracted.substring(1,extracted.length()-1);
1389                                                 StringTokenizer sToken = new StringTokenizer(extracted, ",");
1390                                                 while(sToken.hasMoreTokens()) {
1391                                                 String str1 = sToken.nextToken().trim().substring(1);
1392                                             updatedReportCols.add(getParseSQLDataColumn("", str1,
1393                                                         new StringBuffer(""), updatedReportCols, true));
1394                                                 }
1395                                         }
1396
1397                                         }
1398
1399                                 }
1400                                 lastToken = nextToken;
1401                                 nextToken = getNextCYMBALSQLParseToken(sql, true);
1402                         }
1403
1404                 }
1405                 if (updatedReportCols.size() == 0)
1406                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1407                                         "The SQL statement must have at least one column in the SELECT clause.");
1408                 if (getDataSourceList().getDataSource().size() == 0)
1409                         addDataSourceType(new ObjectFactory(), "du0", "DUAL", "", "DUAL", null, null, null);
1410                 DataSourceType dst = (DataSourceType) getDataSourceList().getDataSource().get(0);
1411                 dst.getDataColumnList().getDataColumn().clear();
1412
1413                 for (int i = 0; i < updatedReportCols.size(); i++) {
1414                         DataColumnType dct = (DataColumnType) updatedReportCols.get(i);
1415                         dct.setTableId(dst.getTableId());
1416                         dct.setOrderSeq(i + 1);
1417                         dst.getDataColumnList().getDataColumn().add(dct);
1418                 } // for
1419                 setReportSQL(parsedSQL.toString());
1420                 resetCache(false);
1421         } // parseReportSQL
1422
1423         public void parseReportSQL(String sql, boolean storeInSession) throws RaptorException {
1424                 StringBuffer parsedSQL = new StringBuffer();
1425
1426                 Vector updatedReportCols = new Vector();
1427
1428                 curSQLParsePos = 0;
1429                 int lastParsePos = curSQLParsePos;
1430                 String lastToken = null;
1431                 String nextToken = getNextSQLParseToken(sql, true);
1432
1433         String  dbInfo          = getDBInfo();
1434         boolean isCYMBALScript = false;
1435                 if (!isNull(dbInfo) && (!dbInfo.equals(AppConstants.DB_LOCAL))) {
1436                         try {
1437                          String dbType = remDbInfo.getDBType(dbInfo);
1438                          if (dbType.equals("DAYTONA") && !(nextToken.toUpperCase().equals("SELECT"))) {
1439                                  isCYMBALScript = true;
1440                          }
1441                         } catch (Exception ex) {
1442                    throw new RaptorException(ex);
1443                         }
1444                 }
1445                 if ( isCYMBALScript == false ) {
1446                         while (nextToken.length() > 0) {
1447                                 if (parsedSQL.length() == 0) {
1448                                         if (nextToken.toUpperCase().equals("SELECT"))
1449                                                 parsedSQL.append("SELECT ");
1450                                         else
1451                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1452                                                                 "The SQL must start with the SELECT keyword.");
1453                                 } else if (nextToken.toUpperCase().equals("DISTINCT")
1454                                                 && parsedSQL.toString().equals("SELECT ")) {
1455                                         parsedSQL.append("DISTINCT ");
1456                                 } else if (nextToken.equals("*")
1457                                                 && (parsedSQL.toString().equals("SELECT ") || parsedSQL.toString().equals(
1458                                                                 "SELECT DISTINCT "))) {
1459                                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1460                                                         "You cannot use \"SELECT *\". Please specify select columns/expressions.");
1461                                 } else if (nextToken.toUpperCase().equals("FROM")) {
1462                                         if (lastToken != null) {
1463                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null, parsedSQL,
1464                                                                 updatedReportCols, false));
1465                                                 lastToken = null;
1466                                         }
1467
1468                                         parsedSQL.append(" \n");
1469                                         while (lastParsePos < sql.length()
1470                                                         && Character.isWhitespace(sql.charAt(lastParsePos)))
1471                                                 lastParsePos++;
1472                                         parsedSQL.append(sql.substring(lastParsePos));
1473                                         break;
1474                                 } else {
1475                                         if (nextToken.charAt(nextToken.length() - 1) == ',') {
1476                                                 // The token ends with ,
1477                                                 nextToken = nextToken.substring(0, nextToken.length() - 1);
1478
1479                                                 if (nextToken.length() == 0) {
1480                                                         if (lastToken != null) {
1481                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null,
1482                                                                                 parsedSQL, updatedReportCols, false));
1483                                                                 lastToken = null;
1484                                                         } // else just comma => ignore it
1485                                                 } else {
1486                                                         if (lastToken != null) {
1487                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1488                                                                                 parsedSQL, updatedReportCols, false));
1489                                                                 lastToken = null;
1490                                                         } else
1491                                                                 updatedReportCols.add(getParseSQLDataColumn(nextToken, null,
1492                                                                                 parsedSQL, updatedReportCols, false));
1493                                                 }
1494                                         } else {
1495                                                 // The token doesn't end with ,
1496                                                 if (lastToken == null)
1497                                                         lastToken = nextToken;
1498                                                 else {
1499                                                         String token = getNextSQLParseToken(sql, false);
1500                                                         if (!token.toUpperCase().equals("FROM"))
1501                                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1502                                                                                 "|FROM keyword or a comma expected after [" + nextToken
1503                                                                                                 + "].");
1504
1505                                                         updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1506                                                                         parsedSQL, updatedReportCols, false));
1507                                                         lastToken = null;
1508                                                 } // else
1509                                         } // else
1510                                 } // else
1511
1512                                 lastParsePos = curSQLParsePos;
1513                                 nextToken = getNextSQLParseToken(sql, true);
1514                         } // while
1515                 } else { // if CYMBAL Script
1516                         curSQLParsePos = 0;
1517                         Pattern re                      = null;
1518                         Matcher matcher         = null;
1519                         String extracted        = null;
1520                         nextToken = getNextCYMBALSQLParseToken(sql,true);
1521                         while (nextToken.length() > 0) {
1522                                 if (lastToken == null)
1523                                         lastToken = nextToken;
1524
1525                                 if( lastToken.toUpperCase().startsWith("DO DISPLAY")) {
1526                                         re              = Pattern.compile("each(.*)\\[.(.*?)\\]");   //\\[(.*?)\\]
1527                                         matcher = re.matcher(nextToken);
1528                                         if (matcher.find()) {
1529                                                 extracted = matcher.group();
1530                                                 re              = Pattern.compile("\\[(.*?)\\]");
1531                                         matcher = re.matcher(nextToken);
1532                                         if(matcher.find()) {
1533                                                 extracted = matcher.group();
1534                                                 extracted = extracted.substring(1,extracted.length()-1);
1535                                                 StringTokenizer sToken = new StringTokenizer(extracted, ",");
1536                                                 while(sToken.hasMoreTokens()) {
1537                                                 String str1 = sToken.nextToken().trim().substring(1);
1538                                             updatedReportCols.add(getParseSQLDataColumn("", str1,
1539                                                         new StringBuffer(""), updatedReportCols, true));
1540                                                 }
1541                                         }
1542
1543                                         }
1544
1545                                 }
1546                                 lastToken = nextToken;
1547                                 nextToken = getNextCYMBALSQLParseToken(sql, true);
1548                         }
1549
1550                 }
1551                 if (updatedReportCols.size() == 0)
1552                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1553                                         "The SQL statement must have at least one column in the SELECT clause.");
1554                 if (getDataSourceList().getDataSource().size() == 0)
1555                         addDataSourceType(new ObjectFactory(), "du0", "DUAL", "", "DUAL", null, null, null);
1556                 DataSourceType dst = (DataSourceType) getDataSourceList().getDataSource().get(0);
1557                 dst.getDataColumnList().getDataColumn().clear();
1558
1559                 for (int i = 0; i < updatedReportCols.size(); i++) {
1560                         DataColumnType dct = (DataColumnType) updatedReportCols.get(i);
1561                         dct.setTableId(dst.getTableId());
1562                         dct.setOrderSeq(i + 1);
1563                         dst.getDataColumnList().getDataColumn().add(dct);
1564                 } // for
1565                 if(storeInSession)
1566                         setReportSQL(parsedSQL.toString());
1567                 resetCache(false);
1568         } // parseReportSQL
1569
1570         private String getNextCYMBALSQLParseToken(String sql, boolean updateParsePos) {
1571                 int braketCount = 0;
1572                 boolean isInsideQuote = false;
1573                 StringBuffer nextToken = new StringBuffer();
1574                 for (int idxNext = curSQLParsePos; idxNext < sql.length(); idxNext++) {
1575                         char ch = sql.charAt(idxNext);
1576
1577                         if (ch!='\n') {
1578                                         nextToken.append(ch);
1579                                         if (updateParsePos)
1580                                                 curSQLParsePos = idxNext;
1581                         }
1582                         else {
1583                                 curSQLParsePos = idxNext+1;
1584                                 break;
1585                         }
1586                 } // for
1587
1588                 return nextToken.toString();
1589         } // getNextSQLParseToken
1590
1591         public void addChartAdditionalOptions(ObjectFactory objFactory) throws RaptorException {
1592                         ChartAdditionalOptions chartOptions = objFactory.createChartAdditionalOptions();
1593                         cr.setChartAdditionalOptions(chartOptions);
1594         }
1595
1596         public void addChartDrillOptions(ObjectFactory objFactory) throws RaptorException {
1597                 ChartDrillOptions chartOptions = objFactory.createChartDrillOptions();
1598                 cr.setChartDrillOptions(chartOptions);
1599 }
1600
1601         public void addDataminingOptions(ObjectFactory objFactory) throws RaptorException {
1602                         DataminingOptions dataminingOptions = objFactory.createDataminingOptions();
1603                         cr.setDataminingOptions(dataminingOptions);
1604         }
1605
1606 } // ReportDefinition