• Home
• dev.binis
• code-generator
• 1.2.17
• source code
• ValidationEnricherHandler.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

net.binis.codegen.enrich.handler.ValidationEnricherHandler Maven / Gradle / Ivy

package net.binis.codegen.enrich.handler;

/*-
 * #%L
 * code-generator
 * %%
 * Copyright (C) 2021 - 2024 Binis Belev
 * %%
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * #L%
 */

import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.Node;
import com.github.javaparser.ast.body.AnnotationDeclaration;
import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
import com.github.javaparser.ast.body.MethodDeclaration;
import com.github.javaparser.ast.expr.*;
import com.github.javaparser.ast.stmt.BlockStmt;
import com.github.javaparser.ast.stmt.ExpressionStmt;
import com.github.javaparser.ast.stmt.ReturnStmt;
import com.github.javaparser.ast.stmt.Statement;
import com.github.javaparser.ast.type.Type;
import com.github.javaparser.utils.StringEscapeUtils;
import lombok.Builder;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import net.binis.codegen.annotation.validation.*;
import net.binis.codegen.enrich.Enrichers;
import net.binis.codegen.enrich.ValidationEnricher;
import net.binis.codegen.enrich.handler.base.BaseEnricher;
import net.binis.codegen.exception.GenericCodeGenException;
import net.binis.codegen.factory.CodeFactory;
import net.binis.codegen.generation.core.Helpers;
import net.binis.codegen.generation.core.interfaces.PrototypeDescription;
import net.binis.codegen.generation.core.interfaces.PrototypeField;
import net.binis.codegen.generation.core.types.ModifierType;
import net.binis.codegen.options.Options;
import net.binis.codegen.tools.CollectionUtils;
import net.binis.codegen.tools.ContextInterpolator;
import net.binis.codegen.tools.Holder;
import net.binis.codegen.tools.Tools;
import org.apache.commons.lang3.StringUtils;

import javax.lang.model.element.ElementKind;
import java.util.*;
import java.util.stream.Collectors;

import static com.github.javaparser.ast.Modifier.Keyword.PUBLIC;
import static java.util.Objects.isNull;
import static java.util.Objects.nonNull;
import static net.binis.codegen.generation.core.EnrichHelpers.*;
import static net.binis.codegen.generation.core.Helpers.*;
import static net.binis.codegen.tools.Reflection.invoke;
import static net.binis.codegen.tools.Reflection.loadClass;
import static net.binis.codegen.tools.Tools.*;

@Slf4j
public class ValidationEnricherHandler extends BaseEnricher implements ValidationEnricher {

    protected static final String VALUE = "value";
    protected static final String PARAMS = "params";
    protected static final String MESSAGE = "message";
    protected static final String MESSAGES = "messages";
    protected static final String AS_CODE = "asCode";
    protected static final String TARGETS = "targets";

    protected static final Class TARGETS_AWARE = loadClass("net.binis.codegen.validation.consts.ValidationTargets$TargetsAware");

    @Override
    public void enrich(PrototypeDescription description) {
        //Do nothing
    }

    @Override
    public void finalizeEnrich(PrototypeDescription description) {
        var form = new StringBuilder();
        description.getFields().forEach(f -> handleField(description, f, form, false));

        if (nonNull(description.getMixIn())) {
            description.getMixIn().getFields().forEach(f -> handleField(description, f, form, true));
        }

        if (description.hasOption(Options.VALIDATION_FORM)) {
            buildValidationForm(description, form);
        }
    }

    @Override
    public int order() {
        return 0;
    }

    protected void handleField(PrototypeDescription description, PrototypeField field, StringBuilder code, boolean mixIn) {
        var form = description.hasOption(Options.VALIDATION_FORM) ? formMethod(field) : null;
        field.getDescription().getAnnotations().stream().filter(this::isValidationAnnotation).forEach(a -> processAnnotation(description, field, a, form, false, mixIn));

        if (field.isCollection()) {
            field.getDescription().getType().asClassOrInterfaceType().getTypeArguments().ifPresent(args ->
                    args.forEach(type -> type.getAnnotations().stream().filter(this::isValidationAnnotation).forEach(a -> processAnnotation(description, field, a, form, true, mixIn))));
        }

        if (nonNull(form)) {
            var isChild = hasChildren(field);
            var exp = form.getBody().get().getStatement(0).toString();
            if (exp.length() > field.getName().length() + 5) {
                code.append("e -> ").append(exp.replace(".start(", ".start(e, "));
                code.setLength(code.length() - 1);
                if (isChild) {
                    code.insert(code.lastIndexOf(".perform("), ".child()");
                }
                code.append(",\n");
            } else if (isChild) {
                code.append("e -> Validation.start(e, this.getClass(), \"").append(field.getName()).append("\", ").append(field.getName()).append(").child(),\n");
            }
        }
    }

    protected boolean hasChildren(PrototypeField field) {
        var result = hasForm(field.getPrototype());
        if (!result && CollectionUtils.isNotEmpty(field.getTypePrototypes())) {
            result = field.getTypePrototypes().values().stream().anyMatch(this::hasForm);
        }
        return result;
    }

    protected boolean hasForm(PrototypeDescription desc) {
        return nonNull(desc) && desc.hasEnricher(Enrichers.VALIDATION) && desc.hasOption(Options.VALIDATION_FORM);
    }

    protected void processAnnotation(PrototypeDescription description, PrototypeField field, AnnotationExpr annotation, MethodDeclaration form, boolean collection, boolean mixIn) {
        var name = Helpers.getExternalClassNameIfExists(unit(annotation), annotation.getNameAsString());

        var cls = loadClass(name);
        if (nonNull(cls)) {
            if (Validate.class.equals(cls) || cls.isAnnotationPresent(Validate.class)) {
                generateValidation(description, field, annotation, cls, form, collection, mixIn);
            } else if (Sanitize.class.equals(cls) || cls.isAnnotationPresent(Sanitize.class)) {
                generateSanitization(description, field, annotation, cls, form, collection, mixIn);
            } else if (Execute.class.equals(cls) || cls.isAnnotationPresent(Execute.class)) {
                generateExecution(description, field, annotation, cls, collection, mixIn);
            }
        } else {
            Tools.with(lookup.findExternal(name), d ->
                    handleAnnotationFromSource(description, d.getDeclaration().asAnnotationDeclaration(), field, annotation, form, collection, mixIn));
        }

        var mod = description.getRegisteredClass("EmbeddedModifier");
        if (isNull(mod)) {
            mod = description.getRegisteredClass("Modifier");
        }
        if (nonNull(mod)) {
            Helpers.addSuppressWarningsUnchecked(mod);
        }
        if (nonNull(field.getImplementationSetter())) {
            Helpers.addSuppressWarningsUnchecked(description.getImplementation());
        }
    }

//    protected void processTypeAnnotations(PrototypeDescription description, PrototypeField field, List annotations, MethodDeclaration form) {
//        var exp = new StringBuilder("Validation.start(this.getClass(), \"")
//                .append(field.getName())
//                .append("\", ")
//                .append(field.getName())
//                .append(").collection().");
//
//        annotations.forEach(annotation -> {
//            var name = Helpers.getExternalClassNameIfExists(annotation.findCompilationUnit().get(), annotation.getNameAsString());
//
//            var cls = loadClass(name);
//            if (nonNull(cls)) {
//                if (Validate.class.equals(cls) || cls.isAnnotationPresent(Validate.class)) {
//                    var params = getValidationParams(field, annotation, cls);
//                    exp.append("validate")
//                            .append(nonNull(params.getMessages()) ? "WithMessages(" : "(")
//                            .append(params.getCls())
//                            .append(".class, ")
//                            .append(calcMessage(params))
//                            .append(buildParamsStr(params, field, ModifierType.FORM))
//                            .append(")");
//                } else if (Sanitize.class.equals(cls) || cls.isAnnotationPresent(Sanitize.class)) {
//                    var params = getSanitizationParams(field, annotation, cls);
//                    exp.append("sanitize(")
//                            .append(params.getCls())
//                            .append(".class")
//                            .append(buildParamsStr(params, field, ModifierType.FORM))
//                            .append(")");
//                } else if (Execute.class.equals(cls) || cls.isAnnotationPresent(Execute.class)) {
//                    var params = getExecutionParams(field, annotation, cls);
//                    exp.append("execute(")
//                            .append(params.getCls())
//                            .append(".class, ")
//                            .append(calcMessage(params))
//                            .append(buildParamsStr(params, field, ModifierType.FORM))
//                            .append(")");
//                }
//            } else {
////                notNull(lookup.findExternal(name), d ->
////                        handleAnnotationFromSource(description, d.getDeclaration().asAnnotationDeclaration(), field, annotation, form));
//            }
//        });
//
//        log.info(exp.toString());
//
//    }


    protected void handleAnnotationFromSource(PrototypeDescription description, AnnotationDeclaration decl, PrototypeField field, AnnotationExpr annotation, MethodDeclaration form, boolean collection, boolean mixIn) {
        var ann = decl.getAnnotationByClass(Validate.class);
        if (ann.isPresent()) {
            generateValidation(description, field, annotation, ann.get(), decl, form, collection, mixIn);
        } else {
            ann = decl.getAnnotationByClass(Sanitize.class);
            if (ann.isPresent()) {
                generateSanitization(description, field, annotation, ann.get(), decl, form, collection, mixIn);
            } else {
                decl.getAnnotationByClass(Execute.class).ifPresent(annotationExpr ->
                        generateExecution(description, field, annotation, annotationExpr, decl, collection, mixIn));
            }
        }
    }

    protected void generateSanitization(PrototypeDescription description, PrototypeField field, AnnotationExpr annotation, AnnotationExpr ann, AnnotationDeclaration annotationClass, MethodDeclaration form, boolean collection, boolean mixIn) {
        var params = getSanitizationParams(field, annotation, ann, annotationClass);
        field.getDeclaration().findCompilationUnit().ifPresent(u -> u.addImport(getExternalClassName(annotationClass.findCompilationUnit().get(), params.getCls())));
        generateSanitization(description, field, params, form, collection, mixIn);
    }

    protected void generateSanitization(PrototypeDescription description, PrototypeField field, AnnotationExpr annotation, Class annotationClass, MethodDeclaration form, boolean collection, boolean mixIn) {
        generateSanitization(description, field, getSanitizationParams(field, annotation, annotationClass), form, collection, mixIn);
    }

    protected void generateSanitization(PrototypeDescription description, PrototypeField field, Params params, MethodDeclaration form, boolean collection, boolean mixIn) {
        if (!mixIn && nonNull(field.getImplementationSetter())) {
            addSanitization(field, field.getImplementationSetter(), params, ModifierType.MAIN, collection);
        }

        field.getModifiers().stream()
                .filter(m -> !mixIn || m.getOrigin().equals(description))
                .forEach(modifier ->
                        addSanitization(field, modifier.getModifier(), params, modifier.getType(), collection));

        if (!mixIn && description.hasOption(Options.VALIDATION_FORM)) {
            addSanitization(field, form, params, ModifierType.FORM, collection);
        }
    }

    protected Params getSanitizationParams(PrototypeField field, AnnotationExpr annotation, AnnotationExpr ann, AnnotationDeclaration annotationClass) {
        var params = Params.builder();

        handleSanitizationAnnotation(ann, params);
        //TODO: Handle aliases

        return checkTargets(params.build(), field);
    }

    protected Params getSanitizationParams(PrototypeField field, AnnotationExpr annotation, Class annotationClass) {
        String cls = null;
        var params = Params.builder();

        if (!Sanitize.class.equals(annotationClass)) {
            var ann = annotationClass.getDeclaredAnnotation(Sanitize.class);
            params.cls(ann.value().getSimpleName()).params(Arrays.asList(ann.params())).targets(processTargetsClass(ann.targets()));
            cls = ann.value().getCanonicalName();
            field.getDeclaration().findCompilationUnit().get().addImport(cls);

            handleAliases(field, annotation, annotationClass, params);
        } else {
            handleSanitizationAnnotation(annotation, params);
        }

        var result = checkTargets(params.build(), field);

        if (isNull(result.getAsCode())) {
            Tools.with(loadClass(isNull(cls) ? getExternalClassName(field.getParsed().getDeclaration().findCompilationUnit().get(), result.getCls()) : cls), c ->
                    Tools.with(c.getDeclaredAnnotation(AsCode.class), a -> result.setAsCode(a.value())));
        }

        return result;
    }

    protected void handleSanitizationAnnotation(AnnotationExpr annotation, Params.ParamsBuilder params) {
        for (var node : annotation.getChildNodes()) {
            if (node instanceof ClassExpr exp) {
                params.cls(exp.getTypeAsString());
            } else if (node instanceof MemberValuePair pair) {
                switch (pair.getNameAsString()) {
                    case VALUE -> {
                        var cls = pair.getValue().asClassExpr().getTypeAsString();
                        params.cls(cls).full(getExternalClassName(pair, cls));
                    }
                    case TARGETS -> params.targets(processTargets(pair.getValue()));
                    case PARAMS ->
                            params.params(pair.getValue().asArrayInitializerExpr().getValues().stream().map(Expression::asStringLiteralExpr).map(StringLiteralExpr::asString).collect(Collectors.toList()));
                    case AS_CODE -> params.asCode(pair.getValue().asStringLiteralExpr().asString());
                    default -> {
                        //Do nothing
                    }
                }
            }
        }
    }

    protected Params getValidationParams(PrototypeField field, AnnotationExpr annotation, AnnotationExpr ann, AnnotationDeclaration annotationClass) {
        var params = Params.builder();

        handleValidationAnnotation(ann, params);
        //TODO: Handle aliases

        return checkTargets(params.build(), field);
    }

    protected Params getValidationParams(PrototypeField field, AnnotationExpr annotation, Class annotationClass) {
        var params = Params.builder();
        String cls = null;

        if (!Validate.class.equals(annotationClass)) {
            var ann = annotationClass.getDeclaredAnnotation(Validate.class);
            cls = ann.value().getCanonicalName();
            params.cls(ann.value().getSimpleName()).full(cls).params(Arrays.asList(ann.params())).message(ann.message()).targets(processTargetsClass(ann.targets()));
            handleAliases(field, annotation, annotationClass, params);
        } else {
            handleValidationAnnotation(annotation, params);
        }

        var result = checkTargets(params.build(), field);

        if (isNull(result.getAsCode())) {
            Tools.with(loadClass(isNull(cls) ? getExternalClassName(unit(field.getParsed().getDeclaration()), result.getCls()) : cls), c ->
                    Tools.with(c.getDeclaredAnnotation(AsCode.class), a -> result.setAsCode(a.value())));
        }

        return result;
    }

    protected void handleValidationAnnotation(AnnotationExpr annotation, ValidationEnricherHandler.Params.ParamsBuilder params) {
        for (var node : annotation.getChildNodes()) {
            if (node instanceof ClassExpr exp) {
                params.cls(exp.getTypeAsString()).full(getExternalClassName(exp, exp.getTypeAsString()));
            } else if (node instanceof MemberValuePair pair) {
                switch (pair.getNameAsString()) {
                    case VALUE -> {
                        var cls = pair.getValue().asClassExpr().getTypeAsString();
                        params.cls(cls).full(getExternalClassName(pair, cls));
                    }
                    case MESSAGE -> params.message(pair.getValue().asStringLiteralExpr().asString());
                    case MESSAGES ->
                            params.messages(pair.getValue().asArrayInitializerExpr().getValues().stream().map(e -> e.asStringLiteralExpr().asString()).collect(Collectors.toList()));
                    case PARAMS -> {
                        if (pair.getValue().isArrayInitializerExpr()) {
                            params.params(pair.getValue().asArrayInitializerExpr().getValues().stream().map(Expression::asStringLiteralExpr).map(StringLiteralExpr::asString).collect(Collectors.toList()));
                        } else {
                            params.params(List.of(pair.getValue())).annotation(unit(annotation));
                        }
                    }
                    case AS_CODE -> params.asCode(pair.getValue().asStringLiteralExpr().asString());
                    case TARGETS -> params.targets(processTargets(pair.getValue()));
                    default -> {
                        //Do nothing
                    }
                }
            }
        }
    }

    protected void handleAliases(PrototypeField field, AnnotationExpr annotation, Class annotationClass, Params.ParamsBuilder params) {
        var list = new ArrayList