merge with 2.0.0-m3

scm-webapp/src/main/java/sonia/scm/ManagerDaoAdapter.java

@@ -0,0 +1,68 @@
+package sonia.scm;
+
+import com.github.sdorra.ssp.PermissionCheck;
+import sonia.scm.util.AssertUtil;
+
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public class ManagerDaoAdapter<T extends ModelObject, E extends Exception> {
+
+  private final GenericDAO<T> dao;
+  private final Function<T, E> notFoundException;
+  private final Function<T, E> alreadyExistsException;
+
+  public ManagerDaoAdapter(GenericDAO<T> dao, Function<T, E> notFoundException, Function<T, E> alreadyExistsException) {
+    this.dao = dao;
+    this.notFoundException = notFoundException;
+    this.alreadyExistsException = alreadyExistsException;
+  }
+
+  public void modify(T object, Function<T, PermissionCheck> permissionCheck, AroundHandler<T, E> beforeUpdate, AroundHandler<T, E> afterUpdate) throws E {
+    T notModified = dao.get(object.getId());
+    if (notModified != null) {
+      permissionCheck.apply(notModified).check();
+      AssertUtil.assertIsValid(object);
+
+      beforeUpdate.handle(notModified);
+
+      object.setLastModified(System.currentTimeMillis());
+      object.setCreationDate(notModified.getCreationDate());
+
+      dao.modify(object);
+
+      afterUpdate.handle(notModified);
+    } else {
+      throw notFoundException.apply(object);
+    }
+  }
+
+  public T create(T newObject, Supplier<PermissionCheck> permissionCheck, AroundHandler<T, E> beforeCreate, AroundHandler<T, E> afterCreate) throws E {
+    permissionCheck.get().check();
+    AssertUtil.assertIsValid(newObject);
+    if (dao.contains(newObject)) {
+      throw alreadyExistsException.apply(newObject);
+    }
+    newObject.setCreationDate(System.currentTimeMillis());
+    beforeCreate.handle(newObject);
+    dao.add(newObject);
+    afterCreate.handle(newObject);
+    return newObject;
+  }
+
+  public void delete(T toDelete, Supplier<PermissionCheck> permissionCheck, AroundHandler<T, E> beforeDelete, AroundHandler<T, E> afterDelete) throws E {
+    permissionCheck.get().check();
+    if (dao.contains(toDelete)) {
+      beforeDelete.handle(toDelete);
+      dao.delete(toDelete);
+      afterDelete.handle(toDelete);
+    } else {
+      throw notFoundException.apply(toDelete);
+    }
+  }
+
+  @FunctionalInterface
+  public interface AroundHandler<T extends ModelObject, E extends Exception> {
+    void handle(T notModified) throws E;
+  }
+}

scm-webapp/src/main/java/sonia/scm/group/DefaultGroupManager.java

@@ -43,6 +43,7 @@ import com.google.inject.Singleton;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import sonia.scm.HandlerEventType;
+import sonia.scm.ManagerDaoAdapter;
 import sonia.scm.SCMContextProvider;
 import sonia.scm.TransformFilter;
 import sonia.scm.search.SearchRequest;
@@ -84,6 +85,10 @@ public class DefaultGroupManager extends AbstractGroupManager
   public DefaultGroupManager(GroupDAO groupDAO)
   {
     this.groupDAO = groupDAO;
+    this.managerDaoAdapter = new ManagerDaoAdapter<>(
+      groupDAO,
+      GroupNotFoundException::new,
+      GroupAlreadyExistsException::new);
   }
 
   //~--- methods --------------------------------------------------------------
@@ -101,79 +106,34 @@ public class DefaultGroupManager extends AbstractGroupManager
     // do nothing
   }
 
-  /**
-   * Method description
-   *
-   *
-   * @param group
-   *
-   * @throws GroupException
-   * @throws IOException
-   */
   @Override
-  public Group create(Group group) throws GroupException
-  {
+  public Group create(Group group) throws GroupException {
     String type = group.getType();
-
-    if (Util.isEmpty(type))
-    {
+    if (Util.isEmpty(type)) {
       group.setType(groupDAO.getType());
     }
 
-    String name = group.getName();
-    
-    if (logger.isInfoEnabled())
-    {
-      logger.info("create group {} of type {}", name,
-        group.getType());
-    }
-
-    GroupPermissions.create().check();
-    
-    if (groupDAO.contains(name))
-    {
-      throw new GroupAlreadyExistsException(name);
-    }
+    logger.info("create group {} of type {}", group.getName(), group.getType());
 
     removeDuplicateMembers(group);
-    group.setCreationDate(System.currentTimeMillis());
-    fireEvent(HandlerEventType.BEFORE_CREATE, group);
-    groupDAO.add(group);
-    fireEvent(HandlerEventType.CREATE, group);
-    return group;
+
+    return managerDaoAdapter.create(
+      group,
+      GroupPermissions::create,
+      newGroup -> fireEvent(HandlerEventType.BEFORE_CREATE, newGroup),
+      newGroup -> fireEvent(HandlerEventType.CREATE, newGroup)
+    );
   }
 
-  /**
-   * Method description
-   *
-   *
-   * @param group
-   *
-   * @throws GroupException
-   * @throws IOException
-   */
   @Override
-  public void delete(Group group) throws GroupException
-  {
-    if (logger.isInfoEnabled())
-    {
-      logger.info("delete group {} of type {}", group.getName(),
-        group.getType());
-    }
-
-    String name = group.getName();
-    GroupPermissions.delete().check(name);
-
-    if (groupDAO.contains(name))
-    {
-      fireEvent(HandlerEventType.BEFORE_DELETE, group);
-      groupDAO.delete(group);
-      fireEvent(HandlerEventType.DELETE, group);
-    }
-    else
-    {
-      throw new GroupNotFoundException();
-    }
+  public void delete(Group group) throws GroupException {
+    logger.info("delete group {} of type {}", group.getName(), group.getType());
+    managerDaoAdapter.delete(
+      group,
+      () -> GroupPermissions.delete(group.getName()),
+      toDelete -> fireEvent(HandlerEventType.BEFORE_DELETE, toDelete),
+      toDelete -> fireEvent(HandlerEventType.DELETE, toDelete)
+    );
   }
 
   /**
@@ -195,31 +155,18 @@ public class DefaultGroupManager extends AbstractGroupManager
    * @throws IOException
    */
   @Override
-  public void modify(Group group) throws GroupException
-  {
-    if (logger.isInfoEnabled())
-    {
-      logger.info("modify group {} of type {}", group.getName(),
-        group.getType());
-    }
+  public void modify(Group group) throws GroupException {
+    logger.info("modify group {} of type {}", group.getName(), group.getType());
 
-    String name = group.getName();
-    GroupPermissions.modify().check(name);
-
-    Group notModified = groupDAO.get(name);
-    if (notModified != null)
-    {
-      removeDuplicateMembers(group);
-      fireEvent(HandlerEventType.BEFORE_MODIFY, group, notModified);
-      group.setLastModified(System.currentTimeMillis());
-      group.setCreationDate(notModified.getCreationDate());
-      groupDAO.modify(group);
-      fireEvent(HandlerEventType.MODIFY, group, notModified);
-    }
-    else
-    {
-      throw new GroupNotFoundException();
-    }
+    managerDaoAdapter.modify(
+      group,
+      GroupPermissions::modify,
+      notModified -> {
+        removeDuplicateMembers(group);
+        fireEvent(HandlerEventType.BEFORE_MODIFY, group, notModified);
+      },
+      notModified -> fireEvent(HandlerEventType.MODIFY, group, notModified)
+    );
   }
 
   /**
@@ -245,7 +192,7 @@ public class DefaultGroupManager extends AbstractGroupManager
 
     if (fresh == null)
     {
-      throw new GroupNotFoundException();
+      throw new GroupNotFoundException(group);
     }
 
     fresh.copyProperties(group);
@@ -458,4 +405,5 @@ public class DefaultGroupManager extends AbstractGroupManager
 
   /** Field description */
   private GroupDAO groupDAO;
+  private final ManagerDaoAdapter<Group, GroupException> managerDaoAdapter;
 }

scm-webapp/src/main/java/sonia/scm/repository/DefaultRepositoryManager.java

@@ -45,6 +45,7 @@ import org.slf4j.LoggerFactory;
 import sonia.scm.ArgumentIsInvalidException;
 import sonia.scm.ConfigurationException;
 import sonia.scm.HandlerEventType;
+import sonia.scm.ManagerDaoAdapter;
 import sonia.scm.SCMContextProvider;
 import sonia.scm.Type;
 import sonia.scm.config.ScmConfiguration;
@@ -90,6 +91,7 @@ public class DefaultRepositoryManager extends AbstractRepositoryManager {
   private final Set<Type> types;
   private RepositoryMatcher repositoryMatcher;
   private NamespaceStrategy namespaceStrategy;
+  private final ManagerDaoAdapter<Repository, RepositoryException> managerDaoAdapter;
 
 
   @Inject
@@ -116,6 +118,10 @@ public class DefaultRepositoryManager extends AbstractRepositoryManager {
     for (RepositoryHandler handler : handlerSet) {
       addHandler(contextProvider, handler);
     }
+    managerDaoAdapter = new ManagerDaoAdapter<>(
+      repositoryDAO,
+      RepositoryNotFoundException::new,
+      RepositoryAlreadyExistsException::create);
   }
 
 
@@ -128,64 +134,47 @@ public class DefaultRepositoryManager extends AbstractRepositoryManager {
     }
   }
 
-  public Repository create(Repository repository, boolean initRepository)
-    throws RepositoryException {
-    logger.info("create repository {} of type {}", repository.getName(), repository.getType());
-
-    RepositoryPermissions.create().check();
-
-    repository.setNamespace(namespaceStrategy.getNamespace());
-    logger.info("setting namespace of new repository {} to {}", repository.getName(), repository.getNamespace());
-
-    AssertUtil.assertIsValid(repository);
-
-    if (repositoryDAO.contains(repository.getNamespaceAndName())) {
-      throw RepositoryAlreadyExistsException.create(repository);
-    }
-
-    repository.setId(keyGenerator.createKey());
-    repository.setCreationDate(System.currentTimeMillis());
-
-    if (initRepository) {
-      getHandler(repository).create(repository);
-    }
-
-    fireEvent(HandlerEventType.BEFORE_CREATE, repository);
-    repositoryDAO.add(repository);
-    fireEvent(HandlerEventType.CREATE, repository);
-    return repository;
-  }
-
   @Override
-  public Repository create(Repository repository)
-    throws RepositoryException {
+  public Repository create(Repository repository) throws RepositoryException {
     return create(repository, true);
   }
 
+  public Repository create(Repository repository, boolean initRepository) throws RepositoryException {
+    repository.setId(keyGenerator.createKey());
+    repository.setNamespace(namespaceStrategy.getNamespace());
+
+    logger.info("create repository {} of type {} in namespace {}", repository.getName(), repository.getType(), repository.getNamespace());
+
+    return managerDaoAdapter.create(
+      repository,
+      RepositoryPermissions::create,
+      newRepository -> {
+        if (initRepository) {
+          getHandler(newRepository).create(newRepository);
+        }
+        fireEvent(HandlerEventType.BEFORE_CREATE, newRepository);
+      },
+      newRepository -> fireEvent(HandlerEventType.CREATE, newRepository)
+    );
+  }
+
   @Override
-  public void delete(Repository repository)
-    throws RepositoryException {
-    if (logger.isInfoEnabled()) {
-      logger.info("delete repository {} of type {}", repository.getName(),
-        repository.getType());
-    }
+  public void delete(Repository repository) throws RepositoryException {
+    logger.info("delete repository {} of type {}", repository.getName(), repository.getType());
+    managerDaoAdapter.delete(
+      repository,
+      () -> RepositoryPermissions.delete(repository),
+      this::preDelete,
+      toDelete -> fireEvent(HandlerEventType.DELETE, toDelete)
+    );
+  }
 
-    RepositoryPermissions.delete(repository).check();
-
-    if (configuration.isEnableRepositoryArchive() && !repository.isArchived()) {
-      throw new RepositoryIsNotArchivedException(
-        "Repository could not deleted, because it is not archived.");
-    }
-
-    if (repositoryDAO.contains(repository)) {
-      fireEvent(HandlerEventType.BEFORE_DELETE, repository);
-      getHandler(repository).delete(repository);
-      repositoryDAO.delete(repository);
-      fireEvent(HandlerEventType.DELETE, repository);
-    } else {
-      throw new RepositoryNotFoundException(
-        "repository ".concat(repository.getName()).concat(" not found"));
+  private void preDelete(Repository toDelete) throws RepositoryException {
+    if (configuration.isEnableRepositoryArchive() && !toDelete.isArchived()) {
+      throw new RepositoryIsNotArchivedException("Repository could not deleted, because it is not archived.");
     }
+    fireEvent(HandlerEventType.BEFORE_DELETE, toDelete);
+    getHandler(toDelete).delete(toDelete);
   }
 
   @Override
@@ -199,29 +188,18 @@ public class DefaultRepositoryManager extends AbstractRepositoryManager {
   }
 
   @Override
-  public void modify(Repository repository)
-    throws RepositoryException {
-    if (logger.isInfoEnabled()) {
-      logger.info("modify repository {} of type {}", repository.getName(),
-        repository.getType());
-    }
+  public void modify(Repository repository) throws RepositoryException {
+    logger.info("modify repository {} of type {}", repository.getName(), repository.getType());
 
-    AssertUtil.assertIsValid(repository);
-
-    Repository oldRepository = repositoryDAO.get(repository.getNamespaceAndName());
-
-    if (oldRepository != null) {
-      RepositoryPermissions.modify(oldRepository).check();
-      fireEvent(HandlerEventType.BEFORE_MODIFY, repository, oldRepository);
-      repository.setLastModified(System.currentTimeMillis());
-      repository.setCreationDate(oldRepository.getCreationDate());
-      getHandler(repository).modify(repository);
-      repositoryDAO.modify(repository);
-      fireEvent(HandlerEventType.MODIFY, repository, oldRepository);
-    } else {
-      throw new RepositoryNotFoundException(
-        "repository ".concat(repository.getName()).concat(" not found"));
-    }
+    managerDaoAdapter.modify(
+      repository,
+      RepositoryPermissions::modify,
+      notModified -> {
+        fireEvent(HandlerEventType.BEFORE_MODIFY, repository, notModified);
+        getHandler(repository).modify(repository);
+      },
+      notModified -> fireEvent(HandlerEventType.MODIFY, repository, notModified)
+    );
   }
 
   @Override
@@ -235,8 +213,7 @@ public class DefaultRepositoryManager extends AbstractRepositoryManager {
     if (fresh != null) {
       fresh.copyProperties(repository);
     } else {
-      throw new RepositoryNotFoundException(
-        "repository ".concat(repository.getName()).concat(" not found"));
+      throw new RepositoryNotFoundException(repository);
     }
   }
 
@@ -452,5 +429,4 @@ public class DefaultRepositoryManager extends AbstractRepositoryManager {
 
     return handler;
   }
-
 }

scm-webapp/src/main/java/sonia/scm/user/DefaultUserManager.java

@@ -41,11 +41,11 @@ import com.google.inject.Singleton;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import sonia.scm.HandlerEventType;
+import sonia.scm.ManagerDaoAdapter;
 import sonia.scm.SCMContextProvider;
 import sonia.scm.TransformFilter;
 import sonia.scm.search.SearchRequest;
 import sonia.scm.search.SearchUtil;
-import sonia.scm.util.AssertUtil;
 import sonia.scm.util.CollectionAppender;
 import sonia.scm.util.IOUtil;
 import sonia.scm.util.Util;
@@ -96,6 +96,10 @@ public class DefaultUserManager extends AbstractUserManager
   public DefaultUserManager(UserDAO userDAO)
   {
     this.userDAO = userDAO;
+    this.managerDaoAdapter = new ManagerDaoAdapter<>(
+      userDAO,
+      UserNotFoundException::new,
+      UserAlreadyExistsException::new);
   }
 
   //~--- methods --------------------------------------------------------------
@@ -137,65 +141,31 @@ public class DefaultUserManager extends AbstractUserManager
    * @throws UserException
    */
   @Override
-  public User create(User user) throws UserException
-  {
+  public User create(User user) throws UserException {
     String type = user.getType();
-
-    if (Util.isEmpty(type))
-    {
+    if (Util.isEmpty(type)) {
       user.setType(userDAO.getType());
     }
 
-    if (logger.isInfoEnabled())
-    {
-      logger.info("create user {} of type {}", user.getName(), user.getType());
-    }
+    logger.info("create user {} of type {}", user.getName(), user.getType());
 
-    UserPermissions.create().check();
-
-    if (userDAO.contains(user.getName()))
-    {
-      throw new UserAlreadyExistsException(user.getName());
-    }
-
-    AssertUtil.assertIsValid(user);
-    user.setCreationDate(System.currentTimeMillis());
-    fireEvent(HandlerEventType.BEFORE_CREATE, user);
-    userDAO.add(user);
-    fireEvent(HandlerEventType.CREATE, user);
-    return user;
+    return managerDaoAdapter.create(
+      user,
+      UserPermissions::create,
+      newUser -> fireEvent(HandlerEventType.BEFORE_CREATE, newUser),
+      newUser -> fireEvent(HandlerEventType.CREATE, newUser)
+    );
   }
 
-  /**
-   * Method description
-   *
-   *
-   * @param user
-   *
-   * @throws IOException
-   * @throws UserException
-   */
   @Override
-  public void delete(User user) throws UserException
-  {
-    if (logger.isInfoEnabled())
-    {
-      logger.info("delete user {} of type {}", user.getName(), user.getType());
-    }
-
-    String name = user.getName();
-    UserPermissions.delete(name).check();
-
-    if (userDAO.contains(name))
-    {
-      fireEvent(HandlerEventType.BEFORE_DELETE, user);
-      userDAO.delete(user);
-      fireEvent(HandlerEventType.DELETE, user);
-    }
-    else
-    {
-      throw new UserNotFoundException();
-    }
+  public void delete(User user) throws UserException {
+    logger.info("delete user {} of type {}", user.getName(), user.getType());
+    managerDaoAdapter.delete(
+      user,
+      () -> UserPermissions.delete(user.getName()),
+      toDelete -> fireEvent(HandlerEventType.BEFORE_DELETE, toDelete),
+      toDelete -> fireEvent(HandlerEventType.DELETE, toDelete)
+    );
   }
 
   /**
@@ -227,27 +197,13 @@ public class DefaultUserManager extends AbstractUserManager
   @Override
   public void modify(User user) throws UserException
   {
-    String name = user.getName();
-    if (logger.isInfoEnabled())
-    {
-      logger.info("modify user {} of type {}", user.getName(), user.getType());
-    }
-    
-    UserPermissions.modify(user).check();
-    User notModified = userDAO.get(name);
-    if (notModified != null)
-    {
-      AssertUtil.assertIsValid(user);
-      fireEvent(HandlerEventType.BEFORE_MODIFY, user, notModified);
-      user.setLastModified(System.currentTimeMillis());
-      user.setCreationDate(notModified.getCreationDate());
-      userDAO.modify(user);
-      fireEvent(HandlerEventType.MODIFY, user, notModified);
-    }
-    else
-    {
-      throw new UserNotFoundException();
-    }
+    logger.info("modify user {} of type {}", user.getName(), user.getType());
+
+    managerDaoAdapter.modify(
+      user,
+      UserPermissions::modify,
+      notModified -> fireEvent(HandlerEventType.BEFORE_MODIFY, user, notModified),
+      notModified -> fireEvent(HandlerEventType.MODIFY, user, notModified));
   }
 
   /**
@@ -272,7 +228,7 @@ public class DefaultUserManager extends AbstractUserManager
 
     if (fresh == null)
     {
-      throw new UserNotFoundException();
+      throw new UserNotFoundException(user);
     }
 
     fresh.copyProperties(user);
@@ -497,6 +453,6 @@ public class DefaultUserManager extends AbstractUserManager
 
   //~--- fields ---------------------------------------------------------------
 
-  /** Field description */
   private final UserDAO userDAO;
+  private final ManagerDaoAdapter<User, UserException> managerDaoAdapter;
 }