# List of modules to import when celery starts.

import sys

import os

import ConfigParser

root = os.getcwd()

sys.path.append(root)

config = ConfigParser.ConfigParser({'here':root})

config.read('%s/%s' % (root, PYLONS_CONFIG_NAME))

PYLONS_CONFIG = config

CELERY_IMPORTS = ("pylons_app.lib.celerylib.tasks",)

## Result store settings.

CELERY_RESULT_BACKEND = "database"

CELERY_RESULT_DBURI = dict(config.items('app:main'))['sqlalchemy.db1.url']

CELERY_RESULT_SERIALIZER = 'json'

    _get_repos_switcher_cached

class BaseController(WSGIController):

    def __before__(self):

        c.hg_app_version = __version__

        c.hg_app_name = config['hg_app_title']

        c.repo_name = get_repo_slug(request)

        c.cached_repo_list = _get_repos_cached()

        c.repo_switcher_list = _get_repos_switcher_cached(c.cached_repo_list)

        if c.repo_name:

        self.sa = meta.Session

    def __call__(self, environ, start_response):

        """Invoke the Controller"""

        # WSGIController.__call__ dispatches to the Controller method

        # the request is routed to. This routing information is

        # available in environ['pylons.routes_dict']

        try:

            #putting this here makes sure that we update permissions every time

            c.hg_app_user = auth.get_user(session)

            return WSGIController.__call__(self, environ, start_response)

        m = SmtpMailer(mail_from, user, passwd, mail_server,

                       mail_port, ssl, tls)

        m.send(recipients, subject, body)  

    except:

        log.error('Mail sending failed')

        log.error(traceback.format_exc())

        return False

    return True

@task

def create_repo_fork(form_data, cur_user):

    import os

    from pylons_app.model.repo_model import RepoModel

    sa = get_session()

    rm = RepoModel(sa)

    rm.create(form_data, cur_user, just_db=True, fork=True)

    repos_path = get_hg_ui_settings()['paths_root_path'].replace('*', '')

    repo_path = os.path.join(repos_path, form_data['repo_name'])

    repo_fork_path = os.path.join(repos_path, form_data['fork_name'])

    MercurialRepository(str(repo_fork_path), True, clone_url=str(repo_path))

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'].replace('*', '')

    repo = MercurialRepository(repos_path + repo_name)

# along with this program; if not, write to the Free Software

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

# MA  02110-1301, USA.

"""

Created on April 9, 2010

Model for hg app

@author: marcink

"""

from beaker.cache import cache_region

from mercurial import ui

from mercurial.hgweb.hgwebdir_mod import findrepos

from pylons.i18n.translation import _

from pylons_app.lib.auth import HasRepoPermissionAny

from pylons_app.model import meta

from pylons_app.model.db import Repository, User

from vcs.exceptions import RepositoryError, VCSError

import logging

import os

import sys

log = logging.getLogger(__name__)

try:

    from vcs.backends.hg import MercurialRepository

except ImportError:

    sys.stderr.write('You have to import vcs module')

    raise Exception('Unable to import vcs')

def _get_repos_cached_initial(app_globals, initial):

            try:

                #name = name.split('/')[-1]

                if repos_list.has_key(name):

                    raise RepositoryError('Duplicate repository name %s found in'

                                    ' %s' % (name, path))

                else:

                    repos_list[name] = MercurialRepository(path, baseui=baseui)

                    repos_list[name].name = name

                    dbrepo = None

                    if not initial:

                        dbrepo = sa.query(Repository)\

                            .options(joinedload(Repository.fork))\

                            .filter(Repository.repo_name == name)\

                            .scalar()

                    if dbrepo:

                        log.info('Adding db instance to cached list')

                        repos_list[name].dbrepo = dbrepo

                        repos_list[name].description = dbrepo.description

                        if dbrepo.user:

                            repos_list[name].contact = dbrepo.user.full_contact

                        else:

            tmp_d['last_change_sort'] = last_change[1] - last_change[0]

            tmp_d['tip'] = tip.short_id

            tmp_d['tip_sort'] = tip.revision 

            tmp_d['rev'] = tip.revision

            tmp_d['contact'] = repo.contact

            tmp_d['contact_sort'] = tmp_d['contact']

            tmp_d['repo_archives'] = list(repo._get_archives())

            tmp_d['last_msg'] = tip.message

            tmp_d['repo'] = repo

            yield tmp_d

    def get_repo(self, repo_name):

import logging

log = logging.getLogger(__name__) 

import pylons.test

__all__ = ['environ', 'url', 'TestController']

# Invoke websetup with the current config file

#SetupCommand('setup-app').run([config_file])

environ = {}

class TestController(TestCase):

    def __init__(self, *args, **kwargs):

        wsgiapp = pylons.test.pylonsapp

        config = wsgiapp.config

        self.app = TestApp(wsgiapp)

        url._push_object(URLGenerator(config['routes.map'], environ))

        self.sa = meta.Session

                      % (repo_name, fork_name) in response.session['flash'][0], 'No flash message about fork'

        #test if the fork was created in the database

        fork_repo = self.sa.query(Repository).filter(Repository.repo_name == fork_name).one()

        assert fork_repo.repo_name == fork_name, 'wrong name of repo name in new db fork repo'

        assert fork_repo.fork.repo_name == repo_name, 'wron fork parrent'

        #test if fork is visible in the list ?

        response = response.follow()

        print response