diff --git a/pom.xml b/pom.xml index 9b60839..6720c51 100644 --- a/pom.xml +++ b/pom.xml @@ -13,7 +13,7 @@ org.springframework.boot spring-boot-starter-parent - 1.5.8.RELEASE + 1.5.11.RELEASE diff --git a/src/main/java/eu/dnetlib/uoaorcidservice/controllers/MetricsController.java b/src/main/java/eu/dnetlib/uoaorcidservice/controllers/MetricsController.java new file mode 100644 index 0000000..fe3621b --- /dev/null +++ b/src/main/java/eu/dnetlib/uoaorcidservice/controllers/MetricsController.java @@ -0,0 +1,78 @@ +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 countWorksPerDashboard() { + return metricsService.countWorksPerDashboard(); + } + + @RequestMapping(value = "/report/worksPerYear", method = RequestMethod.GET) + public List countWorksPerYear() { + return metricsService.countWorksPerYear(); + } + + @RequestMapping(value = "/report/worksPerYearAndMonth", method = RequestMethod.GET) + public List countWorksPerYearAndMonth() { + return metricsService.countWorksPerYearAndMonth(); + } + + @RequestMapping(value = "/report/worksPerOrcid", method = RequestMethod.GET) + public List countWorksPerOrcid() { + return metricsService.countWorksPerOrcid(); + } + + @RequestMapping(value = "/report/uniqueUsersWithLinksPerMonth", method = RequestMethod.GET) + public List countUniqueUsersWithLinksPerMonth() { + return metricsService.countUniqueUsersWithLinksPerMonth(); + } + + @RequestMapping(value = "/report/uniqueUsersWithLinksPerYear", method = RequestMethod.GET) + public List countUniqueUsersWithLinksPerYear() { + return metricsService.countUniqueUsersWithLinksPerYear(); + } + + @RequestMapping(value = "/report/newUsersPerMonth", method = RequestMethod.GET) + public List countNewUsersPerMonth() { + return metricsService.countNewUsersPerMonth(); + } + + @RequestMapping(value = "/report/newUsersPerYear", method = RequestMethod.GET) + public List countNewUsersPerYear() { + return metricsService.countNewUsersPerYear(); + } + + @RequestMapping(value = "/report/tokensPerOrcid", method = RequestMethod.GET) + public List countTokensPerOrcid() { + return metricsService.countTokensPerOrcid(); + } + + @RequestMapping(value = "/report/totalUniqueUsers", method = RequestMethod.GET) + public List countTotalUniqueUsers() { + return metricsService.countTotalUniqueUsers(); + } + + @RequestMapping(value = "/report/totalWorks", method = RequestMethod.GET) + public List countTotalWorks() { + return metricsService.countTotalWorks(); + } +} diff --git a/src/main/java/eu/dnetlib/uoaorcidservice/dao/MongoDBDAOs/MongoDBUserTokensDAO.java b/src/main/java/eu/dnetlib/uoaorcidservice/dao/MongoDBUserTokensDAO.java similarity index 57% rename from src/main/java/eu/dnetlib/uoaorcidservice/dao/MongoDBDAOs/MongoDBUserTokensDAO.java rename to src/main/java/eu/dnetlib/uoaorcidservice/dao/MongoDBUserTokensDAO.java index 0fd5705..bf04c16 100644 --- a/src/main/java/eu/dnetlib/uoaorcidservice/dao/MongoDBDAOs/MongoDBUserTokensDAO.java +++ b/src/main/java/eu/dnetlib/uoaorcidservice/dao/MongoDBUserTokensDAO.java @@ -1,12 +1,14 @@ -package eu.dnetlib.uoaorcidservice.dao.MongoDBDAOs; +package eu.dnetlib.uoaorcidservice.dao; -import eu.dnetlib.uoaorcidservice.dao.UserTokensDAO; +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; -public interface MongoDBUserTokensDAO extends UserTokensDAO, MongoRepository { +@Repository +public interface MongoDBUserTokensDAO extends MongoDBUserTokensDAOCustom, UserTokensDAO, MongoRepository { List findAll(); diff --git a/src/main/java/eu/dnetlib/uoaorcidservice/dao/MongoDBDAOs/MongoDBWorkDAO.java b/src/main/java/eu/dnetlib/uoaorcidservice/dao/MongoDBWorkDAO.java similarity index 58% rename from src/main/java/eu/dnetlib/uoaorcidservice/dao/MongoDBDAOs/MongoDBWorkDAO.java rename to src/main/java/eu/dnetlib/uoaorcidservice/dao/MongoDBWorkDAO.java index 9616294..481d268 100644 --- a/src/main/java/eu/dnetlib/uoaorcidservice/dao/MongoDBDAOs/MongoDBWorkDAO.java +++ b/src/main/java/eu/dnetlib/uoaorcidservice/dao/MongoDBWorkDAO.java @@ -1,21 +1,24 @@ -package eu.dnetlib.uoaorcidservice.dao.MongoDBDAOs; +package eu.dnetlib.uoaorcidservice.dao; -import eu.dnetlib.uoaorcidservice.dao.WorkDAO; +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; -public interface MongoDBWorkDAO extends WorkDAO, MongoRepository { +@Repository +public interface MongoDBWorkDAO extends MongoDBWorkDAOCustom, WorkDAO, MongoRepository { List findAll(); - Work findById(String Id); + Optional findById(String Id); // List findByPidsContaining(String Pid); // Work findByPidsContainingAndOrcid(String Pid, String Orcid); - List findByPidsInAndOrcid(List Pids, String Orcid); + List findByPidsInAndOrcid(String[] Pids, String Orcid); List findByOrcidOrderByCreationDateDesc(String Orcid); List findByOrcid(String Orcid); diff --git a/src/main/java/eu/dnetlib/uoaorcidservice/dao/WorkDAO.java b/src/main/java/eu/dnetlib/uoaorcidservice/dao/WorkDAO.java index e0c37db..9b16bfd 100644 --- a/src/main/java/eu/dnetlib/uoaorcidservice/dao/WorkDAO.java +++ b/src/main/java/eu/dnetlib/uoaorcidservice/dao/WorkDAO.java @@ -3,11 +3,12 @@ package eu.dnetlib.uoaorcidservice.dao; import eu.dnetlib.uoaorcidservice.entities.Work; import java.util.List; +import java.util.Optional; public interface WorkDAO { List findAll(); - Work findById(String Id); + Optional findById(String Id); // List findByPidsContaining(String Pid); diff --git a/src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOs/MongoDBUserTokensDAOCustom.java b/src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOs/MongoDBUserTokensDAOCustom.java new file mode 100644 index 0000000..183a51f --- /dev/null +++ b/src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOs/MongoDBUserTokensDAOCustom.java @@ -0,0 +1,11 @@ +package eu.dnetlib.uoaorcidservice.dao.customDAOs; + +import java.util.List; + +public interface MongoDBUserTokensDAOCustom { + List newUsersPerMonth(); + List newUsersPerYear(); + + List tokensPerOrcid(); + List totalUniqueUsers(); +} diff --git a/src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOs/MongoDBWorkDAOCustom.java b/src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOs/MongoDBWorkDAOCustom.java new file mode 100644 index 0000000..3783279 --- /dev/null +++ b/src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOs/MongoDBWorkDAOCustom.java @@ -0,0 +1,18 @@ +package eu.dnetlib.uoaorcidservice.dao.customDAOs; + + +import org.springframework.data.mongodb.repository.MongoRepository; + +import java.util.List; + +public interface MongoDBWorkDAOCustom { + List worksPerDashboard(); + List worksPerYear(); + List worksPerYearAndMonth(); + List worksPerOrcid(); + + List uniqueUsersWithLinksPerMonth(); + List uniqueUsersWithLinksPerYear(); + + List totalWorks(); +} diff --git a/src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOsImpl/MongoDBUserTokensDAOImpl.java b/src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOsImpl/MongoDBUserTokensDAOImpl.java new file mode 100644 index 0000000..a603025 --- /dev/null +++ b/src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOsImpl/MongoDBUserTokensDAOImpl.java @@ -0,0 +1,105 @@ +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 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 results = mongoTemplate.aggregate( + agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()), + "userTokens", Object.class); + List 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 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 results = mongoTemplate.aggregate( + agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()), + "userTokens", Object.class); + List mappedResult = results.getMappedResults(); + return mappedResult; + } + + + @Override + public List tokensPerOrcid() { + Aggregation agg = newAggregation( + group("orcid") + .count().as("tokens"), + project("tokens").andInclude("orcid"), + sort(Sort.Direction.DESC, "tokens") + ); + + AggregationResults results = mongoTemplate.aggregate( + agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()), + "userTokens", Object.class); + List mappedResult = results.getMappedResults(); + return mappedResult; + } + + @Override + public List totalUniqueUsers() { + Aggregation agg = newAggregation( + group("orcid"), + count().as("users"), + project("users") + ); + + AggregationResults results = mongoTemplate.aggregate( + agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()), + "userTokens", Object.class); + List mappedResult = results.getMappedResults(); + return mappedResult; + } +} diff --git a/src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOsImpl/MongoDBWorkDAOImpl.java b/src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOsImpl/MongoDBWorkDAOImpl.java new file mode 100644 index 0000000..4543073 --- /dev/null +++ b/src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOsImpl/MongoDBWorkDAOImpl.java @@ -0,0 +1,188 @@ +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 worksPerDashboard() { + + Aggregation agg = newAggregation( + group("dashboard") + .count().as("works"), + project("works") + .and("dashboard").previousOperation(), + sort(Sort.Direction.DESC, "works") + ); + + AggregationResults results = mongoTemplate.aggregate( + agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()), + "work", Object.class); + List 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 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 results = mongoTemplate.aggregate( + agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()), + "work", Object.class); + List 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 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 results = mongoTemplate.aggregate( + agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()), + "work", Object.class); + List mappedResult = results.getMappedResults(); + return mappedResult; + } + +// Work Count per orcid +// db.work.aggregate( { $group : { _id : "$orcid", count: { $sum: 1 } } }, {$sort : { count: -1 }} ); + @Override + public List worksPerOrcid() { + Aggregation agg = newAggregation( + group("orcid") + .count().as("works"), + project("works") + .andInclude("orcid"), + sort(Sort.Direction.DESC, "works") + ); + + AggregationResults results = mongoTemplate.aggregate( + agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()), + "work", Object.class); + List 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 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 results = mongoTemplate.aggregate( + agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()), + "work", Object.class); + List 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 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 results = mongoTemplate.aggregate( + agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()), + "work", Object.class); + List mappedResult = results.getMappedResults(); + return mappedResult; + } + + @Override + public List totalWorks() { + Aggregation agg = newAggregation( + count().as("works"), + project("works") + ); + + AggregationResults results = mongoTemplate.aggregate( + agg.withOptions(newAggregationOptions().cursor(new BasicDBObject()).build()), + "work", Object.class); + List mappedResult = results.getMappedResults(); + return mappedResult; + +// return mongoTemplate.count(null, "work"); + } +} \ No newline at end of file diff --git a/src/main/java/eu/dnetlib/uoaorcidservice/services/MetricsService.java b/src/main/java/eu/dnetlib/uoaorcidservice/services/MetricsService.java new file mode 100644 index 0000000..0ec2743 --- /dev/null +++ b/src/main/java/eu/dnetlib/uoaorcidservice/services/MetricsService.java @@ -0,0 +1,68 @@ +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 countWorksPerDashboard() { + return workDAO.worksPerDashboard(); + } + + public List countWorksPerYear() { + return workDAO.worksPerYear(); + } + + public List countWorksPerYearAndMonth() { + return workDAO.worksPerYearAndMonth(); + } + + public List countWorksPerOrcid() { + return workDAO.worksPerOrcid(); + } + + public List countUniqueUsersWithLinksPerMonth() { + return workDAO.uniqueUsersWithLinksPerMonth(); + } + + public List countUniqueUsersWithLinksPerYear() { + return workDAO.uniqueUsersWithLinksPerYear(); + } + + public List countNewUsersPerMonth() { + return userTokensDAO.newUsersPerMonth(); + } + + public List countNewUsersPerYear() { + return userTokensDAO.newUsersPerYear(); + } + + public List countTokensPerOrcid() { + return userTokensDAO.tokensPerOrcid(); + } + + public List countTotalUniqueUsers() { + return userTokensDAO.totalUniqueUsers(); + } + + public List countTotalWorks() { + return workDAO.totalWorks(); + } +}