Java 类javax.ws.rs.HeaderParam 实例源码

/**
 * Indirect HTTP POST
 *
 * @see <a href="http://www.w3.org/TR/sparql11-http-rdf-update/#http-post">
 * Section 5.5 "HTTP POST"
 * </a>
 * @param uriInfo JAX-RS {@link UriInfo} object
 * @param type Content-Type HTTP header field
 * @param graphString the "graph" query parameter
 * @param def the "default" query parameter
 * @param chunked the "chunked" query parameter
 * @param in HTTP body as {@link InputStream}
 * @return "204 No Content", if operation was successful
 */
@POST
@Consumes({
    RDFMediaType.RDF_TURTLE,
    RDFMediaType.RDF_YARS,
    RDFMediaType.RDF_XML,
    RDFMediaType.RDF_NTRIPLES,
    RDFMediaType.RDF_XML
})
public Response graphIndirectPost(
        @Context UriInfo uriInfo,
        @HeaderParam("Content-Type") MediaType type,
        @QueryParam("graph") String graphString,
        @QueryParam("default") String def,
        @QueryParam("chunked") String chunked,
        InputStream in) {
    return handleAdd(uriInfo, type, graphString, def, in, chunked, false);
}

@GET
@Produces({"application/hal+json", "application/hal+json;concept=events;v=1"})
@ApiOperation(
        value = "obtain all events emitted by the account-event service", response = EventsRepresentation.class,
        notes = " the events are signalled by this resource as this this is the authoritative resource for all events that " +
                "subscribers to the account service should be able to listen for and react to. In other words this is the authoritative" +
                "feed for the account service",
        authorizations = {
                @Authorization(value = "oauth2", scopes = {}),
                @Authorization(value = "oauth2-cc", scopes = {}),
                @Authorization(value = "oauth2-ac", scopes = {}),
                @Authorization(value = "oauth2-rop", scopes = {}),
                @Authorization(value = "Bearer")
        },
        tags = {"interval", "events"},
        produces = "application/hal+json,  application/hal+json;concept=events;v=1",
        nickname = "listAccountAllEvents"
    )
@ApiResponses(value = {
        @ApiResponse(code = 415, message = "Content type not supported.")
    })
public Response listAll(@Context UriInfo uriInfo, @Context Request request,
                        @HeaderParam("Accept") String accept, @QueryParam("interval") String interval) {
    return eventsProducers.getOrDefault(accept, this::handleUnsupportedContentType)
            .getResponse(uriInfo, request, interval);
}

/**
 * Retrieve the repository resource profile
 *
 * @param rangeValue the range value
 * @return a binary or the triples for the specified node
 * @throws IOException if IO exception occurred
 */
@GET
@Produces({TURTLE_WITH_CHARSET + ";qs=1.0", JSON_LD + ";qs=0.8",
        N3_WITH_CHARSET, N3_ALT2_WITH_CHARSET, RDF_XML, NTRIPLES, TEXT_PLAIN_WITH_CHARSET,
        TURTLE_X, TEXT_HTML_WITH_CHARSET})
public Response getResource(@HeaderParam("Range") final String rangeValue) throws IOException {
    LOGGER.info("GET: {}", externalPath);

    final URI internalURI = createFromPath(externalPath);

    final Container container = getContainerService().find(internalURI);
    if (container == null) {
        if (!isRoot(internalURI)) {
            return Response.status(Response.Status.NOT_FOUND).build();
        } else {
            return getResource(createRoot());
        }
    }

    return getResource(container);
}

/**
 * Creates a new object.
 *
 * This originally used application/octet-stream;qs=1001 as a workaround
 * for JERSEY-2636, to ensure requests without a Content-Type get routed here.
 * This qs value does not parse with newer versions of Jersey, as qs values
 * must be between 0 and 1.  We use qs=1.000 to mark where this historical
 * anomaly had been.
 *
 * @param contentDisposition the content Disposition value
 * @param requestContentType the request content type
 * @param slug the slug value
 * @param requestBodyStream  the request body stream
 * @param link the link value
 * @param digest the digest header
 * @return 201
 * @throws InvalidChecksumException if invalid checksum exception occurred
 * @throws IOException if IO exception occurred
 * @throws MalformedRdfException if malformed rdf exception occurred
 */
@POST
@Consumes({MediaType.APPLICATION_OCTET_STREAM + ";qs=1.000", WILDCARD})
@Produces({TURTLE_WITH_CHARSET + ";qs=1.0", JSON_LD + ";qs=0.8",
        N3_WITH_CHARSET, N3_ALT2_WITH_CHARSET, RDF_XML, NTRIPLES, TEXT_PLAIN_WITH_CHARSET,
        TURTLE_X, TEXT_HTML_WITH_CHARSET, "*/*"})
public Response createObject(@HeaderParam(CONTENT_DISPOSITION) final ContentDisposition contentDisposition,
                             @HeaderParam(CONTENT_TYPE) final MediaType requestContentType,
                             @HeaderParam("Slug") final String slug,
                             @ContentLocation final InputStream requestBodyStream,
                             @HeaderParam(LINK) final String link,
                             @HeaderParam("Digest") final String digest)
        throws InvalidChecksumException, IOException, MalformedRdfException {
    LOGGER.info("POST: {}", externalPath);

    final ContainerService containerService = getContainerService();
    final URI resourceUri = createFromPath(externalPath);

    //check that resource exists
    if (!containerService.exists(resourceUri)) {
        if (!isRoot(resourceUri)) {
            return status(NOT_FOUND).build();
        } else {
            createRoot();
        }
    }

    final String newResourceName = slug == null ? UUID.randomUUID().toString() : slug;
    final String resourcePath = (isRoot(resourceUri) ? "" : resourceUri.getPath());
    final URI newResourceUri = createFromPath(resourcePath + "/" + newResourceName);
    final Container container = containerService.findOrCreate(newResourceUri);
    final Model model = ModelFactory.createDefaultModel();

    model.read(requestBodyStream, container.getIdentifier().toString(), "TTL");
    final Stream<Triple> triples = model.listStatements().toList().stream().map(Statement::asTriple);
    container.updateTriples(triples);
    return created(toExternalURI(container.getIdentifier(), headers)).build();
}

@POST
@Consumes(MediaType.APPLICATION_JSON)
@Path("/updatepassword")
public Response updatePassword(@HeaderParam("token") String token, String body) 
        throws SQLException, Exception{

    Gson gson = new Gson();
    Usuario u = gson.fromJson(body, Usuario.class);  

    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);
    }

    int id = getSubject(token);    
    u.setId(id);
    UsuarioDAO.updatePassword(u);

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

/**
     * Roleリソースのルート.
     * Boxの一覧を返す。
     * @param authzHeader Authorization ヘッダ
     * @return JAX-RS Response Object
     */
//    @Path("")
    @GET
    public final Response list(
            @HeaderParam(HttpHeaders.AUTHORIZATION) final String authzHeader) {
        // アクセス制御
        this.davRsCmp.checkAccessContext(this.davRsCmp.getAccessContext(), CellPrivilege.AUTH_READ);
        EntitiesResponse er = op.getEntities(Box.EDM_TYPE_NAME, null);
        List<OEntity> loe = er.getEntities();
        List<String> sl = new ArrayList<String>();
        sl.add(BOX_PATH_CELL_LEVEL);
        for (OEntity oe : loe) {
            OProperty<String> nameP = oe.getProperty("Name", String.class);
            sl.add(nameP.getValue());
        }
        StringBuilder sb = new StringBuilder();
        for (String s : sl) {
            sb.append(s + "<br/>");
        }
        return Response.ok().entity(sb.toString()).build();
    }

/**
 * returns a Tableau export for the dataset
 * @return
 * @throws DatasetNotFoundException
 * @throws NamespaceException
 */
@GET
@Produces({APPLICATION_TDS, APPLICATION_TDS_DRILL})
public Response get(@HeaderParam(HttpHeaders.HOST) String host) throws DatasetNotFoundException, NamespaceException {
  // make sure path exists
  DatasetConfig datasetConfig = namespace.getDataset(datasetPath.toNamespaceKey());

  ResponseBuilder builder =  Response.ok().entity(datasetConfig);
  if (host == null) {
    return builder.build();
  }

  final String hostOnly;
  int portIndex = host.indexOf(":");
  if (portIndex == -1) {
    hostOnly = host;
  } else {
    hostOnly = host.substring(0, portIndex);
  }

  builder.header(WebServer.X_DREMIO_HOSTNAME, hostOnly);

  return builder.build();
}

@GET
@Secured
@Path("/launchevent/{eventId}")
@Produces(MediaType.APPLICATION_XML)
public SessionInfo launchEvent(@HeaderParam("securityToken") String securityToken, @PathParam("eventId") int eventId) {
    SessionInfo sessionInfo = new SessionInfo();
    SecurityChallenge securityChallenge = new SecurityChallenge();
    securityChallenge.setChallengeId("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
    securityChallenge.setLeftSize(14);
    securityChallenge.setPattern("FFFFFFFFFFFFFFFF");
    securityChallenge.setRightSize(50);
    sessionInfo.setChallenge(securityChallenge);
    sessionInfo.setEventId(eventId);
    EventSessionEntity createEventSession = eventBO.createEventSession(eventId);
    sessionInfo.setSessionId(createEventSession.getId());
    tokenSessionBO.setActiveLobbyId(securityToken, 0L);
    return sessionInfo;
}

@PUT
    @Path("logEvent/{fn_event}")
    public void logEvent(@HeaderParam("uid") String uid,
            String message,
            @PathParam("fn_event") String event)
            throws Exception {
                File dir = new File(Storage_Controller.getBaseFolder());
                File log = new File(dir, "log.txt");

                if(!log.exists()){
                    log.createNewFile();
                }

                SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss");
                String time  = dateFormat.format(new Date());

                BufferedWriter output = new BufferedWriter(new FileWriter(log, true));

//              System.out.println("["+time+"]\t["+uid+"]\t["+event+"]\t"+message+"\n");
                output.write("["+time+"]\t["+uid+"]\t["+event+"]\t"+message+"\n");
                output.flush();
    }

@POST
@Path(LRAOperationAPI.REQUEST)
@Produces(MediaType.TEXT_PLAIN)
@Consumes(MediaType.APPLICATION_JSON)
@LRA(value = LRA.Type.REQUIRED)
public Response requestShipment(@HeaderParam(LRAClient.LRA_HTTP_HEADER) String lraUri, OrderInfo orderInfo) {
    String lraId = LRAClient.getLRAId(lraUri);
    log.info("processing request for LRA " + lraId);

    shipmentService.computeShipment(lraId, orderInfo);

    //stub for compensation scenario
    if ("failShipment".equals(orderInfo.getProduct().getProductId())) {
        return Response
                .status(Response.Status.BAD_REQUEST)
                .entity("Shipment for order " + orderInfo.getOrderId() + " failure")
                .build();
    }

    return Response
            .ok()
            .entity(String.format("Shipment for order %s processed", orderInfo.getOrderId()))
            .build();
}

/**
 * Direct HTTP PUT
 *
 * @see <a href="http://www.w3.org/TR/sparql11-http-rdf-update/#http-put">
 * Section 5.3 "HTTP PUT"
 * </a>
 * @param uriInfo JAX-RS {@link UriInfo} object
 * @param type Content-Type HTTP header field
 * @param chunked the "chunked" query parameter
 * @param in HTTP body as {@link InputStream}
 * @return "204 No Content", if operation was successful
 */
@PUT
@Consumes({
    RDFMediaType.RDF_TURTLE,
    RDFMediaType.RDF_YARS,
    RDFMediaType.RDF_XML,
    RDFMediaType.RDF_NTRIPLES,
    RDFMediaType.RDF_XML
})
@Path("/{graph}")
public Response graphDirectPut(
        @Context UriInfo uriInfo,
        @HeaderParam("Content-Type") MediaType type,
        @QueryParam("chunked") String chunked,
        InputStream in) {
    String graphuri = uriInfo.getAbsolutePath().toASCIIString();
    return handleAdd(uriInfo, type, graphuri, null, in, chunked, true);
}

@Override
public Object provideValue(Parameter parameter, ContainerRequestContext requestContext, ObjectMapper objectMapper) {
    Object returnValue;
    String value = requestContext.getHeaderString(parameter.getAnnotation(HeaderParam.class).value());
    if (value == null) {
        return null;
    }
    else {
        if (String.class.isAssignableFrom(parameter.getType())) {
            returnValue = value;
        }
        else {
            try {
                returnValue = objectMapper.readValue(value, parameter.getType());
            }
            catch (IOException e) {
                throw new IllegalStateException(e);
            }
        }
    }

    return returnValue;
}

@POST
@Path("checkLogin")
@Produces(MediaType.APPLICATION_JSON)
public BaseDTO checkLogin(@HeaderParam("sessionId") String sessionId) {
    logger.info("sessionId : {}", sessionId);

    PimDevice pimDevice = pimDeviceManager.findUniqueBy("sessionId",
            sessionId);
    logger.info("pimDevice : {}", pimDevice);

    if (pimDevice == null) {
        return null;
    }

    BaseDTO result = new BaseDTO();

    result.setCode(200);

    return result;
}

@GET
@Produces({"application/hal+json", "application/hal+json;concept=metadata;v=1"})
@ApiOperation(
        value = "metadata for the events endpoint", response = EventsMetadataRepresentation.class,
        authorizations = {
                @Authorization(value = "oauth2", scopes = {}),
                @Authorization(value = "oauth2-cc", scopes = {}),
                @Authorization(value = "oauth2-ac", scopes = {}),
                @Authorization(value = "oauth2-rop", scopes = {}),
                @Authorization(value = "Bearer")
        },
        notes = " the events are signalled by this resource as this this is the authoritative resource for all events that " +
                "subscribers to the customer service should be able to listen for and react to. In other words this is the authoritative" +
                "feed for the customer service",
        tags = {"events"},
        produces = "application/hal+json,  application/hal+json;concept=metadata;v=1",
        nickname = "getCustomerMetadata"
    )
@ApiResponses(value = {
        @ApiResponse(code = 415, message = "Content type not supported.")
    })
public Response getCustomerServiceMetadata(@Context UriInfo uriInfo, @Context Request request, @HeaderParam("Accept") String accept) {
    return eventMetadataProducers.getOrDefault(accept, this::handleUnsupportedContentType).getResponse(uriInfo, request);
}

@GET
@Produces({"application/hal+json", "application/hal+json;concept=virtualaccount;v=1"})
@ApiOperation(value = "lists accounts", response = VirtualAccountsRepresentation.class,
        authorizations = {
                @Authorization(value = "oauth2", scopes = {}),
                @Authorization(value = "oauth2-cc", scopes = {}),
                @Authorization(value = "oauth2-ac", scopes = {}),
                @Authorization(value = "oauth2-rop", scopes = {}),
                @Authorization(value = "Bearer")
        },
        extensions = {@Extension(name = "roles", properties = {
                @ExtensionProperty(name = "advisor", value = "advisors are allowed getting every virtualaccount"),
                @ExtensionProperty(name = "customer", value = "customer only allowed getting own locations")}
        )},
        produces = "application/hal+json, application/hal+json;concept=locations;v=1",
        notes = "List all locations in a default projection, which is VirtualAccount version 1" +
                "Supported projections and versions are: " +
                "VirtualAccounts in version 1 " +
                "The Accept header for the default version is application/hal+json;concept=virtualaccount;v=1.0.0.... " +
                "The format for the default version is {....}", nickname = "listVirtualAccounts")
@ApiResponses(value = {
        @ApiResponse(code = 415, message = "Content type not supported.")
    })
public Response list(@Context UriInfo uriInfo, @Context Request request, @HeaderParam("Accept") String accept) {
    return accountsProducer.getOrDefault(accept, this::handleUnsupportedContentType).getResponse(uriInfo, request);
}

@GET
@Produces({"application/hal+json", "application/hal+json;concept=events;v=1"})
@ApiOperation(
        value = "obtain all events emitted by the customer-event service", response = EventsRepresentation.class,
        notes = " the events are signalled by this resource as this this is the authoritative resource for all events that " +
                "subscribers to the customers service should be able to listen for and react to. In other words this is the authoritative" +
                "feed for the customers service",
        authorizations = {
                @Authorization(value = "oauth2", scopes = {}),
                @Authorization(value = "oauth2-cc", scopes = {}),
                @Authorization(value = "oauth2-ac", scopes = {}),
                @Authorization(value = "oauth2-rop", scopes = {}),
                @Authorization(value = "Bearer")
        },
        tags = {"interval", "events"},
        produces = "application/hal+json,  application/hal+json;concept=events;v=1",
        nickname = "listAllCustomerEvents"
    )
@ApiResponses(value = {
        @ApiResponse(code = 415, message = "Content type not supported.")
    })
public Response listAllCustomerEvents(@Context UriInfo uriInfo, @Context Request request,
                        @HeaderParam("Accept") String accept, @QueryParam("interval") String interval) {
    return eventsProducers.getOrDefault(accept, this::handleUnsupportedContentType)
            .getResponse(uriInfo, request, interval);
}

@PUT
@Path("/{uuid}/content/{filepath:(.*)}")
@Consumes(MediaType.WILDCARD)
@Produces(MediaType.APPLICATION_JSON)
@ApiOperation(value = "Upload or replace a file")
public Response uploadOrReplaceFile(
    //@formatter:off
    @PathParam("uuid")
        String stagingUuid,
    @PathParam("filepath")
        String filepath,
    @QueryParam("append")
        boolean append,
    @ApiParam(value = APIDOC_UNZIPTO)
    @QueryParam("unzipto")
        String unzipTo,
    @HeaderParam("content-length") @DefaultValue("-1")
        long size,
    @HeaderParam("content-type")
        String contentType,
    InputStream binaryData
    //@formatter:on
) throws IOException;

@GET
public Response get(@PathParam("id") String id, @Context Request request,
                    @HeaderParam("Range") Optional<String> range,
                    @HeaderParam("If-Range") Optional<String> ifRange) {

  Optional<File> video = videosRepository.findById(id);
  if (!video.isPresent()) return Response.status(NOT_FOUND).build();

  Optional<Response> notModifiedResponse = evaluateRequestPreconditions(video.get(), request);
  if (notModifiedResponse.isPresent()) return notModifiedResponse.get();

  if (range.isPresent() && (!ifRange.isPresent() || ifRangePreconditionMatches(video.get(), ifRange.get())))
    return videoPartResponse(video.get(), range.get());

  return fullVideoResponse(video.get());
}

@GET
@Produces({"application/hal+json", "application/hal+json;concept=customers;v=1"})
@ApiOperation(value = "lists customers", response = CustomersRepresentation.class,
        authorizations = {
                @Authorization(value = "oauth2", scopes = {}),
                @Authorization(value = "oauth2-cc", scopes = {}),
                @Authorization(value = "oauth2-ac", scopes = {}),
                @Authorization(value = "oauth2-rop", scopes = {}),
                @Authorization(value = "Bearer")
        },
        extensions = {@Extension(name = "roles", properties = {
                @ExtensionProperty(name = "advisor", value = "advisors are allowed getting every customer"),
                @ExtensionProperty(name = "customer", value = "customer only allowed getting own information")}
        )},
        produces = "application/hal+json, application/hal+json;concept=customers;v=1",
        notes = "List all customers in a default projection, which is Customers version 1" +
                "Supported projections and versions are: " +
                "Customers in version 1 " +
                "The Accept header for the default version is application/hal+json;concept=customers;v=1.0.0.... " +
                "The format for the default version is {....}", nickname = "listCustomers")
@ApiResponses(value = {
        @ApiResponse(code = 415, message = "Content type not supported.")
    })
public Response list(@Context UriInfo uriInfo, @Context Request request, @HeaderParam("Accept") String accept) {
    return customersProducers.getOrDefault(accept, this::handleUnsupportedContentType).getResponse(uriInfo, request);
}

@Override
protected void initParameterAnnotationMgr() {
  super.initParameterAnnotationMgr();

  parameterAnnotationMgr.register(PathParam.class, new PathParamAnnotationProcessor());
  parameterAnnotationMgr.register(FormParam.class, new FormParamAnnotationProcessor());
  parameterAnnotationMgr.register(CookieParam.class, new CookieParamAnnotationProcessor());

  parameterAnnotationMgr.register(HeaderParam.class, new HeaderParamAnnotationProcessor());
  parameterAnnotationMgr.register(QueryParam.class, new QueryParamAnnotationProcessor());
}

@GET
@Path("/clusters")
@Produces(MediaType.APPLICATION_JSON)
public JsonArray getSupportedOpenShiftClusters(@HeaderParam(HttpHeaders.AUTHORIZATION) final String authorization,
                                               @Context HttpServletRequest request) {
    JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();
    Set<OpenShiftCluster> clusters = clusterRegistry.getClusters();
    if (request.getParameterMap().containsKey("all") || openShiftServiceFactory.getDefaultIdentity().isPresent()) {
        // Return all clusters
        clusters
                .stream()
                .map(OpenShiftCluster::getId)
                .forEach(arrayBuilder::add);
    } else {
        final KeycloakService keycloakService = this.keycloakServiceInstance.get();
        clusters.parallelStream().map(OpenShiftCluster::getId)
                .forEach(clusterId ->
                                 keycloakService.getIdentity(clusterId, authorization)
                                         .ifPresent(token -> arrayBuilder.add(clusterId)));
    }

    return arrayBuilder.build();
}

@HEAD
@Path("/repository/{repo}")
public Response repositoryExists(@HeaderParam(HttpHeaders.AUTHORIZATION) final String authorization,
                                 @NotNull @PathParam("repo") String repository) {
    Identity identity = identities.getGitHubIdentity(authorization);
    GitHubService gitHubService = gitHubServiceFactory.create(identity);
    if (gitHubService.repositoryExists(gitHubService.getLoggedUser().getLogin() + "/" + repository)) {
        return Response.ok().build();
    } else {
        return Response.status(Response.Status.NOT_FOUND).build();
    }
}

@HEAD
@Path("/token/github")
public Response gitHubTokenExists(@HeaderParam(HttpHeaders.AUTHORIZATION) final String authorization) {
    Identity identity = identities.getGitHubIdentity(authorization);
    boolean tokenExists = (identity != null);
    if (tokenExists) {
        return Response.ok().build();
    } else {
        return Response.status(Response.Status.NOT_FOUND).build();
    }
}

/**
 * PROPFINDの処理.
 * @param requestBodyXml リクエストボディ
 * @param depth Depthヘッダ
 * @param contentLength Content-Length ヘッダ
 * @param transferEncoding Transfer-Encoding ヘッダ
 * @return JAX-RS Response
 */
@WebDAVMethod.PROPFIND
public Response propfind(final Reader requestBodyXml,
        @HeaderParam(PersoniumCoreUtils.HttpHeaders.DEPTH) final String depth,
        @HeaderParam(HttpHeaders.CONTENT_LENGTH) final Long contentLength,
        @HeaderParam("Transfer-Encoding") final String transferEncoding) {
    // Access Control
    this.davRsCmp.checkAccessContext(this.davRsCmp.getAccessContext(), BoxPrivilege.READ_PROPERTIES);
    return this.davRsCmp.doPropfind(requestBodyXml, depth, contentLength, transferEncoding,
            BoxPrivilege.READ_ACL);

}

@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();
}

@GET
@Path("{regNo}-{accountNo}")
@Produces({"application/hal+json", "application/hal+json;concept=account;v=1", "application/hal+json;concept=account;v=2"})
@ApiOperation(value = "gets the information from a single account", response = AccountRepresentation.class,
        authorizations = {
                @Authorization(value = "oauth2", scopes = {}),
                @Authorization(value = "oauth2-cc", scopes = {}),
                @Authorization(value = "oauth2-ac", scopes = {}),
                @Authorization(value = "oauth2-rop", scopes = {}),
                @Authorization(value = "Bearer")
        },
        extensions = {@Extension(name = "roles", properties = {
                @ExtensionProperty(name = "customer", value = "customer allows getting own account"),
                @ExtensionProperty(name = "advisor", value = "advisor allows getting every account")}
        )},
        produces = "application/hal+json, application/hal+json;concept=account;v=1, application/hal+json;concept=account;v=2",
        notes = "obtain a single account back in a default projection, which is Account version 2" +
                " Supported projections and versions are:" +
                " AccountSparse in version1 and Account in version 2" +
                " The format of the default version is .... - The Accept Header is not marked as required in the " +
                "swagger - but it is needed - we are working on a solution to that", nickname = "getAccount")
@ApiResponses(value = {
        @ApiResponse(code = 404, message = "No account found.")
        })
public Response get(@Context UriInfo uriInfo, @Context Request request,
                    @PathParam("regNo") @Pattern(regexp = "^[0-9]{4}$") String regNo,
                    @PathParam("accountNo") @Pattern(regexp = "^[0-9]+$") String accountNo,
                    @HeaderParam("Accept") String accept) {
    LOGGER.info("Default version of account collected");
    return accountProducers.getOrDefault(accept, this::handleUnsupportedContentType).getResponse(uriInfo, request, regNo, accountNo);
}

@GET
@Consumes(MediaType.APPLICATION_JSON)
@Path("/getid")
public Response  getId(@HeaderParam("token") String token, 
        @QueryParam("id") int id) throws SQLException, Exception {

    if(!Verify(token, "admin")) 
        return Response.status(Response.Status.UNAUTHORIZED).build();

    Gson gson = new Gson();
    Usuario u = UsuarioDAO.retreave(id);

    return Response.status(Response.Status.OK)
            .entity(gson.toJson(u)).build();
}

@GET
@Path("{category}")
@Produces({ "application/hal+json", "application/hal+json;concept=eventcategory;v=1"})
@ApiOperation(value = "obtain all events scoped to a certain category", response = EventsRepresentation.class,
        notes = " the events are signalled by this resource as this this is the authoritative resource for all events that " +
                "subscribers to the account service should be able to listen for and react to. In other words this is the authoritative" +
                "feed for the account service, allowing for subscribers to have these grouped into categories",
        authorizations = {
                @Authorization(value = "oauth2", scopes = {}),
                @Authorization(value = "oauth2-cc", scopes = {}),
                @Authorization(value = "oauth2-ac", scopes = {}),
                @Authorization(value = "oauth2-rop", scopes = {}),
                @Authorization(value = "Bearer")
        },
        tags = {"interval", "events"},
        produces = "application/hal+json,  application/hal+json;concept=eventcategory;v=1",
        nickname = "getAccountEventsByCategory"
    )
@ApiResponses(value = {
        @ApiResponse(code = 415, message = "Content type not supported.")
    })
public Response getByCategory(@Context UriInfo uriInfo, @Context Request request,
                              @HeaderParam("Accept") String accept, @PathParam("category") String category,
                            @QueryParam("interval") String interval) {
    return eventCategoryProducers.getOrDefault(accept, this::handleUnsupportedContentType)
            .getResponse(uriInfo, request, category, interval);
}

@GET
@Produces({ "application/hal+json", "application/hal+json;concept=reconciledtransactions;v=1"})
@ApiOperation(value = "obtain reconciled transactions (added API capabilities not though not implemented)",
        response = ReconciledTransactionsRepresentation.class,
        authorizations = {
                @Authorization(value = "oauth2", scopes = {}),
                @Authorization(value = "oauth2-cc", scopes = {}),
                @Authorization(value = "oauth2-ac", scopes = {}),
                @Authorization(value = "oauth2-rop", scopes = {}),
                @Authorization(value = "Bearer")
        },
        extensions = {@Extension(name = "roles", properties = {
                @ExtensionProperty(name = "customer", value = "customer allows getting from own account"),
                @ExtensionProperty(name = "advisor", value = "advisor allows getting from every account")}
        )},
        tags = {"select", "sort", "elements", "interval", "filter", "embed", "decorator", "reconciled"},
        notes = "obtain a list of all reconciled transactions from an account" +
        "the reconciled transactions are user controlled checks and notes for transactions " +
        "such as - Yes I have verified that this transaction was correct and thus it is reconciled",
        produces = "application/hal+json, application/hal+json;concept=reconciledtransactions;v=1",
        nickname = "listReconciledTransactions")
@ApiResponses(value = {
        @ApiResponse(code = 415, message = "Content type not supported.")
    })
public Response list(@Context UriInfo uriInfo, @Context Request request,
        @HeaderParam("Accept") String accept, @PathParam("regNo") String regNo, @PathParam("accountNo") String accountNo
                     ) {
    return reconciledTxsProducers.getOrDefault(accept, this::handleUnsupportedContentType)
            .getResponse(uriInfo, request, regNo, accountNo);
}

/**
 * @param cookieAuthValue クッキー内の p_cookieキーに指定された値
 * @param cookiePeer p_cookie_peerクエリに指定された値
 * @param authzHeaderValue Authorization ヘッダ
 * @param host Host ヘッダ
 * @param xPersoniumUnitUser ヘッダ
 * @param uriInfo UriInfo
 * @return UnitCtlResourceオブジェクト
 */
@Path("__ctl")
public final UnitCtlResource ctl(
        @CookieParam(P_COOKIE_KEY) final String cookieAuthValue,
        @QueryParam(COOKIE_PEER_QUERY_KEY) final String cookiePeer,
        @HeaderParam(HttpHeaders.AUTHORIZATION) final String authzHeaderValue,
        @HeaderParam(HttpHeaders.HOST) final String host,
        @HeaderParam(PersoniumCoreUtils.HttpHeaders.X_PERSONIUM_UNIT_USER) final String xPersoniumUnitUser,
        @Context final UriInfo uriInfo) {
    AccessContext ac = AccessContext.create(authzHeaderValue,
            uriInfo, cookiePeer, cookieAuthValue, null, uriInfo.getBaseUri().toString(),
            host, xPersoniumUnitUser);
    return new UnitCtlResource(ac, uriInfo);
}

/**
 * process PROPFIND Method.
 * @param requestBodyXml request body
 * @param depth Depth Header
 * @param contentLength Content-Length Header
 * @param transferEncoding Transfer-Encoding Header
 * @return JAX-RS response object
 */
@WebDAVMethod.PROPFIND
public Response propfind(Reader requestBodyXml,
        @HeaderParam(PersoniumCoreUtils.HttpHeaders.DEPTH) String depth,
        @HeaderParam(HttpHeaders.CONTENT_LENGTH) Long contentLength,
        @HeaderParam("Transfer-Encoding") String transferEncoding) {
    // Access Control
    cellSnapshotCellRsCmp.checkAccessContext(cellSnapshotCellRsCmp.getAccessContext(), CellPrivilege.ROOT);
    return cellSnapshotCellRsCmp.doPropfind(requestBodyXml, depth, contentLength, transferEncoding,
            CellPrivilege.ROOT);
}

@GET
@Path("{latitude}-{longitude}")
@Produces({"application/hal+json", "application/hal+json;concept=location;v=1", "application/hal+json;concept=location;v=2"})
@ApiOperation(value = "gets the information from a single position", response = LocationRepresentation.class,
        authorizations = {
                @Authorization(value = "oauth2", scopes = {}),
                @Authorization(value = "oauth2-cc", scopes = {}),
                @Authorization(value = "oauth2-ac", scopes = {}),
                @Authorization(value = "oauth2-rop", scopes = {}),
                @Authorization(value = "Bearer")
        },
        extensions = {@Extension(name = "roles", properties = {
                @ExtensionProperty(name = "customer", value = "customer allows getting own information"),
                @ExtensionProperty(name = "advisor", value = "advisor allows getting all information")}
        )},
        produces = "application/hal+json, application/hal+json;concept=location;v=1, application/hal+json;concept=location;v=2",
        notes = "obtain a single customer back in a default projection, which is Location version 2" +
                " Supported projections and versions are:" +
                " Location in version1 and Location in version 2" +
                " The format of the default version is .... - The Accept Header is not marked as required in the " +
                "swagger - but it is needed - we are working on a solution to that", nickname = "getLocation")
@ApiResponses(value = {
        @ApiResponse(code = 404, message = "location not found.")
        })
public Response get(@Context UriInfo uriInfo, @Context Request request,
                    @PathParam("latitude") @Pattern(regexp = "^[0-9]+.[0-9]+,[0-9]*$") String latitude,
                    @PathParam("longitude") @Pattern(regexp = "^[0-9]+.[0-9]+,[0-9]*$") String longitude,
                    @HeaderParam("Accept") String accept) {
    LOGGER.info("Default version of location collected");
    return locationProducers.getOrDefault(accept, this::handleUnsupportedContentType)
            .getResponse(uriInfo, request, latitude, longitude);
}

@GET
@Secured
@Path("/categories")
@Produces(MediaType.APPLICATION_XML)
public ArrayOfCategoryTrans categories(@HeaderParam("securityToken") String securityToken) {
    Long activePersonaId = tokenBO.getActivePersonaId(securityToken);
    ArrayOfCategoryTrans arrayOfCategoryTrans = new ArrayOfCategoryTrans();
    List<CategoryEntity> listCategoryEntity = productBO.categories();
    for (CategoryEntity entity : listCategoryEntity) {
        CategoryTrans categoryTrans = new CategoryTrans();
        categoryTrans.setCatalogVersion(Integer.parseInt(entity.getCatalogVersion()));
        categoryTrans.setDisplayName(entity.getDisplayName());
        categoryTrans.setFilterType(entity.getFilterType());
        categoryTrans.setIcon(entity.getIcon());
        categoryTrans.setId(entity.getIdentifiant().toString());
        categoryTrans.setLongDescription(entity.getLongDescription());
        categoryTrans.setName(entity.getName());
        categoryTrans.setPriority(entity.getPriority());
        categoryTrans.setProducts(productBO.getVinylByCategory(entity, activePersonaId));
        categoryTrans.setShortDescription(entity.getShortDescription());
        categoryTrans.setShowInNavigationPane(entity.getShowInNavigationPane());
        categoryTrans.setShowPromoPage(entity.getShowPromoPage());
        categoryTrans.setWebIcon(entity.getWebIcon());
        arrayOfCategoryTrans.getCategoryTrans().add(categoryTrans);
    }
    return arrayOfCategoryTrans;
}

@GET
@Secured
@Path("/notifycoincollected")
@Produces(MediaType.APPLICATION_XML)
public String notifyCoinCollected(@HeaderParam("securityToken") String securityToken, @QueryParam("coins") Integer coins) {
    Long activePersonaId = tokenSessionBO.getActivePersonaId(securityToken);
    return eventsBO.notifyCoinCollected(activePersonaId, coins);
}

@GET    
@Consumes("application/json")
@Produces("application/json")
@Path("vehicles/{vehicleId}/registered-points")
String getLastRegisteredPoints(@HeaderParam("Authorization") String authorization,
        @PathParam("vehicleId") int id,
        @QueryParam("size")int size,
        @QueryParam("sort")String sort);

@OPTIONS
@Produces(MediaType.APPLICATION_JSON + "; charset=UTF-8")
@Path("/tagnames")
public Response corsPreflightTagNames(@HeaderParam("Access-Control-Request-Headers") final String requestHeaders,
        @HeaderParam("Access-Control-Request-Method") final String requestMethod)
{
    ResponseBuilder responseBuilder = getCorsPreflightResponseBuilder(requestHeaders, requestMethod);
    return (responseBuilder.build());
}

@GET
@Secured
@Path("/gettreasurehunteventsession")
@Produces(MediaType.APPLICATION_XML)
public TreasureHuntEventSession getTreasureHuntEventSession(@HeaderParam("securityToken") String securityToken) {
    Long activePersonaId = tokenSessionBO.getActivePersonaId(securityToken);
    return eventsBO.getTreasureHuntEventSession(activePersonaId);
}

@PUT
@Path("/contents/{path}/{fileName}")
@Produces("application/json; charset=utf-8")
@Consumes("application/json; charset=utf-8")
@GZIP
public GitHubResponse createFile(@PathParam("user") String user,
        @PathParam("repository") String repository,
        @PathParam("path") String path,
        @PathParam("fileName") String fileName,
        @HeaderParam("Authorization") String authorization,
        GitHubCreateFileRequest content);

@GET    
@Consumes("application/json")
@Path("/{id}/registered-points")
String getLastRegisteredPoints(@HeaderParam("Authorization") String authorization,
        @PathParam("id") int id,
        @QueryParam("imei")String imei,         
        @QueryParam("size")int size,
        @QueryParam("sort")String sort);

@POST
@Secured
@Path("GetPermanentSession")
@Produces(MediaType.APPLICATION_XML)
public UserInfo getPermanentSession(@HeaderParam("userId") Long userId) {
    tokenBO.deleteByUserId(userId);
    String randomUUID = tokenBO.createToken(userId);
    UserInfo userInfo = userBO.getUserById(userId);
    userInfo.getUser().setSecurityToken(randomUUID);
    userBO.createXmppUser(userInfo);
    return userInfo;
}