@Override protected ObjectMapper initializeObjectMapper() { final ObjectMapper mapper = super.initializeObjectMapper(); final FilterProvider filters = new SimpleFilterProvider() .addFilter("beanObjectFilter", new CasSimpleBeanObjectFilter()); mapper.setFilters(filters); mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); mapper.configure(SerializationFeature.WRITE_EMPTY_JSON_ARRAYS, false); mapper.configure(SerializationFeature.WRITE_NULL_MAP_VALUES, false); mapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY); mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); mapper.addMixIn(Object.class, CasSimpleBeanObjectFilter.class); mapper.disable(SerializationFeature.INDENT_OUTPUT); mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS); return mapper; }
@Test public void findAllTest2() throws Exception { Auction auction = new Auction(); auction.setRealmId(1); auction.setItemId(124105); List<Auction> auctions = auctionService.findAll(auction); ObjectMapper mapper = new ObjectMapper(); FilterProvider filters = new SimpleFilterProvider().addFilter("auctionFilter", SimpleBeanPropertyFilter.filterOutAllExcept("owner")); MappingJacksonValue mappingJacksonValue = new MappingJacksonValue(auctions); mappingJacksonValue.setFilters(filters); System.out.println(mappingJacksonValue.getValue()); }
private ObjectMapper createMapper(JsonFactory mapping, ClassLoader classLoader) { ObjectMapper mapper = new ObjectMapper(mapping); mapper.addMixIn(MasterSlaveServersConfig.class, MasterSlaveServersConfigMixIn.class); mapper.addMixIn(SingleServerConfig.class, SingleSeverConfigMixIn.class); mapper.addMixIn(Config.class, ConfigMixIn.class); mapper.addMixIn(CodecProvider.class, ClassMixIn.class); mapper.addMixIn(ResolverProvider.class, ClassMixIn.class); mapper.addMixIn(Codec.class, ClassMixIn.class); mapper.addMixIn(RedissonNodeInitializer.class, ClassMixIn.class); mapper.addMixIn(LoadBalancer.class, ClassMixIn.class); FilterProvider filterProvider = new SimpleFilterProvider() .addFilter("classFilter", SimpleBeanPropertyFilter.filterOutAllExcept()); mapper.setFilterProvider(filterProvider); mapper.setSerializationInclusion(Include.NON_NULL); if (classLoader != null) { TypeFactory tf = TypeFactory.defaultInstance() .withClassLoader(classLoader); mapper.setTypeFactory(tf); } return mapper; }
@Test public void testSerializeComment() throws IOException { final Comment aComment = new Comment(); aComment.setContent("<b>There it is</b>"); ByteArrayOutputStream out = new ByteArrayOutputStream(); jsonHelper.withWriter(out, new Writer() { @Override public void writeContents(JsonGenerator generator, ObjectMapper objectMapper) throws JsonGenerationException, JsonMappingException, IOException { FilterProvider fp = new SimpleFilterProvider().addFilter( JacksonHelper.DEFAULT_FILTER_NAME, new ReturnAllBeanProperties()); objectMapper.writer(fp).writeValue(generator, aComment); } }); assertTrue(out.toString().contains("{\"content\":\"<b>There it is</b>\"")); }
@Test public void testNullInComment() throws IOException { final Comment aComment = new Comment(); aComment.setContent(null); ByteArrayOutputStream out = new ByteArrayOutputStream(); jsonHelper.withWriter(out, new Writer() { @Override public void writeContents(JsonGenerator generator, ObjectMapper objectMapper) throws JsonGenerationException, JsonMappingException, IOException { FilterProvider fp = new SimpleFilterProvider().addFilter( JacksonHelper.DEFAULT_FILTER_NAME, new ReturnAllBeanProperties()); objectMapper.writer(fp).writeValue(generator, aComment); } }); assertEquals("Null values should not be output.", "{\"canEdit\":false,\"canDelete\":false}", out.toString()); }
@Test public void renderSimpleBeanWithFilters() throws Exception { TestSimpleBeanFiltered bean = new TestSimpleBeanFiltered(); bean.setProperty1("value"); bean.setProperty2("value"); Map<String, Object> model = new HashMap<String, Object>(); model.put("bindingResult", mock(BindingResult.class, "binding_result")); model.put("foo", bean); FilterProvider filters = new SimpleFilterProvider().addFilter("myJacksonFilter", SimpleBeanPropertyFilter.serializeAllExcept("property2")); model.put(FilterProvider.class.getName(), filters); view.setUpdateContentLength(true); view.render(model, request, response); String content = response.getContentAsString(); assertTrue(content.length() > 0); assertEquals(content.length(), response.getContentLength()); assertThat(content, containsString("\"property1\":\"value\"")); assertThat(content, not(containsString("\"property2\":\"value\""))); assertFalse(content.contains(FilterProvider.class.getName())); }
@Test public void ensureThatSerializingASymbolWithoutProjectDoesNotCrash() throws JsonProcessingException { String expectedJson = "{\"actions\":[" + "{\"type\":\"web_click\",\"disabled\":false,\"negated\":false,\"ignoreFailure\":false," + "\"errorOutput\":null,\"node\":null,\"doubleClick\":false}," + "{\"type\":\"web_checkForText\",\"disabled\":false,\"negated\":false,\"ignoreFailure\":false," + "\"errorOutput\":null,\"value\":\"F[oO0]+\",\"regexp\":true}," + "{\"type\":\"wait\",\"disabled\":false,\"negated\":false,\"ignoreFailure\":false," + "\"errorOutput\":null,\"duration\":" + ONE_SECOND + "}" + "],\"group\":2,\"id\":null,\"name\":\"WebSymbol\",\"project\":null,\"successOutput\":null}"; symbol.setProject(null); ObjectMapper mapper = new ObjectMapper(); mapper.addMixInAnnotations(Object.class, PropertyFilterMixIn.class); SimpleBeanPropertyFilter filter = SimpleBeanPropertyFilter.serializeAllExcept("hidden"); FilterProvider filters = new SimpleFilterProvider().addFilter("filter properties by name", filter); String json = mapper.writer(filters).writeValueAsString(symbol); assertEquals(expectedJson, json); }
private ObjectWriter getObjectWriter(ObjectMapper mapper, String[] fieldsToReturn) { if (fieldsToReturn.length != 0) { mapper.addMixInAnnotations( Object.class, PropertyFilterMixIn.class); HashSet<String> givenFields = new HashSet<>(); givenFields.add("schemas"); Collections.addAll(givenFields, fieldsToReturn); String[] finalFieldsToReturn = givenFields.toArray(new String[givenFields.size()]); FilterProvider filters = new SimpleFilterProvider() .addFilter("filter properties by name", SimpleBeanPropertyFilter.filterOutAllExcept( finalFieldsToReturn)); return mapper.writer(filters); } return mapper.writer(); }
protected FindConfigFileService(final FilterProvider filterProvider, final TextEncryptor textEncryptor, final JsonSerializer<FieldPath> fieldPathSerializer, final JsonDeserializer<FieldPath> fieldPathDeserializer) { final ObjectMapper objectMapper = new Jackson2ObjectMapperBuilder() .featuresToEnable(SerializationFeature.INDENT_OUTPUT) .mixIns(customMixins()) .serializersByType(ImmutableMap.of(FieldPath.class, fieldPathSerializer)) .deserializersByType(ImmutableMap.of(FieldPath.class, fieldPathDeserializer)) .createXmlMapper(false) .build(); setConfigFileLocation(CONFIG_FILE_LOCATION); setConfigFileName(CONFIG_FILE_NAME); setDefaultConfigFile(getDefaultConfigFile()); setMapper(objectMapper); setTextEncryptor(textEncryptor); setFilterProvider(filterProvider); }
protected void configureJSONExporter() { mapper = new ObjectMapper(); // configure mapper.enable(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS); // set Mixins mapper.addMixInAnnotations(BaseNode.class, JsonExportBaseNodeMixin.class); mapper.addMixInAnnotations(TaskNode.class, JsonExportBaseNodeMixin.class); mapper.addMixInAnnotations(EventNode.class, JsonExportBaseNodeMixin.class); mapper.addMixInAnnotations(InfoNode.class, JsonExportBaseNodeMixin.class); mapper.addMixInAnnotations(SymLinkNode.class, JsonExportBaseNodeMixin.class); mapper.addMixInAnnotations(UrlResNode.class, JsonExportBaseNodeMixin.class); // add additional filters mapper.addMixInAnnotations(Object.class, PropertyFilterMixIn.class); String[] ignorableFieldNames = {"importTmpId", "fullSrc", "srcName"}; FilterProvider filters = new SimpleFilterProvider().addFilter("filter properties by name", SimpleBeanPropertyFilter.serializeAllExcept(ignorableFieldNames)); writer = mapper.writer(filters); }
@SuppressWarnings("deprecation") @RequestMapping(value = "/api/path", method = RequestMethod.GET) @ResponseBody public String getPathsForProfile(Model model, String profileIdentifier, @RequestParam(value = "typeFilter[]", required = false) String[] typeFilter, @RequestParam(value = "clientUUID", defaultValue = Constants.PROFILE_CLIENT_DEFAULT_ID) String clientUUID) throws Exception { int profileId = ControllerUtils.convertProfileIdentifier(profileIdentifier); List<EndpointOverride> paths = PathOverrideService.getInstance().getPaths(profileId, clientUUID, typeFilter); HashMap<String, Object> jqReturn = Utils.getJQGridJSON(paths, "paths"); ObjectMapper objectMapper = new ObjectMapper(); objectMapper.addMixInAnnotations(Object.class, ViewFilters.GetPathFilter.class); String[] ignorableFieldNames = {"possibleEndpoints", "enabledEndpoints"}; FilterProvider filters = new SimpleFilterProvider().addFilter("Filter properties from the PathController GET", SimpleBeanPropertyFilter.serializeAllExcept(ignorableFieldNames)); ObjectWriter writer = objectMapper.writer(filters); return writer.writeValueAsString(jqReturn); }
@RequestMapping(value = "/api/path/test", method = RequestMethod.GET) @ResponseBody public String testPath(@RequestParam String url, @RequestParam String profileIdentifier, @RequestParam Integer requestType) throws Exception { int profileId = ControllerUtils.convertProfileIdentifier(profileIdentifier); List<EndpointOverride> trySelectedRequestPaths = PathOverrideService.getInstance().getSelectedPaths(Constants.OVERRIDE_TYPE_REQUEST, ClientService.getInstance().findClient("-1", profileId), ProfileService.getInstance().findProfile(profileId), url, requestType, true); HashMap<String, Object> jqReturn = Utils.getJQGridJSON(trySelectedRequestPaths, "paths"); ObjectMapper objectMapper = new ObjectMapper(); objectMapper.addMixInAnnotations(Object.class, ViewFilters.GetPathFilter.class); String[] ignorableFieldNames = {"possibleEndpoints", "enabledEndpoints"}; FilterProvider filters = new SimpleFilterProvider().addFilter("Filter properties from the PathController GET", SimpleBeanPropertyFilter.serializeAllExcept(ignorableFieldNames)); ObjectWriter writer = objectMapper.writer(filters); return writer.writeValueAsString(jqReturn); }
public static String objectToJsonExclude(Object data,String filterName, String ...exName) { try { SimpleBeanPropertyFilter theFilter = SimpleBeanPropertyFilter .serializeAllExcept(exName); FilterProvider filters = new SimpleFilterProvider() .addFilter(filterName, theFilter); return MAPPER.writer(filters).writeValueAsString(data); } catch (JsonProcessingException e) { e.printStackTrace(); } return null; }
@Test public void testSerializeMultipleObjects() throws IOException { final Collection<Comment> allComments = new ArrayList<Comment>(); Comment aComment = new Comment(); aComment.setContent("<b>There it is</b>"); allComments.add(aComment); aComment = new Comment(); aComment.setContent("<p>I agree with the author</p>"); allComments.add(aComment); ByteArrayOutputStream out = new ByteArrayOutputStream(); jsonHelper.withWriter(out, new Writer() { @Override public void writeContents(JsonGenerator generator, ObjectMapper objectMapper) throws JsonGenerationException, JsonMappingException, IOException { FilterProvider fp = new SimpleFilterProvider().addFilter( JacksonHelper.DEFAULT_FILTER_NAME, new ReturnAllBeanProperties()); objectMapper.writer(fp).writeValue(generator, allComments); } }); assertTrue(out.toString().contains("content\":\"<b>There it is</b>")); assertTrue(out.toString().contains("content\":\"<p>I agree with the author</p>")); }
@ExceptionHandler(CerebroException.class) @ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR) public String getErrorCode(final CerebroException exception) throws IOException { LOGGER.error("Service error", exception); ObjectMapper objectMapper = new ObjectMapper(); FilterProvider filterProvider = new SimpleFilterProvider().addFilter("responseFilter", SimpleBeanPropertyFilter.filterOutAllExcept("errorCode", "errorMessage")); objectMapper.setFilterProvider(filterProvider); return objectMapper.writeValueAsString(exception); }
/** * Filter out undesired attributes from the given model. * The return value can be either another {@link Map} or a single value object. * <p>The default implementation removes {@link BindingResult} instances and entries * not included in the {@link #setModelKeys renderedAttributes} property. * @param model the model, as passed on to {@link #renderMergedOutputModel} * @return the value to be rendered */ @Override protected Object filterModel(Map<String, Object> model) { Map<String, Object> result = new HashMap<String, Object>(model.size()); Set<String> modelKeys = (!CollectionUtils.isEmpty(this.modelKeys) ? this.modelKeys : model.keySet()); for (Map.Entry<String, Object> entry : model.entrySet()) { if (!(entry.getValue() instanceof BindingResult) && modelKeys.contains(entry.getKey()) && !entry.getKey().equals(JsonView.class.getName()) && !entry.getKey().equals(FilterProvider.class.getName())) { result.put(entry.getKey(), entry.getValue()); } } return (this.extractValueFromSingleKeyModel && result.size() == 1 ? result.values().iterator().next() : result); }
/** * Filter and optionally wrap the model in {@link MappingJacksonValue} container. * @param model the model, as passed on to {@link #renderMergedOutputModel} * @param request current HTTP request * @return the wrapped or unwrapped value to be rendered */ protected Object filterAndWrapModel(Map<String, Object> model, HttpServletRequest request) { Object value = filterModel(model); Class<?> serializationView = (Class<?>) model.get(JsonView.class.getName()); FilterProvider filters = (FilterProvider) model.get(FilterProvider.class.getName()); if (serializationView != null || filters != null) { MappingJacksonValue container = new MappingJacksonValue(value); container.setSerializationView(serializationView); container.setFilters(filters); value = container; } return value; }
/** * Write the actual JSON content to the stream. * @param stream the output stream to use * @param object the value to be rendered, as returned from {@link #filterModel} * @throws IOException if writing failed */ protected void writeContent(OutputStream stream, Object object) throws IOException { JsonGenerator generator = this.objectMapper.getFactory().createGenerator(stream, this.encoding); writePrefix(generator, object); Class<?> serializationView = null; FilterProvider filters = null; Object value = object; if (value instanceof MappingJacksonValue) { MappingJacksonValue container = (MappingJacksonValue) value; value = container.getValue(); serializationView = container.getSerializationView(); filters = container.getFilters(); } if (serializationView != null) { this.objectMapper.writerWithView(serializationView).writeValue(generator, value); } else if (filters != null) { this.objectMapper.writer(filters).writeValue(generator, value); } else { this.objectMapper.writeValue(generator, value); } writeSuffix(generator, object); generator.flush(); }
public ObjectMapperExceptField(Class<?> targetClass, String property) { super(); SimpleBeanPropertyFilter theFilter = SimpleBeanPropertyFilter.serializeAllExcept(property); FilterProvider filters = new SimpleFilterProvider().addFilter("myFilter", theFilter); addMixInAnnotations(targetClass, PropertyFilterMixIn.class); setFilters(filters); }
public static String writeGroup(SymbolGroup group) throws JsonProcessingException { SimpleBeanPropertyFilter filter = SimpleBeanPropertyFilter.serializeAllExcept("symbolAmount"); FilterProvider filters = new SimpleFilterProvider().addFilter("filter properties by name", filter); ObjectMapper mapper = new ObjectMapper(); mapper.addMixInAnnotations(Object.class, PropertyFilterMixIn.class); return mapper.writer(filters).writeValueAsString(group); }
@Override public void initialize(Bootstrap<SystemApiConfiguration> maintenanceConfigurationBootstrap) { ObjectMapper mapper = maintenanceConfigurationBootstrap.getObjectMapper(); mapper.addMixInAnnotations(NetworkInterface.class, NetworkInterfaceMixin.class); FilterProvider filterProvider = new SimpleFilterProvider() .addFilter("networkInterface filter", SimpleBeanPropertyFilter.serializeAllExcept("name", "displayName", "inetAddresses", "interfaceAddresses", "mtu", "subInterfaces")); mapper.setFilters(filterProvider); }
public static FilterProvider getFilterProvider(final String... fieldsToExclude) { if (null == fieldsToExclude || fieldsToExclude.length == 0) { // Use the 'serializeAllExcept' method so it is compatible with older versions of jackson return new SimpleFilterProvider() .addFilter(FILTER_FIELDS_BY_NAME, (BeanPropertyFilter) SimpleBeanPropertyFilter.serializeAllExcept()); } return new SimpleFilterProvider() .addFilter(FILTER_FIELDS_BY_NAME, (BeanPropertyFilter) SimpleBeanPropertyFilter.serializeAllExcept(fieldsToExclude)); }
protected MappingJacksonValue buildResponse(Object resource, String attributes) { MappingJacksonValue wrapper = new MappingJacksonValue(resource); if (!Strings.isNullOrEmpty(attributes)) { Set<String> attributesSet = extractAttributes(attributes); FilterProvider filterProvider = new SimpleFilterProvider().addFilter( "attributeFilter", SimpleBeanPropertyFilter.filterOutAllExcept(attributesSet) ); wrapper.setFilters(filterProvider); } return wrapper; }
/** * Bulk update a set of documents using partial documents. * * @param index document index * @param documentType Type of the document * @param filterProvider Serialization filterProvider to use in document serialization to only output fields we wish to update. * @param documentIds documents to update. * @param documentTemplate the document template to apply changes from */ final protected void updateDocuments(String index, String documentType, FilterProvider filterProvider, Set<String> documentIds, IDocument documentTemplate) { if (documentIds.size() == 0) { return; } BulkRequestBuilder bulkRequestBuilder = this.getClient().prepareBulk(); ObjectWriter writer = getObjectWriter(documentTemplate.getClass()).with(filterProvider); this.updateDocumentDatesTracking(documentTemplate); for (String documentId : documentIds) { UpdateRequestBuilder request = this.getClient().prepareUpdate() .setIndex(index) .setId(documentId) .setType(documentType) .setDoc(this.getSourceFromDocument(writer, documentTemplate)); bulkRequestBuilder.add(request); } try { bulkRequestBuilder.setRefresh(true); BulkResponse response = bulkRequestBuilder.execute().actionGet(); if (response.hasFailures()) { throw new SearchServiceException(String.format("Unexpected failure bulk updating documents %s", response.buildFailureMessage())); } } catch (VersionConflictEngineException vc) { throw new ConcurrentModificationException(vc); } catch (ElasticsearchException ex) { throw new SearchServiceException("Unexpected failure while indexing a document.", ex); } }
/** * Convert a {@link Marathon} object to Json. * * @param marathon * @return * @throws IOException */ @Override public String serializeMarathon(Marathon marathon) throws IOException { FilterProvider filters = new SimpleFilterProvider().addFilter("filterConstraints", SimpleBeanPropertyFilter.serializeAllExcept("constraints")); String json = objectMapper.setFilterProvider(filters).writeValueAsString(marathon); return json; }
@Override public String process(String textToProcess, JsonNode configuration) throws Throwable { HttpResponseForAvailability httpResponseForAvailability = JsonConverter.jsonStringToObject(textToProcess, HttpResponseForAvailability.class); ObjectMapper mapper = new ObjectMapper(); String[] ignorableFieldNames = { "httpStatusCode"}; FilterProvider filters = new SimpleFilterProvider() .addFilter("httpFilter", SimpleBeanPropertyFilter.serializeAllExcept(ignorableFieldNames)); ObjectWriter writer = mapper.writer(filters); return writer.writeValueAsString(httpResponseForAvailability); }
@Override public String process(String textToProcess, JsonNode configuration) throws Throwable { HttpResponseForAvailability httpResponseForAvailability = JsonConverter.jsonStringToObject(textToProcess, HttpResponseForAvailability.class); ObjectMapper mapper = new ObjectMapper(); String[] ignorableFieldNames = { "body"}; FilterProvider filters = new SimpleFilterProvider() .addFilter("httpFilter",SimpleBeanPropertyFilter.serializeAllExcept(ignorableFieldNames)); ObjectWriter writer = mapper.writer(filters); return writer.writeValueAsString(httpResponseForAvailability); }
@Autowired public HodFindConfigFileService( final FilterProvider filterProvider, final TextEncryptor textEncryptor, final JsonSerializer<FieldPath> fieldPathSerializer, final JsonDeserializer<FieldPath> fieldPathDeserializer) { super(filterProvider, textEncryptor, fieldPathSerializer, fieldPathDeserializer); }
@Autowired public IdolFindConfigFileService( final FilterProvider filterProvider, final TextEncryptor textEncryptor, final JsonSerializer<FieldPath> fieldPathSerializer, final JsonDeserializer<FieldPath> fieldPathDeserializer, final IdolConfigUpdateHandler idolConfigUpdateHandler ) { super(filterProvider, textEncryptor, fieldPathSerializer, fieldPathDeserializer); this.idolConfigUpdateHandler = idolConfigUpdateHandler; }
protected BeanPropertyFilter findFilter(SerializerProvider paramSerializerProvider) { Object localObject = this._propertyFilterId; FilterProvider localFilterProvider = paramSerializerProvider.getFilterProvider(); if (localFilterProvider == null) throw new JsonMappingException("Can not resolve BeanPropertyFilter with id '" + localObject + "'; no FilterProvider configured"); return localFilterProvider.findFilter(localObject); }
private SerializationConfig(SerializationConfig paramSerializationConfig, FilterProvider paramFilterProvider) { super(paramSerializationConfig); this._serFeatures = paramSerializationConfig._serFeatures; this._serializationInclusion = paramSerializationConfig._serializationInclusion; this._filterProvider = paramFilterProvider; }
private static String toXml(final Object object, final FilterProvider filterProvider) { try { if (filterProvider == null) { return mapper.writeValueAsString(object); } else { return mapper.writer(filterProvider).writeValueAsString(object); } } catch(final JsonProcessingException e) { throw new XmlProcessingException(e); } }
public static String toXml(final Ds3ObjectList objects, final boolean isBulkPut) { if (isBulkPut) { return XmlOutput.toXml(objects); } final FilterProvider filters = new SimpleFilterProvider().addFilter("sizeFilter", SimpleBeanPropertyFilter.serializeAllExcept("Size")); return XmlOutput.toXml(objects, filters); }
/** * {@inheritDoc} */ @Override public FilterProvider transform(final ObjectGraph graph) { // Root entity. final FilteringPropertyFilter root = new FilteringPropertyFilter(graph.getEntityClass(), graph.getFields(), createSubfilters(graph.getEntityClass(), graph.getSubgraphs())); return new FilteringFilterProvider(root); }
@Override protected void configure() { bindAsContract(JacksonObjectProvider.class) // FilteringObjectProvider. .to(new GenericType<ObjectProvider<FilterProvider>>() { }) // FilteringGraphTransformer. .to(new GenericType<ObjectGraphTransformer<FilterProvider>>() { }) // Scope. .in(Singleton.class); }
/** * <p>setObjectWriterInjector.</p> * * @param provider a {@link javax.inject.Provider} object. * @param genericType a {@link java.lang.reflect.Type} object. * @param annotations an array of {@link java.lang.annotation.Annotation} objects. * @throws java.io.IOException if any. */ public static void setObjectWriterInjector(Provider<ObjectProvider<FilterProvider>> provider, final Type genericType, final Annotation[] annotations) throws IOException { final FilterProvider filterProvider = provider.get().getFilteringObject(genericType, true, annotations); if (filterProvider != null) { ObjectWriterInjector.set(new FilteringObjectWriterModifier(filterProvider, ObjectWriterInjector.getAndClear())); } }
@Override public void dispatchNotification(final Date creationDate, final Activity.ActivityAction activityAction, final NodeObserver.Event mobSOSEvent, final int dataId, final Activity.DataType dataType, final int userId) { // Filters to generate JSON elements FilterProvider filters = new SimpleFilterProvider().addFilter( "ActivityFilter", SimpleBeanPropertyFilter.filterOutAllExcept("id", "name")); mapper = new ObjectMapper(); mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); mapper.setFilters(filters); Activity.AdditionalObject additionalObject = generateAdditionalObject(dataType, dataId, userId); try { if (emailDispatcher != null && (activityAction == Activity.ActivityAction.CREATE || activityAction == Activity.ActivityAction.UPDATE || activityAction == Activity.ActivityAction.REALIZE)) { // add email emailDispatcher.addEmailNotification(creationDate, activityAction, dataId, dataType, userId, additionalObject); } if (activityDispatcher != null && (activityAction == Activity.ActivityAction.CREATE || activityAction == Activity.ActivityAction.UPDATE || activityAction == Activity.ActivityAction.REALIZE || activityAction == Activity.ActivityAction.DEVELOP || activityAction == Activity.ActivityAction.LEADDEVELOP || activityAction == Activity.ActivityAction.FOLLOW || activityAction == Activity.ActivityAction.VOTE)) { // dispatch activity activityDispatcher.sendActivityOverRMI(creationDate, activityAction, dataId, dataType, userId, additionalObject); } if (mobSOSEvent != null) { // dispatch mobSOS log call L2pLogger.logEvent(mobSOSEvent, Context.getCurrent().getMainAgent(), mapper.writeValueAsString(additionalObject)); } } catch (JsonProcessingException e) { logger.warning(e.getMessage()); } }
@Test public void success() throws Exception { User user = createUser(); ObjectMapper mapper = new ObjectMapper(); mapper.addMixInAnnotations(Thing.class, ThingMixin.class); FilterProvider filterProvider = new SimpleFilterProvider() .addFilter("thing filter", SimpleBeanPropertyFilter.serializeAllExcept("user")); mapper.setFilters(filterProvider); StringWriter writer = new StringWriter(); mapper.writeValue(writer, user); }
@Override public ObjectWriter modify(EndpointConfigBase<?> endpoint, MultivaluedMap<String, Object> responseHeaders, Object valueToWrite, ObjectWriter w, JsonGenerator g) throws IOException { SimpleBeanPropertyFilter filter = null; if (includes != null && !includes.isEmpty()) { filter = new SimpleBeanPropertyFilter.FilterExceptFilter(includes); } else if (excludes != null && !excludes.isEmpty()) { filter = SimpleBeanPropertyFilter.serializeAllExcept(excludes); } else { filter = SimpleBeanPropertyFilter.serializeAllExcept(new HashSet<String>()); } FilterProvider provider = new SimpleFilterProvider().addFilter("property_filter", filter); return w.with(provider); }