@Override
public Response run(JerseyResourceDelegateContext context) {
JerseyResourceDelegateContextKey<String> queryIdKey =
JerseyResourceDelegateContextKey.valueOf(queryIdKeyName, String.class);
String queryId = context.get(queryIdKey);
JerseyResourceDelegateContextKey<String> printTypeKey =
JerseyResourceDelegateContextKey.valueOf(printTypeKeyName, String.class);
String printType = context.get(printTypeKey);
JerseyResourceDelegateContextKey<MasterContext> masterContextKey =
JerseyResourceDelegateContextKey.valueOf(
JerseyResourceDelegateUtil.MasterContextKey, MasterContext.class);
MasterContext masterContext = context.get(masterContextKey);
QueryId queryIdObj = TajoIdUtils.parseQueryId(queryId);
QueryManager queryManager = masterContext.getQueryJobManager();
QueryInProgress queryInProgress = queryManager.getQueryInProgress(queryIdObj);
QueryInfo queryInfo = null;
if (queryInProgress == null) {
queryInfo = queryManager.getFinishedQuery(queryIdObj);
} else {
queryInfo = queryInProgress.getQueryInfo();
}
if (queryInfo != null) {
if (briefPrint.equalsIgnoreCase(printType)) {
queryInfo = getBriefQueryInfo(queryInfo);
}
return Response.ok(queryInfo).build();
} else {
return Response.status(Status.NOT_FOUND).build();
}
}
@GET
@Path("/{id}")
public Response get(@PathParam("id") int id, @Context Request request) {
// Create cache control header
CacheControl cc = new CacheControl();
// Set max age to one day
cc.setMaxAge(86400);
Response.ResponseBuilder rb = null;
// Calculate the ETag on last modified date of user resource
EntityTag etag = new EntityTag(UserDao.getLastModifiedById(id).hashCode() + "");
// Verify if it matched with etag available in http request
rb = request.evaluatePreconditions(etag);
// If ETag matches the rb will be non-null;
// Use the rb to return the response without any further processing
if (rb != null) {
return rb.cacheControl(cc).tag(etag).build();
}
// If rb is null then either it is first time request; or resource is modified
// Get the updated representation and return with Etag attached to it
rb = Response.ok(UserDao.get(id).get()).cacheControl(cc).tag(etag);
return rb.build();
}
@POST
public Response add(final String body) {
logger.debug("Adding a new user with body {}", body);
User user = userJsonConverter.convertFrom(body);
if (user.getUserType().equals(User.UserType.EMPLOYEE)) {
return Response.status(HttpCode.FORBIDDEN.getCode()).build();
}
HttpCode httpCode = HttpCode.CREATED;
OperationResult result;
try {
user = userService.add(user);
result = OperationResult.success(JsonUtils.getJsonElementWithId(user.getId()));
} catch (final FieldNotValidException e) {
httpCode = HttpCode.VALIDATION_ERROR;
logger.error("One of the fields of the user is not valid", e);
result = getOperationResultInvalidField(RESOURCE_MESSAGE, e);
} catch (final UserExistException e) {
httpCode = HttpCode.VALIDATION_ERROR;
logger.error("There is already an user for the given email", e);
result = getOperationResultExists(RESOURCE_MESSAGE, "email");
}
logger.debug("Returning the operation result after adding user: {}", result);
return Response.status(httpCode.getCode())
.entity(OperationResultJsonWriter.toJson(result))
.build();
}
@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;
}
@Path("devices/{deviceLibraryIdentifier}/registrations/{passTypeIdentifier}/{serialNumber}")
@DELETE
public Response unregisterDevice(
@PathParam("deviceLibraryIdentifier") String deviceLibraryIdentifier,
@PathParam("passTypeIdentifier") String passTypeIdentifier,
@PathParam("serialNumber") String serialNumber,
@HeaderParam("Authorization") @DefaultValue("") String authorization) {
PassDAO pass = new PassDAO(passTypeIdentifier, serialNumber);
if (!pass.retrieve()) {
// pass not found
// response is UNAUTHORIZED in order to prevent trial/error/guessing for passes
log.warn("pass does not exist: {}", serialNumber);
return Response.status(Response.Status.UNAUTHORIZED).build();
}
if (!AuthUtil.isAuthorized(authorization, pass.getAuthenticationToken())) {
log.warn("invalid authorization: {}", authorization);
return Response.status(Response.Status.UNAUTHORIZED).build();
}
DeviceDAO device = new DeviceDAO(deviceLibraryIdentifier);
if (device.retrieve()) {
device.removeRegistration(passTypeIdentifier, serialNumber);
if (device.store()) {
return Response.status(Response.Status.OK).build();
} else {
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
}
}
return Response.status(Response.Status.NOT_FOUND).build();
}
@PUT
@Path("/{id}/password")
@PermitAll
public Response updatePassword(@PathParam("id") final Long id, final String body) {
logger.debug("Updating the password for user {}", id);
if (!securityContext.isUserInRole(Roles.ADMINISTRATOR.name())) {
if (!isLoggedUser(id)) {
return Response.status(HttpCode.FORBIDDEN.getCode()).build();
}
}
HttpCode httpCode = HttpCode.OK;
OperationResult result;
try {
userService.updatePassword(id, getPasswordFromJson(body));
result = OperationResult.success();
} catch (UserNotFoundException e) {
httpCode = HttpCode.NOT_FOUND;
logger.error("No user found for the given id", e);
result = getOperationResultNotFound(RESOURCE_MESSAGE);
}
logger.debug("Returning the operation result after updating user password: {}", result);
return Response.status(httpCode.getCode())
.entity(OperationResultJsonWriter.toJson(result))
.build();
}
@PUT
@Path("/{id}")
public Response update(@PathParam("id") int id) {
// Update the User resource
UserDao.update(UserDao.get(id).get());
return Response.status(200).build();
}
@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();
}
@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();
}
@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 Response run(JerseyResourceDelegateContext context) {
JerseyResourceDelegateContextKey<String> sessionIdKey =
JerseyResourceDelegateContextKey.valueOf(sessionIdKeyName, String.class);
String sessionId = context.get(sessionIdKey);
JerseyResourceDelegateContextKey<SubmitQueryRequest> submitQueryRequestKey =
JerseyResourceDelegateContextKey.valueOf(
submitQueryRequestKeyName, SubmitQueryRequest.class);
SubmitQueryRequest request = context.get(submitQueryRequestKey);
JerseyResourceDelegateContextKey<MasterContext> masterContextKey =
JerseyResourceDelegateContextKey.valueOf(
JerseyResourceDelegateUtil.MasterContextKey, MasterContext.class);
MasterContext masterContext = context.get(masterContextKey);
if (sessionId == null || sessionId.isEmpty()) {
return ResourcesUtil.createBadRequestResponse(LOG, "Session Id is null or empty string.");
}
if (request == null || request.getQuery() == null || request.getQuery().isEmpty()) {
return ResourcesUtil.createBadRequestResponse(LOG, "query is null or emptry string.");
}
Session session;
try {
session = masterContext.getSessionManager().getSession(sessionId);
} catch (InvalidSessionException e) {
return ResourcesUtil.createBadRequestResponse(
LOG, "Provided session id (" + sessionId + ") is invalid.");
}
SubmitQueryResponse response =
masterContext.getGlobalEngine().executeQuery(session, request.getQuery(), false);
if (ReturnStateUtil.isError(response.getState())) {
return ResourcesUtil.createExceptionResponse(LOG, response.getState().getMessage());
} else {
JerseyResourceDelegateContextKey<UriInfo> uriInfoKey =
JerseyResourceDelegateContextKey.valueOf(
JerseyResourceDelegateUtil.UriInfoKey, UriInfo.class);
UriInfo uriInfo = context.get(uriInfoKey);
QueryId queryId = new QueryId(response.getQueryId());
URI queryURI =
uriInfo
.getBaseUriBuilder()
.path(QueryResource.class)
.path(QueryResource.class, "getQuery")
.build(queryId.toString());
GetSubmitQueryResponse queryResponse = new GetSubmitQueryResponse();
if (queryId.isNull() == false) {
queryResponse.setUri(queryURI);
}
queryResponse.setResultCode(response.getState().getReturnCode());
queryResponse.setQuery(request.getQuery());
return Response.status(Status.OK).entity(queryResponse).build();
}
}
@GET
@Path("/cluster")
public Response clusterIndex(@Context UriInfo uriInfo) {
final int desired = store.state().desiredInstances().getValue();
final int running = store.state().crateInstances().size();
final HashMap<String, List<String>> excluded = store.state().excludedSlaves();
return Response.ok()
.entity(
new GenericAPIResponse() {
@Override
public Object getMessage() {
return new HashMap<String, Object>() {
{
put("mesosMaster", conf.mesosMaster());
put(
"instances",
new HashMap<String, Integer>() {
{
put("desired", desired);
put("running", running);
}
});
put("excludedSlaves", excluded);
put(
"cluster",
new HashMap<String, Object>() {
{
put("version", conf.version);
put("name", conf.clusterName);
put("httpPort", conf.httpPort);
put("nodeCount", conf.nodeCount);
}
});
put(
"resources",
new HashMap<String, Double>() {
{
put("memory", conf.resMemory);
put("heap", conf.resHeap);
put("cpus", conf.resCpus);
put("disk", conf.resDisk);
}
});
put(
"api",
new HashMap<String, Integer>() {
{
put("apiPort", conf.apiPort);
}
});
}
};
}
})
.build();
}
private Response sendAuthorizationCodeResponse(AuthorizationRequest authReq) {
String uri = authReq.getRedirectUri();
String authorizationCode = getAuthorizationCodeValue();
authReq.setAuthorizationCode(authorizationCode);
authorizationRequestRepository.save(authReq);
uri = uri + appendQueryMark(uri) + "code=" + authorizationCode + appendStateParameter(authReq);
return Response.seeOther(UriBuilder.fromUri(uri).build())
.cacheControl(cacheControlNoStore())
.header("Pragma", "no-cache")
.build();
}
@GET
@Path("/{id}")
@RolesAllowed({"ADMINISTRATOR"})
public Response find(@PathParam("id") final Long id) {
logger.debug("Find user by id: {}", id);
Response.ResponseBuilder responseBuilder;
try {
User user = userService.find(id);
OperationResult result =
OperationResult.success(userJsonConverter.convertToJsonElement(user));
responseBuilder =
Response.status(HttpCode.OK.getCode()).entity(OperationResultJsonWriter.toJson(result));
logger.debug("User found by id: {}", user);
} catch (UserNotFoundException e) {
logger.error("No user found for id", id);
responseBuilder = Response.status(HttpCode.NOT_FOUND.getCode());
}
return responseBuilder.build();
}
@Path("devices/{deviceLibraryIdentifier}/registrations/{passTypeIdentifier}")
@GET
public Response getSerialNumbersOfPassesAssociatedWithDevice(
@PathParam("deviceLibraryIdentifier") String deviceLibraryIdentifier,
@PathParam("passTypeIdentifier") String passTypeIdentifier,
@QueryParam("passesUpdatedSince") @DefaultValue("") String passesUpdatedSince) {
DeviceDAO device = new DeviceDAO(deviceLibraryIdentifier);
ListOfPasses passes = new ListOfPasses();
passes.setLastUpdated(DateUtil.getTimeStamp());
if (device.retrieve()) {
for (Registration reg : device.getRegistrations()) {
if (passTypeIdentifier.equals(reg.getPassTypeIdentifier())) {
passes.addSerialNumber(reg.getSerialNumber());
}
}
}
if (passes.getSerialNumbers().size() > 0) {
return Response.status(Response.Status.OK).entity(passes.toJson(Pass.PRETTY)).build();
}
return Response.status(Response.Status.NO_CONTENT).build();
}
@GET
@Path("/setOperatorToKen")
@ApiOperation(
value = "A quick way to sets value of operator to Ken profile",
notes = "For testing purposes",
response = String.class,
produces = MediaType.TEXT_PLAIN)
public Response setOperatorToKen() throws NotFoundException {
if (PersonData.get(PersonData.KEN.getUpi()) == null) PersonData.replace(PersonData.KEN);
return Response.ok().entity(PersonData.setOperator(PersonData.KEN.getUpi())).build();
}
@Path("version")
@GET
@Produces(MediaType.APPLICATION_JSON)
public Response getServiceVersion() {
return Response.status(Response.Status.OK)
.entity(
"mobile-passes service version "
+ String.valueOf(ServiceConst.MAJOR_VERSION)
+ "."
+ String.valueOf(ServiceConst.MINOR_VERSION))
.build();
}
/**
* The "token endpoint" as described in <a
* href="http://tools.ietf.org/html/draft-ietf-oauth-v2-31#section-3.2">Section 3.2</a> of the
* OAuth spec.
*
* @param authorization the HTTP Basic auth header.
* @param formParameters the request parameters
* @return the response
*/
@POST
@Path("/token")
@Produces(MediaType.APPLICATION_JSON)
@Consumes("application/x-www-form-urlencoded")
public Response token(
@HeaderParam("Authorization") String authorization,
final MultivaluedMap<String, String> formParameters) {
// Convert incoming parameters into internal form and validate them
AccessTokenRequest accessTokenRequest =
AccessTokenRequest.fromMultiValuedFormParameters(formParameters);
BasicAuthCredentials credentials =
BasicAuthCredentials.createCredentialsFromHeader(authorization);
ValidationResponse vr = oAuth2Validator.validate(accessTokenRequest, credentials);
if (!vr.valid()) {
return sendErrorResponse(vr);
}
// The request looks valid, attempt to process
String grantType = accessTokenRequest.getGrantType();
AuthorizationRequest request;
try {
if (GRANT_TYPE_AUTHORIZATION_CODE.equals(grantType)) {
request = authorizationCodeToken(accessTokenRequest);
} else if (GRANT_TYPE_REFRESH_TOKEN.equals(grantType)) {
request = refreshTokenToken(accessTokenRequest);
} else if (GRANT_TYPE_CLIENT_CREDENTIALS.equals(grantType)) {
request = clientCredentialToken(accessTokenRequest);
} else if (GRANT_TYPE_PASSWORD.equals(grantType)) {
request = passwordToken(accessTokenRequest);
} else {
return sendErrorResponse(ValidationResponse.UNSUPPORTED_GRANT_TYPE);
}
} catch (ValidationResponseException e) {
return sendErrorResponse(e.v);
}
AccessToken token = createAccessToken(request, false);
AccessTokenResponse response =
new AccessTokenResponse(
token.getToken(),
BEARER,
token.getExpiresIn(),
token.getRefreshToken(),
StringUtils.join(token.getScopes(), ' '));
return Response.ok()
.entity(response)
.cacheControl(cacheControlNoStore())
.header("Pragma", "no-cache")
.build();
}
@GET
@Path("/{type}")
@Produces(MediaType.APPLICATION_JSON)
public Response getItemsByType(@PathParam("type") String type) {
System.out.println("get item by type = " + type);
List<Item> items = ItemDao.getItemsByType(type);
final GenericEntity<List<Item>> entity = new GenericEntity<List<Item>>(items) {};
return Response.ok()
.entity(entity)
.header("Access-Control-Allow-Origin", "*")
.header("Access-Control-Allow-Methods", "POST, GET")
.build();
}
@PUT
@Path("/{id}")
@PermitAll
public Response update(@PathParam("id") final Long id, final String body) {
logger.debug("Updating the user {} with body {}", id, body);
if (!securityContext.isUserInRole(Roles.ADMINISTRATOR.name())) {
if (!isLoggedUser(id)) {
return Response.status(HttpCode.FORBIDDEN.getCode()).build();
}
}
final User user = userJsonConverter.convertFrom(body);
user.setId(id);
HttpCode httpCode = HttpCode.OK;
OperationResult result;
try {
userService.update(user);
result = OperationResult.success();
} catch (FieldNotValidException e) {
httpCode = HttpCode.VALIDATION_ERROR;
logger.error("One of the fields of the user is not valid", e);
result = getOperationResultInvalidField(RESOURCE_MESSAGE, e);
} catch (UserExistException e) {
httpCode = HttpCode.VALIDATION_ERROR;
logger.error("There is already an user for the given email", e);
result = getOperationResultExists(RESOURCE_MESSAGE, "email");
} catch (UserNotFoundException e) {
httpCode = HttpCode.NOT_FOUND;
logger.error("No user found for the given id", e);
result = getOperationResultNotFound(RESOURCE_MESSAGE);
}
logger.debug("Returning the operation result after updating user: {}", result);
return Response.status(httpCode.getCode())
.entity(OperationResultJsonWriter.toJson(result))
.build();
}
@GET
@Path("/")
@Produces(MediaType.APPLICATION_JSON)
public Response getItems() {
System.out.println("get all items ");
List<Item> items = ItemDao.getItems();
final GenericEntity<List<Item>> entity = new GenericEntity<List<Item>>(items) {};
return Response.ok()
.entity(entity)
.header("Access-Control-Allow-Origin", "*")
.header("Access-Control-Allow-Methods", "POST, GET")
.build();
}
@Path("passes/{passTypeIdentifier}/{serialNumber}")
@GET
public Response getLatestVersionOfPass(
@PathParam("passTypeIdentifier") String passTypeIdentifier,
@PathParam("serialNumber") String serialNumber,
@HeaderParam("Authorization") @DefaultValue("") String authorization,
@HeaderParam("If-Modified-Since") @DefaultValue("") String ifModifedSince) {
PassDAO pass = new PassDAO(serialNumber);
if (!pass.retrieve()) {
// pass not found
// response is UNAUTHORIZED in order to prevent trial/error/guessing for passes
log.warn("pass does not exist: {}", serialNumber);
return Response.status(Response.Status.UNAUTHORIZED).build();
}
if (!AuthUtil.isAuthorized(authorization, pass.getAuthenticationToken())) {
log.warn("invalid authorization: {}", authorization);
return Response.status(Response.Status.UNAUTHORIZED).build();
}
return Response.status(Response.Status.OK).entity(pass.toJson()).build();
}
@GET
@Path("/{upi}")
@ApiOperation(
value = "Get person by upi",
notes = "Use pck123 as upi. Use 20 as api_key (or 123 to test FORBIDDEN with message)",
response = Profile.class)
@ApiResponses(
value = {
@ApiResponse(code = 400, message = "Invalid upi value"),
@ApiResponse(code = 401, message = "Invalid api_key"),
@ApiResponse(code = 403, message = "Forbidden"),
@ApiResponse(code = 404, message = "Person not found")
})
@Produces(MediaType.APPLICATION_JSON)
public Response getByUpi(
@HeaderParam("api_key") String api_key,
@ApiParam(value = "upi of a person", required = true, allowMultiple = true) @PathParam("upi")
String upi)
throws NotFoundException {
if (api_key == null || api_key.charAt(api_key.length() - 1) != '0') {
return Response.status(Response.Status.FORBIDDEN)
.build(); // .entity("Invalid api key '"+api_key+"'").build();
} else if (api_key.equals("123")) {
return Response.status(Response.Status.FORBIDDEN)
.entity("Invalid api key '" + api_key + "'")
.build();
}
// return Response.status(Status.OK).entity(dto).type(request.getContentType()).build();
Profile result = PersonData.get(upi);
if (result != null) return Response.ok().entity(result).build();
if (upi != null && upi.equals("pck123"))
return Response.ok().entity(new Profile("Patrick", "pck123")).build();
else
// throw new NotFoundException(400, "Invalid upi key");
return Response.status(Response.Status.NOT_FOUND).build();
}
@POST
@Path("/authenticate")
@PermitAll
public Response findByEmailAndPassword(final String body) {
logger.debug("Find user by email and password");
Response.ResponseBuilder responseBuilder;
try {
User userWithEmailAndPassword = getUserWithEmailAndPasswordFromJson(body);
User user =
userService.find(
userWithEmailAndPassword.getEmail(), userWithEmailAndPassword.getPassword());
OperationResult result =
OperationResult.success(userJsonConverter.convertToJsonElement(user));
responseBuilder =
Response.status(HttpCode.OK.getCode()).entity(OperationResultJsonWriter.toJson(result));
logger.debug("User found by email/password: {}", user);
} catch (UserNotFoundException e) {
logger.error("No user found for email/password");
responseBuilder = Response.status(HttpCode.NOT_FOUND.getCode());
}
return responseBuilder.build();
}
@Path("log")
@POST
@Consumes(MediaType.APPLICATION_JSON)
public Response doLog(String logsAsJson) {
ServiceLogs logs = ServiceLogs.fromJson(logsAsJson);
LogDAO logger = new LogDAO();
log.info("Apple wants to tell us something:");
for (String line : logs.getLogs()) {
logger.store(line);
log.info("{}", line);
}
return Response.status(Response.Status.OK).build();
}
@Override
public Response run(JerseyResourceDelegateContext context) {
JerseyResourceDelegateContextKey<String> stateKey =
JerseyResourceDelegateContextKey.valueOf(stateKeyName, String.class);
String state = context.get(stateKey);
JerseyResourceDelegateContextKey<Long> startTimeKey =
JerseyResourceDelegateContextKey.valueOf(startTimeKeyName, Long.class);
long startTime = context.get(startTimeKey);
JerseyResourceDelegateContextKey<Long> endTimeKey =
JerseyResourceDelegateContextKey.valueOf(endTimeKeyName, Long.class);
long endTime = context.get(endTimeKey);
JerseyResourceDelegateContextKey<MasterContext> masterContextKey =
JerseyResourceDelegateContextKey.valueOf(
JerseyResourceDelegateUtil.MasterContextKey, MasterContext.class);
MasterContext masterContext = context.get(masterContextKey);
TajoProtos.QueryState queryState = null;
try {
if (state != null && !state.isEmpty()) {
queryState = TajoProtos.QueryState.valueOf(state);
}
} catch (Exception e) {
return ResourcesUtil.createBadRequestResponse(LOG, state + " is not a valid query state.");
}
Map<String, List<QueryInfo>> queriesMap = new HashMap<>();
List<QueryInfo> queriesInfo = new ArrayList<>();
QueryManager queryManager = masterContext.getQueryJobManager();
for (QueryInProgress queryInProgress : queryManager.getSubmittedQueries()) {
queriesInfo.add(queryInProgress.getQueryInfo());
}
for (QueryInProgress queryInProgress : queryManager.getRunningQueries()) {
queriesInfo.add(queryInProgress.getQueryInfo());
}
queriesInfo.addAll(queryManager.getFinishedQueries());
if (state != null) {
queriesInfo = selectQueriesInfoByState(queriesInfo, queryState);
}
if (startTime > 0 || endTime > 0) {
queriesInfo = selectQueriesInfoByTime(queriesInfo, startTime, endTime);
}
queriesMap.put("queries", queriesInfo);
return Response.ok(queriesMap).build();
}
@Path("/devices/{deviceLibraryIdentifier}/registrations/{passTypeIdentifier}/{serialNumber}")
@POST
public Response registerDeviceForPassPushNotifications(
@PathParam("deviceLibraryIdentifier") String deviceLibraryIdentifier,
@PathParam("passTypeIdentifier") String passTypeIdentifier,
@PathParam("serialNumber") String serialNumber,
@HeaderParam("Authorization") @DefaultValue("") String authorization,
String jsonDictionaryWithPushToken) {
PassDAO pass = new PassDAO(serialNumber);
if (!pass.retrieve()) {
// pass not found
// response is UNAUTHORIZED in order to prevent trial/error/guessing for passes
log.warn("pass does not exist: {}", serialNumber);
return Response.status(Response.Status.UNAUTHORIZED).build();
}
if (!AuthUtil.isAuthorized(authorization, pass.getAuthenticationToken())) {
log.warn("invalid authorization: {}", authorization);
return Response.status(Response.Status.UNAUTHORIZED).build();
}
String pushToken = ServiceUtil.getPushTokenFromBody(jsonDictionaryWithPushToken);
DeviceDAO device = new DeviceDAO(deviceLibraryIdentifier);
device.retrieve();
if (device.addRegistration(passTypeIdentifier, serialNumber, pushToken) == 1) {
// really added a new record
if (device.store()) {
return Response.status(Response.Status.CREATED).build();
}
} else {
// nothing added, was already in list
return Response.status(Response.Status.OK).build();
}
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
}
@RolesAllowed({"administrador", "registrado"})
@Path("/modificarPASSWORD/{login}")
@POST
public Response modificarPASSWORD(
@FormParam("password") String password, @PathParam("login") String login)
throws SQLException {
UserDAO userdao = new UserDAOImpl();
try {
userdao.insertarPASWWORD(login, password);
} catch (SQLException e) {
throw new InternalServerErrorException();
}
return Response.ok().build();
}
@PUT
@Path("/person/me/{myUpi}")
@ApiOperation(
value = "Currently logged person. This is what is returned me call to /me",
notes = "This is a mockup",
response = String.class,
produces = MediaType.TEXT_PLAIN)
@ApiResponses(
value = {
@ApiResponse(code = 200, message = "Previous upi"),
@ApiResponse(code = 400, message = "Unexpected error")
})
public Response setMe(@ApiParam(value = "my upi") @PathParam("myUpi") String newUpi) {
return Response.ok().entity(PersonData.setMe(newUpi)).build();
}
@RolesAllowed({"administrador", "registrado"})
@Path("/eliminar/{login}")
@DELETE
public Response eliminarUser(@PathParam("login") String login) throws UserNoExisteException {
UserDAO userdao = new UserDAOImpl();
try {
if (!userdao.eliminar_Usuario(login))
throw new WebApplicationException("Este usuario no existe ", Response.Status.CONFLICT);
} catch (SQLException e) {
throw new InternalServerErrorException();
}
return Response.ok().build();
}