"""Pylons middleware initialization"""

from beaker.middleware import SessionMiddleware

from paste.cascade import Cascade

from paste.registry import RegistryManager

from paste.urlparser import StaticURLParser

from paste.deploy.converters import asbool

from pylons.middleware import ErrorHandler, StatusCodeRedirect

from pylons.wsgiapp import PylonsApp

from routes.middleware import RoutesMiddleware

from rhodecode.lib.middleware.simplehg import SimpleHg

from rhodecode.lib.middleware.https_fixup import HttpsFixup

from rhodecode.config.environment import load_environment

def make_app(global_conf, full_stack=True, static_files=True, **app_conf):

    """Create a Pylons WSGI application and return it

    ``global_conf``

        The inherited configuration for this application. Normally from

        the [DEFAULT] section of the Paste ini file.

    ``full_stack``

        Whether or not this application provides a full WSGI stack (by

    ``app_conf``

        The application's local configuration. Normally specified in

        the [app:<name>] section of the Paste ini file (where <name>

        defaults to main).

    """

    # Configure the Pylons environment

    config = load_environment(global_conf, app_conf)

    # The Pylons WSGI app

    app = PylonsApp(config=config)

    # Routing/Session/Cache Middleware

    app = RoutesMiddleware(app, config['routes.map'])

    app = SessionMiddleware(app, config)

    # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)

    app = SimpleHg(app, config)

    if asbool(full_stack):

        # Handle Python exceptions

        app = ErrorHandler(app, global_conf, **config['pylons.errorware'])

        # Display error documents for 401, 403, 404 status codes (and

        # 500 when debug is disabled)

        if asbool(config['debug']):

            app = StatusCodeRedirect(app)

        else:

            app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])

    #enable https redirets based on HTTP_X_URL_SCHEME set by proxy

    app = HttpsFixup(app)

    # Establish the Registry for this application

    app = RegistryManager(app)

    if asbool(static_files):

        # Serve static files

        static_app = StaticURLParser(config['pylons.paths']['static_files'])

        app = Cascade([static_app, app])

    app.config = config

    return app

@task

@locked_task

def get_commits_stats(repo_name, ts_min_y, ts_max_y):

    from rhodecode.model.db import Statistics, Repository

    log = get_commits_stats.get_logger()

    author_key_cleaner = lambda k: person(k).replace('"', "") #for js data compatibilty

    commits_by_day_author_aggregate = {}

    commits_by_day_aggregate = {}

    repos_path = get_hg_ui_settings()['paths_root_path']

    p = os.path.join(repos_path, repo_name)

    skip_date_limit = True

    parse_limit = 250 #limit for single task changeset parsing optimal for

    last_rev = 0

    last_cs = None

    timegetter = itemgetter('time')

    sa = get_session()

    dbrepo = sa.query(Repository)\

        .filter(Repository.repo_name == repo_name).scalar()

    cur_stats = sa.query(Statistics)\

def __get_codes_stats(repo_name):

    LANGUAGES_EXTENSIONS = ['action', 'adp', 'ashx', 'asmx',

    'aspx', 'asx', 'axd', 'c', 'cfg', 'cfm', 'cpp', 'cs', 'diff', 'do', 'el',

    'erl', 'h', 'java', 'js', 'jsp', 'jspx', 'lisp', 'lua', 'm', 'mako', 'ml',

    'pas', 'patch', 'php', 'php3', 'php4', 'phtml', 'pm', 'py', 'rb', 'rst',

    's', 'sh', 'tpl', 'txt', 'vim', 'wss', 'xhtml', 'xml', 'xsl', 'xslt', 'yaws']

    repos_path = get_hg_ui_settings()['paths_root_path']

    p = os.path.join(repos_path, repo_name)

    tip = repo.get_changeset()

    code_stats = {}

    def aggregate(cs):

        for f in cs[2]:

            k = f.mimetype

            if f.extension in LANGUAGES_EXTENSIONS:

                if code_stats.has_key(k):

                    code_stats[k] += 1

                else:

                    code_stats[k] = 1

    map(aggregate, tip.walk('/'))

from webhelpers.html.tags import auto_discovery_link, checkbox, css_classes, \

    end_form, file, form, hidden, image, javascript_link, link_to, link_to_if, \

    link_to_unless, ol, required_legend, select, stylesheet_link, submit, text, \

    password, textarea, title, ul, xml_declaration, radio

from webhelpers.html.tools import auto_link, button_to, highlight, js_obfuscate, \

    mail_to, strip_links, strip_tags, tag_re

from webhelpers.number import format_byte_size, format_bit_size

from webhelpers.pylonslib import Flash as _Flash

from webhelpers.pylonslib.secure_form import secure_form

from webhelpers.text import chop_at, collapse, convert_accented_entities, \

    convert_misc_entities, lchop, plural, rchop, remove_formatting, \

    replace_whitespace, urlify, truncate, wrap_paragraphs

#Custom helpers here :)

class _Link(object):

    '''

    Make a url based on label and url with help of url_for

    :param label:name of link    if not defined url is used

    :param url: the url for link

    '''

    def __call__(self, label='', *url_, **urlargs):

        if label is None or '':

            label = url

    try:

        cs = repo.get_changeset(rev)

    except RepositoryError:

        from rhodecode.lib.utils import EmptyChangeset

        cs = EmptyChangeset()

    return cs

flash = _Flash()

# MERCURIAL FILTERS available via h.

from mercurial import util

capitalize = lambda x: x.capitalize()

email = util.email

email_or_none = lambda x: util.email(x) if util.email(x) != x else None

person = lambda x: _person(x)

# PERMS

from rhodecode.lib.auth import HasPermissionAny, HasPermissionAll, \

HasRepoPermissionAny, HasRepoPermissionAll

# GRAVATAR URL

import hashlib

import urllib

from pylons import request

def gravatar_url(email_address, size=30):

    ssl_enabled = 'https' == request.environ.get('HTTP_X_URL_SCHEME')

    default = 'identicon'

    baseurl_nossl = "http://www.gravatar.com/avatar/"

    baseurl_ssl = "https://secure.gravatar.com/avatar/"

    baseurl = baseurl_ssl if ssl_enabled else baseurl_nossl

# as published by the Free Software Foundation; version 2

# of the License or (at your opinion) any later version of the license.

# 

# This program is distributed in the hope that it will be useful,

# 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, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

from dulwich import server as dulserver

class SimpleGitUploadPackHandler(dulserver.UploadPackHandler):

    def handle(self):

        write = lambda x: self.proto.write_sideband(1, x)

        graph_walker = dulserver.ProtocolGraphWalker(self, self.repo.object_store,

            self.repo.get_peeled)

        objects_iter = self.repo.fetch_objects(

          graph_walker.determine_wants, graph_walker, self.progress,

          get_tagged=self.get_tagged)

        # we are done

        self.proto.write("0000")

dulserver.DEFAULT_HANDLERS = {

  'git-upload-pack': SimpleGitUploadPackHandler,

  'git-receive-pack': dulserver.ReceivePackHandler,

}

from dulwich.repo import Repo

from dulwich.web import HTTPGitApplication

from paste.auth.basic import AuthBasicAuthenticator

from paste.httpheaders import REMOTE_USER, AUTH_TYPE

from rhodecode.lib.utils import action_logger, is_git, invalidate_cache, \

    check_repo_fast

from webob.exc import HTTPNotFound, HTTPForbidden, HTTPInternalServerError

import logging

import os

import traceback

log = logging.getLogger(__name__)

class SimpleGit(object):

    def __init__(self, application, config):

        self.application = application

        self.config = config

        #authenticate this git request using 

        self.authenticate = AuthBasicAuthenticator('', authfunc)

    def __make_app(self):

        backend = dulserver.DictBackend({'/' + self.repo_name: Repo(self.repo_path)})

        gitserve = HTTPGitApplication(backend)

        return gitserve

    def __get_environ_user(self, environ):

        return environ.get('REMOTE_USER')

    def __get_user(self, username):

    def __get_action(self, environ):

        """

        Maps git request commands into a pull or push command.

        :param environ:

        """

        service = environ['QUERY_STRING'].split('=')

        if len(service) > 1:

            service_cmd = service[1]

            mapping = {'git-receive-pack': 'push',

                       'git-upload-pack': 'pull',

                       }

}

#content div.box table {

width:100%;

border-collapse:collapse;

margin:0;

padding:0;

}

#content div.box table th {

background:#eee;

border-bottom:1px solid #ddd;

}

#content div.box table th.left {

text-align:left;

}

#content div.box table th.right {

text-align:right;

}

#content div.box table th.center {

text-align:center;

			        <th class="left">${get_sort(_('Last change'))}</th>

			        <th class="left">${get_sort(_('Tip'))}</th>

			        <th class="left">${get_sort(_('Owner'))}</th>

			        <th class="left">${_('RSS')}</th>

			        <th class="left">${_('Atom')}</th>

	            </tr>

            </thead>

                        <tbody>

					    %for cnt,repo in enumerate(c.repos_list):

					        %if h.HasRepoPermissionAny('repository.write','repository.read','repository.admin')(repo['name'],'main page check'):

					        <tr class="parity${cnt%2}">

					            <td>

					             %if repo['repo'].dbrepo.private:

					                <img class="icon" alt="${_('private')}" src="/images/icons/lock.png"/>

					             %else:

					                <img class="icon" alt="${_('public')}" src="/images/icons/lock_open.png"/>

					             %endif  

					            ${h.link_to(repo['name'],

					                h.url('summary_home',repo_name=repo['name']))}

					            %if repo['repo'].dbrepo.fork:

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

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

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

					            	src="/images/icons/arrow_divide.png"/></a>

					            %endif

					            </td>

					            <td title="${repo['description']}">${h.truncate(repo['description'],60)}</td>

					            <td>

					            	%if repo['rev']>=0:

					            	${h.link_to('r%s:%s' % (repo['rev'],repo['tip']),

					                h.url('changeset_home',repo_name=repo['name'],revision=repo['tip']),

					                class_="tooltip",

					                tooltip_title=h.tooltip(repo['last_msg']))}

					            	%else:

					            		${_('No changesets yet')}

					            	%endif    

					            </td>

					            <td title="${repo['contact']}">${h.person(repo['contact'])}</td>

					            <td>

	<tr>

		<th class="left">${_('date')}</th>

		<th class="left">${_('author')}</th>

		<th class="left">${_('revision')}</th>

		<th class="left">${_('commit message')}</th>

		<th class="left">${_('branch')}</th>

		<th class="left">${_('tags')}</th>

		<th class="left">${_('links')}</th>

	</tr>

%for cnt,cs in enumerate(c.repo_changesets):

	<tr class="parity${cnt%2}">

		<td title="${cs.author}">${h.person(cs.author)}</td>

		<td>r${cs.revision}:${cs.short_id}</td>

		<td>

			${h.link_to(h.truncate(cs.message,60),

			h.url('changeset_home',repo_name=c.repo_name,revision=cs.short_id),

			title=cs.message)}

		</td>

		<td>

			<span class="logtags">

				<span class="branchtag">${cs.branch}</span>

			</span>

		</td>

			  	</div>

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

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

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

			  </div>

			 </div>

			 <div class="field">

			  <div class="label">

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

			  </div>

			  <div class="input-short">

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

			  </div>

			 </div>

			 <div class="field">

			  <div class="label">

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

			  </div>

			  <div class="input-short">

			      <input type="text" id="clone_url" readonly="readonly" value="hg clone ${c.clone_repo_url}" size="70"/>

			  </div>

from rhodecode import get_version

import sys

py_version = sys.version_info

requirements = [

        "Pylons>=1.0.0",

        "pygments>=1.3.0",

        "py-bcrypt",

        "babel",

    ]

classifiers = ['Development Status :: 4 - Beta',

                   'Environment :: Web Environment',

                   'Framework :: Pylons',

                   'Intended Audience :: Developers',

                   'License :: OSI Approved :: BSD License',

                   'Operating System :: OS Independent',

                   'Programming Language :: Python', ]