# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

"""

    Pylons middleware initialization

"""

from beaker.middleware import SessionMiddleware

from routes.middleware import RoutesMiddleware

from paste.cascade import Cascade

from paste.registry import RegistryManager

from paste.urlparser import StaticURLParser

from paste.deploy.converters import asbool

from paste.gzipper import make_gzip_middleware

from pylons.middleware import ErrorHandler, StatusCodeRedirect

from pylons.wsgiapp import PylonsApp

from kallithea.lib.middleware.simplehg import SimpleHg

from kallithea.lib.middleware.simplegit import SimpleGit

from kallithea.lib.middleware.https_fixup import HttpsFixup

from kallithea.config.environment import load_environment

from kallithea.lib.middleware.wrapper import RequestWrapper

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

        default, meaning it handles its own exceptions and errors).

        Disable full_stack when this application is "managed" by

        another WSGI middleware.

    ``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)

    if asbool(config['pdebug']):

        from kallithea.lib.profiler import ProfilingMiddleware

        app = ProfilingMiddleware(app)

    if asbool(full_stack):

        from kallithea.lib.middleware.sentry import Sentry

        from kallithea.lib.middleware.errormator import Errormator

        if Errormator and asbool(config['app_conf'].get('errormator')):

            app = Errormator(app, config)

        elif Sentry:

            app = Sentry(app, config)

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

        # Note: will buffer the output in memory!

        if asbool(config['debug']):

            app = StatusCodeRedirect(app)

        else:

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

        # we want our low level middleware to get to the request ASAP. We don't

        # need any pylons stack middleware in them - especially no StatusCodeRedirect buffering

        app = SimpleHg(app, config)

        app = SimpleGit(app, config)

        app = RequestWrapper(app, config) # logging

    # Establish the Registry for this application

    app = RegistryManager(app) # thread / request-local module globals / variables

    if asbool(static_files):

        # Serve static files

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

        app = Cascade([static_app, app])

        app = make_gzip_middleware(app, global_conf, compress_level=1)

    app.config = config

    return app

    for pat in ('https://', 'http://'):

        if uri.startswith(pat):

            uri = uri[len(pat):]

            proto = pat

            break

    # remove passwords and username

    uri = uri[uri.find('@') + 1:]

    # get the port

    cred_pos = uri.find(':')

    if cred_pos == -1:

        host, port = uri, None

    else:

        host, port = uri[:cred_pos], uri[cred_pos + 1:]

    return filter(None, [proto, host, port])

def credentials_filter(uri):

    """

    Returns a url with removed credentials

    :param uri:

    """

    uri = uri_filter(uri)

    #check if we have port

    if len(uri) > 2 and uri[2]:

        uri[2] = ':' + uri[2]

    return ''.join(uri)

def get_clone_url(uri_tmpl, qualified_home_url, repo_name, repo_id, **override):

    parsed_url = urlobject.URLObject(qualified_home_url)

    decoded_path = safe_unicode(urllib.unquote(parsed_url.path.rstrip('/')))

    args = {

        'scheme': parsed_url.scheme,

        'user': '',

        'netloc': parsed_url.netloc+decoded_path,  # path if we use proxy-prefix

        'prefix': decoded_path,

        'repo': repo_name,

        'repoid': str(repo_id)

    }

    args.update(override)

    args['user'] = urllib.quote(safe_str(args['user']))

    for k, v in args.items():

        uri_tmpl = uri_tmpl.replace('{%s}' % k, v)

    # remove leading @ sign if it's present. Case of empty user

    url_obj = urlobject.URLObject(uri_tmpl)

    url = url_obj.with_netloc(url_obj.netloc.lstrip('@'))

    return safe_unicode(url)

def get_changeset_safe(repo, rev):

    """

    Safe version of get_changeset if this changeset doesn't exists for a

    repo it returns a Dummy one instead

    :param repo:

    :param rev:

    """

    from kallithea.lib.vcs.backends.base import BaseRepository

    from kallithea.lib.vcs.exceptions import RepositoryError

    from kallithea.lib.vcs.backends.base import EmptyChangeset

    if not isinstance(repo, BaseRepository):

        raise Exception('You must pass an Repository '

                        'object as first argument got %s', type(repo))

    try:

        cs = repo.get_changeset(rev)

    except (RepositoryError, LookupError):

        cs = EmptyChangeset(requested_revision=rev)

    return cs

def datetime_to_time(dt):

    if dt:

        return time.mktime(dt.timetuple())

def time_to_datetime(tm):

    if tm:

        if isinstance(tm, basestring):

            try:

                tm = float(tm)

            except ValueError:

                return

        return datetime.datetime.fromtimestamp(tm)

# Must match regexp in kallithea/public/js/base.js MentionsAutoComplete()

# Matching is gready so we don't have to look beyond the end.

def extract_mentioned_users(s):

    r"""

    Returns unique usernames from given string s that have @mention

    :param s: string to get mentions

    >>> extract_mentioned_users('@1-2.a_X,@1234 not@not @ddd@not @n @ee @ff @gg, @gg;@hh @n\n@zz,')

    ['1-2.a_X', '1234', 'ddd', 'ee', 'ff', 'gg', 'hh', 'zz']

    """

    usrs = set()

    for username in MENTIONS_REGEX.findall(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__

def fix_PATH(os_=None):

    """

    Get current active python path, and append it to PATH variable to fix issues

    of subprocess calls and different python versions

    """

    if os_ is None:

        import os

    else:

        os = os_

    cur_path = os.path.split(sys.executable)[0]

    if not os.environ['PATH'].startswith(cur_path):

        os.environ['PATH'] = '%s:%s' % (cur_path, os.environ['PATH'])

def obfuscate_url_pw(engine):

    from sqlalchemy.engine import url as sa_url

    from sqlalchemy.exc import ArgumentError

    try:

        _url = sa_url.make_url(engine or '')

    except ArgumentError:

        return engine

    if _url.password:

        _url.password = 'XXXXX'

    return str(_url)

def get_server_url(environ):

    req = webob.Request(environ)

    return req.host_url + req.script_name

def _extract_extras(env=None):

    """

    Extracts the Kallithea extras data from os.environ, and wraps it into named

    AttributeDict object

    """

    if not env:

        env = os.environ

    try:

        extras = json.loads(env['KALLITHEA_EXTRAS'])

    except KeyError:

        extras = {}

    try:

        for k in ['username', 'repository', 'locked_by', 'scm', 'make_lock',

                  'action', 'ip']:

            extras[k]

    except KeyError, e:

        raise Exception('Missing key %s in os.environ %s' % (e, extras))

    return AttributeDict(extras)

def _set_extras(extras):

    # RC_SCM_DATA can probably be removed in the future, but for compatibilty now...

    os.environ['KALLITHEA_EXTRAS'] = os.environ['RC_SCM_DATA'] = json.dumps(extras)

def unique_id(hexlen=32):

    alphabet = "23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjklmnpqrstuvwxyz"

    return suuid(truncate_to=hexlen, alphabet=alphabet)

def suuid(url=None, truncate_to=22, alphabet=None):

    """

    Generate and return a short URL safe UUID.

    If the url parameter is provided, set the namespace to the provided

    URL and generate a UUID.

div#legend_container table,

div#legend_choices table {

    width: auto !important;

}

table#permissions_manage {

    width: 0 !important;

}

table#permissions_manage span.private_repo_msg {

    font-size: 0.8em;

    opacity: 0.6;

}

table#permissions_manage td.private_repo_msg {

    font-size: 0.8em;

}

table#permissions_manage tr#add_perm_input td {

    vertical-align: middle;

}

div.gravatar {

    background-color: #FFF;

    float: left;

    margin-right: 0.7em;

    padding: 1px 1px 1px 1px;

    line-height: 0;

    -webkit-border-radius: 3px;

    -khtml-border-radius: 3px;

    border-radius: 3px;

}

div.gravatar img {

    -webkit-border-radius: 2px;

    -khtml-border-radius: 2px;

    border-radius: 2px;

}

#header, #content, #footer {

    min-width: 978px;

}

#content {

    clear: both;

    padding: 10px 10px 14px 10px;

}

#content.hover {

    padding: 55px 10px 14px 10px !important;

}

#content div.box div.title div.search {

    border-left: 1px solid #576622;

}

#content div.box div.title div.search div.input input {

    border: 1px solid #576622;

}

.btn {

    color: #515151;

    background-color: #DADADA;

    background-repeat: repeat-x;

    background-image: -khtml-gradient(linear, left top, left bottom, from(#F4F4F4),to(#DADADA) );

    background-image: -moz-linear-gradient(top, #F4F4F4, #DADADA);

    background-image: -ms-linear-gradient(top, #F4F4F4, #DADADA);

    background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #F4F4F4),color-stop(100%, #DADADA) );

    background-image: -webkit-linear-gradient(top, #F4F4F4, #DADADA);

    background-image: -o-linear-gradient(top, #F4F4F4, #DADADA);

    background-image: linear-gradient(to bottom, #F4F4F4, #DADADA);

    border-top: 1px solid #DDD;

    border-left: 1px solid #c6c6c6;

    border-right: 1px solid #DDD;

    border-bottom: 1px solid #c6c6c6;

    outline: none;

    margin: 0px 3px 3px 0px;

    -webkit-border-radius: 4px 4px 4px 4px !important;

    -khtml-border-radius: 4px 4px 4px 4px !important;

    border-radius: 4px 4px 4px 4px !important;

    cursor: pointer !important;

    padding: 3px 3px 3px 3px;

    display: inline-block;

}

ul.nav-stacked {

    margin: 20px;

    color: #393939;

    font-weight: 700;

}

ul.nav-stacked a {

    color: inherit;

}

/* make .btn inputs and buttons and divs look the same */

button.btn,

input.btn {

    font-family: inherit;

    font-size: inherit;

    line-height: inherit;

}

.btn::-moz-focus-inner {

    border: 0;

    padding: 0;

}

.btn.badge {

    cursor: default !important;

}

input[disabled].btn,

.btn.disabled {

    color: #999;

}

.btn.btn-danger.disabled {

    color: #eee;

    background-color: #c77;

    border-color: #b66

}

.btn.btn-small {

    padding: 2px 6px;

}

.btn.btn-mini {

    padding: 0px 4px;

}

.btn:focus {

    outline: none;

}

.btn:hover {

    text-decoration: none;

    color: #515151;

    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.25), 0 0 3px #FFFFFF !important;

}

.btn.badge:hover {

    box-shadow: none !important;

}

.btn.disabled:hover {

    background-position: 0;

    color: #999;

    text-decoration: none;

    box-shadow: none !important;

}

.btn.red {

    color: #fff;

    background-color: #c43c35;

    background-repeat: repeat-x;

    background-image: -khtml-gradient(linear, left top, left bottom, from(#ee5f5b), to(#c43c35));

    background-image: -moz-linear-gradient(top, #ee5f5b, #c43c35);

    background-image: -ms-linear-gradient(top, #ee5f5b, #c43c35);

    background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #ee5f5b), color-stop(100%, #c43c35));

    background-image: -webkit-linear-gradient(top, #ee5f5b, #c43c35);

    background-image: -o-linear-gradient(top, #ee5f5b, #c43c35);

    background-image: linear-gradient(to bottom, #ee5f5b, #c43c35);

    border-color: #c43c35 #c43c35 #882a25;

    border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);

}

.btn.blue {

    color: #fff;

    background-color: #339bb9;

    background-repeat: repeat-x;

    background-image: -khtml-gradient(linear, left top, left bottom, from(#5bc0de), to(#339bb9));

    background-image: -moz-linear-gradient(top, #5bc0de, #339bb9);

    background-image: -ms-linear-gradient(top, #5bc0de, #339bb9);

    background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #5bc0de), color-stop(100%, #339bb9));

    background-image: -webkit-linear-gradient(top, #5bc0de, #339bb9);

    background-image: -o-linear-gradient(top, #5bc0de, #339bb9);

    background-image: linear-gradient(to bottom, #5bc0de, #339bb9);

    border-color: #339bb9 #339bb9 #22697d;

    border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);

}

.btn.green {

    color: #fff;

    background-color: #57a957;

    background-repeat: repeat-x;

    background-image: -khtml-gradient(linear, left top, left bottom, from(#62c462), to(#57a957));

    background-image: -moz-linear-gradient(top, #62c462, #57a957);

    background-image: -ms-linear-gradient(top, #62c462, #57a957);

    background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #62c462), color-stop(100%, #57a957));

    background-image: -webkit-linear-gradient(top, #62c462, #57a957);

    background-image: -o-linear-gradient(top, #62c462, #57a957);

    background-image: linear-gradient(to bottom, #62c462, #57a957);

// branch_renderer.js - Rendering of branch DAGs on the client side

//

// Copyright 2010 Marcin Kuzminski <marcin AT python-works DOT com>

// Copyright 2008 Jesper Noehr <jesper AT noehr DOT org>

// Copyright 2008 Dirkjan Ochtman <dirkjan AT ochtman DOT nl>

// Copyright 2006 Alexander Schremmer <alex AT alexanderweb DOT de>

//

// derived from code written by Scott James Remnant <scott@ubuntu.com>

// Copyright 2005 Canonical Ltd.

//

// This software may be used and distributed according to the terms

// of the GNU General Public License, incorporated herein by reference.

var colors = [

	[ 1.0, 0.0, 0.0 ],

	[ 1.0, 1.0, 0.0 ],

	[ 0.0, 1.0, 0.0 ],

	[ 0.0, 1.0, 1.0 ],

	[ 0.0, 0.0, 1.0 ],

	[ 1.0, 0.0, 1.0 ],

	[ 1.0, 1.0, 0.0 ],

	[ 0.0, 0.0, 0.0 ]

];

function BranchRenderer(canvas_id, content_id, row_id_prefix) {

	// canvas_id is canvas to render into

	// content_id's height is applied to canvas

	// row_id_prefix is prefix that is applied to get row id's

	this.canvas = document.getElementById(canvas_id);

	var content = document.getElementById(content_id);

	if (!document.createElement("canvas").getContext)

		this.canvas = window.G_vmlCanvasManager.initElement(this.canvas);

	if (!this.canvas) { // canvas creation did for some reason fail - fail silently

		this.render = function(data,canvasWidth) {};

		return;

	}

	this.ctx = this.canvas.getContext('2d');

	this.ctx.strokeStyle = 'rgb(0, 0, 0)';

	this.ctx.fillStyle = 'rgb(0, 0, 0)';

	this.cur = [0, 0];

	this.line_width = 2.0;

	this.dot_radius = 3.5;

	this.close_x = 1.5 * this.dot_radius;

	this.close_y = 0.5 * this.dot_radius;

	this.calcColor = function(color, bg, fg) {

		color %= colors.length;

		var red = (colors[color][0] * fg) || bg;

		var green = (colors[color][1] * fg) || bg;

		var blue = (colors[color][2] * fg) || bg;

		red = Math.round(red * 255);

		green = Math.round(green * 255);

		blue = Math.round(blue * 255);

		var s = 'rgb(' + red + ', ' + green + ', ' + blue + ')';

		return s;

	}

	this.setColor = function(color, bg, fg) {

		var s = this.calcColor(color, bg, fg);

		this.ctx.strokeStyle = s;

		this.ctx.fillStyle = s;

	}

	this.render = function(data,canvasWidth) {

		var idx = 1;

		this.canvas.setAttribute('width',canvasWidth);

		this.canvas.setAttribute('height',content.clientHeight);

		// HiDPI version needs to be scaled by 2x then halved via css

		// Note: Firefox on OS X fails scaling if the canvas height is more than 32k

		if (window.devicePixelRatio && content.clientHeight * window.devicePixelRatio < 32768) {

			this.canvas.setAttribute('width', canvasWidth * window.devicePixelRatio);

			this.canvas.setAttribute('height', content.clientHeight * window.devicePixelRatio);

			this.canvas.style.width = canvasWidth + "px";

			this.canvas.style.height = content.clientHeight + "px";

			this.ctx.scale(window.devicePixelRatio, window.devicePixelRatio);

		}

		var lineCount = 1;

		for (var i=0;i<data.length;i++) {

			var in_l = data[i][1];

			for (var j in in_l) {

				var m = in_l[j][0];

				if (m > lineCount)

					lineCount = m;

			}

		}

		var edge_pad = this.dot_radius + 2;

		var base_x = canvasWidth - edge_pad;

		for (var i=0; i < data.length; ++i) {

			var row = document.getElementById(row_id_prefix+idx);

			if (row == null) {

				console.log("error: row "+row_id_prefix+idx+" not found");

				continue;

			}

			var next = document.getElementById(row_id_prefix+(idx+1));

			var extra = 0;

			cur = data[i];

			node = cur[0];

			in_l = cur[1];

			closing = cur[2];

			var rowY = row.offsetTop + row.offsetHeight/2;

			var nextY = (next == null) ? rowY + row.offsetHeight/2 : next.offsetTop + next.offsetHeight/2;

			for (var j in in_l) {

				line = in_l[j];

				start = line[0];

				end = line[1];

				color = line[2];

				// figure out if this is a dead-end;

				// we want to fade away this line

				var dead_end = true;

				if (next != null) {

					nextdata = data[i+1];

					next_l = nextdata[1];

					for (var k=0; k < next_l.length; ++k) {

						if (next_l[k][0] == end) {

							dead_end = false;

							break;

						}

					}

					if (nextdata[0][0] == end) // this is a root - not a dead end

						dead_end = false;

				}

				if (dead_end) {

					var gradient = this.ctx.createLinearGradient(x,rowY,x,nextY);

					gradient.addColorStop(0,this.calcColor(color, 0.0, 0.65));

					gradient.addColorStop(1,this.calcColor(color, 1.0, 0.0));

					this.ctx.strokeStyle = gradient;

					this.ctx.fillStyle = gradient;

				}

				// if this is a merge of differently

				// colored line, make it a gradient towards

				// the merged color

				else if (color != node[1] && start == node[0])

				{

					var gradient = this.ctx.createLinearGradient(x,rowY,x,nextY);

					gradient.addColorStop(0,this.calcColor(node[1], 0.0, 0.65));

					gradient.addColorStop(1,this.calcColor(color, 0.0, 0.65));

					this.ctx.strokeStyle = gradient;

					this.ctx.fillStyle = gradient;

				}

				else

				{

					this.setColor(color, 0.0, 0.65);

				}

				this.ctx.lineWidth=this.line_width;

				this.ctx.beginPath();

				this.ctx.moveTo(x, rowY);

				if (start == end)

				{

					this.ctx.lineTo(x,nextY+extra,3);

				}

				else

				{

					var ymid = (rowY+nextY) / 2;

					this.ctx.bezierCurveTo (x,ymid,x2,ymid,x2,nextY);

				}

				this.ctx.stroke();

			}

			column = node[0];

			color = node[1];

			this.setColor(color, 0.25, 0.75);

			if (closing)

			{

				this.ctx.fillRect(x - this.close_x, rowY - this.close_y, 2*this.close_x, 2*this.close_y);

			}

			else

			{

				this.ctx.beginPath();

				this.ctx.arc(x, rowY, this.dot_radius, 0, Math.PI * 2, true);

				this.ctx.fill();

			}

			idx++;

		}

	}

}

## -*- coding: utf-8 -*-

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

<%block name="title">

    ${_('Repository Defaults')}

</%block>

<%def name="breadcrumbs_links()">

    ${h.link_to(_('Admin'),h.url('admin_home'))}

    »

    ${_('Defaults')}

</%def>

<%block name="header_menu">

    ${self.menu('admin')}

</%block>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    ${h.form(url('default', id='defaults'),method='put')}

    <div class="form">

        <!-- fields -->

        <div class="fields">

            <div class="field">

                <div class="label">

                    <label for="default_repo_type">${_('Type')}:</label>

                </div>

                <div class="input">

                    ${h.select('default_repo_type','hg',c.backends,class_="medium")}

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="default_repo_private">${_('Private repository')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('default_repo_private',value="True")}

                    <span class="help-block">${_('Private repositories are only visible to people explicitly added as collaborators.')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="default_repo_enable_statistics">${_('Enable statistics')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('default_repo_enable_statistics',value="True")}

                    <span class="help-block">${_('Enable statistics window on summary page.')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="default_repo_enable_downloads">${_('Enable downloads')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('default_repo_enable_downloads',value="True")}

                    <span class="help-block">${_('Enable download menu on summary page.')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="default_repo_enable_locking">${_('Enable locking')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('default_repo_enable_locking',value="True")}

                    <span class="help-block">${_('Enable lock-by-pulling on repository.')}</span>

                </div>

            </div>

            <div class="buttons">

            ${h.submit('save',_('Save'),class_="btn")}

            </div>

        </div>

    </div>

    ${h.end_form()}