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             e.printStackTrace();
 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                         }
 668
 669                 resetCache(true);
 670         } // removeColumnFilter
 671
 672         public void addColumnSort(String colId, String ascDesc) {
 673                 addColumnSort(colId, ascDesc, -1);
 674         } // addColumnSort
 675
 676         public void addColumnSort(String colId, String ascDesc, int sortOrder) {
 677                 if (sortOrder <= 0) {
 678                         sortOrder = 1;
 679                         List reportCols = getAllColumns();
 680                         for (Iterator iter = reportCols.iterator(); iter.hasNext();)
 681                                 if (((DataColumnType) iter.next()).getOrderBySeq() > 0)
 682                                         sortOrder++;
 683                 } // if
 684
 685                 DataColumnType dct = getColumnById(colId);
 686                 dct.setOrderBySeq(sortOrder);
 687                 dct.setOrderByAscDesc(ascDesc);
 688
 689                 resetCache(true);
 690         } // addColumnSort
 691
 692         public void removeColumnSort(String colId) {
 693                 DataColumnType dct = getColumnById(colId);
 694                 int sortOrder = dct.getOrderBySeq();
 695
 696                 dct.setOrderBySeq(0);
 697                 dct.setOrderByAscDesc(null);
 698
 699                 if (sortOrder > 0) {
 700                         List reportCols = getAllColumns();
 701                         for (Iterator iter = reportCols.iterator(); iter.hasNext();) {
 702                                 DataColumnType dct2 = (DataColumnType) iter.next();
 703
 704                                 if (dct2.getOrderBySeq() > sortOrder)
 705                                         dct2.setOrderBySeq(dct2.getOrderBySeq() - 1);
 706                         } // for
 707                 } // if
 708
 709                 resetCache(true);
 710         } // removeColumnSort
 711
 712         public void shiftColumnSortUp(String colId) {
 713                 List reportCols = getAllColumns();
 714                 Collections.sort(reportCols, new OrderBySeqComparator());
 715
 716                 for (int i = 0; i < reportCols.size(); i++) {
 717                         DataColumnType dct = (DataColumnType) reportCols.get(i);
 718
 719                         if (dct.getColId().equals(colId) && (dct.getOrderBySeq() > 0)) {
 720                                 DataColumnType dctUp = (DataColumnType) reportCols.get(i - 1);
 721                                 if (dctUp.getOrderBySeq() > 0)
 722                                         dctUp.setOrderBySeq(dctUp.getOrderBySeq() + 1);
 723                                 dct.setOrderBySeq(dct.getOrderBySeq() - 1);
 724                                 break;
 725                         } // if
 726                 } // for
 727
 728                 Collections.sort(reportCols, new OrderSeqComparator());
 729                 resetCache(true);
 730         } // shiftColumnSortUp
 731
 732         public void shiftColumnSortDown(String colId) {
 733                 List reportCols = getAllColumns();
 734                 Collections.sort(reportCols, new OrderBySeqComparator());
 735
 736                 for (int i = 0; i < reportCols.size(); i++) {
 737                         DataColumnType dct = (DataColumnType) reportCols.get(i);
 738
 739                         if (dct.getColId().equals(colId) && (dct.getOrderBySeq() > 0)) {
 740                                 DataColumnType dctDown = (DataColumnType) reportCols.get(i + 1);
 741                                 if (dctDown.getOrderBySeq() > 0)
 742                                         dctDown.setOrderBySeq(dctDown.getOrderBySeq() - 1);
 743                                 dct.setOrderBySeq(dct.getOrderBySeq() + 1);
 744                                 break;
 745                         } // if
 746                 } // for
 747
 748                 Collections.sort(reportCols, new OrderSeqComparator());
 749                 resetCache(true);
 750         } // shiftColumnSortDown
 751
 752         /** ************************************************************************************************* */
 753
 754         public String generateNewSemaphoreId() {
 755                 if (getSemaphoreList() == null)
 756                         return "sem1";
 757
 758                 String semaphoreId = null;
 759                 boolean idExists = true;
 760                 for (int i = 1; idExists; i++) {
 761                         semaphoreId = "sem" + i;
 762                         idExists = false;
 763                         for (Iterator iter = getSemaphoreList().getSemaphore().iterator(); iter.hasNext();)
 764                                 if (semaphoreId.equals(((SemaphoreType) iter.next()).getSemaphoreId())) {
 765                                         idExists = true;
 766                                         break;
 767                                 }
 768                 } // for
 769
 770                 return semaphoreId;
 771         } // generateNewSemaphoreId
 772
 773         public SemaphoreType addSemaphore(ObjectFactory objFactory, SemaphoreType semaphoreType)
 774                         throws RaptorException {
 775                 SemaphoreType sem =  null;
 776                 try {
 777                 if (getSemaphoreList() == null)
 778                         setSemaphoreList(objFactory.createSemaphoreList());
 779
 780                 String semaphoreName = null;
 781                 boolean nameExists = true;
 782                 for (int i = 1; nameExists; i++) {
 783                         semaphoreName = semaphoreType.getSemaphoreName() + ((i > 1) ? (" v" + i) : "");
 784                         nameExists = false;
 785                         for (Iterator iter2 = getSemaphoreList().getSemaphore().iterator(); iter2
 786                                         .hasNext();)
 787                                 if (semaphoreName.equals(((SemaphoreType) iter2.next()).getSemaphoreName())) {
 788                                         nameExists = true;
 789                                         break;
 790                                 }
 791                 } // for
 792
 793                 sem = cloneSemaphoreType(objFactory, semaphoreType);
 794                 getSemaphoreList().getSemaphore().add(sem);
 795
 796                 sem.setSemaphoreId(generateNewSemaphoreId());
 797                 sem.setSemaphoreName(semaphoreName);
 798                 } catch (JAXBException ex) {
 799                         throw new RaptorException(ex.getMessage(), ex.getCause());
 800                 }
 801
 802                 return sem;
 803         } // addSemaphore
 804
 805         public SemaphoreType addSemaphoreType(ObjectFactory objFactory, String semaphoreName,
 806                         String semaphoreType, String comment) throws RaptorException {
 807                 SemaphoreType sem =  null;
 808                         if (getSemaphoreList() == null)
 809                                 setSemaphoreList(objFactory.createSemaphoreList());
 810
 811                         sem = objFactory.createSemaphoreType();
 812                         getSemaphoreList().getSemaphore().add(sem);
 813
 814                         sem.setSemaphoreId(generateNewSemaphoreId());
 815                         sem.setSemaphoreName(semaphoreName);
 816                         sem.setSemaphoreType(nvl(semaphoreType));
 817                         if (nvl(comment).length() > 0)
 818                                 sem.setComment(comment);
 819
 820                         FormatList formatList = objFactory.createFormatList();
 821                         sem.setFormatList(formatList);
 822                 return sem;
 823         } // addSemaphoreType
 824
 825
 826         public String getNextIdForJavaScriptElement (ObjectFactory objFactory, String fieldId) throws RaptorException {
 827                 String id = "";
 828                 JavascriptItemType jit = null;
 829                 int incr = 0;
 830                         if (getJavascriptList() == null) {
 831                                 setJavascriptList(objFactory.createJavascriptList());
 832                                 return fieldId + "|1";
 833                         } else {
 834                                 if(getJavascriptList().getJavascriptItem().iterator().hasNext()) {
 835                                 for (Iterator iter = getJavascriptList().getJavascriptItem().iterator(); iter.hasNext();) {
 836                                         jit = (JavascriptItemType) iter.next();
 837                                         logger.debug(EELFLoggerDelegate.debugLogger, ("^^^^^JAVASCRIPTITEMTYPE " + jit.getFieldId() + " " + fieldId + " " + id));
 838                                         if(nvl(jit.getFieldId()).length()>0 && jit.getFieldId().equals(fieldId)) {
 839                                                 ++incr;
 840                                         }
 841                                 } // for
 842                                 return fieldId + "|"+incr;
 843                                 } else {
 844                                         return fieldId + "|1";
 845                                 }
 846
 847                         }
 848         }
 849
 850         public JavascriptItemType addJavascriptType(ObjectFactory objFactory, String id) throws RaptorException {
 851                 JavascriptItemType javascriptItemType =  null;
 852                 int flag = 0; // checking whether id existing in the list
 853                         if (getJavascriptList() == null) {
 854                                 setJavascriptList(objFactory.createJavascriptList());
 855                                 javascriptItemType = objFactory.createJavascriptItemType();
 856                                 getJavascriptList().getJavascriptItem().add(javascriptItemType);
 857                                 return javascriptItemType;
 858                         } else {
 859
 860                                 for (Iterator iter = getJavascriptList().getJavascriptItem().iterator(); iter.hasNext();) {
 861                                         javascriptItemType  = (JavascriptItemType)iter.next();
 862                                         if(javascriptItemType.getId().equals(id) && !id.startsWith("-1")) {
 863                                                 flag = 1;
 864                                                 break;
 865                                         }
 866                                 }
 867                                 if(flag == 1)
 868                                         return javascriptItemType;
 869                                 else {
 870                                         javascriptItemType = objFactory.createJavascriptItemType();
 871                                         getJavascriptList().getJavascriptItem().add(javascriptItemType);
 872                                         return javascriptItemType;
 873                                 }
 874                         }
 875
 876         } // addSemaphoreType
 877
 878         public boolean deleteJavascriptType(String id) throws RaptorException {
 879                 JavascriptItemType javascriptType =  null;
 880                 if (getJavascriptList() == null)
 881                         return true;
 882                 for (Iterator iter = getJavascriptList().getJavascriptItem().iterator(); iter.hasNext();) {
 883                         javascriptType  = (JavascriptItemType)iter.next();
 884                         if(javascriptType.getId().equals(id)) {
 885                                 iter.remove();
 886                                 return true;
 887                         }
 888                 }
 889                 return false;
 890         } // addSemaphoreType
 891
 892         public static FormatType addEmptyFormatType(ObjectFactory objFactory,
 893                         SemaphoreType semaphore) throws RaptorException {
 894                 FormatType fmt = null;
 895                         fmt = objFactory.createFormatType();
 896                         semaphore.getFormatList().getFormat().add(fmt);
 897
 898                         String formatId = null;
 899                         boolean idExists = true;
 900                         for (int i = 1; idExists; i++) {
 901                                 formatId = semaphore.getSemaphoreId() + "_fmt" + i;
 902                                 idExists = false;
 903                                 for (Iterator iter = semaphore.getFormatList().getFormat().iterator(); iter
 904                                                 .hasNext();)
 905                                         if (formatId.equals(((FormatType) iter.next()).getFormatId())) {
 906                                                 idExists = true;
 907                                                 break;
 908                                         }
 909                         } // for
 910                         fmt.setFormatId(formatId);
 911                 return fmt;
 912         } // addEmptyFormatType
 913
 914         public static void deleteFormatType(SemaphoreType semaphore, String formatId) {
 915                 for (Iterator iter = semaphore.getFormatList().getFormat().iterator(); iter.hasNext();)
 916                         if (formatId.equals(((FormatType) iter.next()).getFormatId())) {
 917                                 iter.remove();
 918                                 break;
 919                         } // if
 920         } // deleteFormatType
 921
 922         public FormFieldType addFormFieldType(ObjectFactory objFactory, String fieldName,
 923                         String colId, String fieldType, String validationType, String mandatory,
 924                         String defaultValue, String fieldSQL, String comment, Calendar rangeStartDate, Calendar rangeEndDate,
 925                         String rangeStartDateSQL, String rangeEndDateSQL) throws RaptorException {
 926                 FormFieldType fft = null;
 927                         fft = objFactory.createFormFieldType();
 928
 929                         fft.setFieldName(fieldName);
 930                         fft.setColId(colId);
 931                         fft.setFieldType(fieldType);
 932                         fft.setValidationType(validationType);
 933                         fft.setMandatory(nvl(mandatory, "N"));
 934                         fft.setDefaultValue(nvl(defaultValue));
 935                         fft.setOrderBySeq((getFormFieldList() == null) ? 1 : getFormFieldList().getFormField()
 936                                         .size() + 1);
 937                         fft.setFieldSQL(fieldSQL);
 938             try {
 939                 fft.setRangeStartDate(DatatypeFactory.newInstance()
 940                         .newXMLGregorianCalendar(rangeStartDate.YEAR, rangeStartDate.MONTH, rangeStartDate.DAY_OF_WEEK, rangeStartDate.HOUR, rangeStartDate.MINUTE, rangeStartDate.SECOND, rangeStartDate.MILLISECOND, rangeStartDate.ZONE_OFFSET));
 941                 fft.setRangeStartDate(DatatypeFactory.newInstance()
 942                         .newXMLGregorianCalendar(rangeEndDate.YEAR, rangeEndDate.MONTH, rangeEndDate.DAY_OF_WEEK, rangeEndDate.HOUR, rangeEndDate.MINUTE, rangeEndDate.SECOND, rangeEndDate.MILLISECOND, rangeEndDate.ZONE_OFFSET));
 943             } catch (DatatypeConfigurationException ex) {
 944
 945             }
 946
 947                         fft.setRangeStartDateSQL(rangeStartDateSQL);
 948                         fft.setRangeEndDateSQL(rangeEndDateSQL);
 949                         if (nvl(comment).length() > 0)
 950                                 fft.setComment(comment);
 951
 952                         String fieldId = null;
 953                         boolean idExists = true;
 954                         for (int i = 1; idExists; i++) {
 955                                 fieldId = "ff" + i;
 956                                 idExists = false;
 957                                 if (getFormFieldList() != null)
 958                                         for (Iterator iter = getFormFieldList().getFormField().iterator(); iter
 959                                                         .hasNext();)
 960                                                 if (fieldId.equals(((FormFieldType) iter.next()).getFieldId())) {
 961                                                         idExists = true;
 962                                                         break;
 963                                                 }
 964                         } // for
 965                         fft.setFieldId(fieldId);
 966
 967                         if (getFormFieldList() == null) {
 968                                 FormFieldList formFieldList = objFactory.createFormFieldList();
 969                                 setFormFieldList(formFieldList);
 970                         }
 971
 972                         getFormFieldList().getFormField().add(fft);
 973                 return fft;
 974         } // addFormFieldType
 975
 976         //addCustomizedTextForParameters
 977         public void addCustomizedTextForParameters(String comment) throws RaptorException {
 978                         getFormFieldList().setComment(comment);
 979         }
 980
 981         public FormFieldType addFormFieldBlank(ObjectFactory objFactory) throws RaptorException {
 982                 FormFieldType fft = null;
 983                         fft = objFactory.createFormFieldType();
 984
 985                         fft.setFieldName("BLANK");
 986                 fft.setColId("bk");
 987                 fft.setFieldType(FormField.FFT_BLANK);
 988                 fft.setOrderBySeq((getFormFieldList() == null) ? 1 : getFormFieldList().getFormField()
 989                                         .size() + 1);
 990                         String fieldId = null;
 991                         boolean idExists = true;
 992                         for (int i = 1; idExists; i++) {
 993                                 fieldId = "ff" + i;
 994                                 idExists = false;
 995                                 if (getFormFieldList() != null)
 996                                         for (Iterator iter = getFormFieldList().getFormField().iterator(); iter
 997                                                         .hasNext();)
 998                                                 if (fieldId.equals(((FormFieldType) iter.next()).getFieldId())) {
 999                                                         idExists = true;
1000                                                         break;
1001                                                 }
1002                         } // for
1003                         fft.setFieldId(fieldId);
1004
1005                         if (getFormFieldList() == null) {
1006                                 FormFieldList formFieldList = objFactory.createFormFieldList();
1007                                 setFormFieldList(formFieldList);
1008                         }
1009
1010                         getFormFieldList().getFormField().add(fft);
1011                 return fft;
1012         } // addFormFieldBlank
1013
1014         public void replaceFormFieldReferences(String fieldName, String replaceWith) {
1015                 if (fieldName.equals(replaceWith))
1016                         return;
1017
1018                 for (Iterator iter = getAllColumns().iterator(); iter.hasNext();) {
1019                         DataColumnType dct = (DataColumnType) iter.next();
1020
1021                         if (dct.isCalculated() && dct.getColName().indexOf(fieldName) >= 0)
1022                                 dct.setColName(Utils.replaceInString(dct.getColName(), fieldName, nvl(
1023                                                 replaceWith, "NULL")));
1024
1025                         if (dct.getColFilterList() != null)
1026                                 for (Iterator iter2 = dct.getColFilterList().getColFilter().iterator(); iter2
1027                                                 .hasNext();) {
1028                                         ColFilterType cft = (ColFilterType) iter2.next();
1029
1030                                         if (nvl(cft.getArgType()).equals(AppConstants.AT_FORM)
1031                                                         && nvl(cft.getArgValue()).equals(fieldName))
1032                                                 cft.setArgValue(replaceWith);
1033                                 } // for
1034                 } // for
1035         } // replaceFormFieldReferences
1036
1037         public void deleteFormField(String fieldId) {
1038                 String fieldDisplayName = null;
1039
1040                 int orderBySeq = Integer.MAX_VALUE;
1041                 if (getFormFieldList() != null)
1042                         for (Iterator iter = getFormFieldList().getFormField().iterator(); iter.hasNext();) {
1043                                 FormFieldType fft = (FormFieldType) iter.next();
1044
1045                                 if (fieldId.equals(fft.getFieldId())) {
1046                                         fieldDisplayName = getFormFieldDisplayName(fft);
1047                                         iter.remove();
1048                                 } else if (fft.getOrderBySeq()!=null && (fft.getOrderBySeq().intValue() > orderBySeq))
1049                                         fft.setOrderBySeq(fft.getOrderBySeq() - 1);
1050                         } // for
1051
1052                 if (fieldDisplayName != null)
1053                         replaceFormFieldReferences(fieldDisplayName, "");
1054         } // deleteFormField
1055
1056         public void shiftFormFieldUp(String fieldId) {
1057                 if (getFormFieldList() == null)
1058                         return;
1059
1060                 for (int i = 0; i < getFormFieldList().getFormField().size(); i++) {
1061                         FormFieldType fft = (FormFieldType) getFormFieldList().getFormField().get(i);
1062
1063                         if (fft.getFieldId().equals(fieldId) && (i > 0)) {
1064                                 FormFieldType prevFft = (FormFieldType) getFormFieldList().getFormField().get(
1065                                                 i - 1);
1066                                 prevFft.setOrderBySeq(prevFft.getOrderBySeq() + 1);
1067                                 fft.setOrderBySeq((fft.getOrderBySeq() == null)?0:fft.getOrderBySeq() - 1);
1068
1069                                 getFormFieldList().getFormField().remove(i);
1070                                 getFormFieldList().getFormField().add(i - 1, fft);
1071                                 return;
1072                         } // if
1073                 } // for
1074         } // shiftFormFieldUp
1075
1076         public void shiftFormFieldDown(String fieldId) {
1077                 if (getFormFieldList() == null)
1078                         return;
1079
1080                 for (int i = 0; i < getFormFieldList().getFormField().size(); i++) {
1081                         FormFieldType fft = (FormFieldType) getFormFieldList().getFormField().get(i);
1082
1083                         if (fft.getFieldId().equals(fieldId)
1084                                         && (i < getFormFieldList().getFormField().size() - 1)) {
1085                                 FormFieldType nextFft = (FormFieldType) getFormFieldList().getFormField().get(
1086                                                 i + 1);
1087                                 nextFft.setOrderBySeq((nextFft.getOrderBySeq() == null)?0:nextFft.getOrderBySeq() - 1);
1088                                 fft.setOrderBySeq((fft.getOrderBySeq() == null)?0:fft.getOrderBySeq() + 1);
1089
1090                                 getFormFieldList().getFormField().remove(i + 1);
1091                                 getFormFieldList().getFormField().add(i, nextFft);
1092                                 return;
1093                         } // if
1094                 } // for
1095         } // shiftFormFieldDown
1096
1097         public static void addFormFieldPredefinedValue(ObjectFactory objFactory,
1098                         FormFieldType formField, String predefinedValue) throws RaptorException {
1099                         if (formField.getPredefinedValueList() == null) {
1100                                 PredefinedValueList predefinedValueList = objFactory.createPredefinedValueList();
1101                                 formField.setPredefinedValueList(predefinedValueList);
1102                         } // if
1103
1104                         if (predefinedValue.length() > 0) {
1105                                 formField.getPredefinedValueList().getPredefinedValue().add(predefinedValue);
1106                                 Collections.sort(formField.getPredefinedValueList().getPredefinedValue());
1107                         } // if
1108         } // addFormFieldPredefinedValue
1109
1110         public static void deleteFormFieldPredefinedValue(FormFieldType formField,
1111                         String predefinedValue) {
1112                 if (formField != null && formField.getPredefinedValueList() != null
1113                                 && predefinedValue.length() > 0)
1114                         for (Iterator iter = formField.getPredefinedValueList().getPredefinedValue()
1115                                         .iterator(); iter.hasNext();)
1116                                 if (predefinedValue.equals((String) iter.next())) {
1117                                         iter.remove();
1118                                         break;
1119                                 } // if
1120         } // deleteFormFieldPredefinedValue
1121
1122         /** ************************************************************************************************* */
1123
1124         private int curSQLParsePos = 0;
1125
1126         private String getNextSQLParseToken(String sql, boolean updateParsePos) {
1127                 int braketCount = 0;
1128                 boolean isInsideQuote = false;
1129                 StringBuffer nextToken = new StringBuffer();
1130                 for (int idxNext = curSQLParsePos; idxNext < sql.length(); idxNext++) {
1131                         char ch = sql.charAt(idxNext);
1132
1133                         if (Character.isWhitespace(ch) || ch == ',') {
1134                                 if (ch == ',')
1135                                         nextToken.append(ch);
1136
1137                                 if (nextToken.length() == 0)
1138                                         continue;
1139                                 else if (braketCount == 0 && (!isInsideQuote)) {
1140                                         if (updateParsePos)
1141                                                 curSQLParsePos = idxNext + ((ch == ',') ? 1 : 0);
1142                                         break;
1143                                 } else if (ch != ',' && nextToken.charAt(nextToken.length() - 1) != ' ')
1144                                         nextToken.append(' ');
1145                         } else {
1146                                 nextToken.append(ch);
1147
1148                                 if (ch == '(' || ch == '[')
1149                                         braketCount++;
1150                                 else if (ch == ')' || ch == ']')
1151                                         braketCount--;
1152                                 else if (ch == '\''/* ||ch=='\"' */)
1153                                         isInsideQuote = (!isInsideQuote);
1154                         } // else
1155                 } // for
1156
1157                 return nextToken.toString();
1158         } // getNextSQLParseToken
1159
1160         private boolean isParseSQLColID(String token) {
1161                 if (nvl(token).length() == 0)
1162                         return false;
1163
1164                 for (int i = 0; i < token.length(); i++) {
1165                         char ch = token.charAt(i);
1166
1167                         if (i == 0 && ch == '_')
1168                                 return false;
1169
1170                         if (!(Character.isLetterOrDigit(ch) || ch == '_'))
1171                                 return false;
1172                 } // for
1173
1174                 return true;
1175         } // isParseSQLColID
1176
1177         private DataColumnType getParseSQLDataColumn(String sqlExpression, String colId,
1178                         StringBuffer parsedSQL, Vector updatedReportCols, boolean isCYMBALScript) throws RaptorException {
1179                 DataColumnType dct = null;
1180
1181                 if (colId != null) {
1182                         if (!isParseSQLColID(colId))
1183                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1184                                                 "["
1185                                                                 + colId
1186                                                                 + "] must either be a valid column id consisting only of letters, numbers, and underscores, or there must be a comma in front of it.");
1187
1188                         dct = getColumnById(colId);
1189                 } else {
1190                         // Getting unique column id
1191                         colId = "";
1192                         int colIdN = 0;
1193                         for (int i = 0; (i < sqlExpression.length()) && (colIdN < 2); i++)
1194                                 if (Character.isLetter(sqlExpression.charAt(i))) {
1195                                         colId += sqlExpression.toLowerCase().charAt(i);
1196                                         colIdN++;
1197                                 } // if
1198
1199                         colIdN = getAllColumns().size() + updatedReportCols.size();
1200                         for (boolean idAlreadyUsed = true; idAlreadyUsed; colIdN++) {
1201                                 String newColId = colId + colIdN;
1202                                 idAlreadyUsed = false;
1203
1204                                 for (Iterator iter = getAllColumns().iterator(); iter.hasNext();)
1205                                         if (newColId.equals(((DataColumnType) iter.next()).getColId())) {
1206                                                 idAlreadyUsed = true;
1207                                                 break;
1208                                         }
1209
1210                                 if (!idAlreadyUsed)
1211                                         for (Iterator iter = updatedReportCols.iterator(); iter.hasNext();)
1212                                                 if (newColId.equals(((DataColumnType) iter.next()).getColId())) {
1213                                                         idAlreadyUsed = true;
1214                                                         break;
1215                                                 }
1216                         } // for
1217
1218                         colId += (colIdN - 1);
1219                 } // else
1220
1221                 if (dct == null) {
1222                         dct = (new ObjectFactory()).createDataColumnType();
1223                         dct.setColId(colId);
1224                         dct.setDisplayWidth(10);
1225                         dct.setDisplayAlignment("Left");
1226                         dct.setVisible(true);
1227                         dct.setGroupBreak(false); // ???
1228                         if(!isCYMBALScript) {
1229                                 boolean isValidIdentifier = Character.isLetterOrDigit(sqlExpression.charAt(0));
1230                                 for (int i = 0; i < sqlExpression.length(); i++)
1231                                         if (!(Character.isLetterOrDigit(sqlExpression.charAt(i))
1232                                                         || (sqlExpression.charAt(i) == '_') || (sqlExpression.charAt(i) == '$'))) {
1233                                                 isValidIdentifier = false;
1234                                                 break;
1235                                         } // if
1236
1237                                 if (isValidIdentifier) {
1238                                         dct.setDisplayName(sqlExpression);
1239                                 } else {
1240                                         dct.setDisplayName(colId);
1241                                 } // else
1242                         } else dct.setDisplayName(colId);
1243                 } // if
1244                  if(!isCYMBALScript)
1245                 sqlExpression = sqlExpression.replaceAll(", '", ",'");
1246                 dct.setDbColName(sqlExpression);
1247                 dct.setColName(sqlExpression);
1248                 dct.setCalculated(true);
1249                 dct.setColType(AppConstants.CT_CHAR);
1250                 dct.setDbColType(AppConstants.CT_CHAR);
1251                 adjustColumnType(dct); // ???
1252                 if(!isCYMBALScript) {
1253                         if (parsedSQL.toString().equals("SELECT ")
1254                                         || parsedSQL.toString().equals("SELECT DISTINCT "))
1255                                 parsedSQL.append("\n\t");
1256                         else
1257                                 parsedSQL.append(", \n\t");
1258                         parsedSQL.append(sqlExpression);
1259                         parsedSQL.append(" ");
1260                         parsedSQL.append(colId);
1261                 }
1262
1263                 return dct;
1264         } // getParseSQLDataColumn
1265
1266         public void parseReportSQL(String sql) throws RaptorException {
1267                 StringBuffer parsedSQL = new StringBuffer();
1268
1269                 Vector updatedReportCols = new Vector();
1270
1271                 curSQLParsePos = 0;
1272                 int lastParsePos = curSQLParsePos;
1273                 String lastToken = null;
1274                 String nextToken = getNextSQLParseToken(sql, true);
1275
1276         String  dbInfo          = getDBInfo();
1277         boolean isCYMBALScript = false;
1278                 if (!isNull(dbInfo) && (!dbInfo.equals(AppConstants.DB_LOCAL))) {
1279                         try {
1280                          String dbType = remDbInfo.getDBType(dbInfo);
1281                          if (dbType.equals("DAYTONA") && !(nextToken.toUpperCase().equals("SELECT"))) {
1282                                  isCYMBALScript = true;
1283                          }
1284                         } catch (Exception ex) {
1285                    throw new RaptorException(ex);
1286                         }
1287                 }
1288                 if ( isCYMBALScript == false ) {
1289                         while (nextToken.length() > 0) {
1290                                 if (parsedSQL.length() == 0) {
1291                                         if (nextToken.toUpperCase().equals("SELECT"))
1292                                                 parsedSQL.append("SELECT ");
1293                                         else
1294                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1295                                                                 "The SQL must start with the SELECT keyword.");
1296                                 } else if (nextToken.toUpperCase().equals("DISTINCT")
1297                                                 && parsedSQL.toString().equals("SELECT ")) {
1298                                         parsedSQL.append("DISTINCT ");
1299                                 } else if (nextToken.equals("*")
1300                                                 && (parsedSQL.toString().equals("SELECT ") || parsedSQL.toString().equals(
1301                                                                 "SELECT DISTINCT "))) {
1302                                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1303                                                         "You cannot use \"SELECT *\". Please specify select columns/expressions.");
1304                                 } else if (nextToken.toUpperCase().equals("FROM")) {
1305                                         if (lastToken != null) {
1306                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null, parsedSQL,
1307                                                                 updatedReportCols, false));
1308                                                 lastToken = null;
1309                                         }
1310
1311                                         parsedSQL.append(" \n");
1312                                         while (lastParsePos < sql.length()
1313                                                         && Character.isWhitespace(sql.charAt(lastParsePos)))
1314                                                 lastParsePos++;
1315                                         parsedSQL.append(sql.substring(lastParsePos));
1316                                         break;
1317                                 } else {
1318                                         if (nextToken.charAt(nextToken.length() - 1) == ',') {
1319                                                 // The token ends with ,
1320                                                 nextToken = nextToken.substring(0, nextToken.length() - 1);
1321
1322                                                 if (nextToken.length() == 0) {
1323                                                         if (lastToken != null) {
1324                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null,
1325                                                                                 parsedSQL, updatedReportCols, false));
1326                                                                 lastToken = null;
1327                                                         } // else just comma => ignore it
1328                                                 } else {
1329                                                         if (lastToken != null) {
1330                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1331                                                                                 parsedSQL, updatedReportCols, false));
1332                                                                 lastToken = null;
1333                                                         } else
1334                                                                 updatedReportCols.add(getParseSQLDataColumn(nextToken, null,
1335                                                                                 parsedSQL, updatedReportCols, false));
1336                                                 }
1337                                         } else {
1338                                                 // The token doesn't end with ,
1339                                                 if (lastToken == null)
1340                                                         lastToken = nextToken;
1341                                                 else {
1342                                                         String token = getNextSQLParseToken(sql, false);
1343                                                         if (!token.toUpperCase().equals("FROM"))
1344                                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1345                                                                                 "|FROM keyword or a comma expected after [" + nextToken
1346                                                                                                 + "].");
1347
1348                                                         updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1349                                                                         parsedSQL, updatedReportCols, false));
1350                                                         lastToken = null;
1351                                                 } // else
1352                                         } // else
1353                                 } // else
1354
1355                                 lastParsePos = curSQLParsePos;
1356                                 nextToken = getNextSQLParseToken(sql, true);
1357                         } // while
1358                 } else { // if CYMBAL Script
1359                         curSQLParsePos = 0;
1360                         Pattern re                      = null;
1361                         Matcher matcher         = null;
1362                         String extracted        = null;
1363                         nextToken = getNextCYMBALSQLParseToken(sql,true);
1364                         while (nextToken.length() > 0) {
1365                                 if (lastToken == null)
1366                                         lastToken = nextToken;
1367
1368                                 if( lastToken.toUpperCase().startsWith("DO DISPLAY")) {
1369                                         re              = Pattern.compile("each(.*)\\[.(.*?)\\]");   //\\[(.*?)\\]
1370                                         matcher = re.matcher(nextToken);
1371                                         if (matcher.find()) {
1372                                                 extracted = matcher.group();
1373                                                 re              = Pattern.compile("\\[(.*?)\\]");
1374                                         matcher = re.matcher(nextToken);
1375                                         if(matcher.find()) {
1376                                                 extracted = matcher.group();
1377                                                 extracted = extracted.substring(1,extracted.length()-1);
1378                                                 StringTokenizer sToken = new StringTokenizer(extracted, ",");
1379                                                 while(sToken.hasMoreTokens()) {
1380                                                 String str1 = sToken.nextToken().trim().substring(1);
1381                                             updatedReportCols.add(getParseSQLDataColumn("", str1,
1382                                                         new StringBuffer(""), updatedReportCols, true));
1383                                                 }
1384                                         }
1385
1386                                         }
1387
1388                                 }
1389                                 lastToken = nextToken;
1390                                 nextToken = getNextCYMBALSQLParseToken(sql, true);
1391                         }
1392
1393                 }
1394                 if (updatedReportCols.size() == 0)
1395                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1396                                         "The SQL statement must have at least one column in the SELECT clause.");
1397                 if (getDataSourceList().getDataSource().size() == 0)
1398                         addDataSourceType(new ObjectFactory(), "du0", "DUAL", "", "DUAL", null, null, null);
1399                 DataSourceType dst = (DataSourceType) getDataSourceList().getDataSource().get(0);
1400                 dst.getDataColumnList().getDataColumn().clear();
1401
1402                 for (int i = 0; i < updatedReportCols.size(); i++) {
1403                         DataColumnType dct = (DataColumnType) updatedReportCols.get(i);
1404                         dct.setTableId(dst.getTableId());
1405                         dct.setOrderSeq(i + 1);
1406                         dst.getDataColumnList().getDataColumn().add(dct);
1407                 } // for
1408                 setReportSQL(parsedSQL.toString());
1409                 resetCache(false);
1410         } // parseReportSQL
1411
1412         public void parseReportSQL(String sql, boolean storeInSession) throws RaptorException {
1413                 StringBuffer parsedSQL = new StringBuffer();
1414
1415                 Vector updatedReportCols = new Vector();
1416
1417                 curSQLParsePos = 0;
1418                 int lastParsePos = curSQLParsePos;
1419                 String lastToken = null;
1420                 String nextToken = getNextSQLParseToken(sql, true);
1421
1422         String  dbInfo          = getDBInfo();
1423         boolean isCYMBALScript = false;
1424                 if (!isNull(dbInfo) && (!dbInfo.equals(AppConstants.DB_LOCAL))) {
1425                         try {
1426                          String dbType = remDbInfo.getDBType(dbInfo);
1427                          if (dbType.equals("DAYTONA") && !(nextToken.toUpperCase().equals("SELECT"))) {
1428                                  isCYMBALScript = true;
1429                          }
1430                         } catch (Exception ex) {
1431                    throw new RaptorException(ex);
1432                         }
1433                 }
1434                 if ( isCYMBALScript == false ) {
1435                         while (nextToken.length() > 0) {
1436                                 if (parsedSQL.length() == 0) {
1437                                         if (nextToken.toUpperCase().equals("SELECT"))
1438                                                 parsedSQL.append("SELECT ");
1439                                         else
1440                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1441                                                                 "The SQL must start with the SELECT keyword.");
1442                                 } else if (nextToken.toUpperCase().equals("DISTINCT")
1443                                                 && parsedSQL.toString().equals("SELECT ")) {
1444                                         parsedSQL.append("DISTINCT ");
1445                                 } else if (nextToken.equals("*")
1446                                                 && (parsedSQL.toString().equals("SELECT ") || parsedSQL.toString().equals(
1447                                                                 "SELECT DISTINCT "))) {
1448                                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1449                                                         "You cannot use \"SELECT *\". Please specify select columns/expressions.");
1450                                 } else if (nextToken.toUpperCase().equals("FROM")) {
1451                                         if (lastToken != null) {
1452                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null, parsedSQL,
1453                                                                 updatedReportCols, false));
1454                                                 lastToken = null;
1455                                         }
1456
1457                                         parsedSQL.append(" \n");
1458                                         while (lastParsePos < sql.length()
1459                                                         && Character.isWhitespace(sql.charAt(lastParsePos)))
1460                                                 lastParsePos++;
1461                                         parsedSQL.append(sql.substring(lastParsePos));
1462                                         break;
1463                                 } else {
1464                                         if (nextToken.charAt(nextToken.length() - 1) == ',') {
1465                                                 // The token ends with ,
1466                                                 nextToken = nextToken.substring(0, nextToken.length() - 1);
1467
1468                                                 if (nextToken.length() == 0) {
1469                                                         if (lastToken != null) {
1470                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null,
1471                                                                                 parsedSQL, updatedReportCols, false));
1472                                                                 lastToken = null;
1473                                                         } // else just comma => ignore it
1474                                                 } else {
1475                                                         if (lastToken != null) {
1476                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1477                                                                                 parsedSQL, updatedReportCols, false));
1478                                                                 lastToken = null;
1479                                                         } else
1480                                                                 updatedReportCols.add(getParseSQLDataColumn(nextToken, null,
1481                                                                                 parsedSQL, updatedReportCols, false));
1482                                                 }
1483                                         } else {
1484                                                 // The token doesn't end with ,
1485                                                 if (lastToken == null)
1486                                                         lastToken = nextToken;
1487                                                 else {
1488                                                         String token = getNextSQLParseToken(sql, false);
1489                                                         if (!token.toUpperCase().equals("FROM"))
1490                                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1491                                                                                 "|FROM keyword or a comma expected after [" + nextToken
1492                                                                                                 + "].");
1493
1494                                                         updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1495                                                                         parsedSQL, updatedReportCols, false));
1496                                                         lastToken = null;
1497                                                 } // else
1498                                         } // else
1499                                 } // else
1500
1501                                 lastParsePos = curSQLParsePos;
1502                                 nextToken = getNextSQLParseToken(sql, true);
1503                         } // while
1504                 } else { // if CYMBAL Script
1505                         curSQLParsePos = 0;
1506                         Pattern re                      = null;
1507                         Matcher matcher         = null;
1508                         String extracted        = null;
1509                         nextToken = getNextCYMBALSQLParseToken(sql,true);
1510                         while (nextToken.length() > 0) {
1511                                 if (lastToken == null)
1512                                         lastToken = nextToken;
1513
1514                                 if( lastToken.toUpperCase().startsWith("DO DISPLAY")) {
1515                                         re              = Pattern.compile("each(.*)\\[.(.*?)\\]");   //\\[(.*?)\\]
1516                                         matcher = re.matcher(nextToken);
1517                                         if (matcher.find()) {
1518                                                 extracted = matcher.group();
1519                                                 re              = Pattern.compile("\\[(.*?)\\]");
1520                                         matcher = re.matcher(nextToken);
1521                                         if(matcher.find()) {
1522                                                 extracted = matcher.group();
1523                                                 extracted = extracted.substring(1,extracted.length()-1);
1524                                                 StringTokenizer sToken = new StringTokenizer(extracted, ",");
1525                                                 while(sToken.hasMoreTokens()) {
1526                                                 String str1 = sToken.nextToken().trim().substring(1);
1527                                             updatedReportCols.add(getParseSQLDataColumn("", str1,
1528                                                         new StringBuffer(""), updatedReportCols, true));
1529                                                 }
1530                                         }
1531
1532                                         }
1533
1534                                 }
1535                                 lastToken = nextToken;
1536                                 nextToken = getNextCYMBALSQLParseToken(sql, true);
1537                         }
1538
1539                 }
1540                 if (updatedReportCols.size() == 0)
1541                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1542                                         "The SQL statement must have at least one column in the SELECT clause.");
1543                 if (getDataSourceList().getDataSource().size() == 0)
1544                         addDataSourceType(new ObjectFactory(), "du0", "DUAL", "", "DUAL", null, null, null);
1545                 DataSourceType dst = (DataSourceType) getDataSourceList().getDataSource().get(0);
1546                 dst.getDataColumnList().getDataColumn().clear();
1547
1548                 for (int i = 0; i < updatedReportCols.size(); i++) {
1549                         DataColumnType dct = (DataColumnType) updatedReportCols.get(i);
1550                         dct.setTableId(dst.getTableId());
1551                         dct.setOrderSeq(i + 1);
1552                         dst.getDataColumnList().getDataColumn().add(dct);
1553                 } // for
1554                 if(storeInSession)
1555                         setReportSQL(parsedSQL.toString());
1556                 resetCache(false);
1557         } // parseReportSQL
1558
1559         private String getNextCYMBALSQLParseToken(String sql, boolean updateParsePos) {
1560                 int braketCount = 0;
1561                 boolean isInsideQuote = false;
1562                 StringBuffer nextToken = new StringBuffer();
1563                 for (int idxNext = curSQLParsePos; idxNext < sql.length(); idxNext++) {
1564                         char ch = sql.charAt(idxNext);
1565
1566                         if (ch!='\n') {
1567                                         nextToken.append(ch);
1568                                         if (updateParsePos)
1569                                                 curSQLParsePos = idxNext;
1570                         }
1571                         else {
1572                                 curSQLParsePos = idxNext+1;
1573                                 break;
1574                         }
1575                 } // for
1576
1577                 return nextToken.toString();
1578         } // getNextSQLParseToken
1579
1580         public void addChartAdditionalOptions(ObjectFactory objFactory) throws RaptorException {
1581                         ChartAdditionalOptions chartOptions = objFactory.createChartAdditionalOptions();
1582                         cr.setChartAdditionalOptions(chartOptions);
1583         }
1584
1585         public void addChartDrillOptions(ObjectFactory objFactory) throws RaptorException {
1586                 ChartDrillOptions chartOptions = objFactory.createChartDrillOptions();
1587                 cr.setChartDrillOptions(chartOptions);
1588 }
1589
1590         public void addDataminingOptions(ObjectFactory objFactory) throws RaptorException {
1591                         DataminingOptions dataminingOptions = objFactory.createDataminingOptions();
1592                         cr.setDataminingOptions(dataminingOptions);
1593         }
1594
1595 } // ReportDefinition