D-Net

package eu.dnetlib.uoaorcidservice.dao.customDAOs;

import java.util.List;

public interface MongoDBUserTokensDAOCustom {

    List<Object> newUsersPerMonth();

    List<Object> newUsersPerYear();

    List<Object> tokensPerOrcid();

    List<Object> totalUniqueUsers();

}

package eu.dnetlib.uoaorcidservice.dao.customDAOs;

import org.springframework.data.mongodb.repository.MongoRepository;

import java.util.List;

public interface MongoDBWorkDAOCustom {

    List<Object> worksPerDashboard();

    List<Object> worksPerYear();

    List<Object> worksPerYearAndMonth();

    List<Object> worksPerOrcid();

    List<Object> uniqueUsersWithLinksPerMonth();

    List<Object> uniqueUsersWithLinksPerYear();

    List<Object> totalWorks();

}

package eu.dnetlib.uoaorcidservice.dao.customDAOsImpl;

import com.mongodb.BasicDBObject;

import eu.dnetlib.uoaorcidservice.dao.customDAOs.MongoDBUserTokensDAOCustom;

import org.apache.log4j.Logger;

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

import org.springframework.data.domain.Sort;

import org.springframework.data.mongodb.core.MongoTemplate;

import org.springframework.data.mongodb.core.aggregation.Aggregation;

import org.springframework.data.mongodb.core.aggregation.AggregationResults;

import org.springframework.data.mongodb.core.aggregation.DateOperators;

import java.util.List;

import static org.springframework.data.mongodb.core.aggregation.Aggregation.*;

import static org.springframework.data.mongodb.core.aggregation.Aggregation.newAggregationOptions;

public class MongoDBUserTokensDAOImpl implements MongoDBUserTokensDAOCustom {

    private final Logger log = Logger.getLogger(this.getClass());

    private final MongoTemplate mongoTemplate;

    @Autowired

    public MongoDBUserTokensDAOImpl(MongoTemplate mongoTemplate) {

        this.mongoTemplate = mongoTemplate;

    }

    //    monthly  new users grant openaire

//    db.userTokens.aggregate([{"$group":{  "_id":{    "date":{$dateToString: { format: "%Y-%m", date: "$creationDate" }},    orcid: "$orcid"   },  "count":{"$sum":1}}},{"$group":{  "_id":"$_id.date",  "count":{"$sum":1}}}, {$sort : { _id: 1 }} ])

    @Override

    public List<Object> newUsersPerMonth() {

        Aggregation agg = newAggregation(

                project("orcid")

                        .and(DateOperators.dateOf("creationDate").month()).as("month")

                        .and(DateOperators.dateOf("creationDate").year()).as("year"),

                group("month", "year", "orcid")

                        .count().as("orcid_works"),

                group("month", "year")

                        .count().as("works"),

                project("works")

                        .andInclude("month", "year")

        );

        AggregationResults<Object> results = mongoTemplate.aggregate(

                agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()),

                "userTokens", Object.class);

        List<Object> mappedResult = results.getMappedResults();

        return mappedResult;

    }

    //    yearly  new users grant openaire

//    db.userTokens.aggregate([{"$group":{  "_id":{    "date":{$dateToString: { format: "%Y", date: "$creationDate" }},    orcid: "$orcid"   },  "count":{"$sum":1}}},{"$group":{  "_id":"$_id.date",  "count":{"$sum":1}}}, {$sort : { _id: 1 }} ])

    @Override

    public List<Object> newUsersPerYear() {

        Aggregation agg = newAggregation(

                project("orcid")

                        .and(DateOperators.dateOf("creationDate").year()).as("year"),

                group("year", "orcid")

                        .count().as("orcid_works"),

                group("year")

                        .count().as("works"),

                project("works")

                        .andInclude("year")

        );

        AggregationResults<Object> results = mongoTemplate.aggregate(

                agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()),

                "userTokens", Object.class);

        List<Object> mappedResult = results.getMappedResults();

        return mappedResult;

    }

    @Override

    public List<Object> tokensPerOrcid() {

        Aggregation agg = newAggregation(

                group("orcid")

                        .count().as("tokens"),

                project("tokens").andInclude("orcid"),

                sort(Sort.Direction.DESC, "tokens")

        );

        AggregationResults<Object> results = mongoTemplate.aggregate(

                agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()),

                "userTokens", Object.class);

        List<Object> mappedResult = results.getMappedResults();

        return mappedResult;

    }

    @Override

    public List<Object> totalUniqueUsers() {

        Aggregation agg = newAggregation(

                group("orcid"),

                count().as("users"),

                project("users")

        );

        AggregationResults<Object> results = mongoTemplate.aggregate(

                agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()),

                "userTokens", Object.class);

        List<Object> mappedResult = results.getMappedResults();

        return mappedResult;

    }

}

package eu.dnetlib.uoaorcidservice.dao.customDAOsImpl;

import com.mongodb.BasicDBObject;

import eu.dnetlib.uoaorcidservice.dao.customDAOs.MongoDBWorkDAOCustom;

import org.apache.log4j.Logger;

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

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

import org.springframework.context.annotation.Primary;

import org.springframework.data.domain.Sort;

import org.springframework.data.mongodb.core.MongoTemplate;

import org.springframework.data.mongodb.core.aggregation.*;

import java.util.List;

import static org.springframework.data.mongodb.core.aggregation.Aggregation.*;

public class MongoDBWorkDAOImpl implements MongoDBWorkDAOCustom {

    private final Logger log = Logger.getLogger(this.getClass());

    private final MongoTemplate mongoTemplate;

    @Autowired

    public MongoDBWorkDAOImpl(MongoTemplate mongoTemplate) {

        this.mongoTemplate = mongoTemplate;

    }

//    works per dashboard

//    db.work.aggregate(  { $group : {  _id : "$dashboard",   count: { $sum: 1 } } }, {$sort : { count: -1 }}  );

    @Override

    public List<Object> worksPerDashboard() {

        Aggregation agg = newAggregation(

                group("dashboard")

                        .count().as("works"),

                project("works")

                        .and("dashboard").previousOperation(),

                sort(Sort.Direction.DESC, "works")

        );

        AggregationResults<Object> results = mongoTemplate.aggregate(

                agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()),

                "work", Object.class);

        List<Object> mappedResult = results.getMappedResults();

        return mappedResult;

    }

//    Yearly work sum

//    db.work.aggregate( { $group : { _id : { $dateToString: { format: "%Y", date: "$creationDate" } }, count: { $sum: 1 } } } , {$sort : { _id: 1 }} );

    @Override

    public List<Object> worksPerYear() {

//        Aggregation agg = newAggregation(

////                project( "creationDate", "putCode" )

//

////                project().and("creationDate").as("creationDate").and("putCode").as("_id")

////                project("orcid", "putCode").and("year(creationDate)").as("_id")

//

////                group("year(creationDate)"),

////                project().and("year(creationDate)").previousOperation()

//

//

//                project().and(DateOperators.dateOf("creationDate").year()).as("field1")

//

////                project().andInclude("orcid", "putCode").and("year(creationDate)").previousOperation()

////                        .and("creationDate").previousOperation()

//        );

        Aggregation agg = newAggregation(

                project().and(DateOperators.dateOf("creationDate").year()).as("year"),

                group("year")

                        .count().as("works"),

                project("works")

                        .and("year").previousOperation()

        );

        AggregationResults<Object> results = mongoTemplate.aggregate(

                agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()),

                "work", Object.class);

        List<Object> mappedResult = results.getMappedResults();

        return mappedResult;

    }

//    Monthly work sum

//    db.work.aggregate( { $group : { _id : { $dateToString: { format: "%Y-%m", date: "$creationDate" } }, count: { $sum: 1 } } } , {$sort : { _id: 1 }} );

//    @Override

    public List<Object> worksPerYearAndMonth() {

        Aggregation agg = newAggregation(

                project()

                        .and(DateOperators.dateOf("creationDate").year()).as("year")

                        .and(DateOperators.dateOf("creationDate").month()).as("month"),

                group("month", "year")

                        .count().as("works"),

                project("works")

                        .andInclude("month", "year")

        );

        AggregationResults<Object> results = mongoTemplate.aggregate(

                agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()),

                "work", Object.class);

        List<Object> mappedResult = results.getMappedResults();

        return mappedResult;

    }

//    Work Count per orcid

//    db.work.aggregate(  { $group : {  _id : "$orcid",   count: { $sum: 1 } } }, {$sort : { count: -1 }}  );

    @Override

    public List<Object> worksPerOrcid() {

        Aggregation agg = newAggregation(

                group("orcid")

                        .count().as("works"),

                project("works")

                        .andInclude("orcid"),

                sort(Sort.Direction.DESC, "works")

        );

        AggregationResults<Object> results = mongoTemplate.aggregate(

                agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()),

                "work", Object.class);

        List<Object> mappedResult = results.getMappedResults();

        return mappedResult;

    }

//    monthly  usage: unique users that linked a work

//    db.work.aggregate([{"$group":{  "_id":{    "date":{$dateToString: { format: "%Y-%m", date: "$creationDate" }},    orcid: "$orcid"   },  "count":{"$sum":1}}},{"$group":{  "_id":"$_id.date",  "count":{"$sum":1}}}, {$sort : { _id: 1 }} ])

    @Override

    public List<Object> uniqueUsersWithLinksPerMonth() {

        Aggregation agg = newAggregation(

                project("orcid")

                        .and(DateOperators.dateOf("creationDate").month()).as("month")

                        .and(DateOperators.dateOf("creationDate").year()).as("year"),

                group("month", "year", "orcid")

                        .count().as("orcid_works"),

                group("month", "year")

                        .count().as("works"),

                project("works")

                        .andInclude("month", "year")

        );

        AggregationResults<Object> results = mongoTemplate.aggregate(

                agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()),

                "work", Object.class);

        List<Object> mappedResult = results.getMappedResults();

        return mappedResult;

    }

//    yearly  usage: unique users that linked a work

//    db.work.aggregate([{"$group":{  "_id":{    "date":{$dateToString: { format: "%Y", date: "$creationDate" }},    orcid: "$orcid"   },  "count":{"$sum":1}}},{"$group":{  "_id":"$_id.date",  "count":{"$sum":1}}}, {$sort : { _id: 1 }} ])

    @Override

    public List<Object> uniqueUsersWithLinksPerYear() {

        Aggregation agg = newAggregation(

                project("orcid")

                        .and(DateOperators.dateOf("creationDate").year()).as("year"),

                group("year", "orcid")

                        .count().as("orcid_works"),

                group("year")

                        .count().as("works"),

                project("works")

                        .andInclude("year")

        );

        AggregationResults<Object> results = mongoTemplate.aggregate(

                agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()),

                "work", Object.class);

        List<Object> mappedResult = results.getMappedResults();

        return mappedResult;

    }

    @Override

    public List<Object> totalWorks() {

        Aggregation agg = newAggregation(

                count().as("works"),

                project("works")

        );

        AggregationResults<Object> results = mongoTemplate.aggregate(

                agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()),

                "work", Object.class);

        List<Object> mappedResult = results.getMappedResults();

        return mappedResult;

//        return mongoTemplate.count(null, "work");

    }

}

import java.util.Optional;

    Optional<Work> findById(String Id);

package eu.dnetlib.uoaorcidservice.dao;

import eu.dnetlib.uoaorcidservice.dao.customDAOs.MongoDBUserTokensDAOCustom;

import eu.dnetlib.uoaorcidservice.entities.UserTokens;

import org.springframework.data.mongodb.repository.MongoRepository;

import org.springframework.stereotype.Repository;

import java.util.List;

@Repository

public interface MongoDBUserTokensDAO extends MongoDBUserTokensDAOCustom, UserTokensDAO, MongoRepository<UserTokens, String> {

    List<UserTokens> findAll();

    UserTokens findByAaiId(String AaiId);

    UserTokens findByOrcid(String Orcid);

    UserTokens save(UserTokens userTokens);

    void deleteAll();

    void deleteByAaiId(String AaiId);

    void deleteByOrcid(String Orcid);

}

package eu.dnetlib.uoaorcidservice.dao;

import eu.dnetlib.uoaorcidservice.dao.customDAOs.MongoDBWorkDAOCustom;

import eu.dnetlib.uoaorcidservice.entities.Work;

import org.springframework.data.mongodb.repository.MongoRepository;

import org.springframework.stereotype.Repository;

import java.util.List;

import java.util.Optional;

@Repository

public interface MongoDBWorkDAO extends MongoDBWorkDAOCustom, WorkDAO, MongoRepository<Work, String> {

    List<Work> findAll();

    Optional<Work> findById(String Id);

//    List<Work> findByPidsContaining(String Pid);

//    Work findByPidsContainingAndOrcid(String Pid, String Orcid);

    List<Work> findByPidsInAndOrcid(String[] Pids, String Orcid);

    List<Work> findByOrcidOrderByCreationDateDesc(String Orcid);

    List<Work> findByOrcid(String Orcid);

    Work findByPutCode(String putCode);

    Work save(Work work);

    void deleteAll();

    void deleteById(String Id);

    void deleteByPutCode(String PutCode);

}

package eu.dnetlib.uoaorcidservice.services;

import eu.dnetlib.uoaorcidservice.dao.MongoDBUserTokensDAO;

import eu.dnetlib.uoaorcidservice.dao.customDAOs.MongoDBUserTokensDAOCustom;

import eu.dnetlib.uoaorcidservice.dao.customDAOs.MongoDBWorkDAOCustom;

import org.apache.log4j.Logger;

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

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

import org.springframework.stereotype.Service;

import java.util.List;

@Service

public class MetricsService {

    private final Logger log = Logger.getLogger(this.getClass());

    @Autowired

    @Qualifier("mongoDBWorkDAO")

    private MongoDBWorkDAOCustom workDAO;

    @Autowired

    @Qualifier("mongoDBUserTokensDAO")

    private MongoDBUserTokensDAOCustom userTokensDAO;

    public List<Object> countWorksPerDashboard() {

        return workDAO.worksPerDashboard();

    }

    public List<Object> countWorksPerYear() {

        return workDAO.worksPerYear();

    }

    public List<Object> countWorksPerYearAndMonth() {

        return workDAO.worksPerYearAndMonth();

    }

    public List<Object> countWorksPerOrcid() {

        return workDAO.worksPerOrcid();

    }

    public List<Object> countUniqueUsersWithLinksPerMonth() {

        return workDAO.uniqueUsersWithLinksPerMonth();

    }

    public List<Object> countUniqueUsersWithLinksPerYear() {

        return workDAO.uniqueUsersWithLinksPerYear();

    }

    public List<Object> countNewUsersPerMonth() {

        return userTokensDAO.newUsersPerMonth();

    }

    public List<Object> countNewUsersPerYear() {

        return userTokensDAO.newUsersPerYear();

    }

    public List<Object> countTokensPerOrcid() {

        return userTokensDAO.tokensPerOrcid();

    }

    public List<Object> countTotalUniqueUsers() {

        return userTokensDAO.totalUniqueUsers();

    }

    public List<Object> countTotalWorks() {

        return workDAO.totalWorks();

    }

}

package eu.dnetlib.uoaorcidservice.controllers;

import eu.dnetlib.uoaorcidservice.configuration.properties.OrcidConfig;

import eu.dnetlib.uoaorcidservice.services.MetricsService;

import org.apache.log4j.Logger;

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

import org.springframework.web.bind.annotation.CrossOrigin;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController

@CrossOrigin(origins = "*")

public class MetricsController {

    private final Logger log = Logger.getLogger(this.getClass());

    private final Logger orcid_log = Logger.getLogger("ORCID-" + this.getClass().getName());

    @Autowired

    private MetricsService metricsService;

    @RequestMapping(value = "/report/worksPerDashboard", method = RequestMethod.GET)

    public List<Object> countWorksPerDashboard() {

        return metricsService.countWorksPerDashboard();

    }

    @RequestMapping(value = "/report/worksPerYear", method = RequestMethod.GET)

    public List<Object> countWorksPerYear() {

        return metricsService.countWorksPerYear();

    }

    @RequestMapping(value = "/report/worksPerYearAndMonth", method = RequestMethod.GET)

    public List<Object> countWorksPerYearAndMonth() {

        return metricsService.countWorksPerYearAndMonth();

    }

    @RequestMapping(value = "/report/worksPerOrcid", method = RequestMethod.GET)

    public List<Object> countWorksPerOrcid() {

        return metricsService.countWorksPerOrcid();

    }

    @RequestMapping(value = "/report/uniqueUsersWithLinksPerMonth", method = RequestMethod.GET)

    public List<Object> countUniqueUsersWithLinksPerMonth() {

        return metricsService.countUniqueUsersWithLinksPerMonth();

    }

    @RequestMapping(value = "/report/uniqueUsersWithLinksPerYear", method = RequestMethod.GET)

    public List<Object> countUniqueUsersWithLinksPerYear() {

        return metricsService.countUniqueUsersWithLinksPerYear();

    }

    @RequestMapping(value = "/report/newUsersPerMonth", method = RequestMethod.GET)

    public List<Object> countNewUsersPerMonth() {

        return metricsService.countNewUsersPerMonth();

    }

    @RequestMapping(value = "/report/newUsersPerYear", method = RequestMethod.GET)

    public List<Object> countNewUsersPerYear() {

        return metricsService.countNewUsersPerYear();

    }

    @RequestMapping(value = "/report/tokensPerOrcid", method = RequestMethod.GET)

    public List<Object> countTokensPerOrcid() {

        return metricsService.countTokensPerOrcid();

    }

    @RequestMapping(value = "/report/totalUniqueUsers", method = RequestMethod.GET)

    public List<Object> countTotalUniqueUsers() {

        return metricsService.countTotalUniqueUsers();

    }

    @RequestMapping(value = "/report/totalWorks", method = RequestMethod.GET)

    public List<Object> countTotalWorks() {

        return metricsService.countTotalWorks();

    }

}

		<version>1.5.11.RELEASE</version>