D-Net

package eu.dnetlib.data.mapreduce.hbase.bulktag;

import com.google.common.collect.Maps;

import com.google.common.collect.Sets;

import eu.dnetlib.data.bulktag.Pair;

import eu.dnetlib.data.proto.FieldTypeProtos;

import eu.dnetlib.data.proto.OafProtos;

import eu.dnetlib.data.proto.ResultProtos;

import java.util.*;

import java.util.stream.Collectors;

/**

 * Created by miriam on 02/08/2018.

 */

public class ResultTagger {

    private final static String CLASS_ID = "bulktagging::community";

    private final static String SCHEMA_ID = "dnet:provenanceActions";

    private final static String COUNTER_GROUP = "Bulk Tagging";

            context.getCounter(COUNTER_GROUP, "deleted by inference").increment(1);

        final List<ResultProtos.Result.Context> contextList = oaf.getEntity().getResult().getMetadata().getContextList();

            context.getCounter(COUNTER_GROUP, "exist context list").increment(1);

        }else{

            context.getCounter(COUNTER_GROUP, "not exist context list").increment(1);

        }

        final Set<String> communities = new HashSet<>();

                .map(subject -> subject.getValue())

                .filter(StringUtils::isNotBlank)

                .map(String::toLowerCase)

                .map(String::trim)

                .collect(Collectors.toCollection(HashSet::new))

                .forEach(s -> communities.addAll(conf.getCommunityForSubjectValue(s)));

        oaf.getEntity().getResult().getInstanceList()

                .map(i -> new Pair<>(i.getCollectedfrom().getKey(), i.getHostedby().getKey()))

                .map(s -> StringUtils.substringAfter(s, "|"))

                .collect(Collectors.toCollection(HashSet::new))

                .forEach(dsId -> communities.addAll(conf.getCommunityForDatasourceValue(dsId)));

        //TODO: add code for Zenodo Communities

            context.getCounter(COUNTER_GROUP, "list of communities empty").increment(1);

        }else{

            context.getCounter(COUNTER_GROUP, "list of communities has values!").increment(1);

        }

        mBuilder.getContextBuilderList().forEach(cBuilder -> {

            cBuilders.put(cBuilder.getId(), cBuilder);

        });

        for(String contextId:communities){

            if (cBuilder != null) {

                        .map(di -> di.getInferenceprovenance())

                        .anyMatch(s -> DATA_INFO_TYPE.equals(s))) {

                    context.getCounter(COUNTER_GROUP, "add provenance").increment(1);

                } else {

                    context.getCounter(COUNTER_GROUP, "provenance already bulk tagged").increment(1);

                }

                context.getCounter(COUNTER_GROUP, "add context").increment(1);

            }

        }

        return builder.build();

    private ResultProtos.Result.Context buildContext(final String contextId) {

        return ResultProtos.Result.Context.newBuilder()

                .setId(contextId)

                .addDataInfo(buildDataInfo())

                .build();

    }

    private FieldTypeProtos.DataInfo buildDataInfo() {

        FieldTypeProtos.DataInfo.Builder builder = FieldTypeProtos.DataInfo.newBuilder()

                .setInferred(true)

                .setProvenanceaction(

                        FieldTypeProtos.Qualifier.newBuilder()

                                .setClassid(CLASS_ID)

                                .setClassname("Bulk Tagging for Communities")

                                .setSchemeid(SCHEMA_ID)

                                .setSchemename(SCHEMA_NAME))

                .setInferenceprovenance(DATA_INFO_TYPE)

                .build();

    }

        trust = s;

    }

}