From 6a714c115c0b3fb414fdab62e21e78c6dd97642b Mon Sep 17 00:00:00 2001 From: "konstantina.galouni" Date: Thu, 8 Jul 2021 11:02:27 +0000 Subject: [PATCH] [Trunk | Orcid Service]: 1. pom.xml: Upgrade version of spring boot from 1.5.8.RELEASE to 1.5.11.RELEASE (for custom queries in DB). 2. dao/MongoDBDAOs: Deleted folder MongoDBDAOs and moved its files (MongoDBUserTokensDAO.java, MongoDBWorkDAO.java) to parent (/dao) folder. 3. dao/customDAOs: Added customDAOs folder and files MongoDBUserTokensDAOCustom.java, MongoDBWorkDAOCustom.java (interfaces for custom query methods - for metrics). 4. dao/customDAOsImpl: Added customDAOsImpl folder and files MongoDBUserTokensDAOImpl.java, MongoDBWorkDAOImpl.java (implementation of interfaces for custom query methods - for metrics). 5. services/MetricsService.java: Added service to call custom query methods for metrics. 6. MetricsController.java: Added controller for API methods to expose custom query methods for metrics. 7. WorkDAO.java: Changed method signature "Optional findById(String Id);" to return Optional. 8. MongoDBWorkDAO.java: Changed method signature "Optional findById(String Id);" to return Optional | [Bug fix] In method "findByPidsInAndOrcid()", first parameter is array, not list. --- pom.xml | 2 +- .../controllers/MetricsController.java | 78 ++++++++ .../MongoDBUserTokensDAO.java | 8 +- .../dao/{MongoDBDAOs => }/MongoDBWorkDAO.java | 13 +- .../dnetlib/uoaorcidservice/dao/WorkDAO.java | 3 +- .../MongoDBUserTokensDAOCustom.java | 11 + .../dao/customDAOs/MongoDBWorkDAOCustom.java | 18 ++ .../MongoDBUserTokensDAOImpl.java | 105 ++++++++++ .../customDAOsImpl/MongoDBWorkDAOImpl.java | 188 ++++++++++++++++++ .../services/MetricsService.java | 68 +++++++ 10 files changed, 484 insertions(+), 10 deletions(-) create mode 100644 src/main/java/eu/dnetlib/uoaorcidservice/controllers/MetricsController.java rename src/main/java/eu/dnetlib/uoaorcidservice/dao/{MongoDBDAOs => }/MongoDBUserTokensDAO.java (57%) rename src/main/java/eu/dnetlib/uoaorcidservice/dao/{MongoDBDAOs => }/MongoDBWorkDAO.java (58%) create mode 100644 src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOs/MongoDBUserTokensDAOCustom.java create mode 100644 src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOs/MongoDBWorkDAOCustom.java create mode 100644 src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOsImpl/MongoDBUserTokensDAOImpl.java create mode 100644 src/main/java/eu/dnetlib/uoaorcidservice/dao/customDAOsImpl/MongoDBWorkDAOImpl.java create mode 100644 src/main/java/eu/dnetlib/uoaorcidservice/services/MetricsService.java 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(); + } +}