HOME = os.getenv('HOME', os.getenv('USERPROFILE')) or ''

        HOME_CONF = os.path.abspath(os.path.join(HOME, CONFIG_NAME))

        self._conf_name = HOME_CONF if not config_location else config_location

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

"""

    rhodecode.bin.gist

    ~~~~~~~~~~~~~~~~~~

    Gist CLI client for RhodeCode

    :created_on: May 9, 2013

    :author: marcink

    :copyright: (C) 2010-2013 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# 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/>.

from __future__ import with_statement

import os

import sys

import stat

import argparse

import fileinput

from rhodecode.bin.base import api_call, RcConf

def argparser(argv):

    usage = (

      "rhodecode-gist [-h] [--format=FORMAT] [--apikey=APIKEY] [--apihost=APIHOST] "

      "[--config=CONFIG] [--save-config] "

      "[filename or stdin use - for terminal stdin ]\n"

      "Create config file: rhodecode-gist --apikey=<key> --apihost=http://rhodecode.server --save-config"

    )

    parser = argparse.ArgumentParser(description='RhodeCode Gist cli',

                                     usage=usage)

    ## config

    group = parser.add_argument_group('config')

    group.add_argument('--apikey', help='api access key')

    group.add_argument('--apihost', help='api host')

    group.add_argument('--config', help='config file')

    group.add_argument('--save-config', action='store_true',

                       help='save the given config into a file')

    group = parser.add_argument_group('GIST')

    group.add_argument('-f', '--filename', help='set uploaded gist filename')

    group.add_argument('-p', '--private', action='store_true',

                       help='Create private Gist')

    group.add_argument('-d', '--description', help='Gist description')

    group.add_argument('-l', '--lifetime', metavar='MINUTES',

                       help='Gist lifetime in minutes, -1 (Default) is forever')

    args, other = parser.parse_known_args()

    return parser, args, other

def _run(argv):

    conf = None

    parser, args, other = argparser(argv)

    api_credentials_given = (args.apikey and args.apihost)

    if args.save_config:

        if not api_credentials_given:

            raise parser.error('--save-config requires --apikey and --apihost')

        conf = RcConf(config_location=args.config,

                      autocreate=True, config={'apikey': args.apikey,

                                               'apihost': args.apihost})

        sys.exit()

    if not conf:

        conf = RcConf(config_location=args.config, autoload=True)

        if not conf:

            if not api_credentials_given:

                parser.error('Could not find config file and missing '

                             '--apikey or --apihost in params')

    apikey = args.apikey or conf['apikey']

    host = args.apihost or conf['apihost']

    DEFAULT_FILENAME = 'gistfile1.txt'

    if other:

        # skip multifiles for now

        filename = other[0]

        if filename == '-':

            filename = DEFAULT_FILENAME

            gist_content = ''

            for line in fileinput.input():

                gist_content += line

        else:

            with open(filename, 'rb') as f:

                gist_content = f.read()

    else:

        filename = DEFAULT_FILENAME

        gist_content = None

        # little bit hacky but cross platform check where the

        # stdin comes from we skip the terminal case it can be handled by '-'

        mode = os.fstat(0).st_mode

        if stat.S_ISFIFO(mode):

            # "stdin is piped"

            gist_content = sys.stdin.read()

        elif stat.S_ISREG(mode):

            # "stdin is redirected"

            gist_content = sys.stdin.read()

        else:

            # "stdin is terminal"

            pass

    # make sure we don't upload binary stuff

    if gist_content and '\0' in gist_content:

        raise Exception('Error: binary files upload is not possible')

    filename = args.filename or filename

    if gist_content:

        files = {

            filename: {

                'content': gist_content,

                'lexer': None

            }

        }

        margs = dict(

            gist_lifetime=args.lifetime,

            gist_description=args.description,

            gist_type='private' if args.private else 'public',

            files=files

        )

        api_call(apikey, host, 'json', 'create_gist', **margs)

    return 0

def main(argv=None):

    """

    Main execution function for cli

    :param argv:

    """

    if argv is None:

        argv = sys.argv

    try:

        return _run(argv)

    except Exception, e:

        print e

        return 1

if __name__ == '__main__':

    sys.exit(main(sys.argv))

    #ADMIN GIST

    rmap.resource('gist', 'gists', controller='admin/gists',

        path_prefix=ADMIN_PREFIX)

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

"""

    rhodecode.controllers.admin.gist

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    gist controller for RhodeCode

    :created_on: May 9, 2013

    :author: marcink

    :copyright: (C) 2010-2013 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# 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/>.

import time

import logging

import traceback

import formencode

from formencode import htmlfill

from pylons import request, tmpl_context as c, url

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from rhodecode.model.forms import GistForm

from rhodecode.model.gist import GistModel

from rhodecode.model.meta import Session

from rhodecode.model.db import Gist

from rhodecode.lib import helpers as h

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.auth import LoginRequired, NotAnonymous

from rhodecode.lib.utils2 import safe_str, safe_int, time_to_datetime

from rhodecode.lib.helpers import Page

from webob.exc import HTTPNotFound

from sqlalchemy.sql.expression import or_

from rhodecode.lib.vcs.exceptions import VCSError

log = logging.getLogger(__name__)

class GistsController(BaseController):

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

    def __load_defaults(self):

        c.lifetime_values = [

            (str(-1), _('forever')),

            (str(5), _('5 minutes')),

            (str(60), _('1 hour')),

            (str(60 * 24), _('1 day')),

            (str(60 * 24 * 30), _('1 month')),

        ]

        c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]

    @LoginRequired()

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

        """GET /admin/gists: All items in the collection"""

        # url('gists')

        c.show_private = request.GET.get('private') and c.rhodecode_user.username != 'default'

        gists = Gist().query()\

            .filter(or_(Gist.gist_expires == -1, Gist.gist_expires >= time.time()))\

            .order_by(Gist.created_on.desc())

        if c.show_private:

            c.gists = gists.filter(Gist.gist_type == Gist.GIST_PRIVATE)\

                             .filter(Gist.gist_owner == c.rhodecode_user.user_id)

        else:

            c.gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)

        p = safe_int(request.GET.get('page', 1), 1)

        c.gists_pager = Page(c.gists, page=p, items_per_page=10)

        return render('admin/gists/index.html')

    @LoginRequired()

    @NotAnonymous()

    def create(self):

        """POST /admin/gists: Create a new item"""

        # url('gists')

        self.__load_defaults()

        gist_form = GistForm([x[0] for x in c.lifetime_values])()

        try:

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

            #TODO: multiple files support, from the form

            nodes = {

                form_result['filename'] or 'gistfile1.txt': {

                    'content': form_result['content'],

                    'lexer': None  # autodetect

                }

            }

            _public = form_result['public']

            gist_type = Gist.GIST_PUBLIC if _public else Gist.GIST_PRIVATE

            gist = GistModel().create(

                description=form_result['description'],

                owner=c.rhodecode_user,

                gist_mapping=nodes,

                gist_type=gist_type,

                lifetime=form_result['lifetime']

            )

            Session().commit()

            new_gist_id = gist.gist_access_id

        except formencode.Invalid, errors:

            defaults = errors.value

            return formencode.htmlfill.render(

                render('admin/gists/new.html'),

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8"

            )

        except Exception, e:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during gist creation'), category='error')

            return redirect(url('new_gist'))

        return redirect(url('gist', id=new_gist_id))

    @LoginRequired()

    @NotAnonymous()

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

        """GET /admin/gists/new: Form to create a new item"""

        # url('new_gist')

        self.__load_defaults()

        return render('admin/gists/new.html')

    @LoginRequired()

    @NotAnonymous()

    def update(self, id):

        """PUT /admin/gists/id: 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('gist', id=ID),

        #           method='put')

        # url('gist', id=ID)

    @LoginRequired()

    @NotAnonymous()

    def delete(self, id):

        """DELETE /admin/gists/id: Delete an existing item"""

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

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

        # Or using helpers:

        #    h.form(url('gist', id=ID),

        #           method='delete')

        # url('gist', id=ID)

    @LoginRequired()

    def show(self, id, format='html'):

        """GET /admin/gists/id: Show a specific item"""

        # url('gist', id=ID)

        gist_id = id

        c.gist = Gist.get_or_404(gist_id)

        #check if this gist is not expired

        if c.gist.gist_expires != -1:

            if time.time() > c.gist.gist_expires:

                log.error('Gist expired at %s' %

                          (time_to_datetime(c.gist.gist_expires)))

                raise HTTPNotFound()

        try:

            c.file_changeset, c.files = GistModel().get_gist_files(gist_id)

        except VCSError:

            log.error(traceback.format_exc())

            raise HTTPNotFound()

        return render('admin/gists/show.html')

    @LoginRequired()

    @NotAnonymous()

    def edit(self, id, format='html'):

        """GET /admin/gists/id/edit: Form to edit an existing item"""

        # url('edit_gist', id=ID)

    Permission, User, Gist

from rhodecode.model.gist import GistModel

    # perms handled inside

    def create_gist(self, apiuser, files, owner=Optional(OAttr('apiuser')),

                    gist_type=Optional(Gist.GIST_PUBLIC),

                    gist_lifetime=Optional(-1),

                    gist_description=Optional('')):

        try:

            if isinstance(owner, Optional):

                owner = apiuser.user_id

            owner = get_user_or_error(owner)

            description = Optional.extract(gist_description)

            gist_type = Optional.extract(gist_type)

            gist_lifetime = Optional.extract(gist_lifetime)

            # files: {

            #    'filename': {'content':'...', 'lexer': null},

            #    'filename2': {'content':'...', 'lexer': null}

            #}

            gist = GistModel().create(description=description,

                                      owner=owner,

                                      gist_mapping=files,

                                      gist_type=gist_type,

                                      lifetime=gist_lifetime)

            Session().commit()

            return dict(

                msg='created new gist',

                gist_url=gist.gist_url(),

                gist_id=gist.gist_access_id,

                gist_type=gist.gist_type,

                files=files.keys()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create gist')

    def update_gist(self, apiuser):

        pass

    def delete_gist(self, apiuser):

        pass

from rhodecode.lib.exceptions import NonRelativePathError

            #strip all crap out of file, just leave the basename

                nodes = {

                    node_path: {

                        'content': content

                    }

                }

                self.scm_model.create_nodes(

                    user=c.rhodecode_user.user_id, repo=c.rhodecode_db_repo,

                    message=message,

                    nodes=nodes,

                    parent_cs=c.cs,

                    author=author,

                )

            except NonRelativePathError, e:

                h.flash(_('Location must be relative path and must not '

                          'contain .. in path'), category='warning')

                return redirect(url('changeset_home', repo_name=c.repo_name,

                                    revision='tip'))

    # Gist

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_7_0 import Gist

    tbl = Gist.__table__

    tbl.create()

    #==========================================================================

    # RepoGroup

class NonRelativePathError(Exception):

    pass

import uuid

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.

    :param url to get the uuid for

    :truncate_to: truncate the basic 22 UUID to shorter version

    The IDs won't be universally unique any longer, but the probability of

    a collision will still be very low.

    """

    # Define our alphabet.

    _ALPHABET = alphabet or "23456789ABCDEFGHJKLMNPQRSTUVWXYZ"

    # If no URL is given, generate a random UUID.

    if url is None:

        unique_id = uuid.uuid4().int

    else:

        unique_id = uuid.uuid3(uuid.NAMESPACE_URL, url).int

    alphabet_length = len(_ALPHABET)

    output = []

    while unique_id > 0:

        digit = unique_id % alphabet_length

        output.append(_ALPHABET[digit])

        unique_id = int(unique_id / alphabet_length)

    return "".join(output)[:truncate_to]

        :param user: UserID, username, or User instance

        :param repository: RepoID, repository name or Repository Instance

        :param permission: PermissionID, permission_name or Permission instance