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