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                 return getReportType().equals(AppConstants.RT_CROSSTAB) ? canPersistCrossTabReport()
 278                                 : (getReportType().equals(AppConstants.RT_LINEAR)? canPersistLinearReport()
 279                                                 :(getReportType().equals(AppConstants.RT_HIVE)? canPersistLinearReport()
 280                                                                 :canPersistDashboard()));
 281         } // canPersistReport
 282
 283         public void persistReport(HttpServletRequest request) throws RaptorException {
 284                 if (!canPersistReport()) {
 285                         logger.debug(EELFLoggerDelegate.debugLogger,"&&&&&&&&&&&&&&&&&&&&&& In !canPersistReport ReportType: " + getReportType());
 286                         return;
 287                 } else {
 288                         logger.debug(EELFLoggerDelegate.debugLogger,"&&&&&&&&&&&&&&&&&&&&&&  Not In !canPersistReport");
 289                 }
 290
 291                 Connection connection = null;
 292                 try {
 293                         String userID = AppUtils.getUserID(request);
 294                         String reportXML = marshal();
 295                         logger.debug(EELFLoggerDelegate.debugLogger, ("Ocurring during Schedule "));
 296                         logger.debug(EELFLoggerDelegate.debugLogger,"&&&&&&&&&&&&&&&&&&&&&&  Report ID " + reportID);
 297                         if ("-1".equals(nvl(reportID, "-1"))) {
 298                 connection = DbUtils.startTransaction();
 299                                 // Add report
 300                 String sql = "";
 301                 if (nvl(Globals.getAdhocReportSequence()).length()> 0 && nvl(Globals.getAdhocUserRoldId()).length() > 0 && AppUtils.isUserInRole(request, Globals.getAdhocUserRoldId()) && !AppUtils.isAdminUser(request)) {
 302                         sql = Globals.getPersistReportAdhoc();
 303                         sql = sql.replace("[Globals.getAdhocReportSequence()]", Globals.getAdhocReportSequence());
 304
 305                 } else{
 306                         sql = Globals.getNewReportData();
 307                 }
 308                 DataSet ds = DbUtils.executeQuery(connection,sql);
 309                                 setReportID(ds.getString(0, 0));
 310
 311                                 reportSecurity.reportCreate(reportID, userID, isPublic());
 312                                 ReportLoader.createCustomReportRec(connection, this, reportXML);
 313                                 ReportLoader.createReportLogEntry(connection, reportID, userID,
 314                                                 AppConstants.RLA_CREATE, "", "");
 315                                 reportUpdateLogged = true;
 316                                 logger.debug(EELFLoggerDelegate.debugLogger, ("[DEBUG MESSAGE FROM RAPTOR] DB insert report " + reportID + " succesfull"));
 317                         } else {
 318                                 // Update report
 319                                 verifySQLBasedReportAccess(request);
 320                                 reportSecurity.reportUpdate(request);
 321                 connection = DbUtils.startTransaction();
 322                                 ReportLoader.updateCustomReportRec(connection, this, reportXML);
 323                                 if (!reportUpdateLogged) {
 324                                         ReportLoader.createReportLogEntry(connection, reportID, userID,
 325                                                         AppConstants.RLA_UPDATE,"","");
 326                                         reportUpdateLogged = true;
 327                                 } // if
 328                                 logger.debug(EELFLoggerDelegate.debugLogger, ("[DEBUG MESSAGE FROM RAPTOR] DB update report " + reportID + " succesfull"));
 329                         }
 330
 331                         getReportSchedule().persistScheduleData(connection, request);
 332
 333                         DbUtils.commitTransaction(connection);
 334                 } catch (RaptorException e) {
 335                     logger.debug(EELFLoggerDelegate.errorLogger, "RaptorException in persistReport", e);
 336                         DbUtils.rollbackTransaction(connection);
 337                         throw e;
 338                 } finally {
 339                 DbUtils.clearConnection(connection);
 340         }
 341         } // persistReport
 342
 343         public String getCrossTabDisplayValue(String crossTabValue) {
 344                 return nvl(crossTabValue).equals(AppConstants.CV_ROW) ? "Row headings" : (nvl(
 345                                 crossTabValue).equals(AppConstants.CV_COLUMN) ? "Column headings" : (nvl(
 346                                 crossTabValue).equals(AppConstants.CV_VALUE) ? "Report values" : "Invisible/Filter"));
 347         } // getCrossTabDisplayValue
 348
 349         public String getCrossTabDisplayValue(DataColumnType dct) {
 350                 return getCrossTabDisplayValue(dct.getCrossTabValue());
 351         } // getCrossTabDisplayValue
 352
 353         public String getColumnLabel(DataColumnType dct) throws Exception {
 354                 String tableName = getTableById(dct.getTableId()).getTableName();
 355                 Vector dbColumns = null;
 356                 dbColumns = DataCache.getReportTableDbColumns(tableName, cr.getDbInfo());
 357                 if (dbColumns != null)
 358                         for (int i = 0; i < dbColumns.size(); i++) {
 359                                 DBColumnInfo dbCol = (DBColumnInfo) dbColumns.get(i);
 360                                 if (dct.getDbColName().equals(dbCol.getColName()))
 361                                         return dbCol.getLabel();
 362                         } // for
 363
 364                 return "";
 365         } // getCrossTabDisplayValue
 366
 367         public String getFilterLabel(ColFilterType cft) {
 368                 StringBuffer fLabel = new StringBuffer();
 369
 370                 fLabel.append(cft.getExpression());
 371                 fLabel.append(" ");
 372                 if (cft.getArgType() != null)
 373                         if (cft.getArgType().equals(AppConstants.AT_FORMULA)) {
 374                                 fLabel.append("[" + cft.getArgValue() + "]");
 375                         } else if (cft.getArgType().equals(AppConstants.AT_VALUE)) {
 376                                 fLabel.append(cft.getArgValue());
 377                         } else if (cft.getArgType().equals(AppConstants.AT_LIST)) {
 378                                 fLabel.append("(" + cft.getArgValue() + ")");
 379                         } else if (cft.getArgType().equals(AppConstants.AT_COLUMN)) {
 380                                 DataColumnType dctFilter = getColumnById(cft.getArgValue());
 381                                 fLabel.append("[" + dctFilter.getDisplayName() + "]");
 382                         } else if (cft.getArgType().equals(AppConstants.AT_FORM)) {
 383                                 fLabel.append("[Form Field]");
 384                         }
 385
 386                 return fLabel.toString();
 387         } // getFilterLabel
 388
 389         public Vector getReportUsers(HttpServletRequest request) throws RaptorException {
 390                 return reportSecurity.getReportUsers(request);
 391         } // getReportUsers
 392
 393         public Vector getReportRoles(HttpServletRequest request) throws RaptorException {
 394                 return reportSecurity.getReportRoles(request);
 395         } // getReportRoles
 396
 397         /** ************************************************************************************************* */
 398
 399         public void clearAllDrillDowns() {
 400                 List reportCols = getAllColumns();
 401                 for (int i = 0; i < reportCols.size(); i++) {
 402                         DataColumnType dct = (DataColumnType) reportCols.get(i);
 403                         dct.setDrillDownURL(null);
 404                         dct.setDrillDownParams(null);
 405                         dct.setDrillDownType(null);
 406                 } // for
 407         } // clearAllDrillDowns
 408
 409         public void setOuterJoin(DataSourceType curTable, String joinType) {
 410                 String refDefinition = nvl(curTable.getRefDefinition());
 411                 int outerJoinIdx = refDefinition.indexOf(" (+)");
 412                 if (outerJoinIdx >= 0)
 413                         // Clear existing outer join
 414                         if (outerJoinIdx == (refDefinition.length() - 4))
 415                                 refDefinition = refDefinition.substring(0, outerJoinIdx);
 416                         else
 417                                 refDefinition = refDefinition.substring(0, outerJoinIdx)
 418                                                 + refDefinition.substring(outerJoinIdx + 4);
 419
 420                 int equalSignIdx = refDefinition.indexOf("=");
 421                 if (equalSignIdx < 0)
 422                         // Ref. definition not present
 423                         return;
 424
 425                 if (refDefinition.indexOf(curTable.getTableId()) < equalSignIdx) {
 426                         // Cur. table is on the left side
 427                         if (nvl(joinType).equals(AppConstants.OJ_CURRENT))
 428                                 refDefinition = refDefinition.substring(0, equalSignIdx) + " (+)"
 429                                                 + refDefinition.substring(equalSignIdx);
 430                         else if (nvl(joinType).equals(AppConstants.OJ_JOINED))
 431                                 refDefinition = refDefinition + " (+)";
 432                 } else {
 433                         // Joined table is on the left side
 434                         if (nvl(joinType).equals(AppConstants.OJ_CURRENT))
 435                                 refDefinition = refDefinition + " (+)";
 436                         else if (nvl(joinType).equals(AppConstants.OJ_JOINED))
 437                                 refDefinition = refDefinition.substring(0, equalSignIdx) + " (+)"
 438                                                 + refDefinition.substring(equalSignIdx);
 439                 }
 440
 441                 curTable.setRefDefinition(refDefinition);
 442         } // setOuterJoin
 443
 444         public void addDataSourceType(ObjectFactory objFactory, String tableId, String tableName,
 445                         String tablePK, String displayName, String refTableId, String refDefinition,
 446                         String comment) throws RaptorException {
 447                 DataSourceType dst = objFactory.createDataSourceType();
 448
 449                 dst.setTableId(tableId);
 450                 dst.setTableName(tableName);
 451                 dst.setTablePK(tablePK);
 452                 dst.setDisplayName(displayName);
 453                 if (nvl(refTableId).length() > 0)
 454                         dst.setRefTableId(refTableId);
 455                 if (nvl(refDefinition).length() > 0)
 456                         dst.setRefDefinition(refDefinition);
 457                 if (nvl(comment).length() > 0)
 458                         dst.setComment(comment);
 459
 460                 DataColumnList dataColumnList = objFactory.createDataColumnList();
 461                 dst.setDataColumnList(dataColumnList);
 462
 463                 getDataSourceList().getDataSource().add(dst);
 464
 465                 resetCache(true);
 466         } // addDataSourceType
 467
 468         public void deleteDataSourceType(String tableId) {
 469                 super.deleteDataSourceType(tableId);
 470         } // deleteDataSourceType
 471
 472         public String getUniqueColumnId(String colName) {
 473                 String colId = "";
 474
 475                 int colIdN = getAllColumns().size() + 1;
 476                 do {
 477                         colId = colName.substring(0, 2).toLowerCase() + (colIdN++);
 478                 } while (getColumnById(colId) != null);
 479
 480                 return colId;
 481         } // getUniqueColumnId
 482
 483         public DataColumnType addDataColumnType(ObjectFactory objFactory, String colId,
 484                         String tableId, // Table to which the new column belongs
 485                         String dbColName, String crossTabValue, String colName, String displayName,
 486                         int displayWidth, String displayAlignment, int orderSeq, boolean visible,
 487                         boolean calculated, String colType, String colFormat, boolean groupBreak,
 488                         int orderBySeq, String orderByAscDesc, String displayTotal, String colOnChart,
 489                         int chartSeq, String drillDownType, String drillDownURL, String drillDownParams,
 490                         String semaphoreId, String comment) throws RaptorException {
 491                 DataColumnType dct = null;
 492                         dct = objFactory.createDataColumnType();
 493
 494                         dct.setColId(colId);
 495                         dct.setTableId(tableId);
 496                         dct.setDbColName(dbColName);
 497                         if (nvl(crossTabValue).length() > 0)
 498                                 dct.setCrossTabValue(crossTabValue);
 499                         dct.setColName(colName);
 500                         dct.setDisplayName(displayName);
 501                         if (displayWidth > 0)
 502                                 dct.setDisplayWidth(displayWidth);
 503                         if (nvl(displayAlignment).length() > 0)
 504                                 dct.setDisplayAlignment(displayAlignment);
 505                         if (orderSeq > 0)
 506                                 dct.setOrderSeq(orderSeq);
 507                         else
 508                                 dct.setOrderSeq(getAllColumns().size() + 1);
 509                         dct.setVisible(visible);
 510                         dct.setCalculated(calculated);
 511                         if (nvl(colFormat).length() > 0)
 512                                 dct.setColFormat(colFormat);
 513                         dct.setGroupBreak(groupBreak);
 514                         if (orderBySeq > 0)
 515                                 dct.setOrderBySeq(orderBySeq);
 516                         if (nvl(orderByAscDesc).length() > 0)
 517                                 dct.setOrderByAscDesc(orderByAscDesc);
 518                         if (nvl(displayTotal).length() > 0)
 519                                 dct.setDisplayTotal(displayTotal);
 520                         if (nvl(colOnChart).length() > 0)
 521                                 dct.setColOnChart(colOnChart);
 522                         if (chartSeq > 0)
 523                                 dct.setChartSeq(chartSeq);
 524                         if (nvl(drillDownType).length() > 0)
 525                                 dct.setDrillDownType(drillDownType);
 526                         if (nvl(drillDownURL).length() > 0)
 527                                 dct.setDrillDownURL(drillDownURL);
 528                         if (nvl(drillDownParams).length() > 0)
 529                                 dct.setDrillDownParams(drillDownParams);
 530                         if (nvl(semaphoreId).length() > 0)
 531                                 dct.setSemaphoreId(semaphoreId);
 532                         if (nvl(comment).length() > 0)
 533                                 dct.setComment(comment);
 534
 535                         dct.setDbColType(colType);
 536                         adjustColumnType(dct);
 537
 538                         getTableById(tableId).getDataColumnList().getDataColumn().add(dct);
 539
 540                         resetCache(false);
 541
 542                 return dct;
 543         } // addDataColumnType
 544
 545         public void deleteDataColumnType(String colId) {
 546                 int colOrder = getColumnById(colId).getOrderSeq();
 547
 548                 List dcList = getColumnTableById(colId).getDataColumnList().getDataColumn();
 549                 for (Iterator iterC = dcList.iterator(); iterC.hasNext();) {
 550                         DataColumnType dct = (DataColumnType) iterC.next();
 551
 552                         if (dct.getColId().equals(colId) && dct.getOrderSeq() == colOrder)
 553                                 iterC.remove();
 554                         else if (dct.getOrderSeq() > colOrder)
 555                                 dct.setOrderSeq(dct.getOrderSeq() - 1);
 556                 } // for
 557
 558                 if (getFormFieldList() != null)
 559                         for (Iterator iter = getFormFieldList().getFormField().iterator(); iter.hasNext();) {
 560                                 FormFieldType fft = (FormFieldType) iter.next();
 561                                 if (nvl(fft.getColId()).equals(colId)) {
 562                                         fft.setColId("");
 563                                         fft.setFieldType(FormField.FFT_TEXT);
 564                                         if (nvl(fft.getDefaultValue()).equals(AppConstants.FILTER_MAX_VALUE)
 565                                                         || nvl(fft.getDefaultValue())
 566                                                                         .equals(AppConstants.FILTER_MIN_VALUE))
 567                                                 fft.setDefaultValue("");
 568                                 } // if
 569                         } // for
 570
 571                 resetCache(false);
 572                 resetColumnOrderValues();
 573         } // deleteDataColumnType
 574
 575         public void shiftColumnOrderUp(String colId) {
 576                 List reportCols = getAllColumns();
 577                 for (int i = 0; i < reportCols.size(); i++) {
 578                         DataColumnType dct = (DataColumnType) reportCols.get(i);
 579
 580                         if (dct.getColId().equals(colId) && (i > 0)) {
 581                                 DataColumnType dctUp = (DataColumnType) reportCols.get(i - 1);
 582                                 dctUp.setOrderSeq(dctUp.getOrderSeq() + 1);
 583                                 dct.setOrderSeq(dct.getOrderSeq() - 1);
 584                                 break;
 585                         } // if
 586                 } // for
 587
 588                 Collections.sort(reportCols, new OrderSeqComparator());
 589                 resetCache(true);
 590                 resetColumnOrderValues();
 591         } // shiftColumnOrderUp
 592
 593         public void shiftColumnOrderDown(String colId) {
 594                 List reportCols = getAllColumns();
 595                 for (int i = 0; i < reportCols.size(); i++) {
 596                         DataColumnType dct = (DataColumnType) reportCols.get(i);
 597
 598                         if (dct.getColId().equals(colId) && (i < reportCols.size() - 1)) {
 599                                 DataColumnType dctDown = (DataColumnType) reportCols.get(i + 1);
 600                                 dctDown.setOrderSeq(dctDown.getOrderSeq() - 1);
 601                                 dct.setOrderSeq(dct.getOrderSeq() + 1);
 602                                 break;
 603                         } // if
 604                 } // for
 605
 606                 Collections.sort(reportCols, new OrderSeqComparator());
 607                 resetCache(true);
 608                 resetColumnOrderValues();
 609         } // shiftColumnOrderDown
 610
 611         public void resetColumnOrderValues() {
 612                 List reportCols = getAllColumns();
 613
 614                 int colOrder = 0;
 615                 for (Iterator iter = reportCols.iterator(); iter.hasNext();) {
 616                         DataColumnType dct = (DataColumnType) iter.next();
 617                         dct.setOrderSeq(++colOrder);
 618                 } // for
 619
 620                 Collections.sort(reportCols, new OrderSeqComparator());
 621         } // resetColumnOrderValues
 622
 623         public void addColFilterType(ObjectFactory objFactory, String colId, // Column
 624                                                                                                                                                         // to
 625                                                                                                                                                         // which
 626                                                                                                                                                         // the
 627                                                                                                                                                         // new
 628                                                                                                                                                         // filter
 629                                                                                                                                                         // belongs
 630                         String joinCondition, String openBrackets, String expression, String argType,
 631                         String argValue, String closeBrackets, String comment) throws RaptorException {
 632                         ColFilterType cft = objFactory.createColFilterType();
 633
 634                         cft.setColId(colId);
 635                         cft.setJoinCondition(nvl(joinCondition, "AND"));
 636                         if (nvl(openBrackets).length() > 0)
 637                                 cft.setOpenBrackets(openBrackets);
 638                         cft.setExpression(expression);
 639                         if (nvl(argType).length() > 0)
 640                                 cft.setArgType(argType);
 641                         if (nvl(argValue).length() > 0)
 642                                 cft.setArgValue(argValue);
 643                         if (nvl(closeBrackets).length() > 0)
 644                                 cft.setCloseBrackets(closeBrackets);
 645                         if (nvl(comment).length() > 0)
 646                                 cft.setComment(comment);
 647
 648                         DataColumnType dct = getColumnById(colId);
 649                         if (dct != null) {
 650                                 if (dct.getColFilterList() == null)
 651                                         dct.setColFilterList(objFactory.createColFilterList());
 652
 653                                 cft.setFilterSeq(dct.getColFilterList().getColFilter().size());
 654                                 dct.getColFilterList().getColFilter().add(cft);
 655                         } // if
 656
 657                         resetCache(true);
 658         } // addColFilterType
 659
 660         public void removeColumnFilter(String colId, int filterPos) {
 661                 DataColumnType dct = getColumnById(colId);
 662
 663                 if (dct.getColFilterList() != null)
 664                         try {
 665                                 dct.getColFilterList().getColFilter().remove(filterPos);
 666                         } catch (IndexOutOfBoundsException e) {
 667                             logger.debug(EELFLoggerDelegate.errorLogger, "IndexOutOfBoundsException in removeColumnFilter", e);
 668                         }
 669
 670                 resetCache(true);
 671         } // removeColumnFilter
 672
 673         public void addColumnSort(String colId, String ascDesc) {
 674                 addColumnSort(colId, ascDesc, -1);
 675         } // addColumnSort
 676
 677         public void addColumnSort(String colId, String ascDesc, int sortOrder) {
 678                 if (sortOrder <= 0) {
 679                         sortOrder = 1;
 680                         List reportCols = getAllColumns();
 681                         for (Iterator iter = reportCols.iterator(); iter.hasNext();)
 682                                 if (((DataColumnType) iter.next()).getOrderBySeq() > 0)
 683                                         sortOrder++;
 684                 } // if
 685
 686                 DataColumnType dct = getColumnById(colId);
 687                 dct.setOrderBySeq(sortOrder);
 688                 dct.setOrderByAscDesc(ascDesc);
 689
 690                 resetCache(true);
 691         } // addColumnSort
 692
 693         public void removeColumnSort(String colId) {
 694                 DataColumnType dct = getColumnById(colId);
 695                 int sortOrder = dct.getOrderBySeq();
 696
 697                 dct.setOrderBySeq(0);
 698                 dct.setOrderByAscDesc(null);
 699
 700                 if (sortOrder > 0) {
 701                         List reportCols = getAllColumns();
 702                         for (Iterator iter = reportCols.iterator(); iter.hasNext();) {
 703                                 DataColumnType dct2 = (DataColumnType) iter.next();
 704
 705                                 if (dct2.getOrderBySeq() > sortOrder)
 706                                         dct2.setOrderBySeq(dct2.getOrderBySeq() - 1);
 707                         } // for
 708                 } // if
 709
 710                 resetCache(true);
 711         } // removeColumnSort
 712
 713         public void shiftColumnSortUp(String colId) {
 714                 List reportCols = getAllColumns();
 715                 Collections.sort(reportCols, new OrderBySeqComparator());
 716
 717                 for (int i = 0; i < reportCols.size(); i++) {
 718                         DataColumnType dct = (DataColumnType) reportCols.get(i);
 719
 720                         if (dct.getColId().equals(colId) && (dct.getOrderBySeq() > 0)) {
 721                                 DataColumnType dctUp = (DataColumnType) reportCols.get(i - 1);
 722                                 if (dctUp.getOrderBySeq() > 0)
 723                                         dctUp.setOrderBySeq(dctUp.getOrderBySeq() + 1);
 724                                 dct.setOrderBySeq(dct.getOrderBySeq() - 1);
 725                                 break;
 726                         } // if
 727                 } // for
 728
 729                 Collections.sort(reportCols, new OrderSeqComparator());
 730                 resetCache(true);
 731         } // shiftColumnSortUp
 732
 733         public void shiftColumnSortDown(String colId) {
 734                 List reportCols = getAllColumns();
 735                 Collections.sort(reportCols, new OrderBySeqComparator());
 736
 737                 for (int i = 0; i < reportCols.size(); i++) {
 738                         DataColumnType dct = (DataColumnType) reportCols.get(i);
 739
 740                         if (dct.getColId().equals(colId) && (dct.getOrderBySeq() > 0)) {
 741                                 DataColumnType dctDown = (DataColumnType) reportCols.get(i + 1);
 742                                 if (dctDown.getOrderBySeq() > 0)
 743                                         dctDown.setOrderBySeq(dctDown.getOrderBySeq() - 1);
 744                                 dct.setOrderBySeq(dct.getOrderBySeq() + 1);
 745                                 break;
 746                         } // if
 747                 } // for
 748
 749                 Collections.sort(reportCols, new OrderSeqComparator());
 750                 resetCache(true);
 751         } // shiftColumnSortDown
 752
 753         /** ************************************************************************************************* */
 754
 755         public String generateNewSemaphoreId() {
 756                 if (getSemaphoreList() == null)
 757                         return "sem1";
 758
 759                 String semaphoreId = null;
 760                 boolean idExists = true;
 761                 for (int i = 1; idExists; i++) {
 762                         semaphoreId = "sem" + i;
 763                         idExists = false;
 764                         for (Iterator iter = getSemaphoreList().getSemaphore().iterator(); iter.hasNext();)
 765                                 if (semaphoreId.equals(((SemaphoreType) iter.next()).getSemaphoreId())) {
 766                                         idExists = true;
 767                                         break;
 768                                 }
 769                 } // for
 770
 771                 return semaphoreId;
 772         } // generateNewSemaphoreId
 773
 774         public SemaphoreType addSemaphore(ObjectFactory objFactory, SemaphoreType semaphoreType)
 775                         throws RaptorException {
 776                 SemaphoreType sem =  null;
 777                 try {
 778                 if (getSemaphoreList() == null)
 779                         setSemaphoreList(objFactory.createSemaphoreList());
 780
 781                 String semaphoreName = null;
 782                 boolean nameExists = true;
 783                 for (int i = 1; nameExists; i++) {
 784                         semaphoreName = semaphoreType.getSemaphoreName() + ((i > 1) ? (" v" + i) : "");
 785                         nameExists = false;
 786                         for (Iterator iter2 = getSemaphoreList().getSemaphore().iterator(); iter2
 787                                         .hasNext();)
 788                                 if (semaphoreName.equals(((SemaphoreType) iter2.next()).getSemaphoreName())) {
 789                                         nameExists = true;
 790                                         break;
 791                                 }
 792                 } // for
 793
 794                 sem = cloneSemaphoreType(objFactory, semaphoreType);
 795                 getSemaphoreList().getSemaphore().add(sem);
 796
 797                 sem.setSemaphoreId(generateNewSemaphoreId());
 798                 sem.setSemaphoreName(semaphoreName);
 799                 } catch (JAXBException ex) {
 800                     logger.debug(EELFLoggerDelegate.errorLogger, "JAXBException in addSemaphore", ex);
 801                         throw new RaptorException(ex.getMessage(), ex.getCause());
 802                 }
 803
 804                 return sem;
 805         } // addSemaphore
 806
 807         public SemaphoreType addSemaphoreType(ObjectFactory objFactory, String semaphoreName,
 808                         String semaphoreType, String comment) throws RaptorException {
 809                 SemaphoreType sem =  null;
 810                         if (getSemaphoreList() == null)
 811                                 setSemaphoreList(objFactory.createSemaphoreList());
 812
 813                         sem = objFactory.createSemaphoreType();
 814                         getSemaphoreList().getSemaphore().add(sem);
 815
 816                         sem.setSemaphoreId(generateNewSemaphoreId());
 817                         sem.setSemaphoreName(semaphoreName);
 818                         sem.setSemaphoreType(nvl(semaphoreType));
 819                         if (nvl(comment).length() > 0)
 820                                 sem.setComment(comment);
 821
 822                         FormatList formatList = objFactory.createFormatList();
 823                         sem.setFormatList(formatList);
 824                 return sem;
 825         } // addSemaphoreType
 826
 827
 828         public String getNextIdForJavaScriptElement (ObjectFactory objFactory, String fieldId) throws RaptorException {
 829                 String id = "";
 830                 JavascriptItemType jit = null;
 831                 int incr = 0;
 832                         if (getJavascriptList() == null) {
 833                                 setJavascriptList(objFactory.createJavascriptList());
 834                                 return fieldId + "|1";
 835                         } else {
 836                                 if(getJavascriptList().getJavascriptItem().iterator().hasNext()) {
 837                                 for (Iterator iter = getJavascriptList().getJavascriptItem().iterator(); iter.hasNext();) {
 838                                         jit = (JavascriptItemType) iter.next();
 839                                         logger.debug(EELFLoggerDelegate.debugLogger, ("^^^^^JAVASCRIPTITEMTYPE " + jit.getFieldId() + " " + fieldId + " " + id));
 840                                         if(nvl(jit.getFieldId()).length()>0 && jit.getFieldId().equals(fieldId)) {
 841                                                 ++incr;
 842                                         }
 843                                 } // for
 844                                 return fieldId + "|"+incr;
 845                                 } else {
 846                                         return fieldId + "|1";
 847                                 }
 848
 849                         }
 850         }
 851
 852         public JavascriptItemType addJavascriptType(ObjectFactory objFactory, String id) throws RaptorException {
 853                 JavascriptItemType javascriptItemType =  null;
 854                 int flag = 0; // checking whether id existing in the list
 855                         if (getJavascriptList() == null) {
 856                                 setJavascriptList(objFactory.createJavascriptList());
 857                                 javascriptItemType = objFactory.createJavascriptItemType();
 858                                 getJavascriptList().getJavascriptItem().add(javascriptItemType);
 859                                 return javascriptItemType;
 860                         } else {
 861
 862                                 for (Iterator iter = getJavascriptList().getJavascriptItem().iterator(); iter.hasNext();) {
 863                                         javascriptItemType  = (JavascriptItemType)iter.next();
 864                                         if(javascriptItemType.getId().equals(id) && !id.startsWith("-1")) {
 865                                                 flag = 1;
 866                                                 break;
 867                                         }
 868                                 }
 869                                 if(flag == 1)
 870                                         return javascriptItemType;
 871                                 else {
 872                                         javascriptItemType = objFactory.createJavascriptItemType();
 873                                         getJavascriptList().getJavascriptItem().add(javascriptItemType);
 874                                         return javascriptItemType;
 875                                 }
 876                         }
 877
 878         } // addSemaphoreType
 879
 880         public boolean deleteJavascriptType(String id) throws RaptorException {
 881                 JavascriptItemType javascriptType =  null;
 882                 if (getJavascriptList() == null)
 883                         return true;
 884                 for (Iterator iter = getJavascriptList().getJavascriptItem().iterator(); iter.hasNext();) {
 885                         javascriptType  = (JavascriptItemType)iter.next();
 886                         if(javascriptType.getId().equals(id)) {
 887                                 iter.remove();
 888                                 return true;
 889                         }
 890                 }
 891                 return false;
 892         } // addSemaphoreType
 893
 894         public static FormatType addEmptyFormatType(ObjectFactory objFactory,
 895                         SemaphoreType semaphore) throws RaptorException {
 896                 FormatType fmt = null;
 897                         fmt = objFactory.createFormatType();
 898                         semaphore.getFormatList().getFormat().add(fmt);
 899
 900                         String formatId = null;
 901                         boolean idExists = true;
 902                         for (int i = 1; idExists; i++) {
 903                                 formatId = semaphore.getSemaphoreId() + "_fmt" + i;
 904                                 idExists = false;
 905                                 for (Iterator iter = semaphore.getFormatList().getFormat().iterator(); iter
 906                                                 .hasNext();)
 907                                         if (formatId.equals(((FormatType) iter.next()).getFormatId())) {
 908                                                 idExists = true;
 909                                                 break;
 910                                         }
 911                         } // for
 912                         fmt.setFormatId(formatId);
 913                 return fmt;
 914         } // addEmptyFormatType
 915
 916         public static void deleteFormatType(SemaphoreType semaphore, String formatId) {
 917                 for (Iterator iter = semaphore.getFormatList().getFormat().iterator(); iter.hasNext();)
 918                         if (formatId.equals(((FormatType) iter.next()).getFormatId())) {
 919                                 iter.remove();
 920                                 break;
 921                         } // if
 922         } // deleteFormatType
 923
 924         public FormFieldType addFormFieldType(ObjectFactory objFactory, String fieldName,
 925                         String colId, String fieldType, String validationType, String mandatory,
 926                         String defaultValue, String fieldSQL, String comment, Calendar rangeStartDate, Calendar rangeEndDate,
 927                         String rangeStartDateSQL, String rangeEndDateSQL) throws RaptorException {
 928                 FormFieldType fft = null;
 929                         fft = objFactory.createFormFieldType();
 930
 931                         fft.setFieldName(fieldName);
 932                         fft.setColId(colId);
 933                         fft.setFieldType(fieldType);
 934                         fft.setValidationType(validationType);
 935                         fft.setMandatory(nvl(mandatory, "N"));
 936                         fft.setDefaultValue(nvl(defaultValue));
 937                         fft.setOrderBySeq((getFormFieldList() == null) ? 1 : getFormFieldList().getFormField()
 938                                         .size() + 1);
 939                         fft.setFieldSQL(fieldSQL);
 940             try {
 941                 fft.setRangeStartDate(DatatypeFactory.newInstance()
 942                         .newXMLGregorianCalendar(rangeStartDate.YEAR, rangeStartDate.MONTH, rangeStartDate.DAY_OF_WEEK, rangeStartDate.HOUR, rangeStartDate.MINUTE, rangeStartDate.SECOND, rangeStartDate.MILLISECOND, rangeStartDate.ZONE_OFFSET));
 943                 fft.setRangeStartDate(DatatypeFactory.newInstance()
 944                         .newXMLGregorianCalendar(rangeEndDate.YEAR, rangeEndDate.MONTH, rangeEndDate.DAY_OF_WEEK, rangeEndDate.HOUR, rangeEndDate.MINUTE, rangeEndDate.SECOND, rangeEndDate.MILLISECOND, rangeEndDate.ZONE_OFFSET));
 945             } catch (DatatypeConfigurationException ex) {
 946                 logger.debug(EELFLoggerDelegate.errorLogger, "DatatypeConfigurationException in addFormFieldType", ex);
 947             }
 948
 949                         fft.setRangeStartDateSQL(rangeStartDateSQL);
 950                         fft.setRangeEndDateSQL(rangeEndDateSQL);
 951                         if (nvl(comment).length() > 0)
 952                                 fft.setComment(comment);
 953
 954                         String fieldId = null;
 955                         boolean idExists = true;
 956                         for (int i = 1; idExists; i++) {
 957                                 fieldId = "ff" + i;
 958                                 idExists = false;
 959                                 if (getFormFieldList() != null)
 960                                         for (Iterator iter = getFormFieldList().getFormField().iterator(); iter
 961                                                         .hasNext();)
 962                                                 if (fieldId.equals(((FormFieldType) iter.next()).getFieldId())) {
 963                                                         idExists = true;
 964                                                         break;
 965                                                 }
 966                         } // for
 967                         fft.setFieldId(fieldId);
 968
 969                         if (getFormFieldList() == null) {
 970                                 FormFieldList formFieldList = objFactory.createFormFieldList();
 971                                 setFormFieldList(formFieldList);
 972                         }
 973
 974                         getFormFieldList().getFormField().add(fft);
 975                 return fft;
 976         } // addFormFieldType
 977
 978         //addCustomizedTextForParameters
 979         public void addCustomizedTextForParameters(String comment) throws RaptorException {
 980                         getFormFieldList().setComment(comment);
 981         }
 982
 983         public FormFieldType addFormFieldBlank(ObjectFactory objFactory) throws RaptorException {
 984                 FormFieldType fft = null;
 985                         fft = objFactory.createFormFieldType();
 986
 987                         fft.setFieldName("BLANK");
 988                 fft.setColId("bk");
 989                 fft.setFieldType(FormField.FFT_BLANK);
 990                 fft.setOrderBySeq((getFormFieldList() == null) ? 1 : getFormFieldList().getFormField()
 991                                         .size() + 1);
 992                         String fieldId = null;
 993                         boolean idExists = true;
 994                         for (int i = 1; idExists; i++) {
 995                                 fieldId = "ff" + i;
 996                                 idExists = false;
 997                                 if (getFormFieldList() != null)
 998                                         for (Iterator iter = getFormFieldList().getFormField().iterator(); iter
 999                                                         .hasNext();)
1000                                                 if (fieldId.equals(((FormFieldType) iter.next()).getFieldId())) {
1001                                                         idExists = true;
1002                                                         break;
1003                                                 }
1004                         } // for
1005                         fft.setFieldId(fieldId);
1006
1007                         if (getFormFieldList() == null) {
1008                                 FormFieldList formFieldList = objFactory.createFormFieldList();
1009                                 setFormFieldList(formFieldList);
1010                         }
1011
1012                         getFormFieldList().getFormField().add(fft);
1013                 return fft;
1014         } // addFormFieldBlank
1015
1016         public void replaceFormFieldReferences(String fieldName, String replaceWith) {
1017                 if (fieldName.equals(replaceWith))
1018                         return;
1019
1020                 for (Iterator iter = getAllColumns().iterator(); iter.hasNext();) {
1021                         DataColumnType dct = (DataColumnType) iter.next();
1022
1023                         if (dct.isCalculated() && dct.getColName().indexOf(fieldName) >= 0)
1024                                 dct.setColName(Utils.replaceInString(dct.getColName(), fieldName, nvl(
1025                                                 replaceWith, "NULL")));
1026
1027                         if (dct.getColFilterList() != null)
1028                                 for (Iterator iter2 = dct.getColFilterList().getColFilter().iterator(); iter2
1029                                                 .hasNext();) {
1030                                         ColFilterType cft = (ColFilterType) iter2.next();
1031
1032                                         if (nvl(cft.getArgType()).equals(AppConstants.AT_FORM)
1033                                                         && nvl(cft.getArgValue()).equals(fieldName))
1034                                                 cft.setArgValue(replaceWith);
1035                                 } // for
1036                 } // for
1037         } // replaceFormFieldReferences
1038
1039         public void deleteFormField(String fieldId) {
1040                 String fieldDisplayName = null;
1041
1042                 int orderBySeq = Integer.MAX_VALUE;
1043                 if (getFormFieldList() != null)
1044                         for (Iterator iter = getFormFieldList().getFormField().iterator(); iter.hasNext();) {
1045                                 FormFieldType fft = (FormFieldType) iter.next();
1046
1047                                 if (fieldId.equals(fft.getFieldId())) {
1048                                         fieldDisplayName = getFormFieldDisplayName(fft);
1049                                         iter.remove();
1050                                 } else if (fft.getOrderBySeq()!=null && (fft.getOrderBySeq().intValue() > orderBySeq))
1051                                         fft.setOrderBySeq(fft.getOrderBySeq() - 1);
1052                         } // for
1053
1054                 if (fieldDisplayName != null)
1055                         replaceFormFieldReferences(fieldDisplayName, "");
1056         } // deleteFormField
1057
1058         public void shiftFormFieldUp(String fieldId) {
1059                 if (getFormFieldList() == null)
1060                         return;
1061
1062                 for (int i = 0; i < getFormFieldList().getFormField().size(); i++) {
1063                         FormFieldType fft = (FormFieldType) getFormFieldList().getFormField().get(i);
1064
1065                         if (fft.getFieldId().equals(fieldId) && (i > 0)) {
1066                                 FormFieldType prevFft = (FormFieldType) getFormFieldList().getFormField().get(
1067                                                 i - 1);
1068                                 prevFft.setOrderBySeq(prevFft.getOrderBySeq() + 1);
1069                                 fft.setOrderBySeq((fft.getOrderBySeq() == null)?0:fft.getOrderBySeq() - 1);
1070
1071                                 getFormFieldList().getFormField().remove(i);
1072                                 getFormFieldList().getFormField().add(i - 1, fft);
1073                                 return;
1074                         } // if
1075                 } // for
1076         } // shiftFormFieldUp
1077
1078         public void shiftFormFieldDown(String fieldId) {
1079                 if (getFormFieldList() == null)
1080                         return;
1081
1082                 for (int i = 0; i < getFormFieldList().getFormField().size(); i++) {
1083                         FormFieldType fft = (FormFieldType) getFormFieldList().getFormField().get(i);
1084
1085                         if (fft.getFieldId().equals(fieldId)
1086                                         && (i < getFormFieldList().getFormField().size() - 1)) {
1087                                 FormFieldType nextFft = (FormFieldType) getFormFieldList().getFormField().get(
1088                                                 i + 1);
1089                                 nextFft.setOrderBySeq((nextFft.getOrderBySeq() == null)?0:nextFft.getOrderBySeq() - 1);
1090                                 fft.setOrderBySeq((fft.getOrderBySeq() == null)?0:fft.getOrderBySeq() + 1);
1091
1092                                 getFormFieldList().getFormField().remove(i + 1);
1093                                 getFormFieldList().getFormField().add(i, nextFft);
1094                                 return;
1095                         } // if
1096                 } // for
1097         } // shiftFormFieldDown
1098
1099         public static void addFormFieldPredefinedValue(ObjectFactory objFactory,
1100                         FormFieldType formField, String predefinedValue) throws RaptorException {
1101                         if (formField.getPredefinedValueList() == null) {
1102                                 PredefinedValueList predefinedValueList = objFactory.createPredefinedValueList();
1103                                 formField.setPredefinedValueList(predefinedValueList);
1104                         } // if
1105
1106                         if (predefinedValue.length() > 0) {
1107                                 formField.getPredefinedValueList().getPredefinedValue().add(predefinedValue);
1108                                 Collections.sort(formField.getPredefinedValueList().getPredefinedValue());
1109                         } // if
1110         } // addFormFieldPredefinedValue
1111
1112         public static void deleteFormFieldPredefinedValue(FormFieldType formField,
1113                         String predefinedValue) {
1114                 if (formField != null && formField.getPredefinedValueList() != null
1115                                 && predefinedValue.length() > 0)
1116                         for (Iterator iter = formField.getPredefinedValueList().getPredefinedValue()
1117                                         .iterator(); iter.hasNext();)
1118                                 if (predefinedValue.equals((String) iter.next())) {
1119                                         iter.remove();
1120                                         break;
1121                                 } // if
1122         } // deleteFormFieldPredefinedValue
1123
1124         /** ************************************************************************************************* */
1125
1126         private int curSQLParsePos = 0;
1127
1128         private String getNextSQLParseToken(String sql, boolean updateParsePos) {
1129                 int braketCount = 0;
1130                 boolean isInsideQuote = false;
1131                 StringBuffer nextToken = new StringBuffer();
1132                 for (int idxNext = curSQLParsePos; idxNext < sql.length(); idxNext++) {
1133                         char ch = sql.charAt(idxNext);
1134
1135                         if (Character.isWhitespace(ch) || ch == ',') {
1136                                 if (ch == ',')
1137                                         nextToken.append(ch);
1138
1139                                 if (nextToken.length() == 0)
1140                                         continue;
1141                                 else if (braketCount == 0 && (!isInsideQuote)) {
1142                                         if (updateParsePos)
1143                                                 curSQLParsePos = idxNext + ((ch == ',') ? 1 : 0);
1144                                         break;
1145                                 } else if (ch != ',' && nextToken.charAt(nextToken.length() - 1) != ' ')
1146                                         nextToken.append(' ');
1147                         } else {
1148                                 nextToken.append(ch);
1149
1150                                 if (ch == '(' || ch == '[')
1151                                         braketCount++;
1152                                 else if (ch == ')' || ch == ']')
1153                                         braketCount--;
1154                                 else if (ch == '\''/* ||ch=='\"' */)
1155                                         isInsideQuote = (!isInsideQuote);
1156                         } // else
1157                 } // for
1158
1159                 return nextToken.toString();
1160         } // getNextSQLParseToken
1161
1162         private boolean isParseSQLColID(String token) {
1163                 if (nvl(token).length() == 0)
1164                         return false;
1165
1166                 for (int i = 0; i < token.length(); i++) {
1167                         char ch = token.charAt(i);
1168
1169                         if (i == 0 && ch == '_')
1170                                 return false;
1171
1172                         if (!(Character.isLetterOrDigit(ch) || ch == '_'))
1173                                 return false;
1174                 } // for
1175
1176                 return true;
1177         } // isParseSQLColID
1178
1179         private DataColumnType getParseSQLDataColumn(String sqlExpression, String colId,
1180                         StringBuffer parsedSQL, Vector updatedReportCols, boolean isCYMBALScript) throws RaptorException {
1181                 DataColumnType dct = null;
1182
1183                 if (colId != null) {
1184                         if (!isParseSQLColID(colId))
1185                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1186                                                 "["
1187                                                                 + colId
1188                                                                 + "] must either be a valid column id consisting only of letters, numbers, and underscores, or there must be a comma in front of it.");
1189
1190                         dct = getColumnById(colId);
1191                 } else {
1192                         // Getting unique column id
1193                         colId = "";
1194                         int colIdN = 0;
1195                         for (int i = 0; (i < sqlExpression.length()) && (colIdN < 2); i++)
1196                                 if (Character.isLetter(sqlExpression.charAt(i))) {
1197                                         colId += sqlExpression.toLowerCase().charAt(i);
1198                                         colIdN++;
1199                                 } // if
1200
1201                         colIdN = getAllColumns().size() + updatedReportCols.size();
1202                         for (boolean idAlreadyUsed = true; idAlreadyUsed; colIdN++) {
1203                                 String newColId = colId + colIdN;
1204                                 idAlreadyUsed = false;
1205
1206                                 for (Iterator iter = getAllColumns().iterator(); iter.hasNext();)
1207                                         if (newColId.equals(((DataColumnType) iter.next()).getColId())) {
1208                                                 idAlreadyUsed = true;
1209                                                 break;
1210                                         }
1211
1212                                 if (!idAlreadyUsed)
1213                                         for (Iterator iter = updatedReportCols.iterator(); iter.hasNext();)
1214                                                 if (newColId.equals(((DataColumnType) iter.next()).getColId())) {
1215                                                         idAlreadyUsed = true;
1216                                                         break;
1217                                                 }
1218                         } // for
1219
1220                         colId += (colIdN - 1);
1221                 } // else
1222
1223                 if (dct == null) {
1224                         dct = (new ObjectFactory()).createDataColumnType();
1225                         dct.setColId(colId);
1226                         dct.setDisplayWidth(10);
1227                         dct.setDisplayAlignment("Left");
1228                         dct.setVisible(true);
1229                         dct.setGroupBreak(false); // ???
1230                         if(!isCYMBALScript) {
1231                                 boolean isValidIdentifier = Character.isLetterOrDigit(sqlExpression.charAt(0));
1232                                 for (int i = 0; i < sqlExpression.length(); i++)
1233                                         if (!(Character.isLetterOrDigit(sqlExpression.charAt(i))
1234                                                         || (sqlExpression.charAt(i) == '_') || (sqlExpression.charAt(i) == '$'))) {
1235                                                 isValidIdentifier = false;
1236                                                 break;
1237                                         } // if
1238
1239                                 if (isValidIdentifier) {
1240                                         dct.setDisplayName(sqlExpression);
1241                                 } else {
1242                                         dct.setDisplayName(colId);
1243                                 } // else
1244                         } else dct.setDisplayName(colId);
1245                 } // if
1246                  if(!isCYMBALScript)
1247                 sqlExpression = sqlExpression.replaceAll(", '", ",'");
1248                 dct.setDbColName(sqlExpression);
1249                 dct.setColName(sqlExpression);
1250                 dct.setCalculated(true);
1251                 dct.setColType(AppConstants.CT_CHAR);
1252                 dct.setDbColType(AppConstants.CT_CHAR);
1253                 adjustColumnType(dct); // ???
1254                 if(!isCYMBALScript) {
1255                         if (parsedSQL.toString().equals("SELECT ")
1256                                         || parsedSQL.toString().equals("SELECT DISTINCT "))
1257                                 parsedSQL.append("\n\t");
1258                         else
1259                                 parsedSQL.append(", \n\t");
1260                         parsedSQL.append(sqlExpression);
1261                         parsedSQL.append(" ");
1262                         parsedSQL.append(colId);
1263                 }
1264
1265                 return dct;
1266         } // getParseSQLDataColumn
1267
1268         public void parseReportSQL(String sql) throws RaptorException {
1269                 StringBuffer parsedSQL = new StringBuffer();
1270
1271                 Vector updatedReportCols = new Vector();
1272
1273                 curSQLParsePos = 0;
1274                 int lastParsePos = curSQLParsePos;
1275                 String lastToken = null;
1276                 String nextToken = getNextSQLParseToken(sql, true);
1277
1278         String  dbInfo          = getDBInfo();
1279         boolean isCYMBALScript = false;
1280                 if (!isNull(dbInfo) && (!dbInfo.equals(AppConstants.DB_LOCAL))) {
1281                         try {
1282                          String dbType = remDbInfo.getDBType(dbInfo);
1283                          if (dbType.equals("DAYTONA") && !(nextToken.toUpperCase().equals("SELECT"))) {
1284                                  isCYMBALScript = true;
1285                          }
1286                         } catch (Exception ex) {
1287                    throw new RaptorException(ex);
1288                         }
1289                 }
1290                 if ( isCYMBALScript == false ) {
1291                         while (nextToken.length() > 0) {
1292                                 if (parsedSQL.length() == 0) {
1293                                         if (nextToken.toUpperCase().equals("SELECT"))
1294                                                 parsedSQL.append("SELECT ");
1295                                         else
1296                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1297                                                                 "The SQL must start with the SELECT keyword.");
1298                                 } else if (nextToken.toUpperCase().equals("DISTINCT")
1299                                                 && parsedSQL.toString().equals("SELECT ")) {
1300                                         parsedSQL.append("DISTINCT ");
1301                                 } else if (nextToken.equals("*")
1302                                                 && (parsedSQL.toString().equals("SELECT ") || parsedSQL.toString().equals(
1303                                                                 "SELECT DISTINCT "))) {
1304                                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1305                                                         "You cannot use \"SELECT *\". Please specify select columns/expressions.");
1306                                 } else if (nextToken.toUpperCase().equals("FROM")) {
1307                                         if (lastToken != null) {
1308                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null, parsedSQL,
1309                                                                 updatedReportCols, false));
1310                                                 lastToken = null;
1311                                         }
1312
1313                                         parsedSQL.append(" \n");
1314                                         while (lastParsePos < sql.length()
1315                                                         && Character.isWhitespace(sql.charAt(lastParsePos)))
1316                                                 lastParsePos++;
1317                                         parsedSQL.append(sql.substring(lastParsePos));
1318                                         break;
1319                                 } else {
1320                                         if (nextToken.charAt(nextToken.length() - 1) == ',') {
1321                                                 // The token ends with ,
1322                                                 nextToken = nextToken.substring(0, nextToken.length() - 1);
1323
1324                                                 if (nextToken.length() == 0) {
1325                                                         if (lastToken != null) {
1326                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null,
1327                                                                                 parsedSQL, updatedReportCols, false));
1328                                                                 lastToken = null;
1329                                                         } // else just comma => ignore it
1330                                                 } else {
1331                                                         if (lastToken != null) {
1332                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1333                                                                                 parsedSQL, updatedReportCols, false));
1334                                                                 lastToken = null;
1335                                                         } else
1336                                                                 updatedReportCols.add(getParseSQLDataColumn(nextToken, null,
1337                                                                                 parsedSQL, updatedReportCols, false));
1338                                                 }
1339                                         } else {
1340                                                 // The token doesn't end with ,
1341                                                 if (lastToken == null)
1342                                                         lastToken = nextToken;
1343                                                 else {
1344                                                         String token = getNextSQLParseToken(sql, false);
1345                                                         if (!token.toUpperCase().equals("FROM"))
1346                                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1347                                                                                 "|FROM keyword or a comma expected after [" + nextToken
1348                                                                                                 + "].");
1349
1350                                                         updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1351                                                                         parsedSQL, updatedReportCols, false));
1352                                                         lastToken = null;
1353                                                 } // else
1354                                         } // else
1355                                 } // else
1356
1357                                 lastParsePos = curSQLParsePos;
1358                                 nextToken = getNextSQLParseToken(sql, true);
1359                         } // while
1360                 } else { // if CYMBAL Script
1361                         curSQLParsePos = 0;
1362                         Pattern re                      = null;
1363                         Matcher matcher         = null;
1364                         String extracted        = null;
1365                         nextToken = getNextCYMBALSQLParseToken(sql,true);
1366                         while (nextToken.length() > 0) {
1367                                 if (lastToken == null)
1368                                         lastToken = nextToken;
1369
1370                                 if( lastToken.toUpperCase().startsWith("DO DISPLAY")) {
1371                                         re              = Pattern.compile("each(.*)\\[.(.*?)\\]");   //\\[(.*?)\\]
1372                                         matcher = re.matcher(nextToken);
1373                                         if (matcher.find()) {
1374                                                 extracted = matcher.group();
1375                                                 re              = Pattern.compile("\\[(.*?)\\]");
1376                                         matcher = re.matcher(nextToken);
1377                                         if(matcher.find()) {
1378                                                 extracted = matcher.group();
1379                                                 extracted = extracted.substring(1,extracted.length()-1);
1380                                                 StringTokenizer sToken = new StringTokenizer(extracted, ",");
1381                                                 while(sToken.hasMoreTokens()) {
1382                                                 String str1 = sToken.nextToken().trim().substring(1);
1383                                             updatedReportCols.add(getParseSQLDataColumn("", str1,
1384                                                         new StringBuffer(""), updatedReportCols, true));
1385                                                 }
1386                                         }
1387
1388                                         }
1389
1390                                 }
1391                                 lastToken = nextToken;
1392                                 nextToken = getNextCYMBALSQLParseToken(sql, true);
1393                         }
1394
1395                 }
1396                 if (updatedReportCols.size() == 0)
1397                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1398                                         "The SQL statement must have at least one column in the SELECT clause.");
1399                 if (getDataSourceList().getDataSource().size() == 0)
1400                         addDataSourceType(new ObjectFactory(), "du0", "DUAL", "", "DUAL", null, null, null);
1401                 DataSourceType dst = (DataSourceType) getDataSourceList().getDataSource().get(0);
1402                 dst.getDataColumnList().getDataColumn().clear();
1403
1404                 for (int i = 0; i < updatedReportCols.size(); i++) {
1405                         DataColumnType dct = (DataColumnType) updatedReportCols.get(i);
1406                         dct.setTableId(dst.getTableId());
1407                         dct.setOrderSeq(i + 1);
1408                         dst.getDataColumnList().getDataColumn().add(dct);
1409                 } // for
1410                 setReportSQL(parsedSQL.toString());
1411                 resetCache(false);
1412         } // parseReportSQL
1413
1414         public void parseReportSQL(String sql, boolean storeInSession) throws RaptorException {
1415                 StringBuffer parsedSQL = new StringBuffer();
1416
1417                 Vector updatedReportCols = new Vector();
1418
1419                 curSQLParsePos = 0;
1420                 int lastParsePos = curSQLParsePos;
1421                 String lastToken = null;
1422                 String nextToken = getNextSQLParseToken(sql, true);
1423
1424         String  dbInfo          = getDBInfo();
1425         boolean isCYMBALScript = false;
1426                 if (!isNull(dbInfo) && (!dbInfo.equals(AppConstants.DB_LOCAL))) {
1427                         try {
1428                          String dbType = remDbInfo.getDBType(dbInfo);
1429                          if (dbType.equals("DAYTONA") && !(nextToken.toUpperCase().equals("SELECT"))) {
1430                                  isCYMBALScript = true;
1431                          }
1432                         } catch (Exception ex) {
1433                    throw new RaptorException(ex);
1434                         }
1435                 }
1436                 if ( isCYMBALScript == false ) {
1437                         while (nextToken.length() > 0) {
1438                                 if (parsedSQL.length() == 0) {
1439                                         if (nextToken.toUpperCase().equals("SELECT"))
1440                                                 parsedSQL.append("SELECT ");
1441                                         else
1442                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1443                                                                 "The SQL must start with the SELECT keyword.");
1444                                 } else if (nextToken.toUpperCase().equals("DISTINCT")
1445                                                 && parsedSQL.toString().equals("SELECT ")) {
1446                                         parsedSQL.append("DISTINCT ");
1447                                 } else if (nextToken.equals("*")
1448                                                 && (parsedSQL.toString().equals("SELECT ") || parsedSQL.toString().equals(
1449                                                                 "SELECT DISTINCT "))) {
1450                                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1451                                                         "You cannot use \"SELECT *\". Please specify select columns/expressions.");
1452                                 } else if (nextToken.toUpperCase().equals("FROM")) {
1453                                         if (lastToken != null) {
1454                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null, parsedSQL,
1455                                                                 updatedReportCols, false));
1456                                                 lastToken = null;
1457                                         }
1458
1459                                         parsedSQL.append(" \n");
1460                                         while (lastParsePos < sql.length()
1461                                                         && Character.isWhitespace(sql.charAt(lastParsePos)))
1462                                                 lastParsePos++;
1463                                         parsedSQL.append(sql.substring(lastParsePos));
1464                                         break;
1465                                 } else {
1466                                         if (nextToken.charAt(nextToken.length() - 1) == ',') {
1467                                                 // The token ends with ,
1468                                                 nextToken = nextToken.substring(0, nextToken.length() - 1);
1469
1470                                                 if (nextToken.length() == 0) {
1471                                                         if (lastToken != null) {
1472                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null,
1473                                                                                 parsedSQL, updatedReportCols, false));
1474                                                                 lastToken = null;
1475                                                         } // else just comma => ignore it
1476                                                 } else {
1477                                                         if (lastToken != null) {
1478                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1479                                                                                 parsedSQL, updatedReportCols, false));
1480                                                                 lastToken = null;
1481                                                         } else
1482                                                                 updatedReportCols.add(getParseSQLDataColumn(nextToken, null,
1483                                                                                 parsedSQL, updatedReportCols, false));
1484                                                 }
1485                                         } else {
1486                                                 // The token doesn't end with ,
1487                                                 if (lastToken == null)
1488                                                         lastToken = nextToken;
1489                                                 else {
1490                                                         String token = getNextSQLParseToken(sql, false);
1491                                                         if (!token.toUpperCase().equals("FROM"))
1492                                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1493                                                                                 "|FROM keyword or a comma expected after [" + nextToken
1494                                                                                                 + "].");
1495
1496                                                         updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1497                                                                         parsedSQL, updatedReportCols, false));
1498                                                         lastToken = null;
1499                                                 } // else
1500                                         } // else
1501                                 } // else
1502
1503                                 lastParsePos = curSQLParsePos;
1504                                 nextToken = getNextSQLParseToken(sql, true);
1505                         } // while
1506                 } else { // if CYMBAL Script
1507                         curSQLParsePos = 0;
1508                         Pattern re                      = null;
1509                         Matcher matcher         = null;
1510                         String extracted        = null;
1511                         nextToken = getNextCYMBALSQLParseToken(sql,true);
1512                         while (nextToken.length() > 0) {
1513                                 if (lastToken == null)
1514                                         lastToken = nextToken;
1515
1516                                 if( lastToken.toUpperCase().startsWith("DO DISPLAY")) {
1517                                         re              = Pattern.compile("each(.*)\\[.(.*?)\\]");   //\\[(.*?)\\]
1518                                         matcher = re.matcher(nextToken);
1519                                         if (matcher.find()) {
1520                                                 extracted = matcher.group();
1521                                                 re              = Pattern.compile("\\[(.*?)\\]");
1522                                         matcher = re.matcher(nextToken);
1523                                         if(matcher.find()) {
1524                                                 extracted = matcher.group();
1525                                                 extracted = extracted.substring(1,extracted.length()-1);
1526                                                 StringTokenizer sToken = new StringTokenizer(extracted, ",");
1527                                                 while(sToken.hasMoreTokens()) {
1528                                                 String str1 = sToken.nextToken().trim().substring(1);
1529                                             updatedReportCols.add(getParseSQLDataColumn("", str1,
1530                                                         new StringBuffer(""), updatedReportCols, true));
1531                                                 }
1532                                         }
1533
1534                                         }
1535
1536                                 }
1537                                 lastToken = nextToken;
1538                                 nextToken = getNextCYMBALSQLParseToken(sql, true);
1539                         }
1540
1541                 }
1542                 if (updatedReportCols.size() == 0)
1543                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1544                                         "The SQL statement must have at least one column in the SELECT clause.");
1545                 if (getDataSourceList().getDataSource().size() == 0)
1546                         addDataSourceType(new ObjectFactory(), "du0", "DUAL", "", "DUAL", null, null, null);
1547                 DataSourceType dst = (DataSourceType) getDataSourceList().getDataSource().get(0);
1548                 dst.getDataColumnList().getDataColumn().clear();
1549
1550                 for (int i = 0; i < updatedReportCols.size(); i++) {
1551                         DataColumnType dct = (DataColumnType) updatedReportCols.get(i);
1552                         dct.setTableId(dst.getTableId());
1553                         dct.setOrderSeq(i + 1);
1554                         dst.getDataColumnList().getDataColumn().add(dct);
1555                 } // for
1556                 if(storeInSession)
1557                         setReportSQL(parsedSQL.toString());
1558                 resetCache(false);
1559         } // parseReportSQL
1560
1561         private String getNextCYMBALSQLParseToken(String sql, boolean updateParsePos) {
1562                 int braketCount = 0;
1563                 boolean isInsideQuote = false;
1564                 StringBuffer nextToken = new StringBuffer();
1565                 for (int idxNext = curSQLParsePos; idxNext < sql.length(); idxNext++) {
1566                         char ch = sql.charAt(idxNext);
1567
1568                         if (ch!='\n') {
1569                                         nextToken.append(ch);
1570                                         if (updateParsePos)
1571                                                 curSQLParsePos = idxNext;
1572                         }
1573                         else {
1574                                 curSQLParsePos = idxNext+1;
1575                                 break;
1576                         }
1577                 } // for
1578
1579                 return nextToken.toString();
1580         } // getNextSQLParseToken
1581
1582         public void addChartAdditionalOptions(ObjectFactory objFactory) throws RaptorException {
1583                         ChartAdditionalOptions chartOptions = objFactory.createChartAdditionalOptions();
1584                         cr.setChartAdditionalOptions(chartOptions);
1585         }
1586
1587         public void addChartDrillOptions(ObjectFactory objFactory) throws RaptorException {
1588                 ChartDrillOptions chartOptions = objFactory.createChartDrillOptions();
1589                 cr.setChartDrillOptions(chartOptions);
1590 }
1591
1592         public void addDataminingOptions(ObjectFactory objFactory) throws RaptorException {
1593                         DataminingOptions dataminingOptions = objFactory.createDataminingOptions();
1594                         cr.setDataminingOptions(dataminingOptions);
1595         }
1596
1597 } // ReportDefinition