src/main/java/org/onap/music/rest/RestMusicQAPI.java

   1 /*
   2  * ============LICENSE_START========================================== org.onap.music
   3  * =================================================================== Copyright (c) 2017 AT&T
   4  * Intellectual Property ===================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
   6  * in compliance with the License. You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software distributed under the License
  11  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  12  * or implied. See the License for the specific language governing permissions and limitations under
  13  * the License.
  14  *
  15  * ============LICENSE_END=============================================
  16  * ====================================================================
  17  */
  18 package org.onap.music.rest;
  19
  20 import java.util.HashMap;
  21 import java.util.Map;
  22 import javax.ws.rs.Consumes;
  23 import javax.ws.rs.DELETE;
  24 import javax.ws.rs.GET;
  25 import javax.ws.rs.HeaderParam;
  26 import javax.ws.rs.POST;
  27 import javax.ws.rs.PUT;
  28 import javax.ws.rs.Path;
  29 import javax.ws.rs.PathParam;
  30 import javax.ws.rs.Produces;
  31 import javax.ws.rs.core.Context;
  32 import javax.ws.rs.core.MediaType;
  33 import javax.ws.rs.core.UriInfo;
  34 import javax.ws.rs.core.Response;
  35 import javax.ws.rs.core.Response.ResponseBuilder;
  36 import javax.ws.rs.core.Response.Status;
  37 // cjcimport javax.servlet.http.HttpServletResponse;
  38 import org.onap.music.datastore.jsonobjects.JsonDelete;
  39 import org.onap.music.datastore.jsonobjects.JsonInsert;
  40 import org.onap.music.datastore.jsonobjects.JsonTable;
  41 import org.onap.music.datastore.jsonobjects.JsonUpdate;
  42 import org.onap.music.eelf.logging.EELFLoggerDelegate;
  43
  44 import org.onap.music.eelf.logging.format.AppMessages;
  45 import org.onap.music.eelf.logging.format.ErrorSeverity;
  46 import org.onap.music.eelf.logging.format.ErrorTypes;
  47 import org.apache.commons.lang3.StringUtils;
  48 import org.onap.music.datastore.PreparedQueryObject;
  49 import com.datastax.driver.core.ResultSet;
  50 import org.onap.music.exceptions.MusicServiceException;
  51 import org.onap.music.main.MusicCore;
  52 import org.onap.music.main.MusicUtil;
  53 import org.onap.music.main.ResultType;
  54 // cjc import org.onap.music.main.ReturnType;
  55 import org.onap.music.response.jsonobjects.JsonResponse;
  56 import io.swagger.annotations.Api;
  57 import io.swagger.annotations.ApiOperation;
  58 import io.swagger.annotations.ApiParam;
  59
  60 // import io.swagger.models.Response;
  61 // @Path("/v{version: [0-9]+}/priorityq/")
  62 @Path("{version}/priorityq/")
  63 @Api(value = "Q Api")
  64 public class RestMusicQAPI {
  65
  66   private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(RestMusicQAPI.class);
  67   // private static String xLatestVersion = "X-latestVersion";
  68   /*
  69    * private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(RestMusicDataAPI.class);
  70    * private static final String XMINORVERSION = "X-minorVersion"; private static final String
  71    * XPATCHVERSION = "X-patchVersion"; private static final String NS = "ns"; private static final
  72    * String USERID = "userId"; private static final String PASSWORD = "password";
  73    *    */
  74   // private static final String VERSION = "v2";
  75
  76
  77   /**
  78    *
  79    * @param tableObj
  80    * @param keyspace
  81    * @param tablename
  82    * @throws Exception
  83    */
  84
  85   @POST
  86   @Path("/keyspaces/{keyspace}/{qname}") // is it same as tablename?down
  87   @ApiOperation(value = "Create Q", response = String.class)
  88   @Consumes(MediaType.APPLICATION_JSON)
  89   @Produces(MediaType.APPLICATION_JSON)
  90
  91   /* old
  92   @POST
  93   @Path("/keyspaces/{keyspace}/{qname}")
  94   @ApiOperation(value = "", response = Void.class)
  95   @Consumes(MediaType.APPLICATION_JSON)
  96   */
  97   public Response createQ(
  98   // public Map<String,Object> createQ(
  99           @ApiParam(value = "Major Version", required = true) @PathParam("version") String version,
 100           @ApiParam(value = "Minor Version",
 101                   required = false) @HeaderParam("X-minorVersion") String minorVersion,
 102           @ApiParam(value = "Patch Version",
 103                   required = false) @HeaderParam("X-patchVersion") String patchVersion,
 104           @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
 105           @ApiParam(value = "Application namespace", required = true) @HeaderParam("ns") String ns,
 106           @ApiParam(value = "Authorization", required = true) @HeaderParam(MusicUtil.AUTHORIZATION) String authorization,
 107           JsonTable tableObj,
 108           @ApiParam(value = "Key Space", required = true) @PathParam("keyspace") String keyspace,
 109           @ApiParam(value = "Table Name", required = true) @PathParam("qname") String tablename)
 110           throws Exception {
 111     //logger.info(logger, "cjc before start in q 1** major version=" + version);
 112
 113     ResponseBuilder response = MusicUtil.buildVersionResponse(version, minorVersion, patchVersion);
 114
 115     Map<String, String> fields = tableObj.getFields();
 116     if (fields == null) { // || (!fields.containsKey("order")) ){
 117       logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA,
 118               ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
 119       return response.status(Status.BAD_REQUEST)
 120               .entity(new JsonResponse(ResultType.FAILURE)
 121                       .setError("CreateQ/Required table fields are empty or not set").toMap())
 122               .build();
 123     }
 124
 125     String primaryKey = tableObj.getPrimaryKey();
 126     String partitionKey = tableObj.getPartitionKey();
 127     String clusteringKey = tableObj.getClusteringKey();
 128     String filteringKey = tableObj.getFilteringKey();
 129     String clusteringOrder = tableObj.getClusteringOrder();
 130
 131     if(primaryKey == null) {
 132         primaryKey = tableObj.getFields().get("PRIMARY KEY");
 133     }
 134
 135     if ((primaryKey == null) && (partitionKey == null)) {
 136         logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA,
 137                 ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
 138         return response.status(Status.BAD_REQUEST)
 139                 .entity(new JsonResponse(ResultType.FAILURE)
 140                         .setError("CreateQ: Partition key cannot be empty").toMap())
 141                 .build();
 142       }
 143
 144     if ((primaryKey == null) && (clusteringKey == null)) {
 145         logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA,
 146                 ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
 147         return response.status(Status.BAD_REQUEST)
 148                 .entity(new JsonResponse(ResultType.FAILURE)
 149                         .setError("CreateQ: Clustering key cannot be empty").toMap())
 150                 .build();
 151       }
 152
 153     if (clusteringOrder == null) {
 154         logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA,
 155                 ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
 156         return response.status(Status.BAD_REQUEST)
 157                 .entity(new JsonResponse(ResultType.FAILURE)
 158                         .setError("CreateQ: Clustering Order cannot be empty").toMap())
 159                 .build();
 160       }
 161
 162     if ((primaryKey!=null) && (partitionKey == null)) {
 163         primaryKey.trim();
 164         int count1 = StringUtils.countMatches(primaryKey, ')');
 165         int count2 = StringUtils.countMatches(primaryKey, '(');
 166         if (count1 != count2) {
 167             return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
 168                       .setError("CreateQ Error: primary key '(' and ')' do not match, primary key=" + primaryKey)
 169                       .toMap()).build();
 170         }
 171
 172         if ( primaryKey.indexOf('(') == -1  || ( count2 == 1 && (primaryKey.lastIndexOf(")") +1) ==  primaryKey.length() ) )
 173         {
 174             if (primaryKey.contains(",") ) {
 175                 partitionKey= primaryKey.substring(0,primaryKey.indexOf(","));
 176                 partitionKey=partitionKey.replaceAll("[\\(]+","");
 177                 clusteringKey=primaryKey.substring(primaryKey.indexOf(',')+1);  // make sure index
 178                 clusteringKey=clusteringKey.replaceAll("[)]+", "");
 179             } else {
 180               partitionKey=primaryKey;
 181               partitionKey=partitionKey.replaceAll("[\\)]+","");
 182               partitionKey=partitionKey.replaceAll("[\\(]+","");
 183               clusteringKey="";
 184            }
 185       } else {
 186             partitionKey= primaryKey.substring(0,primaryKey.indexOf(')'));
 187             partitionKey=partitionKey.replaceAll("[\\(]+","");
 188             partitionKey.trim();
 189             clusteringKey= primaryKey.substring(primaryKey.indexOf(')'));
 190             clusteringKey=clusteringKey.replaceAll("[\\(]+","");
 191             clusteringKey=clusteringKey.replaceAll("[\\)]+","");
 192             clusteringKey.trim();
 193             if (clusteringKey.indexOf(",") == 0) clusteringKey=clusteringKey.substring(1);
 194             clusteringKey.trim();
 195             if (clusteringKey.equals(",") ) clusteringKey=""; // print error if needed    ( ... ),)
 196          }
 197     }
 198
 199     if (partitionKey.trim().isEmpty()) {
 200         logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA,
 201                 ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
 202         return response.status(Status.BAD_REQUEST)
 203                 .entity(new JsonResponse(ResultType.FAILURE)
 204                         .setError("CreateQ: Partition key cannot be empty").toMap())
 205                 .build();
 206     }
 207
 208     if (clusteringKey.trim().isEmpty()) {
 209         logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA,
 210                 ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
 211         return response.status(Status.BAD_REQUEST)
 212                 .entity(new JsonResponse(ResultType.FAILURE)
 213                         .setError("CreateQ: Clustering key cannot be empty").toMap())
 214                 .build();
 215     }
 216
 217     if((filteringKey != null) && (filteringKey.equalsIgnoreCase(partitionKey))) {
 218         logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA,
 219                 ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
 220         return response.status(Status.BAD_REQUEST)
 221                 .entity(new JsonResponse(ResultType.FAILURE)
 222                         .setError("CreateQ: Filtering key cannot be same as Partition Key").toMap())
 223                 .build();
 224     }
 225
 226     return new RestMusicDataAPI().createTable(version, minorVersion, patchVersion, aid, ns, authorization, tableObj, keyspace, tablename);
 227   }
 228
 229   /**
 230    *
 231    * @param insObj
 232    * @param keyspace
 233    * @param tablename
 234    * @throws Exception
 235    */
 236   @POST
 237   @Path("/keyspaces/{keyspace}/{qname}/rows")
 238   @ApiOperation(value = "", response = Void.class)
 239   @Consumes(MediaType.APPLICATION_JSON)
 240   @Produces(MediaType.APPLICATION_JSON)
 241   // public Map<String, Object> insertIntoQ(
 242   public Response insertIntoQ(
 243           @ApiParam(value = "Major Version", required = true) @PathParam("version") String version,
 244           @ApiParam(value = "Minor Version",
 245                   required = false) @HeaderParam("X-minorVersion") String minorVersion,
 246           @ApiParam(value = "Patch Version",
 247                   required = false) @HeaderParam("X-patchVersion") String patchVersion,
 248           @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
 249           @ApiParam(value = "Application namespace", required = true) @HeaderParam("ns") String ns,
 250           @ApiParam(value = "Authorization", required = true) @HeaderParam(MusicUtil.AUTHORIZATION) String authorization,
 251           JsonInsert insObj,
 252           @ApiParam(value = "Key Space", required = true) @PathParam("keyspace") String keyspace,
 253           @ApiParam(value = "Table Name", required = true) @PathParam("qname") String tablename)
 254           throws Exception {
 255     // ,@Context HttpServletResponse response) throws Exception {
 256
 257     // Map<String, Object> valuesMap = insObj.getValues();
 258     // check valuesMap.isEmpty and proceed
 259     // if(valuesMap.isEmpty() ) {
 260     // response.addHeader(xLatestVersion, MusicUtil.getVersion());
 261     ResponseBuilder response = MusicUtil.buildVersionResponse(version, minorVersion, patchVersion);
 262     if (insObj.getValues().isEmpty()) {
 263       // response.status(404);
 264       logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA,
 265               ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
 266       return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
 267               .setError("Required HTTP Request body is missing.").toMap()).build();
 268     }
 269     return new RestMusicDataAPI().insertIntoTable(version, minorVersion, patchVersion, aid, ns,
 270             authorization, insObj, keyspace, tablename);
 271   }
 272
 273   /**
 274    *
 275    * @param updateObj
 276    * @param keyspace
 277    * @param tablename
 278    * @param info
 279    * @return
 280    * @throws Exception
 281    */
 282   @PUT
 283   @Path("/keyspaces/{keyspace}/{qname}/rows")
 284   @ApiOperation(value = "updateQ", response = String.class)
 285   @Consumes(MediaType.APPLICATION_JSON)
 286   @Produces(MediaType.APPLICATION_JSON)
 287   public Response updateQ(
 288           @ApiParam(value = "Major Version", required = true) @PathParam("version") String version,
 289           @ApiParam(value = "Minor Version",
 290                   required = false) @HeaderParam("X-minorVersion") String minorVersion,
 291           @ApiParam(value = "Patch Version",
 292                   required = false) @HeaderParam("X-patchVersion") String patchVersion,
 293           @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
 294           @ApiParam(value = "Application namespace", required = true) @HeaderParam("ns") String ns,
 295           @ApiParam(value = "Authorization", required = true) @HeaderParam(MusicUtil.AUTHORIZATION) String authorization,
 296           JsonUpdate updateObj,
 297           @ApiParam(value = "Key Space", required = true) @PathParam("keyspace") String keyspace,
 298           @ApiParam(value = "Table Name", required = true) @PathParam("qname") String tablename,
 299           @Context UriInfo info) throws Exception {
 300
 301     //logger.info(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA, ErrorSeverity.CRITICAL,
 302       //      ErrorTypes.DATAERROR);
 303     ResponseBuilder response = MusicUtil.buildVersionResponse(version, minorVersion, patchVersion);
 304     if (updateObj.getValues().isEmpty()) {
 305       // response.status(404);
 306       logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA,
 307               ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
 308       return response.status(Status.BAD_REQUEST)
 309               .entity(new JsonResponse(ResultType.FAILURE).setError(
 310                       "Required HTTP Request body is missing. JsonUpdate updateObj.getValues() is empty. ")
 311                       .toMap())
 312               .build();
 313
 314
 315     }
 316     return new RestMusicDataAPI().updateTable(version, minorVersion, patchVersion, aid, ns,
 317             authorization,updateObj, keyspace, tablename, info);
 318   }
 319
 320   /**
 321    *
 322    * @param delObj
 323    * @param keyspace
 324    * @param tablename
 325    * @param info
 326    *
 327    * @return
 328    * @throws Exception
 329    */
 330
 331   @DELETE
 332   @Path("/keyspaces/{keyspace}/{qname}/rows")
 333   @ApiOperation(value = "deleteQ", response = String.class)
 334   @Consumes(MediaType.APPLICATION_JSON)
 335   @Produces(MediaType.APPLICATION_JSON)
 336   public Response deleteFromQ(
 337           @ApiParam(value = "Major Version", required = true) @PathParam("version") String version,
 338           @ApiParam(value = "Minor Version",
 339                   required = false) @HeaderParam("X-minorVersion") String minorVersion,
 340           @ApiParam(value = "Patch Version",
 341                   required = false) @HeaderParam("X-patchVersion") String patchVersion,
 342           @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
 343           @ApiParam(value = "Application namespace", required = true) @HeaderParam("ns") String ns,
 344           @ApiParam(value = "Authorization", required = true) @HeaderParam(MusicUtil.AUTHORIZATION) String authorization,
 345          // @ApiParam(value = "userId", required = true) @HeaderParam("userId") String userId,
 346          // @ApiParam(value = "Password", required = true) @HeaderParam("password") String password,
 347           JsonDelete delObj,
 348           @ApiParam(value = "Key Space", required = true) @PathParam("keyspace") String keyspace,
 349           @ApiParam(value = "Table Name", required = true) @PathParam("qname") String tablename,
 350           @Context UriInfo info) throws Exception {
 351     // added checking as per RestMusicDataAPI
 352     ResponseBuilder response = MusicUtil.buildVersionResponse(version, minorVersion, patchVersion);
 353     if (delObj == null) {
 354       // response.status(404);
 355       logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA,
 356               ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
 357       return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
 358               .setError("deleteFromQ JsonDelete delObjis empty").toMap()).build();
 359     }
 360
 361     return new RestMusicDataAPI().deleteFromTable(version, minorVersion, patchVersion, aid, ns,
 362             authorization, delObj, keyspace, tablename, info);
 363   }
 364
 365   /**
 366    *
 367    * @param keyspace
 368    * @param tablename
 369    * @param info
 370    * @return
 371    * @throws Exception
 372    */
 373   @GET
 374   @Path("/keyspaces/{keyspace}/{qname}/peek")
 375   @ApiOperation(value = "", response = Map.class)
 376   @Produces(MediaType.APPLICATION_JSON)
 377   //public Map<String, HashMap<String, Object>> peek(
 378   public Response peek(
 379           @ApiParam(value = "Major Version", required = true) @PathParam("version") String version,
 380           @ApiParam(value = "Minor Version",
 381                   required = false) @HeaderParam("X-minorVersion") String minorVersion,
 382           @ApiParam(value = "Patch Version",
 383                   required = false) @HeaderParam("X-patchVersion") String patchVersion,
 384           @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
 385           @ApiParam(value = "Application namespace", required = true) @HeaderParam("ns") String ns,
 386           @ApiParam(value = "Authorization", required = true) @HeaderParam(MusicUtil.AUTHORIZATION) String authorization,
 387           @ApiParam(value = "Key Space", required = true) @PathParam("keyspace") String keyspace,
 388           @ApiParam(value = "Table Name", required = true) @PathParam("qname") String tablename,
 389           @Context UriInfo info) throws Exception {
 390     int limit =1; //peek must return just the top row
 391     Map<String ,String> auth = new HashMap<>();
 392     String userId =auth.get(MusicUtil.USERID);
 393     String password =auth.get(MusicUtil.PASSWORD);
 394     ResponseBuilder response = MusicUtil.buildVersionResponse(version, minorVersion, patchVersion);
 395
 396     PreparedQueryObject queryObject = new PreparedQueryObject();
 397     if (info.getQueryParameters() == null ) //|| info.getQueryParameters().isEmpty())
 398       queryObject.appendQueryString(
 399               "SELECT *  FROM " + keyspace + "." + tablename + " LIMIT " + limit + ";");
 400     else {
 401
 402       try {
 403         queryObject = new RestMusicDataAPI().selectSpecificQuery(version, minorVersion,
 404                 patchVersion, aid, ns, userId, password, keyspace, tablename, info, limit);
 405       } catch (MusicServiceException ex) {
 406         logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.UNKNOWNERROR,
 407                 ErrorSeverity.WARN, ErrorTypes.GENERALSERVICEERROR);
 408         return response.status(Status.BAD_REQUEST)
 409                 .entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap())
 410                 .build();
 411       }
 412     }
 413
 414     try {
 415       ResultSet results = MusicCore.get(queryObject);
 416       return response.status(Status.OK).entity(new JsonResponse(ResultType.SUCCESS)
 417               .setDataResult(MusicCore.marshallResults(results)).toMap()).build();
 418     } catch (MusicServiceException ex) {
 419       logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.UNKNOWNERROR,
 420               ErrorSeverity.ERROR, ErrorTypes.MUSICSERVICEERROR);
 421       return response.status(Status.BAD_REQUEST)
 422               .entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap())
 423               .build();
 424     }
 425   }
 426
 427   /**
 428    *
 429    *
 430    * @param keyspace
 431    * @param tablename
 432    * @param info
 433    * @return
 434    * @throws Exception
 435    */
 436   @GET
 437   @Path("/keyspaces/{keyspace}/{qname}/filter")
 438   @ApiOperation(value = "filter", response = Map.class)
 439   @Produces(MediaType.APPLICATION_JSON)
 440   // public Map<String, HashMap<String, Object>> filter(
 441   public Response filter(
 442           @ApiParam(value = "Major Version", required = true) @PathParam("version") String version,
 443           @ApiParam(value = "Minor Version",
 444                   required = false) @HeaderParam("X-minorVersion") String minorVersion,
 445           @ApiParam(value = "Patch Version",
 446                   required = false) @HeaderParam("X-patchVersion") String patchVersion,
 447           @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
 448           @ApiParam(value = "Application namespace", required = true) @HeaderParam("ns") String ns,
 449           @ApiParam(value = "Authorization", required = true) @HeaderParam(MusicUtil.AUTHORIZATION) String authorization,
 450          // @ApiParam(value = "userId", required = true) @HeaderParam("userId") String userId,
 451           //@ApiParam(value = "Password", required = true) @HeaderParam("password") String password,
 452           @ApiParam(value = "Key Space", required = true) @PathParam("keyspace") String keyspace,
 453           @ApiParam(value = "Table Name", required = true) @PathParam("qname") String tablename,
 454           @Context UriInfo info) throws Exception {
 455     //int limit = -1;
 456     /*
 457      * PreparedQueryObject query = new RestMusicDataAPI().selectSpecificQuery(version, minorVersion,
 458      * patchVersion, aid, ns, userId, password, keyspace, tablename, info, limit); ResultSet results
 459      * = MusicCore.get(query); return MusicCore.marshallResults(results);
 460      */
 461    /* Map<String ,String> auth = new HashMap<>();
 462     String userId =auth.get(MusicUtil.USERID);
 463     String password =auth.get(MusicUtil.PASSWORD);
 464    */
 465     return new RestMusicDataAPI().select(version, minorVersion, patchVersion, aid, ns, authorization, keyspace, tablename, info);// , limit)
 466
 467   }
 468
 469   /**
 470    *
 471    * @param tabObj
 472    * @param keyspace
 473    * @param tablename
 474    * @throws Exception
 475    */
 476   @DELETE
 477   @ApiOperation(value = "DropQ", response = String.class)
 478   @Path("/keyspaces/{keyspace}/{qname}")
 479   @Produces(MediaType.APPLICATION_JSON)
 480   public Response dropQ(
 481           @ApiParam(value = "Major Version", required = true) @PathParam("version") String version,
 482           @ApiParam(value = "Minor Version",
 483                   required = false) @HeaderParam("X-minorVersion") String minorVersion,
 484           @ApiParam(value = "Patch Version",
 485                   required = false) @HeaderParam("X-patchVersion") String patchVersion,
 486           @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
 487           @ApiParam(value = "Application namespace", required = true) @HeaderParam("ns") String ns,
 488           @ApiParam(value = "Authorization", required = true) @HeaderParam(MusicUtil.AUTHORIZATION) String authorization,
 489          // @ApiParam(value = "userId", required = true) @HeaderParam("userId") String userId,
 490           //@ApiParam(value = "Password", required = true) @HeaderParam("password") String password,
 491           // cjc JsonTable tabObj,
 492           @ApiParam(value = "Key Space", required = true) @PathParam("keyspace") String keyspace,
 493           @ApiParam(value = "Table Name", required = true) @PathParam("qname") String tablename)
 494           throws Exception {
 495     // @Context HttpServletResponse response) throws Exception {
 496     // tabObj never in use & thus no need to verify
 497
 498
 499     return new RestMusicDataAPI().dropTable(version, minorVersion, patchVersion, aid, ns, authorization, keyspace, tablename);
 500   }
 501 }