public String getOverview(UriInfo uriInfo) {
    // verify interaction URI is valid
    findInteraction();

    StringBuilder buffer = new StringBuilder();

    buffer
        .append("<html>")
        .append("<head></head>")
        .append("<body>")
        .append("<p><a href='")
        .append(uriInfo.getAbsolutePath())
        .append("/definition'>Show Interaction Definition</a></p>")
        .append("<p><a href='")
        .append(uriInfo.getAbsolutePath())
        .append("/owner'>Show Interaction Owner</a></p>")
        .append("<p><a href='")
        .append(uriInfo.getAbsolutePath())
        .append("/inData'>Show In Data Values</a></p>")
        .append("<p><a href='")
        .append(uriInfo.getAbsolutePath())
        .append("/outData'>Submit Out Data Values</a></p>")
        .append("</body></html>");

    return buffer.toString();
  }
Пример #2
0
 @POST
 @Path("blueprint/{name}")
 public Response createBlueprint(
     @Context UriInfo uri, @PathParam("name") String name, ConfigManifest blueprint) {
   Response res;
   try {
     ZooKeeper zk = Controller.getInstance().getZKInstance();
     blueprint.setUrl(uri.getAbsolutePath().toURL());
     byte[] data = JAXBUtil.write(blueprint);
     Stat stat =
         zk.exists(
             CommonConfigurationKeys.ZOOKEEPER_CONFIG_BLUEPRINT_PATH_DEFAULT + '/' + name, false);
     if (stat == null) {
       zk.create(
           CommonConfigurationKeys.ZOOKEEPER_CONFIG_BLUEPRINT_PATH_DEFAULT + '/' + name,
           data,
           Ids.OPEN_ACL_UNSAFE,
           CreateMode.PERSISTENT);
     } else {
       throw new WebApplicationException(409);
     }
     res = Response.created(uri.getAbsolutePath()).build();
     return res;
   } catch (WebApplicationException e) {
     throw e;
   } catch (Exception e) {
     LOG.error(ExceptionUtil.getStackTrace(e));
     throw new WebApplicationException(500);
   }
 }
  /**
   * POST method for creating an instance of ContactResource
   *
   * @param content representation for the new resource
   * @return an HTTP response with content of the created resource
   */
  @POST // Create
  @Consumes({
    MediaType.APPLICATION_XML,
    MediaType.APPLICATION_JSON,
    MediaType.TEXT_PLAIN,
    MediaType.TEXT_HTML
  })
  @Produces({
    MediaType.APPLICATION_XML,
    MediaType.APPLICATION_JSON,
    MediaType.TEXT_PLAIN,
    MediaType.TEXT_HTML
  })
  public Response postXmlOrJson(PhoneDirectoryEntry myEntry) {
    String phoneNo = myEntry.getPhoneNo();
    boolean recordExist = phoneDirectoryDAO.checkPhoneNoExist(phoneNo);

    if (recordExist == true) {
      return Response.status(Response.Status.CONFLICT) // .CONFLICT
          .header(
              "Location ",
              String.format("%s%s", context.getAbsolutePath().toString(), myEntry.getPhoneNo()))
          .entity("<PhoneNumber_AlreadyExists PhoneNumber = '" + phoneNo + "'>")
          .build();
    } else {
      phoneDirectoryDAO.addPhoneNumber(myEntry);

      return Response.status(Response.Status.CREATED)
          .header(
              "Location ",
              String.format("%s%s", context.getAbsolutePath().toString(), myEntry.getPhoneNo()))
          .entity(myEntry)
          .build();
    }
  }
  @Test
  public void testConstructSelfUri() {
    String id = UUID.randomUUID().toString();
    URI self = InstanceResource.constructSelfUri(INSTANCE_URI_INFO, id);

    assertEquals(id, Strings.commonSuffix(id, self.getPath()));
    assertEquals(
        INSTANCE_URI_INFO.getAbsolutePath().toString(),
        Strings.commonPrefix(INSTANCE_URI_INFO.getAbsolutePath().toString(), self.toString()));
  }
  /**
   * Builds the references of the PublicPlans of a CSAR and a plan type defined due the constructor.
   *
   * @param uriInfo
   * @return Response
   */
  @GET
  @Produces(ResourceConstants.LINKED_XML)
  public Response getReferences(@Context UriInfo uriInfo) {

    if (this.csarID == null) {
      return Response.status(404).build();
    }

    CSARPublicPlansResource.LOG.debug(
        "Return available management plans for CSAR {} and type {} .",
        this.csarID,
        this.publicPlanType);

    References refs = new References();

    PublicPlanTypes type = PublicPlanTypes.isPlanTypeEnumRepresentation(this.publicPlanType);
    LinkedHashMap<Integer, PublicPlan> linkedMapOfPublicPlans =
        ToscaServiceHandler.getToscaEngineService()
            .getToscaReferenceMapper()
            .getCSARIDToPublicPlans(this.csarID)
            .get(type);

    CSARPublicPlansResource.LOG.debug(
        "Getting the list of PublicPlan of the type \""
            + type
            + "\" for CSAR \""
            + this.csarID.getFileName()
            + "\".");

    for (Integer itr : linkedMapOfPublicPlans.keySet()) {
      PublicPlan plan = linkedMapOfPublicPlans.get(itr);
      refs.getReference()
          .add(
              new Reference(
                  Utilities.buildURI(uriInfo.getAbsolutePath().toString(), Integer.toString(itr)),
                  XLinkConstants.SIMPLE,
                  plan.getPlanID().toString()));
    }

    CSARPublicPlansResource.LOG.info(
        "Number of References in Root: {}", refs.getReference().size());

    // selflink
    refs.getReference()
        .add(
            new Reference(
                uriInfo.getAbsolutePath().toString(), XLinkConstants.SIMPLE, XLinkConstants.SELF));
    return Response.ok(refs.getXMLString()).build();
  }
  /**
   * For test purpose only
   *
   * @param entities
   * @return
   */
  @POST
  @Consumes({"application/json"})
  @Produces({"application/json"})
  public Response post(List<Product> entities, @Context UriInfo info)
      throws UnknownResourceException {

    if (entities == null) {
      return Response.status(Response.Status.BAD_REQUEST.getStatusCode()).build();
    }

    int previousRows = productInventoryFacade.count();
    int affectedRows = 0;

    // Try to persist entities
    try {
      for (Product entitie : entities) {
        productInventoryFacade.checkCreation(entitie);
        productInventoryFacade.create(entitie);
        entitie.setHref(info.getAbsolutePath() + "/" + Long.toString(entitie.getId()));
        productInventoryFacade.edit(entitie);
        affectedRows = affectedRows + 1;
        //                publisher.createNotification(entitie, new Date());
      }
    } catch (BadUsageException e) {
      return Response.status(Response.Status.BAD_REQUEST.getStatusCode()).build();
    }

    Report stat = new Report(productInventoryFacade.count());
    stat.setAffectedRows(affectedRows);
    stat.setPreviousRows(previousRows);

    // 201 OK
    return Response.created(null).entity(stat).build();
  }
 @GET
 @Path("/forward/object/{id}")
 public Response forwardObject(
     @PathParam("id") Integer id, @Context InternalDispatcher dispatcher) {
   uriStack.push(uriInfo.getAbsolutePath().toString());
   return dispatcher.getResponse("/object/" + id);
 }
 @POST
 @Consumes("text/plain")
 @Path("/forward/basic")
 public void postForwardBasic(String basic, @Context InternalDispatcher dispatcher) {
   uriStack.push(uriInfo.getAbsolutePath().toString());
   dispatcher.postEntity("/basic", basic);
 }
 @GET
 @Produces("text/plain")
 @Path("/forward/basic")
 public String forwardBasic(@Context InternalDispatcher dispatcher) {
   uriStack.push(uriInfo.getAbsolutePath().toString());
   return (String) dispatcher.getEntity("/basic");
 }
 @GET
 @Produces("text/plain")
 @Path("/basic")
 public String getBasic() {
   uriStack.push(uriInfo.getAbsolutePath().toString());
   return basic;
 }
Пример #11
0
 @PUT
 @Consumes(MediaType.APPLICATION_XML)
 public Response putTaskData(String value) {
   Response res = null;
   // add your code here
   // first check if the Entity exists in the datastore
   DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
   MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService();
   syncCache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO));
   Key entKey = KeyFactory.createKey("TaskData", keyname);
   Date date = new Date();
   try {
     // if it is, signal that we updated the entity
     Entity ts = datastore.get(entKey);
     ts.setProperty("value", value);
     ts.setProperty("date", date);
     datastore.put(ts);
     res = Response.noContent().build();
   } catch (EntityNotFoundException e) {
     // if it is not, create it and
     // signal that we created the entity in the datastore
     Entity taskdata = new Entity("TaskData", keyname);
     taskdata.setProperty("value", value);
     taskdata.setProperty("date", date);
     datastore.put(taskdata);
     res = Response.created(uriInfo.getAbsolutePath()).build();
   }
   TaskData td = new TaskData(keyname, value, date);
   syncCache.put(keyname, td);
   return res;
 }
 @POST
 @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
 @Produces(BeeterMediaType.BEETER_AUTH_TOKEN)
 public Response registerUser(
     @FormParam("loginid") String loginid,
     @FormParam("password") String password,
     @FormParam("email") String email,
     @FormParam("fullname") String fullname,
     @Context UriInfo uriInfo)
     throws URISyntaxException {
   if (loginid == null || password == null || email == null || fullname == null)
     throw new BadRequestException("all parameters are mandatory");
   UserDAO userDAO = new UserDAOImpl();
   User user = null;
   AuthToken authToken = null;
   try {
     user = userDAO.createUser(loginid, password, email, fullname);
     authToken = (new AuthTokenDAOImpl()).createAuthToken(user.getId());
   } catch (UserAlreadyExistsException e) {
     throw new WebApplicationException("loginid already exists", Response.Status.CONFLICT);
   } catch (SQLException e) {
     throw new InternalServerErrorException();
   }
   URI uri = new URI(uriInfo.getAbsolutePath().toString() + "/" + user.getId());
   return Response.created(uri).type(BeeterMediaType.BEETER_AUTH_TOKEN).entity(authToken).build();
 }
Пример #13
0
 @POST
 @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
 @Produces(GrouptalkMediaType.GROUPTALK_AUTH_TOKEN)
 public Response createJoinGroup(
     @FormParam("userid") String userid,
     @FormParam("groupid") String groupid,
     @Context UriInfo uriInfo)
     throws URISyntaxException {
   if (userid == null || groupid == null)
     throw new BadRequestException("all parameters are mandatory");
   JoinGroupDAO joinGroupDAO = new JoinGroupDAOImpl();
   JoinGroup joinGroup = null;
   AuthToken authenticationToken = null;
   try {
     joinGroup =
         joinGroupDAO.createJoinGroup(securityContext.getUserPrincipal().getName(), groupid);
   } catch (SQLException e) {
     throw new InternalServerErrorException();
   }
   URI uri = new URI(uriInfo.getAbsolutePath().toString() + "/" + joinGroup.getUserid());
   return Response.created(uri)
       .type(GrouptalkMediaType.GROUPTALK_InterestGroups)
       .entity(joinGroup)
       .build();
 }
  @Override
  public void filter(ContainerRequestContext rc) throws IOException {
    checkSecurityContextStart(rc);
    UriInfo ui = rc.getUriInfo();
    String absoluteRequestUri = ui.getAbsolutePath().toString();

    boolean sameUriRedirect = false;
    if (completeUri == null) {
      String referer = rc.getHeaderString("Referer");
      if (referer != null && referer.startsWith(authorizationServiceUri)) {
        completeUri = absoluteRequestUri;
        sameUriRedirect = true;
      }
    }

    if (!sameUriRedirect && absoluteRequestUri.endsWith(startUri)) {
      ClientTokenContext request = getClientTokenContext(rc);
      if (request != null) {
        setClientCodeRequest(request);
        if (completeUri != null) {
          rc.setRequestUri(URI.create(completeUri));
        }
        return;
      }
      Response codeResponse = createCodeResponse(rc, ui);
      rc.abortWith(codeResponse);
    } else if (absoluteRequestUri.endsWith(completeUri)) {
      MultivaluedMap<String, String> requestParams = toRequestState(rc, ui);
      processCodeResponse(rc, ui, requestParams);
      checkSecurityContextEnd(rc, requestParams);
    }
  }
Пример #15
0
 /**
  * Redirects to the overview page
  *
  * @return {@link Response}
  */
 @GET
 public Response redirectToHomePage(@Context UriInfo uriInfo) {
   if (uriInfo.getAbsolutePath().toString().endsWith("/")) {
     return RedirectUtil.createSeeOtherResponse("overview", uriInfo);
   }
   return RedirectUtil.createSeeOtherResponse("dashboard/overview", uriInfo);
 }
  @Test
  public void testContextUriInfoUtil2nd2ndPassPathParamsQueryParams() throws URISyntaxException {

    String dasBaseUri = "http://localhost:port/";

    Map<String, String> pathParams = new HashMap<String, String>();
    pathParams.put("aa", "2.16.840.1.113883.4.349");
    pathParams.put("pid", "1012581676V377802");
    pathParams.put("profile", "benefits");
    pathParams.put("domain", "integratedCare");
    pathParams.put("speciality", "careCoordinatorProfiles");
    pathParams.put("homeCommunityId", "2.16.840.1.113883.4.349.3");
    pathParams.put("remoteRepositoryId", "3.33.333.3.333333.3.333");
    pathParams.put("documentUniqueId", "1001");
    pathParams.put("fileExtension", "xml");

    Map<String, String> queryParams = new HashMap<String, String>();
    queryParams.put("queryParamName1", "queryParamValue1");
    queryParams.put("queryParamName2", "queryParamValue2");
    queryParams.put("queryParamName3", "queryParamValue3");

    javax.ws.rs.core.UriInfo contextUriInfo =
        ContextUriInfoUtil.createUriInfo(dasBaseUri, pathParams, queryParams);

    System.out.println("baseUri: " + contextUriInfo.getBaseUri());
    System.out.println("path: " + contextUriInfo.getPath());
    System.out.println("absolutePath: " + contextUriInfo.getAbsolutePath());
    System.out.println("requestUri: " + contextUriInfo.getRequestUri());
    System.out.println("");
  }
 /**
  * Creates a new agreement
  *
  * <pre>
  *  POST /agreements
  *
  *  Request:
  *    POST /agreements HTTP/1.1
  *    Accept: application/xml
  *
  *  Response:
  *    HTTP/1.1 201 Created
  *    Content-type: application/xml
  *    Location: http://.../agreements/$uuid
  *
  *  {@code
  *    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  *    <message code="201" message= "The agreement has been stored successfully in the SLA Repository Database"/>
  *  }
  *
  * </pre>
  *
  * Example:
  * <li>curl -H "Content-type: application/xml" [email protected]
  *     localhost:8080/sla-service/agreements -X POST
  *
  * @return XML information with the different details of the agreement
  */
 @POST
 @Consumes(MediaType.APPLICATION_XML)
 @Produces(MediaType.APPLICATION_XML)
 public Response createAgreement(
     @Context HttpHeaders hh, @Context UriInfo uriInfo, String payload) {
   logger.debug("StartOf createAgreement - Insert /agreements");
   String location = null;
   try {
     AgreementHelper agreementRestService = getAgreementHelper();
     location =
         agreementRestService.createAgreement(hh, uriInfo.getAbsolutePath().toString(), payload);
   } catch (HelperException e) {
     logger.info("createAgreement exception", e);
     return buildResponse(e);
   }
   Response result =
       buildResponsePOST(
           HttpStatus.CREATED,
           printMessage(
               HttpStatus.CREATED,
               "The agreement has been stored successfully in the SLA Repository Database with location:"
                   + location),
           location);
   logger.debug("EndOf createAgreement");
   return result;
 }
  @Test
  public void testContextUriInfoUtil1stPassPathParamsQueryP() throws URISyntaxException {

    String dasBaseUri = "http://localhost:port/";

    Map<String, String> pathParams = new HashMap<String, String>();
    pathParams.put("aa", "2.16.840.1.113883.4.349");
    pathParams.put("pid", "1012581676V377802");
    pathParams.put("profile", "benefits");
    pathParams.put("domain", "integratedCare");
    pathParams.put("speciality", "careCoordinatorProfiles");

    String queryP = "?zzzzzz=3333333&xxxxx=111111&yyyy=22222";

    Map<String, String> queryParams = new HashMap<String, String>();
    queryParams.put("zzzzzz", "3333333");
    queryParams.put("xxxxx", "111111");
    queryParams.put("yyyy", "22222");

    javax.ws.rs.core.UriInfo contextUriInfo =
        ContextUriInfoUtil.createUriInfo(dasBaseUri, null, pathParams, queryP, queryParams);

    System.out.println("baseUri: " + contextUriInfo.getBaseUri());
    System.out.println("path: " + contextUriInfo.getPath());
    System.out.println("absolutePath: " + contextUriInfo.getAbsolutePath());
    System.out.println("requestUri: " + contextUriInfo.getRequestUri());
    System.out.println("");
  }
Пример #19
0
  @GET
  public IpsPoolManagementDto getIPAddresses(
      @PathParam(VirtualDatacenterResource.VIRTUAL_DATACENTER) final Integer vdcId,
      @PathParam(PrivateNetworkResource.PRIVATE_NETWORK) final Integer vlanId,
      @QueryParam(START_WITH) @DefaultValue("0") @Min(0) final Integer startwith,
      @QueryParam(BY) @DefaultValue("ip") final String orderBy,
      @QueryParam(FILTER) @DefaultValue("") final String filter,
      @QueryParam(LIMIT) @Min(0) @DefaultValue(DEFAULT_PAGE_LENGTH_STRING) final Integer limit,
      @QueryParam(ASC) @DefaultValue("true") final Boolean descOrAsc,
      @QueryParam(ONLYAVAILABLE) @DefaultValue("false") final Boolean available,
      @Context final IRESTBuilder restBuilder)
      throws Exception {

    List<IpPoolManagement> all =
        service.getListIpPoolManagementByVlan(
            vdcId, vlanId, startwith, orderBy, filter, limit, descOrAsc);

    IpsPoolManagementDto ips = new IpsPoolManagementDto();

    for (IpPoolManagement ip : all) {
      ips.add(createTransferObject(ip, restBuilder));
    }

    ips.addLinks(
        restBuilder.buildPaggingLinks(uriInfo.getAbsolutePath().toString(), (PagedList) all));
    ips.setTotalSize(((PagedList) all).getTotalResults());

    return ips;
  }
Пример #20
0
  @PUT
  public Response putItem(@Context HttpHeaders headers, byte[] data) {
    System.out.println("PUT ITEM " + container + " " + item);

    URI uri = uriInfo.getAbsolutePath();
    MediaType mimeType = headers.getMediaType();
    GregorianCalendar gc = new GregorianCalendar();
    gc.set(GregorianCalendar.MILLISECOND, 0);
    Item i = new Item(item, uri.toString(), mimeType.toString(), gc);
    String digest = computeDigest(data);
    i.setDigest(digest);

    Response r;
    if (!MemoryStore.MS.hasItem(container, item)) {
      r = Response.created(uri).build();
    } else {
      r = Response.noContent().build();
    }

    Item ii = MemoryStore.MS.createOrUpdateItem(container, i, data);
    if (ii == null) {
      // Create the container if one has not been created
      URI containerUri = uriInfo.getAbsolutePathBuilder().path("..").build().normalize();
      Container c = new Container(container, containerUri.toString());
      MemoryStore.MS.createContainer(c);
      i = MemoryStore.MS.createOrUpdateItem(container, i, data);
      if (i == null) throw new NotFoundException("Container not found");
    }

    return r;
  }
 @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);
   }
 }
Пример #22
0
 /**
  * Post method for creating an instance of Network using XML as the input format.
  *
  * @param data an NetworkConverter entity that is deserialized from an XML stream
  * @return an instance of NetworkConverter
  */
 @POST
 @Consumes({"application/xml", "application/json"})
 public Response post(NetworkConverter data) {
   Network entity = data.getEntity();
   createEntity(entity);
   return Response.created(uriInfo.getAbsolutePath().resolve(entity.getId() + "/")).build();
 }
Пример #23
0
  @Path(("/registrar"))
  @POST
  @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
  @Produces(MusicloudMediaType.MUSICLOUD_AUTH_TOKEN)
  public Response registerUser(
      @FormParam("login") String login,
      @FormParam("nombre") String nombre,
      @FormParam("apellidos") String apellidos,
      @FormParam("email") String email,
      @FormParam("password") String password,
      @Context UriInfo uriInfo)
      throws URISyntaxException {
    if (login == null || nombre == null || apellidos == null || password == null || email == null)
      throw new BadRequestException("Se necesitan todos los parametros");
    UserDAO userDAO = new UserDAOImpl();
    User user = null;

    try {
      user = userDAO.crear_usuario_registrado(login, nombre, apellidos, email, password);

    } catch (UserAlreadyExistsException e) {
      throw new WebApplicationException("Este login ya existe ", Response.Status.CONFLICT);
    } catch (SQLException e) {
      throw new InternalServerErrorException();
    }
    URI uri = new URI(uriInfo.getAbsolutePath().toString() + "/" + user.getId());
    return Response.ok().build();
  }
 @GET
 @Produces("text/plain")
 @Path("/object/{id}")
 public Response getObject(@PathParam("id") Integer id) {
   uriStack.push(uriInfo.getAbsolutePath().toString());
   if (id == 0) return Response.noContent().build();
   else return Response.ok("object" + id).build();
 }
 @PUT
 @POST
 @Consumes("text/plain")
 @Path("/basic")
 public void putBasic(String basic) {
   uriStack.push(uriInfo.getAbsolutePath().toString());
   this.basic = basic;
 }
Пример #26
0
 @PUT
 @Consumes(MediaType.APPLICATION_JSON)
 public Response updateClient(
     final Client client, @Context final UriInfo uriInfo, @Context final HttpHeaders headers) {
   clientService.updateClient(client);
   return Response.ok(
           new StatusEntity("200", uriInfo.getAbsolutePath() + "/" + client.getClientID()))
       .build();
 }
 private Response putAndGetResponse(Todo todo) {
   Response res;
   if (TodoDao.instance.getModel().containsKey(todo.getId())) {
     res = Response.noContent().build();
   } else {
     res = Response.created(uriInfo.getAbsolutePath()).build();
   }
   TodoDao.instance.getModel().put(todo.getId(), todo);
   return res;
 }
Пример #28
0
 private Response getResponse(Senzor senzor) {
   Response raspuns;
   if (ListaSenzor.instance.getModel().containsKey(senzor.getId())) {
     raspuns = Response.noContent().build();
   } else {
     raspuns = Response.created(uriInfo.getAbsolutePath()).build();
   }
   ListaSenzor.instance.getModel().put(senzor.getId(), senzor);
   return raspuns;
 }
  /**
   * Eine neue Lokalitaet abspeichern.
   *
   * @param person Das Person-Objekt
   * @param uriInfo Info-Objekt zur aufgerufenen URI
   * @param headers
   * @return
   * @return
   * @throws URISyntaxException
   */
  @POST
  @XmlElement(type = Location.class)
  @Consumes({MediaType.APPLICATION_XML, MediaType.TEXT_XML, MediaType.APPLICATION_JSON})
  @Produces
  public Response createLocation(
      Location location, @Context UriInfo uriInfo, @Context HttpHeaders headers) {
    dao.create(location.getBeschreibung());

    return Response.created(uriInfo.getAbsolutePath()).build();
  }
Пример #30
0
 /**
  * Get method for retrieving a collection of Network instance in XML format.
  *
  * @return an instance of NetworksConverter
  */
 @GET
 @Produces({"application/xml", "application/json"})
 public NetworksConverter get(
     @QueryParam("start") @DefaultValue("0") int start,
     @QueryParam("max") @DefaultValue("10") int max,
     @QueryParam("expandLevel") @DefaultValue("1") int expandLevel,
     @QueryParam("query") @DefaultValue("SELECT e FROM Network e") String query) {
   return new NetworksConverter(
       getEntities(start, max, query), uriInfo.getAbsolutePath(), expandLevel);
 }