Add endpoint for repository roles (tests pending)

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

@@ -67,6 +67,7 @@ import sonia.scm.plugin.PluginLoader;
 import sonia.scm.plugin.PluginManager;
 import sonia.scm.repository.DefaultRepositoryManager;
 import sonia.scm.repository.DefaultRepositoryProvider;
+import sonia.scm.repository.DefaultRepositoryRoleManager;
 import sonia.scm.repository.HealthCheckContextListener;
 import sonia.scm.repository.NamespaceStrategy;
 import sonia.scm.repository.NamespaceStrategyProvider;
@@ -76,6 +77,7 @@ import sonia.scm.repository.RepositoryManager;
 import sonia.scm.repository.RepositoryManagerProvider;
 import sonia.scm.repository.RepositoryProvider;
 import sonia.scm.repository.RepositoryRoleDAO;
+import sonia.scm.repository.RepositoryRoleManager;
 import sonia.scm.repository.api.HookContextFactory;
 import sonia.scm.repository.api.RepositoryServiceFactory;
 import sonia.scm.repository.spi.HookEventFacade;
@@ -270,6 +272,7 @@ public class ScmServletModule extends ServletModule
     bind(UserDAO.class, XmlUserDAO.class);
     bind(RepositoryDAO.class, XmlRepositoryDAO.class);
     bind(RepositoryRoleDAO.class, XmlRepositoryRoleDAO.class);
+    bind(RepositoryRoleManager.class).to(DefaultRepositoryRoleManager.class);
 
     bindDecorated(RepositoryManager.class, DefaultRepositoryManager.class,
       RepositoryManagerProvider.class);

scm-webapp/src/main/java/sonia/scm/api/v2/resources/MapperModule.java

@@ -28,6 +28,10 @@ public class MapperModule extends AbstractModule {
     bind(RepositoryPermissionDtoToRepositoryPermissionMapper.class).to(Mappers.getMapper(RepositoryPermissionDtoToRepositoryPermissionMapper.class).getClass());
     bind(RepositoryPermissionToRepositoryPermissionDtoMapper.class).to(Mappers.getMapper(RepositoryPermissionToRepositoryPermissionDtoMapper.class).getClass());
 
+    bind(RepositoryRoleToRepositoryRoleDtoMapper.class).to(Mappers.getMapper(RepositoryRoleToRepositoryRoleDtoMapper.class).getClass());
+    bind(RepositoryRoleDtoToRepositoryRoleMapper.class).to(Mappers.getMapper(RepositoryRoleDtoToRepositoryRoleMapper.class).getClass());
+    bind(RepositoryRoleCollectionToDtoMapper.class);
+
     bind(ChangesetToChangesetDtoMapper.class).to(Mappers.getMapper(DefaultChangesetToChangesetDtoMapper.class).getClass());
     bind(ChangesetToParentDtoMapper.class).to(Mappers.getMapper(ChangesetToParentDtoMapper.class).getClass());
 

scm-webapp/src/main/java/sonia/scm/api/v2/resources/RepositoryRoleCollectionResource.java

@@ -0,0 +1,95 @@
+package sonia.scm.api.v2.resources;
+
+import com.webcohesion.enunciate.metadata.rs.ResponseCode;
+import com.webcohesion.enunciate.metadata.rs.ResponseHeader;
+import com.webcohesion.enunciate.metadata.rs.ResponseHeaders;
+import com.webcohesion.enunciate.metadata.rs.StatusCodes;
+import com.webcohesion.enunciate.metadata.rs.TypeHint;
+import org.apache.shiro.authc.credential.PasswordService;
+import sonia.scm.repository.RepositoryRole;
+import sonia.scm.repository.RepositoryRoleManager;
+import sonia.scm.web.VndMediaType;
+
+import javax.inject.Inject;
+import javax.validation.Valid;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DefaultValue;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.core.Response;
+
+public class RepositoryRoleCollectionResource {
+
+  private static final int DEFAULT_PAGE_SIZE = 10;
+  private final RepositoryRoleDtoToRepositoryRoleMapper dtoToRepositoryRoleMapper;
+  private final RepositoryRoleCollectionToDtoMapper repositoryRoleCollectionToDtoMapper;
+  private final ResourceLinks resourceLinks;
+
+  private final IdResourceManagerAdapter<RepositoryRole, RepositoryRoleDto> adapter;
+
+  @Inject
+  public RepositoryRoleCollectionResource(RepositoryRoleManager manager, RepositoryRoleDtoToRepositoryRoleMapper dtoToRepositoryRoleMapper,
+                                          RepositoryRoleCollectionToDtoMapper repositoryRoleCollectionToDtoMapper, ResourceLinks resourceLinks) {
+    this.dtoToRepositoryRoleMapper = dtoToRepositoryRoleMapper;
+    this.repositoryRoleCollectionToDtoMapper = repositoryRoleCollectionToDtoMapper;
+    this.adapter = new IdResourceManagerAdapter<>(manager, RepositoryRole.class);
+    this.resourceLinks = resourceLinks;
+  }
+
+  /**
+   * Returns all repository roles for a given page number with a given page size (default page size is {@value DEFAULT_PAGE_SIZE}).
+   *
+   * <strong>Note:</strong> This method requires "repositoryRole" privilege.
+   *
+   * @param page     the number of the requested page
+   * @param pageSize the page size (default page size is {@value DEFAULT_PAGE_SIZE})
+   * @param sortBy   sort parameter (if empty - undefined sorting)
+   * @param desc     sort direction desc or asc
+   */
+  @GET
+  @Path("")
+  @Produces(VndMediaType.REPOSITORY_ROLE_COLLECTION)
+  @TypeHint(CollectionDto.class)
+  @StatusCodes({
+    @ResponseCode(code = 200, condition = "success"),
+    @ResponseCode(code = 400, condition = "\"sortBy\" field unknown"),
+    @ResponseCode(code = 401, condition = "not authenticated / invalid credentials"),
+    @ResponseCode(code = 403, condition = "not authorized, the current repositoryRole does not have the \"repositoryRole\" privilege"),
+    @ResponseCode(code = 500, condition = "internal server error")
+  })
+  public Response getAll(@DefaultValue("0") @QueryParam("page") int page,
+    @DefaultValue("" + DEFAULT_PAGE_SIZE) @QueryParam("pageSize") int pageSize,
+    @QueryParam("sortBy") String sortBy,
+    @DefaultValue("false") @QueryParam("desc") boolean desc
+  ) {
+    return adapter.getAll(page, pageSize, x -> true, sortBy, desc,
+                          pageResult -> repositoryRoleCollectionToDtoMapper.map(page, pageSize, pageResult));
+  }
+
+  /**
+   * Creates a new repository role.
+   *
+   * <strong>Note:</strong> This method requires "repositoryRole" privilege.
+   *
+   * @param repositoryRole The repositoryRole to be created.
+   * @return A response with the link to the new repository role (if created successfully).
+   */
+  @POST
+  @Path("")
+  @Consumes(VndMediaType.REPOSITORY_ROLE)
+  @StatusCodes({
+    @ResponseCode(code = 201, condition = "create success"),
+    @ResponseCode(code = 401, condition = "not authenticated / invalid credentials"),
+    @ResponseCode(code = 403, condition = "not authorized, the current user does not have the \"repositoryRole\" privilege"),
+    @ResponseCode(code = 409, condition = "conflict, a repository role with this name already exists"),
+    @ResponseCode(code = 500, condition = "internal server error")
+  })
+  @TypeHint(TypeHint.NO_CONTENT.class)
+  @ResponseHeaders(@ResponseHeader(name = "Location", description = "uri to the created repositoryRole"))
+  public Response create(@Valid RepositoryRoleDto repositoryRole) {
+    return adapter.create(repositoryRole, () -> dtoToRepositoryRoleMapper.map(repositoryRole), u -> resourceLinks.repositoryRole().self(u.getName()));
+  }
+}

scm-webapp/src/main/java/sonia/scm/api/v2/resources/RepositoryRoleCollectionToDtoMapper.java

@@ -0,0 +1,34 @@
+package sonia.scm.api.v2.resources;
+
+import sonia.scm.PageResult;
+import sonia.scm.repository.RepositoryRole;
+import sonia.scm.repository.RepositoryRolePermissions;
+
+import javax.inject.Inject;
+import java.util.Optional;
+
+import static java.util.Optional.empty;
+import static java.util.Optional.of;
+
+public class RepositoryRoleCollectionToDtoMapper extends BasicCollectionToDtoMapper<RepositoryRole, RepositoryRoleDto, RepositoryRoleToRepositoryRoleDtoMapper> {
+
+  private final ResourceLinks resourceLinks;
+
+  @Inject
+  public RepositoryRoleCollectionToDtoMapper(RepositoryRoleToRepositoryRoleDtoMapper repositoryRoleToDtoMapper, ResourceLinks resourceLinks) {
+    super("repositoryRoles", repositoryRoleToDtoMapper);
+    this.resourceLinks = resourceLinks;
+  }
+
+  public CollectionDto map(int pageNumber, int pageSize, PageResult<RepositoryRole> pageResult) {
+    return map(pageNumber, pageSize, pageResult, this.createSelfLink(), this.createCreateLink());
+  }
+
+  Optional<String> createCreateLink() {
+    return RepositoryRolePermissions.modify().isPermitted() ? of(resourceLinks.repositoryRoleCollection().create()): empty();
+  }
+
+  String createSelfLink() {
+    return resourceLinks.repositoryRoleCollection().self();
+  }
+}

scm-webapp/src/main/java/sonia/scm/api/v2/resources/RepositoryRoleDto.java

@@ -0,0 +1,22 @@
+package sonia.scm.api.v2.resources;
+
+import de.otto.edison.hal.Embedded;
+import de.otto.edison.hal.HalRepresentation;
+import de.otto.edison.hal.Links;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.Collection;
+
+@Getter
+@Setter
+@NoArgsConstructor
+public class RepositoryRoleDto extends HalRepresentation {
+  private String name;
+  private Collection<String> verbs;
+
+  RepositoryRoleDto(Links links, Embedded embedded) {
+    super(links, embedded);
+  }
+}

scm-webapp/src/main/java/sonia/scm/api/v2/resources/RepositoryRoleDtoToRepositoryRoleMapper.java

@@ -0,0 +1,14 @@
+package sonia.scm.api.v2.resources;
+
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import sonia.scm.repository.RepositoryRole;
+
+// Mapstruct does not support parameterized (i.e. non-default) constructors. Thus, we need to use field injection.
+@SuppressWarnings("squid:S3306")
+@Mapper
+public abstract class RepositoryRoleDtoToRepositoryRoleMapper extends BaseDtoMapper {
+
+  @Mapping(target = "creationDate", ignore = true)
+  public abstract RepositoryRole map(RepositoryRoleDto repositoryRoleDto);
+}

scm-webapp/src/main/java/sonia/scm/api/v2/resources/RepositoryRoleResource.java

@@ -0,0 +1,103 @@
+package sonia.scm.api.v2.resources;
+
+import com.webcohesion.enunciate.metadata.rs.ResponseCode;
+import com.webcohesion.enunciate.metadata.rs.StatusCodes;
+import com.webcohesion.enunciate.metadata.rs.TypeHint;
+import sonia.scm.repository.RepositoryRole;
+import sonia.scm.repository.RepositoryRoleManager;
+import sonia.scm.web.VndMediaType;
+
+import javax.inject.Inject;
+import javax.validation.Valid;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.Response;
+
+public class RepositoryRoleResource {
+
+  private final RepositoryRoleDtoToRepositoryRoleMapper dtoToRepositoryRoleMapper;
+  private final RepositoryRoleToRepositoryRoleDtoMapper repositoryRoleToDtoMapper;
+
+  private final IdResourceManagerAdapter<RepositoryRole, RepositoryRoleDto> adapter;
+
+  @Inject
+  public RepositoryRoleResource(
+    RepositoryRoleDtoToRepositoryRoleMapper dtoToRepositoryRoleMapper,
+    RepositoryRoleToRepositoryRoleDtoMapper repositoryRoleToDtoMapper,
+    RepositoryRoleManager manager) {
+    this.dtoToRepositoryRoleMapper = dtoToRepositoryRoleMapper;
+    this.repositoryRoleToDtoMapper = repositoryRoleToDtoMapper;
+    this.adapter = new IdResourceManagerAdapter<>(manager, RepositoryRole.class);
+  }
+
+  /**
+   * Returns a repository role.
+   *
+   * <strong>Note:</strong> This method requires "repositoryRole" privilege.
+   *
+   * @param name the id/name of the repository role
+   */
+  @GET
+  @Path("")
+  @Produces(VndMediaType.REPOSITORY_ROLE)
+  @TypeHint(RepositoryRoleDto.class)
+  @StatusCodes({
+    @ResponseCode(code = 200, condition = "success"),
+    @ResponseCode(code = 401, condition = "not authenticated / invalid credentials"),
+    @ResponseCode(code = 403, condition = "not authorized, the current user has no privileges to read the repository role"),
+    @ResponseCode(code = 404, condition = "not found, no repository role with the specified name available"),
+    @ResponseCode(code = 500, condition = "internal server error")
+  })
+  public Response get(@PathParam("name") String name) {
+    return adapter.get(name, repositoryRoleToDtoMapper::map);
+  }
+
+  /**
+   * Deletes a repository role.
+   *
+   * <strong>Note:</strong> This method requires "repositoryRole" privilege.
+   *
+   * @param name the name of the repository role to delete.
+   */
+  @DELETE
+  @Path("")
+  @StatusCodes({
+    @ResponseCode(code = 204, condition = "delete success or nothing to delete"),
+    @ResponseCode(code = 401, condition = "not authenticated / invalid credentials"),
+    @ResponseCode(code = 403, condition = "not authorized, the current user does not have the \"repositoryRole\" privilege"),
+    @ResponseCode(code = 500, condition = "internal server error")
+  })
+  @TypeHint(TypeHint.NO_CONTENT.class)
+  public Response delete(@PathParam("name") String name) {
+    return adapter.delete(name);
+  }
+
+  /**
+   * Modifies the given repository role.
+   *
+   * <strong>Note:</strong> This method requires "repositoryRole" privilege.
+   *
+   * @param name    name of the repository role to be modified
+   * @param repositoryRole repository role object to modify
+   */
+  @PUT
+  @Path("")
+  @Consumes(VndMediaType.REPOSITORY_ROLE)
+  @StatusCodes({
+    @ResponseCode(code = 204, condition = "update success"),
+    @ResponseCode(code = 400, condition = "Invalid body, e.g. illegal change of repository role name"),
+    @ResponseCode(code = 401, condition = "not authenticated / invalid credentials"),
+    @ResponseCode(code = 403, condition = "not authorized, the current user does not have the \"repositoryRole\" privilege"),
+    @ResponseCode(code = 404, condition = "not found, no repository role with the specified name available"),
+    @ResponseCode(code = 500, condition = "internal server error")
+  })
+  @TypeHint(TypeHint.NO_CONTENT.class)
+  public Response update(@PathParam("name") String name, @Valid RepositoryRoleDto repositoryRole) {
+    return adapter.update(name, existing -> dtoToRepositoryRoleMapper.map(repositoryRole));
+  }
+}

scm-webapp/src/main/java/sonia/scm/api/v2/resources/RepositoryRoleRootResource.java

@@ -0,0 +1,34 @@
+package sonia.scm.api.v2.resources;
+
+import javax.inject.Inject;
+import javax.inject.Provider;
+import javax.ws.rs.Path;
+
+/**
+ *  RESTful web service resource to manage repository roles.
+ */
+@Path(RepositoryRoleRootResource.REPOSITORY_ROLES_PATH_V2)
+public class RepositoryRoleRootResource {
+
+  static final String REPOSITORY_ROLES_PATH_V2 = "v2/repository-roles/";
+
+  private final Provider<RepositoryRoleCollectionResource> repositoryRoleCollectionResource;
+  private final Provider<RepositoryRoleResource> repositoryRoleResource;
+
+  @Inject
+  public RepositoryRoleRootResource(Provider<RepositoryRoleCollectionResource> repositoryRoleCollectionResource,
+                                    Provider<RepositoryRoleResource> repositoryRoleResource) {
+    this.repositoryRoleCollectionResource = repositoryRoleCollectionResource;
+    this.repositoryRoleResource = repositoryRoleResource;
+  }
+
+  @Path("")
+  public RepositoryRoleCollectionResource getRepositoryRoleCollectionResource() {
+    return repositoryRoleCollectionResource.get();
+  }
+
+  @Path("{name}")
+  public RepositoryRoleResource getRepositoryRoleResource() {
+    return repositoryRoleResource.get();
+  }
+}

scm-webapp/src/main/java/sonia/scm/api/v2/resources/RepositoryRoleToRepositoryRoleDtoMapper.java

@@ -0,0 +1,42 @@
+package sonia.scm.api.v2.resources;
+
+import de.otto.edison.hal.Embedded;
+import de.otto.edison.hal.Links;
+import org.mapstruct.Mapper;
+import org.mapstruct.ObjectFactory;
+import sonia.scm.repository.RepositoryRole;
+import sonia.scm.repository.RepositoryRoleManager;
+import sonia.scm.repository.RepositoryRolePermissions;
+
+import javax.inject.Inject;
+
+import static de.otto.edison.hal.Embedded.embeddedBuilder;
+import static de.otto.edison.hal.Link.link;
+import static de.otto.edison.hal.Links.linkingTo;
+
+// Mapstruct does not support parameterized (i.e. non-default) constructors. Thus, we need to use field injection.
+@SuppressWarnings("squid:S3306")
+@Mapper
+public abstract class RepositoryRoleToRepositoryRoleDtoMapper extends BaseMapper<RepositoryRole, RepositoryRoleDto> {
+
+  @Inject
+  private RepositoryRoleManager repositoryRoleManager;
+
+  @Inject
+  private ResourceLinks resourceLinks;
+
+  @ObjectFactory
+  RepositoryRoleDto createDto(RepositoryRole repositoryRole) {
+    Links.Builder linksBuilder = linkingTo().self(resourceLinks.repositoryRole().self(repositoryRole.getName()));
+    if (RepositoryRolePermissions.modify().isPermitted()) {
+      linksBuilder.single(link("delete", resourceLinks.repositoryRole().delete(repositoryRole.getName())));
+      linksBuilder.single(link("update", resourceLinks.repositoryRole().update(repositoryRole.getName())));
+    }
+
+    Embedded.Builder embeddedBuilder = embeddedBuilder();
+    applyEnrichers(new EdisonHalAppender(linksBuilder, embeddedBuilder), repositoryRole);
+
+    return new RepositoryRoleDto(linksBuilder.build(), embeddedBuilder.build());
+  }
+
+}

scm-webapp/src/main/java/sonia/scm/api/v2/resources/ResourceLinks.java

@@ -172,7 +172,6 @@ class ResourceLinks {
     }
   }
 
-
   UserCollectionLinks userCollection() {
     return new UserCollectionLinks(scmPathInfoStore.get());
   }
@@ -522,8 +521,50 @@ class ResourceLinks {
     public String content(String namespace, String name, String revision, String path) {
       return addPath(sourceLinkBuilder.method("getRepositoryResource").parameters(namespace, name).method("content").parameters().method("get").parameters(revision, "").href(), path);
     }
+  }
 
+  RepositoryRoleLinks repositoryRole() {
+    return new RepositoryRoleLinks(scmPathInfoStore.get());
+  }
 
+  static class RepositoryRoleLinks {
+    private final LinkBuilder repositoryRoleLinkBuilder;
+
+    RepositoryRoleLinks(ScmPathInfo pathInfo) {
+      repositoryRoleLinkBuilder = new LinkBuilder(pathInfo, RepositoryRoleRootResource.class, RepositoryRoleResource.class);
+    }
+
+    String self(String name) {
+      return repositoryRoleLinkBuilder.method("getRepositoryRoleResource").parameters(name).method("get").parameters().href();
+    }
+
+    String delete(String name) {
+      return repositoryRoleLinkBuilder.method("getRepositoryRoleResource").parameters(name).method("delete").parameters().href();
+    }
+
+    String update(String name) {
+      return repositoryRoleLinkBuilder.method("getRepositoryRoleResource").parameters(name).method("update").parameters().href();
+    }
+  }
+
+  RepositoryRoleCollectionLinks repositoryRoleCollection() {
+    return new RepositoryRoleCollectionLinks(scmPathInfoStore.get());
+  }
+
+  static class RepositoryRoleCollectionLinks {
+    private final LinkBuilder collectionLinkBuilder;
+
+    RepositoryRoleCollectionLinks(ScmPathInfo pathInfo) {
+      collectionLinkBuilder = new LinkBuilder(pathInfo, RepositoryRoleRootResource.class, RepositoryRoleCollectionResource.class);
+    }
+
+    String self() {
+      return collectionLinkBuilder.method("getRepositoryRoleCollectionResource").parameters().method("getAll").parameters().href();
+    }
+
+    String create() {
+      return collectionLinkBuilder.method("getRepositoryRoleCollectionResource").parameters().method("create").parameters().href();
+    }
   }
 
   public RepositoryPermissionLinks repositoryPermission() {

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

@@ -0,0 +1,191 @@
+/**
+ * Copyright (c) 2010, Sebastian Sdorra
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of SCM-Manager; nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * http://bitbucket.org/sdorra/scm-manager
+ *
+ */
+
+
+
+package sonia.scm.repository;
+
+import com.github.sdorra.ssp.PermissionActionCheck;
+import com.github.sdorra.ssp.PermissionCheck;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import sonia.scm.EagerSingleton;
+import sonia.scm.HandlerEventType;
+import sonia.scm.ManagerDaoAdapter;
+import sonia.scm.NotFoundException;
+import sonia.scm.SCMContextProvider;
+import sonia.scm.util.Util;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.Predicate;
+
+@Singleton @EagerSingleton
+public class DefaultRepositoryRoleManager extends AbstractRepositoryRoleManager
+{
+
+  /** the logger for XmlRepositoryRoleManager */
+  private static final Logger logger =
+    LoggerFactory.getLogger(DefaultRepositoryRoleManager.class);
+
+  @Inject
+  public DefaultRepositoryRoleManager(RepositoryRoleDAO repositoryRoleDAO)
+  {
+    this.repositoryRoleDAO = repositoryRoleDAO;
+    this.managerDaoAdapter = new ManagerDaoAdapter<>(repositoryRoleDAO);
+  }
+
+  @Override
+  public void close() {
+    // do nothing
+  }
+
+  @Override
+  public RepositoryRole create(RepositoryRole repositoryRole) {
+    String type = repositoryRole.getType();
+    if (Util.isEmpty(type)) {
+      repositoryRole.setType(repositoryRoleDAO.getType());
+    }
+
+    logger.info("create repositoryRole {} of type {}", repositoryRole.getName(), repositoryRole.getType());
+
+    return managerDaoAdapter.create(
+      repositoryRole,
+      RepositoryRolePermissions::modify,
+      newRepositoryRole -> fireEvent(HandlerEventType.BEFORE_CREATE, newRepositoryRole),
+      newRepositoryRole -> fireEvent(HandlerEventType.CREATE, newRepositoryRole)
+    );
+  }
+
+  @Override
+  public void delete(RepositoryRole repositoryRole) {
+    logger.info("delete repositoryRole {} of type {}", repositoryRole.getName(), repositoryRole.getType());
+    managerDaoAdapter.delete(
+      repositoryRole,
+      RepositoryRolePermissions::modify,
+      toDelete -> fireEvent(HandlerEventType.BEFORE_DELETE, toDelete),
+      toDelete -> fireEvent(HandlerEventType.DELETE, toDelete)
+    );
+  }
+
+  @Override
+  public void init(SCMContextProvider context) {
+  }
+
+  @Override
+  public void modify(RepositoryRole repositoryRole) {
+    logger.info("modify repositoryRole {} of type {}", repositoryRole.getName(), repositoryRole.getType());
+    managerDaoAdapter.modify(
+      repositoryRole,
+      x -> RepositoryRolePermissions.modify(),
+      notModified -> fireEvent(HandlerEventType.BEFORE_MODIFY, repositoryRole, notModified),
+      notModified -> fireEvent(HandlerEventType.MODIFY, repositoryRole, notModified));
+  }
+
+  @Override
+  public void refresh(RepositoryRole repositoryRole) {
+    logger.info("refresh repositoryRole {} of type {}", repositoryRole.getName(), repositoryRole.getType());
+
+    RepositoryRolePermissions.read().check();
+    RepositoryRole fresh = repositoryRoleDAO.get(repositoryRole.getName());
+
+    if (fresh == null) {
+      throw new NotFoundException(RepositoryRole.class, repositoryRole.getName());
+    }
+  }
+
+  @Override
+  public RepositoryRole get(String id) {
+    RepositoryRolePermissions.read();
+
+    RepositoryRole repositoryRole = repositoryRoleDAO.get(id);
+
+    if (repositoryRole != null) {
+      return repositoryRole.clone();
+    } else {
+      return null;
+    }
+  }
+
+  @Override
+  public Collection<RepositoryRole> getAll() {
+    return getAll(repositoryRole -> true, null);
+  }
+
+  @Override
+  public Collection<RepositoryRole> getAll(Predicate<RepositoryRole> filter, Comparator<RepositoryRole> comparator) {
+    List<RepositoryRole> repositoryRoles = new ArrayList<>();
+
+    if (!RepositoryRolePermissions.read().isPermitted()) {
+      return Collections.emptySet();
+    }
+    for (RepositoryRole repositoryRole : repositoryRoleDAO.getAll()) {
+      repositoryRoles.add(repositoryRole.clone());
+    }
+
+    if (comparator != null) {
+      Collections.sort(repositoryRoles, comparator);
+    }
+
+    return repositoryRoles;
+  }
+
+  @Override
+  public Collection<RepositoryRole> getAll(Comparator<RepositoryRole> comaparator, int start, int limit) {
+    if (!RepositoryRolePermissions.read().isPermitted()) {
+      return Collections.emptySet();
+    }
+    return Util.createSubCollection(repositoryRoleDAO.getAll(), comaparator,
+      (collection, item) -> {
+        collection.add(item.clone());
+      }, start, limit);
+  }
+
+  @Override
+  public Collection<RepositoryRole> getAll(int start, int limit)
+  {
+    return getAll(null, start, limit);
+  }
+
+  @Override
+  public Long getLastModified()
+  {
+    return repositoryRoleDAO.getLastModified();
+  }
+
+  private final RepositoryRoleDAO repositoryRoleDAO;
+  private final ManagerDaoAdapter<RepositoryRole> managerDaoAdapter;
+}