D-Net

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<parent>

		<groupId>eu.dnetlib</groupId>

		<artifactId>dnet45-parent</artifactId>

		<version>1.0.0</version>

	</parent>

	<artifactId>uoa-notification-service</artifactId>

	<version>1.0.3</version>

	<packaging>jar</packaging>

	<scm>

		<developerConnection>scm:svn:https://svn.driver.research-infrastructures.eu/driver/dnet45/modules/uoa-notification-service/tags/uoa-notification-service-1.0.3</developerConnection>

	</scm>

	<name>uoa-notification-service</name>

	<properties>

		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

		<java.version>1.8</java.version>

        <timestampNotificationLibrary>${maven.build.timestamp}</timestampNotificationLibrary>

        <maven.build.timestamp.format>E MMM dd HH:mm:ss z yyyy</maven.build.timestamp.format>

	</properties>

	<dependencyManagement>

		<dependencies>

			<dependency>

				<groupId>org.springframework.boot</groupId>

				<artifactId>spring-boot-dependencies</artifactId>

				<version>1.5.8.RELEASE</version>

				<type>pom</type>

				<scope>import</scope>

			</dependency>

		</dependencies>

	</dependencyManagement>

	<dependencies>

		<dependency>

			<groupId>org.springframework.boot</groupId>

			<artifactId>spring-boot-starter-web</artifactId>

			<exclusions>

				<exclusion>

					<groupId> org.springframework.boot</groupId>

					<artifactId>spring-boot-starter-logging</artifactId>

				</exclusion>

			</exclusions>

		</dependency>

		<dependency>

			<groupId>org.springframework.boot</groupId>

			<artifactId>spring-boot-starter-data-mongodb</artifactId>

		</dependency>

		<!-- Starter for using Spring Security -->

		<dependency>

			<groupId>org.springframework.boot</groupId>

			<artifactId>spring-boot-starter-security</artifactId>

		</dependency>

		<dependency>

			<groupId>eu.dnetlib</groupId>

			<artifactId>uoa-authorization-library</artifactId>

			<version>2.0.3</version>

		</dependency>

		<dependency>

			<groupId>com.google.code.gson</groupId>

			<artifactId>gson</artifactId>

			<version>2.8.2</version>

		</dependency>

		<dependency>

			<groupId>log4j</groupId>

			<artifactId>log4j</artifactId>

			<version>1.2.17</version>

		</dependency>

    </dependencies>

	<build>

		<plugins>

		</plugins>

        <finalName>uoa-notification-service</finalName>

        <resources>

            <resource>

                <directory>src/main/resources</directory>

                <filtering>true</filtering>

            </resource>

        </resources>

	</build>

</project>

package eu.dnetlib.uoanotificationservice.configuration;

import org.springframework.boot.context.properties.ConfigurationProperties;

import java.util.Date;

@ConfigurationProperties("notification.globalVars")

public class GlobalVars {

    public static Date date = new Date();

    private Date buildDate;

    private String version;

    public String getBuildDate() {

        if(buildDate == null) {

            return null;

        }

        return buildDate.toString();

    }

    public void setBuildDate(Date buildDate) {

        this.buildDate = buildDate;

    }

    public static Date getDate() {

        return date;

    }

    public static void setDate(Date date) {

        GlobalVars.date = date;

    }

    public String getVersion() {

        return version;

    }

    public void setVersion(String version) {

        this.version = version;

    }

}

package eu.dnetlib.uoanotificationservice.configuration;

import eu.dnetlib.uoaauthorizationlibrary.configuration.AuthorizationConfiguration;

import org.springframework.boot.context.properties.EnableConfigurationProperties;

import org.springframework.context.annotation.*;

import org.springframework.scheduling.annotation.EnableScheduling;

@Configuration

@EnableConfigurationProperties({MongoConfig.class, GlobalVars.class})

@EnableScheduling

@ComponentScan(basePackages = { "eu.dnetlib.uoanotificationservice"})

@Import({AuthorizationConfiguration.class})

public class NotificationConfiguration { }

package eu.dnetlib.uoanotificationservice.configuration;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties("notification.mongodb")

public class MongoConfig {

    private String host;

    private String database;

    private String username;

    private String password;

    private int port;

    public String getHost() {

        return host;

    }

    public void setHost(String host) {

        this.host = host;

    }

    public String getDatabase() {

        return database;

    }

    public void setDatabase(String database) {

        this.database = database;

    }

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

    public int getPort() {

        return port;

    }

    public void setPort(int port) {

        this.port = port;

    }

}

package eu.dnetlib.uoanotificationservice.configuration;

import com.mongodb.MongoClient;

import com.mongodb.MongoCredential;

import com.mongodb.ServerAddress;

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

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.mongodb.MongoDbFactory;

import org.springframework.data.mongodb.core.MongoTemplate;

import org.springframework.data.mongodb.core.SimpleMongoDbFactory;

import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;

import java.util.Collections;

@Configuration

@EnableMongoRepositories(basePackages = {"eu.dnetlib.uoanotificationservice.dao"}, mongoTemplateRef = "notificationTemplate")

public class NotificationMongoConnection {

    @Autowired

    private MongoConfig mongoConfig;

    @Bean

    public MongoDbFactory NotificationFactory() {

        return new SimpleMongoDbFactory(getMongoClient(), mongoConfig.getDatabase());

    }

    @Bean(name = "notificationTemplate")

    public MongoTemplate getNotificationTemplate() {

        return new MongoTemplate(NotificationFactory());

    }

    private MongoClient getMongoClient() {

        if(mongoConfig.getUsername() != null && mongoConfig.getPassword() != null){

            return new MongoClient(Collections.singletonList(

                    new ServerAddress(mongoConfig.getHost(), mongoConfig.getPort())),

                    Collections.singletonList(MongoCredential.createCredential(mongoConfig.getUsername(), mongoConfig.getDatabase(), mongoConfig.getPassword().toCharArray())));

        } else {

            return new MongoClient(Collections.singletonList(new ServerAddress(mongoConfig.getHost(), mongoConfig.getPort())));

        }

    }

}

package eu.dnetlib.uoanotificationservice.controllers;

import com.mongodb.BasicDBObject;

import com.mongodb.CommandResult;

import com.mongodb.DBObject;

import eu.dnetlib.uoanotificationservice.configuration.GlobalVars;

import eu.dnetlib.uoanotificationservice.configuration.MongoConfig;

import eu.dnetlib.uoanotificationservice.configuration.NotificationMongoConnection;

import org.apache.log4j.Logger;

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

import org.springframework.data.mongodb.core.MongoTemplate;

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

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

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

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

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

import java.util.HashMap;

import java.util.Map;

@RestController

@CrossOrigin(origins = "*")

@RequestMapping("/notification-service")

public class NotificationServiceCheckDeployController {

    private final Logger log = Logger.getLogger(this.getClass());

    @Autowired

    private NotificationMongoConnection mongoConnection;

    @Autowired

    private MongoConfig mongoConfig;

    @Autowired

    private GlobalVars globalVars;

    @RequestMapping(value = {"", "/health_check"}, method = RequestMethod.GET)

    public String hello() {

        log.debug("Hello from uoa-notification-service!");

        return "Hello from uoa-notification-service!";

    }

    @PreAuthorize("hasAnyAuthority(@AuthorizationService.PORTAL_ADMIN)")

    @RequestMapping(value = "/health_check/advanced", method = RequestMethod.GET)

    public Map<String, String> checkEverything() {

        Map<String, String> response = new HashMap<>();

        MongoTemplate mt = mongoConnection.getNotificationTemplate();

        DBObject ping = new BasicDBObject("ping", "1");

        try {

            CommandResult answer = mt.getDb().command(ping);

            response.put("Mongo try: error", answer.getErrorMessage());

        } catch (Exception e) {

            response.put("Mongo catch: error", e.getMessage());

        }

        response.put("notification.mongodb.database", mongoConfig.getDatabase());

        response.put("notification.mongodb.host", mongoConfig.getHost());

        response.put("notification.mongodb.port", String.valueOf(mongoConfig.getPort()));

        response.put("notification.mongodb.username", mongoConfig.getUsername() == null ? null : "[unexposed value]");

        response.put("notification.mongodb.password", mongoConfig.getPassword() == null ? null : "[unexposed value]");

        if(GlobalVars.date != null) {

            response.put("Date of deploy", GlobalVars.date.toString());

        }

        if(globalVars.getBuildDate() != null) {

            response.put("Date of build", globalVars.getBuildDate());

        }

        if (globalVars.getVersion() != null) {

            response.put("Version", globalVars.getVersion());

        }

        return response;

    }

}

package eu.dnetlib.uoanotificationservice.controllers;

import eu.dnetlib.uoaauthorizationlibrary.security.AuthorizationService;

import eu.dnetlib.uoanotificationservice.entities.Notification;

import eu.dnetlib.uoanotificationservice.entities.User;

import eu.dnetlib.uoanotificationservice.services.NotificationService;

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

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

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

import java.util.Date;

import java.util.List;

@RestController

@RequestMapping("/notification")

@CrossOrigin(origins = "*")

public class NotificationController {

    @Autowired

    private NotificationService notificationService;

    @Autowired

    private AuthorizationService authorizationService;

    @PreAuthorize("hasAuthority(@AuthorizationService.PORTAL_ADMIN)")

    @RequestMapping(value = {"/all"}, method = RequestMethod.GET)

    public List<Notification> getAllNotifications() {

        return notificationService.getAllNotifications();

    }

    @PreAuthorize("hasAuthority(@AuthorizationService.REGISTERED_USER)")

    @RequestMapping(value = {"/{service}"}, method = RequestMethod.GET)

    public List<Notification> getMyNotifications(@PathVariable String service) {

        return notificationService.getMyNotifications(authorizationService.getAaiId(), authorizationService.getEmail(),

                service, authorizationService.getRoles());

    }

    @PreAuthorize("hasAuthority(@AuthorizationService.REGISTERED_USER)")

    @RequestMapping(value = {"/all/{service}"}, method = RequestMethod.PUT)

    public User markAllAsRead(@PathVariable String service) {

        List<Notification> notifications = notificationService.getMyNotifications(authorizationService.getAaiId(), authorizationService.getEmail(),

                service, authorizationService.getRoles());

        return notificationService.readAllNotifications(notifications, authorizationService.getAaiId());

    }

    @PreAuthorize("hasAuthority(@AuthorizationService.REGISTERED_USER) && @Utils.hasValidGroups(#notification.groups)")

    @RequestMapping(value = {"/save"}, method = RequestMethod.POST)

    public Notification save(@RequestBody Notification notification) {

        notification.setUser(authorizationService.getAaiId());

        notification.setDate(new Date());

        notification.setRead(false);

        return notificationService.save(notification);

    }

    @PreAuthorize("hasAuthority(@AuthorizationService.REGISTERED_USER) && @Utils.canRead(#id)")

    @RequestMapping(value = {"/{id}"}, method = RequestMethod.PUT)

    public User readNotification(@PathVariable String id) {

        return notificationService.readNotification(authorizationService.getAaiId(), id);

    }

}

package eu.dnetlib.uoanotificationservice.utils;

import eu.dnetlib.uoaauthorizationlibrary.security.AuthorizationService;

import eu.dnetlib.uoanotificationservice.dao.NotificationDAO;

import org.apache.log4j.Logger;

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

import org.springframework.stereotype.Component;

import java.util.HashSet;

import java.util.Set;

import java.util.stream.Collectors;

@Component("Utils")

public class Utils {

    Logger logger = Logger.getLogger(Utils.class);

    @Autowired

    private AuthorizationService authorizationService;

    @Autowired

    private NotificationDAO notificationDAO;

    public boolean canRead(String id) {

        Set<String> groups = new HashSet<>(authorizationService.getRoles());

        groups.add("all");

        groups.add(authorizationService.getEmail().toLowerCase());

        return notificationDAO.findByIdAndUserNotAndGroupsIn(id, authorizationService.getAaiId(), groups).isPresent();

    }

    public boolean hasValidGroups(Set<String> groups) {

        Set<String> roles = new HashSet<>(authorizationService.getRoles());

        Set<String> check = new HashSet<>(groups);

        Set<String> types = getCuratorTypes(roles);

        if(roles.contains(authorizationService.PORTAL_ADMIN)) {

            return true;

        } else if(groups.contains("all")) {

            return false;

        }

        return check.stream().filter(group -> {

            for (String type : types) {

                if (group.contains(type)) {

                    return false;

                }

            }

            return true;

        }).allMatch(roles::contains);

    }

    private Set<String> getCuratorTypes(Set<String> roles) {

        return roles.stream().filter(role -> role.contains("CURATOR_")).

                map(curator -> curator.replace("CURATOR_", "")).collect(Collectors.toSet());

    }

}

package eu.dnetlib.uoanotificationservice.dao;

import eu.dnetlib.uoanotificationservice.entities.User;

import org.springframework.data.mongodb.repository.MongoRepository;

import org.springframework.stereotype.Repository;

import java.util.List;

import java.util.Optional;

@Repository

public interface UserDAO extends MongoRepository<User, String> {

    List<User> findAll();

    Optional<User> findById(String Id);

    List<User> findByReadContains(String id);

    User save(User user);

    void deleteAll();

    void delete(String id);

}

package eu.dnetlib.uoanotificationservice.dao;

import eu.dnetlib.uoanotificationservice.entities.Notification;

import org.springframework.data.mongodb.repository.MongoRepository;

import org.springframework.stereotype.Repository;

import java.util.Collection;

import java.util.Date;

import java.util.List;

import java.util.Optional;

@Repository

public interface NotificationDAO extends MongoRepository<Notification, String> {

    Optional<Notification> findById(String Id);

    Optional<Notification> findByIdAndUserNotAndGroupsIn(String id, String user, Collection<String> groups);

    List<Notification> findByOrderByDateDesc();

    List<Notification> findByUserNotAndServicesInAndGroupsInOrderByDateDesc(String user, Collection<String> services, Collection<String> groups);

    List<Notification> findByDateBefore(Date date);

}

package eu.dnetlib.uoanotificationservice.services;

import eu.dnetlib.uoanotificationservice.dao.NotificationDAO;

import eu.dnetlib.uoanotificationservice.dao.UserDAO;

import eu.dnetlib.uoanotificationservice.entities.Notification;

import eu.dnetlib.uoanotificationservice.entities.User;

import eu.dnetlib.uoanotificationservice.exception.ResourceNotFoundException;

import org.apache.log4j.Logger;

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

import org.springframework.stereotype.Service;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

@Service

public class NotificationService {

    Logger logger = Logger.getLogger(NotificationService.class);

    @Autowired

    private NotificationDAO notificationDAO;

    @Autowired

    private UserDAO userDAO;

    public List<Notification> getAllNotifications() {

        return notificationDAO.findByOrderByDateDesc();

    }

    public List<Notification> getMyNotifications(String userId, String email, String service, List<String> roles) {

        Set<String> services = new HashSet<>();

        services.add(service);

        services.add("all");

        Set<String> groups = new HashSet<>(roles);

        groups.add(email.toLowerCase());

        groups.add("all");

        List<Notification> notifications = notificationDAO.findByUserNotAndServicesInAndGroupsInOrderByDateDesc(userId, services, groups);

        userDAO.findById(userId).ifPresent(user -> notifications.forEach(notification -> {

            notification.setRead(user.getRead().contains(notification.getId()));

        }));

        return notifications;

    }

    public Notification save(Notification notification) {

        return notificationDAO.save(notification);

    }

    public User readNotification(String userId, String id) {

        Notification notification = notificationDAO.findById(id).orElseThrow(() -> new ResourceNotFoundException("Notification has not been found"));

        User user = userDAO.findById(userId).orElse(new User(userId, new HashSet<>()));

        user.getRead().add(notification.getId());

        return userDAO.save(user);

    }

    public User readAllNotifications(List<Notification> notifications, String userId) {

        User user = userDAO.findById(userId).orElse(new User(userId, new HashSet<>()));

        notifications.forEach(notification -> {

            user.getRead().add(notification.getId());

        });

        return userDAO.save(user);

    }

    public void delete(String id) {

        List<User> users = userDAO.findByReadContains(id);

        users.forEach(user -> {

            user.getRead().remove(id);

            userDAO.save(user);

        });

        notificationDAO.delete(id);

    }

//    // every min for testing

//    //@Scheduled(cron = "0 * * * * *"

//    // every day at midnight

//    @Scheduled(cron = "0 0 0 1/1 * ?")

//    protected void deleteNotifications() {

//        logger.info("Deleting notifications that have been created more than a week ago");

//        Calendar calendar = Calendar.getInstance();

//        calendar.add(Calendar.DAY_OF_MONTH, -7);

//        List<Notification> notifications = notificationDAO.findByDateBefore(calendar.getTime());

//        notifications.forEach(notification -> {

//            delete(notification.getId());

//        });

//    }

}

package eu.dnetlib.uoanotificationservice.entities;

import com.fasterxml.jackson.annotation.JsonProperty;

import org.springframework.data.annotation.Id;

import java.util.Set;

public class User {

    @Id

    @JsonProperty("_id")

    private String id;

    private Set<String> read;

    public User() {

    }

    public User(String id, Set<String> read) {

        this.id = id;

        this.read = read;

    }

    public String getId() {

        return id;

    }

    public void setId(String id) {

        this.id = id;

    }

    public Set<String> getRead() {

        return read;

    }

    public void setRead(Set<String> read) {

        this.read = read;

    }

}

package eu.dnetlib.uoanotificationservice.entities;

import com.fasterxml.jackson.annotation.JsonProperty;

import org.springframework.data.annotation.Id;

import java.util.Date;

import java.util.Set;

public class Notification {

    @Id

    @JsonProperty("_id")

    private String id;

    private String actionType;

    private Set<String> services;

    private String user;

    private String name;

    private String surname;

    private String title;

    private String message;

    private String stakeholder;

    private String stakeholderType;

    private String entity;

    private String entityType;

    private Date date;

    private Set<String> groups;

    private Boolean isRead;

    public Notification() {

    }

    public String getId() {

        return id;

    }

    public void setId(String id) {

        this.id = id;

    }

    public String getActionType() {

        return actionType;

    }

    public void setActionType(String actionType) {

        this.actionType = actionType;

    }

    public Set<String> getServices() {

        return services;

    }

    public void setServices(Set<String> service) {

        this.services = service;

    }

    public String getUser() {

        return user;

    }

    public void setUser(String user) {

        this.user = user;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getSurname() {

        return surname;

    }

    public void setSurname(String surname) {

        this.surname = surname;

    }

    public String getTitle() {

        return title;

    }

    public void setTitle(String title) {

        this.title = title;

    }

    public String getMessage() {

        return message;

    }

    public void setMessage(String message) {

        this.message = message;

    }

    public String getStakeholder() {

        return stakeholder;

    }

    public void setStakeholder(String stakeholder) {

        this.stakeholder = stakeholder;

    }

    public String getStakeholderType() {

        return stakeholderType;

    }

    public void setStakeholderType(String stakeholderType) {

        this.stakeholderType = stakeholderType;

    }

    public String getEntity() {

        return entity;

    }

    public void setEntity(String entity) {

        this.entity = entity;

    }

    public String getEntityType() {

        return entityType;

    }

    public void setEntityType(String entityType) {

        this.entityType = entityType;

    }

    public Date getDate() {

        return date;

    }

    public void setDate(Date date) {

        this.date = date;

    }

    public Set<String> getGroups() {

        return groups;

    }

    public void setGroups(Set<String> groups) {

        this.groups = groups;

    }

    public Boolean getRead() {

        return isRead;

    }

    public void setRead(Boolean read) {

        isRead = read;

    }

}

package eu.dnetlib.uoanotificationservice.exception;

import org.springframework.http.HttpStatus;

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

@ResponseStatus(value = HttpStatus.NOT_FOUND)  // 404

public class ResourceNotFoundException extends RuntimeException {

    public ResourceNotFoundException(String message) {

        super(message);

    }

    public ResourceNotFoundException(String message, Throwable err) {

        super(message, err);

    }

    public HttpStatus getStatus() {

        return HttpStatus.NOT_FOUND;

    }

}

#notification.mongodb.host = localhost

#notification.mongodb.port = 27017

#notification.mongodb.database = openaire_notification

notification.globalVars.buildDate=@timestampNotificationLibrary@

notification.globalVars.version=${project.version}