D-Net

package eu.dnetlib.repo.manager.service;

import org.springframework.http.ResponseEntity;

public interface UserService {

    ResponseEntity<Object> login();

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.domain.data.Repository;

import eu.dnetlib.domain.data.RepositoryInterface;

import eu.dnetlib.repo.manager.domain.RepositorySnippet;

import eu.dnetlib.repo.manager.exception.ResourceNotFoundException;

import eu.dnetlib.repo.manager.shared.*;

import org.json.JSONException;

import org.springframework.security.core.Authentication;

import java.io.IOException;

import java.util.List;

import java.util.Map;

public interface RepositoryService {

    Country[] getCountries() ;

    List<RepositorySnippet> getRepositoriesByCountry(String country, String mode, Boolean managed) throws JSONException, IOException;

    List<Repository> getRepositoriesOfUser(String userEmail,

                                           String page,

                                           String size) throws JSONException;

    Repository getRepositoryById(String id) throws JSONException, ResourceNotFoundException;

    List<AggregationDetails> getRepositoryAggregations(String id) throws JSONException;

    Map<String,List<AggregationDetails>> getRepositoryAggregationsByYear(String id) throws JSONException;

    List<Repository> getRepositoriesByName(String name,

                                           String page,

                                           String size) throws JSONException;

    List<RepositorySnippet> searchRegisteredRepositories(String country, String typology, String englishName,

                                                                String officialName, String requestSortBy, String order,

                                                                int page, int pageSize) throws Exception;

    List<RepositoryInterface> getRepositoryInterface(String id) throws JSONException;

    Repository addRepository(String datatype, Repository repository) throws Exception;

    void deleteRepositoryInterface(String id, String registeredBy);

    RepositoryInterface addRepositoryInterface(String datatype,

                                               String repoId,

                                               String registeredBy,

                                               RepositoryInterface iFace) throws JSONException,ResourceNotFoundException;

    List<String> getDnetCountries();

    List<String> getTypologies();

    List<Timezone> getTimezones();

    Repository updateRepository(Repository repository, Authentication authentication) throws Exception;

    List<String> getUrlsOfUserRepos(String user_email,

                                    String page,

                                    String size) throws JSONException;

    List<String> getDatasourceVocabularies(String mode);

    Map<String, String> getCompatibilityClasses(String mode);

    Map<String, String> getDatasourceClasses(String mode);

    String getCountryName(String countryCode);

    MetricsInfo getMetricsInfoForRepository(String repoId) throws RepositoryServiceException;

    Map<String, String> getListLatestUpdate(String mode) throws RepositoryServiceException, JSONException;

    RepositoryInterface updateRepositoryInterface(String repositoryId, String registeredBy, RepositoryInterface repositoryInterface) throws Exception;

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.repo.manager.service.customHystrixCommands.*;

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

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

import org.springframework.stereotype.Service;

import org.springframework.web.client.RestTemplate;

import java.util.HashMap;

import java.util.Map;

@Service("statsService")

public class StatsServiceImpl implements StatsService {

    @Autowired

    RestTemplate restTemplate;

    @Value("${search.api.baseAddress}")

    private String baseAddress;

    @Value("${search.api.usagestats}")

    private String usagestatsBaseAddress;

    @Value("${search.api.usageEvents}")

    private String usagestatsEvents;

    @Override

    public Map getStatistics()  {

        UsageStatsTotalHystrixCommand usageStatsTotalHystrixCommand = new UsageStatsTotalHystrixCommand(usagestatsEvents,restTemplate);

        DataRepositoriesHystrixCommand dataRepositoriesHystrixCommand = new DataRepositoriesHystrixCommand(baseAddress,restTemplate);

        AggregatorsHystrixCommand aggregatorsHystrixCommand = new AggregatorsHystrixCommand(baseAddress,restTemplate);

        LiteratureHystrixCommand literatureHystrixCommand = new LiteratureHystrixCommand(baseAddress,restTemplate);

        JournalHystrixCommand journalHystrixCommand = new JournalHystrixCommand(baseAddress,restTemplate);

        PublicationHystrixCommand publicationHystrixCommand = new PublicationHystrixCommand(baseAddress,restTemplate);

        DatasetsHystrixCommand datasetsHystrixCommand = new DatasetsHystrixCommand(baseAddress,restTemplate);

        SoftwareHystrixCommand softwareHystrixCommand = new SoftwareHystrixCommand(baseAddress,restTemplate);

        LastYearUsageStatsHystrixCommand lastYearUsageStatsHystrixCommand = new LastYearUsageStatsHystrixCommand(usagestatsBaseAddress,restTemplate);

        Map<String,Object> stats = new HashMap<>();

        stats.put("aggregators",aggregatorsHystrixCommand.execute());

        stats.put("dataRepositories",dataRepositoriesHystrixCommand.execute());

        stats.put("literature",literatureHystrixCommand.execute());

        stats.put("journal",journalHystrixCommand.execute());

        stats.put("publications",publicationHystrixCommand.execute());

        stats.put("datasets",datasetsHystrixCommand.execute());

        stats.put("software",softwareHystrixCommand.execute());

        stats.put("lastYearUsagestats", lastYearUsageStatsHystrixCommand.execute());

        stats.put("usagestats",usageStatsTotalHystrixCommand.execute());

        return stats;

    }

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.domain.data.PiwikInfo;

import eu.dnetlib.repo.manager.shared.RepositoryServiceException;

import org.springframework.http.ResponseEntity;

import java.util.List;

public interface PiWikService {

    PiwikInfo getPiwikSiteForRepo(String repositoryId);

    PiwikInfo savePiwikInfo(PiwikInfo piwikInfo);

    List<PiwikInfo> getPiwikSitesForRepos();

    ResponseEntity<Object> approvePiwikSite(String repositoryId);

    String getOpenaireId(String repositoryid);

    ResponseEntity<Object> markPiwikSiteAsValidated(String repositoryId) throws RepositoryServiceException;

    PiwikInfo enableMetricsForRepository(String officialName, String repoWebsite, PiwikInfo piwikInfo) throws RepositoryServiceException;

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.repo.manager.shared.BrokerException;

import eu.dnetlib.repo.manager.shared.Term;

import eu.dnetlib.repo.manager.shared.broker.*;

import io.swagger.annotations.Api;

import org.json.JSONException;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

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

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

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

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

import java.io.IOException;

import java.util.List;

import java.util.Map;

public interface BrokerService {

    DatasourcesBroker getDatasourcesOfUser(String user, String includeShared, String includeByOthers) throws BrokerException, JSONException;

    List<BrowseEntry> getTopicsForDatasource(String datasourceName) throws BrokerException;

    EventsPage advancedShowEvents(String page,

                                  String size,

                                  AdvQueryObject advQueryObject) throws BrokerException, JSONException ,IOException;

    EventsPage showEvents(String datasourceName,

                          String topic,

                          String page,

                          String size) throws BrokerException, JSONException;

    Map<String, List<SimpleSubscriptionDesc>> getSimpleSubscriptionsOfUser(String userEmail) throws BrokerException;

    Subscription subscribe(OpenaireSubscription obj) throws BrokerException;

    ResponseEntity<Object> unsubscribe(String subscriptionId) throws BrokerException;

    Subscription getSubscription(String subscriptionId) throws BrokerException;

    Map<String, Term> getDnetTopics() throws BrokerException;

    EventsPage getNotificationsBySubscriptionId(String subscriptionId, String page, String size) throws BrokerException;

    Map<String, List<Subscription>> getSubscriptionsOfUser(String userEmail) throws BrokerException;

}

package eu.dnetlib.repo.manager.service;

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 org.json.JSONException;

import org.springframework.http.ResponseEntity;

import java.util.List;

public interface ValidatorService {

    JobForValidation submitJobForValidation(JobForValidation jobForValidation) throws ValidatorServiceException;

    ResponseEntity<Object> reSubmitJobForValidation(String email, String jobId) throws JSONException, ValidatorServiceException;

    List<RuleSet> getRuleSets(String mode);

    List<String> getSetsOfRepository(String url);

    boolean identifyRepo(String url);

    RuleSet getRuleSet(String acronym);

    List<StoredJob> getStoredJobsNew(String user,

                                     String jobType,

                                     String offset,

                                     String limit,

                                     String dateFrom,

                                     String dateTo,

                                     String validationStatus) throws ValidatorServiceException;

    int getStoredJobsTotalNumberNew(String user, String jobType, String validationStatus) throws ValidatorServiceException;

    InterfaceInformation getInterfaceInformation(String baseUrl) throws ValidationServiceException;

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class AggregatorsHystrixCommand extends HystrixCommand<String> {

    RestTemplate restTemplate;

    String baseAddress;

    public AggregatorsHystrixCommand(String baseAddress, RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.baseAddress = baseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected String run() throws Exception {

        String url = baseAddress + "/resources" +

                "?query= " +

                " oaftype exact datasource and " +

                " ( datasourcetypename exact Institutional Repository Aggregator " +

                "     or datasourcetypename exact Publication Repository Aggregator )";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page", 0)

                .queryParam("size", 0)

                .queryParam("format", "json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET, null, Map.class);

        Map metadata = (Map) ((Map) rs.getBody()).get("meta");

        return String.valueOf(metadata.get("total"));

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class UsageStatsTotalHystrixCommand extends HystrixCommand<Integer> {

    RestTemplate restTemplate ;

    String usagestatsEvents;

    public UsageStatsTotalHystrixCommand(String usagestatsEvents,RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.usagestatsEvents = usagestatsEvents;

        this.restTemplate = restTemplate;

    }

    @Override

    protected Integer run() {

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(usagestatsEvents)

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET,null,Map.class);

        Map metadata = (Map) ((Map)rs.getBody()).get("totals");

//        String rs = restTemplate.getForObject(uriComponents.toUri(), String.class);

//        JSONObject resultSet = new JSONObject(rs);

//        JSONObject totals = resultSet.getJSONObject("totals");

        return (Integer) metadata.get("events");

    }

    @Override

    protected Integer getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class DatasetsHystrixCommand extends HystrixCommand<String> {

    RestTemplate restTemplate;

    String baseAddress;

    public DatasetsHystrixCommand(String baseAddress,RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.restTemplate = restTemplate;

        this.baseAddress = baseAddress;

    }

    @Override

    protected String run() throws Exception {

        String url = baseAddress+"/datasets/count";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page", 0)

                .queryParam("size", 0)

                .queryParam("format", "json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET, null, Map.class);

        Map metadata = (Map) (rs.getBody());

        return String.valueOf(metadata.get("total"));

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

public class LastYearUsageStatsHystrixCommand extends HystrixCommand<Map> {

    RestTemplate restTemplate;

    String usagestatsBaseAddress;

    public LastYearUsageStatsHystrixCommand(String usagestatsBaseAddress,RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.usagestatsBaseAddress = usagestatsBaseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected Map run() throws Exception {

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(usagestatsBaseAddress + "/totals")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET,null,Map.class);

        List yearly_stats = (List) ((Map)rs.getBody()).get("yearly_stats");

        Map lastYear = (Map) yearly_stats.get(yearly_stats.size()-1);

        Integer downloads = (Integer) lastYear.get("downloads");

        Integer views = (Integer) lastYear.get("views");

        Integer year = (Integer) lastYear.get("year");

        Map<String,Object> usagestats = new HashMap<>();

        usagestats.put("number",String.valueOf(downloads+views));

        usagestats.put("year",year);

        return usagestats;

    }

    @Override

    protected Map getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class PublicationHystrixCommand extends HystrixCommand<String> {

    RestTemplate restTemplate;

    private String baseAddress;

    public PublicationHystrixCommand(String baseAddress, RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.baseAddress = baseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected String run() throws Exception {

        String url = baseAddress + "/publications/count";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page", 0)

                .queryParam("size", 0)

                .queryParam("format", "json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET, null, Map.class);

        Map metadata = (Map) (rs.getBody());

        return String.valueOf(metadata.get("total"));

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class JournalHystrixCommand extends HystrixCommand<String> {

    RestTemplate restTemplate;

    private String baseAddress;

    public JournalHystrixCommand(String baseAddress, RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.baseAddress = baseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected String run() throws Exception {

        String url = baseAddress+"/resources"+

                "?query= " +

                " oaftype exact datasource and " +

                " datasourcetypename exact Journal";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page", 0)

                .queryParam("size", 0)

                .queryParam("format", "json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET, null, Map.class);

        Map metadata = (Map) ((Map) rs.getBody()).get("meta");

        return String.valueOf(metadata.get("total"));

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class SoftwareHystrixCommand extends HystrixCommand<String> {

    String baseAddress;

    RestTemplate restTemplate;

    public SoftwareHystrixCommand(String baseAddress, RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.baseAddress = baseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected String run() {

        String url = baseAddress + "/software/count";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page", 0)

                .queryParam("size", 0)

                .queryParam("format", "json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET, null, Map.class);

        Map metadata = (Map) (rs.getBody());

        return String.valueOf(metadata.get("total"));

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class LiteratureHystrixCommand extends HystrixCommand<String> {

    RestTemplate restTemplate;

    private String baseAddress;

    public LiteratureHystrixCommand(String baseAddress , RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.baseAddress = baseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected String run() throws Exception {

        String url = baseAddress+"/resources"+

                "?query= " +

                " oaftype exact datasource and " +

                " ( datasourcetypename exact Institutional Repository  " +

                "     or datasourcetypename exact Publication Repository )";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page", 0)

                .queryParam("size", 0)

                .queryParam("format", "json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET, null, Map.class);

        Map metadata = (Map) ((Map) rs.getBody()).get("meta");

        return String.valueOf(metadata.get("total"));

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class DataRepositoriesHystrixCommand extends HystrixCommand<String> {

    RestTemplate restTemplate ;

    private String baseAddress;

    public DataRepositoriesHystrixCommand(String baseAddress,RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.baseAddress = baseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected String run() {

        String url = baseAddress+"/resources" +

                "?query= " +

                " oaftype exact datasource and " +

                " datasourcetypename exact Data Repository ";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page",0)

                .queryParam("size",0)

                .queryParam("format","json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET,null,Map.class);

        Map metadata = (Map) ((Map)rs.getBody()).get("meta");

        return String.valueOf(metadata.get("total"));

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.api.functionality.ValidatorServiceException;

import eu.dnetlib.domain.functionality.validator.StoredJob;

import eu.dnetlib.repo.manager.shared.JobsOfUser;

import io.swagger.annotations.Api;

import org.json.JSONException;

import org.springframework.http.MediaType;

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

public interface MonitorService {

    JobsOfUser getJobsOfUser(String user,

                             String jobType,

                             String offset,

                             String limit,

                             String dateFrom,

                             String dateTo,

                             String validationStatus,

                             String includeJobsTotal) throws JSONException, ValidatorServiceException;

    int getJobsOfUserPerValidationStatus(String user,

                                         String jobType,

                                         String validationStatus) throws JSONException;

    StoredJob getJobSummary(String jobId,

                            String groupBy) throws JSONException;

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.domain.data.PiwikInfo;

import eu.dnetlib.domain.data.Repository;

import eu.dnetlib.domain.functionality.validator.JobForValidation;

import org.springframework.security.core.Authentication;

public interface EmailUtils {

    void reportException(Exception exception);

    void sendAdministratorRequestToEnableMetrics(PiwikInfo piwikInfo) throws Exception;

    void sendUserRequestToEnableMetrics(PiwikInfo piwikInfo) throws Exception;

    void sendAdministratorMetricsEnabled(PiwikInfo piwikInfo) throws Exception;

    void sendUserMetricsEnabled(PiwikInfo piwikInfo) throws Exception;

    void sendAdminRegistrationEmail(Repository repository, Authentication authentication) throws Exception;

    void sendUserRegistrationEmail(Repository repository, Authentication authentication) throws Exception;

    void sendAdminUpdateRepositoryEmail(Repository repository, Authentication authentication) throws Exception;

    void sendUserUpdateRepositoryEmail(Repository repository, Authentication authentication) throws Exception;

    void sendSubmitJobForValidationEmail(Authentication authentication, JobForValidation jobForValidation) throws Exception;

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.repo.manager.domain.RepositorySummaryInfo;

import org.json.JSONException;

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

import java.util.List;

public interface DashboardService {

    List<RepositorySummaryInfo> getRepositoriesSummaryInfo(@PathVariable("userEmail") String userEmail,

                                                           @PathVariable("page") String page,

                                                           @PathVariable("size") String size) throws JSONException;

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.usagestats.sushilite.domain.ReportItem;

import eu.dnetlib.usagestats.sushilite.domain.ReportResponseWrapper;

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

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

import org.springframework.core.ParameterizedTypeReference;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;

import org.springframework.security.access.prepost.PreAuthorize;

import org.springframework.stereotype.Service;

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

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

import org.springframework.web.client.RestClientException;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.ArrayList;

import java.util.List;

@Service("sushiliteService")

public class SushiliteServiceImpl implements SushiliteService {

    @Value("${services.repomanager.usagestats.sushiliteEndpoint}")

    private String usagestatsSushiliteEndpoint;

    @Autowired

    private EmailUtils emailUtils;

    private static final org.apache.log4j.Logger LOGGER = org.apache.log4j.Logger.getLogger(SushiliteServiceImpl.class);

    @Override

    @PreAuthorize("hasRole('ROLE_USER')")

    public ReportResponseWrapper getReportResults(@PathVariable("page") String page,

                                                  @PathVariable("pageSize") String pageSize,

                                                  @RequestParam(value = "Report") String Report,

                                                  @RequestParam(value = "Release",defaultValue="4") String Release,

                                                  @RequestParam(value = "RequestorID",required=false,defaultValue="anonymous") String RequestorID,

                                                  @RequestParam(value = "BeginDate",required=false,defaultValue="") String BeginDate,

                                                  @RequestParam(value = "EndDate",required=false,defaultValue="") String EndDate,

                                                  @RequestParam(value = "RepositoryIdentifier") String RepositoryIdentifier,

                                                  @RequestParam(value = "ItemIdentifier",required=false,defaultValue="") String ItemIdentifier,

                                                  @RequestParam(value = "ItemDataType",required=false,defaultValue="") String ItemDataType,

                                                  @RequestParam(value = "Granularity") String Granularity,

                                                  @RequestParam(value = "Pretty",required=false,defaultValue="") String Pretty) {

            //build the uri params

            UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(this.usagestatsSushiliteEndpoint + "GetReport/")

                                                                .queryParam("Report", Report)

                                                                .queryParam("Release", Release)

                                                                .queryParam("RequestorID", RequestorID)

                                                                .queryParam("BeginDate", BeginDate)

                                                                .queryParam("EndDate", EndDate)

                                                                .queryParam("RepositoryIdentifier", RepositoryIdentifier)

                                                                .queryParam("ItemIdentifier", ItemIdentifier)

                                                                .queryParam("ItemDataType", ItemDataType)

                                                                .queryParam("Granularity", Granularity)

                                                                .queryParam("Pretty", Pretty);

            //create new template engine

            RestTemplate template = new RestTemplate();

            template.getMessageConverters().add(new MappingJackson2HttpMessageConverter());

            ResponseEntity<ReportResponseWrapper> resp;

            try {

                //communicate with endpoint

                resp = template.exchange(

                        builder.build().encode().toUri(),

                        HttpMethod.GET,

                        null,

                        new ParameterizedTypeReference<ReportResponseWrapper>() {

                        });

            } catch (RestClientException e) {

                LOGGER.debug("Exception on getReportResults" , e);

                emailUtils.reportException(e);

                throw e;

            }

            // check remote api's response

            System.out.println("sushi responded status " + resp.getStatusCode());

            // get the items corresponding to the requested page

            List<ReportItem> requestedItemList = new ArrayList<>();

            if (resp.getBody().getReportResponse().getReportWrapper().getReport().getCustomer().getReportItems() != null) {

                try {

                    int totalItems = resp.getBody().getReportResponse().getReportWrapper().getReport().getCustomer().getReportItems().size();

                    int size = Integer.parseInt(pageSize);

                    int offset = Integer.parseInt(page)*size;

                    if (offset < totalItems ) {

                        int upperIndex = offset+size;

                        if (upperIndex > totalItems) {

                            upperIndex = totalItems;

                        }

                        requestedItemList = resp.getBody().getReportResponse().getReportWrapper().getReport().getCustomer().getReportItems().subList(offset,upperIndex);

                    }

                } catch (NumberFormatException e) {

                    LOGGER.debug("Exception on getReportResults - trying to cast strings to integers", e);

                    //emailUtils.reportException(e);

                    throw e;

                }

            }

            ReportResponseWrapper newReportResponse = resp.getBody();

            newReportResponse.getReportResponse().getReportWrapper().getReport().getCustomer().setReportItems(requestedItemList);

            return newReportResponse;

    }

}

package eu.dnetlib.repo.manager.service;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;

import eu.dnetlib.repo.manager.exception.EndPointException;

import org.json.JSONException;

import java.util.Map;

public interface StatsService {

    Map getStatistics() ;

}

package eu.dnetlib.repo.manager.service;

import org.mitre.openid.connect.model.OIDCAuthenticationToken;

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

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.security.core.GrantedAuthority;

import org.springframework.security.core.context.SecurityContextHolder;

import org.springframework.stereotype.Service;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

@Service("userService")

public class UserServiceImpl implements UserService {

    private static final org.apache.log4j.Logger LOGGER = org.apache.log4j.Logger

            .getLogger(UserServiceImpl.class);

    @Value("${oidc.issuer}")

    private String oidc_issuer;

    @Override

    public ResponseEntity<Object> login() {

        OIDCAuthenticationToken authentication = (OIDCAuthenticationToken) SecurityContextHolder.getContext().getAuthentication();

        LOGGER.debug("User authentication : " + authentication);

        Map<String,Object> body = new HashMap<>();

        body.put("sub",authentication.getSub());

        if(authentication.getUserInfo().getName() == null || authentication.getUserInfo().getName().equals(""))

            body.put("name",authentication.getUserInfo().getGivenName() + " " + authentication.getUserInfo().getFamilyName());

        else

            body.put("name",authentication.getUserInfo().getName());

        body.put("email",authentication.getUserInfo().getEmail());

        List<String> roles = authentication.getAuthorities().stream().map(GrantedAuthority::getAuthority).collect(Collectors.toList());

        body.put("role",roles);

        return new ResponseEntity<>(body, HttpStatus.OK);

    }

}

package eu.dnetlib.repo.manager.service;

import com.fasterxml.jackson.core.JsonProcessingException;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.fasterxml.jackson.databind.SerializationFeature;

import eu.dnetlib.api.functionality.ValidatorServiceException;

import eu.dnetlib.domain.data.Repository;

import eu.dnetlib.domain.data.RepositoryInterface;

import eu.dnetlib.domain.enabling.Vocabulary;

import eu.dnetlib.domain.functionality.validator.JobForValidation;

import eu.dnetlib.repo.manager.domain.RepositorySnippet;

import eu.dnetlib.repo.manager.domain.RequestFilter;

import eu.dnetlib.repo.manager.exception.ResourceNotFoundException;

import eu.dnetlib.repo.manager.shared.*;

import eu.dnetlib.repo.manager.utils.Converter;

import gr.uoa.di.driver.enabling.vocabulary.VocabularyLoader;

import gr.uoa.di.driver.xml.repository.INTERFACE;

import org.apache.commons.codec.digest.DigestUtils;

import org.apache.log4j.Logger;

import org.json.JSONArray;

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.*;

import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;

import org.springframework.security.core.Authentication;

import org.springframework.security.core.context.SecurityContextHolder;

import org.springframework.stereotype.Service;

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.sql.Timestamp;

import java.util.*;

import java.util.concurrent.ConcurrentHashMap;

import java.util.stream.Collectors;

@Service("repositoryService")

public class RepositoryServiceImpl implements RepositoryService {

    @Value("${api.baseAddress}")

    private String baseAddress;

    @Value("${services.repo-manager.adminEmail}")

    private String adminEmail;

    @Autowired

    RestTemplate restTemplate;

    private HttpHeaders httpHeaders;

    private final String[] vocabularyNames = {"dnet:countries", "dnet:datasource_typologies", "dnet:compatibilityLevel"};

    private static final Logger LOGGER = Logger.getLogger(RepositoryServiceImpl.class);

    @Value("${services.repomanager.usageStatisticsDiagramsBaseURL}")

    private String usageStatisticsDiagramsBaseURL;

    @Value("${services.repomanager.usageStatisticsNumbersBaseURL}")

    private String usageStatisticsNumbersBaseURL;

    @Autowired

    private VocabularyLoader vocabularyLoader;

    @Autowired

    private PiWikService piWikService;

    @Autowired

    private EmailUtils emailUtils;

    @Autowired

    ValidatorService validatorService;

    private Map<String, Vocabulary> vocabularyMap = new ConcurrentHashMap<String, Vocabulary>();

    private Map<String, String> countriesMap = new HashMap<>();

    private Map<String, String> inverseCountriesMap = new HashMap<>();

    private static Map<String,List<String>> dataSourceClass = new HashMap<String,List<String>>(){{

        put("opendoar",new ArrayList<String>(){{ add("pubsrepository::institutional");

                                                    add("pubsrepository::thematic");

                                                    add("pubsrepository::unknown");

                                                    add("pubsrepository::mock");

        }});

        put("re3data",new ArrayList<String>(){{ add("datarepository::unknown");

        }});

        put("journal",new ArrayList<String>(){{ add("pubsrepository::journal");

        }});

        put("aggregator",new ArrayList<String>(){{ add("aggregator::pubsrepository::institutional");

                                                        add("aggregator::pubsrepository::journals");

                                                        add("aggregator::datarepository");

                                                        add("aggregator::pubsrepository::unknown");

        }});

    }};

    private static Map<String,String> invertedDataSourceClass = new HashMap<String,String>(){{

        put("pubsrepository::institutional","opendoar");

        put("pubsrepository::thematic","opendoar");

        put("pubsrepository::unknown","opendoar");

        put("pubsrepository::mock","opendoar");

        put("datarepository::unknown","re3data");

        put("pubsrepository::journal","journal");

        put("aggregator::pubsrepository::institutional","aggregator");

        put("aggregator::pubsrepository::journals","aggregator");

        put("aggregator::datarepository","aggregator");

        put("aggregator::pubsrepository::unknown","aggregator");

    }};

    @PostConstruct

    private void init() {

        LOGGER.debug("Initialization method of repository api!");

        LOGGER.debug("Updated version!");

        httpHeaders = new HttpHeaders();

        httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8);

        for (String vocName : vocabularyNames) {

            vocabularyMap.put(vocName, vocabularyLoader.getVocabulary(vocName, Locale.ENGLISH, Locale.ROOT));

        }

        Country[] countries = getCountries();

        for (Country c : countries) {

            countriesMap.put(c.getName(), c.getCode());

            inverseCountriesMap.put(c.getCode(), c.getName());

        }

    }

    @Override

    public Country[] getCountries() {

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(baseAddress + "/ds/countries")

                .build().encode();

        return restTemplate.getForObject(uriComponents.toUri(), Country[].class);

    }

    @Override

    public List<RepositorySnippet> getRepositoriesByCountry(@PathVariable("country") String country,

                                                            @PathVariable("mode") String mode,

                                                            @RequestParam(value = "managed",required=false) Boolean managed) throws JSONException, IOException {

        LOGGER.debug("Getting repositories by country!");

        int page = 0;

        int size = 100;

        List<RepositorySnippet> resultSet = new ArrayList<>();

        ObjectMapper mapper = new ObjectMapper();

        String filterKey = "UNKNOWN";

        if (mode.equalsIgnoreCase("opendoar"))

            filterKey = "openaire____::opendoar";

        else if (mode.equalsIgnoreCase("re3data"))

            filterKey = "openaire____::re3data";

        LOGGER.debug("Country code equals : " + country);

        LOGGER.debug("Filter mode equals : " + filterKey);

        UriComponents uriComponents = searchSnipperDatasource(String.valueOf(page),String.valueOf(size));

        RequestFilter requestFilter = new RequestFilter();

        requestFilter.setCountry(country);

        requestFilter.setCollectedfrom(filterKey);

        try{

            String rs = restTemplate.postForObject(uriComponents.toUri(),requestFilter, String.class);

            JSONArray jsonArray = (JSONArray) new JSONObject(rs).get("datasourceInfo");

            while (jsonArray.length() > 0 ) {

                resultSet.addAll(mapper.readValue(String.valueOf(jsonArray),

                        mapper.getTypeFactory().constructCollectionType(List.class, RepositorySnippet.class)));

                page += 1;

                uriComponents = searchSnipperDatasource(String.valueOf(page),String.valueOf(size));

                rs = restTemplate.postForObject(uriComponents.toUri(),requestFilter, String.class);

                jsonArray = (JSONArray) new JSONObject(rs).get("datasourceInfo");

            }

            return resultSet;

        }catch (Exception e){

            LOGGER.debug("Exception on getRepositoriesByCountry" , e);

//            emailUtils.reportException(e);

            throw e;

        }

    }

    public List<RepositorySnippet> searchRegisteredRepositories(String country, String typology, String englishName,

            String officialName, String requestSortBy, String order, int page, int pageSize) throws Exception {

        LOGGER.debug("Searching registered repositories");

        List<RepositorySnippet> resultSet = new ArrayList<>();

        ObjectMapper mapper = new ObjectMapper();

        UriComponents uriComponents = searchRegisteredDatasource(requestSortBy, order, Integer.toString(page), Integer.toString(pageSize));

        RequestFilter requestFilter = new RequestFilter();

        requestFilter.setCountry(country);

        requestFilter.setTypology(typology);

        requestFilter.setOfficialname(officialName);

        requestFilter.setEnglishname(englishName);

        try {

            String rs = restTemplate.postForObject(uriComponents.toUri(),requestFilter, String.class);

            JSONArray jsonArray = (JSONArray) new JSONObject(rs).get("datasourceInfo");

            resultSet.addAll(mapper.readValue(String.valueOf(jsonArray),  mapper.getTypeFactory().constructCollectionType(List.class, RepositorySnippet.class)));

             return resultSet;

        }catch (Exception e){

            LOGGER.error("Error searching registered datasources" , e);

            throw e;

        }

    }

    private Repository updateRepositoryInfo(Repository r) throws JSONException {

        /*

        * from datasource class

        * we get the datasource type form the inverted map

        * */

        r.setDatasourceType(getRepositoryType(r.getDatasourceClass()));

        r.setInterfaces(this.getRepositoryInterface(r.getId()));

        r.setPiwikInfo(piWikService.getPiwikSiteForRepo(r.getId()));

        r.setCountryName(getCountryName(r.getCountryCode()));

        return r;

    }

    private Collection<Repository> getRepositoriesByMode(String mode, List<Repository> rs) {

        List<Repository> reps = new ArrayList<>();

        for (Repository r : rs) {

            if (r.getCollectedFrom() != null && r.getCollectedFrom().equals(mode))

                reps.add(r);

        }

        return reps;

    }

    @Override

    public List<Repository> getRepositoriesOfUser(@PathVariable("userEmail") String userEmail,

                                                  @PathVariable("page") String page,

                                                  @PathVariable("size") String size) throws JSONException {

        LOGGER.debug("Retreiving repositories of user : " + userEmail );

        UriComponents uriComponents = searchDatasource(page,size);

        RequestFilter requestFilter = new RequestFilter();

        requestFilter.setRegisteredby(userEmail);

        try{

            String rs = restTemplate.postForObject(uriComponents.toUri(),requestFilter, String.class);

            List<Repository> repos = Converter.jsonToRepositoryList(new JSONObject(rs));

            for (Repository r : repos)

                this.updateRepositoryInfo(r);

            return repos;

        }catch (Exception e){

            LOGGER.debug("Exception on getRepositoriesOfUser" , e);

            emailUtils.reportException(e);

            throw e;

        }

    }

    @Override

    public Repository getRepositoryById(@PathVariable("id") String id) throws JSONException,ResourceNotFoundException {

        LOGGER.debug("Retreiving repositories with id : " + id );

        Repository repo = null;

        UriComponents uriComponents = searchDatasource("0","100");

        RequestFilter requestFilter = new RequestFilter();

        requestFilter.setId(id);

        try{

            String rs = restTemplate.postForObject(uriComponents.toUri(),requestFilter, String.class);

            JSONArray jsonArray = (JSONArray) new JSONObject(rs).get("datasourceInfo");

            if(jsonArray.length() == 0)

                throw new ResourceNotFoundException();

            repo = Converter.jsonToRepositoryObject(jsonArray.getJSONObject(0));

            return updateRepositoryInfo(repo);

        }catch (JSONException e){

            LOGGER.debug("Exception on getRepositoryById" , e);

            emailUtils.reportException(e);

            throw e;

        }

    }

    @Override

    public List<AggregationDetails> getRepositoryAggregations(@PathVariable("id") String id) throws JSONException {

        LOGGER.debug("Retreiving aggregations for repository with id : " + id );

        UriComponents uriComponents = searchDatasource("0","100");

        RequestFilter requestFilter = new RequestFilter();

        requestFilter.setId(id);

        List<AggregationDetails> aggregationHistory = new ArrayList<>();

        try {

            String rs = restTemplate.postForObject(uriComponents.toUri(),requestFilter, String.class);

            JSONObject repository = new JSONObject(rs);

            if(repository.getJSONArray("datasourceInfo").length() == 0)

                return aggregationHistory;

            aggregationHistory.addAll(Converter.getAggregationHistoryFromJson(repository.getJSONArray("datasourceInfo").getJSONObject(0)));

            return aggregationHistory.size() == 0? aggregationHistory : aggregationHistory.stream()

                                                    .sorted(Comparator.comparing(AggregationDetails::getDate).reversed())

                                                    .limit(20)

                                                    .collect(Collectors.toList());

        } catch (JSONException e) {

            LOGGER.debug("Exception on getRepositoryAggregations" , e);

            emailUtils.reportException(e);

            throw e;

        }

    }

    @Override

    public Map<String, List<AggregationDetails>> getRepositoryAggregationsByYear(@PathVariable("id") String id) throws JSONException {

        LOGGER.debug("Retreiving aggregations (by year) for repository with id : " + id );

        UriComponents uriComponents = searchDatasource("0","100");

        RequestFilter requestFilter = new RequestFilter();

        requestFilter.setId(id);

        List<AggregationDetails> aggregationHistory = new ArrayList<>();

        Map<String, List<AggregationDetails>> aggregationByYear = new HashMap<>();

        try {

            String rs = restTemplate.postForObject(uriComponents.toUri(),requestFilter, String.class);

            JSONObject repository = new JSONObject(rs);

            if(repository.getJSONArray("datasourceInfo").length() == 0)

                return aggregationByYear;

            aggregationHistory.addAll(Converter.getAggregationHistoryFromJson(repository.getJSONArray("datasourceInfo").getJSONObject(0)));

            return aggregationHistory.size() == 0? aggregationByYear:createYearMap(aggregationHistory);

        } catch (JSONException e) {

            LOGGER.debug("Exception on getRepositoryAggregations" , e);

            emailUtils.reportException(e);

            throw e;

        }

    }

    private Map<String,List<AggregationDetails>> createYearMap(List<AggregationDetails> aggregationHistory) {

        Map<String, List<AggregationDetails>> aggregationByYear;

        aggregationHistory = aggregationHistory.stream()

                            .sorted(Comparator.comparing(AggregationDetails::getDate).reversed())

                            .collect(Collectors.toList());

       return aggregationHistory.stream()

                            .collect(Collectors.groupingBy(AggregationDetails::getYear));

    }

    @Override

    public List<Repository> getRepositoriesByName(@PathVariable("name") String name,

                                                  @PathVariable("page") String page,

                                                  @PathVariable("size") String size) throws JSONException {

        LOGGER.debug("Retreiving  repositories with official name : " + name );

        UriComponents uriComponents = searchDatasource("0","100");

        RequestFilter requestFilter = new RequestFilter();

        requestFilter.setOfficialname(name);

        try{

            String rs = restTemplate.postForObject(uriComponents.toUri(),requestFilter, String.class);

            List<Repository> repos = Converter.jsonToRepositoryList(new JSONObject(rs));

            for (Repository r : repos)

                updateRepositoryInfo(r);

            return repos;

        }catch (Exception e){

            LOGGER.debug("Exception on getRepositoriesByName" , e);

            emailUtils.reportException(e);

            throw e;

        }

    }

    @Override

    public List<RepositoryInterface> getRepositoryInterface(@PathVariable("id") String id) throws JSONException {

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(baseAddress + "/ds/api/")

                .path("/{id}")

                .build().expand(id).encode();

        try{

            String rs = restTemplate.getForObject(uriComponents.toUri(), String.class);

            return Converter.jsonToRepositoryInterfaceList(new JSONObject(rs));

        }catch (Exception e ){

            LOGGER.debug("Exception on getRepositoryInterface" , e);

            emailUtils.reportException(e);

            throw e;

        }

    }

    @Override

    public Repository addRepository(@RequestParam("datatype") String datatype,

                                    @RequestBody Repository repository) throws Exception {

        LOGGER.debug("storing " + datatype + " repository with id: " + repository.getId());

        repository.setCountryCode(countriesMap.get(repository.getCountryName()));

        repository.setActivationId(UUID.randomUUID().toString());

        repository.setCollectedFrom("infrastruct_::openaire");

        if (datatype.equals("journal")) {

            repository.setId("openaire____::issn" + repository.getIssn());

            repository.setNamespacePrefix("issn" + repository.getIssn());

            this.storeRepository(repository, SecurityContextHolder.getContext().getAuthentication());

        }else if (datatype.equals("aggregator")) {

            repository.setId("openaire____::" + com.unboundid.util.Base64.encode(repository.getOfficialName()));

            repository.setNamespacePrefix(DigestUtils.md5Hex(repository.getOfficialName()).substring(0,12));

            this.storeRepository(repository, SecurityContextHolder.getContext().getAuthentication());

        }else {

            this.latentUpdate(repository, SecurityContextHolder.getContext().getAuthentication());

        }

        return repository;

    }

    /* update method acting as add -> send email with registration topic/body*/

    private Repository latentUpdate(Repository repository, Authentication authentication) throws Exception {

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(baseAddress + "/ds/update/")

                .build()

                .encode();

        try {

            String json_repository = Converter.repositoryObjectToJson(repository);

            LOGGER.debug("JSON to add(update) -> " + json_repository);

//

//            // TODO delete these 3 lines

//            HttpHeaders temp = new HttpHeaders();

//            temp.setContentType(MediaType.APPLICATION_JSON_UTF8);

            HttpEntity<String> httpEntity = new HttpEntity<String>(json_repository, httpHeaders);

            ResponseEntity responseEntity = restTemplate.exchange(uriComponents.toUri(),HttpMethod.POST, httpEntity, ResponseEntity.class);

            if (responseEntity.getStatusCode().equals(HttpStatus.OK)) {

                emailUtils.sendUserRegistrationEmail(repository, authentication);

                emailUtils.sendAdminRegistrationEmail(repository, authentication);

            } else

                LOGGER.debug(responseEntity.getBody().toString());

            return repository;

        } catch (Exception e) {

            LOGGER.debug("Exception on updateRepository" , e);

            emailUtils.reportException(e);

            throw e;

        }