@Override
public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer) throws Exception {

    String key = writer.getName();
    @SuppressWarnings("unchecked")
    Collection<Object> values = (Collection<Object>) ((Map<?, ?>) pojo).get(key);

    if (includeParameter(key)) {
        Collection<Object> write = filter(key, values);
        if (CollectionUtils.isNotEmpty(write)) {
            // customize the key
            jgen.writeFieldName(transform(key));

            // only write the element
            ((MapProperty) writer).setValue(write);
            writer.serializeAsElement(write, jgen, provider);
        }
    }
}
 

/**
 * 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;
}
 

@Override
public void serializeAsField(
    final Object object,
    final JsonGenerator generator,
    final SerializerProvider provider,
    final PropertyWriter writer) throws Exception {

    if (generator.canOmitFields()) {

        final Object value = writer.getMember().getValue(object);

        if (value instanceof RntbdToken && !((RntbdToken) value).isPresent()) {
            return;
        }
    }

    writer.serializeAsField(object, generator, provider);
}
 

@Override
protected boolean include(PropertyWriter writer) {
    if (writer.findAnnotation(JsonLogIgnore.class) != null) {
        return false;
    }
    JsonLogIgnoreProperties jsonLogIgnoreProperties =
            writer.findAnnotation(JsonLogIgnoreProperties.class);
    if (jsonLogIgnoreProperties != null) {
        for (String ignoredName : jsonLogIgnoreProperties.value()) {
            if (Objects.equals(ignoredName, writer.getName())) {
                return false;
            }
        }
    }
    return super.include(writer);
}
 

@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());
    }
}
 

private PropertyWriter filter(PropertyWriter writer) {
  if (!transform) {
    return writer;
  }

  SentinelSecure secure = writer.getAnnotation(SentinelSecure.class);
  if (secure == null || secure.value() == null || secure.value().isEmpty()) {
    return writer;
  }

  return new SensitivePropertyWriter((BeanPropertyWriter) writer, secure.value());
}
 

@Override
public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer) throws Exception {
    if (writer.getName().equals("catalogId") && DEFAULT_CATALOG.equals(((Event)pojo).getCatalogId())) {
        return;
    }
    super.serializeAsField(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;

    // Check if we have to skip the field because it is marked as "details" and details is set to false
    // or if we have to turn details off temporarily in case the field is marked as "simple"
    JsonDetails det = writer.getAnnotation(JsonDetails.class);
    if (det != null) {
        if (!details && det.value()) {
            return;
        }

        if (det.simple()) {
            details = false;
        }
    }

    // Add our object to the path
    path.add(key);

    // Check if the permission service allows access to our path
    // If yes then we want to serialize the rest of our object
    if (permissionService.permits(perms, path)) {
        super.serializeAsField(pojo, jgen, provider, writer);
    }

    // Reset path and details after our object is done
    path.remove(key);
    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
public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider provider,
                             PropertyWriter writer)
    throws Exception {
    if (pojo instanceof TaggedLogAPIEntity) {
        TaggedLogAPIEntity entity = (TaggedLogAPIEntity)pojo;
        Set<String> modified = entity.modifiedQualifiers();
        Set<String> basePropertyNames = getPropertyNames();
        String writerName = writer.getName();
        if (modified.contains(writerName) || basePropertyNames.contains(writerName)) {
            if ((!entity.isSerializeVerbose() && verboseFields.contains(writerName))
                || (timestamp.equals(writerName)
                    && !EntityDefinitionManager.isTimeSeries(entity.getClass()))) {
                // log skip
                if (LOG.isDebugEnabled()) {
                    LOG.debug("skip field");
                }
            } else {
                // if serializeAlias is not null and exp is not null
                if (exp.equals(writerName) && entity.getSerializeAlias() != null
                    && entity.getExp() != null) {
                    Map<String, Object> _exp = new HashMap<String, Object>();
                    for (Map.Entry<String, Object> entry : entity.getExp().entrySet()) {
                        String alias = entity.getSerializeAlias().get(entry.getKey());
                        if (alias != null) {
                            _exp.put(alias, entry.getValue());
                        } else {
                            _exp.put(entry.getKey(), entry.getValue());
                        }
                    }
                    entity.setExp(_exp);
                }
                // write included field into serialized json output
                writer.serializeAsField(pojo, jgen, provider);
            }
        }
    } else {
        writer.serializeAsField(pojo, jgen, provider);
    }
}
 

@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);
    }
}
 

@Override
protected boolean include(PropertyWriter writer) {
    return !isFilterable(writer.getMember().getDeclaringClass(), writer.getName());
}
 

@Override
public void serializeAsField(Object pojo, JsonGenerator gen, SerializerProvider prov, PropertyWriter writer)
    throws Exception {
  filter(writer).serializeAsField(pojo, gen, prov);
}
 

@Override
public void serializeAsElement(Object elementValue, JsonGenerator gen, SerializerProvider prov, PropertyWriter writer)
    throws Exception {
  filter(writer).serializeAsElement(elementValue, gen, prov);
}
 

@SuppressWarnings("deprecation")
@Override
public void depositSchemaProperty(PropertyWriter writer, ObjectNode propertiesNode, SerializerProvider provider) throws JsonMappingException {
  writer.depositSchemaProperty(propertiesNode, provider);
}
 

@Override
public void depositSchemaProperty(PropertyWriter writer, JsonObjectFormatVisitor objectVisitor, SerializerProvider provider) throws JsonMappingException {
  writer.depositSchemaProperty(objectVisitor, provider);
}
 

public KatharsisFieldPropertyFilter(Predicate2<Object, PropertyWriter> includeChecker) {
    this.includeChecker = includeChecker;
}
 

private boolean include(Object bean, PropertyWriter writer) {
    return includeChecker.test(bean, 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(PropertyWriter writer) {
    return predicate.test(writer.getName());
}
 

/**
 * Accessor for iterating over logical properties that the type
 * handled by this serializer has, from serialization perspective.
 * Actual type of properties, if any, will be
 * {@link com.fasterxml.jackson.databind.ser.BeanPropertyWriter}.
 * Of standard Jackson serializers, only {@link com.fasterxml.jackson.databind.ser.BeanSerializer}
 * exposes properties.
 *
 * @since 2.6
 */
public Iterator<PropertyWriter> properties() {
    return ClassUtil.emptyIterator();
}