[Observe-commits] 06/18: Modélisation des utilisateurs et chargement au démarrage de l'application web (See #7494)

This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository observe. See http://git.codelutin.com/observe.git commit 61245bc03c8de739eeac82ce3e3ebcb6f2964b1c Author: Tony CHEMIT <chemit@codelutin.com> Date: Sun Aug 30 15:23:32 2015 +0200 Modélisation des utilisateurs et chargement au démarrage de l'application web (See #7494) --- .../web/ObserveWebApplicationContext.java | 22 ++- .../ObserveWebApplicationConfiguration.java | 27 ++- .../user/InvalidObserveWebUserException.java | 15 ++ .../InvalidObserveWebUserPermissionException.java | 15 ++ .../user/InvalidObserveWebUsersException.java | 15 ++ .../web/configuration/user/ObserveWebUser.java | 22 +++ .../user/ObserveWebUserPermission.java | 14 ++ .../web/configuration/user/ObserveWebUsers.java | 18 ++ .../configuration/user/ObserveWebUsersHelper.java | 138 ++++++++++++++++ .../user/impl/ObserveWebUserBean.java | 65 ++++++++ .../user/impl/ObserveWebUserImmutable.java | 58 +++++++ .../user/impl/ObserveWebUserPermissionBean.java | 38 +++++ .../impl/ObserveWebUserPermissionImmutable.java | 31 ++++ .../user/impl/ObserveWebUsersBean.java | 43 +++++ .../user/impl/ObserveWebUsersImmutable.java | 42 +++++ .../user/ObserveWebUsersHelperTest.java | 183 +++++++++++++++++++++ 16 files changed, 736 insertions(+), 10 deletions(-) diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/ObserveWebApplicationContext.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/ObserveWebApplicationContext.java index ae5990b..0ad4882 100644 --- a/observe-application-web/src/main/java/fr/ird/observe/application/web/ObserveWebApplicationContext.java +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/ObserveWebApplicationContext.java @@ -7,6 +7,11 @@ import fr.ird.observe.application.web.configuration.db.InvalidObserveWebDatabase import fr.ird.observe.application.web.configuration.db.InvalidObserveWebDatabasesException; import fr.ird.observe.application.web.configuration.db.ObserveWebDatabases; import fr.ird.observe.application.web.configuration.db.ObserveWebDatabasesHelper; +import fr.ird.observe.application.web.configuration.user.InvalidObserveWebUserException; +import fr.ird.observe.application.web.configuration.user.InvalidObserveWebUserPermissionException; +import fr.ird.observe.application.web.configuration.user.InvalidObserveWebUsersException; +import fr.ird.observe.application.web.configuration.user.ObserveWebUsers; +import fr.ird.observe.application.web.configuration.user.ObserveWebUsersHelper; import fr.ird.observe.services.ObserveService; import fr.ird.observe.services.ObserveServiceApplicationContext; import fr.ird.observe.services.ObserveServiceFactory; @@ -35,7 +40,9 @@ public class ObserveWebApplicationContext implements Closeable { protected ObserveServiceApplicationContext serviceApplicationContext; - private ObserveWebDatabases databases; + protected ObserveWebDatabases databases; + + protected ObserveWebUsers users; public static ObserveWebApplicationContext getApplicationContext(HttpContext context) { @@ -50,7 +57,7 @@ public class ObserveWebApplicationContext implements Closeable { } - public void init() throws InvalidObserveWebDatabaseException, InvalidObserveWebDatabasesException, InvalidObserveWebDatabaseRoleException { + public void init() throws InvalidObserveWebDatabaseException, InvalidObserveWebDatabasesException, InvalidObserveWebDatabaseRoleException, InvalidObserveWebUserPermissionException, InvalidObserveWebUsersException, InvalidObserveWebUserException { // init configuration applicationConfiguration = new ObserveWebApplicationConfiguration(); @@ -62,7 +69,8 @@ public class ObserveWebApplicationContext implements Closeable { databases = databasesHelper.load(applicationConfiguration.getDatabasesConfigurationFile()); // init users - //TODO + ObserveWebUsersHelper usersHelper = new ObserveWebUsersHelper(); + users = usersHelper.load(applicationConfiguration.getUsersConfigurationFile()); // init service application context serviceApplicationContext = new ObserveServiceApplicationContext(); @@ -86,6 +94,14 @@ public class ObserveWebApplicationContext implements Closeable { } + public ObserveWebDatabases getDatabases() { + return databases; + } + + public ObserveWebUsers getUsers() { + return users; + } + public ObserveDtoGsonSupplier getGsonSupplier() { return gsonSupplier; } diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/ObserveWebApplicationConfiguration.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/ObserveWebApplicationConfiguration.java index 8f7d723..4429dcc 100644 --- a/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/ObserveWebApplicationConfiguration.java +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/ObserveWebApplicationConfiguration.java @@ -134,6 +134,10 @@ public class ObserveWebApplicationConfiguration { if (!databasesConfigurationFile.exists()) { // Generate a default databasesConfigurationFile + if (log.isInfoEnabled()) { + log.info("Generate a default databasesConfigurationFile for tests purpose only:\n" + DEV_DATABASES_CONFIGURATION_FILE_CONTENT); + } + try { Files.write(databasesConfigurationFile.toPath(), DEV_DATABASES_CONFIGURATION_FILE_CONTENT.getBytes()); } catch (IOException e) { @@ -144,6 +148,9 @@ public class ObserveWebApplicationConfiguration { if (!usersConfigurationFile.exists()) { // Generate a default usersConfigurationFile + if (log.isInfoEnabled()) { + log.info("Generate a default usersConfigurationFile for tests purpose only:\n" + DEV_USERS_CONFIGURATION_FILE_CONTENT); + } try { Files.write(usersConfigurationFile.toPath(), DEV_USERS_CONFIGURATION_FILE_CONTENT.getBytes()); } catch (IOException e) { @@ -246,14 +253,20 @@ public class ObserveWebApplicationConfiguration { " roles: \n" + " - login: admin\n" + " password: a\n" + + " - login: referentiel\n" + + " password: a\n" + " url: jdbc:postgresql://localhost:5432/obstuna"; private static final String DEV_USERS_CONFIGURATION_FILE_CONTENT = - "databases: \n" + - "- name: production\n" + - " defaultDatabase: true\n" + - " roles: \n" + - " - login: admin\n" + - " password: a\n" + - " url: jdbc:postgresql://localhost:5432/obstuna"; + "users: \n" + + "- login: admin\n" + + " password: a\n" + + " permissions: \n" + + " - database: production\n" + + " role: admin\n" + + "- login: referentiel\n" + + " password: a\n" + + " permissions: \n" + + " - database: production\n" + + " role: referentiel"; } diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/InvalidObserveWebUserException.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/InvalidObserveWebUserException.java new file mode 100644 index 0000000..3d06b34 --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/InvalidObserveWebUserException.java @@ -0,0 +1,15 @@ +package fr.ird.observe.application.web.configuration.user; + +/** + * Created on 30/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class InvalidObserveWebUserException extends Exception { + + private static final long serialVersionUID = 1L; + + public InvalidObserveWebUserException(String message) { + super(message); + } +} diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/InvalidObserveWebUserPermissionException.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/InvalidObserveWebUserPermissionException.java new file mode 100644 index 0000000..20ebb4d --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/InvalidObserveWebUserPermissionException.java @@ -0,0 +1,15 @@ +package fr.ird.observe.application.web.configuration.user; + +/** + * Created on 30/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class InvalidObserveWebUserPermissionException extends Exception { + + private static final long serialVersionUID = 1L; + + public InvalidObserveWebUserPermissionException(String message) { + super(message); + } +} diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/InvalidObserveWebUsersException.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/InvalidObserveWebUsersException.java new file mode 100644 index 0000000..d617472 --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/InvalidObserveWebUsersException.java @@ -0,0 +1,15 @@ +package fr.ird.observe.application.web.configuration.user; + +/** + * Created on 30/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class InvalidObserveWebUsersException extends Exception { + + private static final long serialVersionUID = 1L; + + public InvalidObserveWebUsersException(String message) { + super(message); + } +} diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/ObserveWebUser.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/ObserveWebUser.java new file mode 100644 index 0000000..1c4211d --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/ObserveWebUser.java @@ -0,0 +1,22 @@ +package fr.ird.observe.application.web.configuration.user; + +import com.google.common.base.Optional; + +import java.util.Collection; + +/** + * Created on 30/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public interface ObserveWebUser<R extends ObserveWebUserPermission> { + + String getLogin(); + + String getPassword(); + + Collection<R> getPermissions(); + + Optional<R> getPermissionByDatabaseName(String databaseName); + +} diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/ObserveWebUserPermission.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/ObserveWebUserPermission.java new file mode 100644 index 0000000..6e156fa --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/ObserveWebUserPermission.java @@ -0,0 +1,14 @@ +package fr.ird.observe.application.web.configuration.user; + +/** + * Created on 30/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public interface ObserveWebUserPermission { + + String getDatabase(); + + String getRole(); + +} diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/ObserveWebUsers.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/ObserveWebUsers.java new file mode 100644 index 0000000..19e6b69 --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/ObserveWebUsers.java @@ -0,0 +1,18 @@ +package fr.ird.observe.application.web.configuration.user; + +import com.google.common.base.Optional; + +import java.util.Collection; + +/** + * Created on 30/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public interface ObserveWebUsers<U extends ObserveWebUser> { + + Collection<U> getUsers(); + + Optional<U> getUserByLogin(String login); + +} diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/ObserveWebUsersHelper.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/ObserveWebUsersHelper.java new file mode 100644 index 0000000..e3661ff --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/ObserveWebUsersHelper.java @@ -0,0 +1,138 @@ +package fr.ird.observe.application.web.configuration.user; + +import com.esotericsoftware.yamlbeans.YamlConfig; +import com.esotericsoftware.yamlbeans.YamlReader; +import com.esotericsoftware.yamlbeans.YamlWriter; +import com.google.common.base.Charsets; +import com.google.common.io.Files; +import fr.ird.observe.application.web.configuration.user.impl.ObserveWebUserBean; +import fr.ird.observe.application.web.configuration.user.impl.ObserveWebUserPermissionBean; +import fr.ird.observe.application.web.configuration.user.impl.ObserveWebUsersBean; +import fr.ird.observe.application.web.configuration.user.impl.ObserveWebUsersImmutable; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.lang3.StringUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.Reader; +import java.util.LinkedHashSet; +import java.util.Set; + +/** + * Created on 30/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ObserveWebUsersHelper { + + /** Logger. */ + private static final Log log = LogFactory.getLog(ObserveWebUsersHelper.class); + + public ObserveWebUsersImmutable load(File file) throws InvalidObserveWebUsersException, InvalidObserveWebUserException, InvalidObserveWebUserPermissionException { + + ObserveWebUsersBean observeWebUsersBean = loadBean(file); + validateObserveWebUsersBean(observeWebUsersBean); + ObserveWebUsersImmutable observeWebUsersImmutable = observeWebUsersBean.toImmutable(); + return observeWebUsersImmutable; + + } + + public ObserveWebUsersBean loadBean(File file) { + ObserveWebUsersBean result; + try (Reader fileReader = Files.newReader(file, Charsets.UTF_8)) { + YamlReader reader = new YamlReader(fileReader, createConfig()); + result = reader.read(ObserveWebUsersBean.class); + fileReader.close(); + + } catch (Exception e) { + throw new RuntimeException("Could not read users from file: " + file, e); + } + + return result; + } + + public void validateObserveWebUsersBean(ObserveWebUsersBean observeWebUsersBean) throws InvalidObserveWebUsersException, InvalidObserveWebUserException, InvalidObserveWebUserPermissionException { + + if (CollectionUtils.isEmpty(observeWebUsersBean.getUsers())) { + throw new InvalidObserveWebUserException("No user defined"); + } + + for (ObserveWebUserBean observeWebUserBean : observeWebUsersBean.getUsers()) { + validateObserveWebUserBean(observeWebUserBean); + } + + } + + public void validateObserveWebUserBean(ObserveWebUserBean observeWebUserBean) throws InvalidObserveWebUserPermissionException, InvalidObserveWebUserException { + + String login = observeWebUserBean.getLogin(); + if (StringUtils.isBlank(login)) { + throw new InvalidObserveWebUserException("Found a user with no login defined"); + } + + if (StringUtils.isBlank(observeWebUserBean.getPassword())) { + throw new InvalidObserveWebUserException("User " + login + " has no password defined"); + } + + if (CollectionUtils.isEmpty(observeWebUserBean.getPermissions())) { + throw new InvalidObserveWebUserException("User " + login + " has no roles defined"); + } + + // unique database name + Set<String> databaseNames = new LinkedHashSet<>(); + + for (ObserveWebUserPermissionBean observeWebUserPermissionBean : observeWebUserBean.getPermissions()) { + + validateObserveWebUserPermissionBean(observeWebUserBean, observeWebUserPermissionBean); + + boolean added = databaseNames.add(observeWebUserPermissionBean.getDatabase()); + if (!added) { + throw new InvalidObserveWebUserException("User " + login + " contains with a doublon database permission: " + observeWebUserPermissionBean.getDatabase()); + } + + } + + } + + public void validateObserveWebUserPermissionBean(ObserveWebUserBean observeWebUserBean, ObserveWebUserPermissionBean observeWebUserRoleBean) throws InvalidObserveWebUserPermissionException { + + String login = observeWebUserBean.getLogin(); + + if (StringUtils.isBlank(observeWebUserRoleBean.getDatabase())) { + throw new InvalidObserveWebUserPermissionException("User " + login + ", found a permission with no database name defined"); + } + if (StringUtils.isBlank(observeWebUserRoleBean.getRole())) { + throw new InvalidObserveWebUserPermissionException("User " + login + ", found a permission " + observeWebUserRoleBean.getDatabase() + " with no role defined"); + } + + } + + public void storeBean(ObserveWebUsersBean users, File file) { + + if (log.isInfoEnabled()) { + log.info("Store users to " + file); + } + + try (BufferedWriter fileWriter = Files.newWriter(file, Charsets.UTF_8)) { + YamlWriter writer = new YamlWriter(fileWriter, createConfig()); + writer.write(users); + writer.close(); + } catch (Exception e) { + throw new RuntimeException("Could not write users to file: " + file, e); + } + + } + + protected YamlConfig createConfig() { + + YamlConfig yamlConfig = new YamlConfig(); + yamlConfig.writeConfig.setIndentSize(2); + yamlConfig.writeConfig.setWriteRootTags(false); + yamlConfig.setPropertyElementType(ObserveWebUsersBean.class, "users", ObserveWebUserBean.class); + yamlConfig.setPropertyElementType(ObserveWebUserBean.class, "permissions", ObserveWebUserPermissionBean.class); + return yamlConfig; + + } +} diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUserBean.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUserBean.java new file mode 100644 index 0000000..4b87486 --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUserBean.java @@ -0,0 +1,65 @@ +package fr.ird.observe.application.web.configuration.user.impl; + +import com.google.common.base.Function; +import com.google.common.base.Optional; +import com.google.common.collect.Iterables; +import fr.ird.observe.application.web.configuration.user.ObserveWebUser; + +import java.util.LinkedHashSet; + +/** + * Created on 30/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ObserveWebUserBean implements ObserveWebUser<ObserveWebUserPermissionBean> { + + private String login; + + private String password; + + protected LinkedHashSet<ObserveWebUserPermissionBean> roles; + + @Override + public String getLogin() { + return login; + } + + @Override + public String getPassword() { + return password; + } + + @Override + public LinkedHashSet<ObserveWebUserPermissionBean> getPermissions() { + return roles; + } + + @Override + public Optional<ObserveWebUserPermissionBean> getPermissionByDatabaseName(String databaseName) { + throw new UnsupportedOperationException("Can not call this method on bean version, use immutable one."); + } + + public void setLogin(String login) { + this.login = login; + } + + public void setPassword(String password) { + this.password = password; + } + + public void setPermissions(LinkedHashSet<ObserveWebUserPermissionBean> roles) { + this.roles = roles; + } + + public ObserveWebUserImmutable toImmutable() { + return new ObserveWebUserImmutable(login, password, Iterables.transform(roles, new Function<ObserveWebUserPermissionBean, ObserveWebUserPermissionImmutable>() { + + @Override + public ObserveWebUserPermissionImmutable apply(ObserveWebUserPermissionBean input) { + return input.toImmutable(); + } + })); + } + +} diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUserImmutable.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUserImmutable.java new file mode 100644 index 0000000..2801cd6 --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUserImmutable.java @@ -0,0 +1,58 @@ +package fr.ird.observe.application.web.configuration.user.impl; + +import com.google.common.base.Function; +import com.google.common.base.Optional; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Maps; +import fr.ird.observe.application.web.configuration.user.ObserveWebUser; + +import java.util.Collection; + +/** + * Created on 30/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ObserveWebUserImmutable implements ObserveWebUser<ObserveWebUserPermissionImmutable> { + + private final String login; + + private final String password; + + private final ImmutableMap<String, ObserveWebUserPermissionImmutable> permissions; + + public ObserveWebUserImmutable(String login, String password, Iterable<ObserveWebUserPermissionImmutable> permissions) { + + this.login = login; + this.password = password; + this.permissions = Maps.uniqueIndex(permissions, new Function<ObserveWebUserPermissionImmutable, String>() { + + @Override + public String apply(ObserveWebUserPermissionImmutable input) { + return input.getDatabase(); + } + }); + + } + + @Override + public String getLogin() { + return login; + } + + @Override + public String getPassword() { + return password; + } + + @Override + public Collection<ObserveWebUserPermissionImmutable> getPermissions() { + return permissions.values(); + } + + @Override + public Optional<ObserveWebUserPermissionImmutable> getPermissionByDatabaseName(String databaseName) { + return Optional.fromNullable(permissions.get(databaseName)); + } + +} diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUserPermissionBean.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUserPermissionBean.java new file mode 100644 index 0000000..133c2f6 --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUserPermissionBean.java @@ -0,0 +1,38 @@ +package fr.ird.observe.application.web.configuration.user.impl; + +import fr.ird.observe.application.web.configuration.user.ObserveWebUserPermission; + +/** + * Created on 30/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ObserveWebUserPermissionBean implements ObserveWebUserPermission { + + private String role; + + private String database; + + @Override + public String getDatabase() { + return database; + } + + @Override + public String getRole() { + return role; + } + + public void setRole(String role) { + this.role = role; + } + + public void setDatabase(String database) { + this.database = database; + } + + public ObserveWebUserPermissionImmutable toImmutable() { + return new ObserveWebUserPermissionImmutable(database, role); + } + +} diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUserPermissionImmutable.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUserPermissionImmutable.java new file mode 100644 index 0000000..7692fda --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUserPermissionImmutable.java @@ -0,0 +1,31 @@ +package fr.ird.observe.application.web.configuration.user.impl; + +import fr.ird.observe.application.web.configuration.user.ObserveWebUserPermission; + +/** + * Created on 30/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ObserveWebUserPermissionImmutable implements ObserveWebUserPermission { + + private final String database; + + private final String role; + + public ObserveWebUserPermissionImmutable(String database, String role) { + this.database = database; + this.role = role; + } + + @Override + public String getDatabase() { + return database; + } + + @Override + public String getRole() { + return role; + } + +} diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUsersBean.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUsersBean.java new file mode 100644 index 0000000..d88e838 --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUsersBean.java @@ -0,0 +1,43 @@ +package fr.ird.observe.application.web.configuration.user.impl; + +import com.google.common.base.Function; +import com.google.common.base.Optional; +import com.google.common.collect.Iterables; +import fr.ird.observe.application.web.configuration.user.ObserveWebUsers; + +import java.util.LinkedHashSet; + +/** + * Created on 30/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ObserveWebUsersBean implements ObserveWebUsers<ObserveWebUserBean> { + + protected LinkedHashSet<ObserveWebUserBean> users; + + @Override + public LinkedHashSet<ObserveWebUserBean> getUsers() { + return users; + } + + @Override + public Optional<ObserveWebUserBean> getUserByLogin(String databaseName) { + throw new UnsupportedOperationException("Can not call this method on bean version, use immutable one."); + } + + public void setUsers(LinkedHashSet<ObserveWebUserBean> users) { + this.users = users; + } + + public ObserveWebUsersImmutable toImmutable() { + return new ObserveWebUsersImmutable(Iterables.transform(users, new Function<ObserveWebUserBean, ObserveWebUserImmutable>() { + + @Override + public ObserveWebUserImmutable apply(ObserveWebUserBean input) { + return input.toImmutable(); + } + })); + } + +} diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUsersImmutable.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUsersImmutable.java new file mode 100644 index 0000000..4ad728e --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/configuration/user/impl/ObserveWebUsersImmutable.java @@ -0,0 +1,42 @@ +package fr.ird.observe.application.web.configuration.user.impl; + +import com.google.common.base.Function; +import com.google.common.base.Optional; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Maps; +import fr.ird.observe.application.web.configuration.user.ObserveWebUsers; + +import javax.annotation.Nullable; +import java.util.Collection; + +/** + * Created on 30/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ObserveWebUsersImmutable implements ObserveWebUsers<ObserveWebUserImmutable> { + + private final ImmutableMap<String, ObserveWebUserImmutable> users; + + public ObserveWebUsersImmutable(Iterable<ObserveWebUserImmutable> users) { + this.users = Maps.uniqueIndex(users, new Function<ObserveWebUserImmutable, String>() { + + @Nullable + @Override + public String apply(ObserveWebUserImmutable input) { + return input.getLogin(); + } + }); + } + + @Override + public Collection<ObserveWebUserImmutable> getUsers() { + return users.values(); + } + + @Override + public Optional<ObserveWebUserImmutable> getUserByLogin(String login) { + return Optional.fromNullable(users.get(login)); + } + +} diff --git a/observe-application-web/src/test/java/fr/ird/observe/application/web/configuration/user/ObserveWebUsersHelperTest.java b/observe-application-web/src/test/java/fr/ird/observe/application/web/configuration/user/ObserveWebUsersHelperTest.java new file mode 100644 index 0000000..65cfbf7 --- /dev/null +++ b/observe-application-web/src/test/java/fr/ird/observe/application/web/configuration/user/ObserveWebUsersHelperTest.java @@ -0,0 +1,183 @@ +package fr.ird.observe.application.web.configuration.user; + +import com.google.common.base.Charsets; +import com.google.common.base.Optional; +import com.google.common.collect.Iterables; +import com.google.common.io.Files; +import fr.ird.observe.application.web.configuration.ObserveWebApplicationConfiguration; +import fr.ird.observe.application.web.configuration.user.impl.ObserveWebUserBean; +import fr.ird.observe.application.web.configuration.user.impl.ObserveWebUserImmutable; +import fr.ird.observe.application.web.configuration.user.impl.ObserveWebUserPermissionBean; +import fr.ird.observe.application.web.configuration.user.impl.ObserveWebUserPermissionImmutable; +import fr.ird.observe.application.web.configuration.user.impl.ObserveWebUsersBean; +import fr.ird.observe.application.web.configuration.user.impl.ObserveWebUsersImmutable; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.io.File; +import java.util.Collection; +import java.util.LinkedHashSet; +import java.util.Set; + +/** + * Created on 30/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ObserveWebUsersHelperTest { + + protected ObserveWebApplicationConfiguration configuration; + + protected ObserveWebUsersHelper observeWebUsersHelper; + + public static final String FILE_CONTENT = "users: \n" + + "- login: user1\n" + + " password: password1\n" + + " permissions: \n" + + " - database: production\n" + + " role: admin\n" + + " - database: test\n" + + " role: technicien\n" + + "- login: user2\n" + + " password: password2\n" + + " permissions: \n" + + " - database: test\n" + + " role: referentiel\n"; + + @Before + public void setUp() throws Exception { + configuration = new ObserveWebApplicationConfiguration(); + configuration.init(); + observeWebUsersHelper = new ObserveWebUsersHelper(); + } + + @Test + public void testLoad() throws Exception { + + File databasesFile = configuration.getUsersConfigurationFile(); + + Files.write(FILE_CONTENT, databasesFile, Charsets.UTF_8); + + ObserveWebUsersImmutable databases = observeWebUsersHelper.load(databasesFile); + Assert.assertNotNull(databases); + Collection<ObserveWebUserImmutable> usersSet = databases.getUsers(); + Assert.assertNotNull(usersSet); + Assert.assertEquals(2, usersSet.size()); + + Optional<ObserveWebUserImmutable> production = databases.getUserByLogin("user1"); + Assert.assertTrue(production.isPresent()); + + Optional<ObserveWebUserImmutable> production2 = databases.getUserByLogin("user3"); + Assert.assertFalse(production2.isPresent()); + + { + ObserveWebUserImmutable user = Iterables.get(usersSet, 0); + Assert.assertNotNull(user); + Assert.assertEquals("user1", user.getLogin()); + Assert.assertNotNull(user.getPermissions()); + Assert.assertEquals(2, user.getPermissions().size()); + + Optional<ObserveWebUserPermissionImmutable> administrateur = user.getPermissionByDatabaseName("production"); + Assert.assertTrue(administrateur.isPresent()); + + Optional<ObserveWebUserPermissionImmutable> administrateur2 = user.getPermissionByDatabaseName("administrateur2"); + Assert.assertFalse(administrateur2.isPresent()); + } + { + ObserveWebUserImmutable user = Iterables.get(usersSet, 1); + Assert.assertNotNull(user); + Assert.assertEquals("user2", user.getLogin()); + Assert.assertNotNull(user.getPermissions()); + Assert.assertEquals(1, user.getPermissions().size()); + + Optional<ObserveWebUserPermissionImmutable> administrateur = user.getPermissionByDatabaseName("test"); + Assert.assertTrue(administrateur.isPresent()); + + } + + } + + @Test + public void testLoadBean() throws Exception { + + File databasesFile = configuration.getUsersConfigurationFile(); + + Files.write(FILE_CONTENT, databasesFile, Charsets.UTF_8); + + ObserveWebUsersBean users = observeWebUsersHelper.loadBean(databasesFile); + Assert.assertNotNull(users); + Set<ObserveWebUserBean> usersSet = users.getUsers(); + Assert.assertNotNull(usersSet); + Assert.assertEquals(2, usersSet.size()); + + { + ObserveWebUser user = Iterables.get(usersSet, 0); + Assert.assertNotNull(user); + Assert.assertEquals("user1", user.getLogin()); + Assert.assertNotNull(user.getPermissions()); + Assert.assertEquals(2, user.getPermissions().size()); + } + { + ObserveWebUser user = Iterables.get(usersSet, 1); + Assert.assertNotNull(user); + Assert.assertEquals("user2", user.getLogin()); + Assert.assertNotNull(user.getPermissions()); + Assert.assertEquals(1, user.getPermissions().size()); + } + } + + @Test + public void testStoreBean() throws Exception { + + LinkedHashSet<ObserveWebUserBean> userSet = new LinkedHashSet<>(); + { + ObserveWebUserBean user = new ObserveWebUserBean(); + user.setLogin("user1"); + user.setPassword("password1"); + LinkedHashSet<ObserveWebUserPermissionBean> permissions = new LinkedHashSet<>(); + { + ObserveWebUserPermissionBean permission = new ObserveWebUserPermissionBean(); + permission.setDatabase("production"); + permission.setRole("admin"); + permissions.add(permission); + } + { + ObserveWebUserPermissionBean permission = new ObserveWebUserPermissionBean(); + permission.setDatabase("test"); + permission.setRole("technicien"); + permissions.add(permission); + } + + user.setPermissions(permissions); + userSet.add(user); + } + { + ObserveWebUserBean user = new ObserveWebUserBean(); + user.setLogin("user2"); + user.setPassword("password2"); + LinkedHashSet<ObserveWebUserPermissionBean> permissions = new LinkedHashSet<>(); + { + ObserveWebUserPermissionBean permission = new ObserveWebUserPermissionBean(); + permission.setDatabase("test"); + permission.setRole("referentiel"); + permissions.add(permission); + } + + user.setPermissions(permissions); + userSet.add(user); + } + ObserveWebUsersBean users = new ObserveWebUsersBean(); + users.setUsers(userSet); + + File databasesFile = configuration.getUsersConfigurationFile(); + + observeWebUsersHelper.storeBean(users, databasesFile); + + String fileContent = Files.asCharSource(databasesFile, Charsets.UTF_8).read(); + + Assert.assertEquals(FILE_CONTENT, fileContent); + System.out.println(fileContent); + + } +} \ No newline at end of file -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.