from rhodecode.model.db import User, Permission, UserEmailMap

from rhodecode.model.forms import UserForm

from rhodecode.model.user import UserModel

from rhodecode.model.meta import Session

from rhodecode.lib.utils import action_logger

from rhodecode.lib.compat import json

log = logging.getLogger(__name__)

class UsersController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

        user_actions = lambda user_id, username: (

                template.get_def("user_actions")

                .render(user_id, username, _=_, h=h, c=c))

        for user in c.users_list:

            users_data.append({

                "gravatar": grav_tmpl(user. email, 24),

                "raw_username": user.username,

                "username": user_lnk(user.user_id, user.username),

                "firstname": user.name,

                "lastname": user.lastname,

                "last_login": h.fmt_date(user.last_login),

                "active": h.bool2icon(user.active),

                "admin": h.bool2icon(user.admin),

                "ldap": h.bool2icon(bool(user.ldap_dn)),

                "action": user_actions(user.user_id, user.username),

            })

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import re

from datetime import datetime

from pylons.i18n.translation import _, ungettext

from rhodecode.lib.vcs.utils.lazy import LazyProperty

def __get_lem():

        cs = repo.get_changeset(rev)

    except RepositoryError:

        cs = EmptyChangeset(requested_revision=rev)

    return cs

MENTIONS_REGEX = r'(?:^@|\s@)([a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+)(?:\s{1})'

def extract_mentioned_users(s):

    """

    Returns unique usernames from given string s that have @mention

    usrs = set()

    for username in re.findall(MENTIONS_REGEX, s):

        usrs.add(username)

    return sorted(list(usrs), key=lambda k: k.lower())

class AttributeDict(dict):

    def __getattr__(self, attr):

        return self.get(attr, None)

    __setattr__ = dict.__setitem__

    __delattr__ = dict.__delitem__

    var comp = YAHOO.util.Sort.compare;

    var compState = comp(a_, b_, desc);

    return compState;

};

var nameSort = function(a, b, desc, field) {

    var a_ = fromHTML(a.getData(field));

    var b_ = fromHTML(b.getData(field));

    // extract name from table

    a_ = get_name(a_)

          {key: "gravatar"},

          {key: "raw_username"},

          {key: "username"},

          {key: "firstname"},

          {key: "lastname"},

          {key: "last_login"},

          {key: "active"},

          {key: "admin"},

          {key: "ldap"},

          {key: "action"},

      ]

   };

      {key:"gravatar",label:"",sortable:false,},

      {key:"username",label:"${_('username')}",sortable:true,

    	  sortOptions: { sortFunction: linkSort }

      },

      {key:"firstname",label:"${_('firstname')}",sortable:true,},

      {key:"lastname",label:"${_('lastname')}",sortable:true,},

      {key:"active",label:"${_('active')}",sortable:true,},

      {key:"admin",label:"${_('admin')}",sortable:true,},

      {key:"ldap",label:"${_('ldap')}",sortable:true,},

      {key:"action",label:"${_('action')}",sortable:false},

  ];