示例#1
0
    def begin(self):
        """Called before any tests are collected or run

        Loads the application, and in turn its configuration.

        """
        global pylonsapp
        path = os.getcwd()
        sys.path.insert(0, path)
        pkg_resources.working_set.add_entry(path)
        self.app = pylonsapp = loadapp('config:' + self.config_file,
                                       relative_to=path)

        # Setup the config and app_globals, only works if we can get
        # to the config object
        conf = getattr(pylonsapp, 'config')
        if conf:
            pylons.config._push_object(conf)

            if 'pylons.app_globals' in conf:
                pylons.app_globals._push_object(conf['pylons.app_globals'])

        # Initialize a translator for tests that utilize i18n
        translator = _get_translator(pylons.config.get('lang'))
        pylons.translator._push_object(translator)
示例#2
0
    def begin(self):
        """Called before any tests are collected or run

        Loads the application, and in turn its configuration.

        """
        global pylonsapp
        path = os.getcwd()
        sys.path.insert(0, path)
        pkg_resources.working_set.add_entry(path)
        self.app = pylonsapp = loadapp('config:' + self.config_file,
                                       relative_to=path)

        # Setup the config and app_globals, only works if we can get
        # to the config object
        conf = getattr(pylonsapp, 'config')
        if conf:
            pylons.config._push_object(conf)

            if 'pylons.app_globals' in conf:
                pylons.app_globals._push_object(conf['pylons.app_globals'])

        # Initialize a translator for tests that utilize i18n
        translator = _get_translator(pylons.config.get('lang'))
        pylons.translator._push_object(translator)
示例#3
0
    def setup_app_env(self, environ, start_response):
        """Setup and register all the Pylons objects with the registry
        
        After creating all the global objects for use in the request,
        :meth:`~PylonsApp.register_globals` is called to register them
        in the environment.
        
        """
        if self.log_debug:
            log.debug("Setting up Pylons stacked object globals")

        # Setup the basic pylons global objects
        req_options = self.request_options
        req = Request(environ,
                      charset=req_options['charset'],
                      unicode_errors=req_options['errors'],
                      decode_param_names=req_options['decode_param_names'])
        req.language = req_options['language']
        req.config = self.config
        req.link, req.route_dict = environ['wsgiorg.routing_args']

        response = Response(content_type=self.response_options['content_type'],
                            charset=self.response_options['charset'])
        response.headers.update(self.response_options['headers'])

        # Store a copy of the request/response in environ for faster access
        pylons_obj = PylonsContext()
        pylons_obj.config = self.config
        pylons_obj.request = req
        pylons_obj.response = response
        pylons_obj.app_globals = self.globals
        pylons_obj.h = self.helpers

        if 'routes.url' in environ:
            pylons_obj.url = environ['routes.url']

        environ['pylons.pylons'] = pylons_obj

        environ['pylons.environ_config'] = self.environ_config

        # Setup the translator object
        lang = self.config['lang']
        pylons_obj.translator = _get_translator(lang,
                                                pylons_config=self.config)

        if self.config['pylons.strict_tmpl_context']:
            tmpl_context = ContextObj()
        else:
            tmpl_context = AttribSafeContextObj()
        pylons_obj.tmpl_context = req.tmpl_context = tmpl_context

        if self._session_key in environ:
            pylons_obj.session = req.session = environ[self._session_key]
        if self._cache_key in environ:
            pylons_obj.cache = environ[self._cache_key]

        # Load the globals with the registry if around
        if 'paste.registry' in environ:
            self.register_globals(environ)
示例#4
0
文件: wsgiapp.py 项目: bluker/pylons
 def setup_app_env(self, environ, start_response):
     """Setup and register all the Pylons objects with the registry
     
     After creating all the global objects for use in the request,
     :meth:`~PylonsApp.register_globals` is called to register them
     in the environment.
     
     """
     if self.log_debug:
         log.debug("Setting up Pylons stacked object globals")
     
     
     # Setup the basic pylons global objects
     req_options = self.request_options
     req = Request(environ, charset=req_options['charset'],
                   unicode_errors=req_options['errors'],
                   decode_param_names=req_options['decode_param_names'])
     req.language = req_options['language']
     req.config = self.config
     req.link, req.route_dict = environ['wsgiorg.routing_args']
     
     response = Response(
         content_type=self.response_options['content_type'],
         charset=self.response_options['charset'])
     response.headers.update(self.response_options['headers'])
     
     # Store a copy of the request/response in environ for faster access
     pylons_obj = PylonsContext()
     pylons_obj.config = self.config
     pylons_obj.request = req
     pylons_obj.response = response
     pylons_obj.app_globals = self.globals
     pylons_obj.h = self.helpers
     
     if 'routes.url' in environ:
         pylons_obj.url = environ['routes.url']
             
     environ['pylons.pylons'] = pylons_obj
     
     environ['pylons.environ_config'] = self.environ_config
     
     # Setup the translator object
     lang = self.config['lang']
     pylons_obj.translator = _get_translator(lang, pylons_config=self.config)
     
     if self.config['pylons.strict_tmpl_context']:
         tmpl_context = ContextObj()
     else:
         tmpl_context = AttribSafeContextObj()
     pylons_obj.tmpl_context = req.tmpl_context = tmpl_context
     
     if self._session_key in environ:
         pylons_obj.session = req.session = environ[self._session_key]
     if self._cache_key in environ:
         pylons_obj.cache = environ[self._cache_key]
     
     # Load the globals with the registry if around
     if 'paste.registry' in environ:
         self.register_globals(environ)
示例#5
0
def setup_py_trans():
    global lang_setup
    import pylons
    from pylons.i18n.translation import _get_translator
    root = os.path.join(test_root, 'sample_controllers')
    lang_setup = {'pylons.paths': {'root': root}, 'pylons.package': 'sample_controllers'}
    sys.path.append(test_root)
    pylons.translator._push_object(_get_translator(None, pylons_config=lang_setup))
示例#6
0
def setup_py_trans():
    global lang_setup
    import pylons
    from pylons.i18n.translation import _get_translator
    root = os.path.join(test_root, 'sample_controllers')
    lang_setup = {'pylons.paths': {'root': root}, 'pylons.package': 'sample_controllers'}
    sys.path.append(test_root)
    pylons.translator._push_object(_get_translator(None, pylons_config=lang_setup))
示例#7
0
def set_language_context_manager(language=None, **kwargs):
    # this is stolen from the pylons test setup.
    # it will make sure the gettext-stuff is working
    translator = _get_translator(language, **kwargs)
    pylons.translator._push_object(translator)
    try:
        yield
    finally:
        pylons.translator._pop_object()
示例#8
0
 def setup_app_env(self, environ, start_response):
     """Setup and register all the Pylons objects with the registry
     
     After creating all the global objects for use in the request,
     :meth:`~PylonsApp.register_globals` is called to register them
     in the environment.
     
     """
     if self.log_debug:
         log.debug("Setting up Pylons stacked object globals")
     
     # Setup the basic pylons global objects
     req = Request(environ)
     req.language = self.request_options['language']
     
     response = Response(
         content_type=self.response_options['content_type'],
         charset=self.response_options['charset'])
     response.headers.update(self.response_options['headers'])
     
     # Store a copy of the request/response in environ for faster access
     pylons_obj = PylonsContext()
     pylons_obj.config = self.config
     pylons_obj.request = req
     pylons_obj.response = response
     pylons_obj.g = pylons_obj.app_globals = self.globals
     pylons_obj.h = self.helpers
     
     if hasattr(self, 'buffet'):
         pylons_obj.buffet = self.buffet
     
     environ['pylons.pylons'] = pylons_obj
     
     environ['pylons.environ_config'] = self.environ_config
     
     # Setup the translator object
     pylons_obj.translator = _get_translator(self.config.get('lang'))
     
     if self.config['pylons.strict_c']:
         c = ContextObj()
     else:
         c = AttribSafeContextObj()
     pylons_obj.c = c
     
     econf = self.config['pylons.environ_config']
     if econf.get('session') and econf['session'] in environ:
         pylons_obj.session = environ[econf['session']]
     elif 'beaker.session' in environ:
         pylons_obj.session = environ['beaker.session']
     if econf.get('cache') and econf['cache'] in environ:
         pylons_obj.cache = environ[econf['cache']]
     elif 'beaker.cache' in environ:
         pylons_obj.cache = environ['beaker.cache']
     
     # Load the globals with the registry if around
     if 'paste.registry' in environ:
         self.register_globals(environ)
示例#9
0
def init_stack(config=None):
    if not config:
        config = pylons.test.pylonsapp.config
    url._push_object(URLGenerator(config['routes.map'], environ))
    pylons.app_globals._push_object(config['pylons.app_globals'])
    pylons.config._push_object(config)
    pylons.tmpl_context._push_object(ContextObj())
    # Initialize a translator for tests that utilize i18n
    translator = _get_translator(pylons.config.get('lang'))
    pylons.translator._push_object(translator)
示例#10
0
def init_stack(config=None):
    if not config:
        config = pylons.test.pylonsapp.config
    url._push_object(URLGenerator(config['routes.map'], environ))
    pylons.app_globals._push_object(config['pylons.app_globals'])
    pylons.config._push_object(config)
    pylons.tmpl_context._push_object(ContextObj())
    # Initialize a translator for tests that utilize i18n
    translator = _get_translator(pylons.config.get('lang'))
    pylons.translator._push_object(translator)
示例#11
0
    def __init__(self, *args, **kwargs):
        wsgiapp = loadapp('config:test.ini', relative_to=conf_dir)
        config = wsgiapp.config
        pylons.app_globals._push_object(config['pylons.app_globals'])
        pylons.config._push_object(config)

        # Initialize a translator for tests that utilize i18n
        translator = _get_translator(pylons.config.get('lang'))
        pylons.translator._push_object(translator)

        url._push_object(URLGenerator(config['routes.map'], environ))
        self.app = TestApp(wsgiapp)
        TestCase.__init__(self, *args, **kwargs)
示例#12
0
 def __init__(self, *args, **kwargs):
     wsgiapp = loadapp('config:test.ini', relative_to=conf_dir)
     config = wsgiapp.config
     pylons.app_globals._push_object(config['pylons.app_globals'])
     pylons.config._push_object(config)
     
     # Initialize a translator for tests that utilize i18n
     translator = _get_translator(pylons.config.get('lang'))
     pylons.translator._push_object(translator)
     
     url._push_object(URLGenerator(config['routes.map'], environ))
     self.app = TestApp(wsgiapp)
     TestCase.__init__(self, *args, **kwargs)
示例#13
0
def _init_stack(config=None, environ=None):
    if not config:
        config = pylons.test.pylonsapp.config
    if not environ:
        environ = {}
    pylons.url._push_object(URLGenerator(config['routes.map'], environ or {}))
    pylons.app_globals._push_object(config['pylons.app_globals'])
    pylons.config._push_object(config)
    pylons.tmpl_context._push_object(ContextObj())
    # Initialize a translator for tests that utilize i18n
    translator = _get_translator(pylons.config.get('lang'))
    pylons.translator._push_object(translator)
    pylons.session._push_object(SessionObject(environ or {}))
    pylons.request._push_object(webob.Request.blank('', environ=environ))
示例#14
0
    def begin(self):
        """Called before any tests are collected or run

        Loads the application, and in turn its configuration.

        """
        global pylonsapp
        path = os.getcwd()
        sys.path.insert(0, path)
        pkg_resources.working_set.add_entry(path)
        self.app = pylonsapp = loadapp('config:' + self.config_file,
                                       relative_to=path)

        # Initialize a translator for tests that utilize i18n
        translator = _get_translator(pylons.config.get('lang'))
        pylons.translator._push_object(translator)
示例#15
0
    def begin(self):
        """Called before any tests are collected or run

        Loads the application, and in turn its configuration.

        """
        global pylonsapp
        path = os.getcwd()
        sys.path.insert(0, path)
        pkg_resources.working_set.add_entry(path)
        self.app = pylonsapp = loadapp('config:' + self.config_file,
                                       relative_to=path)

        # Initialize a translator for tests that utilize i18n
        translator = _get_translator(pylons.config.get('lang'))
        pylons.translator._push_object(translator)
示例#16
0
def pytest_configure():
    path = os.getcwd()
    sys.path.insert(0, path)
    pkg_resources.working_set.add_entry(path)
    pylons.test.pylonsapp = loadapp('config:test.ini', relative_to=path)

    # Setup the config and app_globals, only works if we can get
    # to the config object
    conf = getattr(pylons.test.pylonsapp, 'config')
    if conf:
        pylons.config._push_object(conf)

        if 'pylons.app_globals' in conf:
            pylons.app_globals._push_object(conf['pylons.app_globals'])

    # Initialize a translator for tests that utilize i18n
    translator = _get_translator(pylons.config.get('lang'))
    pylons.translator._push_object(translator)

    return pylons.test.pylonsapp
示例#17
0
def pytest_sessionstart(session):
    """Initialize CKAN environment.
    """
    global pylonsapp
    path = os.getcwd()
    sys.path.insert(0, path)
    pkg_resources.working_set.add_entry(path)
    pylonsapp = loadapp(
        'config:' + session.config.option.ckan_ini,
        relative_to=path,
    )

    # Initialize a translator for tests that utilize i18n
    translator = _get_translator(pylons.config.get('lang'))
    pylons.translator._push_object(translator)

    class FakeResponse:
        headers = {}  # because render wants to delete Pragma

    pylons.response._push_object(FakeResponse)
def grok_app(conf, packages=None):
    if packages is None:
        packages = []

    items = [request, tmpl_context, response, session, url]
    translator._push_object(_get_translator(None))
    config._push_object(conf)

    for item in items:
        item._push_object(object())

    zope_config = zope.configuration.config.ConfigurationMachine()
    do_grok('grokcore.component', zope_config)
    for package in packages:
        do_grok(package, zope_config)
    zope_config.execute_actions()

    translator._pop_object()
    config._pop_object()
    for item in items:
        item._pop_object()
示例#19
0
    def pylons_compatibility_tween(request):
        """
        While migrating from pylons to pyramid we need to call some pylons code
        from pyramid. For example while rendering an old template that uses the
        'c' or 'h' objects. This tween sets up the needed pylons globals.
        """
        try:
            config = rhodecode.CONFIG
            environ = request.environ
            session = request.session
            session_key = (config['pylons.environ_config'].get(
                'session', 'beaker.session'))

            # Setup pylons globals.
            pylons.config._push_object(config)
            pylons.request._push_object(request)
            pylons.session._push_object(session)
            environ[session_key] = session
            pylons.url._push_object(URLGenerator(config['routes.map'],
                                                 environ))

            # TODO: Maybe we should use the language from pyramid.
            translator = _get_translator(config.get('lang'))
            pylons.translator._push_object(translator)

            # Get the rhodecode auth user object and make it available.
            auth_user = get_auth_user(environ)
            request.user = auth_user
            environ['rc_auth_user'] = auth_user

            # Setup the pylons context object ('c')
            context = ContextObj()
            context.rhodecode_user = auth_user
            attach_context_attributes(context)
            pylons.tmpl_context._push_object(context)
            return handler(request)
        finally:
            # Dispose current database session and rollback uncommitted
            # transactions.
            meta.Session.remove()
示例#20
0
def pytest_sessionstart():
    # setup resources before any test is executed
    pylonsapp = None
    pylons.test.pylonsapp = pylonsapp
    path = os.getcwd()
    sys.path.insert(0, path)
    pkg_resources.working_set.add_entry(path)
    config_file = py.test.config.inicfg.get("test_ini")
    pylonsapp = pylons.test.pylonsapp = loadapp('config:' + config_file,
                                                relative_to=path)

    # Setup the config and app_globals, only works if we can get
    # to the config object
    conf = getattr(pylonsapp, 'config')
    if conf:
        pylons.config._push_object(conf)

        if 'pylons.app_globals' in conf:
            pylons.app_globals._push_object(conf['pylons.app_globals'])

    # Initialize a translator for tests that utilize i18n
    translator = _get_translator(pylons.config.get('lang'))
    pylons.translator._push_object(translator)
示例#21
0
文件: cli.py 项目: okfn/ckan-old
    def run_harvester(self, *args, **kwds):
        from pylons.i18n.translation import _get_translator
        import pylons

        pylons.translator._push_object(_get_translator(pylons.config.get("lang")))

        from ckan.model import HarvestingJob
        from ckan.controllers.harvesting import HarvestingJobController

        jobs = HarvestingJob.filter(status=u"New").all()
        jobs_len = len(jobs)
        jobs_count = 0
        if jobs_len:
            print "Running %s harvesting jobs..." % jobs_len
        else:
            print "There are no new harvesting jobs."
        print ""
        for job in jobs:
            jobs_count += 1
            print "Running job %s/%s: %s" % (jobs_count, jobs_len, job.id)
            self.print_harvesting_job(job)
            job_controller = HarvestingJobController(job)
            job_controller.harvest_documents()
示例#22
0
def pytest_configure():
    path = os.getcwd()
    sys.path.insert(0, path)
    pkg_resources.working_set.add_entry(path)

    # Disable INFO logging of test database creation, restore with NOTSET
    logging.disable(logging.INFO)
    pylons.test.pylonsapp = loadapp('config:kallithea/tests/test.ini', relative_to=path)
    logging.disable(logging.NOTSET)

    # Setup the config and app_globals, only works if we can get
    # to the config object
    conf = getattr(pylons.test.pylonsapp, 'config')
    if conf:
        pylons.config._push_object(conf)

        if 'pylons.app_globals' in conf:
            pylons.app_globals._push_object(conf['pylons.app_globals'])

    # Initialize a translator for tests that utilize i18n
    translator = _get_translator(pylons.config.get('lang'))
    pylons.translator._push_object(translator)

    return pylons.test.pylonsapp
示例#23
0
#Empty

import pylons
from pylons.i18n.translation import _get_translator

pylons.translator._push_object(_get_translator(pylons.config.get('lang')))
示例#24
0
def importdomains(orgid, filename, skipfirst):
    "Import domains"
    logger = importdomains.get_logger()
    results = dict(rows=[], global_error=[])
    keys = tuple(DOMAINFIELDS + DAFIELDS + DSFIELDS + ASFIELDS)
    translator = _get_translator(None)
    pylons.translator._push_object(translator)
    try:
        with open(filename, 'rU') as handle:
            dialect = csv.Sniffer().sniff(handle.read(1024))
            handle.seek(0)
            rows = csv.DictReader(handle, fieldnames=keys, dialect=dialect)
            query = Session.query(Group).filter(Group.id == orgid)
            org = query.one()
            logger.info("Importing domains from file: %s for: %s" %
                        (filename, org.name))
            try:
                count = 1
                for row in rows:
                    if skipfirst and (count == 1):
                        count += 1
                        continue
                    result = dict(id=None,
                                name=row['name'],
                                imported=False,
                                error=None)
                    try:
                        session_dict = {}
                        token = make_csrf(session_dict)
                        fields = getkeys(row)
                        post_data = dict2mdict(fields)
                        post_data.add('csrf_token', token)
                        form = AddDomainForm(post_data,
                                            csrf_context=session_dict)
                        form.organizations.query = query
                        if form.validate():
                            # insert to db
                            domain = Domain()
                            for field in form:
                                if field.name != 'csrf_token':
                                    setattr(domain, field.name, field.data)
                            domain.organizations.append(org)
                            Session.add(domain)
                            Session.commit()
                            result['id'] = domain.id
                            result['imported'] = True
                            logger.info("Imported domain: %s" % row['name'])
                            # process other data
                            process_aux(row, domain.id)
                        else:
                            logger.info("Import failed domain: %s" %
                                        row['name'])
                            if isinstance(form.errors, dict):
                                errors = []
                                for field in form.errors:
                                    themsg = u'%s: %s' % (field,
                                                unicode(form.errors[field][0]))
                                    errors.append(themsg)
                                result['error'] = u', '.join(errors)
                            else:
                                result['error'] = form.errors
                    except TypeError, err:
                        logger.info("Import failed domain: %s" % row['name'])
                        result['error'] = str(err)
                    except IntegrityError, err:
                        Session.rollback()
                        logger.info("Import failed domain: %s" % row['name'])
                        result['error'] = 'Domain already exists'
                    finally:
                        count += 1
                        results['rows'].append(result)
示例#25
0
def importdomains(orgid, filename, skipfirst):
    "Import domains"
    logger = importdomains.get_logger()
    results = dict(rows=[], global_error=[])
    keys = tuple(DOMAINFIELDS + DAFIELDS + DSFIELDS + ASFIELDS)
    translator = _get_translator(None)
    pylons.translator._push_object(translator)
    try:
        with open(filename, 'rU') as handle:
            dialect = csv.Sniffer().sniff(handle.read(1024))
            handle.seek(0)
            rows = csv.DictReader(handle, fieldnames=keys, dialect=dialect)
            query = Session.query(Group).filter(Group.id == orgid)
            org = query.one()
            logger.info("Importing domains from file: %s for: %s" %
                        (filename, org.name))
            try:
                count = 1
                for row in rows:
                    if skipfirst and (count == 1):
                        count += 1
                        continue
                    result = dict(id=None,
                                  name=row['name'],
                                  imported=False,
                                  error=None)
                    try:
                        session_dict = {}
                        token = make_csrf(session_dict)
                        fields = getkeys(row)
                        post_data = dict2mdict(fields)
                        post_data.add('csrf_token', token)
                        form = AddDomainForm(post_data,
                                             csrf_context=session_dict)
                        form.organizations.query = query
                        if form.validate():
                            # insert to db
                            domain = Domain()
                            for field in form:
                                if field.name != 'csrf_token':
                                    setattr(domain, field.name, field.data)
                            domain.organizations.append(org)
                            Session.add(domain)
                            Session.commit()
                            result['id'] = domain.id
                            result['imported'] = True
                            logger.info("Imported domain: %s" % row['name'])
                            # process other data
                            process_aux(row, domain.id)
                        else:
                            logger.info("Import failed domain: %s" %
                                        row['name'])
                            if isinstance(form.errors, dict):
                                errors = []
                                for field in form.errors:
                                    themsg = u'%s: %s' % (
                                        field, unicode(form.errors[field][0]))
                                    errors.append(themsg)
                                result['error'] = u', '.join(errors)
                            else:
                                result['error'] = form.errors
                    except TypeError, err:
                        logger.info("Import failed domain: %s" % row['name'])
                        result['error'] = str(err)
                    except IntegrityError, err:
                        Session.rollback()
                        logger.info("Import failed domain: %s" % row['name'])
                        result['error'] = 'Domain already exists'
                    finally:
                        count += 1
                        results['rows'].append(result)
示例#26
0
def importaccounts(domid, filename, skipfirst, userid):
    "import accounts"
    logger = importaccounts.get_logger()
    results = dict(rows=[], global_error=[])
    keys = tuple(ACCOUNTFIELDS + ADDRESSFIELDS)
    translator = _get_translator(None)
    pylons.translator._push_object(translator)
    try:
        with open(filename, 'rU') as handle:
            dialect = csv.Sniffer().sniff(handle.read(1024))
            handle.seek(0)
            rows = csv.DictReader(handle, fieldnames=keys, dialect=dialect)
            query = Session.query(Domain).filter(Domain.id == domid)
            domain = query.one()
            requester = Session.query(User).get(userid)
            logger.info("Importing accounts from file: %s for: %s" %
                        (filename, domain.name))
            try:
                count = 1
                for row in rows:
                    if skipfirst and (count == 1):
                        count += 1
                        continue
                    result = dict(id=None,
                                  username=row['username'],
                                  imported=False,
                                  error=None)
                    try:
                        session_dict = {}
                        token = make_csrf(session_dict)
                        fields = getkeys(row)
                        post_data = dict2mdict(fields)
                        post_data.add('password2', row['password1'])
                        post_data.add('domains', domid)
                        post_data.add('csrf_token', token)
                        form = AddUserForm(post_data,
                                           csrf_context=session_dict)
                        form.domains.query = query
                        if form.validate():
                            # db insert
                            if domain.name != form.email.data.split('@')[1]:
                                raise TypeError(
                                    'Cannot import: %s into domain: %s' %
                                    (form.email.data, domain.name))
                            user = User(form.username.data, form.email.data)
                            for attr in [
                                    'firstname', 'lastname', 'email', 'active',
                                    'account_type', 'send_report',
                                    'spam_checks', 'low_score', 'high_score',
                                    'timezone'
                            ]:
                                setattr(user, attr, getattr(form, attr).data)
                            user.local = True
                            user.set_password(form.password1.data)
                            if user.is_peleb:
                                user.domains = [domain]
                            Session.add(user)
                            Session.commit()
                            result['id'] = user.id
                            result['imported'] = True
                            logger.info("Imported account: %s" %
                                        row['username'])
                            # address add
                            add_address(row, user, requester)
                        else:
                            logger.info("Import failed account: %s" %
                                        row['username'])
                            if isinstance(form.errors, dict):
                                errors = []
                                for field in form.errors:
                                    themsg = u'%s: %s' % (
                                        field, unicode(form.errors[field][0]))
                                    errors.append(themsg)
                                result['error'] = u', '.join(errors)
                            else:
                                result['error'] = form.errors
                    except TypeError, err:
                        logger.info("Import failed account: %s" %
                                    row['username'])
                        result['error'] = str(err)
                    except IntegrityError, err:
                        Session.rollback()
                        logger.info("Import failed account: %s" %
                                    row['username'])
                        result['error'] = 'Account already exists'
                    finally:
                        count += 1
                        results['rows'].append(result)
示例#27
0
def setup_app(command, conf, vars):
    load_environment(conf.global_conf, conf.local_conf)
    
    # http://pylonshq.com/project/pylonshq/ticket/509
    from pylons.i18n.translation import _get_translator
    import pylons
    pylons.translator._push_object(_get_translator(pylons.config.get('lang')))

    from wurdig.model import meta
    meta.metadata.bind = meta.engine
    
    users = UsersFromDatabase(model)
    
    filename = os.path.split(conf.filename)[-1]
    if filename == 'test.ini':
        # Permanently drop any existing tables
        meta.metadata.drop_all(checkfirst=True)
        
    # Create the tables if they aren't there already
    meta.metadata.create_all(checkfirst=True)
    
    users.role_create("admin")
    users.user_create("admin", password=md5("admin"))
    users.user_add_role("admin", role="admin")
    
    setting_site_title = model.Setting()
    setting_site_title.key = u'site_title'
    setting_site_title.value = u'My Wurdig Blog'
    setting_site_title.description = _(u'Site Title?')
    setting_site_title.help = _(u'What is the title of this '
                                'site (ex. Jason Leveille\'s Blog)?')
    meta.Session.add(setting_site_title)
    meta.Session.flush()
    
    setting_site_tagline = model.Setting()
    setting_site_tagline.key = u'site_tagline'
    setting_site_tagline.value = u'Just Another Wurdig Blog'
    setting_site_tagline.description = _(u'Site Tagline?')
    setting_site_tagline.help = _(u'What is the tagline of this site?')
    meta.Session.add(setting_site_tagline)
    meta.Session.flush()
    
    setting_display_tagline = model.Setting()
    setting_display_tagline.key = u'display_tagline'
    setting_display_tagline.value = u'true'
    setting_display_tagline.description = _(u'Display Site Tagline?')
    setting_display_tagline.type = u'b'
    setting_display_tagline.help = _(u'Should the tagline be shown for your site?')
    meta.Session.add(setting_display_tagline)
    meta.Session.flush()
    
    setting_admin_email = model.Setting()
    setting_admin_email.key = u'admin_email'
    setting_admin_email.value = u''
    setting_admin_email.description = _(u'Administrator Email')
    setting_admin_email.help = _(u'What is the administrator email for this site?  '
                                 'This will be used for notifications, to send email, etc?')
    meta.Session.add(setting_admin_email)
    meta.Session.flush()
    
    setting_display_admin_email = model.Setting()
    setting_display_admin_email.key = u'display_admin_email'
    setting_display_admin_email.value = u'false'
    setting_display_admin_email.description = _(u'Display Admin Email?')
    setting_display_admin_email.type = u'b'
    setting_display_admin_email.help = _(u'Should the administrator email be '
                                         'display (obfuscated) publicly?')
    meta.Session.add(setting_display_admin_email)
    meta.Session.flush()
    
    setting_spamword = model.Setting()
    setting_spamword.key = u'spamword'
    setting_spamword.value = u'wurdig'
    setting_spamword.description = _(u'Your Spam Deterrent Word?')
    setting_spamword.help = _(u'If you enable Akismet this spamword '
                              'becomes irrelevant.  Otherwise, what is '
                              'your spam deterrent word (used in comments)?')
    meta.Session.add(setting_spamword)
    meta.Session.flush()
    
    setting_enable_googlesearch = model.Setting()
    setting_enable_googlesearch.key = u'enable_googlesearch'
    setting_enable_googlesearch.value = u'false'
    setting_enable_googlesearch.description = _(u'Enable Google Search?')
    setting_enable_googlesearch.type = u'b'
    setting_enable_googlesearch.help = _(u'Should Google Search be enabled?  '
                                         'If so, you\'ll need a Google Search '
                                         'Key (http://www.google.com/sitesearch/).')
    meta.Session.add(setting_enable_googlesearch)
    meta.Session.flush()
    
    setting_googlesearch_key = model.Setting()
    setting_googlesearch_key.key = u'googlesearch_key'
    setting_googlesearch_key.value = u''
    setting_googlesearch_key.description = _(u'Your Google Search Key?')
    setting_googlesearch_key.help = _(u'What is your Google Search Key '
                                      '(http://www.google.com/sitesearch/)?  '
                                      'Only relevant if you have Google search enabled.')
    meta.Session.add(setting_googlesearch_key)
    meta.Session.flush()
    
    setting_enable_googleanalytics = model.Setting()
    setting_enable_googleanalytics.key = u'enable_googleanalytics'
    setting_enable_googleanalytics.value = u'false'
    setting_enable_googleanalytics.description = _(u'Enable Google Analytics?')
    setting_enable_googleanalytics.type = u'b'
    setting_enable_googleanalytics.help = _(u'Do you want to enable Google Analytics?')
    meta.Session.add(setting_enable_googleanalytics)
    meta.Session.flush()
    
    setting_googleanalytics_key = model.Setting()
    setting_googleanalytics_key.key = u'googleanalytics_key'
    setting_googleanalytics_key.value = u''
    setting_googleanalytics_key.description = _(u'Your Google Analytics Key?')
    setting_googleanalytics_key.help = _(u'What is your Google Analytics key?')
    meta.Session.add(setting_googleanalytics_key)
    meta.Session.flush()
    
    setting_enable_akismet = model.Setting()
    setting_enable_akismet.key = u'enable_akismet'
    setting_enable_akismet.value = u'false'
    setting_enable_akismet.description = _(u'Enable Akismet Spam Detection?')
    setting_enable_akismet.type = u'b'
    setting_enable_akismet.help = _(u'Do you want to enable Akismet spam '
                                    'detection?  You\'ll need an Akismet '
                                    'API key (http://akismet.com/personal/).')
    meta.Session.add(setting_enable_akismet)
    meta.Session.flush()
    
    setting_akismet_key = model.Setting()
    setting_akismet_key.key = u'akismet_key'
    setting_akismet_key.value = u''
    setting_akismet_key.description = _(u'Your Akismet API Key?')
    setting_akismet_key.help = _(u'What is your Akismet API Key '
                                 '(http://akismet.com/personal/)?')
    meta.Session.add(setting_akismet_key)
    meta.Session.flush()
    
    setting_enable_twitter_display = model.Setting()
    setting_enable_twitter_display.key = u'enable_twitter_display'
    setting_enable_twitter_display.value = u'false'
    setting_enable_twitter_display.description = _(u'Enable Twitter Display?')
    setting_enable_twitter_display.type = u'b'
    setting_enable_twitter_display.help = _(u'Do you want to display '
                                            'your latest tweets?')
    meta.Session.add(setting_enable_twitter_display)
    meta.Session.flush()
    
    setting_twitter_screenname = model.Setting()
    setting_twitter_screenname.key = u'twitter_screenname'
    setting_twitter_screenname.value = u''
    setting_twitter_screenname.description = u'Your Twitter Screen Name?'
    setting_twitter_screenname.help = _(u'What is your Twitter screen name?')
    meta.Session.add(setting_twitter_screenname)
    meta.Session.flush()
    
    setting_enable_delicious_display = model.Setting()
    setting_enable_delicious_display.key = u'enable_delicious_display'
    setting_enable_delicious_display.value = u'false'
    setting_enable_delicious_display.description = _(u'Enable Delicious Bookmarks Display?')
    setting_enable_delicious_display.type = u'b'
    setting_enable_delicious_display.help = _(u'Do you want to display your '
                                              'Delicious bookmarks '
                                              '(http://delicious.com/)?')
    meta.Session.add(setting_enable_delicious_display)
    meta.Session.flush()
    
    setting_delicious_username = model.Setting()
    setting_delicious_username.key = u'delicious_username'
    setting_delicious_username.value = u''
    setting_delicious_username.description = _(u'Your Delicious User Name?')
    setting_delicious_username.help = _(u'What is your Delicious user name?')
    meta.Session.add(setting_delicious_username)
    meta.Session.flush()
    
    setting_enable_flickr_display = model.Setting()
    setting_enable_flickr_display.key = u'enable_flickr_display'
    setting_enable_flickr_display.value = u'false'
    setting_enable_flickr_display.description = _(u'Enable Flickr Image Display?')
    setting_enable_flickr_display.type = u'b'
    setting_enable_flickr_display.help = _(u'Do you want to display '
                                           'images from your Flickr account?')
    meta.Session.add(setting_enable_flickr_display)
    meta.Session.flush()
    
    setting_flickr_id = model.Setting()
    setting_flickr_id.key = u'flickr_id'
    setting_flickr_id.value = u''
    setting_flickr_id.description = _(u'Your Flickr ID?')
    setting_flickr_id.help = _(u'What is your Flickr ID (http://idgettr.com/)?')
    meta.Session.add(setting_flickr_id)
    meta.Session.flush()
    
    setting_flickr_web_address = model.Setting()
    setting_flickr_web_address.key = u'flickr_web_address_identifier'
    setting_flickr_web_address.value = u''
    setting_flickr_web_address.description = _(u'Your Flickr Web Address Identifier?')
    setting_flickr_web_address.help = _(u'The part of your Flickr Web Address after photos.  Ex. http://flickr.com/photos/{web_address_identifier}/?')
    meta.Session.add(setting_flickr_web_address)
    meta.Session.flush()
    
    setting_use_minified_assets = model.Setting()
    setting_use_minified_assets.key = u'use_minified_assets'
    setting_use_minified_assets.value = u'false'
    setting_use_minified_assets.description = _(u'Use Minified Assets (CSS/JS)?')
    setting_use_minified_assets.type = u'b'
    setting_use_minified_assets.help = _(u'Do you want to combine and '
                                         'minify your js/css files?  If '
                                         'you\'re unsure, don\'t do anything.')
    meta.Session.add(setting_use_minified_assets)
    meta.Session.flush()
    
    setting_use_externalposts_feed = model.Setting()
    setting_use_externalposts_feed.key = u'use_externalposts_feed'
    setting_use_externalposts_feed.value = u'false'
    setting_use_externalposts_feed.description = _(u'Use External Posts Feed (ex. Feedburner)?')
    setting_use_externalposts_feed.type = u'b'
    setting_use_externalposts_feed.help = _(u'Do you want to point your '
                                            'blog posts feed at an external URL?')
    meta.Session.add(setting_use_externalposts_feed)
    meta.Session.flush()
    
    setting_externalposts_feed_url = model.Setting()
    setting_externalposts_feed_url.key = u'externalposts_feed_url'
    setting_externalposts_feed_url.value = u''
    setting_externalposts_feed_url.description = _(u'Your External Posts Feed URL?')
    setting_externalposts_feed_url.help = _(u'What is the external URL '
                                            'that contains your post feed '
                                            '(ex. http://feeds2.feedburner.com/leveille)?')
    meta.Session.add(setting_externalposts_feed_url)
    meta.Session.flush()
    
    setting_blogroll = model.Setting()
    setting_blogroll.key = u'blogroll'
    setting_blogroll.value = u"""
    <h4>%s</h4>
    <ul>
        <li><a title="456 Berea Street" rel="external" href="http://www.456bereastreet.com/">456 Berea Street</a></li>
        <li><a title="Ben Ramsey" rel="external" href="http://benramsey.com/">Ben Ramsey</a></li>
        <li><a title="Daytime Running Lights" rel="external" href="http://jchrisa.net">Daytime Running Lights</a></li>
        <li><a title="Eric Florenzano" rel="external" href="http://www.eflorenzano.com">Eric Florenzano</a></li>
        <li><a title="Ian Bicking" rel="external" href="http://blog.ianbicking.org/">Ian Bicking</a></li>
        <li><a title="Chris Shiflett" rel="external" href="http://shiflett.org/">Chris Shiflett</a></li>
        <li><a title="Simon Willison" rel="external" href="http://simonwillison.net/">Simon Willison</a></li>
        <li><a title="Teach Me the Web" rel="external" href="http://teachmetheweb.org/">Teach Me the Web</a></li>
        <li><a title="Travis Swicegood" rel="external" href="http://www.travisswicegood.com/index.php">Travis Swicegood</a></li>
        <li><a title="Zac Gordon" rel="external" href="http://zgordon.org/">Zac Gordon</a></li>
    </ul>
    """ % _('Blogroll')
    setting_blogroll.description = _(u'Blogroll')
    setting_blogroll.type = u'ta'
    setting_blogroll.help = _(u'Your favorite links!')
    meta.Session.add(setting_blogroll)
    meta.Session.flush()

    page1 = model.Page()
    page1.title = u'About me and this site'
    page1.slug = u'about'
    page1.content = u"""
    <p>Welcome.  My name is Jason Leveille.  I currently live (with my beautiful wife and two daughters) and attend <a href="http://www.hood.edu">graduate school (<abbr title="Master of Science in Computer Science">MSCS</abbr>)</a> in Frederick, Maryland.  June 16th, 2007 I ended my <del>6</del> <ins>8</ins> year career as a <a href="http://www.qohs.org">High School</a> <abbr title="Computer Science">CS</abbr> teacher, and June 18th, 2007 I started my new career as a web software developer with <a href="http://www.blueatlas.com">Blue Atlas Interactive</a> in Germantown, Maryland.  I had been developing web applications since 2002, and finally decided that it was something I needed to be doing full time.  While developing I mostly work with PHP and JavaScript, though I have been paid to develop web applications in .net (C#), Python (Plone), classic asp, and I have dabbled in Ruby/Rails, Django, and Pylons.  I also work closely with designers to take their PSD goodies and turn them into CSS works of art.  I have also been known to focus on issues in <a href="http://www.webstandards.org/action/edutf/examples/">web standards</a> and <a href="http://www.adainfo.org/accessible/it/events.asp">accessibility</a>.</p>
    <p>If you have any questions for me about any of my posts, feel free to leave a comment.  If that is not sufficient, my email address is leveillej [at] gmail [dot] com.</p>
    <h3>ElseWhere</h3>
    <ul>
        <li><a href="http://twitter.com/jleveille">Twitter</a></li>
        <li><a href="http://del.icio.us/leveille">Del.icio.us</a></li>
    </ul>
    <h3>Disclaimer</h3>
    <p>Views and opinions expressed on this site are mine and do not necessarily reflect the views of my fantastic employer, <a href="http://www.blueatlas.com">Blue Atlas Interactive</a>.</p>
    <h3>My Office</h3>
    <div class="wurdig-caption aligncenter" style="width: 440px;"><a href="http://www.flickr.com/photos/leveilles/3273777769/"><img title="My Office" src="http://farm4.static.flickr.com/3368/3273777769_be393f175a_b.jpg" alt="Office Image 1" width="430" height="287"></a><p class="wurdig-caption-text">Office Image 1</p></div>
    <div class="wurdig-caption aligncenter" style="width: 440px;"><a href="http://www.flickr.com/photos/leveilles/3274596830/in/photostream/"><img title="Office Image 2" src="http://farm4.static.flickr.com/3300/3274596830_ac344872d7_b.jpg" alt="Office Image 2" width="430" height="287"></a><p class="wurdig-caption-text">Office Image 2</p></div>
    """
    meta.Session.add(page1)
    meta.Session.flush()
    
    page2 = model.Page()
    page2.title = u'My life as a teacher'
    page2.slug = u'teaching'
    page2.content = u'<p>I am often asked about my old teaching material (which used to be housed at http://www.my-classes.org - <a href="http://web.archive.org/web/20071216031655/http://www.my-classes.org/">wayback</a>).  <a href="http://jasonleveille.com/teacher/">My old lessons</a> are still available (I can\'t say how relevant they still are though!).  Let me know if you have any questions.</p>'
    meta.Session.add(page2)
    meta.Session.flush()
        
    search = model.Page()
    search.title = u'Search'
    search.slug = u'search'
    search.content = u"""
    <div id="cse-search-results"></div>
        <script type="text/javascript">
            var googleSearchIframeName = "cse-search-results";
            var googleSearchFormName = "cse-search-box";
            var googleSearchFrameWidth = 600;
            var googleSearchDomain = "www.google.com";
            var googleSearchPath = "/cse";
        </script>
        <script type="text/javascript" src="http://www.google.com/afsonline/show_afs_search.js">
    </script>
    """
    meta.Session.add(search)
    meta.Session.flush()
    
    post1 = model.Post()
    post1.title = u'First test post'
    post1.slug = u'first-test-post'
    post1.content = u'<p>This is the first test post</p>'
    post1.created_on = datetime.datetime(2008, 3, 17, 12, 30, 45)
    meta.Session.add(post1)
    meta.Session.flush()
    
    post5 = model.Post()
    post5.title = u'Fifth test post'
    post5.slug = u'fifth-test-post'
    post5.content = u'<p>This is the fifth test post</p>'
    post5.created_on = datetime.datetime(2008, 3, 17, 12, 30, 45)
    post5.draft = False
    post5.posted_on = datetime.datetime(2008, 3, 18, 12, 30, 45)
    meta.Session.add(post5)
    meta.Session.flush()
    
    post2 = model.Post()
    post2.title = u'Second test post'
    post2.slug = u'second-test-post'
    post2.content = u'<p>This is the second test post</p>'
    post2.created_on = datetime.datetime(2009, 3, 24, 12, 30, 45)
    post2.draft = False
    post2.posted_on = datetime.datetime(2009, 3, 24, 12, 30, 45)
    meta.Session.add(post2)
    meta.Session.flush()
    
    post3 = model.Post()
    post3.title = u'Third test post'
    post3.slug = u'third-test-post'
    post3.content = u'<p>This is the third test post</p>'
    post3.created_on = datetime.datetime(2009, 3, 25, 12, 30, 45)
    post3.draft = False
    post3.posted_on = datetime.datetime(2009, 3, 25, 12, 30, 45)
    meta.Session.add(post3)
    meta.Session.flush()

    post4 = model.Post()
    post4.title = u'Fourth test post'
    post4.slug = u'fourth-test-post'
    post4.content = u'<p>This is the fourth test post</p>'
    post4.created_on = datetime.datetime(2009, 4, 5, 12, 30, 45)
    post4.draft = False
    post4.posted_on = datetime.datetime(2009, 4, 5, 12, 30, 45)
    meta.Session.add(post4)
    meta.Session.flush()
    
    comment1 = model.Comment()
    comment1.post_id = int(2)
    comment1.content = u'This is my comment content'
    comment1.name = u'Responsible Web'
    comment1.email = u'*****@*****.**'
    comment1.url = u'http://responsibleweb.com'
    meta.Session.add(comment1)
    meta.Session.flush()

    comment2 = model.Comment()
    comment2.post_id = int(2)
    comment2.content = u'This is my second comment content'
    comment2.name = u'Responsible Web'
    comment2.email = u'*****@*****.**'
    comment2.url = u'http://responsibleweb.com'
    comment2.approved = True
    meta.Session.add(comment2)
    meta.Session.flush()

    tag1 = model.Tag()
    tag1.name = u'Pylons'
    tag1.slug = u'pylons'
    meta.Session.add(tag1)
    meta.Session.flush()

    tag2 = model.Tag()
    tag2.name = u'Python'
    tag2.slug = u'python'
    meta.Session.add(tag2)
    meta.Session.flush()

    post_x = meta.Session.query(model.Post)
    post_y = post_x.get(int(2))
    post_z = post_x.get(int(3))
    tag_x = meta.Session.query(model.Tag)
    tag_y = tag_x.filter_by(name=u'Python').first()
    tag_z = tag_x.filter_by(name=u'Pylons').first()
    post_y.tags.append(tag_y)
    post_y.tags.append(tag_z)
    post_z.tags.append(tag_z)
    meta.Session.add(post_y)
    meta.Session.add(post_z)
    meta.Session.flush()
    
    meta.Session.commit()
    log.info('Successfully set up.')
示例#28
0
文件: invite.py 项目: alkadis/vcv
def load_config(filename):
    conf = appconfig("config:" + os.path.abspath(filename) + "#content")
    config = load_environment(conf.global_conf, conf.local_conf)
    pylons.config.update(config)
    translator = _get_translator(pylons.config.get("lang"))
    pylons.translator._push_object(translator)
示例#29
0
                      [x for x in sys.path if not x.endswith("r2/r2/lib")]):
        from Captcha import Base

from pylons import app_globals as g
from r2.config.middleware import RedditApp

# unfortunately, because of the deep intertwinded dependency we have in the
# orm with app_globals, we unfortunately have to do some pylons-setup
# at import time
baseplate.events.EventQueue = Queue.Queue
wsgiapp = loadapp('config:test.ini', relative_to=conf_dir)
pylons.app_globals._push_object(wsgiapp.config['pylons.app_globals'])
pylons.config._push_object(wsgiapp.config)

# Initialize a translator for tests that utilize i18n
translator = _get_translator(pylons.config.get('lang'))
pylons.translator._push_object(translator)

url._push_object(URLGenerator(pylons.config['routes.map'], {}))


def diff_dicts(d, expected, prefix=None):
    """Given 2 dicts, return a summary of their differences

    :param dict d: dict to match from ("got")
    :param dict expected: dict to match against ("want")
    :param prefix: key prefix (used for recursion)
    :type prefix: list or None
    :rtype: dict
    :returns: mapping of flattened keys to 2-ples of (got, want)
    """
示例#30
0
def load_config(filename):
    conf = appconfig('config:' + os.path.abspath(filename) + '#content')
    load_environment(conf.global_conf, conf.local_conf)
    translator = _get_translator(pylons.config.get('lang'))
    pylons.translator._push_object(translator)
 def testSetUp(self):
     config = pylons.test.pylonsapp.config
     translator = _get_translator(config.get('lang'), pylons_config=config)
     pylons.translator._push_object(translator)
     url._push_object(URLGenerator(pylons.test.pylonsapp.config['routes.map'], environ))
示例#32
0
    ):
        from Captcha import Base

from pylons import app_globals as g
from r2.config.middleware import RedditApp

# unfortunately, because of the deep intertwinded dependency we have in the
# orm with app_globals, we unfortunately have to do some pylons-setup
# at import time
baseplate.events.EventQueue = Queue.Queue
wsgiapp = loadapp('config:test.ini', relative_to=conf_dir)
pylons.app_globals._push_object(wsgiapp.config['pylons.app_globals'])
pylons.config._push_object(wsgiapp.config)

# Initialize a translator for tests that utilize i18n
translator = _get_translator(pylons.config.get('lang'))
pylons.translator._push_object(translator)

url._push_object(URLGenerator(pylons.config['routes.map'], {}))


def diff_dicts(d, expected, prefix=None):
    """Given 2 dicts, return a summary of their differences

    :param dict d: dict to match from ("got")
    :param dict expected: dict to match against ("want")
    :param prefix: key prefix (used for recursion)
    :type prefix: list or None
    :rtype: dict
    :returns: mapping of flattened keys to 2-ples of (got, want)
    """
示例#33
0
文件: __init__.py 项目: Rumel/reddit
    with patch.object(sys, "path", [x for x in sys.path if not x.endswith("r2/r2/lib")]):
        from Captcha import Base

from pylons import app_globals as g
from r2.config.middleware import RedditApp

# unfortunately, because of the deep intertwinded dependency we have in the
# orm with app_globals, we unfortunately have to do some pylons-setup
# at import time
baseplate.events.EventQueue = Queue.Queue
wsgiapp = loadapp("config:test.ini", relative_to=conf_dir)
pylons.app_globals._push_object(wsgiapp.config["pylons.app_globals"])
pylons.config._push_object(wsgiapp.config)

# Initialize a translator for tests that utilize i18n
translator = _get_translator(pylons.config.get("lang"))
pylons.translator._push_object(translator)

url._push_object(URLGenerator(pylons.config["routes.map"], {}))


class MockAmqp(object):
    """An amqp replacement, suitable for unit tests.

    Besides providing a mock `queue` for storing all received events, this
    class provides a set of handy assert-style functions for checking what
    was previously queued.
    """

    def __init__(self, test_cls):
        self.queue = defaultdict(list)
示例#34
0
def load_config(filename):
    conf = appconfig('config:' + os.path.abspath(filename) + '#content')
    config = load_environment(conf.global_conf, conf.local_conf)
    pylons.config.update(config)
    translator = _get_translator(pylons.config.get('lang'))
    pylons.translator._push_object(translator)
示例#35
0
def importaccounts(domid, filename, skipfirst, userid):
    "import accounts"
    logger = importaccounts.get_logger()
    results = dict(rows=[], global_error=[])
    keys = tuple(ACCOUNTFIELDS + ADDRESSFIELDS)
    translator = _get_translator(None)
    pylons.translator._push_object(translator)
    try:
        with open(filename, 'rU') as handle:
            dialect = csv.Sniffer().sniff(handle.read(1024))
            handle.seek(0)
            rows = csv.DictReader(handle, fieldnames=keys, dialect=dialect)
            query = Session.query(Domain).filter(Domain.id == domid)
            domain = query.one()
            requester = Session.query(User).get(userid)
            logger.info("Importing accounts from file: %s for: %s" %
                        (filename, domain.name))
            try:
                count = 1
                for row in rows:
                    if skipfirst and (count == 1):
                        count += 1
                        continue
                    result = dict(id=None,
                                username=row['username'],
                                imported=False,
                                error=None)
                    try:
                        session_dict = {}
                        dummy = AddUserForm(dict2mdict({}),
                                csrf_context=session_dict)
                        fields = getkeys(row)
                        post_data = dict2mdict(fields)
                        post_data.add('password2', row['password1'])
                        post_data.add('domains', domid)
                        post_data.add('csrf_token',
                                    dummy.csrf_token.current_token)
                        form = AddUserForm(post_data,
                                csrf_context=session_dict)
                        form.domains.query = query
                        if form.validate():
                            #db insert
                            if domain.name != form.email.data.split('@')[1]:
                                raise TypeError(
                                    'Cannot import: %s into domain: %s' %
                                    (form.email.data, domain.name)
                                    )
                            user = User(form.username.data, form.email.data)
                            for attr in ['firstname', 'lastname', 'email',
                                'active', 'account_type', 'send_report',
                                'spam_checks', 'low_score', 'high_score',
                                'timezone']:
                                setattr(user, attr, getattr(form, attr).data)
                            user.local = True
                            user.set_password(form.password1.data)
                            if user.is_peleb:
                                user.domains = [domain]
                            Session.add(user)
                            Session.commit()
                            result['id'] = user.id
                            result['imported'] = True
                            logger.info("Imported account: %s" %
                                        row['username'])
                            #address add
                            add_address(row, user, requester)
                        else:
                            logger.info("Import failed account: %s" %
                                        row['username'])
                            if isinstance(form.errors, dict):
                                errors = []
                                for field in form.errors:
                                    themsg = u'%s: %s' % (field,
                                            unicode(form.errors[field][0]))
                                    errors.append(themsg)
                                result['error'] = u', '.join(errors)
                            else:
                                result['error'] = form.errors
                    except TypeError, err:
                        logger.info("Import failed account: %s" %
                                    row['username'])
                        result['error'] = str(err)
                    except IntegrityError, err:
                        Session.rollback()
                        logger.info("Import failed account: %s" %
                                    row['username'])
                        result['error'] = 'Account already exists'
                    finally:
                        count += 1
                        results['rows'].append(result)