/** * Can serialize field? * * @param pojo the pojo * @param writer the writer * @return the boolean */ private boolean canSerializeField(final Object pojo, final PropertyWriter writer) { boolean foundPackage = false; final String packageName = pojo.getClass().getPackage().getName(); for (int i = 0; !foundPackage && i < INCLUDE_PACKAGES.length; i++) { foundPackage = (packageName.startsWith(INCLUDE_PACKAGES[i])); } if (!foundPackage) { LOGGER.trace("Package [{}] is ignored", packageName); return false; } boolean foundField = true; final String fieldName = writer.getFullName().getSimpleName(); for (int i = 0; foundField && i < EXCLUDE_FIELDS.length; i++) { foundField = !fieldName.equalsIgnoreCase(EXCLUDE_FIELDS[i]); } if (!foundField) { LOGGER.trace("Field [{}] is excluded", fieldName); return false; } return true; }
private Path getPath(PropertyWriter writer, JsonStreamContext sc) { LinkedList<PathElement> elements = new LinkedList<>(); if (sc != null) { elements.add(new PathElement(writer.getName(), sc.getCurrentValue())); sc = sc.getParent(); } while (sc != null) { if (sc.getCurrentName() != null && sc.getCurrentValue() != null) { elements.addFirst(new PathElement(sc.getCurrentName(), sc.getCurrentValue())); } sc = sc.getParent(); } return new Path(elements); }
@Override public void serializeAsField( final Object pojo, final JsonGenerator jgen, final SerializerProvider prov, final PropertyWriter writer) throws Exception { if (writer instanceof BeanPropertyWriter) { final BeanPropertyWriter beanPropertyWriter = (BeanPropertyWriter) writer; if (beanPropertyWriter.getAnnotation(LogRedact.class) == null) { super.serializeAsField(pojo, jgen, prov, writer); } else { if (_allowNull && beanPropertyWriter.get(pojo) == null) { super.serializeAsField(pojo, jgen, prov, writer); } else { jgen.writeStringField(beanPropertyWriter.getSerializedName().getValue(), REDACTION_STRING); } } } else { super.serializeAsField(pojo, jgen, prov, writer); } }
/** * @deprecated Provided for test compatibility with deprecated method in Jackson. */ @Test @Deprecated public void testDeprecatedSerializeAsFieldWithNull() throws Exception { final RedactionFilter mockFilter = Mockito.mock(RedactionFilter.class); Mockito.doAnswer(new SerializeAsFieldAnswer(new RedactionFilter(true))) .when(mockFilter).serializeAsField( Mockito.any(), Mockito.any(JsonGenerator.class), Mockito.any(SerializerProvider.class), Mockito.any(PropertyWriter.class)); // CHECKSTYLE.OFF: IllegalInstantiation - No Guava dependency here. final Map<String, Object> filterMap = new HashMap<>(); // CHECKSTYLE.ON: IllegalInstantiation filterMap.put(RedactionFilter.REDACTION_FILTER_ID, mockFilter); _objectMapper.setFilters(new SimpleFilterProvider(filterMap)); final JsonNode actualTree = _objectMapper.valueToTree(_redactedBean); final JsonNode expectedTree = readTree("testDeprecatedSerializeAsFieldWithNull.json"); Assert.assertEquals(expectedTree, actualTree); }
/** * @deprecated Provided for test compatibility with deprecated method in Jackson. */ @Test @Deprecated public void testDeprecatedSerializeAsFieldWithoutNull() throws Exception { final RedactionFilter mockFilter = Mockito.mock(RedactionFilter.class); Mockito.doAnswer(new SerializeAsFieldAnswer(new RedactionFilter(false))) .when(mockFilter).serializeAsField( Mockito.any(), Mockito.any(JsonGenerator.class), Mockito.any(SerializerProvider.class), Mockito.any(PropertyWriter.class)); // CHECKSTYLE.OFF: IllegalInstantiation - No Guava dependency here. final Map<String, Object> filterMap = new HashMap<>(); // CHECKSTYLE.ON: IllegalInstantiation filterMap.put(RedactionFilter.REDACTION_FILTER_ID, mockFilter); _objectMapper.setFilters(new SimpleFilterProvider(filterMap)); final JsonNode actualTree = _objectMapper.valueToTree(_redactedBean); final JsonNode expectedTree = readTree("testDeprecatedSerializeAsFieldWithoutNull.json"); Assert.assertEquals(expectedTree, actualTree); }
@Override public void serializeAsField(final Object pojo, final JsonGenerator jgen, final SerializerProvider provider, final PropertyWriter writer) throws Exception { try { if (!canSerializeField(pojo, writer)) { return; } super.serializeAsField(pojo, jgen, provider, writer); } catch (final Exception e) { LOGGER.debug(e.getMessage()); } }
public static void main(String[] args) throws Exception { ConfigurableApplicationContext context = SpringApplication.run(SampleDataJpaApplication.class, args); Iterable<ObjectMapper> objectMappers = context.getBeansOfType(ObjectMapper.class) .values(); objectMappers.forEach(mapper -> mapper.registerModule(new Hibernate5Module())); Squiggly.init(objectMappers, new RequestSquigglyContextProvider() { @Override public void serializeAsIncludedField(Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer) throws Exception { if (isFilteringEnabled()) { Object value = writer.getMember().getValue(pojo); if (value instanceof PersistentCollection) { ((PersistentCollection) value).forceInitialization(); } } super.serializeAsIncludedField(pojo, jgen, provider, writer); } }); ObjectMapper objectMapper = Iterables.getFirst(objectMappers, null); // Enable Squiggly for Jackson message converter if (objectMapper != null) { for (MappingJackson2HttpMessageConverter converter : context.getBeansOfType(MappingJackson2HttpMessageConverter.class).values()) { converter.setObjectMapper(objectMapper); } } }
protected boolean include(final PropertyWriter writer, final JsonGenerator jgen) { if (!contextProvider.isFilteringEnabled()) { return true; } JsonStreamContext streamContext = getStreamContext(jgen); if (streamContext == null) { return true; } Path path = getPath(writer, streamContext); SquigglyContext context = contextProvider.getContext(path.getFirst().getBeanClass()); String filter = context.getFilter(); if (AnyDeepName.ID.equals(filter)) { return true; } if (path.isCachable()) { // cache the match result using the path and filter expression Pair<Path, String> pair = Pair.of(path, filter); Boolean match = MATCH_CACHE.getIfPresent(pair); if (match == null) { match = pathMatches(path, context); } MATCH_CACHE.put(pair, match); return match; } return pathMatches(path, context); }
@Override public void serializeAsField(final Object pojo, final JsonGenerator jgen, final SerializerProvider provider, final PropertyWriter writer) throws Exception { if (include(writer, jgen)) { contextProvider.serializeAsIncludedField(pojo, jgen, provider, writer); } else if (!jgen.canOmitFields()) { contextProvider.serializeAsExcludedField(pojo, jgen, provider, writer); } }
@Override public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer) throws Exception { if (include(pojo, writer)) { super.serializeAsField(pojo, jgen, provider, writer); } }
@Override public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer) throws Exception { String key = writer.getName(); boolean prevDetails = details; JsonDetails det = writer.getAnnotation(JsonDetails.class); if (det != null) { if (!details && det.value()) { return; } if (det.simple()) { details = false; } } path.add(key); if (!permissionService.permits(perms, path)) { path.remove(key); return; } super.serializeAsField(pojo, jgen, provider, writer); details = prevDetails; }
private boolean includeField(Object pojo, PropertyWriter writer) { // if (writer.getAnnotation(ApiPermissionsAllowed.class) == null) { // return true; // } // // return Arrays.asList(writer.getAnnotation(ApiPermissionsAllowed.class).value()) // .stream() // .anyMatch(apiPermission -> apiPermission.equals(((ApiEntity) pojo).getrgetPermission())); return true; }
@Override protected boolean include(PropertyWriter writer) { if (new CurrentSecurityContext().isStaffOrAdmin()) { return true; } return !privateFields.contains(writer.getName()); }
@Override public Void answer(final InvocationOnMock invocation) throws Throwable { // CHECKSTYLE.ON: IllegalThrows if (invocation.getArguments()[3] instanceof BeanPropertyWriter) { _redactionFilter.serializeAsField(invocation.getArguments()[0], (JsonGenerator) invocation.getArguments()[1], (SerializerProvider) invocation.getArguments()[2], (BeanPropertyWriter) invocation.getArguments()[3]); } else { _redactionFilter.serializeAsField(invocation.getArguments()[0], (JsonGenerator) invocation.getArguments()[1], (SerializerProvider) invocation.getArguments()[2], (PropertyWriter) invocation.getArguments()[3]); } return null; }
@Override public void serializeAsField(final Object pojo, final JsonGenerator jgen, final SerializerProvider prov, final PropertyWriter writer) throws Exception { if (include(writer.getName())) { writer.serializeAsField(pojo, jgen, prov); } }
@Override public void serializeAsElement(final Object elementValue, final JsonGenerator jgen, final SerializerProvider prov, final PropertyWriter writer) throws Exception { if (include(writer.getName())) { writer.serializeAsElement(elementValue, jgen, prov); } }
@Override public void depositSchemaProperty(final PropertyWriter writer, final ObjectNode propertiesNode, final SerializerProvider provider) throws JsonMappingException { if (include(writer.getName())) { writer.depositSchemaProperty(propertiesNode, provider); } }
@Override public void depositSchemaProperty(final PropertyWriter writer, final JsonObjectFormatVisitor objectVisitor, final SerializerProvider provider) throws JsonMappingException { if (include(writer.getName())) { writer.depositSchemaProperty(objectVisitor, provider); } }
private void processFirstPass(Node parentNode, Object pojo, SerializerProvider provider, PropertyWriter writer, JsonGenerator generator) throws Exception { State state = this.state.get(); Leaf leaf = Leaf.copyOf(state.propertyPath); // if this property _can_ contribute towards the path leading to a matching leaf then we have to check boolean matches = matcher.matches(leaf); if (matches || matcher.matchesParent(leaf)) { if (parentNode.isRoot()) { // make sure we don't actually write anything to the output, only replace if we are the root node, it will // be passed to other nodes as needed via recursive calls generator = new JsonFactory().createGenerator(CharStreams.nullWriter()); } // prepare a node for this property so child branches can add to it as needed state.currentNode = new Node(parentNode, writer.getName()); writer.serializeAsField(pojo, generator, provider); // check the results of processing the children if (state.currentNode.isEmpty()) { // either we don't have any children or none of them are matching leaves. // in any case if (matches) { // it turns out we match anyway so add this node parentNode.addChild(state.currentNode); } } else { // child leafs match so we need to include this node as a parent of them parentNode.addChild(state.currentNode); } } }
public boolean matchesFirstChild(PropertyWriter writer) { if (children == null) { return false; } Node child = children.peekFirst(); return child != null && child.matchesName(writer); }
@Override public void setUp() throws Exception { super.setUp(); setDefault(Matcher.class, Matcher.all()); setDefault(JsonGenerator.class, mock(JsonGenerator.class)); setDefault(SerializerProvider.class, mock(SerializerProvider.class)); setDefault(PropertyWriter.class, mock(PropertyWriter.class)); setDefault(CharSequence.class, "*"); }
@Override public void setUp() throws Exception { super.setUp(); setDefault(JacksonRequestParamFilter.class, mock(JacksonRequestParamFilter.class)); setDefault(Matcher.class, Matcher.all()); setDefault(JsonGenerator.class, mock(JsonGenerator.class)); setDefault(SerializerProvider.class, mock(SerializerProvider.class)); setDefault(PropertyWriter.class, mock(PropertyWriter.class)); setDefault(CharSequence.class, "*"); }
@Override protected boolean include(PropertyWriter writer) { return include(writer.getType()); }
@Override public void serializeAsIncludedField(Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer) throws Exception { writer.serializeAsField(pojo, jgen, provider); }
@Override public void serializeAsExcludedField(Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer) throws Exception { writer.serializeAsOmittedField(pojo, jgen, provider); }
@Override protected boolean include(final PropertyWriter writer) { throw new UnsupportedOperationException("Cannot call include without JsonGenerator"); }
@Override public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider prov, PropertyWriter writer) throws Exception { delegate.serializeAsField(pojo, jgen, prov, writer); }
@Override public void serializeAsElement(Object elementValue, JsonGenerator jgen, SerializerProvider prov, PropertyWriter writer) throws Exception { delegate.serializeAsElement(elementValue, jgen, prov, writer); }
@SuppressWarnings("deprecation") @Override public void depositSchemaProperty(PropertyWriter writer, ObjectNode propertiesNode, SerializerProvider provider) throws JsonMappingException { delegate.depositSchemaProperty(writer, propertiesNode, provider); }
@Override public void depositSchemaProperty(PropertyWriter writer, JsonObjectFormatVisitor objectVisitor, SerializerProvider provider) throws JsonMappingException { delegate.depositSchemaProperty(writer, objectVisitor, provider); }
public KatharsisFieldPropertyFilter(Predicate2<Object, PropertyWriter> includeChecker) { this.includeChecker = includeChecker; }
private boolean include(Object bean, PropertyWriter writer) { return includeChecker.test(bean, writer); }
@Override protected boolean include(PropertyWriter writer) { return include(writer.getFullName().getSimpleName()); }
@Override public void serializeAsElement(Object elementValue, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer) throws Exception { JsonSerializer ser = provider.findValueSerializer(writer.getType()); WebAPI.getLogger().info(writer.getName() + ": " + (ser != null ? ser.getClass().getName() : "")); super.serializeAsElement(elementValue, jgen, provider, writer); }
@Override public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer) throws Exception { if (includeField(pojo, writer)) { writer.serializeAsField(pojo, jgen, provider); } }
@Override protected boolean include(BeanPropertyWriter writer) { return this.include((PropertyWriter)writer); }