@GET
 @Produces(
     com.smartitengineering.util.opensearch.jaxrs.MediaType.APPLICATION_OPENSEARCHDESCRIPTION_XML)
 public Response getSpec() {
   OpenSearchDescriptorBuilder descBuilder = OpenSearchDescriptorBuilder.getBuilder();
   descBuilder.shortName("Content Search");
   descBuilder.description("Search the content repository for contents!");
   StringBuilder templateBuilder = getSearchUri(true);
   final String urlTemplate = templateBuilder.toString();
   if (logger.isDebugEnabled()) {
     logger.debug("Template URL: " + urlTemplate);
   }
   UrlBuilder xmlBuilder =
       UrlBuilder.getBuilder()
           .rel(RelEnum.RESULTS)
           .indexOffset(start)
           .template(urlTemplate)
           .type(MediaType.APPLICATION_ATOM_XML);
   UrlBuilder jsonBulder =
       UrlBuilder.getBuilder()
           .rel(RelEnum.RESULTS)
           .indexOffset(start)
           .template(urlTemplate)
           .type(MediaType.APPLICATION_JSON);
   descBuilder.urls(xmlBuilder.build(), jsonBulder.build());
   ResponseBuilder builder = Response.ok(descBuilder.build());
   return builder.build();
 }
Example #2
0
  @RolesAllowed(value = {"Admin"})
  @POST
  @Path("/updateadmin")
  @Consumes("application/json")
  @Produces("application/json")
  public Response updateAdmin(Admin admin) {
    UserDAO userDAO = new UserDAO();
    ResponseBuilder builder;

    ForCodeError error = ForCodeValidator.validateUpdate(admin);
    try {
      if (error == null) {
        userDAO.update(admin);
        builder = Response.status(Response.Status.OK).entity(admin);
        logger.info("Admin updated.");
      } else {
        System.out.println(error.getMessage());
        builder = Response.status(Response.Status.CONFLICT).entity(error);
        logger.info("Conflict while trying to update Admin.");
      }
    } catch (ForCodeDataException fde) {
      logger.warn(fde.getMessage());
      builder = Response.status(Response.Status.BAD_REQUEST).entity(fde);
    }

    return builder.build();
  }
Example #3
0
  @PermitAll
  @POST
  @Path("/searchinstitution")
  @Consumes("application/json")
  @Produces("application/json")
  public Response searchInstitution(String institutionName) {

    logger.info("Searching for institution " + institutionName);

    Institution institution = this.findInstitution(institutionName);

    ResponseBuilder builder;

    if (institution == null) {
      ForCodeError error = ErrorFactory.getErrorFromIndex(ErrorFactory.INSTITUTION_NOT_FOUND);
      builder = Response.status(Response.Status.NOT_FOUND).entity(error);

      logger.info("Unsuccessful attempt to find institution.");
    } else {
      builder = Response.status(Response.Status.FOUND).entity(institution);

      logger.info("Successful attempt to find institution.");
    }

    return builder.build();
  }
Example #4
0
  @RolesAllowed(value = {"Admin"})
  @POST
  @Path("/createinstitute")
  @Consumes("application/json")
  @Produces("application/json")
  public Response createInstitution(Institution institution) {
    InstitutionDAO userDAO = new InstitutionDAO();
    ResponseBuilder builder;

    ForCodeError error = ForCodeValidator.validate(institution);

    try {
      if (error == null) {
        userDAO.insert(institution);
        builder = Response.status(Response.Status.OK).entity(institution);
        logger.info("New institution registered.");
      } else {
        System.out.println(error.getMessage());
        builder = Response.status(Response.Status.CONFLICT).entity(error);
        logger.info("Conflict while trying to register new institute.");
      }
    } catch (ForCodeDataException fde) {
      logger.warn(fde.getMessage());
      builder = Response.status(Response.Status.BAD_REQUEST).entity(fde);
    }

    return builder.build();
  }
  @GET
  @Produces(MediaType.TEXT_HTML)
  public Response detailView(@Context HttpServletRequest request) {

    ModelAndView view;
    ModelMap model = new ModelMap();
    ResponseBuilder builder;

    try {
      model.addAttribute("title", "Account Settings - " + getContextName());
      model.addAttribute("user", getCurrentUser());
      model.addAttribute("currentView", "detail");

      addFlashMessage(request, model);

      view = new ModelAndView("user.detail", model);
      builder = Response.ok();
    } catch (UserNotFoundException e) {
      logger.warn("User not found", e);

      view = buildErrorView(Status.INTERNAL_SERVER_ERROR, e.getMessage());
      builder = Response.serverError();
    }

    return builder.entity(view).build();
  }
Example #6
0
  @PermitAll
  @GET
  @Path("/searchuser")
  @Consumes("application/json")
  @Produces("application/json")
  public Response searchUser(@QueryParam("q") String username) {

    logger.info("Searching for user " + username);

    User user = this.findUser(username);

    ResponseBuilder builder;

    if (user == null) {
      ForCodeError error = ErrorFactory.getErrorFromIndex(ErrorFactory.USER_NOT_FOUND);
      builder = Response.status(Response.Status.NOT_FOUND).entity(error);

      logger.info("Unsuccessful attempt to find user.");
    } else {

      user.setPassword(null);
      user.setUserKey(null);

      builder = Response.status(Response.Status.FOUND).entity(user);

      logger.info("Successful attempt to find user.");
    }

    return builder.build();
  }
  /**
   * Create Push Application
   *
   * @param pushApp new {@link PushApplication}
   * @return created {@link PushApplication}
   * @statuscode 201 The PushApplication Variant created successfully
   * @statuscode 400 The format of the client request was incorrect
   */
  @POST
  @Consumes(MediaType.APPLICATION_JSON)
  @Produces(MediaType.APPLICATION_JSON)
  @ReturnType("org.jboss.aerogear.unifiedpush.api.PushApplication")
  public Response registerPushApplication(PushApplication pushApp) {

    // some validation
    try {
      validateModelClass(pushApp);
    } catch (ConstraintViolationException cve) {

      // Build and return the 400 (Bad Request) response
      ResponseBuilder builder = createBadRequestResponse(cve.getConstraintViolations());

      return builder.build();
    }

    pushAppService.addPushApplication(pushApp);

    return Response.created(
            UriBuilder.fromResource(PushApplicationEndpoint.class)
                .path(String.valueOf(pushApp.getPushApplicationID()))
                .build())
        .entity(pushApp)
        .build();
  }
Example #8
0
  @PermitAll
  @GET
  @Path("/contestbyid")
  @Consumes("application/json")
  @Produces("application/json")
  public Response seachContestById(@QueryParam("q") Integer idContest) {
    ContestDAO contestDao = new ContestDAO();
    ResponseBuilder builder;

    logger.info("Searching for contest " + idContest);
    try {
      Contest contest = contestDao.getById(idContest);

      if (contest == null) {
        ForCodeError error = ErrorFactory.getErrorFromIndex(ErrorFactory.CONTEST_NOT_EXISTENT);
        builder = Response.status(Response.Status.NOT_FOUND).entity(error);
      } else {
        builder = Response.status(Response.Status.OK).entity(contest);
      }
    } catch (ForCodeDataException fde) {
      logger.warn(fde.getMessage());
      builder = Response.status(Response.Status.BAD_REQUEST).entity(fde);
    }

    return builder.build();
  }
Example #9
0
  @RolesAllowed(value = {"Manager"})
  @POST
  @Path("/invalidatecontestant")
  @Consumes("application/json")
  @Produces("application/json")
  public Response invalidateContestant(UserContest contestant) {
    UserContestDAO userContestDao = new UserContestDAO();
    ResponseBuilder builder;

    try {
      contestant = userContestDao.getById(contestant.getIdUserContest());
      logger.info("Invalidating contestant");

      if (contestant == null) {
        logger.info("Contestant not found");
        ForCodeError error = ErrorFactory.getErrorFromIndex(ErrorFactory.USER_CONTEST_NOT_FOUND);
        builder = Response.status(Response.Status.NOT_FOUND).entity(error);

      } else {
        contestant.setValid(false);
        userContestDao.update(contestant);

        logger.info("Contestant invalidated " + contestant.getUser().getUsername());
        builder = Response.status(Response.Status.ACCEPTED).entity(contestant);
      }
    } catch (ForCodeDataException fde) {
      logger.warn(fde.getMessage());
      builder = Response.status(Response.Status.BAD_REQUEST).entity(fde);
    }
    return builder.build();
  }
  /**
   * Update Push Application
   *
   * @param pushApplicationID id of {@link PushApplication}
   * @param updatedPushApp new info of {@link PushApplication}
   * @statuscode 204 The PushApplication updated successfully
   * @statuscode 400 The format of the client request was incorrect
   * @statuscode 404 The requested PushApplication resource does not exist
   */
  @PUT
  @Path("/{pushAppID}")
  @Consumes(MediaType.APPLICATION_JSON)
  @Produces(MediaType.APPLICATION_JSON)
  @ReturnType("java.lang.Void")
  public Response updatePushApplication(
      @PathParam("pushAppID") String pushApplicationID, PushApplication updatedPushApp) {

    PushApplication pushApp = getSearch().findByPushApplicationIDForDeveloper(pushApplicationID);

    if (pushApp != null) {

      // some validation
      try {
        validateModelClass(updatedPushApp);
      } catch (ConstraintViolationException cve) {

        // Build and return the 400 (Bad Request) response
        ResponseBuilder builder = createBadRequestResponse(cve.getConstraintViolations());

        return builder.build();
      }

      // update name/desc:
      pushApp.setDescription(updatedPushApp.getDescription());
      pushApp.setName(updatedPushApp.getName());
      pushAppService.updatePushApplication(pushApp);

      return Response.noContent().build();
    }

    return Response.status(Status.NOT_FOUND)
        .entity("Could not find requested PushApplicationEntity")
        .build();
  }
  /**
   * Get Push Application.
   *
   * @param pushApplicationID id of {@link PushApplication}
   * @param includeDeviceCount boolean param to put device count into response headers, default
   *     {@code false}
   * @param includeActivity boolean param to put activity into response headers, default {@code
   *     false}
   * @return requested {@link PushApplication}
   * @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
   * @statuscode 404 The requested PushApplication resource does not exist
   */
  @GET
  @Path("/{pushAppID}")
  @Produces(MediaType.APPLICATION_JSON)
  @ReturnType("org.jboss.aerogear.unifiedpush.api.PushApplication")
  public Response findById(
      @PathParam("pushAppID") String pushApplicationID,
      @QueryParam("includeDeviceCount") @DefaultValue("false") boolean includeDeviceCount,
      @QueryParam("includeActivity") @DefaultValue("false") boolean includeActivity) {

    PushApplication pushApp = getSearch().findByPushApplicationIDForDeveloper(pushApplicationID);

    if (pushApp != null) {
      ResponseBuilder response = Response.ok(pushApp);
      if (includeActivity) {
        putActivityIntoResponseHeaders(pushApp, response);
      }
      if (includeDeviceCount) {
        putDeviceCountIntoResponseHeaders(pushApp, response);
      }
      return response.build();
    }

    return Response.status(Status.NOT_FOUND)
        .entity("Could not find requested PushApplicationEntity")
        .build();
  }
Example #12
0
  @PermitAll
  @POST
  @Path("/createcontestant")
  @Consumes("application/json")
  @Produces("application/json")
  public Response createContestant(Contestant contestant) {
    UserDAO userDAO = new UserDAO();
    ResponseBuilder builder;

    ForCodeError error = ForCodeValidator.validateInsertion(contestant);
    try {
      if (error == null) {
        userDAO.insert(contestant);
        builder = Response.status(Response.Status.OK).entity(contestant);
        logger.info("New Contestant registered.");
      } else {
        System.out.println(error.getMessage());
        builder = Response.status(Response.Status.CONFLICT).entity(error);
        logger.info("Conflict while trying to register new contestant.");
      }
    } catch (ForCodeDataException fde) {
      logger.warn(fde.getMessage());
      builder = Response.status(Response.Status.BAD_REQUEST).entity(fde);
    }

    return builder.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();
  }
  private Response launch(String yaml, EntitySpec<? extends Application> spec) {
    try {
      Application app = EntityManagementUtils.createUnstarted(mgmt(), spec);
      CreationResult<Application, Void> result = EntityManagementUtils.start(app);

      boolean isEntitled =
          Entitlements.isEntitled(
              mgmt().getEntitlementManager(),
              Entitlements.INVOKE_EFFECTOR,
              EntityAndItem.of(app, StringAndArgument.of(Startable.START.getName(), null)));

      if (!isEntitled) {
        throw WebResourceUtils.unauthorized(
            "User '%s' is not authorized to start application %s",
            Entitlements.getEntitlementContext().user(), spec.getType());
      }

      log.info("Launched from YAML: " + yaml + " -> " + app + " (" + result.task() + ")");

      URI ref = URI.create(app.getApplicationId());
      ResponseBuilder response = created(ref);
      if (result.task() != null) response.entity(TaskTransformer.FROM_TASK.apply(result.task()));
      return response.build();
    } catch (ConstraintViolationException e) {
      throw new UserFacingException(e);
    } catch (Exception e) {
      throw Exceptions.propagate(e);
    }
  }
  @RolesAllowed("user")
  @POST
  @Path("/create")
  @Consumes("application/json")
  @Produces("application/json")
  public Response createDebate(NewPolarizedRoom newDebate) {

    logger.info("Starting new room creating");

    OpiningError error = new PolarizedRoomValidation().validateInsertion(newDebate);
    ResponseBuilder builder;

    if (error == null) {

      UserDAO userDAO = new UserDAO();
      User user = userDAO.getByLogin(newDebate.getCreator().getLogin());
      newDebate.setCreator(user);

      PolarizedRoom polarizedRoom = newDebate.toPolarizedRoom();

      PolarizedRoomDAO polarizedRoomDAO = new PolarizedRoomDAO();
      polarizedRoomDAO.insert(polarizedRoom);

      builder = Response.status(Response.Status.OK).entity(polarizedRoom);

      logger.info("Room succefully created");

    } else {
      builder = Response.status(Response.Status.CONFLICT).entity(error);
      logger.warn("Room creation is failed with error code: " + error.getCode());
    }

    return builder.build();
  }
Example #16
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();
  }
Example #17
0
  /**
   * Modify an existing datastream's content
   *
   * @param pathList
   * @param requestContentType Content-Type header
   * @param requestBodyStream Binary blob
   * @return 201 Created
   * @throws RepositoryException
   * @throws InvalidChecksumException
   */
  @PUT
  @Timed
  public Response modifyContent(
      @PathParam("path") final List<PathSegment> pathList,
      @QueryParam("checksum") final String checksum,
      @HeaderParam("Content-Disposition") final String contentDisposition,
      @HeaderParam("Content-Type") final MediaType requestContentType,
      @ContentLocation final InputStream requestBodyStream,
      @Context final Request request,
      @Context final HttpServletResponse servletResponse)
      throws RepositoryException, InvalidChecksumException, URISyntaxException, ParseException {

    try {
      final String path = toPath(pathList);
      final MediaType contentType = getSimpleContentType(requestContentType);

      if (nodeService.exists(session, path)) {

        final Datastream ds = datastreamService.getDatastream(session, path);

        evaluateRequestPreconditions(request, ds);
      }

      LOGGER.debug("create Datastream {}", path);

      final URI checksumURI = checksumURI(checksum);
      final String originalFileName = originalFileName(contentDisposition);

      final Datastream datastream =
          datastreamService.createDatastream(
              session,
              path,
              contentType.toString(),
              originalFileName,
              requestBodyStream,
              checksumURI);

      final boolean isNew = datastream.isNew();
      session.save();
      versionService.nodeUpdated(datastream.getNode());

      ResponseBuilder builder;
      if (isNew) {
        final HttpIdentifierTranslator subjects =
            new HttpIdentifierTranslator(session, FedoraNodes.class, uriInfo);

        builder =
            created(new URI(subjects.getSubject(datastream.getContentNode().getPath()).getURI()));
      } else {
        builder = noContent();
      }

      addCacheControlHeaders(servletResponse, datastream);

      return builder.build();
    } finally {
      session.logout();
    }
  }
 @GET
 @Path("{search_id:[0-9]+}/allids")
 @Produces(UTF8MediaType.APPLICATION_JSON)
 public Response getAllSearchResultIds(@PathParam("search_id") long searchId) {
   List<String> searchResultIds = searchService.getAllSearchResultIds(searchId);
   ResponseBuilder builder = Response.ok(searchResultIds);
   return builder.build();
 }
 @Override
 public Response toResponse(LocationBaseException exception) {
   ResponseBuilder rb = Response.status(Response.Status.INTERNAL_SERVER_ERROR);
   rb.type("application/json;charset=UTF-8");
   rb.entity(exception);
   Response r = rb.build();
   return r;
 }
 @POST
 @Consumes(MediaType.APPLICATION_JSON)
 public Response contactSAV(Mail mail) {
   emailService.envoiEmailSAV(mail.getObject(), mail.getMsg(), mail.getExpediteur());
   ResponseBuilder builder = Response.ok();
   builder.status(200);
   return 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);
 }
Example #22
0
  public void handleValidationException(ValidationException exception, ResponseBuilder builder) {
    builder.status(BAD_REQUEST);
    ValidationErrorMessageWrapper error = new ValidationErrorMessageWrapper();

    for (ConstraintViolation<Object> violation : exception.getViolations()) {
      error.addMessage(violation.getMessage());
    }
    builder.entity(error);
  }
 @POST
 @Path("/delete")
 public Response deletePost() {
   UserPerson userPersonForDelete = userPerson;
   Services.getInstance().getUserPersonService().delete(userPersonForDelete);
   Services.getInstance().getUserService().delete(userPersonForDelete.getUser());
   Services.getInstance().getPersonService().delete(userPersonForDelete.getPerson());
   ResponseBuilder responseBuilder = Response.ok();
   return responseBuilder.build();
 }
 @GET
 @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
 @Path("{id}")
 public final Response get(@PathParam("id") long id, @Context HttpServletRequest httpRequest) {
   final FormBean form = dbManager.selectFormBean(id);
   final ResponseBuilder builder =
       form != null ? Response.ok(form) : Response.status(Status.NOT_FOUND);
   final Response response = builder.build();
   return response;
 }
  /**
   * @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();
  }
Example #26
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();
 }
 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()));
   }
 }
  @GET
  @Produces({"application/xml", "application/json"})
  @Path("/{assettype}")
  public Response getChecksums(
      @PathParam("modulename") String moduleName, @PathParam("modulePart") String modulePart) {
    ChecksumList checksumList = getChecksumList(moduleName, modulePart);

    ResponseBuilder rb = Response.ok(checksumList);
    return rb.build();
  }
Example #29
0
  public void testPie1() {
    try {

      String url = baseURL + "/rest/Pie/search;id=*/utensilCollection";

      WebClient client = WebClient.create(url);
      client.type("application/xml").accept("application/xml");
      Response response = client.get();

      if (response.getStatus() == Status.NOT_ACCEPTABLE.getStatusCode()) {
        InputStream is = (InputStream) response.getEntity();
        org.jdom.input.SAXBuilder builder = new org.jdom.input.SAXBuilder(false);
        org.jdom.Document jDoc = builder.build(is);
        assertEquals(jDoc.getRootElement().getName(), "response");
      } else if (response.getStatus() == Status.NOT_FOUND.getStatusCode()) {
        InputStream is = (InputStream) response.getEntity();
        org.jdom.input.SAXBuilder builder = new org.jdom.input.SAXBuilder(false);
        org.jdom.Document jDoc = builder.build(is);
        assertEquals(jDoc.getRootElement().getName(), "response");
      } else if (response.getStatus() != 200) {
        throw new RuntimeException("Failed : HTTP error code : " + response.getStatus());
      }

      File myFile = new File("Pie_Search" + "XML.xml");
      System.out.println("writing data to file " + myFile.getAbsolutePath());
      FileWriter myWriter = new FileWriter(myFile);

      BufferedReader br =
          new BufferedReader(new InputStreamReader(((InputStream) response.getEntity())));

      String output;
      System.out.println("Output from Server .... \n");
      while ((output = br.readLine()) != null) {
        myWriter.write(output);
        System.out.println(output);
      }

      myWriter.flush();
      myWriter.close();

    } catch (Exception e) {
      e.printStackTrace();
      ResponseBuilder builder = Response.status(Status.INTERNAL_SERVER_ERROR);
      builder.type("application/xml");
      StringBuffer buffer = new StringBuffer();
      buffer.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
      buffer.append("<response>");
      buffer.append("<type>ERROR</type>");
      buffer.append("<code>INTERNAL_ERROR_4</code>");
      buffer.append("<message>Failed to Query due to: " + e.getMessage() + "</message>");
      buffer.append("</response>");
      builder.entity(buffer.toString());
      throw new WebApplicationException(builder.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;
  }