D-Net

package eu.dnetlib.data.bulktag;

import eu.dnetlib.data.bulktag.selectioncriteria.Selection;

import eu.dnetlib.data.bulktag.selectioncriteria.VerbResolver;

import org.springframework.beans.factory.annotation.Autowired;

import java.io.Serializable;

import java.lang.reflect.InvocationTargetException;

public class Constraint implements Serializable {

    private String verb;

    private String field;

    private String value;

    private Selection selection;

//    @Autowired

//    private VerbResolver resolver;

    public Constraint() {

    }

    public String getVerb() {

        return verb;

    }

    public void setVerb(String verb) {

        this.verb = verb;

    }

    public String getField() {

        return field;

    }

    public void setField(String field) {

        this.field = field;

    }

    public String getValue() {

        return value;

    }

    public void setValue(String value) {

        this.value = value;

    }

    public void setSelection(Selection sel){

        selection = sel;

    }

    public void setSelection(VerbResolver resolver) throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {

        selection = resolver.getSelectionCriteria(verb,value);

    }

    public boolean verifyCriteria(String metadata){

        return selection.apply(metadata);

    }

   /* public boolean verifyCriteria(String metadata) throws InvocationTargetException, IllegalAccessException {

        Method method;

        boolean ret = false;

        if(verb.contains("equal")){

            method = getStringMethod(metadata,verb);

        }else{

            method = getCharSequenceMethod(metadata,verb);

        }

        if (method == null)

            return false;

        ret = (boolean)method.invoke(metadata,value);

        if(verb.startsWith("not_"))

            return !ret;

        return ret;

    }

    private Method getCharSequenceMethod(String metadata, String verb) {

        try{

            if(verb.startsWith("not_")) {

                return metadata.getClass().getMethod(verb.substring(4), CharSequence.class);

            }

            else{

                return metadata.getClass().getMethod(verb, CharSequence.class);

            }

        }catch(NoSuchMethodException nsme){

        }

        return null;

    }

    private Method getStringMethod(String metadata, String verb) {

        try{

            if(verb.startsWith("not_")) {

                return metadata.getClass().getMethod(verb.substring(4), String.class);

            }

            else{

                return metadata.getClass().getMethod(verb, String.class);

            }

        }catch(NoSuchMethodException nsme){

        }

        return null;

    }*/

}

package eu.dnetlib.data.bulktag.selectioncriteria;

import org.reflections.Reflections;

import java.io.Serializable;

import java.lang.reflect.InvocationTargetException;

import java.util.Map;

import java.util.stream.Collectors;

public class VerbResolver implements Serializable {

    private final Map<String, Class<Selection>> map;

    public VerbResolver(){

        this.map = new Reflections("eu.dnetlib").getTypesAnnotatedWith(VerbClass.class).stream()

                .collect(Collectors.toMap(v -> v.getAnnotation(VerbClass.class).value(), v->(Class<Selection>)v));

    }

    public Selection getSelectionCriteria(String name, String param) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

            return map.get(name).getDeclaredConstructor((String.class)).newInstance(param);

    }

}

package eu.dnetlib.data.bulktag.selectioncriteria;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.TYPE)

public @interface VerbClass {

    public String value();

}

package eu.dnetlib.data.bulktag.selectioncriteria;

public interface Selection {

    boolean apply(String value);

}

package eu.dnetlib.data.bulktag.selectioncriteria;

@VerbClass("equals")

public class EqualVerb implements Selection {

    private String param;

    public EqualVerb(final String param) {

        this.param = param;

    }

    @Override

    public boolean apply(String value) {

        return value.equalsIgnoreCase(param);

    }

}

package eu.dnetlib.data.bulktag.selectioncriteria;

@VerbClass("not_equals")

public class NotEqualVerb implements Selection {

    private String param;

    public NotEqualVerb(final String param) {

        this.param = param;

    }

    @Override

    public boolean apply(String value) {

        return !value.equalsIgnoreCase(param);

    }

}

package eu.dnetlib.data.bulktag.selectioncriteria;

public class VerbResolverFactory {

    public static VerbResolver newInstance(){

        return new VerbResolver();

    }

}

package eu.dnetlib.data.bulktag.selectioncriteria;

@VerbClass("contains")

public class ContainsVerb implements Selection {

    private String param;

    public ContainsVerb(final String param) {

        this.param = param;

    }

    @Override

    public boolean apply(String value) {

        return value.contains(param);

    }

}

package eu.dnetlib.data.bulktag.selectioncriteria;

@VerbClass("not_contains")

public class NotContainsVerb implements Selection {

    private String param;

    public NotContainsVerb(final String param) {

        this.param = param;

    }

    @Override

    public boolean apply(String value) {

        return !value.contains(param);

    }

}

package eu.dnetlib.data.bulktag;

import com.google.common.reflect.TypeToken;

import com.google.gson.Gson;

import eu.dnetlib.data.bulktag.selectioncriteria.VerbResolver;

import java.io.Serializable;

import java.lang.reflect.Type;

import java.util.Collection;

import java.util.List;

import java.util.Map;

public class SelectionConstraints implements Serializable {

    private List<Constraints>criteria;

//    private VerbResolver resolver;

//

//    public VerbResolver getResolver() {

//        return resolver;

//    }

    public SelectionConstraints() {

    }

    public List<Constraints> getCriteria() {

        return criteria;

    }

    public void setCriteria(List<Constraints> criteria) {

        this.criteria = criteria;

    }

    public void setSc(String json){

        Type collectionType = new TypeToken<Collection<Constraints>>(){}.getType();

        criteria = new Gson().fromJson(json, collectionType);

    }

    //Constraints in or

//    public boolean verifyCriteria(Map<String,String> param){

//        for(Constraints selc: criteria){

//            if(selc.verifyCriteria(param)){

//                return true;

//            }

//        }

//        return false;

//    }

    public boolean verifyCriteria(Map<String,List<String>> param){

        for(Constraints selc: criteria){

            if(selc.verifyCriteria(param)){

                return true;

            }

        }

        return false;

    }

    public void setSelection(VerbResolver resolver) {

        for(Constraints cs : criteria){

            cs.setSelection(resolver);

        }

    }

}