Java Code Examples for javax.ws.rs.GET

@GET
@Path(KMSRESTConstants.KEYS_METADATA_RESOURCE)
@Produces(MediaType.APPLICATION_JSON)
public Response getKeysMetadata(@QueryParam(KMSRESTConstants.KEY)
    List<String> keyNamesList) throws Exception {
  KMSWebApp.getAdminCallsMeter().mark();
  UserGroupInformation user = HttpUserGroupInformation.get();
  final String[] keyNames = keyNamesList.toArray(
      new String[keyNamesList.size()]);
  assertAccess(KMSACLs.Type.GET_METADATA, user, KMSOp.GET_KEYS_METADATA);

  KeyProvider.Metadata[] keysMeta = user.doAs(
      new PrivilegedExceptionAction<KeyProvider.Metadata[]>() {
        @Override
        public KeyProvider.Metadata[] run() throws Exception {
          return provider.getKeysMetadata(keyNames);
        }
      }
  );

  Object json = KMSServerJSONUtils.toJSON(keyNames, keysMeta);
  kmsAudit.ok(user, KMSOp.GET_KEYS_METADATA, "");
  return Response.ok().type(MediaType.APPLICATION_JSON).entity(json).build();
}
 

@GET
@Path("find")
@Produces(MediaType.APPLICATION_JSON)
public Response find() {
    JsonArray build = null;
    try {
        build = adminClinicService.get().stream().map(h -> Json.createObjectBuilder()
                .add("firstname", h.getPersonId().getFirstName())
                .add("lastname", h.getPersonId().getLastName())
                .add("id", h.getAdminClinicId())
                .build())
                .collect(Json::createArrayBuilder, JsonArrayBuilder::add, JsonArrayBuilder::add)
                .build();
    } catch (Exception ex) {
        return Response.ok().header("Exception", ex.getMessage()).build();
    }
    return Response.ok().entity(build == null ? "No data found" : build).build();
}
 

@GET
@Path("find")
@Produces(MediaType.APPLICATION_JSON)
public Response find() {
    JsonArray build = null;
    try {
        build = countryService.get().stream().map(h -> Json.createObjectBuilder()
                .add("id", h.getCountryId())
                .add("name", h.getCountryName())
                .build())
                .collect(Json::createArrayBuilder, JsonArrayBuilder::add, JsonArrayBuilder::add)
                .build();
    } catch (Exception ex) {
        return Response.ok().header("Exception", ex.getMessage()).build();
    }
    return Response.ok().entity(build == null ? "No data found" : build).build();
}
 

@GET
@Path("{planId}")
@Produces({ MediaType.TEXT_HTML })
public Response getPlanAsHtml(
    @PathParam("serviceProviderId") final String serviceProviderId, @PathParam("planId") final String planId
    ) throws ServletException, IOException, URISyntaxException
{
    // Start of user code getPlanAsHtml_init
    // End of user code

    final Plan aPlan = PlannerReasonerManager.getPlan(httpServletRequest, serviceProviderId, planId);

    if (aPlan != null) {
        httpServletRequest.setAttribute("aPlan", aPlan);
        // Start of user code getPlanAsHtml_setAttributes
        // End of user code

        RequestDispatcher rd = httpServletRequest.getRequestDispatcher("/se/ericsson/cf/scott/sandbox/plan.jsp");
        rd.forward(httpServletRequest,httpServletResponse);
    }

    throw new WebApplicationException(Status.NOT_FOUND);
}
 

@GET
@Path("/verifyExpiration")
@Produces(MediaType.APPLICATION_JSON)
public JsonObject verifyExpiration(@QueryParam("exp") Long exp) {
    boolean pass = false;
    String msg;
    // exp
    Long expValue = rawTokenJson.getExpirationTime();
    if (expValue == null || expValue.intValue() == 0) {
        msg = Claims.exp.name() + "value is null or empty, FAIL";
    }
    else if (expValue.equals(exp)) {
        msg = Claims.exp.name() + " PASS";
        pass = true;
    }
    else {
        msg = String.format("%s: %s != %s", Claims.exp.name(), expValue, exp);
    }
    JsonObject result = Json.createObjectBuilder()
            .add("pass", pass)
            .add("msg", msg)
            .build();
    return result;
}
 

@GET
@Produces({"application/xml", "application/json"})
@Path("/recent/region/producttype/{regionName}/{productTypeId}/{orderLineId}")
public List<LiveSalesList> findRecentRegionProductTypeFrom(@PathParam("regionName") String regionName, @PathParam("productTypeId") Integer productTypeId, @PathParam("orderLineId") Integer orderLineId) {
    CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
    javax.persistence.criteria.CriteriaQuery cq = cb.createQuery();
    Root<LiveSalesList> liveSalesList = cq.from(LiveSalesList.class);
    cq.select(liveSalesList);
    cq.where(cb.and(
        cb.equal(liveSalesList.get(LiveSalesList_.productTypeId), productTypeId),
        cb.equal(liveSalesList.get(LiveSalesList_.region), regionName),
        cb.gt(liveSalesList.get(LiveSalesList_.orderLineId), orderLineId)
    ));
    Query q = getEntityManager().createQuery(cq);
    q.setMaxResults(500);
    return q.getResultList();
}
 

@GET
@Path("/apps/{appid}")
@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
public AppInfo getApp(@Context HttpServletRequest hsr,
    @PathParam("appid") String appId) {
  init();
  if (appId == null || appId.isEmpty()) {
    throw new NotFoundException("appId, " + appId + ", is empty or null");
  }
  ApplicationId id;
  id = ConverterUtils.toApplicationId(recordFactory, appId);
  if (id == null) {
    throw new NotFoundException("appId is null");
  }
  RMApp app = rm.getRMContext().getRMApps().get(id);
  if (app == null) {
    throw new NotFoundException("app with id: " + appId + " not found");
  }
  return new AppInfo(rm, app, hasAccess(app, hsr), hsr.getScheme() + "://");
}
 

@GET
@Traced(operationName = "find_tweets") //Tracing instrumentation
@Timed //Metrics instrumentation
public Response findTweets() {
  try {
    final List<TweetRepresentation> tweetRepresentations =
        tweetsService.findTweets(new TweetsQuery())
            .stream()
            .map(Tweet::printRepresentation)
            .collect(toList());
    final TweetsRepresentation tweetsRepresentation = new TweetsRepresentation();
    tweetsRepresentation.setTweets(tweetRepresentations);
    return Response.ok(tweetsRepresentation).build();
  } catch (Exception e) {
    e.printStackTrace();
    return Response.serverError().entity(e.getMessage()).build();
  }
}
 

@GET
@Path("find")
@Produces(MediaType.APPLICATION_JSON)
public Response find() {
    JsonArray build = null;
    try {
        build = cityService.get().stream().map(h -> Json.createObjectBuilder()
                .add("id", h.getCityId())
                .add("name", h.getCityName())
                .build())
                .collect(Json::createArrayBuilder, JsonArrayBuilder::add, JsonArrayBuilder::add)
                .build();
    } catch (Exception ex) {
        return Response.ok().header("Exception", ex.getMessage()).build();
    }
    return Response.ok().entity(build == null ? "No data found" : build).build();
}
 

@Path("/{inspectionHookId}")
@GET
public InspectionHookEntity getInspectionHook(@PathParam("controllerId") String controllerId,
        @PathParam("inspectionHookId") String inspectionHookId)
                throws Exception {

    LOG.info("Getting the inspection hook element for id {} ", inspectionHookId);

    SampleSdnRedirectionApi sdnApi = ((SampleSdnRedirectionApi) this.api
            .createRedirectionApi(new VirtualizationConnectorElementImpl("Sample", controllerId), "TEST"));

    InspectionHookEntity inspectionHook = (InspectionHookEntity) sdnApi.getInspectionHook(inspectionHookId);

    inspectionHook.setInspectedPort(null);
    inspectionHook.setInspectionPort(null);

    return inspectionHook;
}
 

@GET
@Path("/containers")
@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
public ContainersInfo getNodeContainers() {
  init();
  ContainersInfo allContainers = new ContainersInfo();
  for (Entry<ContainerId, Container> entry : this.nmContext.getContainers()
      .entrySet()) {
    if (entry.getValue() == null) {
      // just skip it
      continue;
    }
    ContainerInfo info = new ContainerInfo(this.nmContext, entry.getValue(),
        uriInfo.getBaseUri().toString(), webapp.name());
    allContainers.add(info);
  }
  return allContainers;
}
 

@ApiOperation(value = "Retrieves the Distributed Appliance Instance",
        notes = "Retrieves a Distributed Appliance Instance specified by the Id",
        response = DistributedApplianceDto.class)
@ApiResponses(value = { @ApiResponse(code = 200, message = "Successful operation"),
        @ApiResponse(code = 400, message = "In case of any error", response = ErrorCodeDto.class) })
@Path("/{distributedApplianceInstanceId}")
@GET
public DistributedApplianceInstanceDto getDistributedApplianceInstance(@Context HttpHeaders headers,
                                                                       @ApiParam(value = "The Id of the Distributed Appliance Instance",
                                                                               required = true) @PathParam("distributedApplianceInstanceId") Long distributedApplianceInstanceId) {

    logger.info("Getting Distributed Appliance Instance " + distributedApplianceInstanceId);
    this.userContext.setUser(OscAuthFilter.getUsername(headers));

    GetDtoFromEntityRequest getDtoRequest = new GetDtoFromEntityRequest();
    getDtoRequest.setEntityId(distributedApplianceInstanceId);
    getDtoRequest.setEntityName("DistributedApplianceInstance");
    GetDtoFromEntityServiceApi<DistributedApplianceInstanceDto> getDtoService = this.getDtoFromEntityServiceFactory.getService(DistributedApplianceInstanceDto.class);

    return this.apiUtil.submitBaseRequestToService(getDtoService, getDtoRequest).getDto();
}
 

@GET
@Path("usuarios")
public List<UsuarioDetailDTO> getUsuariosGuias(@QueryParam("guias")int g ){
   List<UsuarioDetailDTO> lista = new ArrayList<UsuarioDetailDTO>(); 
   List<UsuarioDetailDTO> lista1 = listEntity2DTO(usuarioLogic.getUsuarios());
   for (UsuarioDetailDTO usuario : lista1 )
   {
       if (usuario.getGuia()!=null)
          { 
       if (usuario.getGuia().booleanValue())
       {
           lista.add(usuario); 
       }
        }
   }
   
   if (g == 1 )
   {
       return lista; 
   }
   else 
   {
       return lista1; 
   }
}
 

@GET
@Produces(MediaType.APPLICATION_JSON)
public ResourceIndex index(@Context Application application,
		@Context HttpServletRequest request) throws Exception {
	// String basePath = request.getRequestURL().toString();
	return new ResourceIndex(IndexResource.getResourceIndexNode(JournalResource.class, request)); // basePath));
}
 

@GET
@Secured
@Path("/GetPersonaPresenceByName")
@Produces(MediaType.APPLICATION_XML)
public String getPersonaPresenceByName(@QueryParam("displayName") String displayName) {
	PersonaPresence personaPresenceByName = bo.getPersonaPresenceByName(displayName);
	if (personaPresenceByName.getPersonaId() == 0) {
		return "";
	}
	return MarshalXML.marshal(personaPresenceByName);
}
 

/**
 * Return a specific configuration. System properties overrides the value from the database. Configuration values
 * are
 * always encrypted.
 * 
 * @param name
 *            The requested parameter name.
 * @return a specific configuration. May be <code>null</code>.
 */
@GET
@CacheResult(cacheName = "configuration")
public String get(@CacheKey final String name) {
	String value = System.getProperty(name);
	if (value == null) {
		value = Optional.ofNullable(repository.findByName(name)).map(SystemConfiguration::getValue).orElse(null);
	}
	return Optional.ofNullable(value).map(cryptoHelper::decryptAsNeeded).orElse(null);
}
 

@GET
@Path("/aggregations/terms/{queryString}")
public Response getAggregationsUrl(@PathParam("queryString") @NotNull String query) {

  EsAggregation aggregation = new EsAggregation();
  aggregation.setQuery(query);

  return getAggregations(aggregation);
}
 

@GET
@Produces({ MediaType.APPLICATION_JSON })
@Path("{id}/files")
public Page<FileOutVO> getFiles(@PathParam("id") Long id, @Context UriInfo uriInfo)
		throws AuthenticationException, AuthorisationException, ServiceException {
	PSFUriPart psf;
	return new Page<FileOutVO>(WebUtil.getServiceLocator().getFileService().getFiles(auth, fileModule, id, null, null, psf = new PSFUriPart(uriInfo)), psf);
}
 

@GET
@Path("subscribe")
@Produces(MediaType.SERVER_SENT_EVENTS)
public void subscribe(@Context SseEventSink eventSink,
                      @Context Sse sse){
    eventSink.send(sse.newEvent("Welcome to the List!"));
    eventSink.send(sse.newEvent("Message One!"));
    eventSink.send(sse.newEvent("SERVER-NOTIFICATION", "Message Two!"));
    eventSink.send(sse.newEventBuilder()
                    .comment("Nice Test")
                    .name("SERVER-TEST")
                    .data("Some data...could be an object")
                    .build());
    eventSink.close();
}
 

@GET
@Path("/{group}")
@PermitAll
@Timed(name = "getFeatures")
public Response getFeatures(
    @Auth AuthPrincipal principal,
    @PathParam("group") String group
) throws AuthenticationException {

  final long start = System.currentTimeMillis();
  grantedGuard(principal, group);
  return this.headers.enrich(Response.ok(featureService.loadFeatures(group)), start).build();
}
 

/**
 * Returns all in votes of a given contentId Element
 * @param contentId to get the in votes of
 * @param con Connection to use - is injected automatically
 * @return a list of Users that voted in for the given contentid
 */
@GET
@Path("/ins")
public Response getInsOfContentId(@PathParam("contentId") final long contentId, @Context final Connection con){
	final ContentVoteDao dao = new ContentVoteDao(con);
	final List<User> insOfUsers= dao.getUsersThatVotedInOfContentId(contentId);
	return ok(UserUtil.toModels(insOfUsers, true));
}
 

@GET
@Path("/cluster/{id}")
@Produces(MediaType.APPLICATION_JSON)
public ClusterResponse getClusterInfo(@PathParam("id") final String id) throws Exception {
  ClusterEnriched cluster = service.getClusterInfo(new ClusterId(id));
  return toClusterResponse(cluster);
}
 

@Override
@GET
@Path("/count/consensus")
@Produces(MediaType.APPLICATION_JSON)
public RpcResult getConsensusCount() {
    return RpcResult.getSuccess();
}
 

@GET
@Path("/runtime")
@Produces("application/json")
public ArrayList<ServiceData> getRuntimeInfo() {
	try {
		logger.fine("Getting Runtime info");
		ArrayList<ServiceData> list = new ArrayList<ServiceData>();
		ServiceData data = new ServiceData();
		data.name = "Runtime";
		data.description = "Java";			
		list.add(data);
		
		data = new ServiceData();
		data.name = "Version";
		data.description = System.getProperty("java.version");			
		list.add(data);
		
		data = new ServiceData();
		data.name = "Vendor";
		data.description = System.getProperty("java.vendor");			
		list.add(data);
		
		return list;
	}
	catch (Exception e) {
		e.printStackTrace();
		return null;
	}
}
 

@GET
@Consumes("text/plain")
@Produces("text/plain")
@Path("diameter_application_id_whitelist_remove")
public String diameter_application_id_whitelist_remove(@MatrixParam("ai") int ai) {
    DiameterFirewallConfig.diameter_application_id_whitelist.remove((new Integer(ai)).toString());
    return "Successful";
}
 

/**
 * Only return the public keys.
 *
 * @return public key set.
 */
@ApiOperation(value = "Get public keys",
    response = Response.class,
    notes = "Provides the JWKS of public keys used for JWS and JWE for clients.")
@GET
@Produces(MediaType.APPLICATION_JSON)
public String getPublicKeySet() {

    return cachedDataProvider.getKeySet().toJson(JsonWebKey.OutputControlLevel.PUBLIC_ONLY);
}
 

@GET
@Path("/apps/{appid}/appattempts/{appattemptid}/containers/{containerid}")
@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
@Override
public ContainerInfo getContainer(@Context HttpServletRequest req,
    @Context HttpServletResponse res, @PathParam("appid") String appId,
    @PathParam("appattemptid") String appAttemptId,
    @PathParam("containerid") String containerId) {
  init(res);
  return super.getContainer(req, res, appId, appAttemptId, containerId);
}
 

@GET
@Path("/{connector}/config")
public Map<String, String> getConnectorConfig(final @PathParam("connector") String connector,
                                              final @QueryParam("forward") Boolean forward) throws Throwable {
    FutureCallback<Map<String, String>> cb = new FutureCallback<>();
    herder.connectorConfig(connector, cb);
    return completeOrForwardRequest(cb, "/connectors/" + connector + "/config", "GET", null, forward);
}
 

/**
 * process OPTIONS Method.
 * @return JAX-RS response object
 */
@OPTIONS
public Response options() {
    // Check exist
    checkFileExists();
    // Access Control
    davRsCmp.getParent().checkAccessContext(davRsCmp.getAccessContext(), CellPrivilege.ROOT);
    return PersoniumCoreUtils.responseBuilderForOptions(
            HttpMethod.GET,
            HttpMethod.PUT,
            HttpMethod.DELETE,
            io.personium.common.utils.PersoniumCoreUtils.HttpMethod.PROPFIND
            ).build();
}
 

@GET
@Path(Urls.ConfigUrls.IDP_CONFIG_DATA)
@Timed
public IdpConfigDto getIdpConfig(@PathParam(Urls.SharedUrls.ENTITY_ID_PARAM) String entityId) {

    IdentityProviderConfigEntityData idpData = getIdentityProviderConfigData(entityId);
    return new IdpConfigDto(
            idpData.getSimpleId(),
            idpData.isEnabled(),
            idpData.getSupportedLevelsOfAssurance(),
            idpData.getUseExactComparisonType()
    );
}
 

@GET
@Path("/{id}")
public Response getUser(@PathParam("id") long id) {
    User user = users.findUser(id);
    if (user != null) {
        return Response.status(Response.Status.ACCEPTED).entity(user).build();
    }
    return Response.status(Response.Status.NOT_FOUND).build();
}
 

/**
 * Returns all meters of all devices.
 *
 * @return 200 OK with array of all the meters in the system
 * @onos.rsModel Meters
 */
@GET
@Produces(MediaType.APPLICATION_JSON)
public Response getMeters() {
    final Iterable<Meter> meters = meterService.getAllMeters();
    if (meters != null) {
        meters.forEach(meter -> metersNode.add(codec(Meter.class).encode(meter, this)));
    }
    return ok(root).build();
}
 

@GET
@Path("/{uuid}/{version}")
@ApiOperation(value = "Get information about an item", response = ItemBean.class)
public ItemBean getItem(
	// @formatter:off
	@Context UriInfo uriInfo,
	@ApiParam(APIDOC_ITEMUUID) @PathParam("uuid") String uuid,
	@ApiParam(APIDOC_ITEMVERSION) @PathParam("version") int version,
	@ApiParam(value = "How much information to return for the item", required = false, allowableValues = ALL_ALLOWABLE_INFOS, allowMultiple = true) @QueryParam("info") CsvList info);
 

@GET
@Path("/{n}")
@Consumes({ MediaType.APPLICATION_FORM_URLENCODED })
@Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
public Response read(@Context HttpServletRequest request, @Context HttpHeaders header,
		@Context Company company, @Context Locale locale, @Context User user, @Context ServiceContext serviceContext,
		@DefaultValue("0") @PathParam("n") int n);
 

/**
 * Returns control message metrics of a given device.
 *
 * @param deviceId device identification
 * @return control message metrics of a given device
 * @onos.rsModel ControlMessageMetric
 */
@GET
@Produces(MediaType.APPLICATION_JSON)
@Path("messages/{deviceId}")
public Response controlMessageMetrics(@PathParam("deviceId") String deviceId) {

    metricsStats(monitorService, localNodeId, CONTROL_MESSAGE_METRICS,
            DeviceId.deviceId(deviceId), root);

    return ok(root).build();
}
 

@GET
public List<String> getPortIds(@PathParam("controllerId") String controllerId) throws Exception {
    LOG.info("Listing port elements ids'");

    SampleSdnRedirectionApi sdnApi = ((SampleSdnRedirectionApi) this.api
            .createRedirectionApi(new VirtualizationConnectorElementImpl("Sample", controllerId), "TEST"));

    return sdnApi.getPortIds();
}
 

@GET
@Path("/{nickname}/details-qr")
@Produces("image/png")
public Response deviceDetailsLinkQrCode(
        @PathParam("nickname") final String nickname,
        @QueryParam("baseUrl") @DefaultValue(DEFAULT_BASE_URL) final String baseUrl
) throws IOException {
    final byte[] detailsQr = qrCodeAsPng(baseUrl, nickname, "");
    return Response.ok(new ByteArrayInputStream(detailsQr)).build();
}
 

@GET
@Path("filter/group/user/q")
@Produces(MediaType.APPLICATION_JSON + ";charset=utf-8")
public void groupFilterUserQuery(String data, @Suspended AsyncResponse response) {

    response.resume(getUserGroupDetailsByFilter(request));
}
 

/**
 * Returns a group with the given deviceId and appCookie.
 *
 * @param deviceId device identifier
 * @param appCookie group key
 * @return 200 OK with a group entry in the system
 * @onos.rsModel Group
 */
@GET
@Produces(MediaType.APPLICATION_JSON)
@Path("{deviceId}/{appCookie}")
public Response getGroupByDeviceIdAndAppCookie(@PathParam("deviceId") String deviceId,
                                               @PathParam("appCookie") String appCookie) {
    final DeviceId deviceIdInstance = DeviceId.deviceId(deviceId);
    final GroupKey appCookieInstance = new DefaultGroupKey(appCookie.getBytes());

    Group group = nullIsNotFound(groupService.getGroup(deviceIdInstance, appCookieInstance),
            GROUP_NOT_FOUND);

    groupsNode.add(codec(Group.class).encode(group, this));
    return ok(root).build();
}
 

@GET
@Path("/")
public Collection<String> listConnectors(final @QueryParam("forward") Boolean forward) throws Throwable {
    FutureCallback<Collection<String>> cb = new FutureCallback<>();
    herder.connectors(cb);
    return completeOrForwardRequest(cb, "/connectors", "GET", null, new TypeReference<Collection<String>>() {
    }, forward);
}
 

@GET
@Path("acceleration/settings")
@Produces(APPLICATION_JSON)
public AccelerationSettingsDescriptor getAccelerationSettings() throws NamespaceException {
  final DatasetConfig config = namespaceService.getDataset(datasetPath.toNamespaceKey());
  if (config.getType() == DatasetType.VIRTUAL_DATASET) {
    final String msg = String.format("acceleration settings apply only to physical dataset. %s is a virtual dataset",
        datasetPath.toPathString());
    throw new IllegalArgumentException(msg);
  }

  final AccelerationSettings settings = config.getPhysicalDataset().getAccelerationSettings();
  final AccelerationSettingsDescriptor descriptor = new AccelerationSettingsDescriptor()
    .setAccelerationRefreshPeriod(settings.getRefreshPeriod())
    .setAccelerationGracePeriod(settings.getGracePeriod())
    .setMethod(settings.getMethod())
    .setRefreshField(settings.getRefreshField());

  final ByteString schemaBytes = DatasetHelper.getSchemaBytes(config);
  if (schemaBytes != null) {
    final BatchSchema schema = BatchSchema.deserialize(schemaBytes.toByteArray());
    descriptor.setFieldList(FluentIterable
        .from(schema)
        .transform(new Function<Field, String>() {
          @Nullable
          @Override
          public String apply(@Nullable final Field field) {
            return field.getName();
          }
        })
        .toList()
    );
  }
  return descriptor;
}
 

@GET
@Path("/{customername}")
@Produces(MediaType.APPLICATION_JSON)
@ApiOperation(value = "query all available coupon.", notes = "query all available coupon.", produces = MediaType.APPLICATION_JSON)
@ApiResponses(value = {@ApiResponse(code = 403, message = "Invalid user information"),
    @ApiResponse(code = 500, message = "CustomerService Internal Server Error")})
public List<CouponImpl> query(
    @ApiParam(value = "customer name", required = true) @PathParam("customername") String customername) {
  try {
    return couponService.getCoupons(customername);
  } catch (Exception e) {
    logger.warn("Failed get", e);
    throw new InvocationException(Response.Status.INTERNAL_SERVER_ERROR, "Internal Server Error");
  }
}
 

/**
 * Return the OSLC service provider catalog as RDF/XML, XML or JSON
 *
 * @return
 */
@GET
@Path("{serviceProviderCatalogId}") // Required to distinguish from array result.  But, ignored.
@Produces({OslcMediaType.APPLICATION_RDF_XML, OslcMediaType.APPLICATION_XML, OslcMediaType.APPLICATION_JSON})
public ServiceProviderCatalog getServiceProviderCatalog()
{
    ServiceProviderCatalog catalog =  ServiceProviderCatalogSingleton.getServiceProviderCatalog(httpServletRequest);

    if (catalog != null) {
        httpServletResponse.addHeader(PlannerReasonerConstants.HDR_OSLC_VERSION,"2.0");
        return catalog;
    }

    throw new WebApplicationException(Status.NOT_FOUND);
}
 

@GET
@Produces( { MediaType.APPLICATION_JSON, "application/javascript" })
public Response getZNodeListJSON(
        @PathParam("path") String path,
        @QueryParam("callback") String callback,
        @DefaultValue("data") @QueryParam("view") String view,
        @DefaultValue("base64") @QueryParam("dataformat") String dataformat,
        @Context UriInfo ui) throws InterruptedException, KeeperException {
    return getZNodeList(true, path, callback, view, dataformat, ui);
}
 

/**
 * 查询全部应用配置.
 * 
 * @return 全部应用配置
 */
@GET
@Path("/list")
@Produces(MediaType.APPLICATION_JSON)
public Collection<CloudAppConfiguration> findAllApps() {
    return appConfigService.loadAll();
}
 

@GET
@Produces(MediaType.APPLICATION_JSON)
public JsonArray getAllCargo() {
    List<Cargo> cargos = cargoRepository.findAll();

    JsonArrayBuilder builder = Json.createArrayBuilder();

    for (Cargo cargo : cargos) {
        builder.add(Json.createObjectBuilder()
                .add("trackingId", cargo.getTrackingId().getIdString())
                .add("routingStatus", cargo.getDelivery()
                        .getRoutingStatus().toString())
                .add("misdirected", cargo.getDelivery().isMisdirected())
                .add("transportStatus", cargo.getDelivery()
                        .getTransportStatus().toString())
                .add("atDestination", cargo.getDelivery()
                        .isUnloadedAtDestination())
                .add("origin", cargo.getOrigin().getUnLocode().getIdString())
                .add("lastKnownLocation",
                        cargo.getDelivery().getLastKnownLocation().getUnLocode().getIdString().equals("XXXXX")
                                ? "Unknown"
                                : cargo.getDelivery().getLastKnownLocation().getUnLocode().getIdString())
        );
    }

    return builder.build();
}
 

@GET
@Produces({MediaType.TEXT_PLAIN, MediaType.APPLICATION_JSON})
@Path("{word}")
public int get(@PathParam("word") String word) throws OryxServingException {
  Map<String,Integer> map = getModel().getWords();
  Integer count;
  synchronized (map) {
    count = map.get(word);
  }
  if (count == null) {
    throw new OryxServingException(Response.Status.BAD_REQUEST, "No such word");
  }
  return count;
}
 

@GET
@Path("/json")
@Produces(MediaType.APPLICATION_JSON)
public Blah hello2B() {

    return new Blah();
}
 

@Path("route")
@GET
public Collection<Position> getRoute(
        @QueryParam("deviceId") final List<Long> deviceIds, @QueryParam("groupId") final List<Long> groupIds,
        @QueryParam("from") String from, @QueryParam("to") String to) throws SQLException {
    return Route.getObjects(getUserId(), deviceIds, groupIds,
            DateUtil.parseDate(from), DateUtil.parseDate(to));
}
 

@GET
@Path("/{uuid}/{version}/history")
@ApiOperation(value = "Get all history for an item", response = HistoryEventBean.class)
public List<HistoryEventBean> getHistory(
	// @formatter:off
	@ApiParam(APIDOC_ITEMUUID) @PathParam("uuid") String uuid,
	@ApiParam(APIDOC_ITEMVERSION) @PathParam("version") int version);
 

@GET
@Consumes(MediaType.APPLICATION_JSON)
@Path("/verify")
public Response verify(@HeaderParam("token") String token){
          
    try {
        if(!Verify(token, "admin") && !Verify(token, "user"))
            return Response.status(Response.Status.UNAUTHORIZED)
                    .entity("Usuário ou senha incorretos").build();
    } catch (Exception ex) {
        return Resposta.retornar(400, ex.toString(), token);
    }

    return Response.status(Response.Status.OK).build();
}
 

/**
 * Return a simple map.
 */
@GET
@Path("/map")
public Map<Integer, String> map() {
	final Map<Integer, String> result = new HashMap<>();
	result.put(5, "value5");
	result.put(6, "value6");
	return result;
}
 

@GET
@Path("/{operationId}/actions")
@Consumes({ "application/json" })
@Produces({ "application/json" })
@ApiOperation(value = "", notes = "Retrieves available actions for Multi-Target Application operation ", response = String.class, responseContainer = "List", authorizations = {
    @Authorization(value = "oauth2", scopes = {

    }) }, tags = {})
@ApiResponses(value = { @ApiResponse(code = 200, message = "OK", response = String.class, responseContainer = "List") })
public Response getOperationActions(@ApiParam(value = "", required = true) @PathParam("operationId") String operationId) {
    return delegate.getOperationActions(operationId, securityContext, spaceGuid);
}
 

/**
 * This is a secured endpoint. The Fernet token is passed in via the X-Auth-Token header parameter.
 *
 * @param authHeader
 *            a Fernet token
 * @return the secret information
 */
@GET
public String getSecret(@HeaderParam("X-Auth-Token") final String authHeader) {
    // first, validate the token
    // if the token is valid, proceed to return the requested data
    final Token token = Token.fromString(authHeader);
    final User user = token.validateAndDecrypt(key, validator);
    // if the token is invalid, an exception will be thrown and the next line will not be executed
    // additional authorisation rules can be evaluated here such as ensuring the user specified by the token has
    // access to the data requested
    return user.getSecret();
}
 

@GET
@Path("{resourceShapePath}")
@Produces({OslcMediaType.APPLICATION_RDF_XML, OslcMediaType.APPLICATION_XML, OslcMediaType.TEXT_XML, OslcMediaType.APPLICATION_JSON, OslcMediaType.TEXT_TURTLE})
public ResourceShape getResourceShape(@Context                        final HttpServletRequest httpServletRequest,
                                      @PathParam("resourceShapePath") final String             resourceShapePath)
       throws OslcCoreApplicationException,
              URISyntaxException
{
    return getOslcResourceShapeResource().getResourceShape(httpServletRequest, resourceShapePath);
}
 

@ApiOperation(value = "Retrieves the Deployment Specification",
        notes = "Retrieves a Deployment Specification specified by its owning Virtual System and Deployment Spec Id",
        response = ApplianceManagerConnectorDto.class)
@ApiResponses(value = { @ApiResponse(code = 200, message = "Successful operation"),
        @ApiResponse(code = 400, message = "In case of any error", response = ErrorCodeDto.class) })
@Path("/{vsId}/deploymentSpecs/{dsId}")
@GET
public DeploymentSpecDto getDeploymentSpec(@Context HttpHeaders headers,
        @ApiParam(value = "The Virtual System Id") @PathParam("vsId") Long vsId,
        @ApiParam(value = "The Deployment Specification Id") @PathParam("dsId") Long dsId) {
    logger.info("getting Deployment Spec " + dsId);
    this.userContext.setUser(OscAuthFilter.getUsername(headers));
    GetDtoFromEntityRequest getDtoRequest = new GetDtoFromEntityRequest();
    getDtoRequest.setEntityId(dsId);
    getDtoRequest.setEntityName("DeploymentSpec");
    GetDtoFromEntityServiceApi<DeploymentSpecDto> getDtoService = this.getDtoFromEntityServiceFactory.getService(DeploymentSpecDto.class);
    DeploymentSpecDto dto = this.apiUtil.submitBaseRequestToService(getDtoService, getDtoRequest).getDto();

    this.apiUtil.validateParentIdMatches(dto, vsId, "SecurityGroup");

    return dto;
}
 

/**
 * 应用服务监控：全网应用Profile SnapShot
 * 
 * @return
 */
@GET
@Path("profile/q/cache")
@Produces(MediaType.APPLICATION_JSON + ";charset=utf-8")
public void loadAppProfileList(@QueryParam("fkey") String fkey, @QueryParam("fvalue") String fvalue,
        @Suspended AsyncResponse response) {

    UAVHttpMessage message = new UAVHttpMessage();
    message.setIntent("profile");
    if (StringHelper.isEmpty(fkey) || StringHelper.isEmpty(fvalue)) {
        String groups = getUserGroupsByFilter(request);
        if ("NOMAPPING".equals(groups)) {
            response.resume("{\"rs\":\"{}\"}");
        }
        else if ("ALL".equals(groups)) {
            loadAppProfileListFromHttp(message, response);
        }
        else {
            message.putRequest("fkey", "appgroup");
            message.putRequest("fvalue", groups);
            loadAppProfileListFromHttp(message, response);
        }
    }
    else {
        message.putRequest("fkey", fkey);
        message.putRequest("fvalue", fvalue);
        loadAppProfileListFromHttp(message, response);
    }

}
 

/**
 * Lists all patients.
 *
 * @return List of patients
 */
@GET
@Produces("application/json")
@Path("/account")
public List<PatientAccount> account() {
    return database.snapshots(PatientAccount.class).collect(toList());
}
 

@GET
@Produces({ MediaType.APPLICATION_JSON })
@Path("course")
public Page<HyperlinkOutVO> getCourseLinks(@Context UriInfo uriInfo)
		throws AuthenticationException, AuthorisationException, ServiceException {
	PSFUriPart psf;
	return new Page<HyperlinkOutVO>(WebUtil.getServiceLocator().getHyperlinkService()
			.getHyperlinks(auth, HyperlinkModule.COURSE_HYPERLINK, null, null, psf = new PSFUriPart(uriInfo)), psf);
}
 

/**
 * RDF/XML, XML and JSON representations of a single OSLC Service Provider
 *
 * @param serviceProviderId
 * @return
 */
@GET
@Path("{serviceProviderId}")
@Produces({OslcMediaType.APPLICATION_RDF_XML, OslcMediaType.APPLICATION_XML, OslcMediaType.APPLICATION_JSON})
public ServiceProvider getServiceProvider(@PathParam("serviceProviderId") final String serviceProviderId)
{
    httpServletResponse.addHeader("Oslc-Core-Version","2.0");
    return ServiceProviderCatalogSingleton.getServiceProvider(httpServletRequest, serviceProviderId);
}