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)
 857                                         return javascriptItemType;
 858                                 else {
 859                                         javascriptItemType = objFactory.createJavascriptItemType();
 860                                         getJavascriptList().getJavascriptItem().add(javascriptItemType);
 861                                         return javascriptItemType;
 862                                 }
 863                         }
 864
 865         } // addSemaphoreType
 866
 867         public boolean deleteJavascriptType(String id) throws RaptorException {
 868                 JavascriptItemType javascriptType =  null;
 869                 if (getJavascriptList() == null)
 870                         return true;
 871                 for (Iterator iter = getJavascriptList().getJavascriptItem().iterator(); iter.hasNext();) {
 872                         javascriptType  = (JavascriptItemType)iter.next();
 873                         if(javascriptType.getId().equals(id)) {
 874                                 iter.remove();
 875                                 return true;
 876                         }
 877                 }
 878                 return false;
 879         } // addSemaphoreType
 880
 881         public static FormatType addEmptyFormatType(ObjectFactory objFactory,
 882                         SemaphoreType semaphore) throws RaptorException {
 883                 FormatType fmt = null;
 884                         fmt = objFactory.createFormatType();
 885                         semaphore.getFormatList().getFormat().add(fmt);
 886
 887                         String formatId = null;
 888                         boolean idExists = true;
 889                         for (int i = 1; idExists; i++) {
 890                                 formatId = semaphore.getSemaphoreId() + "_fmt" + i;
 891                                 idExists = false;
 892                                 for (Iterator iter = semaphore.getFormatList().getFormat().iterator(); iter
 893                                                 .hasNext();)
 894                                         if (formatId.equals(((FormatType) iter.next()).getFormatId())) {
 895                                                 idExists = true;
 896                                                 break;
 897                                         }
 898                         } // for
 899                         fmt.setFormatId(formatId);
 900                 return fmt;
 901         } // addEmptyFormatType
 902
 903         public static void deleteFormatType(SemaphoreType semaphore, String formatId) {
 904                 for (Iterator iter = semaphore.getFormatList().getFormat().iterator(); iter.hasNext();)
 905                         if (formatId.equals(((FormatType) iter.next()).getFormatId())) {
 906                                 iter.remove();
 907                                 break;
 908                         } // if
 909         } // deleteFormatType
 910
 911         public FormFieldType addFormFieldType(ObjectFactory objFactory, String fieldName,
 912                         String colId, String fieldType, String validationType, String mandatory,
 913                         String defaultValue, String fieldSQL, String comment, Calendar rangeStartDate, Calendar rangeEndDate,
 914                         String rangeStartDateSQL, String rangeEndDateSQL) throws RaptorException {
 915                 FormFieldType fft = null;
 916                         fft = objFactory.createFormFieldType();
 917
 918                         fft.setFieldName(fieldName);
 919                         fft.setColId(colId);
 920                         fft.setFieldType(fieldType);
 921                         fft.setValidationType(validationType);
 922                         fft.setMandatory(nvl(mandatory, "N"));
 923                         fft.setDefaultValue(nvl(defaultValue));
 924                         fft.setOrderBySeq((getFormFieldList() == null) ? 1 : getFormFieldList().getFormField()
 925                                         .size() + 1);
 926                         fft.setFieldSQL(fieldSQL);
 927                         //fft.setRangeStartDate(rangeStartDate);
 928                         //fft.setRangeEndDate(rangeEndDate);
 929
 930             try {
 931                 fft.setRangeStartDate(DatatypeFactory.newInstance()
 932                         .newXMLGregorianCalendar(rangeStartDate.YEAR, rangeStartDate.MONTH, rangeStartDate.DAY_OF_WEEK, rangeStartDate.HOUR, rangeStartDate.MINUTE, rangeStartDate.SECOND, rangeStartDate.MILLISECOND, rangeStartDate.ZONE_OFFSET));
 933                 fft.setRangeStartDate(DatatypeFactory.newInstance()
 934                         .newXMLGregorianCalendar(rangeEndDate.YEAR, rangeEndDate.MONTH, rangeEndDate.DAY_OF_WEEK, rangeEndDate.HOUR, rangeEndDate.MINUTE, rangeEndDate.SECOND, rangeEndDate.MILLISECOND, rangeEndDate.ZONE_OFFSET));
 935                 /*currField.setRangeEndDate(DatatypeFactory.newInstance()
 936                         .newXMLGregorianCalendar(end));*/
 937             } catch (DatatypeConfigurationException ex) {
 938
 939             }
 940
 941                         fft.setRangeStartDateSQL(rangeStartDateSQL);
 942                         fft.setRangeEndDateSQL(rangeEndDateSQL);
 943                         if (nvl(comment).length() > 0)
 944                                 fft.setComment(comment);
 945
 946                         String fieldId = null;
 947                         boolean idExists = true;
 948                         for (int i = 1; idExists; i++) {
 949                                 fieldId = "ff" + i;
 950                                 idExists = false;
 951                                 if (getFormFieldList() != null)
 952                                         for (Iterator iter = getFormFieldList().getFormField().iterator(); iter
 953                                                         .hasNext();)
 954                                                 if (fieldId.equals(((FormFieldType) iter.next()).getFieldId())) {
 955                                                         idExists = true;
 956                                                         break;
 957                                                 }
 958                         } // for
 959                         fft.setFieldId(fieldId);
 960
 961                         if (getFormFieldList() == null) {
 962                                 FormFieldList formFieldList = objFactory.createFormFieldList();
 963                                 setFormFieldList(formFieldList);
 964                         }
 965
 966                         getFormFieldList().getFormField().add(fft);
 967                 return fft;
 968         } // addFormFieldType
 969
 970         //addCustomizedTextForParameters
 971         public void addCustomizedTextForParameters(String comment) throws RaptorException {
 972                         getFormFieldList().setComment(comment);
 973         }
 974
 975         public FormFieldType addFormFieldBlank(ObjectFactory objFactory) throws RaptorException {
 976                 FormFieldType fft = null;
 977                         fft = objFactory.createFormFieldType();
 978
 979                         fft.setFieldName("BLANK");
 980                 fft.setColId("bk");
 981                 fft.setFieldType(FormField.FFT_BLANK);
 982                 fft.setOrderBySeq((getFormFieldList() == null) ? 1 : getFormFieldList().getFormField()
 983                                         .size() + 1);
 984                         String fieldId = null;
 985                         boolean idExists = true;
 986                         for (int i = 1; idExists; i++) {
 987                                 fieldId = "ff" + i;
 988                                 idExists = false;
 989                                 if (getFormFieldList() != null)
 990                                         for (Iterator iter = getFormFieldList().getFormField().iterator(); iter
 991                                                         .hasNext();)
 992                                                 if (fieldId.equals(((FormFieldType) iter.next()).getFieldId())) {
 993                                                         idExists = true;
 994                                                         break;
 995                                                 }
 996                         } // for
 997                         fft.setFieldId(fieldId);
 998
 999                         if (getFormFieldList() == null) {
1000                                 FormFieldList formFieldList = objFactory.createFormFieldList();
1001                                 setFormFieldList(formFieldList);
1002                         }
1003
1004                         getFormFieldList().getFormField().add(fft);
1005                 return fft;
1006         } // addFormFieldBlank
1007
1008         public void replaceFormFieldReferences(String fieldName, String replaceWith) {
1009                 if (fieldName.equals(replaceWith))
1010                         return;
1011
1012                 for (Iterator iter = getAllColumns().iterator(); iter.hasNext();) {
1013                         DataColumnType dct = (DataColumnType) iter.next();
1014
1015                         if (dct.isCalculated() && dct.getColName().indexOf(fieldName) >= 0)
1016                                 dct.setColName(Utils.replaceInString(dct.getColName(), fieldName, nvl(
1017                                                 replaceWith, "NULL")));
1018
1019                         if (dct.getColFilterList() != null)
1020                                 for (Iterator iter2 = dct.getColFilterList().getColFilter().iterator(); iter2
1021                                                 .hasNext();) {
1022                                         ColFilterType cft = (ColFilterType) iter2.next();
1023
1024                                         if (nvl(cft.getArgType()).equals(AppConstants.AT_FORM)
1025                                                         && nvl(cft.getArgValue()).equals(fieldName))
1026                                                 cft.setArgValue(replaceWith);
1027                                 } // for
1028                 } // for
1029         } // replaceFormFieldReferences
1030
1031         public void deleteFormField(String fieldId) {
1032                 String fieldDisplayName = null;
1033
1034                 int orderBySeq = Integer.MAX_VALUE;
1035                 if (getFormFieldList() != null)
1036                         for (Iterator iter = getFormFieldList().getFormField().iterator(); iter.hasNext();) {
1037                                 FormFieldType fft = (FormFieldType) iter.next();
1038
1039                                 if (fieldId.equals(fft.getFieldId())) {
1040                                         //orderBySeq = fft.getOrderBySeq();
1041                                         fieldDisplayName = getFormFieldDisplayName(fft);
1042                                         iter.remove();
1043                                 } else if (fft.getOrderBySeq()!=null && (fft.getOrderBySeq().intValue() > orderBySeq))
1044                                         fft.setOrderBySeq(fft.getOrderBySeq() - 1);
1045                         } // for
1046
1047                 if (fieldDisplayName != null)
1048                         replaceFormFieldReferences(fieldDisplayName, "");
1049         } // deleteFormField
1050
1051         public void shiftFormFieldUp(String fieldId) {
1052                 if (getFormFieldList() == null)
1053                         return;
1054
1055                 for (int i = 0; i < getFormFieldList().getFormField().size(); i++) {
1056                         FormFieldType fft = (FormFieldType) getFormFieldList().getFormField().get(i);
1057
1058                         if (fft.getFieldId().equals(fieldId) && (i > 0)) {
1059                                 FormFieldType prevFft = (FormFieldType) getFormFieldList().getFormField().get(
1060                                                 i - 1);
1061                                 prevFft.setOrderBySeq(prevFft.getOrderBySeq() + 1);
1062                                 fft.setOrderBySeq((fft.getOrderBySeq() == null)?0:fft.getOrderBySeq() - 1);
1063
1064                                 getFormFieldList().getFormField().remove(i);
1065                                 getFormFieldList().getFormField().add(i - 1, fft);
1066                                 return;
1067                         } // if
1068                 } // for
1069         } // shiftFormFieldUp
1070
1071         public void shiftFormFieldDown(String fieldId) {
1072                 if (getFormFieldList() == null)
1073                         return;
1074
1075                 for (int i = 0; i < getFormFieldList().getFormField().size(); i++) {
1076                         FormFieldType fft = (FormFieldType) getFormFieldList().getFormField().get(i);
1077
1078                         if (fft.getFieldId().equals(fieldId)
1079                                         && (i < getFormFieldList().getFormField().size() - 1)) {
1080                                 FormFieldType nextFft = (FormFieldType) getFormFieldList().getFormField().get(
1081                                                 i + 1);
1082                                 nextFft.setOrderBySeq((nextFft.getOrderBySeq() == null)?0:nextFft.getOrderBySeq() - 1);
1083                                 fft.setOrderBySeq((fft.getOrderBySeq() == null)?0:fft.getOrderBySeq() + 1);
1084
1085                                 getFormFieldList().getFormField().remove(i + 1);
1086                                 getFormFieldList().getFormField().add(i, nextFft);
1087                                 return;
1088                         } // if
1089                 } // for
1090         } // shiftFormFieldDown
1091
1092         public static void addFormFieldPredefinedValue(ObjectFactory objFactory,
1093                         FormFieldType formField, String predefinedValue) throws RaptorException {
1094                         if (formField.getPredefinedValueList() == null) {
1095                                 PredefinedValueList predefinedValueList = objFactory.createPredefinedValueList();
1096                                 formField.setPredefinedValueList(predefinedValueList);
1097                         } // if
1098
1099                         if (predefinedValue.length() > 0) {
1100                                 formField.getPredefinedValueList().getPredefinedValue().add(predefinedValue);
1101                                 Collections.sort(formField.getPredefinedValueList().getPredefinedValue());
1102                         } // if
1103         } // addFormFieldPredefinedValue
1104
1105         public static void deleteFormFieldPredefinedValue(FormFieldType formField,
1106                         String predefinedValue) {
1107                 if (formField != null && formField.getPredefinedValueList() != null
1108                                 && predefinedValue.length() > 0)
1109                         for (Iterator iter = formField.getPredefinedValueList().getPredefinedValue()
1110                                         .iterator(); iter.hasNext();)
1111                                 if (predefinedValue.equals((String) iter.next())) {
1112                                         iter.remove();
1113                                         break;
1114                                 } // if
1115         } // deleteFormFieldPredefinedValue
1116
1117         /** ************************************************************************************************* */
1118
1119         private int curSQLParsePos = 0;
1120
1121         private String getNextSQLParseToken(String sql, boolean updateParsePos) {
1122                 int braketCount = 0;
1123                 boolean isInsideQuote = false;
1124                 StringBuffer nextToken = new StringBuffer();
1125                 for (int idxNext = curSQLParsePos; idxNext < sql.length(); idxNext++) {
1126                         char ch = sql.charAt(idxNext);
1127
1128                         if (Character.isWhitespace(ch) || ch == ',') {
1129                                 if (ch == ',')
1130                                         nextToken.append(ch);
1131
1132                                 if (nextToken.length() == 0)
1133                                         continue;
1134                                 else if (braketCount == 0 && (!isInsideQuote)) {
1135                                         if (updateParsePos)
1136                                                 curSQLParsePos = idxNext + ((ch == ',') ? 1 : 0);
1137                                         break;
1138                                 } else if (ch != ',' && nextToken.charAt(nextToken.length() - 1) != ' ')
1139                                         nextToken.append(' ');
1140                         } else {
1141                                 nextToken.append(ch);
1142
1143                                 if (ch == '(' || ch == '[')
1144                                         braketCount++;
1145                                 else if (ch == ')' || ch == ']')
1146                                         braketCount--;
1147                                 else if (ch == '\''/* ||ch=='\"' */)
1148                                         isInsideQuote = (!isInsideQuote);
1149                         } // else
1150                 } // for
1151
1152                 return nextToken.toString();
1153         } // getNextSQLParseToken
1154
1155         private boolean isParseSQLColID(String token) {
1156                 if (nvl(token).length() == 0)
1157                         return false;
1158
1159                 for (int i = 0; i < token.length(); i++) {
1160                         char ch = token.charAt(i);
1161
1162                         if (i == 0 && ch == '_')
1163                                 return false;
1164
1165                         if (!(Character.isLetterOrDigit(ch) || ch == '_'))
1166                                 return false;
1167                 } // for
1168
1169                 return true;
1170         } // isParseSQLColID
1171
1172         private DataColumnType getParseSQLDataColumn(String sqlExpression, String colId,
1173                         StringBuffer parsedSQL, Vector updatedReportCols, boolean isCYMBALScript) throws RaptorException {
1174                 DataColumnType dct = null;
1175
1176                 if (colId != null) {
1177                         if (!isParseSQLColID(colId))
1178                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1179                                                 "["
1180                                                                 + colId
1181                                                                 + "] must either be a valid column id consisting only of letters, numbers, and underscores, or there must be a comma in front of it.");
1182
1183                         dct = getColumnById(colId);
1184                 } else {
1185                         // Getting unique column id
1186                         colId = "";
1187                         int colIdN = 0;
1188                         for (int i = 0; (i < sqlExpression.length()) && (colIdN < 2); i++)
1189                                 if (Character.isLetter(sqlExpression.charAt(i))) {
1190                                         colId += sqlExpression.toLowerCase().charAt(i);
1191                                         colIdN++;
1192                                 } // if
1193
1194                         colIdN = getAllColumns().size() + updatedReportCols.size();
1195                         for (boolean idAlreadyUsed = true; idAlreadyUsed; colIdN++) {
1196                                 String newColId = colId + colIdN;
1197                                 idAlreadyUsed = false;
1198
1199                                 for (Iterator iter = getAllColumns().iterator(); iter.hasNext();)
1200                                         if (newColId.equals(((DataColumnType) iter.next()).getColId())) {
1201                                                 idAlreadyUsed = true;
1202                                                 break;
1203                                         }
1204
1205                                 if (!idAlreadyUsed)
1206                                         for (Iterator iter = updatedReportCols.iterator(); iter.hasNext();)
1207                                                 if (newColId.equals(((DataColumnType) iter.next()).getColId())) {
1208                                                         idAlreadyUsed = true;
1209                                                         break;
1210                                                 }
1211                         } // for
1212
1213                         colId += (colIdN - 1);
1214                 } // else
1215
1216                 if (dct == null) {
1217                         dct = (new ObjectFactory()).createDataColumnType();
1218                         dct.setColId(colId);
1219                         dct.setDisplayWidth(10);
1220                         dct.setDisplayAlignment("Left");
1221                         dct.setVisible(true);
1222                         dct.setGroupBreak(false); // ???
1223                         if(!isCYMBALScript) {
1224                                 boolean isValidIdentifier = Character.isLetterOrDigit(sqlExpression.charAt(0));
1225                                 for (int i = 0; i < sqlExpression.length(); i++)
1226                                         if (!(Character.isLetterOrDigit(sqlExpression.charAt(i))
1227                                                         || (sqlExpression.charAt(i) == '_') || (sqlExpression.charAt(i) == '$'))) {
1228                                                 isValidIdentifier = false;
1229                                                 break;
1230                                         } // if
1231
1232                                 if (isValidIdentifier) {
1233                                         dct.setDisplayName(sqlExpression);
1234                                 } else {
1235                                         dct.setDisplayName(colId);
1236                                 } // else
1237                         } else dct.setDisplayName(colId);
1238                 } // if
1239                  if(!isCYMBALScript)
1240                 sqlExpression = sqlExpression.replaceAll(", '", ",'");
1241                 dct.setDbColName(sqlExpression);
1242                 dct.setColName(sqlExpression);
1243                 dct.setCalculated(true);
1244                 dct.setColType(AppConstants.CT_CHAR);
1245                 dct.setDbColType(AppConstants.CT_CHAR);
1246                 adjustColumnType(dct); // ???
1247                 if(!isCYMBALScript) {
1248                         if (parsedSQL.toString().equals("SELECT ")
1249                                         || parsedSQL.toString().equals("SELECT DISTINCT "))
1250                                 parsedSQL.append("\n\t");
1251                         else
1252                                 parsedSQL.append(", \n\t");
1253                         parsedSQL.append(sqlExpression);
1254                         parsedSQL.append(" ");
1255                         parsedSQL.append(colId);
1256                 }
1257
1258                 return dct;
1259         } // getParseSQLDataColumn
1260
1261         public void parseReportSQL(String sql) throws RaptorException {
1262                 StringBuffer parsedSQL = new StringBuffer();
1263
1264                 Vector updatedReportCols = new Vector();
1265
1266                 curSQLParsePos = 0;
1267                 int lastParsePos = curSQLParsePos;
1268                 String lastToken = null;
1269                 String nextToken = getNextSQLParseToken(sql, true);
1270
1271         String  dbInfo          = getDBInfo();
1272         boolean isCYMBALScript = false;
1273                 if (!isNull(dbInfo) && (!dbInfo.equals(AppConstants.DB_LOCAL))) {
1274                         try {
1275                          org.onap.portalsdk.analytics.util.RemDbInfo remDbInfo = new org.onap.portalsdk.analytics.util.RemDbInfo();
1276                          String dbType = remDbInfo.getDBType(dbInfo);
1277                          if (dbType.equals("DAYTONA") && !(nextToken.toUpperCase().equals("SELECT"))) {
1278                                  isCYMBALScript = true;
1279                          }
1280                         } catch (Exception ex) {
1281                    throw new RaptorException(ex);
1282                         }
1283                 }
1284                 if ( isCYMBALScript == false ) {
1285                         while (nextToken.length() > 0) {
1286                                 if (parsedSQL.length() == 0) {
1287                                         if (nextToken.toUpperCase().equals("SELECT"))
1288                                                 parsedSQL.append("SELECT ");
1289                                         else
1290                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1291                                                                 "The SQL must start with the SELECT keyword.");
1292                                 } else if (nextToken.toUpperCase().equals("DISTINCT")
1293                                                 && parsedSQL.toString().equals("SELECT ")) {
1294                                         parsedSQL.append("DISTINCT ");
1295                                 } else if (nextToken.equals("*")
1296                                                 && (parsedSQL.toString().equals("SELECT ") || parsedSQL.toString().equals(
1297                                                                 "SELECT DISTINCT "))) {
1298                                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1299                                                         "You cannot use \"SELECT *\". Please specify select columns/expressions.");
1300                                 } else if (nextToken.toUpperCase().equals("FROM")) {
1301                                         if (lastToken != null) {
1302                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null, parsedSQL,
1303                                                                 updatedReportCols, false));
1304                                                 lastToken = null;
1305                                         }
1306
1307                                         parsedSQL.append(" \n");
1308                                         while (lastParsePos < sql.length()
1309                                                         && Character.isWhitespace(sql.charAt(lastParsePos)))
1310                                                 lastParsePos++;
1311                                         parsedSQL.append(sql.substring(lastParsePos));
1312                                         break;
1313                                 } else {
1314                                         if (nextToken.charAt(nextToken.length() - 1) == ',') {
1315                                                 // The token ends with ,
1316                                                 nextToken = nextToken.substring(0, nextToken.length() - 1);
1317
1318                                                 if (nextToken.length() == 0) {
1319                                                         if (lastToken != null) {
1320                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null,
1321                                                                                 parsedSQL, updatedReportCols, false));
1322                                                                 lastToken = null;
1323                                                         } // else just comma => ignore it
1324                                                 } else {
1325                                                         if (lastToken != null) {
1326                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1327                                                                                 parsedSQL, updatedReportCols, false));
1328                                                                 lastToken = null;
1329                                                         } else
1330                                                                 updatedReportCols.add(getParseSQLDataColumn(nextToken, null,
1331                                                                                 parsedSQL, updatedReportCols, false));
1332                                                 }
1333                                         } else {
1334                                                 // The token doesn't end with ,
1335                                                 if (lastToken == null)
1336                                                         lastToken = nextToken;
1337                                                 else {
1338                                                         String token = getNextSQLParseToken(sql, false);
1339                                                         if (!token.toUpperCase().equals("FROM"))
1340                                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1341                                                                                 "|FROM keyword or a comma expected after [" + nextToken
1342                                                                                                 + "].");
1343
1344                                                         updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1345                                                                         parsedSQL, updatedReportCols, false));
1346                                                         lastToken = null;
1347                                                 } // else
1348                                         } // else
1349                                 } // else
1350
1351                                 lastParsePos = curSQLParsePos;
1352                                 nextToken = getNextSQLParseToken(sql, true);
1353                         } // while
1354                 } else { // if CYMBAL Script
1355                         curSQLParsePos = 0;
1356                         Pattern re                      = null;
1357                         Matcher matcher         = null;
1358                         String extracted        = null;
1359                         nextToken = getNextCYMBALSQLParseToken(sql,true);
1360                         while (nextToken.length() > 0) {
1361                                 if (lastToken == null)
1362                                         lastToken = nextToken;
1363
1364                                 if( lastToken.toUpperCase().startsWith("DO DISPLAY")) {
1365                                         re              = Pattern.compile("each(.*)\\[.(.*?)\\]");   //\\[(.*?)\\]
1366                                         matcher = re.matcher(nextToken);
1367                                         if (matcher.find()) {
1368                                                 extracted = matcher.group();
1369                                                 re              = Pattern.compile("\\[(.*?)\\]");
1370                                         matcher = re.matcher(nextToken);
1371                                         if(matcher.find()) {
1372                                                 extracted = matcher.group();
1373                                                 extracted = extracted.substring(1,extracted.length()-1);
1374                                                 StringTokenizer sToken = new StringTokenizer(extracted, ",");
1375                                                 while(sToken.hasMoreTokens()) {
1376                                                 String str1 = sToken.nextToken().trim().substring(1);
1377                                             updatedReportCols.add(getParseSQLDataColumn("", str1,
1378                                                         new StringBuffer(""), updatedReportCols, true));
1379                                                 }
1380                                         }
1381
1382                                         }
1383
1384                                 }
1385                                 lastToken = nextToken;
1386                                 nextToken = getNextCYMBALSQLParseToken(sql, true);
1387                         }
1388
1389                 }
1390                 if (updatedReportCols.size() == 0)
1391                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1392                                         "The SQL statement must have at least one column in the SELECT clause.");
1393                 if (getDataSourceList().getDataSource().size() == 0)
1394                         addDataSourceType(new ObjectFactory(), "du0", "DUAL", "", "DUAL", null, null, null);
1395                 DataSourceType dst = (DataSourceType) getDataSourceList().getDataSource().get(0);
1396                 dst.getDataColumnList().getDataColumn().clear();
1397
1398                 for (int i = 0; i < updatedReportCols.size(); i++) {
1399                         DataColumnType dct = (DataColumnType) updatedReportCols.get(i);
1400                         dct.setTableId(dst.getTableId());
1401                         dct.setOrderSeq(i + 1);
1402                         dst.getDataColumnList().getDataColumn().add(dct);
1403                 } // for
1404                 setReportSQL(parsedSQL.toString());
1405                 resetCache(false);
1406         } // parseReportSQL
1407
1408         public void parseReportSQL(String sql, boolean storeInSession) throws RaptorException {
1409                 StringBuffer parsedSQL = new StringBuffer();
1410
1411                 Vector updatedReportCols = new Vector();
1412
1413                 curSQLParsePos = 0;
1414                 int lastParsePos = curSQLParsePos;
1415                 String lastToken = null;
1416                 String nextToken = getNextSQLParseToken(sql, true);
1417
1418         String  dbInfo          = getDBInfo();
1419         boolean isCYMBALScript = false;
1420                 if (!isNull(dbInfo) && (!dbInfo.equals(AppConstants.DB_LOCAL))) {
1421                         try {
1422                          org.onap.portalsdk.analytics.util.RemDbInfo remDbInfo = new org.onap.portalsdk.analytics.util.RemDbInfo();
1423                          String dbType = remDbInfo.getDBType(dbInfo);
1424                          if (dbType.equals("DAYTONA") && !(nextToken.toUpperCase().equals("SELECT"))) {
1425                                  isCYMBALScript = true;
1426                          }
1427                         } catch (Exception ex) {
1428                    throw new RaptorException(ex);
1429                         }
1430                 }
1431                 if ( isCYMBALScript == false ) {
1432                         while (nextToken.length() > 0) {
1433                                 if (parsedSQL.length() == 0) {
1434                                         if (nextToken.toUpperCase().equals("SELECT"))
1435                                                 parsedSQL.append("SELECT ");
1436                                         else
1437                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1438                                                                 "The SQL must start with the SELECT keyword.");
1439                                 } else if (nextToken.toUpperCase().equals("DISTINCT")
1440                                                 && parsedSQL.toString().equals("SELECT ")) {
1441                                         parsedSQL.append("DISTINCT ");
1442                                 } else if (nextToken.equals("*")
1443                                                 && (parsedSQL.toString().equals("SELECT ") || parsedSQL.toString().equals(
1444                                                                 "SELECT DISTINCT "))) {
1445                                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1446                                                         "You cannot use \"SELECT *\". Please specify select columns/expressions.");
1447                                 } else if (nextToken.toUpperCase().equals("FROM")) {
1448                                         if (lastToken != null) {
1449                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null, parsedSQL,
1450                                                                 updatedReportCols, false));
1451                                                 lastToken = null;
1452                                         }
1453
1454                                         parsedSQL.append(" \n");
1455                                         while (lastParsePos < sql.length()
1456                                                         && Character.isWhitespace(sql.charAt(lastParsePos)))
1457                                                 lastParsePos++;
1458                                         parsedSQL.append(sql.substring(lastParsePos));
1459                                         break;
1460                                 } else {
1461                                         if (nextToken.charAt(nextToken.length() - 1) == ',') {
1462                                                 // The token ends with ,
1463                                                 nextToken = nextToken.substring(0, nextToken.length() - 1);
1464
1465                                                 if (nextToken.length() == 0) {
1466                                                         if (lastToken != null) {
1467                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, null,
1468                                                                                 parsedSQL, updatedReportCols, false));
1469                                                                 lastToken = null;
1470                                                         } // else just comma => ignore it
1471                                                 } else {
1472                                                         if (lastToken != null) {
1473                                                                 updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1474                                                                                 parsedSQL, updatedReportCols, false));
1475                                                                 lastToken = null;
1476                                                         } else
1477                                                                 updatedReportCols.add(getParseSQLDataColumn(nextToken, null,
1478                                                                                 parsedSQL, updatedReportCols, false));
1479                                                 }
1480                                         } else {
1481                                                 // The token doesn't end with ,
1482                                                 if (lastToken == null)
1483                                                         lastToken = nextToken;
1484                                                 else {
1485                                                         String token = getNextSQLParseToken(sql, false);
1486                                                         if (!token.toUpperCase().equals("FROM"))
1487                                                                 throw new org.onap.portalsdk.analytics.error.ValidationException(
1488                                                                                 "|FROM keyword or a comma expected after [" + nextToken
1489                                                                                                 + "].");
1490
1491                                                         updatedReportCols.add(getParseSQLDataColumn(lastToken, nextToken,
1492                                                                         parsedSQL, updatedReportCols, false));
1493                                                         lastToken = null;
1494                                                 } // else
1495                                         } // else
1496                                 } // else
1497
1498                                 lastParsePos = curSQLParsePos;
1499                                 nextToken = getNextSQLParseToken(sql, true);
1500                         } // while
1501                 } else { // if CYMBAL Script
1502                         curSQLParsePos = 0;
1503                         Pattern re                      = null;
1504                         Matcher matcher         = null;
1505                         String extracted        = null;
1506                         nextToken = getNextCYMBALSQLParseToken(sql,true);
1507                         while (nextToken.length() > 0) {
1508                                 if (lastToken == null)
1509                                         lastToken = nextToken;
1510
1511                                 if( lastToken.toUpperCase().startsWith("DO DISPLAY")) {
1512                                         re              = Pattern.compile("each(.*)\\[.(.*?)\\]");   //\\[(.*?)\\]
1513                                         matcher = re.matcher(nextToken);
1514                                         if (matcher.find()) {
1515                                                 extracted = matcher.group();
1516                                                 re              = Pattern.compile("\\[(.*?)\\]");
1517                                         matcher = re.matcher(nextToken);
1518                                         if(matcher.find()) {
1519                                                 extracted = matcher.group();
1520                                                 extracted = extracted.substring(1,extracted.length()-1);
1521                                                 StringTokenizer sToken = new StringTokenizer(extracted, ",");
1522                                                 while(sToken.hasMoreTokens()) {
1523                                                 String str1 = sToken.nextToken().trim().substring(1);
1524                                             updatedReportCols.add(getParseSQLDataColumn("", str1,
1525                                                         new StringBuffer(""), updatedReportCols, true));
1526                                                 }
1527                                         }
1528
1529                                         }
1530
1531                                 }
1532                                 lastToken = nextToken;
1533                                 nextToken = getNextCYMBALSQLParseToken(sql, true);
1534                         }
1535
1536                 }
1537                 if (updatedReportCols.size() == 0)
1538                         throw new org.onap.portalsdk.analytics.error.ValidationException(
1539                                         "The SQL statement must have at least one column in the SELECT clause.");
1540                 if (getDataSourceList().getDataSource().size() == 0)
1541                         addDataSourceType(new ObjectFactory(), "du0", "DUAL", "", "DUAL", null, null, null);
1542                 DataSourceType dst = (DataSourceType) getDataSourceList().getDataSource().get(0);
1543                 dst.getDataColumnList().getDataColumn().clear();
1544
1545                 for (int i = 0; i < updatedReportCols.size(); i++) {
1546                         DataColumnType dct = (DataColumnType) updatedReportCols.get(i);
1547                         dct.setTableId(dst.getTableId());
1548                         dct.setOrderSeq(i + 1);
1549                         dst.getDataColumnList().getDataColumn().add(dct);
1550                 } // for
1551                 if(storeInSession)
1552                         setReportSQL(parsedSQL.toString());
1553                 resetCache(false);
1554         } // parseReportSQL
1555
1556         private String getNextCYMBALSQLParseToken(String sql, boolean updateParsePos) {
1557                 int braketCount = 0;
1558                 boolean isInsideQuote = false;
1559                 StringBuffer nextToken = new StringBuffer();
1560                 for (int idxNext = curSQLParsePos; idxNext < sql.length(); idxNext++) {
1561                         char ch = sql.charAt(idxNext);
1562
1563                         if (ch!='\n') {
1564                                         nextToken.append(ch);
1565                                         if (updateParsePos)
1566                                                 curSQLParsePos = idxNext;
1567                         }
1568                         else {
1569                                 curSQLParsePos = idxNext+1;
1570                                 break;
1571                         }
1572                 } // for
1573
1574                 return nextToken.toString();
1575         } // getNextSQLParseToken
1576
1577         public void addChartAdditionalOptions(ObjectFactory objFactory) throws RaptorException {
1578                         ChartAdditionalOptions chartOptions = objFactory.createChartAdditionalOptions();
1579                         cr.setChartAdditionalOptions(chartOptions);
1580         }
1581
1582         public void addChartDrillOptions(ObjectFactory objFactory) throws RaptorException {
1583                 ChartDrillOptions chartOptions = objFactory.createChartDrillOptions();
1584                 cr.setChartDrillOptions(chartOptions);
1585 }
1586
1587         public void addDataminingOptions(ObjectFactory objFactory) throws RaptorException {
1588                         DataminingOptions dataminingOptions = objFactory.createDataminingOptions();
1589                         cr.setDataminingOptions(dataminingOptions);
1590         }
1591         /*public void addChartAdditionalOptions(ObjectFactory objFactory, String chartType, String chartMultiplePieOrder, String chartMultiplePieLabelDisplay,
1592                         String chartOrientation, String secondaryChartRenderer, String chartDisplay, String legendPosition,
1593                         String labelAngle) throws RaptorException {
1594                 try {
1595                         ChartAdditionalOptions chartOptions = objFactory.createChartAdditionalOptions();
1596
1597                         if (nvl(chartMultiplePieOrder).length() > 0)
1598                                 chartOptions.setChartMultiplePieOrder(chartMultiplePieOrder);
1599                         if (nvl(chartMultiplePieLabelDisplay).length() > 0)
1600                                 chartOptions.setChartMultiplePieLabelDisplay(chartMultiplePieLabelDisplay);
1601                         if (nvl(chartOrientation).length() > 0)
1602                                 chartOptions.setChartOrientation(chartOrientation);
1603                         if (nvl(secondaryChartRenderer).length() > 0)
1604                                 chartOptions.setSecondaryChartRenderer(secondaryChartRenderer);
1605                         if (nvl(chartDisplay).length() > 0)
1606                                 chartOptions.setChartDisplay(chartDisplay);
1607                         if (nvl(legendPosition).length() > 0)
1608                                 chartOptions.setLegendPosition(legendPosition);
1609                         if (nvl(labelAngle).length() > 0)
1610                                 chartOptions.setLabelAngle(labelAngle);
1611
1612                 cr.setChartAdditionalOptions(chartOptions);
1613                 } catch (JAXBException ex) {
1614                         throw new RaptorException(ex.getMessage(), ex.getCause());
1615                 }
1616         } // addChartAdditionalOptions*/
1617
1618
1619 } // ReportDefinition