Merge branch 'master' into add-features-to-ldapauth

src/main/scala/app/AccountController.scala

@@ -1,17 +1,25 @@
 package app
 
 import service._
-import util.{FileUtil, OneselfAuthenticator}
+import util._
 import util.StringUtil._
 import util.Directory._
+import util.ControlUtil._
 import jp.sf.amateras.scalatra.forms._
 import org.apache.commons.io.FileUtils
+import org.scalatra.i18n.Messages
+import org.eclipse.jgit.api.Git
+import org.eclipse.jgit.lib.{FileMode, Constants}
+import org.eclipse.jgit.dircache.DirCache
+import model.GroupMember
 
 class AccountController extends AccountControllerBase
-  with AccountService with RepositoryService with ActivityService with OneselfAuthenticator
+  with AccountService with RepositoryService with ActivityService with WikiService with LabelsService
+  with OneselfAuthenticator with UsersAuthenticator with GroupManagerAuthenticator with ReadableUsersAuthenticator
 
 trait AccountControllerBase extends AccountManagementControllerBase {
-  self: AccountService with RepositoryService with ActivityService with OneselfAuthenticator =>
+  self: AccountService with RepositoryService with ActivityService with WikiService with LabelsService
+    with OneselfAuthenticator with UsersAuthenticator with GroupManagerAuthenticator with ReadableUsersAuthenticator =>
 
   case class AccountNewForm(userName: String, password: String, fullName: String, mailAddress: String,
                             url: Option[String], fileId: Option[String])
@@ -37,6 +45,40 @@ trait AccountControllerBase extends AccountManagementControllerBase {
     "clearImage"  -> trim(label("Clear image"  , boolean()))
   )(AccountEditForm.apply)
 
+  case class NewGroupForm(groupName: String, url: Option[String], fileId: Option[String], members: String)
+  case class EditGroupForm(groupName: String, url: Option[String], fileId: Option[String], members: String, clearImage: Boolean)
+
+  val newGroupForm = mapping(
+    "groupName" -> trim(label("Group name" ,text(required, maxlength(100), identifier, uniqueUserName))),
+    "url"       -> trim(label("URL"        ,optional(text(maxlength(200))))),
+    "fileId"    -> trim(label("File ID"    ,optional(text()))),
+    "members"   -> trim(label("Members"    ,text(required, members)))
+  )(NewGroupForm.apply)
+
+  val editGroupForm = mapping(
+    "groupName"  -> trim(label("Group name"  ,text(required, maxlength(100), identifier))),
+    "url"        -> trim(label("URL"         ,optional(text(maxlength(200))))),
+    "fileId"     -> trim(label("File ID"     ,optional(text()))),
+    "members"    -> trim(label("Members"     ,text(required, members))),
+    "clearImage" -> trim(label("Clear image" ,boolean()))
+  )(EditGroupForm.apply)
+
+  case class RepositoryCreationForm(owner: String, name: String, description: Option[String], isPrivate: Boolean, createReadme: Boolean)
+  case class ForkRepositoryForm(owner: String, name: String)
+
+  val newRepositoryForm = mapping(
+    "owner"        -> trim(label("Owner"          , text(required, maxlength(40), identifier, existsAccount))),
+    "name"         -> trim(label("Repository name", text(required, maxlength(40), identifier, uniqueRepository))),
+    "description"  -> trim(label("Description"    , optional(text()))),
+    "isPrivate"    -> trim(label("Repository Type", boolean())),
+    "createReadme" -> trim(label("Create README"  , boolean()))
+  )(RepositoryCreationForm.apply)
+
+  val forkRepositoryForm = mapping(
+    "owner" -> trim(label("Repository owner", text(required))),
+    "name"  -> trim(label("Repository name",  text(required)))
+  )(ForkRepositoryForm.apply)
+
   /**
    * Displays user information.
    */
@@ -51,14 +93,20 @@ trait AccountControllerBase extends AccountManagementControllerBase {
             getActivitiesByUser(userName, true))
 
         // Members
-        case "members" if(account.isGroupAccount) =>
-          _root_.account.html.members(account, getGroupMembers(account.userName))
+        case "members" if(account.isGroupAccount) => {
+          val members = getGroupMembers(account.userName)
+          _root_.account.html.members(account, members.map(_.userName),
+            context.loginAccount.exists(x => members.exists { member => member.userName == x.userName && member.isManager }))
+        }
 
         // Repositories
-        case _ =>
+        case _ => {
+          val members = getGroupMembers(account.userName)
           _root_.account.html.repositories(account,
             if(account.isGroupAccount) Nil else getGroupsByUserName(userName),
-            getVisibleRepositories(context.loginAccount, baseUrl, Some(userName)))
+            getVisibleRepositories(context.loginAccount, baseUrl, Some(userName)),
+            context.loginAccount.exists(x => members.exists { member => member.userName == x.userName && member.isManager }))
+        }
       }
     } getOrElse NotFound
   }
@@ -134,4 +182,228 @@ trait AccountControllerBase extends AccountManagementControllerBase {
     } else NotFound
   }
 
+  get("/groups/new")(usersOnly {
+    account.html.group(None, List(GroupMember("", context.loginAccount.get.userName, true)))
+  })
+
+  post("/groups/new", newGroupForm)(usersOnly { form =>
+    createGroup(form.groupName, form.url)
+    updateGroupMembers(form.groupName, form.members.split(",").map {
+      _.split(":") match {
+        case Array(userName, isManager) => (userName, isManager.toBoolean)
+      }
+    }.toList)
+    updateImage(form.groupName, form.fileId, false)
+    redirect(s"/${form.groupName}")
+  })
+
+  get("/:groupName/_editgroup")(managersOnly {
+    defining(params("groupName")){ groupName =>
+      account.html.group(getAccountByUserName(groupName, true), getGroupMembers(groupName))
+    }
+  })
+
+  get("/:groupName/_deletegroup")(managersOnly {
+    defining(params("groupName")){ groupName =>
+      // Remove from GROUP_MEMBER
+      updateGroupMembers(groupName, Nil)
+      // Remove repositories
+      getRepositoryNamesOfUser(groupName).foreach { repositoryName =>
+        deleteRepository(groupName, repositoryName)
+        FileUtils.deleteDirectory(getRepositoryDir(groupName, repositoryName))
+        FileUtils.deleteDirectory(getWikiRepositoryDir(groupName, repositoryName))
+        FileUtils.deleteDirectory(getTemporaryDir(groupName, repositoryName))
+      }
+    }
+    redirect("/")
+  })
+
+  post("/:groupName/_editgroup", editGroupForm)(managersOnly { form =>
+    defining(params("groupName"), form.members.split(",").map {
+      _.split(":") match {
+        case Array(userName, isManager) => (userName, isManager.toBoolean)
+      }
+    }.toList){ case (groupName, members) =>
+      getAccountByUserName(groupName, true).map { account =>
+        updateGroup(groupName, form.url, false)
+
+        // Update GROUP_MEMBER
+        updateGroupMembers(form.groupName, members)
+        // Update COLLABORATOR for group repositories
+        getRepositoryNamesOfUser(form.groupName).foreach { repositoryName =>
+          removeCollaborators(form.groupName, repositoryName)
+          members.foreach { case (userName, isManager) =>
+            addCollaborator(form.groupName, repositoryName, userName)
+          }
+        }
+
+        updateImage(form.groupName, form.fileId, form.clearImage)
+        redirect(s"/${form.groupName}")
+
+      } getOrElse NotFound
+    }
+  })
+
+  /**
+   * Show the new repository form.
+   */
+  get("/new")(usersOnly {
+    account.html.newrepo(getGroupsByUserName(context.loginAccount.get.userName))
+  })
+
+  /**
+   * Create new repository.
+   */
+  post("/new", newRepositoryForm)(usersOnly { form =>
+    LockUtil.lock(s"${form.owner}/${form.name}/create"){
+      if(getRepository(form.owner, form.name, baseUrl).isEmpty){
+        val ownerAccount  = getAccountByUserName(form.owner).get
+        val loginAccount  = context.loginAccount.get
+        val loginUserName = loginAccount.userName
+
+        // Insert to the database at first
+        createRepository(form.name, form.owner, form.description, form.isPrivate)
+
+        // Add collaborators for group repository
+        if(ownerAccount.isGroupAccount){
+          getGroupMembers(form.owner).foreach { member =>
+            addCollaborator(form.owner, form.name, member.userName)
+          }
+        }
+
+        // Insert default labels
+        insertDefaultLabels(form.owner, form.name)
+
+        // Create the actual repository
+        val gitdir = getRepositoryDir(form.owner, form.name)
+        JGitUtil.initRepository(gitdir)
+
+        if(form.createReadme){
+          using(Git.open(gitdir)){ git =>
+            val builder  = DirCache.newInCore.builder()
+            val inserter = git.getRepository.newObjectInserter()
+            val headId   = git.getRepository.resolve(Constants.HEAD + "^{commit}")
+            val content  = if(form.description.nonEmpty){
+              form.name + "\n" +
+              "===============\n" +
+              "\n" +
+              form.description.get
+            } else {
+              form.name + "\n" +
+              "===============\n"
+            }
+
+            builder.add(JGitUtil.createDirCacheEntry("README.md", FileMode.REGULAR_FILE,
+              inserter.insert(Constants.OBJ_BLOB, content.getBytes("UTF-8"))))
+            builder.finish()
+
+            JGitUtil.createNewCommit(git, inserter, headId, builder.getDirCache.writeTree(inserter),
+              loginAccount.fullName, loginAccount.mailAddress, "Initial commit")
+          }
+        }
+
+        // Create Wiki repository
+        createWikiRepository(loginAccount, form.owner, form.name)
+
+        // Record activity
+        recordCreateRepositoryActivity(form.owner, form.name, loginUserName)
+      }
+
+      // redirect to the repository
+      redirect(s"/${form.owner}/${form.name}")
+    }
+  })
+
+  get("/:owner/:repository/fork")(readableUsersOnly { repository =>
+    val loginAccount   = context.loginAccount.get
+    val loginUserName  = loginAccount.userName
+
+    LockUtil.lock(s"${loginUserName}/${repository.name}/create"){
+      if(repository.owner == loginUserName){
+        // redirect to the repository
+        redirect(s"/${repository.owner}/${repository.name}")
+      } else {
+        getForkedRepositories(repository.owner, repository.name).find(_._1 == loginUserName).map { case (owner, name) =>
+          // redirect to the repository
+          redirect(s"/${owner}/${name}")
+        } getOrElse {
+          // Insert to the database at first
+          val originUserName = repository.repository.originUserName.getOrElse(repository.owner)
+          val originRepositoryName = repository.repository.originRepositoryName.getOrElse(repository.name)
+
+          createRepository(
+            repositoryName       = repository.name,
+            userName             = loginUserName,
+            description          = repository.repository.description,
+            isPrivate            = repository.repository.isPrivate,
+            originRepositoryName = Some(originRepositoryName),
+            originUserName       = Some(originUserName),
+            parentRepositoryName = Some(repository.name),
+            parentUserName       = Some(repository.owner)
+          )
+
+          // Insert default labels
+          insertDefaultLabels(loginUserName, repository.name)
+
+          // clone repository actually
+          JGitUtil.cloneRepository(
+            getRepositoryDir(repository.owner, repository.name),
+            getRepositoryDir(loginUserName, repository.name))
+
+          // Create Wiki repository
+          JGitUtil.cloneRepository(
+            getWikiRepositoryDir(repository.owner, repository.name),
+            getWikiRepositoryDir(loginUserName, repository.name))
+
+          // insert commit id
+          using(Git.open(getRepositoryDir(loginUserName, repository.name))){ git =>
+            JGitUtil.getRepositoryInfo(loginUserName, repository.name, baseUrl).branchList.foreach { branch =>
+              JGitUtil.getCommitLog(git, branch) match {
+                case Right((commits, _)) => commits.foreach { commit =>
+                  if(!existsCommitId(loginUserName, repository.name, commit.id)){
+                    insertCommitId(loginUserName, repository.name, commit.id)
+                  }
+                }
+                case Left(_) => ???
+              }
+            }
+          }
+
+          // Record activity
+          recordForkActivity(repository.owner, repository.name, loginUserName)
+          // redirect to the repository
+          redirect(s"/${loginUserName}/${repository.name}")
+        }
+      }
+    }
+  })
+
+  private def insertDefaultLabels(userName: String, repositoryName: String): Unit = {
+    createLabel(userName, repositoryName, "bug", "fc2929")
+    createLabel(userName, repositoryName, "duplicate", "cccccc")
+    createLabel(userName, repositoryName, "enhancement", "84b6eb")
+    createLabel(userName, repositoryName, "invalid", "e6e6e6")
+    createLabel(userName, repositoryName, "question", "cc317c")
+    createLabel(userName, repositoryName, "wontfix", "ffffff")
+  }
+
+  private def existsAccount: Constraint = new Constraint(){
+    override def validate(name: String, value: String, messages: Messages): Option[String] =
+      if(getAccountByUserName(value).isEmpty) Some("User or group does not exist.") else None
+  }
+
+  private def uniqueRepository: Constraint = new Constraint(){
+    override def validate(name: String, value: String, params: Map[String, String], messages: Messages): Option[String] =
+      params.get("owner").flatMap { userName =>
+        getRepositoryNamesOfUser(userName).find(_ == value).map(_ => "Repository already exists.")
+      }
+  }
+
+  private def members: Constraint = new Constraint(){
+    override def validate(name: String, value: String, messages: Messages): Option[String] = {
+      if(value.split(",").exists {
+        _.split(":") match { case Array(userName, isManager) => isManager.toBoolean }
+      }) None else Some("Must select one manager at least.")
+    }
+  }
 }

src/main/scala/app/CreateRepositoryController.scala

@@ -1,199 +0,0 @@
-package app
-
-import util.Directory._
-import util.ControlUtil._
-import util._
-import service._
-import org.eclipse.jgit.api.Git
-import jp.sf.amateras.scalatra.forms._
-import org.eclipse.jgit.lib.{FileMode, Constants}
-import org.eclipse.jgit.dircache.DirCache
-import org.scalatra.i18n.Messages
-
-class CreateRepositoryController extends CreateRepositoryControllerBase
-  with RepositoryService with AccountService with WikiService with LabelsService with ActivityService
-  with UsersAuthenticator with ReadableUsersAuthenticator
-
-/**
- * Creates new repository.
- */
-trait CreateRepositoryControllerBase extends ControllerBase {
-  self: RepositoryService with AccountService with WikiService with LabelsService with ActivityService
-    with UsersAuthenticator with ReadableUsersAuthenticator =>
-
-  case class RepositoryCreationForm(owner: String, name: String, description: Option[String], isPrivate: Boolean, createReadme: Boolean)
-
-  case class ForkRepositoryForm(owner: String, name: String)
-
-  val newForm = mapping(
-    "owner"        -> trim(label("Owner"          , text(required, maxlength(40), identifier, existsAccount))),
-    "name"         -> trim(label("Repository name", text(required, maxlength(40), identifier, unique))),
-    "description"  -> trim(label("Description"    , optional(text()))),
-    "isPrivate"    -> trim(label("Repository Type", boolean())),
-    "createReadme" -> trim(label("Create README"  , boolean()))
-  )(RepositoryCreationForm.apply)
-
-  val forkForm = mapping(
-    "owner" -> trim(label("Repository owner", text(required))),
-    "name"  -> trim(label("Repository name",  text(required)))
-  )(ForkRepositoryForm.apply)
-
-  /**
-   * Show the new repository form.
-   */
-  get("/new")(usersOnly {
-    html.newrepo(getGroupsByUserName(context.loginAccount.get.userName))
-  })
-  
-  /**
-   * Create new repository.
-   */
-  post("/new", newForm)(usersOnly { form =>
-    LockUtil.lock(s"${form.owner}/${form.name}/create"){
-      if(getRepository(form.owner, form.name, baseUrl).isEmpty){
-        val ownerAccount  = getAccountByUserName(form.owner).get
-        val loginAccount  = context.loginAccount.get
-        val loginUserName = loginAccount.userName
-
-        // Insert to the database at first
-        createRepository(form.name, form.owner, form.description, form.isPrivate)
-
-        // Add collaborators for group repository
-        if(ownerAccount.isGroupAccount){
-          getGroupMembers(form.owner).foreach { userName =>
-            addCollaborator(form.owner, form.name, userName)
-          }
-        }
-
-        // Insert default labels
-        insertDefaultLabels(form.owner, form.name)
-
-        // Create the actual repository
-        val gitdir = getRepositoryDir(form.owner, form.name)
-        JGitUtil.initRepository(gitdir)
-
-        if(form.createReadme){
-          using(Git.open(gitdir)){ git =>
-            val builder  = DirCache.newInCore.builder()
-            val inserter = git.getRepository.newObjectInserter()
-            val headId   = git.getRepository.resolve(Constants.HEAD + "^{commit}")
-            val content  = if(form.description.nonEmpty){
-              form.name + "\n" +
-              "===============\n" +
-              "\n" +
-              form.description.get
-            } else {
-              form.name + "\n" +
-              "===============\n"
-            }
-
-            builder.add(JGitUtil.createDirCacheEntry("README.md", FileMode.REGULAR_FILE,
-              inserter.insert(Constants.OBJ_BLOB, content.getBytes("UTF-8"))))
-            builder.finish()
-
-            JGitUtil.createNewCommit(git, inserter, headId, builder.getDirCache.writeTree(inserter),
-              loginAccount.fullName, loginAccount.mailAddress, "Initial commit")
-          }
-        }
-
-        // Create Wiki repository
-        createWikiRepository(loginAccount, form.owner, form.name)
-
-        // Record activity
-        recordCreateRepositoryActivity(form.owner, form.name, loginUserName)
-      }
-
-      // redirect to the repository
-      redirect(s"/${form.owner}/${form.name}")
-    }
-  })
-
-  get("/:owner/:repository/fork")(readableUsersOnly { repository =>
-    val loginAccount   = context.loginAccount.get
-    val loginUserName  = loginAccount.userName
-
-    LockUtil.lock(s"${loginUserName}/${repository.name}/create"){
-      if(repository.owner == loginUserName){
-        // redirect to the repository
-        redirect(s"/${repository.owner}/${repository.name}")
-      } else {
-        getForkedRepositories(repository.owner, repository.name).find(_._1 == loginUserName).map { case (owner, name) =>
-          // redirect to the repository
-          redirect(s"/${owner}/${name}")
-        } getOrElse {
-          // Insert to the database at first
-          val originUserName = repository.repository.originUserName.getOrElse(repository.owner)
-          val originRepositoryName = repository.repository.originRepositoryName.getOrElse(repository.name)
-
-          createRepository(
-            repositoryName       = repository.name,
-            userName             = loginUserName,
-            description          = repository.repository.description,
-            isPrivate            = repository.repository.isPrivate,
-            originRepositoryName = Some(originRepositoryName),
-            originUserName       = Some(originUserName),
-            parentRepositoryName = Some(repository.name),
-            parentUserName       = Some(repository.owner)
-          )
-
-          // Insert default labels
-          insertDefaultLabels(loginUserName, repository.name)
-
-          // clone repository actually
-          JGitUtil.cloneRepository(
-            getRepositoryDir(repository.owner, repository.name),
-            getRepositoryDir(loginUserName, repository.name))
-
-          // Create Wiki repository
-          JGitUtil.cloneRepository(
-            getWikiRepositoryDir(repository.owner, repository.name),
-            getWikiRepositoryDir(loginUserName, repository.name))
-
-          // insert commit id
-          using(Git.open(getRepositoryDir(loginUserName, repository.name))){ git =>
-            JGitUtil.getRepositoryInfo(loginUserName, repository.name, baseUrl).branchList.foreach { branch =>
-              JGitUtil.getCommitLog(git, branch) match {
-                case Right((commits, _)) => commits.foreach { commit =>
-                  if(!existsCommitId(loginUserName, repository.name, commit.id)){
-                    insertCommitId(loginUserName, repository.name, commit.id)
-                  }
-                }
-                case Left(_) => ???
-              }
-            }
-          }
-
-          // Record activity
-          recordForkActivity(repository.owner, repository.name, loginUserName)
-          // redirect to the repository
-          redirect(s"/${loginUserName}/${repository.name}")
-        }
-      }
-    }
-  })
-
-  private def insertDefaultLabels(userName: String, repositoryName: String): Unit = {
-    createLabel(userName, repositoryName, "bug", "fc2929")
-    createLabel(userName, repositoryName, "duplicate", "cccccc")
-    createLabel(userName, repositoryName, "enhancement", "84b6eb")
-    createLabel(userName, repositoryName, "invalid", "e6e6e6")
-    createLabel(userName, repositoryName, "question", "cc317c")
-    createLabel(userName, repositoryName, "wontfix", "ffffff")
-  }
-
-  private def existsAccount: Constraint = new Constraint(){
-    override def validate(name: String, value: String, messages: Messages): Option[String] =
-      if(getAccountByUserName(value).isEmpty) Some("User or group does not exist.") else None
-  }
-
-  /**
-   * Duplicate check for the repository name.
-   */
-  private def unique: Constraint = new Constraint(){
-    override def validate(name: String, value: String, params: Map[String, String], messages: Messages): Option[String] =
-      params.get("owner").flatMap { userName =>
-        getRepositoryNamesOfUser(userName).find(_ == value).map(_ => "Repository already exists.")
-      }
-  }
-  
-}

src/main/scala/app/PullRequestsController.scala

@@ -105,9 +105,9 @@ trait PullRequestsControllerBase extends ControllerBase {
     } getOrElse NotFound
   })
 
-  get("/:owner/:repository/pull/:id/delete/:branchName")(collaboratorsOnly { repository =>
+  get("/:owner/:repository/pull/:id/delete/*")(collaboratorsOnly { repository =>
     params("id").toIntOpt.map { issueId =>
-      val branchName = params("branchName")
+      val branchName = multiParams("splat").head
       val userName   = context.loginAccount.get.userName
       if(repository.repository.defaultBranch != branchName){
         using(Git.open(getRepositoryDir(repository.owner, repository.name))){ git =>

src/main/scala/app/RepositoryViewerController.scala

@@ -95,7 +95,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
       } map { objectId =>
         if(raw){
           // Download
-          defining(JGitUtil.getContent(git, objectId, false).get){ bytes =>
+          defining(JGitUtil.getContentFromId(git, objectId, false).get){ bytes =>
             contentType = FileUtil.getContentType(path, bytes)
             bytes
           }
@@ -103,7 +103,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
           // Viewer
           val large  = FileUtil.isLarge(git.getRepository.getObjectDatabase.open(objectId).getSize)
           val viewer = if(FileUtil.isImage(path)) "image" else if(large) "large" else "other"
-          val bytes  = if(viewer == "other") JGitUtil.getContent(git, objectId, false) else None
+          val bytes  = if(viewer == "other") JGitUtil.getContentFromId(git, objectId, false) else None
 
           val content = if(viewer == "other"){
             if(bytes.isDefined && FileUtil.isText(bytes.get)){
@@ -159,8 +159,8 @@ trait RepositoryViewerControllerBase extends ControllerBase {
   /**
    * Deletes branch.
    */
-  get("/:owner/:repository/delete/:branchName")(collaboratorsOnly { repository =>
-    val branchName = params("branchName")
+  get("/:owner/:repository/delete/*")(collaboratorsOnly { repository =>
+    val branchName = multiParams("splat").head
     val userName   = context.loginAccount.get.userName
     if(repository.repository.defaultBranch != branchName){
       using(Git.open(getRepositoryDir(repository.owner, repository.name))){ git =>
@@ -208,7 +208,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
             while(walk.next){
               val name = walk.getPathString
               val mode = walk.getFileMode(0)
-              if(mode != FileMode.TREE){
+              if(mode == FileMode.REGULAR_FILE){
                 walk.getObjectId(objectId, 0)
                 val entry = new ZipEntry(name)
                 val loader = reader.open(objectId)
@@ -277,7 +277,8 @@ trait RepositoryViewerControllerBase extends ControllerBase {
             val readme = files.find { file =>
               readmeFiles.contains(file.name.toLowerCase)
             }.map { file =>
-              file -> StringUtil.convertFromByteArray(JGitUtil.getContent(Git.open(getRepositoryDir(repository.owner, repository.name)), file.id, true).get)
+              file -> StringUtil.convertFromByteArray(JGitUtil.getContentFromId(
+                Git.open(getRepositoryDir(repository.owner, repository.name)), file.id, true).get)
             }
 
             repo.html.files(revision, repository,

src/main/scala/app/UserManagementController.scala

@@ -5,6 +5,7 @@ import util.AdminAuthenticator
 import util.StringUtil._
 import util.ControlUtil._
 import jp.sf.amateras.scalatra.forms._
+import org.scalatra.i18n.Messages
 import org.apache.commons.io.FileUtils
 import util.Directory._
 
@@ -23,10 +24,10 @@ trait UserManagementControllerBase extends AccountManagementControllerBase {
                           fileId: Option[String], clearImage: Boolean, isRemoved: Boolean)
 
   case class NewGroupForm(groupName: String, url: Option[String], fileId: Option[String],
-                          memberNames: Option[String])
+                          members: String)
 
   case class EditGroupForm(groupName: String, url: Option[String], fileId: Option[String],
-                           memberNames: Option[String], clearImage: Boolean, isRemoved: Boolean)
+                           members: String, clearImage: Boolean, isRemoved: Boolean)
 
   val newUserForm = mapping(
     "userName"    -> trim(label("Username"     ,text(required, maxlength(100), identifier, uniqueUserName))),
@@ -51,28 +52,28 @@ trait UserManagementControllerBase extends AccountManagementControllerBase {
   )(EditUserForm.apply)
 
   val newGroupForm = mapping(
-    "groupName"   -> trim(label("Group name"   ,text(required, maxlength(100), identifier, uniqueUserName))),
-    "url"         -> trim(label("URL"          ,optional(text(maxlength(200))))),
-    "fileId"      -> trim(label("File ID"      ,optional(text()))),
-    "memberNames" -> trim(label("Member Names" ,optional(text())))
+    "groupName" -> trim(label("Group name" ,text(required, maxlength(100), identifier, uniqueUserName))),
+    "url"       -> trim(label("URL"        ,optional(text(maxlength(200))))),
+    "fileId"    -> trim(label("File ID"    ,optional(text()))),
+    "members"   -> trim(label("Members"    ,text(required, members)))
   )(NewGroupForm.apply)
 
   val editGroupForm = mapping(
-    "groupName"   -> trim(label("Group name"   ,text(required, maxlength(100), identifier))),
-    "url"         -> trim(label("URL"          ,optional(text(maxlength(200))))),
-    "fileId"      -> trim(label("File ID"      ,optional(text()))),
-    "memberNames" -> trim(label("Member Names" ,optional(text()))),
-    "clearImage"  -> trim(label("Clear image"  ,boolean())),
-    "removed"     -> trim(label("Disable"      ,boolean()))
+    "groupName"  -> trim(label("Group name"  ,text(required, maxlength(100), identifier))),
+    "url"        -> trim(label("URL"         ,optional(text(maxlength(200))))),
+    "fileId"     -> trim(label("File ID"     ,optional(text()))),
+    "members"    -> trim(label("Members"     ,text(required, members))),
+    "clearImage" -> trim(label("Clear image" ,boolean())),
+    "removed"    -> trim(label("Disable"     ,boolean()))
   )(EditGroupForm.apply)
 
   get("/admin/users")(adminOnly {
     val includeRemoved = params.get("includeRemoved").map(_.toBoolean).getOrElse(false)
-    val users = getAllUsers(includeRemoved)
-
-    val members = users.collect { case account if(account.isGroupAccount) =>
-      account.userName -> getGroupMembers(account.userName)
+    val users          = getAllUsers(includeRemoved)
+    val members        = users.collect { case account if(account.isGroupAccount) =>
+      account.userName -> getGroupMembers(account.userName).map(_.userName)
     }.toMap
+
     admin.users.html.list(users, members, includeRemoved)
   })
   
@@ -127,7 +128,11 @@ trait UserManagementControllerBase extends AccountManagementControllerBase {
 
   post("/admin/users/_newgroup", newGroupForm)(adminOnly { form =>
     createGroup(form.groupName, form.url)
-    updateGroupMembers(form.groupName, form.memberNames.map(_.split(",").toList).getOrElse(Nil))
+    updateGroupMembers(form.groupName, form.members.split(",").map {
+      _.split(":") match {
+        case Array(userName, isManager) => (userName, isManager.toBoolean)
+      }
+    }.toList)
     updateImage(form.groupName, form.fileId, false)
     redirect("/admin/users")
   })
@@ -139,7 +144,11 @@ trait UserManagementControllerBase extends AccountManagementControllerBase {
   })
 
   post("/admin/users/:groupName/_editgroup", editGroupForm)(adminOnly { form =>
-    defining(params("groupName"), form.memberNames.map(_.split(",").toList).getOrElse(Nil)){ case (groupName, memberNames) =>
+    defining(params("groupName"), form.members.split(",").map {
+      _.split(":") match {
+        case Array(userName, isManager) => (userName, isManager.toBoolean)
+      }
+    }.toList){ case (groupName, members) =>
       getAccountByUserName(groupName, true).map { account =>
         updateGroup(groupName, form.url, form.isRemoved)
 
@@ -155,11 +164,11 @@ trait UserManagementControllerBase extends AccountManagementControllerBase {
           }
         } else {
           // Update GROUP_MEMBER
-          updateGroupMembers(form.groupName, memberNames)
+          updateGroupMembers(form.groupName, members)
           // Update COLLABORATOR for group repositories
           getRepositoryNamesOfUser(form.groupName).foreach { repositoryName =>
             removeCollaborators(form.groupName, repositoryName)
-            memberNames.foreach { userName =>
+            members.foreach { case (userName, isManager) =>
               addCollaborator(form.groupName, repositoryName, userName)
             }
           }
@@ -172,8 +181,17 @@ trait UserManagementControllerBase extends AccountManagementControllerBase {
     }
   })
 
-  post("/admin/users/_usercheck")(adminOnly {
+  // TODO Move to other generic controller?
+  post("/admin/users/_usercheck"){
     getAccountByUserName(params("userName")).isDefined
-  })
+  }
+
+  private def members: Constraint = new Constraint(){
+    override def validate(name: String, value: String, messages: Messages): Option[String] = {
+      if(value.split(",").exists {
+        _.split(":") match { case Array(userName, isManager) => isManager.toBoolean }
+      }) None else Some("Must select one manager at least.")
+    }
+  }
 
 }