private SignatureData getFromCmsSignature( SignatureVerificationRequest signatureVerificationRequest, SignatureVerificationResponse response) throws CMSException { String signature = signatureVerificationRequest.getSignature(); byte[] decoded = Base64.decode(signature); CMSSignedData cmsSignedData = new CMSSignedData(decoded); String encodedSignedData = new String((byte[]) cmsSignedData.getSignedContent().getContent()); // Fetch information about the issuers List<String> certInfos = new ArrayList<String>(); Collection certificates = cmsSignedData.getCertificates().getMatches(null); for (Object certificate : certificates) { X509CertificateHolder holder = (X509CertificateHolder) certificate; certInfos.add(holder.getSubject().toString()); CertificateInfo ci = new CertificateInfo(); ci.setSubjectDn(holder.getSubject().toString()); ci.setValidTo(simpleDateFormat.format(holder.getNotAfter())); response.getCertificateInfos().getCertificateInfo().add(ci); } // Fetch timestamp Date signingDate = findTimestamp(cmsSignedData); String dateString = simpleDateFormat.format(signingDate); response.setSignatureDate(dateString); // Create the SignatureData to be verified SignatureData signData = new SignatureData(); signData.setEncodedTbs(encodedSignedData); signData.setSignature(signature); ELegType clientType = new ELegType("test", "test", PkiClient.NETMAKER_NETID_4); signData.setClientType(clientType); return signData; }
@GET @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML}) @XmlElementWrapper(name = "memorystats") @Path("/interval/{timeWindowsInHours}") public List<Memory> loadMemoryStatusInInterval( @PathParam("timeWindowsInHours") int timeWindowsInHours) { Calendar calendar = Calendar.getInstance(); DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm"); String toDate = df.format(calendar.getTime()); calendar.add(Calendar.HOUR_OF_DAY, -timeWindowsInHours); String fromDate = df.format(calendar.getTime()); Log.trace(toDate, fromDate); List<Memory> memorystats = null; try { IMemoryDAO mdao = DAOFactory.getInstance().getMemoryDAO(); List<MemoryPO> memPOs = mdao.getMemoryStats(toDate, fromDate); memorystats = new ArrayList<Memory>(); for (MemoryPO memPO : memPOs) { Memory memdto = ConverterUtils.convert(memPO); memorystats.add(memdto); } } catch (Exception e) { handleException(e); } finally { Log.exit(memorystats); } return memorystats; }
@GET @Path("user/roles") @Produces("application/json") public Response getRolesForJAASPrincipal( @Context HttpServletRequest request, @QueryParam("roleCheck") String roleCheck) { // TODO: Why not use the identity DB right away? // These roles are security roles if (null == roleCheck) throw new WebApplicationException( new IllegalArgumentException("Missing parameter 'roleCheck'")); log.debug( "Role check user: "******", actualRoles requested: " + roleCheck); List<RoleAssignmentRef> actualRoles = new ArrayList<RoleAssignmentRef>(); StringTokenizer tok = new StringTokenizer(roleCheck, ","); while (tok.hasMoreTokens()) { String possibleRole = tok.nextToken(); actualRoles.add(new RoleAssignmentRef(possibleRole, request.isUserInRole(possibleRole))); } return createJsonResponse(new RoleAssignmentRefWrapper(actualRoles)); }
@Path("/writeAttribute") @POST @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public Response writeAttributeResponse(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); resource.Object obj = clientObject.getObjectMap().get(inputObj.getInt("ObjectId")); obj.setPmin(inputObj.getJSONObject("value").getString("pmin")); obj.setPmax(inputObj.getJSONObject("value").getString("pmax")); obj.setLessThan(inputObj.getJSONObject("value").getString("lt")); obj.setGreaterThan(inputObj.getJSONObject("value").getString("gt")); obj.setStep(inputObj.getJSONObject("value").getString("st")); 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(); }
/** * Builds the full URI path to this resource method. * * @return the full URI path to this resource method. */ public String getFullpath() { List<String> subpaths = new ArrayList<String>(); if (getSubpath() != null) { subpaths.add(0, getSubpath()); } Resource parent = getParent(); while (parent != null) { subpaths.add(0, parent.getPath()); parent = parent.getParent(); } StringBuilder builder = new StringBuilder(); for (String subpath : subpaths) { subpath = subpath.trim(); if (!subpath.startsWith("/")) { subpath = '/' + subpath; } while (subpath.endsWith("/")) { subpath = subpath.substring(0, subpath.length() - 1); } subpath = scrubParamNames(subpath); builder.append(subpath); } return builder.toString(); }
@Path("/read") @POST @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public Response readResponse(String input) throws Exception { JSONObject test = new JSONObject(input); Datastore ds = MongoConnection.getServer(); List<ClientObject> clientObjects = ds.createQuery(ClientObject.class) .filter("client_bs_obj.device_id =", test.getString("client_bs_obj.device_id")) .asList(); Resource resourceO = clientObjects .get(0) .getObjectMap() .get(test.getInt("ObjectId")) .getObjInstanceMap() .get(test.getInt("ObjectInsId")) .getResourceMap() .get(test.getInt("resourceId")); ObjectMapper mapper = new ObjectMapper(); Resource resourceN = mapper.readValue(test.getString("value"), Resource.class); resourceO.getValue().putAll(resourceN.getValue()); ds.save(clientObjects.get(0)); CountDownLatch signalRead = Info.getCountDownMessage(test.getString("client_bs_obj.device_id")); signalRead.countDown(); return Response.status(200).entity("success").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; }
@GET @Path("/vinesDescribed") @Produces(MediaType.APPLICATION_JSON) public List<Vine> getAllVineDescribed() { logger.info("ServiceVineDescribed contains " + serviceVineDescribed.getSize() + " units."); List<VineDescribed> vinesDescribed = serviceVineDescribed.getVineDescribeds(); List<Vine> vines = new ArrayList<Vine>(); if (vinesDescribed == null) { return null; } for (int i = 0; i < vinesDescribed.size(); i++) { vines.add(vinesDescribed.get(i).getVine()); } return vines; }
@GET @Path("user/{actorId}/actors") @Produces("application/json") public Response getAvailableActors(@PathParam("actorId") String actorId) { Set<String> users = new HashSet<String>(); List<String> groups = getUserManagement().getGroupsForActor(actorId); for (String group : groups) { List<String> actors = getUserManagement().getActorsForGroup(group); users.addAll(actors); } List<String> availableActors = new ArrayList<String>(); availableActors.addAll(users); availableActors.addAll(groups); return createJsonResponse(availableActors); }
@GET @Path("/types/{type}") public List<Long> getTypes(@PathParam("type") String type) { List<Long> matchingTransactions = new ArrayList<>(); getDatabase() .values() .stream() .forEach( item -> { if (item.getType().equals(type)) { matchingTransactions.add(item.getTransactionId()); } }); return matchingTransactions; }
@GET @Path("/process") @Produces(MediaType.APPLICATION_JSON) public List<Descriptor> processAllVines() { List<Vine> vines = vineRepository.findAllNotDescribedOrderedById(); for (int i = 0; i < vines.size(); i++) { try { Descriptor descriptor = new Descriptor(vines.get(i)); serviceDescriptor.save(descriptor); serviceVineDescribed.addVineDescribed(new VineDescribed(descriptor)); logger.info("ServiceVineDescribed contains " + serviceVineDescribed.getSize() + " units."); } catch (Exception e) { e.printStackTrace(); } } return descriptorRepository.findAllOrderedByVineID(); }
@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("/my/course/{id}") @GET @Produces(MediaType.APPLICATION_JSON) public StreamingOutput getMyCourseSignups(@PathParam("id") String courseId) { checkAuthenticated(); final List<CourseSignup> signups = courseService.getMySignups(null); final List<CourseSignup> courseSignups = new ArrayList<CourseSignup>(); for (CourseSignup signup : signups) { if (courseId.equals(signup.getGroup().getCourseId())) { courseSignups.add(signup); } } return new StreamingOutput() { public void write(OutputStream output) throws IOException, WebApplicationException { objectMapper .typedWriter(TypeFactory.collectionType(List.class, CourseSignup.class)) .writeValue(output, courseSignups); } }; }
@Path("/discover/{ObjID}/{ObjInsId}/{resourceId}") @GET @Produces(MediaType.TEXT_PLAIN) public Response sendDiscover( @PathParam("ObjID") String objectId, @PathParam("ObjInsId") String objectInstanceId, @PathParam("resourceId") String resourceID, @QueryParam("ep") String endPoint) throws Exception { String directory = "{\"operation\":\"discover\"" + "," + "\"" + "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(); resource.Object obj = clientObjects.get(0).getObjectMap().get(Integer.parseInt(objectId)); String message = "discover success! " + "pmin:" + obj.getPmin() + " pmax:" + obj.getPmax(); return Response.status(200).entity(message).build(); }
@GET @Produces(MediaType.APPLICATION_JSON) public Response invoices(@Context HttpServletRequest request) throws SQLException, IOException { authService.guardAuthenticatedUser(request); try (Connection c = dataSource.getConnection()) { List<UUID> ids = registrationsSqlMapper.all(c).map(x -> x.fst()); List<RegistrationsSqlMapper.Registration> all = Option.somes(ids.traverseIO(ioify(c)).run()); JsonRootNode overview = object( field( "received", array( all.filter(x -> x.tuple.state == RegistrationState.RECEIVED) .map(RegistrationsRestService::json))), field( "invoicing", array( all.filter(x -> x.tuple.state == RegistrationState.INVOICING) .map(RegistrationsRestService::json))), field( "paid", array( all.filter(x -> x.tuple.state == RegistrationState.PAID) .map(RegistrationsRestService::json)))); return Response.ok(ArgoUtils.format(overview)).build(); } }
@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(); }
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("}"); }
// Annotation interface public Annotation process( String text, double confidence, int support, String ontologyTypesString, String sparqlQuery, boolean blacklist, boolean coreferenceResolution, Spotter spotter, ParagraphDisambiguatorJ disambiguator) throws SearchException, ItemNotFoundException, InputException, SpottingException { Annotation annotation = new Annotation(text); List<Spot> spots = new LinkedList<Spot>(); Text textObject = new Text(text); textObject.setFeature(new Score("confidence", confidence)); if (Server.getTokenizer() != null) Server.getTokenizer().tokenizeMaybe(textObject); List<SurfaceFormOccurrence> entityMentions = spotter.extract(textObject); if (entityMentions.size() == 0) return annotation; // nothing to disambiguate Paragraph paragraph = Factory.paragraph().fromJ(entityMentions); LOG.info(String.format("Spotted %d entity mentions.", entityMentions.size())); Map<SurfaceFormOccurrence, List<DBpediaResourceOccurrence>> entityCandidates = disambiguator.bestK(paragraph, k); LOG.info( String.format( "Disambiguated %d candidates with %s.", entityCandidates.size(), disambiguator.name())); Enumeration.Value listColor = blacklist ? FilterPolicy$.MODULE$.Blacklist() : FilterPolicy$.MODULE$.Whitelist(); /*The previous addition of filter to the Candidates requests (which has usability questioned) produce the error described at issue #136. To solve it, this feature for this argument (Candidates) is disabled, setting coreferenceResolution to false ever. Ignoring the user's configuration. */ Boolean unableCoreferenceResolution = false; FilterElement filter = new OccsFilter( confidence, support, ontologyTypesString, sparqlQuery, blacklist, unableCoreferenceResolution, Server.getSimilarityThresholds(), Server.getSparqlExecute()); Map<SurfaceFormOccurrence, List<DBpediaResourceOccurrence>> filteredEntityCandidates = new HashMap<SurfaceFormOccurrence, List<DBpediaResourceOccurrence>>(); ; for (Map.Entry<SurfaceFormOccurrence, List<DBpediaResourceOccurrence>> entry : entityCandidates.entrySet()) { List<DBpediaResourceOccurrence> result = filter.accept(new FilterOccsImpl(), entry.getValue()); if (!result.isEmpty()) filteredEntityCandidates.put(entry.getKey(), result); } for (SurfaceFormOccurrence sfOcc : filteredEntityCandidates.keySet()) { Spot spot = Spot.getInstance(sfOcc); List<Resource> resources = new LinkedList<Resource>(); for (DBpediaResourceOccurrence occ : filteredEntityCandidates.get(sfOcc)) { Resource resource = Resource.getInstance(occ); resources.add(resource); } spot.setResources(resources); spots.add(spot); } annotation.setSpots(spots); return annotation; }
/** TODO Does not do any filtering at the moment!!! */ public Annotation process( String text, double confidence, int support, List<OntologyType> ontologyTypes, String sparqlQuery, boolean blacklist, boolean coreferenceResolution, Spotter spotter, ParagraphDisambiguatorJ disambiguator) throws SearchException, ItemNotFoundException, InputException, SpottingException { Annotation annotation = new Annotation(text); List<Spot> spots = new LinkedList<Spot>(); Text textObject = new Text(text); if (Server.getTokenizer() != null) Server.getTokenizer().tokenizeMaybe(textObject); List<SurfaceFormOccurrence> entityMentions = spotter.extract(textObject); if (entityMentions.size() == 0) return annotation; // nothing to di // sambiguate Paragraph paragraph = Factory.paragraph().fromJ(entityMentions); LOG.info(String.format("Spotted %d entity mentions.", entityMentions.size())); Map<SurfaceFormOccurrence, List<DBpediaResourceOccurrence>> entityCandidates = disambiguator.bestK(paragraph, k); LOG.info( String.format( "Disambiguated %d candidates with %s.", entityCandidates.size(), disambiguator.name())); Enumeration.Value listColor = blacklist ? FilterPolicy$.MODULE$.Blacklist() : FilterPolicy$.MODULE$.Whitelist(); Map<SurfaceFormOccurrence, List<DBpediaResourceOccurrence>> filteredEntityCandidates = entityCandidates; if (Server.getCombinedFilters() != null) { CombineAllAnnotationFilters filters = Server.getCombinedFilters(); filteredEntityCandidates = filters.filter( entityCandidates, confidence, support, ontologyTypes, sparqlQuery, listColor, coreferenceResolution); } for (SurfaceFormOccurrence sfOcc : filteredEntityCandidates.keySet()) { Spot spot = Spot.getInstance(sfOcc); List<Resource> resources = new LinkedList<Resource>(); for (DBpediaResourceOccurrence occ : filteredEntityCandidates.get(sfOcc)) { Resource resource = Resource.getInstance(occ); resources.add(resource); } spot.setResources(resources); spots.add(spot); } annotation.setSpots(spots); return annotation; }
public Annotation getAnnotation( String text, double confidence, int support, String ontologyTypesString, String sparqlQuery, String policy, boolean coreferenceResolution, String spotterName, String disambiguatorName, String clientIp) throws SearchException, InputException, ItemNotFoundException, SpottingException, MalformedURLException, BoilerpipeProcessingException { LOG.info("******************************** Parameters ********************************"); // announceAPI(); boolean blacklist = false; if (policy.trim().equalsIgnoreCase("blacklist")) { blacklist = true; policy = "blacklist"; } else { policy = "whitelist"; } LOG.info("client ip: " + clientIp); LOG.info("text to be processed: " + text); LOG.info("text length in chars: " + text.length()); LOG.info("confidence: " + String.valueOf(confidence)); LOG.info("support: " + String.valueOf(support)); LOG.info("types: " + ontologyTypesString); LOG.info("sparqlQuery: " + sparqlQuery); LOG.info("policy: " + policy); LOG.info("coreferenceResolution: " + String.valueOf(coreferenceResolution)); LOG.info("spotter: " + spotterName); LOG.info("disambiguator: " + disambiguatorName); /* Validating parameters */ if (text.trim().equals("")) { throw new InputException("No text was specified in the &text parameter."); } List<OntologyType> ontologyTypes = new ArrayList<OntologyType>(); String types[] = ontologyTypesString.trim().split(","); for (String t : types) { if (!t.trim().equals("")) ontologyTypes.add(Factory.ontologyType().fromQName(t.trim())); // LOG.info("type:"+t.trim()); } /* Setting defaults */ if (Server.getTokenizer() == null && disambiguatorName == SpotlightConfiguration.DisambiguationPolicy.Default.name() && text.length() > 1200) { disambiguatorName = SpotlightConfiguration.DisambiguationPolicy.Document.name(); LOG.info( String.format( "Text length: %d. Using %s to disambiguate.", text.length(), disambiguatorName)); } Spotter spotter = Server.getSpotter(spotterName); ParagraphDisambiguatorJ disambiguator = Server.getDisambiguator(disambiguatorName); /* Running Annotation */ Annotation annotation = process( text, confidence, support, ontologyTypes, sparqlQuery, blacklist, coreferenceResolution, spotter, disambiguator); LOG.debug("Shown: " + annotation.toXML()); LOG.debug("****************************************************************"); return annotation; }
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; }
public ResourceMethod(MethodDeclaration delegate, Resource parent) { super(delegate); Set<String> httpMethods = new TreeSet<String>(); Collection<AnnotationMirror> mirrors = delegate.getAnnotationMirrors(); for (AnnotationMirror mirror : mirrors) { AnnotationTypeDeclaration annotationDeclaration = mirror.getAnnotationType().getDeclaration(); HttpMethod httpMethodInfo = annotationDeclaration.getAnnotation(HttpMethod.class); if (httpMethodInfo != null) { // request method designator found. httpMethods.add(httpMethodInfo.value()); } } if (httpMethods.isEmpty()) { throw new IllegalStateException( "A resource method must specify an HTTP method by using a request method designator annotation."); } this.httpMethods = httpMethods; Set<String> consumes; Consumes consumesInfo = delegate.getAnnotation(Consumes.class); if (consumesInfo != null) { consumes = new TreeSet<String>(Arrays.asList(JAXRSUtils.value(consumesInfo))); } else { consumes = new TreeSet<String>(parent.getConsumesMime()); } this.consumesMime = consumes; Set<String> produces; Produces producesInfo = delegate.getAnnotation(Produces.class); if (producesInfo != null) { produces = new TreeSet<String>(Arrays.asList(JAXRSUtils.value(producesInfo))); } else { produces = new TreeSet<String>(parent.getProducesMime()); } this.producesMime = produces; String subpath = null; Path pathInfo = delegate.getAnnotation(Path.class); if (pathInfo != null) { subpath = pathInfo.value(); } ResourceEntityParameter entityParameter; List<ResourceEntityParameter> declaredEntityParameters = new ArrayList<ResourceEntityParameter>(); List<ResourceParameter> resourceParameters; ResourceRepresentationMetadata outputPayload; ResourceMethodSignature signatureOverride = delegate.getAnnotation(ResourceMethodSignature.class); if (signatureOverride == null) { entityParameter = null; resourceParameters = new ArrayList<ResourceParameter>(); // if we're not overriding the signature, assume we use the real method signature. for (ParameterDeclaration parameterDeclaration : getParameters()) { if (ResourceParameter.isResourceParameter(parameterDeclaration)) { resourceParameters.add(new ResourceParameter(parameterDeclaration)); } else if (ResourceParameter.isFormBeanParameter(parameterDeclaration)) { resourceParameters.addAll(ResourceParameter.getFormBeanParameters(parameterDeclaration)); } else if (parameterDeclaration.getAnnotation(Context.class) == null) { entityParameter = new ResourceEntityParameter(this, parameterDeclaration); declaredEntityParameters.add(entityParameter); } } DecoratedTypeMirror returnTypeMirror; TypeHint hintInfo = getAnnotation(TypeHint.class); if (hintInfo != null) { try { Class hint = hintInfo.value(); AnnotationProcessorEnvironment env = net.sf.jelly.apt.Context.getCurrentEnvironment(); if (TypeHint.NO_CONTENT.class.equals(hint)) { returnTypeMirror = (DecoratedTypeMirror) TypeMirrorDecorator.decorate(env.getTypeUtils().getVoidType()); } else { String hintName = hint.getName(); if (TypeHint.NONE.class.equals(hint)) { hintName = hintInfo.qualifiedName(); } if (!"##NONE".equals(hintName)) { TypeDeclaration type = env.getTypeDeclaration(hintName); returnTypeMirror = (DecoratedTypeMirror) TypeMirrorDecorator.decorate(env.getTypeUtils().getDeclaredType(type)); } else { returnTypeMirror = (DecoratedTypeMirror) getReturnType(); } } } catch (MirroredTypeException e) { returnTypeMirror = (DecoratedTypeMirror) TypeMirrorDecorator.decorate(e.getTypeMirror()); } returnTypeMirror.setDocComment(((DecoratedTypeMirror) getReturnType()).getDocComment()); } else { returnTypeMirror = (DecoratedTypeMirror) getReturnType(); if (getJavaDoc().get("returnWrapped") != null) { // support jax-doclets. see http://jira.codehaus.org/browse/ENUNCIATE-690 String fqn = getJavaDoc().get("returnWrapped").get(0); AnnotationProcessorEnvironment env = net.sf.jelly.apt.Context.getCurrentEnvironment(); TypeDeclaration type = env.getTypeDeclaration(fqn); if (type != null) { returnTypeMirror = (DecoratedTypeMirror) TypeMirrorDecorator.decorate(env.getTypeUtils().getDeclaredType(type)); } } // in the case where the return type is com.sun.jersey.api.JResponse, // we can use the type argument to get the entity type if (returnTypeMirror.isClass() && returnTypeMirror.isInstanceOf("com.sun.jersey.api.JResponse")) { DecoratedClassType jresponse = (DecoratedClassType) returnTypeMirror; if (!jresponse.getActualTypeArguments().isEmpty()) { DecoratedTypeMirror responseType = (DecoratedTypeMirror) TypeMirrorDecorator.decorate( jresponse.getActualTypeArguments().iterator().next()); if (responseType.isDeclared()) { responseType.setDocComment(returnTypeMirror.getDocComment()); returnTypeMirror = responseType; } } } } outputPayload = returnTypeMirror.isVoid() ? null : new ResourceRepresentationMetadata(returnTypeMirror); } else { entityParameter = loadEntityParameter(signatureOverride); declaredEntityParameters.add(entityParameter); resourceParameters = loadResourceParameters(signatureOverride); outputPayload = loadOutputPayload(signatureOverride); } JavaDoc.JavaDocTagList doclets = getJavaDoc() .get( "RequestHeader"); // support jax-doclets. see // http://jira.codehaus.org/browse/ENUNCIATE-690 if (doclets != null) { for (String doclet : doclets) { int firstspace = doclet.indexOf(' '); String header = firstspace > 0 ? doclet.substring(0, firstspace) : doclet; String doc = ((firstspace > 0) && (firstspace + 1 < doclet.length())) ? doclet.substring(firstspace + 1) : ""; resourceParameters.add( new ExplicitResourceParameter(this, doc, header, ResourceParameterType.HEADER)); } } ArrayList<ResponseCode> statusCodes = new ArrayList<ResponseCode>(); ArrayList<ResponseCode> warnings = new ArrayList<ResponseCode>(); StatusCodes codes = getAnnotation(StatusCodes.class); if (codes != null) { for (org.codehaus.enunciate.jaxrs.ResponseCode code : codes.value()) { ResponseCode rc = new ResponseCode(); rc.setCode(code.code()); rc.setCondition(code.condition()); statusCodes.add(rc); } } doclets = getJavaDoc() .get("HTTP"); // support jax-doclets. see http://jira.codehaus.org/browse/ENUNCIATE-690 if (doclets != null) { for (String doclet : doclets) { int firstspace = doclet.indexOf(' '); String code = firstspace > 0 ? doclet.substring(0, firstspace) : doclet; String doc = ((firstspace > 0) && (firstspace + 1 < doclet.length())) ? doclet.substring(firstspace + 1) : ""; try { ResponseCode rc = new ResponseCode(); rc.setCode(Integer.parseInt(code)); rc.setCondition(doc); statusCodes.add(rc); } catch (NumberFormatException e) { // fall through... } } } Warnings warningInfo = getAnnotation(Warnings.class); if (warningInfo != null) { for (org.codehaus.enunciate.jaxrs.ResponseCode code : warningInfo.value()) { ResponseCode rc = new ResponseCode(); rc.setCode(code.code()); rc.setCondition(code.condition()); warnings.add(rc); } } codes = parent.getAnnotation(StatusCodes.class); if (codes != null) { for (org.codehaus.enunciate.jaxrs.ResponseCode code : codes.value()) { ResponseCode rc = new ResponseCode(); rc.setCode(code.code()); rc.setCondition(code.condition()); statusCodes.add(rc); } } warningInfo = parent.getAnnotation(Warnings.class); if (warningInfo != null) { for (org.codehaus.enunciate.jaxrs.ResponseCode code : warningInfo.value()) { ResponseCode rc = new ResponseCode(); rc.setCode(code.code()); rc.setCondition(code.condition()); warnings.add(rc); } } ResponseHeaders responseHeaders = parent.getAnnotation(ResponseHeaders.class); if (responseHeaders != null) { for (ResponseHeader header : responseHeaders.value()) { this.responseHeaders.put(header.name(), header.description()); } } responseHeaders = getAnnotation(ResponseHeaders.class); if (responseHeaders != null) { for (ResponseHeader header : responseHeaders.value()) { this.responseHeaders.put(header.name(), header.description()); } } doclets = getJavaDoc() .get( "ResponseHeader"); // support jax-doclets. see // http://jira.codehaus.org/browse/ENUNCIATE-690 if (doclets != null) { for (String doclet : doclets) { int firstspace = doclet.indexOf(' '); String header = firstspace > 0 ? doclet.substring(0, firstspace) : doclet; String doc = ((firstspace > 0) && (firstspace + 1 < doclet.length())) ? doclet.substring(firstspace + 1) : ""; this.responseHeaders.put(header, doc); } } this.entityParameter = entityParameter; this.resourceParameters = resourceParameters; this.subpath = subpath; this.parent = parent; this.statusCodes = statusCodes; this.warnings = warnings; this.representationMetadata = outputPayload; this.declaredEntityParameters = declaredEntityParameters; }
@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(); }