/ - Diff - D-Net - D-Net project tracking tool

     package eu.dnetlib.repo.manager.shared.broker;
     import com.google.gwt.user.client.rpc.IsSerializable;
     /**
      * Created by claudio on 26/07/16.
      */
     public class Provenance implements IsSerializable {
         private String repositoryName;
         private String url;
         private String id;
         public Provenance() {
+        }
         public String getRepositoryName() {
             return repositoryName;
+        }
         public void setRepositoryName(String repositoryName) {
             this.repositoryName = repositoryName;
+        }
         public String getUrl() {
             return url;
+        }
         public void setUrl(String url) {
             this.url = url;
+        }
         public String getId() {
             return id;
+        }
         public void setId(String id) {
             this.id = id;
+        }
+    }

     package eu.dnetlib.repo.manager.shared.broker;
     import com.google.gwt.user.client.rpc.IsSerializable;
     import java.util.List;
     /**
      * Created by stefanos on 26/10/2016.
      */
     public class EventsPage implements IsSerializable{
         private String datasource;
         private String topic;
         private long currPage;
         private long totalPages;
         private long total;
         private List<OpenAireEventPayload> values;
         public EventsPage() {
+        }
         public EventsPage(final String datasource, final String topic, final long currPage, final long totalPages, final long total,
                           final List<OpenAireEventPayload> values) {
             this.datasource = datasource;
             this.topic = topic;
             this.currPage = currPage;
             this.totalPages = totalPages;
             this.total = total;
             this.values = values;
+        }
         public String getDatasource() {
             return datasource;
+        }
         public void setDatasource(String datasource) {
             this.datasource = datasource;
+        }
         public String getTopic() {
             return topic;
+        }
         public void setTopic(String topic) {
             this.topic = topic;
+        }
         public long getCurrPage() {
             return currPage;
+        }
         public void setCurrPage(long currPage) {
             this.currPage = currPage;
+        }
         public long getTotalPages() {
             return totalPages;
+        }
         public void setTotalPages(long totalPages) {
             this.totalPages = totalPages;
+        }
         public long getTotal() {
             return total;
+        }
         public void setTotal(long total) {
             this.total = total;
+        }
         public List<OpenAireEventPayload> getValues() {
             return values;
+        }
         public void setValues(List<OpenAireEventPayload> values) {
             this.values = values;
+        }
+    }

     package eu.dnetlib.repo.manager.shared.broker;
     import com.google.gwt.user.client.rpc.IsSerializable;
     /**
      * Created by claudio on 22/07/16.
      */
     public class Instance implements IsSerializable {
         private String url;
         private String license;
         private String hostedby;
         private String instancetype;
         public Instance() {
+        }
         public String getUrl() {
             return url;
+        }
         public void setUrl(String url) {
             this.url = url;
+        }
         public String getLicense() {
             return license;
+        }
         public void setLicense(String license) {
             this.license = license;
+        }
         public String getHostedby() {
             return hostedby;
+        }
         public void setHostedby(String hostedby) {
             this.hostedby = hostedby;
+        }
         public String getInstancetype() {
             return instancetype;
+        }
         public void setInstancetype(String instancetype) {
             this.instancetype = instancetype;
+        }
+    }

     package eu.dnetlib.repo.manager.shared.broker;
     import com.google.gwt.user.client.rpc.IsSerializable;
     import java.util.ArrayList;
     import java.util.List;
     /**
      * Created by stefanos on 17/3/2017.
      */
     public class MapConditions implements IsSerializable {
         private String field;
         private MapValueType fieldType;
         private ConditionOperator operator;
         private List<ConditionParams> listParams = new ArrayList<>();
         public MapConditions() {
+        }
         public String getField() {
             return field;
+        }
         public void setField(String field) {
             this.field = field;
+        }
         public MapValueType getFieldType() {
             return fieldType;
+        }
         public void setFieldType(MapValueType fieldType) {
             this.fieldType = fieldType;
+        }
         public ConditionOperator getOperator() {
             return operator;
+        }
         public void setOperator(ConditionOperator operator) {
             this.operator = operator;
+        }
         public List<ConditionParams> getListParams() {
             return listParams;
+        }
         public void setListParams(List<ConditionParams> listParams) {
             this.listParams = listParams;
+        }
+    }

     package eu.dnetlib.repo.manager.shared.broker;
     import com.google.gwt.user.client.rpc.IsSerializable;
     /**
      * Created by claudio on 22/07/16.
      */
     public class Journal implements IsSerializable {
         private String name;
         private String issn;
         private String eissn;
         private String lissn;
         public Journal() {
+        }
         public String getName() {
             return name;
+        }
         public void setName(String name) {
             this.name = name;
+        }
         public String getIssn() {
             return issn;
+        }
         public void setIssn(String issn) {
             this.issn = issn;
+        }
         public String getEissn() {
             return eissn;
+        }
         public void setEissn(String eissn) {
             this.eissn = eissn;
+        }
         public String getLissn() {
             return lissn;
+        }
         public void setLissn(String lissn) {
             this.lissn = lissn;
+        }
+    }

     package eu.dnetlib.repo.manager.shared.broker;
     import com.google.gwt.user.client.rpc.IsSerializable;
     import java.util.ArrayList;
     import java.util.List;
     /**
      * Created by claudio on 22/07/16.
      */
     public class Publication implements IsSerializable {
         private String originalId;
         private List<String> titles = new ArrayList<>();
         private List<String> abstracts = new ArrayList<>();
         private String language;
         private List<String> subjects = new ArrayList<>();
         private List<String> creators = new ArrayList<>();
         private String publicationdate;
         private String publisher;
         private String embargoenddate;
         private List<String> contributor = new ArrayList<>();
         private Journal journal;
         private List<String> collectedFrom = new ArrayList<>();
         private List<Pid> pids = new ArrayList<>();
         private List<Instance> instances = new ArrayList<>();
         private List<ExternalReference> externalReferences = new ArrayList<>();
         private List<Project> projects = new ArrayList<>();
         private List<Dataset> datasets = new ArrayList<>();
         public Publication() {
+        }
         public String getOriginalId() {
             return originalId;
+        }
         public void setOriginalId(String originalId) {
             this.originalId = originalId;
+        }
         public List<String> getTitles() {
             return titles;
+        }
         public void setTitles(List<String> titles) {
             this.titles = titles;
+        }
         public List<String> getAbstracts() {
             return abstracts;
+        }
         public void setAbstracts(List<String> abstracts) {
             this.abstracts = abstracts;
+        }
         public String getLanguage() {
             return language;
+        }
         public void setLanguage(String language) {
             this.language = language;
+        }
         public List<String> getSubjects() {
             return subjects;
+        }
         public void setSubjects(List<String> subjects) {
             this.subjects = subjects;
+        }
         public List<String> getCreators() {
             return creators;
+        }
         public void setCreators(List<String> creators) {
             this.creators = creators;
+        }
         public String getPublicationdate() {
             return publicationdate;
+        }
         public void setPublicationdate(String publicationdate) {
             this.publicationdate = publicationdate;
+        }
         public String getPublisher() {
             return publisher;
+        }
         public void setPublisher(String publisher) {
             this.publisher = publisher;
+        }
         public String getEmbargoenddate() {
             return embargoenddate;
+        }
         public void setEmbargoenddate(String embargoenddate) {
             this.embargoenddate = embargoenddate;
+        }
         public List<String> getContributor() {
             return contributor;
+        }
         public void setContributor(List<String> contributor) {
             this.contributor = contributor;
+        }
         public Journal getJournal() {
             return journal;
+        }
         public void setJournal(Journal journal) {
             this.journal = journal;
+        }
         public List<String> getCollectedFrom() {
             return collectedFrom;
+        }
         public void setCollectedFrom(List<String> collectedFrom) {
             this.collectedFrom = collectedFrom;
+        }
         public List<Pid> getPids() {
             return pids;
+        }
         public void setPids(List<Pid> pids) {
             this.pids = pids;
+        }
         public List<Instance> getInstances() {
             return instances;
+        }
         public void setInstances(List<Instance> instances) {
             this.instances = instances;
+        }
         public List<ExternalReference> getExternalReferences() {
             return externalReferences;
+        }
         public void setExternalReferences(List<ExternalReference> externalReferences) {
             this.externalReferences = externalReferences;
+        }
         public List<Project> getProjects() {
             return projects;
+        }
         public void setProjects(List<Project> projects) {
             this.projects = projects;
+        }
         public List<Dataset> getDatasets() {
             return datasets;
+        }
         public void setDatasets(List<Dataset> datasets) {
             this.datasets = datasets;
+        }
+    }

     package eu.dnetlib.repo.manager.shared.broker;
     import com.google.gwt.user.client.rpc.IsSerializable;
     /**
      * Created by claudio on 11/07/16.
      */
     public class OpenAireEventPayload implements IsSerializable {
         private Publication publication;
         private Publication highlight;
         private Provenance provenance;
         private float trust;
         public OpenAireEventPayload() {
+        }
         public Publication getPublication() {
             return publication;
+        }
         public void setPublication(Publication publication) {
             this.publication = publication;
+        }
         public Publication getHighlight() {
             return highlight;
+        }
         public void setHighlight(Publication highlight) {
             this.highlight = highlight;
+        }
         public Provenance getProvenance() {
             return provenance;
+        }
         public void setProvenance(Provenance provenance) {
             this.provenance = provenance;
+        }
         public float getTrust() {
             return trust;
+        }
         public void setTrust(float trust) {
             this.trust = trust;
+        }
+    }

     package eu.dnetlib.repo.manager.shared.broker;
     import com.google.gwt.user.client.rpc.IsSerializable;
     /**
      * Created by claudio on 22/07/16.
      */
     public class Pid implements IsSerializable {
         private String value;
         private String type;
         public Pid() {
+        }
         public String getValue() {
             return value;
+        }
         public void setValue(String value) {
             this.value = value;
+        }
         public String getType() {
             return type;
+        }
         public void setType(String type) {
             this.type = type;
+        }
+    }

     package eu.dnetlib.repo.manager.shared.broker;
     import com.google.gwt.user.client.rpc.IsSerializable;
     import java.util.List;
     public class Dataset implements IsSerializable {
         private List<String> titles;
         private List<String> collectedFrom;
         private List<Pid> pids;
         private List<Instance> instances;
         public Dataset() {
+        }
         public Dataset(final List<String> titles, final List<String> collectedFrom, final List<Pid> pids, final List<Instance> instances) {
             this.titles = titles;
             this.collectedFrom = collectedFrom;
             this.pids = pids;
             this.instances = instances;
+        }
         public List<String> getTitles() {
             return titles;
+        }
         public void setTitles(List<String> titles) {
             this.titles = titles;
+        }
         public List<String> getCollectedFrom() {
             return collectedFrom;
+        }
         public void setCollectedFrom(List<String> collectedFrom) {
             this.collectedFrom = collectedFrom;
+        }
         public List<Pid> getPids() {
             return pids;
+        }
         public void setPids(List<Pid> pids) {
             this.pids = pids;
+        }
         public List<Instance> getInstances() {
             return instances;
+        }
         public void setInstances(List<Instance> instances) {
             this.instances = instances;
+        }
+    }

     package eu.dnetlib.repo.manager.shared.broker;
     import com.google.gwt.user.client.rpc.IsSerializable;
     /**
      * Created by stefanos on 10-Mar-17.
      */
     public enum NotificationMode implements IsSerializable {
         MOCK, EMAIL
+    }

     package eu.dnetlib.repo.manager.shared;
     import com.fasterxml.jackson.annotation.JsonProperty;
     import com.google.gwt.user.client.rpc.IsSerializable;
     import java.util.List;
     /**
      * Created by stefania on 11/7/17.
      */
     public class MetricsNumbers implements IsSerializable {
         private List<String> downloads;
         private List<String> views;
         @JsonProperty("total_downloads")
         private String totalDownloads;
         @JsonProperty("total_views")
         private String totalViews;
         @JsonProperty("total_openaire_downloads")
         private String totalOpenAIREDownloads;
         @JsonProperty("total_openaire_views")
         private String totalOpenAIREViews;
         @JsonProperty("pageviews")
         private String pageViews;
         public MetricsNumbers() {
+        }
         public MetricsNumbers(List<String> downloads, List<String> views, String totalDownloads, String totalViews,
                               String totalOpenAIREDownloads, String totalOpenAIREViews, String pageViews) {
             this.downloads = downloads;
             this.views = views;
             this.totalDownloads = totalDownloads;
             this.totalViews = totalViews;
             this.totalOpenAIREDownloads = totalOpenAIREDownloads;
             this.totalOpenAIREViews = totalOpenAIREViews;
             this.pageViews = pageViews;
+        }
         public List<String> getDownloads() {
             return downloads;
+        }
         public void setDownloads(List<String> downloads) {
             this.downloads = downloads;
+        }
         public List<String> getViews() {
             return views;
+        }
         public void setViews(List<String> views) {
             this.views = views;
+        }
         public String getTotalDownloads() {
             return totalDownloads;
+        }
         public void setTotalDownloads(String totalDownloads) {
             this.totalDownloads = totalDownloads;
+        }
         public String getTotalViews() {
             return totalViews;
+        }
         public void setTotalViews(String totalViews) {
             this.totalViews = totalViews;
+        }
         public String getTotalOpenAIREDownloads() {
             return totalOpenAIREDownloads;
+        }
         public void setTotalOpenAIREDownloads(String totalOpenAIREDownloads) {
             this.totalOpenAIREDownloads = totalOpenAIREDownloads;
+        }
         public String getTotalOpenAIREViews() {
             return totalOpenAIREViews;
+        }
         public void setTotalOpenAIREViews(String totalOpenAIREViews) {
             this.totalOpenAIREViews = totalOpenAIREViews;
+        }
         public String getPageViews() {
             return pageViews;
+        }
         public void setPageViews(String pageViews) {
             this.pageViews = pageViews;
+        }
+    }

     package eu.dnetlib.repo.manager.service.controllers;
     import eu.dnetlib.domain.data.PiwikInfo;
     import eu.dnetlib.utils.md5.MD5;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.beans.factory.annotation.Qualifier;
     import org.springframework.dao.EmptyResultDataAccessException;
     import org.springframework.jdbc.core.JdbcTemplate;
     import org.springframework.jdbc.core.RowMapper;
     import org.springframework.stereotype.Component;
     import org.springframework.web.bind.annotation.PathVariable;
     import org.springframework.web.bind.annotation.RequestBody;
     import javax.annotation.PostConstruct;
     import javax.sql.DataSource;
     import java.security.NoSuchAlgorithmException;
     import java.sql.ResultSet;
     import java.sql.SQLException;
     import java.sql.Types;
     import java.util.List;
     @Component
     public class PiWikApiImpl implements PiWikApi{
         @Autowired
         @Qualifier("repomanager.dataSource")
         private DataSource dataSource;
         private static final org.apache.log4j.Logger LOGGER = org.apache.log4j.Logger
                 .getLogger(PiWikApiImpl.class);
         private final static String GET_PIWIK_SITE = "select repositoryid, siteid, authenticationtoken, creationdate, requestorname, requestoremail, validated, validationdate, comment, repositoryname, country from piwik_site where repositoryid = ?;";
         private final static String INSERT_PIWIK_INFO = "insert into piwik_site (repositoryid, siteid, creationdate, requestorname, requestoremail, validated, repositoryname, country, authenticationtoken) values (?, ?, now(), ?, ?, ?, ?, ?, ?)";
         private final static String GET_PIWIK_SITES = "select repositoryid, siteid, authenticationtoken, creationdate, requestorname, requestoremail, validated, validationdate, comment, repositoryname, country from piwik_site order by repositoryname";
         private final static String APPROVE_PIWIK_SITE = "update piwik_site set validated=true, validationdate=now() where repositoryid = ?;";
         private RowMapper<PiwikInfo> piwikRowMapper = (rs, i) -> new PiwikInfo(rs.getString("repositoryid"), getOpenaireId(rs.getString("repositoryid")), rs.getString("repositoryname"), rs.getString("country"),
                 rs.getString("siteid"), rs.getString("authenticationtoken"), rs.getTimestamp("creationdate"), rs.getString("requestorname"), rs.getString("requestoremail"),
                 rs.getBoolean("validated"), rs.getTimestamp("validationdate"), rs.getString("comment"));
         @Override
         public PiwikInfo getPiwikSiteForRepo(@PathVariable("repositoryId") String repositoryId) {
             try{
                 return new JdbcTemplate(dataSource).queryForObject(GET_PIWIK_SITE, new String[]{repositoryId}, new int[]{Types.VARCHAR}, piwikRowMapper);
             }catch (EmptyResultDataAccessException e){
                 return null;
+            }
+        }
         @Override
         public PiwikInfo savePiwikInfo(@RequestBody PiwikInfo piwikInfo) {
             JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
             jdbcTemplate.update(INSERT_PIWIK_INFO, new Object[]{piwikInfo.getRepositoryId(), piwikInfo.getSiteId(), piwikInfo.getRequestorName(),
                             piwikInfo.getRequestorEmail(), piwikInfo.isValidated(), piwikInfo.getRepositoryName(), piwikInfo.getCountry(), piwikInfo.getAuthenticationToken()},
                     new int[]{Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.BOOLEAN, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR});
             return piwikInfo;
+        }
         @Override
         public List<PiwikInfo> getPiwikSitesForRepos() {
             LOGGER.debug("Getting piwik sites for repos! ");
             try{
                 return new JdbcTemplate(dataSource).query(GET_PIWIK_SITES, piwikRowMapper);
             }catch (EmptyResultDataAccessException e){
                 return null;
+            }
+        }
         @Override
         public void approvePiwikSite(@PathVariable("repositoryId") String repositoryId) {
             new JdbcTemplate(dataSource).update(APPROVE_PIWIK_SITE, new Object[] {repositoryId}, new int[] {Types.VARCHAR});
+        }
         @Override
         public String getOpenaireId(@PathVariable("repositoryId") String repositoryId) {
             LOGGER.debug("Getting openaire id for repository: " + repositoryId);
             try {
                 if (repositoryId != null && repositoryId.contains("::")) {
                     return repositoryId.split("::")[0] + "::" + MD5.encrypt2Hex(repositoryId.split("::")[1]);
+                }
                 else
                     return null;
             } catch (NoSuchAlgorithmException e) {
                 LOGGER.debug(e);
+            }
             return null;
+        }
+    }

     package eu.dnetlib.repo.manager.shared;
     import com.google.gwt.user.client.rpc.IsSerializable;
     /**
      * Created by panagiotis on 15/1/2018.
      */
     public class Term implements IsSerializable {
         public String englishName;
         public String nativeName;
         public String encoding;
         public String code;
         public Term(String englishName, String nativeName, String encoding, String code) {
             this.englishName = englishName;
             this.nativeName = nativeName;
             this.encoding = encoding;
             this.code = code;
+        }
         public String getEnglishName() {
             return englishName;
+        }
         public void setEnglishName(String englishName) {
             this.englishName = englishName;
+        }
         public String getNativeName() {
             return nativeName;
+        }
         public void setNativeName(String nativeName) {
             this.nativeName = nativeName;
+        }
         public String getEncoding() {
             return encoding;
+        }
         public void setEncoding(String encoding) {
             this.encoding = encoding;
+        }
         public String getCode() {
             return code;
+        }
         public void setCode(String code) {
             this.code = code;
+        }
+    }

     package eu.dnetlib.repo.manager.shared.broker;
     import com.google.gwt.user.client.rpc.IsSerializable;
     import java.util.ArrayList;
     import java.util.List;
     public class AdvQueryObject implements IsSerializable {
         private String datasource = "";
         private String topic = "";
         private List<String> titles = new ArrayList<>();
         private List<String> subjects = new ArrayList<>();
         private List<String> authors = new ArrayList<>();
         private List<Range> dates = new ArrayList<>();
         private Range trust = new Range("0", "1");
         private long page = 0;
         public AdvQueryObject() {
+        }
         public AdvQueryObject(String datasource, String topic, List<String> titles, List<String> subjects, List<String> authors,
                               List<Range> dates, Range trust, long page) {
             this.datasource = datasource;
             this.topic = topic;
             this.titles = titles;
             this.subjects = subjects;
             this.authors = authors;
             this.dates = dates;
             this.trust = trust;
             this.page = page;
+        }
         public String getDatasource() {
             return datasource;
+        }
         public void setDatasource(String datasource) {
             this.datasource = datasource;
+        }
         public String getTopic() {
             return topic;
+        }
         public void setTopic(String topic) {
             this.topic = topic;
+        }
         public List<String> getTitles() {
             return titles;
+        }
         public void setTitles(List<String> titles) {
             this.titles = titles;
+        }
         public List<String> getSubjects() {
             return subjects;
+        }
         public void setSubjects(List<String> subjects) {
             this.subjects = subjects;
+        }
         public List<String> getAuthors() {
             return authors;
+        }
         public void setAuthors(List<String> authors) {
             this.authors = authors;
+        }
         public List<Range> getDates() {
             return dates;
+        }
         public void setDates(List<Range> dates) {
             this.dates = dates;
+        }
         public Range getTrust() {
             return trust;
+        }
         public void setTrust(Range trust) {
             this.trust = trust;
+        }
         public long getPage() {
             return page;
+        }
         public void setPage(long page) {
             this.page = page;
+        }
+    }

     package eu.dnetlib.repo.manager.service.controllers;
     import eu.dnetlib.api.functionality.ValidatorServiceException;
     import eu.dnetlib.domain.functionality.validator.JobForValidation;
     import eu.dnetlib.domain.functionality.validator.RuleSet;
     import eu.dnetlib.domain.functionality.validator.StoredJob;
     import eu.dnetlib.repo.manager.shared.InterfaceInformation;
     import eu.dnetlib.repo.manager.shared.ValidationServiceException;
     import io.swagger.annotations.Api;
     import org.json.JSONException;
     import org.springframework.http.MediaType;
     import org.springframework.web.bind.annotation.*;
     import java.util.List;
     @RestController
     @RequestMapping(value = "/validator")
     @Api(description = "Validator API",  tags = {"validator"})
     public interface ValidatorApi {
         @RequestMapping(value = "/submitJobForValidation",method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE )
         @ResponseBody
         void submitJobForValidation(JobForValidation jobForValidation);
         @RequestMapping(value = "/reSubmitJobForValidation/{jobId}",method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE )
         @ResponseBody
         void reSubmitJobForValidation(String jobId) throws JSONException;
         @RequestMapping(value = "/getRuleSets/{mode}" , method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         List<RuleSet> getRuleSets(String mode);
         @RequestMapping(value = "/getSetsOfRepository" , method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         List<String> getSetsOfRepository(String url);
         @RequestMapping(value = "/identifyRepository" , method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         boolean identifyRepo(String url);
         @RequestMapping(value = "/getRuleSet/{acronym}" , method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         RuleSet getRuleSet(String acronym);
         @RequestMapping(value = "/getStoredJobsNew" , method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         List<StoredJob> getStoredJobsNew(String user,
                                          String jobType,
                                          String offset,
                                          String limit,
                                          String dateFrom,
                                          String dateTo,
                                          String validationStatus) throws ValidatorServiceException;
         @RequestMapping(value = "/getStoredJobsTotalNumberNew" , method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         int getStoredJobsTotalNumberNew(String user, String jobType, String validationStatus) throws ValidatorServiceException;
         @RequestMapping(value = "/getInterfaceInformation/" , method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         InterfaceInformation getInterfaceInformation(String baseUrl) throws ValidationServiceException;
+    }

     package eu.dnetlib.repo.manager.shared;
     import com.google.gwt.user.client.rpc.IsSerializable;
     import java.util.ArrayList;
     import java.util.List;
     public class Aggregations implements IsSerializable{
         private List<AggregationDetails> aggregationHistory = new ArrayList<>();
         private AggregationDetails lastCollection;
         private AggregationDetails lastTransformation;
         public Aggregations() {
+        }
         public List<AggregationDetails> getAggregationHistory() {
             return aggregationHistory;
+        }
         public void setAggregationHistory(List<AggregationDetails> aggregationHistory) {
             this.aggregationHistory = aggregationHistory;
+        }
         public AggregationDetails getLastCollection() {
             return lastCollection;
+        }
         public void setLastCollection(AggregationDetails lastCollection) {
             this.lastCollection = lastCollection;
+        }
         public AggregationDetails getLastTransformation() {
             return lastTransformation;
+        }
         public void setLastTransformation(AggregationDetails lastTransformation) {
             this.lastTransformation = lastTransformation;
+        }
+    }

     package eu.dnetlib.repo.manager.shared;
     import com.google.gwt.user.client.rpc.IsSerializable;
     /**
      * Created by stefania on 2/10/16.
      */
     public class WizardState implements IsSerializable {
+    }

     package eu.dnetlib.repo.manager.service.controllers;
     import com.fasterxml.jackson.databind.JsonNode;
     import com.fasterxml.jackson.databind.ObjectMapper;
     import eu.dnetlib.domain.data.Repository;
     import eu.dnetlib.repo.manager.shared.BrokerException;
     import eu.dnetlib.repo.manager.shared.Term;
     import eu.dnetlib.repo.manager.shared.Tuple;
     import eu.dnetlib.repo.manager.shared.broker.*;
     import io.swagger.annotations.ApiParam;
     import org.json.JSONException;
     import org.json.JSONObject;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.beans.factory.annotation.Value;
     import org.springframework.core.ParameterizedTypeReference;
     import org.springframework.http.HttpEntity;
     import org.springframework.http.HttpHeaders;
     import org.springframework.http.HttpMethod;
     import org.springframework.http.ResponseEntity;
     import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
     import org.springframework.stereotype.Component;
     import org.springframework.util.LinkedMultiValueMap;
     import org.springframework.util.MultiValueMap;
     import org.springframework.web.bind.annotation.PathVariable;
     import org.springframework.web.bind.annotation.RequestBody;
     import org.springframework.web.bind.annotation.RequestParam;
     import org.springframework.web.client.RestClientException;
     import org.springframework.web.client.RestTemplate;
     import org.springframework.web.util.UriComponents;
     import org.springframework.web.util.UriComponentsBuilder;
     import javax.annotation.PostConstruct;
     import java.io.IOException;
     import java.io.InputStream;
     import java.net.URL;
     import java.util.*;
     @Component
     public class BrokerApiImpl implements BrokerApi {
         @Autowired
         private RepositoryApiImpl repoAPI;
         @Value("${services.broker.url}:${services.broker.port}/${services.broker.api}${services.broker.openaire}")
         private String openairePath;
         @Value("${services.broker.url}:${services.broker.port}/${services.broker.api}")
         private String apiPath;
         @Value("${topic_types.url}")
         private String topicsURL;
         private static final org.apache.log4j.Logger LOGGER = org.apache.log4j.Logger
                 .getLogger(BrokerApiImpl.class);
         private RestTemplate restTemplate = null;
         private HttpHeaders httpHeaders;
         private HashMap<String,Term> topics = new HashMap<String, Term>();
         @PostConstruct
         private void initDnetTopicsMap() {
             restTemplate = new RestTemplate();
             restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
             httpHeaders = new HttpHeaders();
             httpHeaders.set("Content-Type", "application/json");
             LOGGER.debug("Init dnet topics!");
             InputStream is = null;
             try {
                 is = new URL(topicsURL).openStream();
                 ObjectMapper mapper = new ObjectMapper();
                 JsonNode root = mapper.readTree(is);
                 for (JsonNode term : root.path("terms") )
                     topics.put(term.path("code").textValue(), parseTerm(term));
             } catch (IOException e) {
                 LOGGER.debug(e);
                 e.printStackTrace();
+            }
+        }
         private Term parseTerm(JsonNode term) {
             return new Term(term.path("englishName").textValue(),term.path("nativeName").textValue(),
                     term.path("encoding").textValue(),term.path("code").textValue());
+        }
         @Override
         public DatasourcesBroker getDatasourcesOfUser(@RequestParam("user")
                                                         @ApiParam(value = "User email", required = true) String user,
                                                       @RequestParam("includeShared")
                                                         @ApiParam(value = "Include shared datasources", required = true , defaultValue = "false") String includeShared,
                                                       @RequestParam("includeByOthers")
                                                         @ApiParam(value = "Include datasources of other", required = true,defaultValue = "false") String includeByOthers) throws JSONException {
             DatasourcesBroker ret = new DatasourcesBroker();
             try {
                 ret.setDatasourcesOfUser(getDatasourcesOfUserType(getRepositoriesOfUser(user)));
                 //TODO fix bug when values are true
                 if (Boolean.parseBoolean(includeShared)) {
                     List<String> sharedDatasourceIds = new ArrayList<String>();
                     ret.setSharedDatasources(getDatasourcesOfUserType(getRepositoriesByIds(sharedDatasourceIds)));
+                }
                 if (Boolean.parseBoolean(includeByOthers)) {
                     ret.setDatasourcesOfOthers(getDatasourcesOfUserType(getRepositoriesOfUser(user)));
+                }
             } catch (BrokerException e) {
                 e.printStackTrace();
+            }
             return ret;
+        }
         @Override
         public List<BrowseEntry> getTopicsForDatasource(@PathVariable("datasourceName")  String datasourceName) throws BrokerException {
             final String service = "/topicsForDatasource";
             UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(openairePath + service)
                     .queryParam("ds", datasourceName);
             ResponseEntity<List<BrowseEntry>> resp;
             try {
                 resp = restTemplate.exchange(
                         builder.build().encode().toUri(),
                         HttpMethod.GET,
                         null,
                         new ParameterizedTypeReference<List<BrowseEntry>>() {
                         });
             } catch (RestClientException e) {
                 throw new BrokerException(e);
+            }
             return resp.getBody();
+        }
         @Override
         public EventsPage advancedShowEvents(@PathVariable("page") String page,
                                              @PathVariable("size") String size,
                                              @RequestBody AdvQueryObject advQueryObject) throws BrokerException, JSONException ,IOException {
             final String service = "/events/{page}/{pageSize}";
             Map<String, Long> uriParams = new HashMap<>();
             uriParams.put("page", Long.parseLong(page));
             uriParams.put("pageSize", Long.parseLong(size));
             UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(openairePath + service);
             MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
             advQueryObject.setPage(Long.parseLong(page));
             HttpEntity<AdvQueryObject> entity = new HttpEntity<>(advQueryObject, httpHeaders);
             ResponseEntity<EventsPage> resp;
             try {
                 resp = restTemplate.exchange(
                         builder.buildAndExpand(uriParams).encode().toUri(),
                         HttpMethod.POST,
                         entity,
                         new ParameterizedTypeReference<EventsPage>() {
+                        }
                 );
             } catch (RestClientException e) {
                 throw new BrokerException(e);
+            }
             return resp.getBody();
+        }
         private List<Tuple<BrowseEntry, String>> getDatasourcesOfUserType(List<Repository> repositories) throws BrokerException {
             List<Tuple<BrowseEntry, String>> entries = new ArrayList<>();
             for (Repository repo : repositories) {
                 BrowseEntry temp = new BrowseEntry();
                 temp.setValue(repo.getOfficialName());
                 temp.setSize(new Long(0));
                 for (BrowseEntry e : getTopicsForDatasource(repo.getOfficialName())) {
                     temp.setSize(temp.getSize() + e.getSize());
+                }
                 Tuple<BrowseEntry, String> tup = new Tuple<>(temp, repo.getLogoUrl());
                 entries.add(tup);
+            }
             // sort the collection by the second field of the tuple which is size
             Collections.sort(entries, new Comparator<Tuple<BrowseEntry, String>>() {
                 @Override
                 public int compare(Tuple<BrowseEntry, String> e1, Tuple<BrowseEntry, String> e2) {
                     return (int) (e2.getFirst().getSize().longValue() - e1.getFirst().getSize().longValue());
+                }
             });
             return entries;
+        }
         private List<Repository> getRepositoriesOfUser(String userEmail) throws JSONException {
             int page = 0;
             int size = 50;
             List<Repository> rs ;
             List<Repository> resultSet = new ArrayList<>();
             while (true){
                 rs = repoAPI.getRepositoriesOfUser(userEmail, String.valueOf(page), String.valueOf(size));
                 resultSet.addAll(rs);
                 page+=1;
                 if(rs.size() == 0) break;
+            }
             return resultSet;
+        }
         private List<Repository> getRepositoriesByIds(List<String> sharedDatasourceIds) {
             return null;
+        }
         @Override
         public EventsPage showEvents(@RequestParam("datasourceName") String datasourceName,
                                      @RequestParam("topic") String topic,
                                      @RequestParam("page") String page,
                                      @RequestParam("size") String size) throws BrokerException, JSONException {
             final String service = "/events";
             UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(openairePath + service)
                     .queryParam("ds", datasourceName)
                     .queryParam("topic", topic)
                     .path("/{page}/{size}/");
             ResponseEntity<EventsPage> resp;
             try {
                 resp = restTemplate.exchange(
                         builder.build().expand(page, size).encode().toUri(),
                         HttpMethod.GET,
                         null,
                         new ParameterizedTypeReference<EventsPage>() {
                         });
             } catch (RestClientException e) {
                 throw new BrokerException(e);
+            }
             return resp.getBody();
+        }
         @Override
         public Map<String, List<SimpleSubscriptionDesc>> getSimpleSubscriptionsOfUser(@PathVariable("userEmail")  String userEmail)
                 throws BrokerException {
             final String service = "/subscriptions";
             UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(openairePath + service)
                     .queryParam("email", userEmail);
             LOGGER.debug(builder.build().encode().toUri());
             ResponseEntity<Map<String, List<SimpleSubscriptionDesc>>> resp;
             try {
                 resp = restTemplate.exchange(
                         builder.build().encode().toUri(),
                         HttpMethod.GET,
                         null,
                         new ParameterizedTypeReference<Map<String, List<SimpleSubscriptionDesc>>>() {
                         });
             } catch (RestClientException e) {
                 LOGGER.debug("Error " , e);
                 throw new BrokerException(e);
+            }
             return resp.getBody();
+        }
         @Override
         public Subscription subscribe(@RequestBody  OpenaireSubscription obj) throws BrokerException {
             final String service = "/subscribe";
             //build the uri params
             UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(openairePath + service);
             HttpEntity<OpenaireSubscription> entity = new HttpEntity<>(obj, httpHeaders);
             //create new template engine
             RestTemplate template = new RestTemplate();
             template.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
             ResponseEntity<Subscription> resp;
             try {
                 //communicate with endpoint
                 resp = restTemplate.exchange(
                         builder.build().encode().toUri(),
                         HttpMethod.POST,
                         entity,
                         new ParameterizedTypeReference<Subscription>() {
                         });
             } catch (RestClientException e) {
                 throw new BrokerException(e);
+            }
             return resp.getBody();
+        }
         @Override
         public void unsubscribe(@PathVariable("subscriptionId") String subscriptionId) throws BrokerException {
             final String service = "/subscriptions/" + subscriptionId;
             //build the uri params
             UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(apiPath + service);
             try {
                 //communicate with endpoint
                 restTemplate.exchange(
                         builder.build().encode().toUri(),
                         HttpMethod.DELETE,
                         null,
                         new ParameterizedTypeReference<Void>() {
                         });
             } catch (RestClientException e) {
                 throw new BrokerException(e);
+            }
+        }
         @Override
         public Subscription getSubscription(@PathVariable("subscriptionId") String subscriptionId) throws BrokerException {
             final String service = "/subscriptions/" + subscriptionId;
             //build the uri params
             UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(apiPath + service);
             ResponseEntity<Subscription> resp;
             try {
                 //communicate with endpoint
                 resp = restTemplate.exchange(
                         builder.build().encode().toUri(),
                         HttpMethod.GET,
                         null,
                         new ParameterizedTypeReference<Subscription>() {
                         });

Project

General

Profile

D-Net

Revision 50861

Added by Panagiotis Kanakakis over 6 years ago