Пример #1
0
  @PUT
  @Produces(MediaType.APPLICATION_JSON)
  @Path("/put/books")
  public Response postView(
      @FormParam("username") String username,
      @FormParam("password") String password,
      @FormParam("schema") String schema,
      @FormParam("collection") String collection,
      @FormParam("json") String json) {

    System.out.println("STORE BOOKS");
    System.out.println(schema);
    System.out.println(collection);
    System.out.println(json);
    try {
      System.out.println(json);
      Gson g = new Gson();
      saveJson(schema, collection, json);
      String out = g.toJson("JSON successfully stored.");
      ResponseBuilder builder = Response.ok(out);
      builder.header("Access-Control-Allow-Origin", "*");
      builder.header("Access-Control-Max-Age", "3600");
      builder.header("Access-Control-Allow-Methods", "PUT");
      builder.header(
          "Access-Control-Allow-Headers",
          "X-Requested-With,Host,User-Agent,Accept,Accept-Language,Accept-Encoding,Accept-Charset,Keep-Alive,Connection,Referer,Origin");
      return builder.build();
    } catch (Exception e) {
      return Response.status(500).entity("Error in 'getView' service: " + e.getMessage()).build();
    }
  }
Пример #2
0
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  @Path("/get/books")
  public Response getBooksTitle(
      @FormParam("title") String title,
      @FormParam("author") String author,
      @FormParam("isbn") String isbn,
      @FormParam("schema") String schema,
      @FormParam("collection") String collection) {

    System.out.println("library");
    System.out.println(schema);
    System.out.println(collection);
    System.out.println(title);
    System.out.println(author);
    try {
      Gson g = new Gson();
      String view = selectBooks(schema, collection, title, author, isbn);
      ResponseBuilder builder = Response.ok(view);
      builder.header("Access-Control-Allow-Origin", "*");
      builder.header("Access-Control-Max-Age", "3600");
      builder.header("Access-Control-Allow-Methods", "POST");
      builder.header(
          "Access-Control-Allow-Headers",
          "X-Requested-With,Host,User-Agent,Accept,Accept-Language,Accept-Encoding,Accept-Charset,Keep-Alive,Connection,Referer,Origin");
      return builder.build();
    } catch (Exception e) {
      return Response.status(500).entity("Error in 'getView' service: " + e.getMessage()).build();
    }
  }
Пример #3
0
  /*
   * (non-Javadoc)
   *
   * @see org.slc.sli.api.client.impl.IRESTClient#connect(java.lang.String, java.lang.String)
   */
  @Override
  public Response connect(final String authorizationCode)
      throws OAuthException, MalformedURLException, URISyntaxException {
    OAuthService service =
        new ServiceBuilder()
            .provider(SliApi.class)
            .apiKey(config.getApiKey())
            .apiSecret(config.getApiSecret())
            .callback(config.getCallback())
            .build();
    Verifier verifier = new Verifier(authorizationCode);
    Token t = null;
    SliApi.TokenResponse r =
        ((SliApi.SLIOauth20ServiceImpl) service)
            .getAccessToken(new Token(config.getApiSecret(), authorizationCode), verifier, t);

    if (r != null && r.getToken() != null) {
      accessToken = r.getToken();
      sessionToken = accessToken.getToken();
    }

    ResponseBuilder builder = Response.status(r.getOauthResponse().getCode());
    for (Map.Entry<String, String> entry : r.getOauthResponse().getHeaders().entrySet()) {
      if (entry.getKey() == null) {
        builder.header("Status", entry.getValue());
      } else {
        builder.header(entry.getKey(), entry.getValue());
      }
    }
    builder.entity(r.getOauthResponse().getBody());

    return builder.build();
  }
 @GET
 @Produces(MIMETYPE_BINARY)
 public Response getBinary(final @Context UriInfo uriInfo) {
   if (LOG.isDebugEnabled()) {
     LOG.debug("GET " + uriInfo.getAbsolutePath() + " as " + MIMETYPE_BINARY);
   }
   servlet.getMetrics().incrementRequests(1);
   try {
     KeyValue value = generator.next();
     if (value == null) {
       LOG.info("generator exhausted");
       return Response.noContent().build();
     }
     ResponseBuilder response = Response.ok(value.getValue());
     response.cacheControl(cacheControl);
     response.header("X-Row", Base64.encodeBytes(value.getRow()));
     response.header(
         "X-Column",
         Base64.encodeBytes(KeyValue.makeColumn(value.getFamily(), value.getQualifier())));
     response.header("X-Timestamp", value.getTimestamp());
     return response.build();
   } catch (IllegalStateException e) {
     ScannerResource.delete(id);
     throw new WebApplicationException(Response.Status.GONE);
   }
 }
  private void preflight(final String origin, final ContainerRequestContext requestContext)
      throws IOException {
    checkOrigin(requestContext, origin);

    final ResponseBuilder builder = Response.ok();
    builder.header(ACCESS_CONTROL_ALLOW_ORIGIN, origin);
    if (allowCredentials) builder.header(ACCESS_CONTROL_ALLOW_CREDENTIALS, "true");
    String requestMethods = requestContext.getHeaderString(ACCESS_CONTROL_REQUEST_METHOD);
    if (requestMethods != null) {
      if (allowedMethods != null) {
        requestMethods = this.allowedMethods;
      }
      builder.header(ACCESS_CONTROL_ALLOW_METHODS, requestMethods);
    }
    String allowHeaders = requestContext.getHeaderString(ACCESS_CONTROL_REQUEST_HEADERS);
    if (allowHeaders != null) {
      if (allowedHeaders != null) {
        allowHeaders = this.allowedHeaders;
      }
      builder.header(ACCESS_CONTROL_ALLOW_HEADERS, allowHeaders);
    }
    if (corsMaxAge > -1) {
      builder.header(ACCESS_CONTROL_MAX_AGE, corsMaxAge);
    }
    requestContext.abortWith(builder.build());
  }
 private void putDeviceCountIntoResponseHeaders(PushApplication app, ResponseBuilder response) {
   long appCount = 0;
   for (Variant variant : app.getVariants()) {
     long variantCount = installationDao.getNumberOfDevicesForVariantID(variant.getVariantID());
     appCount += variantCount;
     response.header("deviceCount_variant_" + variant.getVariantID(), variantCount);
   }
   response.header("deviceCount_app_" + app.getPushApplicationID(), appCount);
 }
 private void putActivityIntoResponseHeaders(PushApplication app, ResponseBuilder response) {
   response.header(
       "activity_app_" + app.getPushApplicationID(),
       metricsService.countMessagesForPushApplication(app.getPushApplicationID()));
   for (Variant variant : app.getVariants()) {
     response.header(
         "activity_variant_" + variant.getVariantID(),
         metricsService.countMessagesForVariant(variant.getVariantID()));
   }
 }
  /**
   * @param req
   * @param returnMethod
   * @return a cors-ed response object.
   */
  private static Response toCORS(final ResponseBuilder req, final String returnMethod) {
    final ResponseBuilder rb =
        req.header("Access-Control-Allow-Origin", "*")
            .header("Access-Control-Allow-Methods", "GET, PUT, OPTIONS");

    if (returnMethod != null && !returnMethod.isEmpty())
      rb.header("Access-Control-Allow-Headers", returnMethod);

    return rb.build();
  }
Пример #9
0
 protected Response accepted(ResponseBody rb, URI jobUri, URI newItemUri) {
   ResponseBuilder bldr = Response.status(Status.ACCEPTED).entity(rb);
   if (jobUri != null) {
     bldr.header("Location", jobUri);
   }
   if (newItemUri != null) {
     bldr.header("X-Location", newItemUri);
   }
   return bldr.build();
 }
Пример #10
0
  private Response makeCORS(ResponseBuilder req, String returnMethod) {
    ResponseBuilder rb =
        req.header("Access-Control-Allow-Origin", "*")
            .header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");

    // if the CORS headers are set, use these or overwrite the settings from
    // above respectively
    if (!"".equals(returnMethod)) {
      rb.header("Access-Control-Allow-Headers", returnMethod);
    }

    return rb.build();
  }
 @GET
 @Path("printlog/{logfileId}")
 @Consumes({MediaType.APPLICATION_JSON})
 @Produces({MediaType.APPLICATION_OCTET_STREAM})
 public Response logFile(@PathParam("logfileId") final Long id) {
   final DataUpload uploadStatus = this.dataUploadRepository.findOne(id);
   final String printFilePath = uploadStatus.getUploadFilePath();
   final String printFileName = printFilePath.replace("csv", "log");
   final File file = new File(printFileName);
   ResponseBuilder response = Response.ok(file);
   response.header("Content-Disposition", "attachment; filename=\"" + printFileName + "\"");
   response.header(
       "Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
   return response.build();
 }
  private Response appendAllowOriginHeader(ResponseBuilder rb, HttpServletRequest request) {

    return rb.header(
            "Access-Control-Allow-Origin", request.getHeader("Origin")) // return submitted origin
        .header("Access-Control-Allow-Credentials", "true")
        .build();
  }
  /**
   * List Push Applications
   *
   * @param page page number
   * @param pageSize number of items per page
   * @param includeDeviceCount put device count into response headers, default {@code false}
   * @param includeActivity put activity into response headers, default {@code false}
   * @return list of {@link PushApplication}s
   * @responseheader total Total count of items
   * @responseheader activity_app_{pushApplicationID} Count number of messages for Push Application
   * @responseheader activity_variant_{variantID} Count number of messages for Variant
   * @responseheader deviceCount_app_{pushApplicationID} Count number of devices for Push
   *     Application
   * @responseheader deviceCount_variant_{variantID} Count number of devices for Variant
   */
  @GET
  @Produces(MediaType.APPLICATION_JSON)
  @ReturnType("java.util.List<org.jboss.aerogear.unifiedpush.api.PushApplication>")
  public Response listAllPushApplications(
      @QueryParam("page") Integer page,
      @QueryParam("per_page") Integer pageSize,
      @QueryParam("includeDeviceCount") @DefaultValue("false") boolean includeDeviceCount,
      @QueryParam("includeActivity") @DefaultValue("false") boolean includeActivity) {
    if (pageSize != null) {
      pageSize = Math.min(MAX_PAGE_SIZE, pageSize);
    } else {
      pageSize = DEFAULT_PAGE_SIZE;
    }

    if (page == null) {
      page = 0;
    }

    final PageResult<PushApplication, Count> pageResult =
        getSearch().findAllPushApplicationsForDeveloper(page, pageSize);
    ResponseBuilder response = Response.ok(pageResult.getResultList());
    response.header("total", pageResult.getAggregate().getCount());
    for (PushApplication app : pageResult.getResultList()) {
      if (includeActivity) {
        putActivityIntoResponseHeaders(app, response);
      }
      if (includeDeviceCount) {
        putDeviceCountIntoResponseHeaders(app, response);
      }
    }
    return response.build();
  }
  /**
   * @param entityType
   * @param entityId
   * @param documentId
   * @return
   */
  @GET
  @Path("{documentId}/attachment")
  @Consumes({MediaType.APPLICATION_JSON})
  @Produces({MediaType.APPLICATION_JSON})
  public Response downloadFile(
      @PathParam("entityType") String entityType,
      @PathParam("entityId") Long entityId,
      @PathParam("documentId") Long documentId) {

    DocumentData documentData =
        this.documentReadPlatformService.retrieveDocument(entityType, entityId, documentId);
    File file = new File(documentData.getLocation());
    ResponseBuilder response = Response.ok(file);
    response.header(
        "Content-Disposition", "attachment; filename=\"" + documentData.getFileName() + "\"");
    response.header("Content-Type", documentData.getType());
    return response.build();
  }
  @Override
  public ContainerResponse filter(ContainerRequest request, ContainerResponse response) {

    ResponseBuilder responseBuilder = Response.fromResponse(response.getResponse());

    responseBuilder.header(ACCESS_CONTROL_ALLOW_ORIGIN, this.origin);

    response.setResponse(responseBuilder.build());

    return response;
  }
  @GET
  @Path("{documentId}/attachment")
  @Consumes({MediaType.APPLICATION_JSON})
  @Produces({MediaType.APPLICATION_OCTET_STREAM})
  public Response downloadFile(
      @PathParam("entityType") final String entityType,
      @PathParam("entityId") final Long entityId,
      @PathParam("documentId") final Long documentId) {

    this.context.authenticatedUser().validateHasReadPermission(this.SystemEntityType);

    // final DocumentData documentData =
    // this.documentReadPlatformService.retrieveDocument(entityType, entityId, documentId);
    final FileData fileData =
        this.documentReadPlatformService.retrieveFileData(entityType, entityId, documentId);
    final ResponseBuilder response = Response.ok(fileData.file());
    response.header("Content-Disposition", "attachment; filename=\"" + fileData.name() + "\"");
    response.header("Content-Type", fileData.contentType());
    return response.build();
  }
Пример #17
0
 @GET
 @Path("/download/{fileName}")
 public Response downloadFile(@PathParam("fileName") String fileName) {
   try {
     File file = new File(Constants.fileLocation + fileName);
     ResponseBuilder builder = Response.ok((Object) file);
     builder.header("Content-Disposition", "attachment; filename=" + fileName);
     return builder.build();
   } catch (Exception e) {
     return Response.status(404).build();
   }
 }
Пример #18
0
  @Override
  public ContainerResponse filter(ContainerRequest req, ContainerResponse contResp) {

    LOGGER.info("Enter CORS filter");
    LOGGER.info("Request= { path:" + req.getPath() + ", method:" + req.getMethod() + " }");

    ResponseBuilder resp = Response.fromResponse(contResp.getResponse());
    resp.header("Access-Control-Allow-Origin", "*");
    resp.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");

    String reqHead = req.getHeaderValue("Access-Control-Request-Headers");

    if (null != reqHead && !reqHead.equals(null)) {
      resp.header("Access-Control-Allow-Headers", reqHead);
    }

    contResp.setResponse(resp.build());

    LOGGER.info("Exit CORS filter");

    return contResp;
  }
Пример #19
0
  private Response prepareResourceSetPermissionTicketResponse(
      HttpServletRequest request, ResourceSetPermission resourceSetPermissions) {
    ResponseBuilder builder = Response.status(Response.Status.CREATED);

    builder.entity(new ResourceSetPermissionTicket(resourceSetPermissions.getTicket()));

    // Add location
    StringBuffer location =
        request.getRequestURL().append("/").append(resourceSetPermissions.getConfigurationCode());
    builder.header("Location", location);

    return builder.build();
  }
Пример #20
0
  @GET // http://localhost:8080/RESTfulWS-web/rest/university/get
  @Path("/get")
  @Produces("text/plain") // pdf - application/pdf, image- image/png
  public Response getStudentFile() {
    File file = new File("d:\\AplikacjeProsteNaukowe\\RESTfulWS\\DemoFile.txt");

    ResponseBuilder response = Response.ok((Object) file);
    response.header(
        "Content-Disposition",
        "attachment; filename=DisplayName-DemoFile.txt"); // pod taka nazwa DisplayName-DemoFile.txt
                                                          // pobierzemy plik
    return response.build();
  }
  /**
   * @param branchGuid -- the GUID of the branch to apply the test to
   * @param selectedTypes -- a list of the Low level Artifact types that will be used for the report
   * @return -- An Excel sheet (in XML format) containing the two reports
   */
  @GET
  @Produces(MediaType.APPLICATION_XML)
  public Response getLowHighReqReport(
      @QueryParam("branch") long branchUuid, @QueryParam("selected_types") String selectedTypes) {
    Conditions.checkNotNull(branchUuid, "branch query param");
    Conditions.checkNotNull(selectedTypes, "selected_types query param");

    StreamingOutput streamingOutput =
        new PublishLowHighReqStreamingOutput(logger, orcsApi, branchUuid, selectedTypes);
    String fileName = "Requirement_Trace_Report.xml";

    ResponseBuilder builder = Response.ok(streamingOutput);
    builder.header("Content-Disposition", "attachment; filename=" + fileName);
    return builder.build();
  }
Пример #22
0
 private synchronized boolean doCancel(String retryAfterHeader) {
   if (cancelled) {
     return true;
   }
   if (!isSuspended()) {
     return false;
   }
   ResponseBuilder rb = Response.status(503);
   if (retryAfterHeader != null) {
     rb.header(HttpHeaders.RETRY_AFTER, retryAfterHeader);
   }
   cancelled = true;
   doResumeFinal(rb.build());
   return cancelled;
 }
Пример #23
0
  public Response build() {
    String origin = request.getHttpHeaders().getRequestHeaders().getFirst(ORIGIN_HEADER);
    if (origin == null) {
      return builder.build();
    }

    if (!preflight
        && (allowedOrigins == null
            || (!allowedOrigins.contains(origin)
                && !allowedOrigins.contains(ACCESS_CONTROL_ALLOW_ORIGIN_WILDCARD)))) {
      return builder.build();
    }

    builder.header(ACCESS_CONTROL_ALLOW_ORIGIN, origin);

    if (preflight) {
      if (allowedMethods != null) {
        builder.header(ACCESS_CONTROL_ALLOW_METHODS, CollectionUtil.join(allowedMethods));
      } else {
        builder.header(ACCESS_CONTROL_ALLOW_METHODS, DEFAULT_ALLOW_METHODS);
      }
    }

    if (!preflight && exposedHeaders != null) {
      builder.header(ACCESS_CONTROL_EXPOSE_HEADERS, CollectionUtil.join(exposedHeaders));
    }

    builder.header(ACCESS_CONTROL_ALLOW_CREDENTIALS, Boolean.toString(auth));

    if (preflight) {
      if (auth) {
        builder.header(
            ACCESS_CONTROL_ALLOW_HEADERS,
            String.format("%s, %s", DEFAULT_ALLOW_HEADERS, AUTHORIZATION_HEADER));
      } else {
        builder.header(ACCESS_CONTROL_ALLOW_HEADERS, DEFAULT_ALLOW_HEADERS);
      }
    }

    if (preflight) {
      builder.header(ACCESS_CONTROL_MAX_AGE, DEFAULT_MAX_AGE);
    }

    return builder.build();
  }
  @GET
  @Path("info.zip")
  @Produces("application/zip")
  public Response doGet() throws Exception {

    ServerInfoCollector serverInfoCollector = Framework.getLocalService(ServerInfoCollector.class);
    // TODO: find a way to delete the File after written in the response by
    // JAX-RS
    File serverInfoZip = serverInfoCollector.collectInfoAsZip();
    ResponseBuilder responseBuilder = Response.ok(serverInfoZip);
    responseBuilder.type(MediaType.APPLICATION_OCTET_STREAM);
    responseBuilder.header(
        "Content-Disposition",
        String.format("attachment; filename=\"%s\"", SERVER_INFO_ZIP_FILENAME));
    return responseBuilder.build();
  }
  private ResponseBuilder appendPreflightResponseHeaders(
      HttpHeaders headers, ResponseBuilder response) {
    // add response headers for the preflight request
    // required
    response
        .header(
            "Access-Control-Allow-Origin",
            headers.getRequestHeader("Origin").get(0)) // return submitted origin
        .header("Access-Control-Allow-Methods", "POST, DELETE") // only POST/DELETE are allowed
        .header(
            "Access-Control-Allow-Headers",
            "accept, origin, content-type, authorization") // explicit Headers!
        .header("Access-Control-Allow-Credentials", "true")
        // indicates how long the results of a preflight request can be cached (in seconds)
        .header("Access-Control-Max-Age", "604800"); // for now, we keep it for seven days

    return response;
  }
  @Path("/any-file-type/{type}")
  @GET
  public Response anyFileType(@PathParam("type") String fileType) {

    /*
     * We are loading file kept in resources/static/ folder using Spring
     * ResourceLoader classpath mechanism. We have following files: 1.
     * sample.doc 2. sample.jpg 3. sample.pdf 4. sample.png Based on type
     * passed, we load sample.<type> from resources folder. We are using
     * Spring ResourceLoader to load file.
     */
    File file = null;
    String mimeType;
    try {

      file = resourceLoader.getResource("classpath:static/sample." + fileType).getFile();

      /*
       * We can also use normal File constructor to load a file. For e.g.
       * File file = new File("C:\sample.pdf");
       */

      if (!file.exists()) {
        throw new WebApplicationException(404);
      }

    } catch (IOException e) {
      e.printStackTrace();
    }

    /* Finding MIME type for explicitly setting MIME */
    mimeType = new MimetypesFileTypeMap().getContentType(file);

    ResponseBuilder rb = Response.ok(file, mimeType);

    /*
     * Setting file name and making sure file download instead of showing in
     * browser
     */
    rb.header("Content-Disposition", "inline; filename=sample." + fileType);

    return rb.build();
  }
  @GET
  @Path("/report/{accessKey}")
  @Produces("application/pdf")
  public Response getFileInPDFFormat(@PathParam("accessKey") String accessKey) {
    // System.out.println("File requested is : " + fileName);
    log.info("************OBTIENE REPORTE PARA KEY: " + accessKey);

    // Put some validations here such as invalid file name or missing file name
    if (accessKey == null || accessKey.isEmpty()) {
      ResponseBuilder response = Response.status(Status.BAD_REQUEST);
      return response.build();
    }

    // Prepare a file object with file to return
    File file = new File("/Users/santteegt/Desktop/FACTURAELECTRONICA.pdf");

    ResponseBuilder response = Response.ok((Object) file);
    response.header(
        "Content-Disposition", "attachment; filename=\"COMPROBANTE-" + accessKey + "\"");
    return response.build();
  }
  /*
   * Setting MIME type explicitly using @Produces annotation. Content will
   * displayed in browser if possible.
   */
  @Path("/png-file/")
  @GET
  @Produces("image/png")
  public Response pngFileType() {
    File file = null;
    try {

      file = resourceLoader.getResource("classpath:static/sample.png").getFile();

      if (!file.exists()) {
        throw new WebApplicationException(404);
      }

    } catch (IOException e) {
      e.printStackTrace();
    }

    ResponseBuilder rb = Response.ok(file);

    /* Setting file name */
    rb.header("Content-Disposition", "attachment; filename=sample.png");

    return rb.build();
  }
Пример #29
0
  @POST
  @Path("{csid}")
  public Response invokeReport(
      @Context UriInfo ui, @PathParam("csid") String csid, InvocationContext invContext) {
    Response response = null;

    try {
      StringBuffer outMimeType = new StringBuffer();
      StringBuffer outFileName = new StringBuffer();
      ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = createServiceContext();
      InputStream reportInputStream = invokeReport(ctx, csid, invContext, outMimeType, outFileName);

      // Need to set response type for what is requested...
      ResponseBuilder builder = Response.ok(reportInputStream, outMimeType.toString());
      builder =
          builder.header(
              "Content-Disposition", "inline;filename=\"" + outFileName.toString() + "\"");
      response = builder.build();
    } catch (Exception e) {
      throw bigReThrow(e, ServiceMessages.POST_FAILED);
    }

    return response;
  }
  @Path("download")
  @GET
  @Consumes({MediaType.APPLICATION_JSON})
  @Produces({MediaType.APPLICATION_JSON})
  public Response retriveDataForDownload(
      @Context final UriInfo uriInfo,
      @QueryParam("source") final String source,
      @QueryParam("status") final String status,
      @QueryParam("fromDate") final Long start,
      @QueryParam("toDate") final Long end)
      throws IOException {

    this.context.authenticatedUser().validateHasReadPermission(resourceNameForPermissions);
    /** have to convert from and to date to format like 2014-06-15 */
    Date fDate = new Date(start);
    Date tDate = new Date(end);
    DateFormat df = new SimpleDateFormat("yyyy-MM-dd");

    String fromDate = df.format(fDate);
    String toDate = df.format(tDate);

    List<PaymentGatewayDownloadData> paymentData =
        readPlatformService.retriveDataForDownload(source, fromDate, toDate, status);

    /** receiptNo serialNumber paymentDate amountPaid PhoneMSISDN Remarks status */
    boolean statusSuccess = false;
    if (status.equalsIgnoreCase("Success")) statusSuccess = true;

    StringBuilder builder = new StringBuilder();
    if (statusSuccess) {
      builder.append(
          "Receipt No, Serial No, Payment Date, Amount Paid, Payment Id, Phone MSISDN, Remarks, Status \n");
    } else {
      builder.append(
          "Receipt No, Serial No, Payment Date, Amount Paid, Phone MSISDN, Remarks, Status \n");
    }

    for (PaymentGatewayDownloadData data : paymentData) {
      builder.append(data.getReceiptNo() + ",");
      builder.append(data.getSerialNo() + ",");
      builder.append(data.getPaymendDate() + ",");
      builder.append(data.getAmountPaid() + ",");
      if (statusSuccess) {
        builder.append(data.getPaymentId() + ",");
      }
      builder.append(data.getPhoneMSISDN() + ",");
      builder.append(data.getRemarks() + ",");
      builder.append(data.getStatus());
      builder.append("\n");
    }
    statusSuccess = false;
    String fileLocation =
        System.getProperty("java.io.tmpdir")
            + File.separator
            + "billing"
            + File.separator
            + ""
            + source
            + ""
            + System.currentTimeMillis()
            + status
            + ".csv";

    String dirLocation = System.getProperty("java.io.tmpdir") + File.separator + "billing";
    File dir = new File(dirLocation);
    if (!dir.exists()) {
      dir.mkdir();
    }

    File file = new File(fileLocation);
    if (!file.exists()) {
      file.createNewFile();
    }
    FileUtils.writeStringToFile(file, builder.toString());

    final ResponseBuilder response = Response.ok(file);
    response.header("Content-Disposition", "attachment; filename=\"" + file.getName() + "\"");
    response.header("Content-Type", "application/csv");

    return response.build();

    /*String toJson = gson.toJson(paymentData);
    JSONArray arry  = null;
    try {
    	arry = new JSONArray(toJson);
    } catch (JSONException e) {
    	e.printStackTrace();
    }
    System.out.println(arry);
    String json = this.toApiJsonSerializer.serialize(paymentData);

    File file=new File("/home/rakesh/Desktop/demo.csv");
       String csv = null;
    try {
    	csv = CDL.toString(arry);
    } catch (JSONException e) {
    	// TODO Auto-generated catch block
    	e.printStackTrace();
    }
       FileUtils.writeStringToFile(file, csv);*/

    // return this.toApiJsonSerializer.serialize(paymentData);

  }