return dict(

          ip_addr=self.ip_addr,

          ip_range=self._get_ip_range(self.ip_addr)

        )

    def __unicode__(self):

        return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,

                                            self.user_id, self.ip_addr)

class UserLog(Base, BaseModel):

    __tablename__ = 'user_logs'

    __table_args__ = (

        _table_args_default_dict,

    )

    user_log_id = Column(Integer(), primary_key=True)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=True)

    username = Column(String(255), nullable=False)

    repository_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=True)

    repository_name = Column(Unicode(255), nullable=False)

    user_ip = Column(String(255), nullable=True)

    action = Column(UnicodeText(), nullable=False)

    action_date = Column(DateTime(timezone=False), nullable=False)

    def __unicode__(self):

        return u"<%s('id:%s:%s')>" % (self.__class__.__name__,

                                      self.repository_name,

                                      self.action)

    @property

    def action_as_day(self):

        return datetime.date(*self.action_date.timetuple()[:3])

    user = relationship('User')

    repository = relationship('Repository', cascade='')

class UserGroup(Base, BaseModel):

    __tablename__ = 'users_groups'

    __table_args__ = (

        _table_args_default_dict,

    )

    users_group_id = Column(Integer(), primary_key=True)

    users_group_name = Column(Unicode(255), nullable=False, unique=True)

    user_group_description = Column(Unicode(10000), nullable=True) # FIXME: not nullable?

    users_group_active = Column(Boolean(), nullable=False)

    inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, default=True)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    _group_data = Column("group_data", LargeBinary(), nullable=True)  # JSON data # FIXME: not nullable?

    members = relationship('UserGroupMember', cascade="all, delete-orphan")

    users_group_to_perm = relationship('UserGroupToPerm', cascade='all')

    users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')

    users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')

    user_user_group_to_perm = relationship('UserUserGroupToPerm ', cascade='all')

    user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')

    user = relationship('User')

    @hybrid_property

    def group_data(self):

        if not self._group_data:

            return {}

        try:

            return json.loads(self._group_data)

        except TypeError:

            return {}

    @group_data.setter

    def group_data(self, val):

        try:

            self._group_data = json.dumps(val)

        except Exception:

            log.error(traceback.format_exc())

    def __unicode__(self):

        return u"<%s('id:%s:%s')>" % (self.__class__.__name__,

                                      self.users_group_id,

                                      self.users_group_name)

    @classmethod

    def get_by_group_name(cls, group_name, cache=False,

                          case_insensitive=False):

        if case_insensitive:

            q = cls.query().filter(func.lower(cls.users_group_name) == func.lower(group_name))

        else:

            q = cls.query().filter(cls.users_group_name == group_name)

        if cache:

            q = q.options(FromCache(

                            "sql_cache_short",

                            "get_group_%s" % _hash_key(group_name)

                          )

            )

        return q.scalar()

    @classmethod

    def get(cls, user_group_id, cache=False):

        user_group = cls.query()

        if cache:

            user_group = user_group.options(FromCache("sql_cache_short",

                                    "get_users_group_%s" % user_group_id))

        return user_group.get(user_group_id)

    def get_api_data(self, with_members=True):

        user_group = self

        data = dict(

            users_group_id=user_group.users_group_id,

            group_name=user_group.users_group_name,

            group_description=user_group.user_group_description,

            active=user_group.users_group_active,

            owner=user_group.user.username,

        )

        if with_members:

            members = []

            for user in user_group.members:

                user = user.user

                members.append(user.get_api_data())

            data['members'] = members

        return data

class UserGroupMember(Base, BaseModel):

    __tablename__ = 'users_groups_members'

    __table_args__ = (

        _table_args_default_dict,

    )

    users_group_member_id = Column(Integer(), primary_key=True)

    users_group_id = Column(Integer(), ForeignKey('users_groups.users_group_id'), nullable=False)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

    user = relationship('User')

    users_group = relationship('UserGroup')

    def __init__(self, gr_id='', u_id=''):

        self.users_group_id = gr_id

        self.user_id = u_id

class RepositoryField(Base, BaseModel):

    __tablename__ = 'repositories_fields'

    __table_args__ = (

        UniqueConstraint('repository_id', 'field_key'),  # no-multi field

        _table_args_default_dict,

    )

    PREFIX = 'ex_'  # prefix used in form to not conflict with already existing fields

    repo_field_id = Column(Integer(), primary_key=True)

    repository_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    field_key = Column(String(250), nullable=False)

    field_label = Column(String(1024), nullable=False)

    field_value = Column(String(10000), nullable=False)

    field_desc = Column(String(1024), nullable=False)

    field_type = Column(String(255), nullable=False)

    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    repository = relationship('Repository')

    @property

    def field_key_prefixed(self):

        return 'ex_%s' % self.field_key

    @classmethod

    def un_prefix_key(cls, key):

        if key.startswith(cls.PREFIX):

            return key[len(cls.PREFIX):]

        return key

    @classmethod

    def get_by_key_name(cls, key, repo):

        row = cls.query() \

                .filter(cls.repository == repo) \

                .filter(cls.field_key == key).scalar()

        return row

class Repository(Base, BaseModel):

    __tablename__ = 'repositories'

    __table_args__ = (

        Index('r_repo_name_idx', 'repo_name'),

        _table_args_default_dict,

    )

    DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'

    DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'

    repo_id = Column(Integer(), primary_key=True)

    repo_name = Column(Unicode(255), nullable=False, unique=True)

    repo_state = Column(String(255), nullable=False)

    clone_uri = Column(String(255), nullable=True) # FIXME: not nullable?

    repo_type = Column(String(255), nullable=False)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

    private = Column(Boolean(), nullable=False)

    enable_statistics = Column("statistics", Boolean(), nullable=False, default=True)

    enable_downloads = Column("downloads", Boolean(), nullable=False, default=True)

    description = Column(Unicode(10000), nullable=False)

    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    updated_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    _landing_revision = Column("landing_revision", String(255), nullable=False)

    enable_locking = Column(Boolean(), nullable=False, default=False)

    _locked = Column("locked", String(255), nullable=True) # FIXME: not nullable?

    _changeset_cache = Column("changeset_cache", LargeBinary(), nullable=True) # JSON data # FIXME: not nullable?

    fork_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=True)

    group_id = Column(Integer(), ForeignKey('groups.group_id'), nullable=True)

    user = relationship('User')

    fork = relationship('Repository', remote_side=repo_id)

    group = relationship('RepoGroup')

    repo_to_perm = relationship('UserRepoToPerm', cascade='all', order_by='UserRepoToPerm.repo_to_perm_id')

    users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')

    stats = relationship('Statistics', cascade='all', uselist=False)

    followers = relationship('UserFollowing',

                             primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',

                             cascade='all')

    extra_fields = relationship('RepositoryField',

                                cascade="all, delete-orphan")

    logs = relationship('UserLog')

    comments = relationship('ChangesetComment', cascade="all, delete-orphan")

    pull_requests_org = relationship('PullRequest',

                    primaryjoin='PullRequest.org_repo_id==Repository.repo_id',

                    cascade="all, delete-orphan")

    pull_requests_other = relationship('PullRequest',

                    primaryjoin='PullRequest.other_repo_id==Repository.repo_id',

                    cascade="all, delete-orphan")

    def __unicode__(self):

        return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,

                                   safe_unicode(self.repo_name))

    @hybrid_property

    def landing_rev(self):

        # always should return [rev_type, rev]

        if self._landing_revision:

            _rev_info = self._landing_revision.split(':')

            if len(_rev_info) < 2:

                _rev_info.insert(0, 'rev')

            return [_rev_info[0], _rev_info[1]]

        return [None, None]

    @landing_rev.setter

    def landing_rev(self, val):

        if ':' not in val:

            raise ValueError('value must be delimited with `:` and consist '

                             'of <rev_type>:<rev>, got %s instead' % val)

        self._landing_revision = val

    @hybrid_property

    def locked(self):

        # always should return [user_id, timelocked]

        if self._locked:

            _lock_info = self._locked.split(':')

            return int(_lock_info[0]), _lock_info[1]

        return [None, None]

    @locked.setter

    def locked(self, val):

        if val and isinstance(val, (list, tuple)):

            self._locked = ':'.join(map(str, val))

        else:

            self._locked = None

    @hybrid_property

    def changeset_cache(self):

        try:

            cs_cache = json.loads(self._changeset_cache) # might raise on bad data

            cs_cache['raw_id'] # verify data, raise exception on error

            return cs_cache

        except (TypeError, KeyError, ValueError):

            return EmptyChangeset().__json__()

    @changeset_cache.setter

    def changeset_cache(self, val):

        try:

            self._changeset_cache = json.dumps(val)

        except Exception:

            log.error(traceback.format_exc())

    @classmethod

    def url_sep(cls):

        return URL_SEP

    @classmethod

    def normalize_repo_name(cls, repo_name):

        """

        Normalizes os specific repo_name to the format internally stored inside

        database using URL_SEP

        :param cls:

        :param repo_name:

        """

        return cls.url_sep().join(repo_name.split(os.sep))

    @classmethod

    def get_by_repo_name(cls, repo_name):

        q = Session().query(cls).filter(cls.repo_name == repo_name)

        q = q.options(joinedload(Repository.fork)) \

                .options(joinedload(Repository.user)) \

                .options(joinedload(Repository.group))

        return q.scalar()

    @classmethod

    def get_by_full_path(cls, repo_full_path):

        base_full_path = os.path.realpath(cls.base_path())

        repo_full_path = os.path.realpath(repo_full_path)

        assert repo_full_path.startswith(base_full_path + os.path.sep)

        repo_name = repo_full_path[len(base_full_path) + 1:]

        repo_name = cls.normalize_repo_name(repo_name)

        return cls.get_by_repo_name(repo_name.strip(URL_SEP))

    @classmethod

    def get_repo_forks(cls, repo_id):

        return cls.query().filter(Repository.fork_id == repo_id)

    @classmethod

    def base_path(cls):

        """

        Returns base path where all repos are stored

        :param cls:

        """

        q = Session().query(Ui) \

            .filter(Ui.ui_key == cls.url_sep())

        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return q.one().ui_value

    @property

    def forks(self):

        """

        Return forks of this repo

        """

        return Repository.get_repo_forks(self.repo_id)

    @property

    def parent(self):

        """

        Returns fork parent

        """

        return self.fork

    @property

    def just_name(self):

        return self.repo_name.split(Repository.url_sep())[-1]

    @property

    def groups_with_parents(self):

        groups = []

        if self.group is None:

            return groups

        cur_gr = self.group

        groups.insert(0, cur_gr)

        while 1:

            gr = getattr(cur_gr, 'parent_group', None)

            cur_gr = cur_gr.parent_group

            if gr is None:

                break

            groups.insert(0, gr)

        return groups

    @property

    def groups_and_repo(self):

        return self.groups_with_parents, self.just_name, self.repo_name

    @LazyProperty

    def repo_path(self):

        """

        Returns base full path for that repository means where it actually

        exists on a filesystem

        """

        q = Session().query(Ui).filter(Ui.ui_key ==

## DATA TABLE RE USABLE ELEMENTS

## usage:

## <%namespace name="dt" file="/data_table/_dt_elements.html"/>

<%namespace name="base" file="/base/base.html"/>

<%def name="quick_menu(repo_name)">

  <ul class="menu_items hidden">

  ##<ul class="dropdown-menu" role="menu" aria-labelledby="dropdownMenu">

    <li style="border-top:1px solid #577632; margin-left: 21px; padding-left: -99px;"></li>

    <li>

       <a title="${_('Summary')}" href="${h.url('summary_home',repo_name=repo_name)}">

       <span class="icon">

           <i class="icon-doc-text-inv"></i>

       </span>

       <span>${_('Summary')}</span>

       </a>

    </li>

    <li>

       <a title="${_('Changelog')}" href="${h.url('changelog_home',repo_name=repo_name)}">

       <span class="icon">

           <i class="icon-clock"></i>

       </span>

       <span>${_('Changelog')}</span>

       </a>

    </li>

    <li>

       <a title="${_('Files')}" href="${h.url('files_home',repo_name=repo_name)}">

       <span class="icon">

           <i class="icon-docs"></i>

       </span>

       <span>${_('Files')}</span>

       </a>

    </li>

    <li>

       <a title="${_('Fork')}" href="${h.url('repo_fork_home',repo_name=repo_name)}">

       <span class="icon">

           <i class="icon-fork"></i>

       </span>

       <span>${_('Fork')}</span>

       </a>

    </li>

    <li>

       <a title="${_('Settings')}" href="${h.url('edit_repo',repo_name=repo_name)}">

       <span class="icon">

           <i class="icon-gear"></i>

       </span>

       <span>${_('Settings')}</span>

       </a>

    </li>

  </ul>

</%def>

<%def name="repo_name(name,rtype,rstate,private,fork_of,short_name=False,admin=False)">

    <%

    def get_name(name,short_name=short_name):

      if short_name:

        return name.split('/')[-1]

      else:

        return name

    %>

  <div class="dt_repo ${'dt_repo_pending' if rstate == 'repo_state_pending' else ''}">

    ##NAME

    <a href="${h.url('edit_repo' if admin else 'summary_home', repo_name=name)}">

    ##TYPE OF REPO

    ${base.repotag(rtype)}

    ##PRIVATE/PUBLIC

    %if private and c.visual.show_private_icon:

      <i class="icon-keyhole-circled" title="${_('Private repository')}"></i>

    %elif not private and c.visual.show_public_icon:

      <i class="icon-globe" title="${_('Public repository')}"></i>

    %else:

      <span style="margin: 0px 8px 0px 8px"></span>

    %endif

    <span class="dt_repo_name">${get_name(name)}</span>

    </a>

    %if fork_of:

      <a href="${h.url('summary_home',repo_name=fork_of.repo_name)}"><i class="icon-fork"></i></a>

    %endif

    %if rstate == 'repo_state_pending':

      <i class="icon-wrench" title="${_('Repository creation in progress...')}"></i>

    %endif

  </div>

</%def>

<%def name="last_change(last_change)">

  <span class="tooltip" date="${last_change}" title="${h.fmt_date(last_change)}">${h.age(last_change)}</span>

</%def>

<%def name="revision(name,rev,tip,author,last_msg)">

  <div>

  %if rev >= 0:

      <a title="${'%s:\n\n%s' % (h.escape(author), h.escape(last_msg))}" class="tooltip revision-link safe-html-title" href="${h.url('changeset_home',repo_name=name,revision=tip)}">${'r%s:%s' % (rev,h.short_id(tip))}</a>

  %else:

      ${_('No changesets yet')}

  %endif

  </div>

</%def>

<%def name="rss(name)">

  %if c.authuser.username != 'default':

    <a title="${_('Subscribe to %s rss feed')% name}" href="${h.url('rss_feed_home',repo_name=name,api_key=c.authuser.api_key)}"><i class="icon-rss-squared"></i></a>

  %else:

    <a title="${_('Subscribe to %s rss feed')% name}" href="${h.url('rss_feed_home',repo_name=name)}"><i class="icon-rss-squared"></i></a>

  %endif

</%def>

<%def name="atom(name)">

  %if c.authuser.username != 'default':

    <a title="${_('Subscribe to %s atom feed')% name}" href="${h.url('atom_feed_home',repo_name=name,api_key=c.authuser.api_key)}"><i class="icon-rss-squared"></i></a>

  %else:

    <a title="${_('Subscribe to %s atom feed')% name}" href="${h.url('atom_feed_home',repo_name=name)}"><i class="icon-rss-squared"></i></a>

  %endif

</%def>

<%def name="repo_actions(repo_name, super_user=True)">

  <div>

    <div style="float:left; margin-right:5px;" class="grid_edit">

      <a href="${h.url('edit_repo',repo_name=repo_name)}" title="${_('Edit')}">

        <i class="icon-pencil"></i> ${h.submit('edit_%s' % repo_name,_('Edit'),class_="action_button")}

      </a>

    </div>

    <div style="float:left" class="grid_delete">

      ${h.form(h.url('delete_repo', repo_name=repo_name), method='delete')}

        <i class="icon-minus-circled" style="color:#FF4444"></i>

        ${h.submit('remove_%s' % repo_name,_('Delete'),class_="action_button",

        onclick="return confirm('"+_('Confirm to delete this repository: %s') % repo_name+"');")}

      ${h.end_form()}

    </div>

  </div>

</%def>

<%def name="repo_state(repo_state)">

  <div>

        <div class="btn btn-mini btn-info disabled">${_('Creating')}</div>

        <div class="btn btn-mini btn-success disabled">${_('Created')}</div>

    %else:

        <div class="btn btn-mini btn-danger disabled" title="${repo_state}">invalid</div>

    %endif

  </div>

</%def>

<%def name="user_actions(user_id, username)">

 <div style="float:left" class="grid_edit">

   <a href="${h.url('edit_user',id=user_id)}" title="${_('Edit')}">

     <i class="icon-pencil"></i> ${h.submit('edit_%s' % username,_('Edit'),class_="action_button")}

   </a>

 </div>

 <div style="float:left" class="grid_delete">

  ${h.form(h.url('delete_user', id=user_id),method='delete')}

    <i class="icon-minus-circled" style="color:#FF4444"></i>

    ${h.submit('remove_',_('Delete'),id="remove_user_%s" % user_id, class_="action_button",

    onclick="return confirm('"+_('Confirm to delete this user: %s') % username+"');")}

  ${h.end_form()}

 </div>

</%def>

<%def name="user_group_actions(user_group_id, user_group_name)">

 <div style="float:left" class="grid_edit">

    <a href="${h.url('edit_users_group', id=user_group_id)}" title="${_('Edit')}">

    <i class="icon-pencil"></i>

     ${h.submit('edit_%s' % user_group_name,_('Edit'),class_="action_button", id_="submit_user_group_edit")}

    </a>

 </div>

 <div style="float:left" class="grid_delete">

    ${h.form(h.url('users_group', id=user_group_id),method='delete')}

      <i class="icon-minus-circled" style="color:#FF4444"></i>

      ${h.submit('remove_',_('Delete'),id="remove_group_%s" % user_group_id, class_="action_button",

      onclick="return confirm('"+_('Confirm to delete this user group: %s') % user_group_name+"');")}

    ${h.end_form()}

 </div>

</%def>

<%def name="repo_group_actions(repo_group_id, repo_group_name, gr_count)">

 <div style="float:left" class="grid_edit">

    <a href="${h.url('edit_repo_group',group_name=repo_group_name)}" title="${_('Edit')}">

    <i class="icon-pencil"></i>

     ${h.submit('edit_%s' % repo_group_name, _('Edit'),class_="action_button")}

    </a>

 </div>

 <div style="float:left" class="grid_delete">

    ${h.form(h.url('repos_group', group_name=repo_group_name),method='delete')}

        <i class="icon-minus-circled" style="color:#FF4444"></i>

        ${h.submit('remove_%s' % repo_group_name,_('Delete'),class_="action_button",

        onclick="return confirm('"+ungettext('Confirm to delete this group: %s with %s repository','Confirm to delete this group: %s with %s repositories',gr_count) % (repo_group_name, gr_count)+"');")}

    ${h.end_form()}

 </div>

</%def>

<%def name="user_name(user_id, username)">

    ${h.link_to(username,h.url('edit_user', id=user_id))}

</%def>

<%def name="repo_group_name(repo_group_name, children_groups)">

  <div style="white-space: nowrap">

  <a href="${h.url('repos_group_home',group_name=repo_group_name)}">

    <i class="icon-folder" title="${_('Repository group')}"></i> ${h.literal(' &raquo; '.join(children_groups))}</a>

  </div>

</%def>

<%def name="user_group_name(user_group_id, user_group_name)">

  <div style="white-space: nowrap">

  <a href="${h.url('edit_users_group', id=user_group_id)}">

    <i class="icon-users" title="${_('User group')}"></i> ${user_group_name}</a>

  </div>

</%def>

<%def name="toggle_follow(repo_id)">

  <span id="follow_toggle_${repo_id}" class="following" title="${_('Stop following this repository')}"

        onclick="toggleFollowingRepo(this, ${repo_id})">

  </span>

</%def>