com.kenshoo.pl.entity.internal.audit.AuditedFieldsResolver Maven / Gradle / Ivy

Go to download
package com.kenshoo.pl.entity.internal.audit;

import com.kenshoo.pl.entity.EntityField;
import com.kenshoo.pl.entity.EntityType;
import com.kenshoo.pl.entity.annotation.audit.Audited;
import com.kenshoo.pl.entity.annotation.audit.NotAudited;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Collection;
import java.util.Optional;

import static com.kenshoo.pl.entity.internal.EntityTypeReflectionUtil.isAnnotatedWith;
import static java.util.Objects.requireNonNull;
import static java.util.stream.Collectors.toList;

public class AuditedFieldsResolver {

    private static final Logger logger = LoggerFactory.getLogger(AuditedFieldsResolver.class);

    public static final AuditedFieldsResolver INSTANCE = new AuditedFieldsResolver();

    public > Optional> resolve(final EntityType entityType) {
        requireNonNull(entityType, "entityType is required");

        return entityType.getIdField()
                         .flatMap(idField -> resolve(entityType, idField));
    }

    private > Optional> resolve(final EntityType entityType,
                                                                           final EntityField idField) {
        final boolean entityTypeAudited = entityType.getClass().isAnnotationPresent(Audited.class);
        final Collection> dataFields = entityType.getFields()
                                                                             .filter(field -> !field.equals(idField))
                                                                             .collect(toList());
        if (dataFields.isEmpty()) {
            return resolve(entityType,
                           entityTypeAudited,
                           idField);
        }
        return resolve(entityType,
                       entityTypeAudited,
                       idField,
                       dataFields);
    }

    private > Optional> resolve(final EntityType entityType,
                                                                           final boolean entityTypeAudited,
                                                                           final EntityField idField) {
        if (entityTypeAudited) {
            return Optional.of(AuditedFieldSet.builder(idField).build());
        }
        return noFieldsToAudit(entityType);
    }

    private > Optional> resolve(final EntityType entityType,
                                                                           final boolean entityTypeAudited,
                                                                           final EntityField idField,
                                                                           final Collection> dataFields) {
        final Collection> auditedDataFields =
            dataFields.stream()
                      .filter(field -> isFieldAudited(entityType,
                                                      entityTypeAudited,
                                                      field))
                      .collect(toList());
        if (auditedDataFields.isEmpty()) {
            return noFieldsToAudit(entityType);
        }
        return Optional.of(AuditedFieldSet.builder(idField)
                                          .withDataFields(auditedDataFields)
                                          .build());
    }

    private > boolean isFieldAudited(final EntityType entityType,
                                                             final boolean entityTypeAudited,
                                                             final EntityField field) {
        if (entityTypeAudited) {
            return !isAnnotatedWith(entityType, NotAudited.class, field);
        }
        return isAnnotatedWith(entityType, Audited.class, field);
    }

    private > Optional> noFieldsToAudit(final EntityType entityType) {
        logger.warn("Cannot audit entity type {} because no fields are marked for auditing and/or @Id annotation is missing",
                    entityType);
        return Optional.empty();
    }

    private AuditedFieldsResolver() {
        // Singleton
    }
}