D-Net

package eu.dnetlib.uoanotificationservice.utils;

import eu.dnetlib.uoaauthorizationlibrary.security.AuthorizationService;

import eu.dnetlib.uoanotificationservice.dao.NotificationDAO;

import eu.dnetlib.uoanotificationservice.entities.Notification;

import eu.dnetlib.uoanotificationservice.services.NotificationService;

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;

@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.getAaiId());

        return notificationDAO.findByIdAndUserNotAndGroupsIn(id, authorizationService.getAaiId(), groups) != null;

    }

    /*public boolean hasValidGroups(Set<String> groups) {

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

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

            return true;

        }

        for(String group : groups) {

        }

        return false;

    }*/

}

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

import java.util.List;

@Repository

public interface UserDAO extends MongoRepository<User, String> {

    List<User> findAll();

    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;

@Repository

public interface NotificationDAO extends MongoRepository<Notification, String> {

    Notification findById(String Id);

    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 org.apache.log4j.Logger;

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

import org.springframework.scheduling.annotation.Scheduled;

import org.springframework.stereotype.Service;

import java.util.Calendar;

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 service, List<String> roles) {

        logger.info("Getting notifications of user " + userId);

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

        services.add(service);

        services.add("all");

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

        groups.add(userId);

        groups.add("all");

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

        User user = userDAO.findById(userId);

        if(user != null) {

            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) {

        logger.info("Read notification " + id + " for  user " + userId);

        User user = userDAO.findById(userId);

        if(user == null) {

            user = new User();

            user.setId(userId);

            user.setRead(new HashSet<>());

        }

        user.getRead().add(id);

        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.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.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 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.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.REGISTERED_USER)")

    @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(), service, authorizationService.getRoles());

    }

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

    @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.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.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

@PropertySources({

        @PropertySource("classpath:notification.properties"),

        @PropertySource(value = "classpath:dnet-override.properties", ignoreResourceNotFound = true)

})

@EnableConfigurationProperties({MongoConfig.class})

@EnableScheduling

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

@Import({AuthorizationConfiguration.class})

public class NotificationConfiguration { }

notification.mongodb.host = localhost

notification.mongodb.port = 27017

notification.mongodb.database = openaire_notification

log4j.rootLogger = DEBUG, R

log4j.logger.eu.dnetlib = DEBUG

log4j.logger.org.springframework = DEBUG, S

log4j.additivity.org.springframework = false

log4j.appender.R=org.apache.log4j.RollingFileAppender

log4j.appender.R.File=/var/log/dnet/uoa-notification-service/uoa-notification-service.log

log4j.appender.R.MaxFileSize=10MB

log4j.appender.R.MaxBackupIndex=10

log4j.appender.R.layout=org.apache.log4j.PatternLayout

log4j.appender.R.layout.ConversionPattern= %d %p %t [%c] - %m%n

log4j.appender.S=org.apache.log4j.RollingFileAppender

log4j.appender.S.File=/var/log/dnet/uoa-notification-service/uoa-notification-service-spring.log

log4j.appender.S.MaxFileSize=10MB

log4j.appender.S.MaxBackupIndex=10

log4j.appender.S.layout=org.apache.log4j.PatternLayout

log4j.appender.S.layout.ConversionPattern= %d %p %t [%c] - %m%n

<?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>

	<groupId>eu.dnetlib</groupId>

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

	<version>1.0.0-SNAPSHOT</version>

	<packaging>jar</packaging>

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

	<parent>

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

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

		<version>1.5.8.RELEASE</version>

		<relativePath/> <!-- lookup parent from repository -->

	</parent>

	<properties>

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

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

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

	</properties>

	<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>1.0.0-SNAPSHOT</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>

	</build>

</project>