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

     package eu.dnetlib.repo.manager.domain.broker;
     import java.util.ArrayList;
     import java.util.List;
     public class AdvQueryObject   {
         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.domain;
     public class Organization{
         private String country;
         private String legalname;
         private String websiteurl;
         private String legalshortname;
         private String logourl;
         public String getCountry() {
             return country;
+        }
         public void setCountry(String country) {
             this.country = country;
+        }
         public String getLegalname() {
             return legalname;
+        }
         public void setLegalname(String legalname) {
             this.legalname = legalname;
+        }
         public String getWebsiteurl() {
             return websiteurl;
+        }
         public void setWebsiteurl(String websiteurl) {
             this.websiteurl = websiteurl;
+        }
         public String getLegalshortname() {
             return legalshortname;
+        }
         public void setLegalshortname(String legalshortname) {
             this.legalshortname = legalshortname;
+        }
         public String getLogourl() {
             return logourl;
+        }
         public void setLogourl(String logourl) {
             this.logourl = logourl;
+        }
+    }

     package eu.dnetlib.repo.manager.domain.broker;
     /**
      * Created by stefanos on 17/3/2017.
      */
     public class ConditionParams {
         private String value;
         private String otherValue;
         public ConditionParams() {
+        }
         public ConditionParams(final String value, final String otherValue) {
             this.value = value;
             this.otherValue = otherValue;
+        }
         public String getValue() {
             return this.value;
+        }
         public void setValue(final String value) {
             this.value = value;
+        }
         public String getOtherValue() {
             return this.otherValue;
+        }
         public void setOtherValue(final String otherValue) {
             this.otherValue = otherValue;
+        }
+    }

     package eu.dnetlib.repo.manager.domain.broker;
     /**
      * Created by stefanos on 17/3/2017.
      */
     public enum MapValueType {
         STRING, INTEGER, FLOAT, DATE, BOOLEAN, LIST_STRING, LIST_INTEGER, LIST_FLOAT, LIST_DATE, LIST_BOOLEAN;
+    }

     package eu.dnetlib.repo.manager.domain;
     import java.util.Date;
     public class RepositorySummaryInfo{
         String id;
         String repositoryName;
         String logoURL;
         int recordsCollected;
         Date lastIndexedVersion;
         long enrichmentEvents;
         String totalViews;
         String totalDownloads;
         public RepositorySummaryInfo() {
+        }
         public String getId() {
             return id;
+        }
         public void setId(String id) {
             this.id = id;
+        }
         public String getRepositoryName() {
             return repositoryName;
+        }
         public void setRepositoryName(String repositoryName) {
             this.repositoryName = repositoryName;
+        }
         public String getLogoURL() {
             return logoURL;
+        }
         public void setLogoURL(String logoURL) {
             this.logoURL = logoURL;
+        }
         public int getRecordsCollected() {
             return recordsCollected;
+        }
         public void setRecordsCollected(int recordsCollected) {
             this.recordsCollected = recordsCollected;
+        }
         public Date getLastIndexedVersion() {
             return lastIndexedVersion;
+        }
         public void setLastIndexedVersion(Date lastIndexedVersion) {
             this.lastIndexedVersion = lastIndexedVersion;
+        }
         public long getEnrichmentEvents() {
             return enrichmentEvents;
+        }
         public void setEnrichmentEvents(long enrichmentEvents) {
             this.enrichmentEvents = enrichmentEvents;
+        }
         public String getTotalViews() {
             return totalViews;
+        }
         public void setTotalViews(String totalViews) {
             this.totalViews = totalViews;
+        }
         public String getTotalDownloads() {
             return totalDownloads;
+        }
         public void setTotalDownloads(String totalDownloads) {
             this.totalDownloads = totalDownloads;
+        }
+    }

     package eu.dnetlib.repo.manager.domain.broker;
     import java.util.Date;
     /**
      * Created by stefanos on 10-Mar-17.
      */
     public class SimpleSubscriptionDesc   {
         private String id;
         private String datasource;
         private String topic;
         private long count;
         private Date creationDate;
         private Date lastNotificationDate;
         public SimpleSubscriptionDesc() {
+        }
         public SimpleSubscriptionDesc(final String id, final String datasource, final String topic, final long count) {
             this.id = id;
             this.datasource = datasource;
             this.topic = topic;
             this.count = count;
+        }
         public String getId() {
             return this.id;
+        }
         public void setId(final String id) {
             this.id = id;
+        }
         public String getDatasource() {
             return this.datasource;
+        }
         public void setDatasource(final String datasource) {
             this.datasource = datasource;
+        }
         public String getTopic() {
             return this.topic;
+        }
         public void setTopic(final String topic) {
             this.topic = topic;
+        }
         public long getCount() {
             return this.count;
+        }
         public void setCount(final long count) {
             this.count = count;
+        }
         public Date getCreationDate() {
             return creationDate;
+        }
         public void setCreationDate(Date creationDate) {
             this.creationDate = creationDate;
+        }
         public Date getLastNotificationDate() {
             return lastNotificationDate;
+        }
         public void setLastNotificationDate(Date lastNotificationDate) {
             this.lastNotificationDate = lastNotificationDate;
+        }
+    }

     package eu.dnetlib.repo.manager.domain;
     public class Timezone{
     	private String name;
     	private double offset;
     	public Timezone(){
+    	}
     	public Timezone(String name, double offset) {
     		super();
     		this.name = name;
     		this.offset = offset;
+    	}
+    }

     package eu.dnetlib.repo.manager.domain;
     /**
      * Created by stefanos on 27-Oct-16.
      */
     public class BrokerException extends Exception {
         public BrokerException(Throwable th) {
             super(th);
+        }
         public BrokerException() {
+        }
+    }

     package eu.dnetlib.repo.manager.domain;
     /**
      * Created by stefania on 3/8/16.
      */
     public class Triple<K, V, L> extends Tuple<K, V>   {
         private L third;
         public Triple() {
+        }
         public Triple(K first, V second, L third) {
             super(first, second);
             this.third = third;
+        }
         public L getThird() {
             return third;
+        }
         public void setThird(L third) {
             this.third = third;
+        }
+    }

     package eu.dnetlib.repo.manager.domain;
     /**
      * Created by stefania on 3/8/16.
      */
     public class Vocabulary   {
         private String id;
         private String name;
         public Vocabulary() {
+        }
         public Vocabulary(String id, String name) {
             this.id = id;
             this.name = name;
+        }
         public String getId() {
             return id;
+        }
         public void setId(String id) {
             this.id = id;
+        }
         public String getName() {
             return name;
+        }
         public void setName(String name) {
             this.name = name;
+        }
+    }

     package eu.dnetlib.repo.manager.domain;
     import eu.dnetlib.domain.functionality.validator.StoredJob;
     import java.util.List;
     /**
      * Created by nikonas on 29/3/16.
      */
     public class JobsOfUser   {
         private int totalJobs;
         private int totalJobsSuccessful;
         private int totalJobsFailed;
         private int totalJobsOngoing;
         private List<StoredJob> jobs;
         public int getTotalJobs() {
             return totalJobs;
+        }
         public void setTotalJobs(int totalJobs) {
             this.totalJobs = totalJobs;
+        }
         public int getTotalJobsSuccessful() {
             return totalJobsSuccessful;
+        }
         public void setTotalJobsSuccessful(int totalJobsSuccessful) {
             this.totalJobsSuccessful = totalJobsSuccessful;
+        }
         public int getTotalJobsFailed() {
             return totalJobsFailed;
+        }
         public void setTotalJobsFailed(int totalJobsFailed) {
             this.totalJobsFailed = totalJobsFailed;
+        }
         public int getTotalJobsOngoing() {
             return totalJobsOngoing;
+        }
         public void setTotalJobsOngoing(int totalJobsOngoing) {
             this.totalJobsOngoing = totalJobsOngoing;
+        }
         public List<StoredJob> getJobs() {
             return jobs;
+        }
         public void setJobs(List<StoredJob> jobs) {
             this.jobs = jobs;
+        }
+    }

     package eu.dnetlib.repo.manager.domain;
     import java.util.Calendar;
     import java.util.Date;
     public class AggregationDetails{
         private String aggregationStage;
         private Date date;
         private int numberOfRecords;
         private String collectionMode;
         private Boolean indexedVersion;
         public AggregationDetails() {
+        }
         public String getAggregationStage() {
             return aggregationStage;
+        }
         public String getCollectionMode() {
             return collectionMode;
+        }
         public void setCollectionMode(String collectionMode) {
             this.collectionMode = collectionMode;
+        }
         public void setAggregationStage(String aggregationStage) {
             this.aggregationStage = aggregationStage;
+        }
         public Date getDate() {
             return date;
+        }
         public void setDate(Date date) {
             this.date = date;
+        }
         public int getNumberOfRecords() {
             return numberOfRecords;
+        }
         public void setNumberOfRecords(int numberOfRecords) {
             this.numberOfRecords = numberOfRecords;
+        }
         public String getYear() {
             Calendar calendar = Calendar.getInstance();
             calendar.setTime(getDate());
             return String.valueOf(calendar.get(Calendar.YEAR));
+        }
         public Boolean getIndexedVersion() {
             return indexedVersion;
+        }
         public void setIndexedVersion(Boolean indexedVersion) {
             this.indexedVersion = indexedVersion;
+        }
+    }

     package eu.dnetlib.repo.manager.domain;
     import eu.dnetlib.repo.manager.domain.broker.BrowseEntry;
     import eu.dnetlib.repo.manager.domain.broker.SimpleSubscriptionDesc;
     import java.util.List;
     import java.util.Map;
     public class BrokerSummary {
         private Map<String, List<SimpleSubscriptionDesc>> userSubs;
         private List<BrowseEntry> topicsForDatasource;
         public BrokerSummary(){}
         public BrokerSummary(Map<String, List<SimpleSubscriptionDesc>> userSubs, List<BrowseEntry> topicsForDatasource) {
             this.userSubs = userSubs;
             this.topicsForDatasource = topicsForDatasource;
+        }
         public Map<String, List<SimpleSubscriptionDesc>> getUserSubs() {
             return userSubs;
+        }
         public void setUserSubs(Map<String, List<SimpleSubscriptionDesc>> userSubs) {
             this.userSubs = userSubs;
+        }
         public List<BrowseEntry> getTopicsForDatasource() {
             return topicsForDatasource;
+        }
         public void setTopicsForDatasource(List<BrowseEntry> topicsForDatasource) {
             this.topicsForDatasource = topicsForDatasource;
+        }
+    }

     package eu.dnetlib.repo.manager.controllers;
     import eu.dnetlib.domain.data.Repository;
     import eu.dnetlib.domain.data.RepositoryInterface;
     import eu.dnetlib.repo.manager.domain.*;
     import eu.dnetlib.repo.manager.domain.dto.RepositoryTerms;
     import eu.dnetlib.repo.manager.domain.dto.User;
     import eu.dnetlib.repo.manager.exception.ResourceNotFoundException;
     import eu.dnetlib.repo.manager.service.RepositoryService;
     import eu.dnetlib.repo.manager.service.security.AuthorizationService;
     import eu.dnetlib.repo.manager.utils.JsonUtils;
     import io.swagger.annotations.Api;
     import org.apache.log4j.Logger;
     import org.json.JSONException;
     import org.mitre.openid.connect.model.OIDCAuthenticationToken;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.http.HttpStatus;
     import org.springframework.http.MediaType;
     import org.springframework.http.ResponseEntity;
     import org.springframework.security.access.prepost.PostAuthorize;
     import org.springframework.security.access.prepost.PreAuthorize;
     import org.springframework.security.core.Authentication;
     import org.springframework.security.core.context.SecurityContextHolder;
     import org.springframework.web.bind.annotation.*;
     import javax.ws.rs.core.Response;
     import java.io.IOException;
     import java.util.Date;
     import java.util.List;
     import java.util.Map;
     @RestController
     @RequestMapping(value = "/repositories")
     @Api(description = "Repository API", tags = {"repositories"})
     public class RepositoryController {
         private static final Logger logger = Logger.getLogger(RepositoryController.class);
         private final RepositoryService repositoryService;
         private final AuthorizationService authorizationService;
         @Autowired
         RepositoryController(RepositoryService repositoryService,
                              AuthorizationService authorizationService) {
             this.repositoryService = repositoryService;
             this.authorizationService = authorizationService;
+        }
         @RequestMapping(value = "/countries", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         public Country[] getCountries() {
             return repositoryService.getCountries();
+        }
         @RequestMapping(value = "/getRepositoriesByCountry/{country}/{mode}", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         public List<RepositorySnippet> getRepositoriesByCountry(@PathVariable("country") String country,
                                                                 @PathVariable("mode") String mode,
                                                                 @RequestParam(value = "managed", required = false) Boolean managed) throws JSONException, IOException {
             return repositoryService.getRepositoriesByCountry(country, mode, managed);
+        }
         @RequestMapping(value = "/snippets/user", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         @PreAuthorize("hasAuthority('REGISTERED_USER')")
         public List<RepositorySnippet> getRepositoriesSnippetsOfUser() throws Exception {
             return repositoryService.getRepositoriesSnippetsOfUser("0", "100"); // FIXME
+        }
         @RequestMapping(value = "/terms", method = RequestMethod.POST,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         @PreAuthorize("hasAuthority('REGISTERED_USER')")
         public void updateRepositoriesTerms(@RequestBody List<RepositoryTerms> repositoriesTerms) throws Exception {
             Date date = new Date();
             if (repositoriesTerms != null) {
             for (RepositoryTerms terms : repositoriesTerms) {
                     Repository repository = repositoryService.getRepositoryById(terms.getId());
                     repository.setConsentTermsOfUse(terms.getConsentTermsOfUse());
                     repository.setFullTextDownload(terms.getFullTextDownload());
                     repository.setLastConsentTermsOfUseDate(date);
                     repositoryService.updateRepository(repository, SecurityContextHolder.getContext().getAuthentication());
+                }
+            }
+        }
         @RequestMapping(value = "/searchRegisteredRepositories/{page}/{size}", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         @PreAuthorize("hasAuthority('SUPER_ADMINISTRATOR') or hasAuthority('CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR')")
         public List<RepositorySnippet> searchRegisteredRepositories(@RequestParam(name = "country", required = false) String country,
                                                                     @RequestParam(name = "typology", required = false) String typology,
                                                                     @RequestParam(name = "englishName", required = false) String englishName,
                                                                     @RequestParam(name = "officialName", required = false) String officialName,
                                                                     @RequestParam("requestSortBy") String requestSortBy,
                                                                     @RequestParam("order") String order,
                                                                     @PathVariable("page") int page,
                                                                     @PathVariable("size") int pageSize) throws Exception {
             return repositoryService.searchRegisteredRepositories(country, typology, englishName, officialName, requestSortBy, order, page, pageSize);
+        }
         @RequestMapping(value = "/getRepositoryById/{id}", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         @PostAuthorize("hasAnyAuthority('SUPER_ADMINISTRATOR', 'CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR') or @authorizationService.isMemberOf(#id) or (returnObject.registeredBy=='null' and hasAuthority('REGISTERED_USER'))")
         public Repository getRepositoryById(@PathVariable("id") String id) throws JSONException, ResourceNotFoundException {
             Repository repo = repositoryService.getRepositoryById(id);
             if (repo != null)
                 logger.info("Returning repository " + repo.getId() + " registered by " + repo.getRegisteredBy());
             else
                 logger.info("Requested repository " + id + " not found");
             return repo;
+        }
         @RequestMapping(value = "/getRepositoryAggregations/{id}", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         public List<AggregationDetails> getRepositoryAggregations(@PathVariable("id") String id) throws JSONException {
             return repositoryService.getRepositoryAggregations(id, 0, 20);
+        }
         @RequestMapping(value = "/getRepositoryAggregationsByYear/{id}", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         public Map<String, List<AggregationDetails>> getRepositoryAggregationsByYear(@PathVariable("id") String id) throws JSONException {
             return repositoryService.getRepositoryAggregationsByYear(id);
+        }
         @RequestMapping(value = "/getRepositoriesByName/{name:.+}/{page}/{size}/", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         public List<Repository> getRepositoriesByName(@PathVariable("name") String name,
                                                       @PathVariable("page") String page,
                                                       @PathVariable("size") String size) throws JSONException {
             return repositoryService.getRepositoriesByName(name, page, size);
+        }
         @RequestMapping(value = "/getRepositoryInterface/{id}", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         @PostAuthorize("hasAuthority('SUPER_ADMINISTRATOR') or hasAuthority('CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR') or @authorizationService.isMemberOf(#id) or (@repositoryService.getRepositoryById(#id).registeredBy=='null' and hasAuthority('REGISTERED_USER'))")
         public List<RepositoryInterface> getRepositoryInterface(@PathVariable("id") String id) throws JSONException {
             return repositoryService.getRepositoryInterface(id);
+        }
         @RequestMapping(value = "/addRepository", method = RequestMethod.POST,
                 consumes = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
     //    @PreAuthorize("hasAuthority('SUPER_ADMINISTRATOR') or hasAuthority('CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR') or (hasAuthority(@authorizationService.convertRepoIdToRoleId(#repository.id)) or hasAuthority(@authorizationService.convertRepoIdToRoleId(returnObject.id)))")
         @PreAuthorize("hasAuthority('SUPER_ADMINISTRATOR') or hasAuthority('CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR') or hasAuthority('REGISTERED_USER')")
         public Repository addRepository(@RequestParam("datatype") String datatype,
                                         @RequestBody Repository repository) throws Exception {
             return repositoryService.addRepository(datatype, repository);
+        }
         @RequestMapping(value = "/getDnetCountries", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         public List<String> getDnetCountries() {
             return repositoryService.getDnetCountries();
+        }
         @RequestMapping(value = "/getTypologies", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         public List<String> getTypologies() {
             return repositoryService.getTypologies();
+        }
         @RequestMapping(value = "/getTimezones", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         public List<Timezone> getTimezones() {
             return repositoryService.getTimezones();
+        }
         @RequestMapping(value = "/updateRepository", method = RequestMethod.POST,
                 consumes = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         @PreAuthorize("hasAuthority('SUPER_ADMINISTRATOR') or hasAuthority('CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR') or @authorizationService.isMemberOfInterface(#repository.id)")
         public Repository updateRepository(@RequestBody Repository repository, Authentication authentication) throws Exception {
             return repositoryService.updateRepository(repository, authentication);
+        }
         @RequestMapping(value = "/deleteInterface/", method = RequestMethod.DELETE)
         @PreAuthorize("hasAuthority('SUPER_ADMINISTRATOR') or hasAuthority('CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR') or @authorizationService.isMemberOfInterface(#id)")
         public void deleteRepositoryInterface(@RequestParam("id") String id,
                                               @RequestParam("registeredBy") String registeredBy) {
             repositoryService.deleteRepositoryInterface(id, registeredBy);
+        }
         @RequestMapping(value = "/addInterface", method = RequestMethod.POST,
                 consumes = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         @PreAuthorize("hasAuthority('SUPER_ADMINISTRATOR') or hasAuthority('CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR') or @authorizationService.isMemberOf(#id)")
         public RepositoryInterface addRepositoryInterface(@RequestParam("datatype") String datatype,
                                                           @RequestParam("repoId") String id,
                                                           @RequestParam("registeredBy") String registeredBy,
                                                           @RequestParam(value = "comment", required = false) String comment,
                                                           @RequestBody RepositoryInterface repositoryInterface) throws Exception {
             return repositoryService.addRepositoryInterface(datatype, id, registeredBy, comment, repositoryInterface);
+        }
         @RequestMapping(value = "/updateRepositoryInterface", method = RequestMethod.POST,
                 consumes = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         @PreAuthorize("hasAuthority('SUPER_ADMINISTRATOR') or hasAuthority('CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR') or @authorizationService.isMemberOf(#id)")
         public RepositoryInterface updateRepositoryInterface(@RequestParam("repoId") String id,
                                                              @RequestParam("registeredBy") String registeredBy,
                                                              @RequestParam(value = "comment", required = false) String comment,
                                                              @RequestBody RepositoryInterface repositoryInterface) throws Exception {
             return repositoryService.updateRepositoryInterface(id, registeredBy, comment, repositoryInterface);
+        }
         @RequestMapping(value = "/getUrlsOfUserRepos/{page}/{size}/", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         @PreAuthorize("hasAuthority('REGISTERED_USER')")
         public List<String> getUrlsOfUserRepos(@PathVariable("page") String page, @PathVariable("size") String size) {
             return repositoryService.getUrlsOfUserRepos(((OIDCAuthenticationToken) SecurityContextHolder.getContext().getAuthentication()).getUserInfo().getEmail(), page, size);
+        }
         @RequestMapping(value = "/getDatasourceVocabularies/{mode}", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         public List<String> getDatasourceVocabularies(@PathVariable("mode") String mode) {
             return repositoryService.getDatasourceVocabularies(mode);
+        }
         @RequestMapping(value = "/getCompatibilityClasses/{mode}", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         public Map<String, String> getCompatibilityClasses(@PathVariable("mode") String mode) {
             return repositoryService.getCompatibilityClasses(mode);
+        }
         @RequestMapping(value = "/getDatasourceClasses/{mode}", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         public Map<String, String> getDatasourceClasses(@PathVariable("mode") String mode) {
             return repositoryService.getDatasourceClasses(mode);
+        }
         @RequestMapping(value = "/getMetricsInfoForRepository/{id}", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         public MetricsInfo getMetricsInfoForRepository(@PathVariable("id") String id) throws RepositoryServiceException {
             return repositoryService.getMetricsInfoForRepository(id);
+        }
         @RequestMapping(value = "/getListLatestUpdate/{mode}", method = RequestMethod.GET,
                 produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         public Map<String, String> getListLatestUpdate(@PathVariable("mode") String mode) throws JSONException {
             return repositoryService.getListLatestUpdate(mode);
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////////////
         ///////////////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Get all the admins of the repository
          */
         @RequestMapping(method = RequestMethod.GET, path = "{id}/admins")
         @PreAuthorize("hasAnyAuthority('SUPER_ADMINISTRATOR', 'CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR') or @authorizationService.isMemberOf(#id)")
         public ResponseEntity<List<User>> getAdminsOfARepo(@PathVariable("id") String id) {
             return new ResponseEntity<>(authorizationService.getAdminsOfRepo(id), HttpStatus.OK);
+        }
         /**
          * Subscribe to repo by email
          */
         @RequestMapping(method = RequestMethod.POST, path = "{id}/admins")
         @PreAuthorize("hasAnyAuthority('SUPER_ADMINISTRATOR', 'CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR') or @authorizationService.isMemberOf(#id)")
         public Response subscribeByEmail(@PathVariable("id") String id, @RequestBody String email) throws ResourceNotFoundException {
             authorizationService.addAdmin(id, email);
             return Response.status(HttpStatus.OK.value()).entity(JsonUtils.createResponse("Role has been assigned").toString()).type(javax.ws.rs.core.MediaType.APPLICATION_JSON).build();
+        }
         /**
          * Unsubscribe from repo by email
          */
         @RequestMapping(method = RequestMethod.DELETE, path = "{id}/admins/{email:.+}")
         @PreAuthorize("hasAnyAuthority('SUPER_ADMINISTRATOR', 'CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR') or @authorizationService.isMemberOf(#id)")
         public ResponseEntity<Void> unsubscribeByEmail(@PathVariable("id") String id, @PathVariable("email") String email) throws ResourceNotFoundException {
             authorizationService.removeAdmin(id, email);
             return new ResponseEntity<>(HttpStatus.NO_CONTENT);
+        }
+    }

     package eu.dnetlib.repo.manager.domain;
     import java.util.ArrayList;
     import java.util.List;
     public class Aggregations{
         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.domain;
     import eu.dnetlib.domain.data.PiwikInfo;
     public class UsageSummary {
         private MetricsInfo metricsInfo;
         private PiwikInfo piwikInfo;
         public UsageSummary() {
+        }
         public UsageSummary(MetricsInfo metricsInfo, PiwikInfo piwikInfo) {
             this.metricsInfo = metricsInfo;
             this.piwikInfo = piwikInfo;
+        }
         public MetricsInfo getMetricsInfo() {
             return metricsInfo;
+        }
         public void setMetricsInfo(MetricsInfo metricsInfo) {
             this.metricsInfo = metricsInfo;
+        }
         public PiwikInfo getPiwikInfo() {
             return piwikInfo;
+        }
         public void setPiwikInfo(PiwikInfo piwikInfo) {
             this.piwikInfo = piwikInfo;
+        }
+    }

     package eu.dnetlib.repo.manager.controllers;
     import eu.dnetlib.repo.manager.domain.dto.Role;
     import eu.dnetlib.repo.manager.service.aai.registry.AaiRegistryService;
     import eu.dnetlib.repo.manager.service.security.AuthoritiesUpdater;
     import eu.dnetlib.repo.manager.service.security.AuthorizationService;
     import eu.dnetlib.repo.manager.service.security.RoleMappingService;
     import eu.dnetlib.repo.manager.utils.JsonUtils;
     import io.swagger.annotations.Api;
     import io.swagger.annotations.ApiOperation;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.http.HttpStatus;
     import org.springframework.http.ResponseEntity;
     import org.springframework.security.access.prepost.PreAuthorize;
     import org.springframework.web.bind.annotation.*;
     import javax.ws.rs.core.MediaType;
     import javax.ws.rs.core.Response;
     import java.util.Collection;
     //@RestController
     //@RequestMapping(value = "/role-management")
     //@Api(description = "Role Management", value = "role-management")
     public class UserRoleController {
         private final AaiRegistryService aaiRegistryService;
         private final AuthoritiesUpdater authoritiesUpdater;
         private final RoleMappingService roleMappingService;
         private final AuthorizationService authorizationService;
         @Autowired
         UserRoleController(AaiRegistryService aaiRegistryService,
                            AuthoritiesUpdater authoritiesUpdater,
                            RoleMappingService roleMappingService,
                            AuthorizationService authorizationService) {
             this.aaiRegistryService = aaiRegistryService;
             this.authoritiesUpdater = authoritiesUpdater;
             this.roleMappingService = roleMappingService;
             this.authorizationService = authorizationService;
+        }
         /**
          * Get the role with the given id.
          **/
         @RequestMapping(method = RequestMethod.GET, path = "/role/{id}")
     //    @PreAuthorize("hasAnyAuthority('REGISTERED_USER', 'SUPER_ADMINISTRATOR', 'CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR')")
         public Response getRole(@RequestParam(value = "type", defaultValue = "datasource") String type, @PathVariable("id") String id) {
             int roleId = aaiRegistryService.getCouId(type, id);
             return Response.status(HttpStatus.OK.value()).entity(JsonUtils.createResponse("Role id is: " + roleId).toString()).type(MediaType.APPLICATION_JSON).build();
+        }
         /**
          * Create a new role with the given name and description.
          **/
         @RequestMapping(method = RequestMethod.POST, path = "/role")
         @PreAuthorize("hasAnyAuthority('SUPER_ADMINISTRATOR')")
         public Response createRole(@RequestBody Role role) {
             aaiRegistryService.createRole(role);
             return Response.status(HttpStatus.OK.value()).entity(JsonUtils.createResponse("Role has been created").toString()).type(MediaType.APPLICATION_JSON).build();
+        }
         /**
          * Subscribe to a type(Community, etc.) with id(ee, egi, etc.)
          */
         @ApiOperation(value = "subscribe")
         @RequestMapping(method = RequestMethod.POST, path = "/subscribe/{type}/{id}")
         @PreAuthorize("hasAnyAuthority('SUPER_ADMINISTRATOR', 'CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR')")
         public Response subscribe(@PathVariable("type") String type, @PathVariable("id") String id) {
             Integer coPersonId = aaiRegistryService.getCoPersonIdByIdentifier();
             if (coPersonId == null) {
                 coPersonId = aaiRegistryService.getCoPersonIdByEmail();
+            }
             Integer couId = aaiRegistryService.getCouId(type, id);
             if (couId != null) {
                 Integer role = aaiRegistryService.getRoleId(coPersonId, couId);
                 aaiRegistryService.assignMemberRole(coPersonId, couId, role);
                 // Add role to current authorities
                 authoritiesUpdater.addRole(roleMappingService.convertRepoIdToAuthority(id));
                 return Response.status(HttpStatus.OK.value()).entity(JsonUtils.createResponse("Role has been assigned").toString()).type(MediaType.APPLICATION_JSON).build();
             } else {
                 return Response.status(HttpStatus.NOT_FOUND.value()).entity(JsonUtils.createResponse("Role has not been found").toString()).type(MediaType.APPLICATION_JSON).build();
+            }
+        }
         /////////////////////////////////////////////////////////////////////////////////////////////
         /////////////////////////////////////////////////////////////////////////////////////////////
         @RequestMapping(method = RequestMethod.GET, path = "/users/couid/{id}")
         @PreAuthorize("hasAnyAuthority('SUPER_ADMINISTRATOR', 'CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR')")
         public ResponseEntity<String> getUsersByCouId(@PathVariable("id") Integer id) {
     //        calls.getUserByCoId()
             return ResponseEntity.ok(aaiRegistryService.getUsersByCouId(id).toString());
+        }
         @RequestMapping(method = RequestMethod.GET, path = "/users/{email}/roles")
         @PreAuthorize("hasAnyAuthority('SUPER_ADMINISTRATOR', 'CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR') or hasAuthority('REGISTERED_USER') and authentication.userInfo.email==#email")
         public ResponseEntity<Collection<String>> getRolesByEmail(@PathVariable("email") String email) {
             return ResponseEntity.ok(authorizationService.getUserRoles(email));
+        }
         @RequestMapping(method = RequestMethod.GET, path = "/user/roles/my")
         @PreAuthorize("hasAuthority('REGISTERED_USER')")
         public ResponseEntity<Collection<String>> getRoleNames() {
             return ResponseEntity.ok(authorizationService.getUserRoles());
+        }
+    }

     package eu.dnetlib.repo.manager.domain;
     import java.util.List;
     public class CollectionMonitorSummary {
         private List<AggregationDetails> aggregationDetails;
         private AggregationDetails lastIndexedVersion;
         public CollectionMonitorSummary(){}
         public CollectionMonitorSummary(List<AggregationDetails> aggregationDetails, AggregationDetails lastIndexedVersion) {
             this.aggregationDetails = aggregationDetails;
             this.lastIndexedVersion = lastIndexedVersion;
+        }
         public List<AggregationDetails> getAggregationDetails() {
             return aggregationDetails;
+        }
         public void setAggregationDetails(List<AggregationDetails> aggregationDetails) {
             this.aggregationDetails = aggregationDetails;
+        }
         public AggregationDetails getLastIndexedVersion() {
             return lastIndexedVersion;
+        }
         public void setLastIndexedVersion(AggregationDetails lastIndexedVersion) {
             this.lastIndexedVersion = lastIndexedVersion;
+        }
+    }

     package eu.dnetlib.repo.manager.controllers;
     import eu.dnetlib.repo.manager.service.PiWikService;
     import eu.dnetlib.repo.manager.service.RepositoryService;
     import eu.dnetlib.repo.manager.service.RepositoryServiceImpl;
     import io.micrometer.core.instrument.binder.jvm.DiskSpaceMetrics;
     import io.micrometer.core.instrument.binder.jvm.JvmGcMetrics;
     import io.micrometer.core.instrument.binder.jvm.JvmMemoryMetrics;
     import io.micrometer.core.instrument.binder.jvm.JvmThreadMetrics;
     import io.micrometer.core.instrument.binder.system.ProcessorMetrics;
     import io.micrometer.core.instrument.binder.system.UptimeMetrics;
     import io.micrometer.prometheus.PrometheusConfig;
     import io.micrometer.prometheus.PrometheusMeterRegistry;
     import io.prometheus.client.exporter.common.TextFormat;
     import org.apache.log4j.Logger;
     import org.json.JSONException;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.http.MediaType;
     import org.springframework.web.bind.annotation.RequestMapping;
     import org.springframework.web.bind.annotation.RequestMethod;
     import org.springframework.web.bind.annotation.RestController;
     import java.io.File;
     @RestController
     @RequestMapping("/actuator/prometheus")
     public class PrometheusController { // TODO: remove this with migration to Spring Boot 2
         private static final Logger LOGGER = Logger.getLogger(PrometheusController.class);
         private final PiWikService piWikService;
         private final RepositoryService repositoryService;
         @Autowired
         public PrometheusController(PiWikService piWikService, RepositoryService repositoryService) {
             this.piWikService = piWikService;
             this.repositoryService = repositoryService;
+        }
         @RequestMapping(method = RequestMethod.GET, path = "", produces = MediaType.TEXT_PLAIN_VALUE)
         public String getPiwikMetrics() {
             PrometheusMeterRegistry registry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
             registry.counter("provide_repositories_registered").increment(repositoryService.getTotalRegisteredRepositories());
             registry.counter("provide_usagecounts_repositories_registered").increment(piWikService.getTotal());
             registry.counter("provide_usagecounts_repositories_validated").increment(piWikService.getValidated(true));
             return registry.scrape(TextFormat.CONTENT_TYPE_OPENMETRICS_100);
+        }
         @RequestMapping(method = RequestMethod.GET, path = "metrics", produces = MediaType.TEXT_PLAIN_VALUE)
         public String getMetrics() {
             PrometheusMeterRegistry registry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
             new JvmThreadMetrics().bindTo(registry);
             new JvmGcMetrics().bindTo(registry);
             new JvmMemoryMetrics().bindTo(registry);
             new DiskSpaceMetrics(new File("/")).bindTo(registry);
             new ProcessorMetrics().bindTo(registry); // metrics related to the CPU stats
             new UptimeMetrics().bindTo(registry);
             return registry.scrape(TextFormat.CONTENT_TYPE_OPENMETRICS_100);
+        }
+    }

     package eu.dnetlib.repo.manager.domain;
     /**
      * Created by nikonas on 7/12/15.
      */
     public class ValidationServiceException extends Exception{
         public enum ErrorCode{
             NO_ADMIN_EMAILS,
             NOT_VALID_BASEURL,
             GENERAL_ERROR, NOT_VALID_SET
+        }
         private ErrorCode errorCode = null;
         public ValidationServiceException() {
+        }
         public ValidationServiceException(ErrorCode errorCode) {
             this.errorCode = errorCode;
+        }
         public ValidationServiceException(String message, Throwable cause, ErrorCode errorCode) {
             super(message, cause);
             this.errorCode = errorCode;
+        }
         public ValidationServiceException(String message, ErrorCode errorCode) {
             super(message);
             this.errorCode = errorCode;
+        }
         public ValidationServiceException(Throwable cause, ErrorCode errorCode) {
             super(cause);
             this.errorCode = errorCode;
+        }
         public ErrorCode getErrorCode() {
             return errorCode;
+        }
+    }

     package eu.dnetlib.repo.manager.domain;
     /**
      * Created by stefania on 12/18/15.
      */
     public class Tuple<K, V>   {
         private K first;
         private V second;
         public Tuple() {
+        }
         public Tuple(K first, V second) {
             this.first = first;
             this.second = second;
+        }
         public K getFirst() {
             return first;
+        }
         public void setFirst(K first) {
             this.first = first;
+        }
         public V getSecond() {
             return second;
+        }
         public void setSecond(V second) {
             this.second = second;
+        }
+    }

     package eu.dnetlib.repo.manager.controllers;
     import eu.dnetlib.domain.data.PiwikInfo;
     import eu.dnetlib.repo.manager.domain.OrderByField;
     import eu.dnetlib.repo.manager.domain.OrderByType;
     import eu.dnetlib.repo.manager.domain.Paging;
     import eu.dnetlib.repo.manager.domain.RepositoryServiceException;
     import eu.dnetlib.repo.manager.service.PiWikServiceImpl;
     import io.swagger.annotations.Api;
     import io.swagger.annotations.ApiImplicitParam;
     import io.swagger.annotations.ApiImplicitParams;
     import org.apache.log4j.Logger;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.core.io.FileSystemResource;
     import org.springframework.http.MediaType;
     import org.springframework.http.ResponseEntity;
     import org.springframework.security.access.prepost.PreAuthorize;
     import org.springframework.web.bind.annotation.*;
     import javax.servlet.http.HttpServletRequest;
     import javax.servlet.http.HttpServletResponse;
     import java.io.FileNotFoundException;
     import java.io.IOException;
     import java.io.PrintWriter;
     import java.nio.file.Files;
     import java.nio.file.Path;
     import java.text.SimpleDateFormat;
     import java.util.Date;
     import java.util.List;
     @RestController
     @RequestMapping(value = "/piwik")
     @Api(description = "Piwik API",  tags = {"piwik"})
     public class PiWikController {
         private static final Logger LOGGER = Logger
                 .getLogger(PiWikController.class);
         @Autowired
         private PiWikServiceImpl piWikService;
         @RequestMapping(value = "/getPiwikSiteForRepo/{repositoryId}" , method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)
         @ResponseBody
         @PreAuthorize("hasAnyAuthority('SUPER_ADMINISTRATOR', 'CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR') or @authorizationService.isMemberOf(#repositoryId) or (@repositoryService.getRepositoryById(#repositoryId).registeredBy=='null' and hasAuthority('REGISTERED_USER'))")
         public PiwikInfo getPiwikSiteForRepo(@PathVariable("repositoryId") String repositoryId) {
             return piWikService.getPiwikSiteForRepo(repositoryId);
+        }
         @RequestMapping(value = "/savePiwikInfo" , method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
         @PreAuthorize("hasAnyAuthority('SUPER_ADMINISTRATOR', 'CONTENT_PROVIDER_DASHBOARD_ADMINISTRATOR') or @authorizationService.isMemberOf(#piwikInfo.repositoryId) or (@repositoryService.getRepositoryById(#piwikInfo.repositoryId).registeredBy=='null' and hasAuthority('REGISTERED_USER'))")
         public PiwikInfo savePiwikInfo(@RequestBody PiwikInfo piwikInfo) {
             return piWikService.savePiwikInfo(piwikInfo);
+        }
         @RequestMapping(value = "/getPiwikSitesForRepos" , method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)
         @ApiImplicitParams({
                 @ApiImplicitParam(name = "from", dataType = "number", paramType = "query"),
                 @ApiImplicitParam(name = "quantity", dataType = "number", paramType = "query"),
                 @ApiImplicitParam(name = "order", dataType = "eu.dnetlib.repo.manager.domain.OrderByType", paramType = "query"),
                 @ApiImplicitParam(name = "orderField", dataType = "eu.dnetlib.repo.manager.domain.OrderByField", paramType = "query"),
                 @ApiImplicitParam(name = "searchField", dataType = "string", paramType = "query"),
         })
         public Paging<PiwikInfo> getPiwikSitesForRepos(
                 @RequestParam(value = "from",required=false,defaultValue = "0") int from,
                 @RequestParam(value = "quantity",required=false,defaultValue = "100") int quantity,
                 @RequestParam(value = "order",required=false,defaultValue = "DSC") OrderByType orderType,
                 @RequestParam(value = "orderField", required = false, defaultValue = "REPOSITORY_NAME") OrderByField orderField,
                 @RequestParam(value = "searchField", required = false, defaultValue = "") String searchField
         ){
             Paging<PiwikInfo> results = new Paging<>();
             List<PiwikInfo> returning = piWikService.getPiwikSitesForRepos(orderField,orderType,from,quantity,searchField);
             results.setFrom(from);
             results.setTo(from + returning.size());
             results.setTotal(piWikService.getPiwikSitesTotals(searchField));
             results.setResults(returning);
             return results;
+        }
         @ApiImplicitParams({
                 @ApiImplicitParam(name = "from", dataType = "number", paramType = "query"),
                 @ApiImplicitParam(name = "quantity", dataType = "number", paramType = "query"),
                 @ApiImplicitParam(name = "order", dataType = "eu.dnetlib.repo.manager.domain.OrderByType", paramType = "query"),
                 @ApiImplicitParam(name = "searchField", dataType = "eu.dnetlib.repo.manager.domain.OrderByField", paramType = "query"),
                 @ApiImplicitParam(name = "orderField", dataType = "string", paramType = "query"),
         })
         @RequestMapping(value = "/getPiwikSitesForRepos/csv" , method = RequestMethod.GET,produces = MediaType.APPLICATION_OCTET_STREAM_VALUE)
         @ResponseBody
         public FileSystemResource getPiwikSitesForReposToCsv(
                 @RequestParam(value = "from",required=false,defaultValue = "0") int from,
                 @RequestParam(value = "quantity",required=false,defaultValue = "10000") int quantity,
                 @RequestParam(value = "order",required=false,defaultValue = "DSC") OrderByType orderType,
                 @RequestParam(value = "orderField", required = false, defaultValue = "REPOSITORY_NAME") OrderByField orderField,
                 @RequestParam(value = "searchField", required = false, defaultValue = "") String searchField,
                 HttpServletResponse response,
                 HttpServletRequest request
         ) throws IOException {
             Path p = Files.createTempFile("exportingCsv-", new Date().toString());
             List<PiwikInfo> returning = piWikService.getPiwikSitesForRepos(orderField,orderType,0,10000,searchField);
             try (PrintWriter writer = new PrintWriter(p.toFile())) {
                 StringBuilder sb = new StringBuilder();
                 sb.append(" Repository ID , Repository name, Country, Site ID, Authentication token, Creation date, Requestor full name, Requestor email, Validated, Validation date, Comment \n");
                 for(PiwikInfo piwikInfo : returning){
                     sb.append(
                             (piwikInfo.getRepositoryId() == null ? "," : piwikInfo.getRepositoryId()+ ",")+
                                     (piwikInfo.getRepositoryName() == null ? "," : piwikInfo.getRepositoryName()+ ",")+
                                     (piwikInfo.getCountry() == null ? "," : piwikInfo.getCountry()+ ",")+
                                     (piwikInfo.getSiteId() == null ? "," : piwikInfo.getSiteId()+ ",") +
                                     (piwikInfo.getAuthenticationToken() == null ? "," : piwikInfo.getAuthenticationToken()+ ",")+
                                     (piwikInfo.getCreationDate() == null ? "," : piwikInfo.getCreationDate().toString()+ ",") +
                                     (piwikInfo.getRequestorName() == null ? "," : piwikInfo.getRequestorName()+ ",") +
                                     (piwikInfo.getRequestorEmail() == null ? "," : piwikInfo.getRequestorEmail()+ ",")+
                                     piwikInfo.isValidated() + "," +
                                     (piwikInfo.getValidationDate() == null ? "," : piwikInfo.getValidationDate().toString()+ ",") +
                                     (piwikInfo.getComment() == null ? "\n" : piwikInfo.getComment()+ "\n")
                     );
+                }
                 writer.write(sb.toString());
             } catch (FileNotFoundException e) {
                 LOGGER.error(e.getMessage());
+            }
             String mimeType = request.getServletContext().getMimeType(p.toFile().getAbsolutePath());
             if (mimeType == null) {
                 mimeType = "application/octet-stream";

Project

General

Profile

D-Net

Revision 62271

Added by Antonis Lempesis almost 2 years ago