@POST @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public Response importVine(Vine vine) { Response.ResponseBuilder builder = null; try { // Verify and save serviceVin.save(vine); // Create an "ok" response builder = Response.ok(); } catch (ConstraintViolationException ce) { // Handle bean validation issues builder = createViolationResponse(ce.getConstraintViolations()); } catch (ValidationException e) { // Handle the unique constrain violation Map<String, String> responseObj = new HashMap<String, String>(); responseObj.put("email", "Email taken"); builder = Response.status(Response.Status.CONFLICT).entity(responseObj); } catch (Exception e) { // Handle generic exceptions Map<String, String> responseObj = new HashMap<String, String>(); responseObj.put("error", e.getMessage()); builder = Response.status(Response.Status.BAD_REQUEST).entity(responseObj); } return builder.build(); }
@Path("/advance/{id}") @GET @Produces("text/html") public Response advanceGet(@PathParam("id") final String encoded) { String[] params = courseService.getCourseSignupFromEncrypted(encoded); if (log.isDebugEnabled()) { for (int i = 0; i < params.length; i++) { log.debug("decoded parameter [" + params[i] + "]"); } } String signupId = params[0]; // This is the status that is being advanced to. String emailStatus = params[1]; Status status = toStatus(emailStatus); CourseSignup signup = courseService.getCourseSignupAnyway(signupId); Map<String, Object> model = new HashMap<>(); model.put("signup", signup); model.put("encoded", encoded); // Check that the status we're trying to advance to is valid if (!statusProgression.next(signup.getStatus()).contains(status)) { model.put("errors", Collections.singletonList("The signup has already been dealt with.")); } else { // We only put the status in if we're happy for it to be changed. model.put("status", emailStatus); } addStandardAttributes(model); return Response.ok(new Viewable("/static/advance", model)).build(); }
// Seeded Local Database public static Map<Long, Transaction> getDatabase() { database.put(1L, new Transaction(0.12, "car", 1, 2)); database.put(2L, new Transaction(10.23, "ship", 2, 1)); database.put(3L, new Transaction(200.34, "car", 3, 2)); database.put(4L, new Transaction(4000.45, "house", 4, 6)); database.put(5L, new Transaction(80000.56, "Shopping", 5)); database.put(6L, new Transaction(160000.67, "house", 6, 3)); return database; }
private Response.ResponseBuilder createViolationResponse(Set<ConstraintViolation<?>> violations) { logger.fine("Validation completed. violations found: " + violations.size()); Map<String, String> responseObj = new HashMap<String, String>(); for (ConstraintViolation<?> violation : violations) { responseObj.put(violation.getPropertyPath().toString(), violation.getMessage()); } return Response.status(Response.Status.BAD_REQUEST).entity(responseObj); }
@GET @Path("{warName}") public Response deploymentState(@PathParam("warName") String warName) throws Exception { DeploymentCheckRequest request = new DeploymentCheckRequest(); request.setWarName(warName); Message<DeploymentCheckRequest> msg = new Message<DeploymentCheckRequest>(DeploymentCheckCommandAction.COMMAND_ACTION, request); checkResponse.resetAll(); sender.sendMessage(msg, null); Map<ChannelMember, DeploymentCheckResponse> responses = new HashMap<ChannelMember, DeploymentCheckResponse>(); int timeout = 240; while (timeout-- > 0) { Thread.sleep(500l); boolean foundAll = true; for (ChannelMember mem : members) { Message<DeploymentCheckResponse> memResponse = checkResponse.getResponse(mem); if (memResponse != null) { responses.put(mem, memResponse.getBody()); } else { foundAll = false; } } if (foundAll) { break; } } if (responses.size() == members.size()) { Set<ChannelMember> membersInError = new HashSet<ChannelMember>(); boolean combinedState = true; boolean anyStarted = false; for (ChannelMember mem : responses.keySet()) { DeploymentCheckResponse response = responses.get(mem); if (response.getError() != null) { combinedState = false; membersInError.add(mem); } else { combinedState = combinedState && response.isFinished(); } if (response.isStarted()) { anyStarted = true; } } Map<String, Object> responseObj = new LinkedHashMap<String, Object>(); responseObj.put("finished", combinedState); responseObj.put("started", anyStarted); if (membersInError.size() > 0) { Set<String> inError = new TreeSet<String>(); responseObj.put("errors", inError); for (ChannelMember mem : membersInError) { inError.add(mem.getAddress().toString() + (mem.isCoordinator() ? ":coord" : "")); } } return Response.ok(new Gson().toJson(responseObj)).build(); } return Response.status(Response.Status.NOT_FOUND).build(); }
@Path("operation") @POST @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public GenericServiceAPIResponseEntity createOperation(InputStream inputStream) { GenericServiceAPIResponseEntity response = new GenericServiceAPIResponseEntity<>(); List<TopologyOperationEntity> operations = new LinkedList<>(); try { List<TopologyOperationEntity> entities = (List<TopologyOperationEntity>) unmarshalOperationEntities(inputStream); if (entities == null) { throw new IllegalArgumentException("inputStream cannot convert to TopologyOperationEntity"); } for (TopologyOperationEntity entity : entities) { String status = dao.loadTopologyExecutionStatus( entity.getSite(), entity.getApplication(), entity.getTopology()); if (status == null) { throw new Exception( String.format( "Fail to fetch the topology execution status by site=%s, application=%s, topology=%s", entity.getSite(), entity.getApplication(), entity.getTopology())); } int operationsInRunning = dao.loadTopologyOperationsInRunning( entity.getSite(), entity.getApplication(), entity.getTopology()); if (operationsInRunning != 0) { throw new Exception( operationsInRunning + "operations are running, please wait for a minute"); } if (validateOperation(entity.getOperation(), status)) { Map<String, String> tags = entity.getTags(); tags.put(AppManagerConstants.OPERATION_ID_TAG, UUID.randomUUID().toString()); entity.setTags(tags); entity.setLastModifiedDate(System.currentTimeMillis()); entity.setTimestamp(System.currentTimeMillis()); operations.add(entity); } else { throw new Exception( String.format( "%s is an invalid operation, as the topology's current status is %s", entity.getOperation(), status)); } } response = dao.createOperation(operations); } catch (Exception e) { response.setSuccess(false); response.setException(e); } return response; }
@Path("/advance/{id}") @POST @Produces("text/html") public Response advancePost( @PathParam("id") final String encoded, @FormParam("formStatus") final String formStatus) { if (null == encoded) { return Response.noContent().build(); } String[] params = courseService.getCourseSignupFromEncrypted(encoded); String signupId = params[0]; Status status = toStatus(params[1]); String placementId = params[2]; CourseSignup signup = courseService.getCourseSignupAnyway(signupId); if (null == signup) { return Response.noContent().build(); } Map<String, Object> model = new HashMap<String, Object>(); model.put("signup", signup); if (!statusProgression.next(signup.getStatus()).contains(status)) { model.put("errors", Collections.singletonList("The signup has already been dealt with.")); } else { try { switch (formStatus.toLowerCase()) { case "accept": courseService.accept(signupId, true, placementId); break; case "approve": courseService.approve(signupId, true, placementId); break; case "confirm": courseService.confirm(signupId, true, placementId); break; case "reject": courseService.reject(signupId, true, placementId); break; default: throw new IllegalStateException("No mapping for action of: " + formStatus); } } catch (IllegalStateException ise) { model.put("errors", Collections.singletonList(ise.getMessage())); } } addStandardAttributes(model); return Response.ok(new Viewable("/static/ok", model)).build(); }
public T execute(String coloExpr, String type, String name) { Set<String> colos = getColosFromExpression(coloExpr, type, name); Map<String, T> results = new HashMap<String, T>(); for (String colo : colos) { try { T resultHolder = doExecute(colo); results.put(colo, resultHolder); } catch (FalconException e) { results.put( colo, getResultInstance( APIResult.Status.FAILED, e.getClass().getName() + "::" + e.getMessage())); } } T finalResult = consolidateResult(results, clazz); if (finalResult.getStatus() != APIResult.Status.SUCCEEDED) { throw FalconWebException.newException(finalResult, Response.Status.BAD_REQUEST); } else { return finalResult; } }
@Path("/create") @POST @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public Response createResponse(String input) throws Exception { JSONObject inputObj = new JSONObject(input); Datastore ds = MongoConnection.getServer(); List<ClientObject> clientObjects = ds.createQuery(ClientObject.class) .filter("client_bs_obj.device_id =", inputObj.getString("client_bs_obj.device_id")) .asList(); ClientObject clientObject = clientObjects.get(0); Map<Integer, ObjInstance> objInstanceMap = clientObject.getObjectMap().get(inputObj.getInt("ObjectId")).getObjInstanceMap(); Map<Integer, Resource> resourceMap = objInstanceMap.get(inputObj.getInt("ObjectInsId")).getResourceMap(); ObjInstance objInstance = new ObjInstance(); objInstance.setObjInstance_id(inputObj.getInt("ObjectInsId") + 1); Resource resource = new Resource(); resource.setRecourse_id(0); resource.setName(inputObj.getString("value")); Map<Integer, Resource> resourceMapNew = objInstance.getResourceMap(); resourceMapNew.put(0, resource); objInstanceMap.put(objInstance.getObjInstance_id(), objInstance); // Map<Integer,Resource> resourceMap = objInstanceMap.get(ObjectInsId).getResourceMap(); ds.save(clientObject); CountDownLatch signalRead = Info.getCountDownMessage(inputObj.getString("client_bs_obj.device_id")); signalRead.countDown(); return Response.status(200).entity(inputObj.getString("message")).build(); }
@Path("/delete") @POST @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.TEXT_PLAIN) public Response deleteResponse(String input) throws Exception { JSONObject inputObj = new JSONObject(input); Datastore ds = MongoConnection.getServer(); List<ClientObject> clientObjects = ds.createQuery(ClientObject.class) .filter("client_bs_obj.device_id =", inputObj.getString("client_bs_obj.device_id")) .asList(); ClientObject clientObject = clientObjects.get(0); Map<Integer, ObjInstance> objInstanceMap = clientObject.getObjectMap().get(inputObj.getInt("ObjectId")).getObjInstanceMap(); objInstanceMap.remove(inputObj.getInt("ObjectInsId")); ds.save(clientObject); CountDownLatch signalRead = Info.getCountDownMessage(inputObj.getString("client_bs_obj.device_id")); signalRead.countDown(); return Response.status(200).entity(inputObj.getString("message")).build(); }
@GET @Path("/{sampleId}/annotate") @Consumes(MediaType.APPLICATION_JSON) @ApiOperation(value = "annotate sample", position = 5) public Response annotateSampleGET( @ApiParam(value = "sampleId", required = true) @PathParam("sampleId") int sampleId, @ApiParam(value = "Annotation set name. Must be unique", required = true) @QueryParam("annotateSetName") String annotateSetName, @ApiParam(value = "variableSetId", required = true) @QueryParam("variableSetId") int variableSetId) { try { QueryResult<VariableSet> variableSetResult = catalogManager.getVariableSet(variableSetId, null, sessionId); if (variableSetResult.getResult().isEmpty()) { return createErrorResponse("sample - annotate", "VariableSet not find."); } Map<String, Object> annotations = new HashMap<>(); variableSetResult .getResult() .get(0) .getVariables() .stream() .filter(variable -> params.containsKey(variable.getId())) .forEach( variable -> { annotations.put(variable.getId(), params.getFirst(variable.getId())); }); QueryResult<AnnotationSet> queryResult = catalogManager.annotateSample( sampleId, annotateSetName, variableSetId, annotations, queryOptions, sessionId); return createOkResponse(queryResult); } catch (Exception e) { return createErrorResponse(e); } }
private void initializeFor(String colo) throws FalconException { processInstanceManagerChannels.put(colo, ChannelFactory.get("ProcessInstanceManager", colo)); }
/** * This just adds the standard skin values that are needed when rendering a page. * * @param model The model to add the values to. */ public void addStandardAttributes(Map<String, Object> model) { model.put("skinRepo", serverConfigurationService.getString("skin.repo", "/library/skin")); model.put("skinDefault", serverConfigurationService.getString("skin.default", "default")); model.put("skinPrefix", serverConfigurationService.getString("portal.neoprefix", "")); }
private Channel getInstanceManager(String colo) throws FalconException { if (!processInstanceManagerChannels.containsKey(colo)) { initializeFor(colo); } return processInstanceManagerChannels.get(colo); }
@Path("/read/{ObjID}/{ObjInsId}/{resourceId}") @GET @Produces(MediaType.APPLICATION_JSON) public Response sendRead( @PathParam("ObjID") Integer objectId, @PathParam("ObjInsId") Integer objectInstanceId, @PathParam("resourceId") Integer resourceID, @QueryParam("ep") String endPoint) throws Exception { String directory = "{" + "\"operation\":\"read\"" + "," + "\"" + "directory\":" + "\"" + objectId + "/" + objectInstanceId + "/" + resourceID + "\"}"; Info.setInfo(endPoint, directory); CountDownLatch signal = Info.getCountDown(endPoint); if (signal == null) { return Response.status(200).entity("Devices not registerd yet").build(); } signal.countDown(); CountDownLatch signalRead = new CountDownLatch(1); Info.setCountDownLatchMessageMap(endPoint, signalRead); signalRead.await(); Datastore ds = MongoConnection.getServer(); List<ClientObject> clientObjects = ds.createQuery(ClientObject.class).filter("client_bs_obj.device_id =", endPoint).asList(); JSONArray jsonArray = new JSONArray(); if (objectInstanceId == 0) { Map<Date, Double> hashMap; hashMap = clientObjects .get(0) .getObjectMap() .get(objectId) .getObjInstanceMap() .get(objectInstanceId) .getResourceMap() .get(resourceID) .getValue(); Map<Date, Double> sortedMap = new TreeMap<Date, Double>(hashMap); Iterator it = sortedMap.entrySet().iterator(); while (it.hasNext()) { Map.Entry pair = (Map.Entry) it.next(); JSONArray jsonArray1 = new JSONArray(); Date date = (Date) pair.getKey(); jsonArray1.put(date.getTime()).put(pair.getValue()); jsonArray.put(jsonArray1); it.remove(); // avoids a ConcurrentModificationException } } else if (objectInstanceId == 1) { Map<Date, Integer> hashMap; hashMap = clientObjects .get(0) .getObjectMap() .get(objectId) .getObjInstanceMap() .get(objectInstanceId) .getResourceMap() .get(resourceID) .getMvalue(); Map<Date, Integer> sortedMap = new TreeMap<Date, Integer>(hashMap); Iterator it = sortedMap.entrySet().iterator(); while (it.hasNext()) { Map.Entry pair = (Map.Entry) it.next(); JSONArray jsonArray1 = new JSONArray(); Date date = (Date) pair.getKey(); jsonArray1.put(date.getTime()).put(pair.getValue()); jsonArray.put(jsonArray1); it.remove(); // avoids a ConcurrentModificationException } } return Response.status(200).entity(jsonArray.toString()).build(); }
private void writeMethodImpl(JMethod method) throws UnableToCompleteException { boolean returnRequest = false; if (method.getReturnType() != JPrimitiveType.VOID) { if (!method.getReturnType().getQualifiedSourceName().equals(Request.class.getName()) && !method .getReturnType() .getQualifiedSourceName() .equals(JsonpRequest.class.getName())) { getLogger() .log( ERROR, "Invalid rest method. Method must have void, Request or JsonpRequest return types: " + method.getReadableDeclaration()); throw new UnableToCompleteException(); } else { returnRequest = true; } } Json jsonAnnotation = source.getAnnotation(Json.class); final Style classStyle = jsonAnnotation != null ? jsonAnnotation.style() : Style.DEFAULT; Options classOptions = source.getAnnotation(Options.class); Options options = method.getAnnotation(Options.class); p(method.getReadableDeclaration(false, false, false, false, true) + " {").i(1); { String restMethod = getRestMethod(method); LinkedList<JParameter> args = new LinkedList<JParameter>(Arrays.asList(method.getParameters())); // the last arg should be the callback. if (args.isEmpty()) { getLogger() .log( ERROR, "Invalid rest method. Method must declare at least a callback argument: " + method.getReadableDeclaration()); throw new UnableToCompleteException(); } JParameter callbackArg = args.removeLast(); JClassType callbackType = callbackArg.getType().isClassOrInterface(); JClassType methodCallbackType = METHOD_CALLBACK_TYPE; if (callbackType == null || !callbackType.isAssignableTo(methodCallbackType)) { getLogger() .log( ERROR, "Invalid rest method. Last argument must be a " + methodCallbackType.getName() + " type: " + method.getReadableDeclaration()); throw new UnableToCompleteException(); } JClassType resultType = getCallbackTypeGenericClass(callbackType); String pathExpression = null; Path pathAnnotation = method.getAnnotation(Path.class); if (pathAnnotation != null) { pathExpression = wrap(pathAnnotation.value()); } JParameter contentArg = null; HashMap<String, JParameter> queryParams = new HashMap<String, JParameter>(); HashMap<String, JParameter> formParams = new HashMap<String, JParameter>(); HashMap<String, JParameter> headerParams = new HashMap<String, JParameter>(); for (JParameter arg : args) { PathParam paramPath = arg.getAnnotation(PathParam.class); if (paramPath != null) { if (pathExpression == null) { getLogger() .log( ERROR, "Invalid rest method. Invalid @PathParam annotation. Method is missing the @Path annotation: " + method.getReadableDeclaration()); throw new UnableToCompleteException(); } pathExpression = pathExpression(pathExpression, arg, paramPath); // .replaceAll(Pattern.quote("{" + paramPath.value() + "}"), // "\"+com.google.gwt.http.client.URL.encodePathSegment(" + toStringExpression(arg) + // ")+\""); if (arg.getAnnotation(Attribute.class) != null) { // allow part of the arg-object participate in as PathParam and the object goes over the // wire contentArg = arg; } continue; } QueryParam queryParam = arg.getAnnotation(QueryParam.class); if (queryParam != null) { queryParams.put(queryParam.value(), arg); continue; } FormParam formParam = arg.getAnnotation(FormParam.class); if (formParam != null) { formParams.put(formParam.value(), arg); continue; } HeaderParam headerParam = arg.getAnnotation(HeaderParam.class); if (headerParam != null) { headerParams.put(headerParam.value(), arg); continue; } if (!formParams.isEmpty()) { getLogger() .log( ERROR, "You can not have both @FormParam parameters and a content parameter: " + method.getReadableDeclaration()); throw new UnableToCompleteException(); } if (contentArg != null) { getLogger() .log( ERROR, "Invalid rest method. Only one content parameter is supported: " + method.getReadableDeclaration()); throw new UnableToCompleteException(); } contentArg = arg; } String acceptTypeBuiltIn = null; if (callbackType.equals(TEXT_CALLBACK_TYPE)) { acceptTypeBuiltIn = "CONTENT_TYPE_TEXT"; } else if (callbackType.equals(JSON_CALLBACK_TYPE)) { acceptTypeBuiltIn = "CONTENT_TYPE_JSON"; } else if (callbackType.isAssignableTo(OVERLAY_CALLBACK_TYPE)) { acceptTypeBuiltIn = "CONTENT_TYPE_JSON"; } else if (callbackType.equals(XML_CALLBACK_TYPE)) { acceptTypeBuiltIn = "CONTENT_TYPE_XML"; } p("final " + METHOD_CLASS + " __method ="); p("getResource()"); if (pathExpression != null) { p(".resolve(" + pathExpression + ")"); } for (Map.Entry<String, JParameter> entry : queryParams.entrySet()) { String expr = entry.getValue().getName(); JClassType type = entry.getValue().getType().isClassOrInterface(); if (type != null && isQueryParamListType(type)) { p( ".addQueryParams(" + wrap(entry.getKey()) + ", " + toIteratedStringExpression(entry.getValue()) + ")"); } else { p( ".addQueryParam(" + wrap(entry.getKey()) + ", " + toStringExpression(entry.getValue().getType(), expr) + ")"); } } // example: .get() p("." + restMethod + "();"); // Handle JSONP specific configuration... JSONP jsonpAnnotation = method.getAnnotation(JSONP.class); final boolean isJsonp = restMethod.equals(METHOD_JSONP) && jsonpAnnotation != null; if (isJsonp) { if (returnRequest && !method .getReturnType() .getQualifiedSourceName() .equals(JsonpRequest.class.getName())) { getLogger() .log( ERROR, "Invalid rest method. JSONP method must have void or JsonpRequest return types: " + method.getReadableDeclaration()); throw new UnableToCompleteException(); } if (jsonpAnnotation.callbackParam().length() > 0) { p( "((" + JSONP_METHOD_CLASS + ")__method).callbackParam(" + wrap(jsonpAnnotation.callbackParam()) + ");"); } if (jsonpAnnotation.failureCallbackParam().length() > 0) { p( "((" + JSONP_METHOD_CLASS + ")__method).failureCallbackParam(" + wrap(jsonpAnnotation.failureCallbackParam()) + ");"); } } else { if (returnRequest && !method.getReturnType().getQualifiedSourceName().equals(Request.class.getName())) { getLogger() .log( ERROR, "Invalid rest method. Non JSONP method must have void or Request return types: " + method.getReadableDeclaration()); throw new UnableToCompleteException(); } } // configure the dispatcher if (options != null && options.dispatcher() != Dispatcher.class) { // use the dispatcher configured for the method. p("__method.setDispatcher(" + options.dispatcher().getName() + ".INSTANCE);"); } else { // use the default dispatcher configured for the service.. p("__method.setDispatcher(this.dispatcher);"); } // configure the expected statuses.. if (options != null && options.expect().length != 0) { // Using method level defined expected status p("__method.expect(" + join(options.expect(), ", ") + ");"); } else if (classOptions != null && classOptions.expect().length != 0) { // Using class level defined expected status p("__method.expect(" + join(classOptions.expect(), ", ") + ");"); } // configure the timeout if (options != null && options.timeout() >= 0) { // Using method level defined value p("__method.timeout(" + options.timeout() + ");"); } else if (classOptions != null && classOptions.timeout() >= 0) { // Using class level defined value p("__method.timeout(" + classOptions.timeout() + ");"); } if (jsonpAnnotation == null) { Produces producesAnnotation = findAnnotationOnMethodOrEnclosingType(method, Produces.class); if (producesAnnotation != null) { p( "__method.header(" + RESOURCE_CLASS + ".HEADER_ACCEPT, " + wrap(producesAnnotation.value()[0]) + ");"); } else { // set the default accept header.... if (acceptTypeBuiltIn != null) { p( "__method.header(" + RESOURCE_CLASS + ".HEADER_ACCEPT, " + RESOURCE_CLASS + "." + acceptTypeBuiltIn + ");"); } else { p( "__method.header(" + RESOURCE_CLASS + ".HEADER_ACCEPT, " + RESOURCE_CLASS + ".CONTENT_TYPE_JSON);"); } } Consumes consumesAnnotation = findAnnotationOnMethodOrEnclosingType(method, Consumes.class); if (consumesAnnotation != null) { p( "__method.header(" + RESOURCE_CLASS + ".HEADER_CONTENT_TYPE, " + wrap(consumesAnnotation.value()[0]) + ");"); } // and set the explicit headers now (could override the accept header) for (Map.Entry<String, JParameter> entry : headerParams.entrySet()) { String expr = entry.getValue().getName(); p( "__method.header(" + wrap(entry.getKey()) + ", " + toStringExpression(entry.getValue().getType(), expr) + ");"); } } if (!formParams.isEmpty()) { p(FORM_POST_CONTENT_CLASS + " __formPostContent = new " + FORM_POST_CONTENT_CLASS + "();"); for (Map.Entry<String, JParameter> entry : formParams.entrySet()) { p( "__formPostContent.addParameter(" + wrap(entry.getKey()) + ", " + toFormStringExpression(entry.getValue(), classStyle) + ");"); } p("__method.form(__formPostContent.getTextContent());"); } if (contentArg != null) { if (contentArg.getType() == STRING_TYPE) { p("__method.text(" + contentArg.getName() + ");"); } else if (contentArg.getType() == JSON_VALUE_TYPE) { p("__method.json(" + contentArg.getName() + ");"); } else if (contentArg.getType().isClass() != null && isOverlayArrayType(contentArg.getType().isClass())) { p("__method.json(new " + JSON_ARRAY_CLASS + "(" + contentArg.getName() + "));"); } else if (contentArg.getType().isClass() != null && contentArg.getType().isClass().isAssignableTo(OVERLAY_VALUE_TYPE)) { p("__method.json(new " + JSON_OBJECT_CLASS + "(" + contentArg.getName() + "));"); } else if (contentArg.getType() == DOCUMENT_TYPE) { p("__method.xml(" + contentArg.getName() + ");"); } else { JClassType contentClass = contentArg.getType().isClass(); if (contentClass == null) { contentClass = contentArg.getType().isClassOrInterface(); if (!locator.isCollectionType(contentClass)) { getLogger().log(ERROR, "Content argument must be a class."); throw new UnableToCompleteException(); } } jsonAnnotation = contentArg.getAnnotation(Json.class); Style style = jsonAnnotation != null ? jsonAnnotation.style() : classStyle; // example: // .json(Listings$_Generated_JsonEncoder_$.INSTANCE.encode(arg0) // ) p( "__method.json(" + locator.encodeExpression(contentClass, contentArg.getName(), style) + ");"); } } List<AnnotationResolver> annotationResolvers = getAnnotationResolvers(context, getLogger()); getLogger() .log( TreeLogger.DEBUG, "found " + annotationResolvers.size() + " additional AnnotationResolvers"); for (AnnotationResolver a : annotationResolvers) { getLogger() .log( TreeLogger.DEBUG, "(" + a.getClass().getName() + ") resolve `" + source.getName() + "#" + method.getName() + "´ ..."); final Map<String, String[]> addDataParams = a.resolveAnnotation(getLogger(), source, method, restMethod); if (addDataParams != null) { for (String s : addDataParams.keySet()) { final StringBuilder sb = new StringBuilder(); final List<String> classList = Arrays.asList(addDataParams.get(s)); sb.append("["); for (int i = 0; i < classList.size(); ++i) { sb.append("\\\"").append(classList.get(i)).append("\\\""); if ((i + 1) < classList.size()) { sb.append(","); } } sb.append("]"); getLogger() .log(TreeLogger.DEBUG, "add call with (\"" + s + "\", \"" + sb.toString() + "\")"); p("__method.addData(\"" + s + "\", \"" + sb.toString() + "\");"); } } } if (acceptTypeBuiltIn != null) { // TODO: shouldn't we also have a cach in here? p(returnRequest(returnRequest, isJsonp) + "__method.send(" + callbackArg.getName() + ");"); } else if (isJsonp) { p(returnRequest(returnRequest, isJsonp) + "((" + JSONP_METHOD_CLASS + ")__method).send(new " + ABSTRACT_ASYNC_CALLBACK_CLASS + "<" + resultType.getParameterizedQualifiedSourceName() + ">((" + JSONP_METHOD_CLASS + ")__method, " + callbackArg.getName() + ") {") .i(1); { p("protected " + resultType.getParameterizedQualifiedSourceName() + " parseResult(" + JSON_VALUE_CLASS + " result) throws Exception {") .i(1); { if (resultType.getParameterizedQualifiedSourceName().equals("java.lang.Void")) { p("return (java.lang.Void) null;"); } else { p("try {").i(1); { if (resultType.isAssignableTo(locator.LIST_TYPE)) { p("result = new " + JSON_ARRAY_CLASS + "(result.getJavaScriptObject());"); } jsonAnnotation = method.getAnnotation(Json.class); Style style = jsonAnnotation != null ? jsonAnnotation.style() : classStyle; p("return " + locator.decodeExpression(resultType, "result", style) + ";"); } i(-1).p("} catch (Throwable __e) {").i(1); { p( "throw new " + RESPONSE_FORMAT_EXCEPTION_CLASS + "(\"Response was NOT a valid JSON document\", __e);"); } i(-1).p("}"); } } i(-1).p("}"); } i(-1).p("});"); } else { p("try {").i(1); { p(returnRequest(returnRequest, isJsonp) + "__method.send(new " + ABSTRACT_REQUEST_CALLBACK_CLASS + "<" + resultType.getParameterizedQualifiedSourceName() + ">(__method, " + callbackArg.getName() + ") {") .i(1); { p("protected " + resultType.getParameterizedQualifiedSourceName() + " parseResult() throws Exception {") .i(1); { if (resultType.getParameterizedQualifiedSourceName().equals("java.lang.Void")) { p("return (java.lang.Void) null;"); } else { p("try {").i(1); { jsonAnnotation = method.getAnnotation(Json.class); Style style = jsonAnnotation != null ? jsonAnnotation.style() : classStyle; p( "return " + locator.decodeExpression( resultType, JSON_PARSER_CLASS + ".parse(__method.getResponse().getText())", style) + ";"); } i(-1).p("} catch (Throwable __e) {").i(1); { p( "throw new " + RESPONSE_FORMAT_EXCEPTION_CLASS + "(\"Response was NOT a valid JSON document\", __e);"); } i(-1).p("}"); } } i(-1).p("}"); } i(-1).p("});"); } i(-1).p("} catch (" + REQUEST_EXCEPTION_CLASS + " __e) {").i(1); { p(callbackArg.getName() + ".onFailure(__method,__e);"); if (returnRequest) { p("return null;"); } } i(-1).p("}"); } } i(-1).p("}"); }
private static Map<String, Object> makeClientData( final PwmApplication pwmApplication, final PwmSession pwmSession, final HttpServletRequest request, final HttpServletResponse response, final String pageUrl) throws ChaiUnavailableException, PwmUnrecoverableException { final Configuration config = pwmApplication.getConfig(); final TreeMap<String, Object> settingMap = new TreeMap<>(); settingMap.put( "client.ajaxTypingTimeout", Integer.parseInt(config.readAppProperty(AppProperty.CLIENT_AJAX_TYPING_TIMEOUT))); settingMap.put( "client.ajaxTypingWait", Integer.parseInt(config.readAppProperty(AppProperty.CLIENT_AJAX_TYPING_WAIT))); settingMap.put( "client.activityMaxEpsRate", Integer.parseInt(config.readAppProperty(AppProperty.CLIENT_ACTIVITY_MAX_EPS_RATE))); settingMap.put( "client.js.enableHtml5Dialog", Boolean.parseBoolean(config.readAppProperty(AppProperty.CLIENT_JS_ENABLE_HTML5DIALOG))); settingMap.put( "client.pwShowRevertTimeout", Integer.parseInt(config.readAppProperty(AppProperty.CLIENT_PW_SHOW_REVERT_TIMEOUT))); settingMap.put( "enableIdleTimeout", config.readSettingAsBoolean(PwmSetting.DISPLAY_IDLE_TIMEOUT)); settingMap.put( "pageLeaveNotice", config.readSettingAsLong(PwmSetting.SECURITY_PAGE_LEAVE_NOTICE_TIMEOUT)); settingMap.put( "setting-showHidePasswordFields", pwmApplication .getConfig() .readSettingAsBoolean( password.pwm.config.PwmSetting.DISPLAY_SHOW_HIDE_PASSWORD_FIELDS)); settingMap.put("setting-displayEula", PwmConstants.ENABLE_EULA_DISPLAY); settingMap.put( "setting-showStrengthMeter", config.readSettingAsBoolean(PwmSetting.PASSWORD_SHOW_STRENGTH_METER)); { long idleSeconds = config.readSettingAsLong(PwmSetting.IDLE_TIMEOUT_SECONDS); if (pageUrl == null || pageUrl.isEmpty()) { LOGGER.warn(pwmSession, "request to /client data did not incliude pageUrl"); } else { try { final PwmURL pwmURL = new PwmURL(new URI(pageUrl), request.getContextPath()); final TimeDuration maxIdleTime = IdleTimeoutCalculator.idleTimeoutForRequest(pwmURL, pwmApplication, pwmSession); idleSeconds = maxIdleTime.getTotalSeconds(); } catch (Exception e) { LOGGER.error( pwmSession, "error determining idle timeout time for request: " + e.getMessage()); } } settingMap.put("MaxInactiveInterval", idleSeconds); } settingMap.put("paramName.locale", config.readAppProperty(AppProperty.HTTP_PARAM_NAME_LOCALE)); settingMap.put("startupTime", pwmApplication.getStartupTime()); settingMap.put("applicationMode", pwmApplication.getApplicationMode()); final String contextPath = request.getContextPath(); settingMap.put("url-context", contextPath); settingMap.put( "url-logout", contextPath + PwmServletDefinition.Logout.servletUrl() + "?idle=true"); settingMap.put("url-command", contextPath + PwmServletDefinition.Command.servletUrl()); settingMap.put( "url-resources", contextPath + "/public/resources" + pwmApplication.getResourceServletService().getResourceNonce()); settingMap.put("url-restservice", contextPath + "/public/rest"); { String passwordGuideText = pwmApplication .getConfig() .readSettingAsLocalizedString( PwmSetting.DISPLAY_PASSWORD_GUIDE_TEXT, pwmSession.getSessionStateBean().getLocale()); final MacroMachine macroMachine = pwmSession.getSessionManager().getMacroMachine(pwmApplication); passwordGuideText = macroMachine.expandMacros(passwordGuideText); settingMap.put("passwordGuideText", passwordGuideText); } { final List<String> formTypeOptions = new ArrayList<>(); for (final FormConfiguration.Type type : FormConfiguration.Type.values()) { formTypeOptions.add(type.toString()); } settingMap.put("formTypeOptions", formTypeOptions); } { final List<String> actionTypeOptions = new ArrayList<>(); for (final ActionConfiguration.Type type : ActionConfiguration.Type.values()) { actionTypeOptions.add(type.toString()); } settingMap.put("actionTypeOptions", actionTypeOptions); } { final List<String> epsTypes = new ArrayList<>(); for (final Statistic.EpsType loopEpsType : Statistic.EpsType.values()) { epsTypes.add(loopEpsType.toString()); } settingMap.put("epsTypes", epsTypes); } { final List<String> epsDurations = new ArrayList<>(); for (final Statistic.EpsDuration loopEpsDuration : Statistic.EpsDuration.values()) { epsDurations.add(loopEpsDuration.toString()); } settingMap.put("epsDurations", epsDurations); } { final Map<String, String> localeInfo = new TreeMap<>(); final Map<String, String> localeDisplayNames = new TreeMap<>(); final Map<String, String> localeFlags = new TreeMap<>(); for (final Locale locale : pwmApplication.getConfig().getKnownLocales()) { final String flagCode = pwmApplication.getConfig().getKnownLocaleFlagMap().get(locale); localeFlags.put(locale.toString(), flagCode); localeInfo.put( locale.toString(), locale.getDisplayName() + " - " + locale.getDisplayLanguage(locale)); localeDisplayNames.put(locale.toString(), locale.getDisplayLanguage()); } settingMap.put("localeInfo", localeInfo); settingMap.put("localeDisplayNames", localeDisplayNames); settingMap.put("localeFlags", localeFlags); settingMap.put("defaultLocale", PwmConstants.DEFAULT_LOCALE.toString()); } if (pwmApplication .getConfig() .readSettingAsEnum(PwmSetting.LDAP_SELECTABLE_CONTEXT_MODE, SelectableContextMode.class) != SelectableContextMode.NONE) { final Map<String, Map<String, String>> ldapProfiles = new LinkedHashMap<>(); for (final String ldapProfile : pwmApplication.getConfig().getLdapProfiles().keySet()) { final Map<String, String> contexts = pwmApplication.getConfig().getLdapProfiles().get(ldapProfile).getLoginContexts(); ldapProfiles.put(ldapProfile, contexts); } settingMap.put("ldapProfiles", ldapProfiles); } return settingMap; }