# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# 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 logging

import traceback

import formencode

from operator import itemgetter

from formencode import htmlfill

from paste.httpexceptions import HTTPInternalServerError

from pylons import request, response, session, tmpl_context as c, url

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \

    HasPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import invalidate_cache, action_logger, repo_name_slug

from rhodecode.lib.helpers import get_token

from rhodecode.model.db import User, Repository, UserFollowing, Group

from rhodecode.model.forms import RepoForm

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

from sqlalchemy.exc import IntegrityError

log = logging.getLogger(__name__)

class ReposController(BaseController):

    """

    REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('repo', 'repos')

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

        super(ReposController, self).__before__()

    def __load_defaults(self):

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

    def __load_data(self, repo_name=None):

        """

        Load defaults settings for edit, and update

        :param repo_name:

        """

        self.__load_defaults()

        c.repo_info = db_repo = Repository.get_by_repo_name(repo_name)

        repo = scm_repo = db_repo.scm_instance

        if c.repo_info is None:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was created or renamed from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('repos'))

        c.default_user_id = User.get_by_username('default').user_id

        c.in_public_journal = self.sa.query(UserFollowing)\

            .filter(UserFollowing.user_id == c.default_user_id)\

            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        if c.repo_info.stats:

            last_rev = c.repo_info.stats.stat_on_revision

        else:

            last_rev = 0

        c.stats_revision = last_rev

        c.repo_last_rev = repo.count() - 1 if repo.revisions else 0

        if last_rev == 0 or c.repo_last_rev == 0:

            c.stats_percentage = 0

        else:

            c.stats_percentage = '%.2f' % ((float((last_rev)) /

                                            c.repo_last_rev) * 100)

        defaults = c.repo_info.get_dict()

        group, repo_name = c.repo_info.groups_and_repo

        defaults['repo_name'] = repo_name

        defaults['repo_group'] = getattr(group[-1] if group else None,

                                         'group_id', None)

import logging

import traceback

import formencode

from formencode import htmlfill

from operator import itemgetter

from pylons import request, response, session, tmpl_context as c, url

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from sqlalchemy.exc import IntegrityError

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import Group

from rhodecode.model.repos_group import ReposGroupModel

from rhodecode.model.forms import ReposGroupForm

log = logging.getLogger(__name__)

class ReposGroupsController(BaseController):

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

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('repos_group', 'repos_groups')

    @LoginRequired()

    def __before__(self):

        super(ReposGroupsController, self).__before__()

    def __load_defaults(self):

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

    def __load_data(self, group_id):

        """

        Load defaults settings for edit, and update

        :param group_id:

        """

        self.__load_defaults()

        repo_group = Group.get(group_id)

        data = repo_group.get_dict()

        data['group_name'] = repo_group.name

        return data

    @HasPermissionAnyDecorator('hg.admin')

    def index(self, format='html'):

        """GET /repos_groups: All items in the collection"""

        # url('repos_groups')

        sk = lambda g:g.parents[0].group_name if g.parents else g.group_name

        c.groups = sorted(Group.query().all(), key=sk)

        return render('admin/repos_groups/repos_groups_show.html')

    @HasPermissionAnyDecorator('hg.admin')

    def create(self):

        """POST /repos_groups: Create a new item"""

        # url('repos_groups')

        self.__load_defaults()

        repos_group_model = ReposGroupModel()

        repos_group_form = ReposGroupForm(available_groups=

                                          c.repo_groups_choices)()

        try:

            form_result = repos_group_form.to_python(dict(request.POST))

            repos_group_model.create(form_result)

            h.flash(_('created repos group %s') \

                    % form_result['group_name'], category='success')

            #TODO: in futureaction_logger(, '', '', '', self.sa)

        except formencode.Invalid, errors:

            return htmlfill.render(

                render('admin/repos_groups/repos_groups_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

        )

    def my_account_update(self):

        """PUT /_admin/my_account_update: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('admin_settings_my_account_update'),

        #           method='put')

        # url('admin_settings_my_account_update', id=ID)

        user_model = UserModel()

        uid = self.rhodecode_user.user_id

        _form = UserForm(edit=True,

                         old_data={'user_id': uid,

                                   'email': self.rhodecode_user.email})()

        form_result = {}

        try:

            form_result = _form.to_python(dict(request.POST))

            user_model.update_my_account(uid, form_result)

            h.flash(_('Your account was updated successfully'),

                    category='success')

        except formencode.Invalid, errors:

            c.user = User.get(self.rhodecode_user.user_id)

            all_repos = self.sa.query(Repository)\

                .filter(Repository.user_id == c.user.user_id)\

                .order_by(func.lower(Repository.repo_name))\

                .all()

            c.user_repos = ScmModel().get_repos(all_repos)

            return htmlfill.render(

                render('admin/users/user_edit_my_account.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of user %s') \

                    % form_result.get('username'), category='error')

        return redirect(url('my_account'))

    @NotAnonymous()

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def create_repository(self):

        """GET /_admin/create_repository: Form to create a new item"""

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        new_repo = request.GET.get('repo', '')

        c.new_repo = repo_name_slug(new_repo)

        return render('admin/repos/repo_add_create_repository.html')

    def get_hg_ui_settings(self):

        ret = self.sa.query(RhodeCodeUi).all()

        if not ret:

            raise Exception('Could not get application ui settings !')

        settings = {}

        for each in ret:

            k = each.ui_key

            v = each.ui_value

            if k == '/':

                k = 'root_path'

            if k.find('.') != -1:

                k = k.replace('.', '_')

            if each.ui_section == 'hooks':

                v = each.ui_active

            settings[each.ui_section + '_' + k] = v

        return settings

            self.first_page = None

            self.page_count = 0

            self.last_page = None

            self.first_item = None

            self.last_item = None

            self.previous_page = None

            self.next_page = None

            self.items = []

        # This is a subclass of the 'list' type. Initialise the list now.

        list.__init__(self, self.items)

def changed_tooltip(nodes):

    """

    Generates a html string for changed nodes in changeset page.

    It limits the output to 30 entries

    :param nodes: LazyNodesGenerator

    """

    if nodes:

        pref = ': <br/> '

        suf = ''

        if len(nodes) > 30:

            suf = '<br/>' + _(' and %s more') % (len(nodes) - 30)

        return literal(pref + '<br/> '.join([safe_unicode(x.path)

                                             for x in nodes[:30]]) + suf)

    else:

        return ': ' + _('No Files')

def repo_link(groups_and_repos):

    """

    Makes a breadcrumbs link to repo within a group

    joins » on each group to create a fancy link

    ex::

        group >> subgroup >> repo

    :param groups_and_repos:

    """

    groups, repo_name = groups_and_repos

    if not groups:

        return repo_name

    else:

        def make_link(group):

        return literal(' » '.join(map(make_link, groups)) + \

                       " » " + repo_name)

def fancy_file_stats(stats):

    """

    Displays a fancy two colored bar for number of added/deleted

    lines of code on file

    :param stats: two element list of added/deleted lines of code

    """

    a, d, t = stats[0], stats[1], stats[0] + stats[1]

    width = 100

    unit = float(width) / (t or 1)

    # needs > 9% of width to be visible or 0 to be hidden

    a_p = max(9, unit * a) if a > 0 else 0

    d_p = max(9, unit * d) if d > 0 else 0

    p_sum = a_p + d_p

    if p_sum > width:

        #adjust the percentage to be == 100% since we adjusted to 9

        if a_p > d_p:

            a_p = a_p - (p_sum - width)

        else:

            d_p = d_p - (p_sum - width)

    a_v = a if a > 0 else ''

    d_v = d if d > 0 else ''

    def cgen(l_type):

        mapping = {'tr':'top-right-rounded-corner',

                   'tl':'top-left-rounded-corner',

                   'br':'bottom-right-rounded-corner',

                   'bl':'bottom-left-rounded-corner'}

        map_getter = lambda x:mapping[x]

        if l_type == 'a' and d_v:

            #case when added and deleted are present

            return ' '.join(map(map_getter, ['tl', 'bl']))

        if l_type == 'a' and not d_v:

            return ' '.join(map(map_getter, ['tr', 'br', 'tl', 'bl']))

        if l_type == 'd' and a_v:

            return ' '.join(map(map_getter, ['tr', 'br']))

        if l_type == 'd' and not a_v:

            return ' '.join(map(map_getter, ['tr', 'br', 'tl', 'bl']))

        return self

    def get_file_content(self, path):

        return u''

    def get_file_size(self, path):

        return 0

def map_groups(groups):

    """Checks for groups existence, and creates groups structures.

    It returns last group in structure

    :param groups: list of groups structure

    """

    sa = meta.Session()

    parent = None

    group = None

    # last element is repo in nested groups structure

    groups = groups[:-1]

    for lvl, group_name in enumerate(groups):

        group_name = '/'.join(groups[:lvl] + [group_name])

        group = sa.query(Group).filter(Group.group_name == group_name).scalar()

        if group is None:

            group = Group(group_name, parent)

            sa.add(group)

            sa.commit()

        parent = group

    return group

def repo2db_mapper(initial_repo_list, remove_obsolete=False):

    """maps all repos given in initial_repo_list, non existing repositories

    are created, if remove_obsolete is True it also check for db entries

    that are not in initial_repo_list and removes them.

    :param initial_repo_list: list of repositories found by scanning methods

    :param remove_obsolete: check for obsolete entries in database

    """

    sa = meta.Session()

    rm = RepoModel()

    user = sa.query(User).filter(User.admin == True).first()

    added = []

    for name, repo in initial_repo_list.items():

        group = map_groups(name.split(os.sep))

        if not rm.get_by_repo_name(name, cache=False):

            log.info('repository %s not found creating default', name)

            added.append(name)

            form_data = {

                         'repo_name': name,

                         'repo_name_full': name,

                         'repo_type': repo.alias,

                         'description': repo.description \

                            if repo.description != 'unknown' else \

                                        '%s repository' % name,

                         'private': False,

                         'group_id': getattr(group, 'group_id', None)

                         }

            rm.create(form_data, user, just_db=True)

    removed = []

    if remove_obsolete:

        #remove from database those repositories that are not in the filesystem

        for repo in sa.query(Repository).all():

            if repo.repo_name not in initial_repo_list.keys():

                removed.append(repo.repo_name)

                sa.delete(repo)

                sa.commit()

    return added, removed

#set cache regions for beaker so celery can utilise it

def add_cache(settings):

    cache_settings = {'regions': None}

    for key in settings.keys():

        for prefix in ['beaker.cache.', 'cache.']:

            if key.startswith(prefix):

                name = key.split(prefix)[1].strip()

                cache_settings[name] = settings[key].strip()

    if cache_settings['regions']:

        for region in cache_settings['regions'].split(','):

            region = region.strip()

            region_settings = {}

            for key, value in cache_settings.items():

                if key.startswith(region):

                    region_settings[key.split('.')[1]] = value

            region_settings['expire'] = int(region_settings.get('expire',

                                                                60))

            region_settings.setdefault('lock_dir',

                                       cache_settings.get('lock_dir'))

            region_settings.setdefault('data_dir',

        try:

            alias = get_scm(repo_full_path)[0]

            log.debug('Creating instance of %s repository', alias)

            backend = get_backend(alias)

        except VCSError:

            log.error(traceback.format_exc())

            log.error('Perhaps this repository is in db and not in '

                      'filesystem run rescan repositories with '

                      '"destroy old data " option from admin panel')

            return

        if alias == 'hg':

            repo = backend(safe_str(repo_full_path), create=False,

                           baseui=self._ui)

            #skip hidden web repository

            if repo._get_hidden():

                return

        else:

            repo = backend(repo_full_path, create=False)

        return repo

class Group(Base, BaseModel):

    __tablename__ = 'groups'

    __table_args__ = (UniqueConstraint('group_name', 'group_parent_id'),

                      CheckConstraint('group_id != group_parent_id'), {'extend_existing':True},)

    __mapper_args__ = {'order_by':'group_name'}

    group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    group_name = Column("group_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)

    group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)

    group_description = Column("group_description", String(length=10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    parent_group = relationship('Group', remote_side=group_id)

    def __init__(self, group_name='', parent_group=None):

        self.group_name = group_name

        self.parent_group = parent_group

    def __repr__(self):

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

                                  self.group_name)

    @classmethod

    def url_sep(cls):

        return '/'

    @classmethod

    def get_by_group_name(cls, group_name):

        return cls.query().filter(cls.group_name == group_name).scalar()

    @property

    def parents(self):

        parents_recursion_limit = 5

        groups = []

        if self.parent_group is None:

            return groups

        cur_gr = self.parent_group

        groups.insert(0, cur_gr)

        cnt = 0

        while 1:

            cnt += 1

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

            cur_gr = cur_gr.parent_group

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                # this will prevent accidental infinit loops

                log.error('group nested more than %s' %

                          parents_recursion_limit)

                break

            groups.insert(0, gr)

        return groups

    @property

    def children(self):

        return Session.query(Group).filter(Group.parent_group == self)

    @property

    def name(self):

        return self.group_name.split(Group.url_sep())[-1]

    @property

    def full_path(self):

        return self.group_name

    @property

    def full_path_splitted(self):

        return self.group_name.split(Group.url_sep())

    @property

<%inherit file="/base/base.html"/>

<%def name="title()">

    ${c.repo_name} ${_('Summary')} - ${c.rhodecode_name}

</%def>

<%def name="breadcrumbs_links()">

    ${h.link_to(u'Home',h.url('/'))}

    » 

    ${h.link_to(c.dbrepo.just_name,h.url('summary_home',repo_name=c.repo_name))}

    »

    ${_('summary')}

</%def>

<%def name="page_nav()">

	${self.menu('summary')}    

</%def>

<%def name="main()">

<div class="box box-left">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    <!-- end box / title -->

	<div class="form">

	  <div id="summary" class="fields">

			 <div class="field">

			  <div class="label">

			      <label>${_('Name')}:</label>

			  </div>

			  <div class="input-short">

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

                      %if c.following:

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

                            onclick="javascript:toggleFollowingRepo(this,${c.dbrepo.repo_id},'${str(h.get_token())}')">

                      </span>                 

                      %else:

                      <span id="follow_toggle" class="follow" title="${_('Start following this repository')}"

                            onclick="javascript:toggleFollowingRepo(this,${c.dbrepo.repo_id},'${str(h.get_token())}')">

                      </span>

                      %endif

                  %endif:			  

                 ##REPO TYPE

		         %if c.dbrepo.repo_type =='hg':

		         %endif

		         %if c.dbrepo.repo_type =='git':

		         %endif 

                 ##PUBLIC/PRIVATE     			  

	             %if c.dbrepo.private:

	             %else:

	             %endif

	              ##REPO NAME

			      <span class="repo_name">${h.repo_link(c.dbrepo.groups_and_repo)}</span>

                  ##FORK

		          %if c.dbrepo.fork:

	            	<div style="margin-top:5px;clear:both"">

	            	<a href="${h.url('summary_home',repo_name=c.dbrepo.fork.repo_name)}">

	            	<img class="icon" alt="${_('public')}"

	            	title="${_('Fork of')} ${c.dbrepo.fork.repo_name}" 

	            	${_('Fork of')} ${c.dbrepo.fork.repo_name}

	            	</a>

	            	</div>

		          %endif

		          ##REMOTE

				  %if c.dbrepo.clone_uri:

                    <div style="margin-top:5px;clear:both">

                    <a href="${h.url(str(h.hide_credentials(c.dbrepo.clone_uri)))}">

                    <img class="icon" alt="${_('remote clone')}"

                    title="${_('Clone from')} ${h.hide_credentials(c.dbrepo.clone_uri)}" 

                    ${_('Clone from')} ${h.hide_credentials(c.dbrepo.clone_uri)}

                    </a>

                    </div>					

				  %endif		            		      

			  </div>

			 </div>

			 <div class="field">

			  <div class="label">

			      <label>${_('Description')}:</label>

			  </div>

			  <div class="input-short desc">${h.urlify_text(c.dbrepo.description)}</div>

			 </div>

			 <div class="field">

			  <div class="label">

			      <label>${_('Contact')}:</label>

			  </div>

			  <div class="input-short">

			  	<div class="gravatar">

			  		<img alt="gravatar" src="${h.gravatar_url(c.dbrepo.user.email)}"/>

			  	</div>

			  		${_('Username')}: ${c.dbrepo.user.username}<br/>

			  		${_('Name')}: ${c.dbrepo.user.name} ${c.dbrepo.user.lastname}<br/>

			  		${_('Email')}: <a href="mailto:${c.dbrepo.user.email}">${c.dbrepo.user.email}</a>

			  </div>

			 </div>

			 <div class="field">

			  <div class="label">

			      <label>${_('Last change')}:</label>

			  </div>

			  <div class="input-short">

                  <b>${'r%s:%s' % (h.get_changeset_safe(c.rhodecode_repo,'tip').revision,

                            h.get_changeset_safe(c.rhodecode_repo,'tip').short_id)}</b> - 

			      <span class="tooltip" title="${c.rhodecode_repo.last_change}">

			      ${h.age(c.rhodecode_repo.last_change)}</span><br/>

			      ${_('by')} ${h.get_changeset_safe(c.rhodecode_repo,'tip').author} 

			  </div>

			 </div>

			 <div class="field">

			  <div class="label">

			      <label>${_('Clone url')}:</label>

			  </div>