| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.esme.lib |
| |
| import net.liftweb._ |
| import http._ |
| import js._ |
| import js.jquery._ |
| import http.jquery._ |
| import JqJsCmds._ |
| import JsCmds._ |
| import SHtml._ |
| import JE._ |
| |
| import sitemap._ |
| import Loc._ |
| |
| import mapper._ |
| |
| import util._ |
| import common._ |
| import Helpers._ |
| |
| import widgets.autocomplete.AutoComplete |
| |
| import org.apache.esme._ |
| import model._ |
| import org.apache.esme.actor.Distributor |
| |
| import scala.xml._ |
| |
| import java.util.Date |
| import java.text.{DateFormat,SimpleDateFormat} |
| |
| /** |
| * Manage the sitemap and related snippets for Access Pools |
| */ |
| object AccessPoolMgr { |
| val logger: Logger = Logger("org.apache.esme.lib.AccessPoolMgr") |
| def loggedIn_? = User.loggedIn_? |
| |
| val ifIsLoggedIn = If(loggedIn_? _, strFuncToFailMsg(() => S.?("base_error_not_logged_in"))) |
| |
| val menuItems = |
| Menu(Loc("pools", new Link("pools" :: Nil, true)/*List("pools_view", "index")*/, S.?("base_pool_menu"), ifIsLoggedIn, |
| Loc.Snippet("addPool", addPool), |
| Loc.Snippet("editPool", editPool), |
| Loc.Snippet("poolUsers", displayPoolUsers), |
| Loc.Snippet("poolDetail", displayPoolDetail)//regist snippet for pool detail display |
| ,Loc.Snippet("myPools", myPoolsWithRoles) |
| )) :: |
| Nil |
| |
| object updatePool extends RequestVar[() => JsCmd](() => Noop) |
| |
| //update pool detail response |
| object updatePoolDetail extends RequestVar[() => JsCmd](() => Noop) |
| |
| object poolsWithRoles extends RequestVar[() => JsCmd](() => Noop) |
| |
| object poolId extends RequestVar[Long](0) |
| |
| |
| /* |
| * Function for adding pools |
| * |
| */ |
| def addPool(in: NodeSeq): NodeSeq = { |
| |
| // redisplay my pools and roles |
| val redisplayPoolsAndRoles = poolsWithRoles.is |
| |
| val theInput = "new_pool" |
| val newPoolDescription = "new_pool_description"; |
| val user = User.currentUser |
| var newPoolName = ""; |
| |
| |
| //def addNewPool(name: String) = { |
| def addNewPool(poolDescription: String) = { |
| |
| /* |
| name.trim match { |
| case x if x.length < 3 => DisplayMessage("messages", <b>{S.?("base_pool_error_name_short")}</b>, 3 seconds, 3 seconds) |
| case x => { |
| */ |
| (newPoolName.trim, poolDescription.trim) match { |
| case (x, y) if x.length < 3 => DisplayMessage("messages", <b>{S.?("base_pool_error_name_short")}</b>, 3 seconds, 3 seconds) |
| case (x, y) => { |
| import org.apache.esme.model.AccessPool |
| //val pool = AccessPool.create.realm(AccessPool.Native).setName(name) |
| val pool = AccessPool.create.realm(AccessPool.Native).setUpAccessPool(x, y) |
| pool match { |
| //case Failure(_,_,_) => DisplayMessage("messages", <b>{S.?("base_pool_msg_duplicate_name_pool",name)}</b>, 3 seconds, 2 seconds) |
| case Failure(_,_,_) => DisplayMessage("messages", <b>{S.?("base_pool_msg_duplicate_name_pool",x)}</b>, 3 seconds, 2 seconds) |
| case Full(p: AccessPool) => val privilegeSaved = |
| Privilege.create.pool(p.saveMe).user(user).permission(Permission.Admin).save |
| if(privilegeSaved && user.isDefined) { |
| import org.apache.esme.model.{Privilege, User} |
| Distributor ! Distributor.AllowUserInPool(user.get.id.is, p.id.is) |
| //logger.info("ACCESS: " + S.?("base_pool_msg_new_pool",name)) |
| logger.info("ACCESS: " + S.?("base_pool_msg_new_pool",x)) |
| val selectPools = ("0", S.?("base_pool_msg_choose_pool")) :: |
| (User.currentUser match { |
| case Full(u)=> Privilege.findViewablePools(u.id).map( |
| p => (p.toString, AccessPool.find(p).get.getName)).toList |
| case _ => Nil |
| }).sortWith(_._2 < _._2) |
| SetValById(theInput, "") & |
| ReplaceOptions("edit_pool", selectPools, Full(p.id.is.toString)) & |
| FireOnchangeById("edit_pool") & |
| redisplayPoolsAndRoles() & |
| //DisplayMessage("messages", <b>{S.?("base_pool_msg_new_pool",name)}</b>, 3 seconds, 2 seconds) |
| DisplayMessage("messages", <b>{S.?("base_pool_msg_new_pool",x)}</b>, 3 seconds, 2 seconds) |
| } else |
| DisplayMessage("messages", <b>{S.?("base_pool_msg_no_permission")}</b>, 3 seconds, 2 seconds) |
| case _ => S.error(S.?("base_error_general")) |
| } |
| } |
| } |
| |
| } |
| |
| case class FireOnchangeById(domElemId: String) extends JsCmd { |
| def toJsCmd = |
| """document.getElementById(""" + domElemId.encJs + """).onchange();""" |
| } |
| |
| bind("add", in, |
| //"poolName" -%> text("", addNewPool, "id" -> theInput), |
| "poolName" -%> text("", newPoolName = _ , "id" -> theInput), |
| "poolDescription" -%> textarea("", addNewPool, "id" -> newPoolDescription, "cols" -> "33", "rows" -> "2")) |
| |
| } |
| |
| var lastSelPool = ""; |
| |
| /* |
| * Function for editing pools |
| * |
| */ |
| def editPool(in: NodeSeq): NodeSeq = { |
| import org.apache.esme.model.{AccessPool, User} |
| val redisplayPool = updatePool.is |
| |
| // redisplay pool detail |
| val redisplayPoolDetail = updatePoolDetail.is |
| |
| val redisplayPoolsAndRoles = poolsWithRoles.is |
| |
| // redisplay pool users and pool detail |
| def redisplay(): JsCmd = { |
| redisplayPoolDetail() & redisplayPool() & redisplayPoolsAndRoles() |
| } |
| |
| var pool = "" |
| var username = "" |
| val editPoolName = "edit_pool" |
| val editUsername = "edit_username" |
| val editPermission = "edit_permission" |
| val adminUser = User.currentUser |
| |
| val adminPools = ("0", S.?("base_pool_msg_choose_pool")) :: |
| (adminUser match { |
| case Full(u)=> Privilege.findViewablePools(u.id).map( |
| p => (p.toString, AccessPool.find(p).get.getName)).toList |
| case _ => Nil |
| }) |
| |
| val permissions = Permission.values.map(perm => (perm.id.toString, perm.toString)).toSeq |
| |
| |
| /* |
| * Function for adding a user to a pool |
| * |
| */ |
| def addPoolUser(permission: String): JsCmd = { |
| pool = lastSelPool; |
| val r: Box[Boolean] = |
| for (admin <- adminUser; |
| p <- AccessPool.find(pool) ?~ S.?("base_pool_err_pool_not_found"); //DisplayMessage("messages", <b>{S.?("base_pool_err_pool_not_found")}</b>, 3 seconds, 2 seconds); |
| user <- User.findFromWeb(username) ?~ S.?("base_pool_err_user_not_found") //DisplayMessage("messages", <b>{S.?("base_pool_err_user_not_found")}</b>, 3 seconds, 2 seconds) |
| ) yield if(Privilege.hasPermission(admin.id.is, p.id.is, Permission.Admin)) { |
| val result = try { |
| import org.apache.esme.model.Permission |
| logger.info("ACCESS: " + S.?("base_pool_msg_new_user",user.id.is, p.id.is, permission)) |
| Privilege.create.user(user).pool(p).permission(Permission(permission.toInt)).save |
| |
| } catch { |
| case _: Exception => false |
| } |
| if (result) { |
| Distributor ! Distributor.AllowUserInPool(user.id.is, p.id.is) |
| DisplayMessage("messages", <b>{S.?("base_pool_msg_permission_set")}</b>, 3 seconds, 2 seconds) |
| } |
| result |
| } else false // "User has no permission to administer pool" |
| /* |
| r match { |
| case Failure(m,_,_) => S.error(m) |
| case Full(true) => S.notice(S.?("base_pool_msg_permission_set")) |
| case _ => S.error(S.?("base_error_general")) |
| } |
| */ |
| |
| poolId.set(pool.toLong) |
| |
| ( r match { |
| case Failure(m,_,_) => DisplayMessage("messages", <b>{m}</b>, 3 seconds, 2 seconds)//S.error(m) |
| case Full(true) => DisplayMessage("messages", <b>{S.?("base_pool_msg_permission_set")}</b>, 3 seconds, 2 seconds)//S.notice(S.?("base_pool_msg_permission_set")) |
| case _ => DisplayMessage("messages", <b>{S.?("base_error_general")}</b>, 3 seconds, 2 seconds)//S.error(S.?("base_error_general")) |
| } ) & |
| //we needn't redisplay pool detail when add a new user |
| redisplayPool() & SetValById(editUsername, "") & |
| redisplayPoolsAndRoles() |
| } |
| |
| /* |
| bind("edit", in, |
| "pool" -%> ajaxSelect(adminPools, Empty, p => {pool = p; |
| poolId.set(p.toLong); |
| redisplay() //redisplay pooluser and pool detail |
| }, |
| "id" -> editPoolName), |
| "username" -%> text(username, username = _, "id" -> editUsername), |
| "permission" -%> select(permissions, Empty, addPoolUser, "id" -> editPermission) |
| ) |
| */ |
| |
| /* |
| bind("edit", in, |
| "pool" -%> org.apache.esme.liftwebext.SHtml.ajaxUntrustedSelect(adminPools, Empty, (p:String) => {lastSelPool = p; pool = p; |
| poolId.set(p.toLong); |
| redisplay() //redisplay pooluser and pool detail |
| }, |
| "id" -> editPoolName), |
| "username" -%> text(username, username = _, "id" -> editUsername), |
| "permission" -%> select(permissions, Empty, addPoolUser, "id" -> editPermission) |
| ) |
| */ |
| |
| bind("edit", in, |
| "pool" -%> org.apache.esme.liftwebext.SHtml.ajaxUntrustedSortedSelect(adminPools, |
| true, |
| Empty, (p:String) => {lastSelPool = p; pool = p; |
| poolId.set(p.toLong); |
| redisplay() //redisplay pooluser and pool detail |
| }, |
| "id" -> editPoolName), |
| "username" -%> AutoComplete("", (current : String,limit : Int) => |
| User.findAll(Like(User.nickname, (current + "%"))).map(_.nickname.is), |
| username = _ : String, |
| List(("selectFirst", "false"), ("minChars", "1")), |
| "name" -> editUsername), |
| "permission" -%> select(permissions, Empty, addPoolUser, "id" -> editPermission) |
| ) |
| } |
| |
| def myPoolsWithRoles(in: NodeSeq): NodeSeq = { |
| |
| // get the span name to update |
| val spanName = S.attr("the_id") openOr "pool_membership_and_roles" |
| |
| def doRender(): NodeSeq = { |
| |
| val user = User.currentUser |
| |
| val userPools = |
| (user match { |
| case Full(u)=> Privilege.findViewablePools(u.id).map( |
| p => (p, AccessPool.find(p).get.getName)) |
| case _ => Nil |
| }) |
| |
| val userPerms = userPools.map((x: (Long, String)) => Privilege.getPermissionString(user.open_!.id, x._1)); |
| val poolsAndRoles = userPools.map(_._2).zip(userPerms) |
| |
| bind("myPool", in, |
| "pool" -> |
| (in1 => |
| poolsAndRoles.flatMap((x: (String, String)) => |
| bind("pool", in1, |
| "poolName" -> x._1, |
| "role" -> x._2 |
| )))) |
| } |
| |
| def updateSpan(): JsCmd = SetHtml(spanName, doRender()) |
| poolsWithRoles.set(updateSpan) |
| doRender |
| } |
| |
| def displayPoolDetail(in: NodeSeq): NodeSeq = { |
| import org.apache.esme.model.AccessPool |
| // get the span name to update |
| val spanName = S.attr("the_pool_id") openOr "PoolDetailSpan" |
| |
| //XXX display date, should we have a common dateFormat? |
| val dateFormat = new SimpleDateFormat("yyyy/MM/dd") |
| def getDateHtml(date: Date) : Text = date match { |
| case null => Text(S.?("base_pool_ui_empty_date")) |
| case d => Text(dateFormat.format(d)) |
| } |
| |
| def displayUserName(uid: Long): NodeSeq = { |
| User.find(uid) match { |
| case Full(user) => <span>{user.nickname}</span> |
| case _ => NodeSeq.Empty |
| } |
| } |
| |
| def doRender(): NodeSeq = |
| AccessPool.find(By(AccessPool.id, poolId.is)) match { |
| case Full(ap) => { |
| bind( |
| "pool", in, |
| "name" -> (if ( ap.description == "" ) ap.getName else ap.getName + " - " + ap.description), |
| "creator" -> displayUserName( ap.creator ), |
| "createdDate" -> getDateHtml(ap.createdDate), |
| "modifier" -> displayUserName(ap.modifier), |
| "lastModifyDate" -> getDateHtml(ap.lastModifyDate)) } |
| case _ => NodeSeq.Empty |
| } |
| |
| def updateSpan(): JsCmd = SetHtml(spanName, doRender()) |
| updatePoolDetail.set(updateSpan) |
| doRender |
| } |
| |
| def displayPoolUsers(in: NodeSeq): NodeSeq = { |
| // get the span name to update |
| val spanName = S.attr("the_id") openOr "PoolSpan" |
| // get the current user |
| val user = User.currentUser |
| |
| // Distributor ! Distributor.RefreshUser(userId) |
| def doRender(): NodeSeq = { |
| val accessPool = AccessPool.find(By(AccessPool.id, poolId.is)) |
| Privilege.findAll(By(Privilege.pool, poolId.is), NotBy(Privilege.permission, Permission.Denied)) match { |
| case Nil => NodeSeq.Empty |
| case xs => { |
| def userNamePrivilege(lst : NodeSeq) : NodeSeq = { |
| xs.flatMap(i => bind("user", lst, |
| "name" -> User.find(i.user).map( |
| _.nickname.is).getOrElse(""), |
| "privilege" -> i.permission.is.toString |
| )) |
| } |
| |
| def renderEditButton(in : NodeSeq) : NodeSeq = if(Privilege.findAdminPools(user.open_!.id).contains(poolId.is)) in else NodeSeq.Empty |
| |
| bind("pool", in, |
| "user" -> userNamePrivilege _, |
| "action" -> renderEditButton _) |
| } |
| } |
| } |
| |
| def updateSpan(): JsCmd = SetHtml(spanName, doRender()) |
| |
| updatePool.set(updateSpan) |
| doRender |
| } |
| } |
