예제 #1
0
    def add(self, value, entry=IndexEntry, **kwargs):

        ''' Shortcut factory method to add an IndexEntry to an index. '''

        if entry == IndexEntry:
            if self.entry_base != _DEFAULT_ENTRY_PATH:
                entry = import_string(self.entry_base)
        else:
            ## validate base
            for k in self.entry_kind:
                found = False
                try:
                    m = import_string(k)
                    assert m == entry
                except AssertionError:
                    continue
                except ImportError:
                    continue
                else:
                    found = True
                    break

                if not found:
                    raise ValueError("Must pass in the EntryBase or a compatible EntryKind for this Index upon add.")

        return entry.new(self, value, **kwargs)
예제 #2
0
    def test_import_string(self):
        self.assertEqual(webapp2.import_string('webob.exc'), webob.exc)
        self.assertEqual(webapp2.import_string('webob'), webob)

        self.assertEqual(webapp2.import_string('asdfg', silent=True), None)
        self.assertEqual(webapp2.import_string('webob.asdfg', silent=True), None)

        self.assertRaises(webapp2.ImportStringError, webapp2.import_string, 'asdfg')
        self.assertRaises(webapp2.ImportStringError, webapp2.import_string, 'webob.asdfg')
예제 #3
0
    def test_import_string(self):
        self.assertEqual(webapp2.import_string('webob.exc'), webob.exc)
        self.assertEqual(webapp2.import_string('webob'), webob)

        self.assertEqual(webapp2.import_string('dfasfasdfdsfsd', silent=True), None)
        self.assertEqual(webapp2.import_string('webob.dfasfasdfdsfsd', silent=True), None)

        self.assertRaises(ImportError, webapp2.import_string, 'dfasfasdfdsfsd')
        self.assertRaises(AttributeError, webapp2.import_string, 'webob.dfasfasdfdsfsd')
예제 #4
0
    def test_import_string(self):
        self.assertEqual(webapp2.import_string('webob.exc'), webob.exc)
        self.assertEqual(webapp2.import_string('webob'), webob)

        self.assertEqual(webapp2.import_string('dfasfasdfdsfsd', silent=True),
                         None)
        self.assertEqual(
            webapp2.import_string('webob.dfasfasdfdsfsd', silent=True), None)

        self.assertRaises(ImportError, webapp2.import_string, 'dfasfasdfdsfsd')
        self.assertRaises(AttributeError, webapp2.import_string,
                          'webob.dfasfasdfdsfsd')
예제 #5
0
    def test_import_string(self):
        self.assertEqual(webapp2.import_string('webob.exc'), webob.exc)
        self.assertEqual(webapp2.import_string('webob'), webob)

        self.assertEqual(webapp2.import_string('asdfg', silent=True), None)
        self.assertEqual(webapp2.import_string('webob.asdfg', silent=True),
                         None)

        self.assertRaises(webapp2.ImportStringError, webapp2.import_string,
                          'asdfg')
        self.assertRaises(webapp2.ImportStringError, webapp2.import_string,
                          'webob.asdfg')
예제 #6
0
    def test_import_string(self):
        self.assertEqual(webapp2.import_string("webob.exc"), webob.exc)
        self.assertEqual(webapp2.import_string("webob"), webob)

        self.assertEqual(webapp2.import_string("asdfg", silent=True), None)
        self.assertEqual(webapp2.import_string("webob.asdfg", silent=True),
                         None)

        self.assertRaises(webapp2.ImportStringError, webapp2.import_string,
                          "asdfg")
        self.assertRaises(webapp2.ImportStringError, webapp2.import_string,
                          "webob.asdfg")
예제 #7
0
파일: ext.py 프로젝트: MiCHiLU/gae-tap
 def oauth_config(self):
   try:
     oauth_config = webapp2.import_string("oauth_config.{0}".format(self.request.host.replace(":", "_")))
   except webapp2.ImportStringError:
     try:
       oauth_config = webapp2.import_string("oauth_config.{0}".format(self.request.host.split(":", 1)[0]))
     except webapp2.ImportStringError as e:
       logging.warning(e)
       try:
         from oauth_config import default as oauth_config
       except ImportError:
         return
   return oauth_config
예제 #8
0
파일: admin.py 프로젝트: noughts/openfish
	def list( self, class_name ):
		# 文字列からモデルクラス、エンティティ取得
		classPath_str = "models."+ class_name.capitalize()
		klass = webapp2.import_string( classPath_str )

		# entities = klass.query( klass.is_deleted==False ).order( -klass.created_at )
		entities = klass.query()


		entities_json = []
		for entity in entities:
			entities_json.append( entity.toDict() )


		# プロパティ情報を dict に入れる
		props = []
		for prop in klass.__dict__["_properties"]:
			props.append({
				"name": prop,
				"className": getattr(klass,prop).__class__.__name__,
			})
		# logging.info( props )

		res = jinja2.get_jinja2().render_template( 'admin/list.html', **{
			"entities": entities,
			"entities_json": json.encode( entities_json ),
			"props": props,
			"class_name": class_name,
		})
		self.response.out.write( res )
예제 #9
0
파일: objects.py 프로젝트: noughts/openfish
    def show(self, class_name):
        id = self.request.get("id", None)
        if id is None:
            out = {
                "meta": functions.createMetaData(
                    status="fail", code=400, method_name="showObjects", message="parameter missing"
                )
            }
            self.response.out.write(json.encode(out))
            return

            # 文字列からモデルクラス取得
        classPath_str = "models." + functions.convertFromSnakeCaseToCamelCase(class_name)
        klass = webapp2.import_string(classPath_str)
        obj = klass.get_by_id(int(id))

        if obj and obj.is_deleted == False:
            out = {
                "meta": functions.createMetaData(status="ok", code=200, method_name="showObjects"),
                "response": {"objects": [obj.toDict(full=True)]},
            }
        else:
            out = {
                "meta": functions.createMetaData(
                    status="fail", code=400, method_name="showObjects", message="object not found"
                )
            }

        self.response.out.write(json.encode(out))
예제 #10
0
    def __getitem__(self, module):
        """Returns the configuration for a module. If it is not already
        set, loads a ``default_config`` variable from the given module and
        updates the configuration with those default values

        Every module that allows some kind of configuration sets a
        ``default_config`` global variable that is loaded by this function,
        cached and used in case the requested configuration was not defined
        by the user.

        :param module:
            The module name.
        :returns:
            A configuration value.
        """
        if module not in self.loaded:
            # Load default configuration and update config.
            values = webapp2.import_string(module + '.default_config',
                                           silent=True)
            if values:
                self.setdefault(module, values)

            self.loaded.append(module)

        try:
            return dict.__getitem__(self, module)
        except KeyError:
            raise KeyError('Module %r is not configured.' % module)
예제 #11
0
    def __getitem__(self, module):
        """Returns the configuration for a module. If it is not already
        set, loads a ``default_config`` variable from the given module and
        updates the configuration with those default values

        Every module that allows some kind of configuration sets a
        ``default_config`` global variable that is loaded by this function,
        cached and used in case the requested configuration was not defined
        by the user.

        :param module:
            The module name.
        :returns:
            A configuration value.
        """
        if module not in self.loaded:
            # Load default configuration and update config.
            values = webapp2.import_string(module + '.default_config',
                                           silent=True)
            if values:
                self.setdefault(module, values)

            self.loaded.append(module)

        try:
            return dict.__getitem__(self, module)
        except KeyError:
            raise KeyError('Module %r is not configured.' % module)
예제 #12
0
def readConfig(config=_config):
    ''' Parses extra config files and combines into one global config. '''

    global _compiled_config
    from webapp2 import import_string
    if _compiled_config is not None:
        return _compiled_config
    else:
        if config['apptools.system'].get(
                'include', False) is not False and len(
                    config['apptools.system']['include']) > 0:
            systemLog('Considering system config includes...')
            for name, configpath in config['apptools.system']['include']:
                systemLog('Checking include "' + str(name) + '" at path "' +
                          str(configpath) + '".')
                try:
                    for key, cfg in import_string(
                            '.'.join(configpath.split('.') +
                                     ['config'])).items():
                        config[key] = cfg
                except Exception, e:
                    systemLog('Encountered exception of type "' +
                              str(e.__class__) +
                              '" when trying to parse config include "' +
                              str(name) + '" at path "' + str(configpath))
                    if debug:
                        raise
                    else:
                        continue
        if len(config) > 0 and _compiled_config is None:
            _compiled_config = config

        return config
예제 #13
0
 def __init__(self, *args, **kwargs):
   super(BaseTestCase, self).__init__(*args, **kwargs)
   try:
     app = webapp2.import_string('main.app')
   except webapp2.ImportStringError:
     app = None
   self.app = app
예제 #14
0
    def user_model(self):
        """Configured user model."""
        cls = self.config['user_model']
        if isinstance(cls, basestring):
            cls = self.config['user_model'] = webapp2.import_string(cls)

        return cls
예제 #15
0
파일: __init__.py 프로젝트: MiCHiLU/gae-tap
def get_api():
  import endpoints
  api_services = list()
  for api in config.API:
    module = webapp2.import_string(api)
    api_services.extend(module.api_services)
  return endpoints.api_server(api_services)
예제 #16
0
파일: auth.py 프로젝트: mohan3d/webapp2
    def user_model(self):
        """Configured user model."""
        cls = self.config['user_model']
        if isinstance(cls, six.string_types):
            cls = self.config['user_model'] = webapp2.import_string(cls)

        return cls
예제 #17
0
파일: objects.py 프로젝트: noughts/openfish
    def create(self, class_name):
        logging.info(self.request.arguments())
        if self.checkModel(class_name) == False:
            return

        if models.BlackList.checkBanned():
            return

            # 文字列からモデルクラス、エンティティ取得
        classPath_str = "models." + functions.convertFromSnakeCaseToCamelCase(class_name)
        klass = webapp2.import_string(classPath_str)

        # マスタデータかどうかチェック & マスターデータだったら管理者以外は作成できないように。
        if klass.isMasterData == True and users.is_current_user_admin() == False:
            logging.warn("管理者以外がマスタデータを作成しようとしました")
            return False

            # 保存開始
        entity = klass()
        self.setPropertyFromRequestData(entity, self.request)
        entity.put()

        # 出力
        out = {
            "meta": functions.createMetaData(status="ok", code=200, method_name="createCustomObject"),
            "response": {"objects": [entity.toDict()]},
        }
        self.response.out.write(json.encode(out))
예제 #18
0
def custom_dispatcher(router, request, response):
    route, args, kwargs = rv = router.match(request)
    request.route, request.route_args, request.route_kwargs = rv

    handler = route.handler
    if isinstance(handler, basestring):
        handler, args, kwargs = parse_handler_template(request, handler, args, kwargs)
        # debug logging
        # logging.info('handler is %s' % handler)
        # logging.info(request.route_args)
        # logging.info(request.route_kwargs)
        # for x in request.params:
        #     logging.info('Param is %s' % x)
        # logging.info(args)
        # logging.info(kwargs)
        try:
            handler = webapp2.import_string(handler)
            # Module, Controller, Action 文字列格納
            handler.adapted_handler_spec = kwargs
            # jinjaテンプレート定義
            handler.JINJA_ENVIRONMENT = jinja2.Environment(
                loader=jinja2.FileSystemLoader(
                    spy_setting.MODULES_DIR + "/" + kwargs["module"] + "/views/templates/" + kwargs["controller"]
                ),
                extensions=["jinja2.ext.autoescape"],
            )

            router.handlers[handler] = handler
        except webapp2.ImportStringError:
            webapp2.abort(404)

    return router.adapt(handler)(request, response)
예제 #19
0
    def user_model(self):
        """Configured user model."""
        cls = self.config["user_model"]
        if isinstance(cls, str):
            cls = self.config["user_model"] = webapp2.import_string(cls)

        return cls
예제 #20
0
def custom_dispatcher(router, request, response):
    route, args, kwargs = rv = router.match(request)
    request.route, request.route_args, request.route_kwargs = rv

    handler = route.handler
    if isinstance(handler, basestring):
        handler, args, kwargs = parse_handler_template(request, handler, args,
                                                       kwargs)
        # debug logging
        # logging.info('handler is %s' % handler)
        # logging.info(request.route_args)
        # logging.info(request.route_kwargs)
        # for x in request.params:
        #     logging.info('Param is %s' % x)
        # logging.info(args)
        # logging.info(kwargs)
        try:
            handler = webapp2.import_string(handler)
            # Module, Controller, Action 文字列格納
            handler.adapted_handler_spec = kwargs
            # jinjaテンプレート定義
            handler.JINJA_ENVIRONMENT = jinja2.Environment(
                loader=jinja2.FileSystemLoader(spy_setting.MODULES_DIR + '/' +
                                               kwargs['module'] +
                                               '/views/templates/' +
                                               kwargs['controller']),
                extensions=['jinja2.ext.autoescape'])

            router.handlers[handler] = handler
        except webapp2.ImportStringError:
            webapp2.abort(404)

    return router.adapt(handler)(request, response)
예제 #21
0
def readConfig(config=_config):

    ''' Parses extra config files and combines into one global config. '''

    global _compiled_config
    from webapp2 import import_string
    if _compiled_config is not None:
        return _compiled_config
    else:
        if config['apptools.system'].get('include', False) is not False and len(config['apptools.system']['include']) > 0:
            systemLog('Considering system config includes...')
            for name, configpath in config['apptools.system']['include']:
                systemLog('Checking include "' + str(name) + '" at path "' + str(configpath) + '".')
                try:
                    for key, cfg in import_string('.'.join(configpath.split('.') + ['config'])).items():
                        config[key] = cfg
                except Exception, e:
                    systemLog('Encountered exception of type "' + str(e.__class__) + '" when trying to parse config include "' + str(name) + '" at path "' + str(configpath))
                    if debug:
                        raise
                    else:
                        continue
        if len(config) > 0 and _compiled_config is None:
            _compiled_config = config

        return config
예제 #22
0
파일: reports.py 프로젝트: noughts/openfish
	def create( self ):
		target_model = self.request.get( 'target_model', None );
		target_id = self.request.get( 'target_id', None );

		# パラメータが足りなかったらエラー
		if target_model is None or target_id is None:
			message = "parameter missing"
			logging.warn( message );
			out = {"meta": functions.createMetaData( status="fail", code=400, method_name="createReport", message=message )};
			self.response.out.write( json.encode(out) )
			return

		# 文字列からターゲットのモデルクラス取得
		classPath_str = "models."+ target_model.capitalize()
		klass = webapp2.import_string( classPath_str )
		target_obj = klass.get_by_id( int(target_id) );

		# ターゲットオブジェクトがなければエラー	
		if target_obj is None:
			message = "target object not found"
			logging.warn( message );
			out = {"meta": functions.createMetaData( status="fail", code=400, method_name="createReport", message=message )};
			self.response.out.write( json.encode(out) )
			return

		# 保存
		entity = models.Report()
		entity.target_key = target_obj.key
		entity.user_key = self.user.key if self.user else None
		entity.put();

		# 出力
		out = {
			"meta": functions.createMetaData( status="ok", code=200, method_name="createReport" ),
			"response": {
				"reports":[
					entity.toDict(),
				],
			},
		};
		self.response.out.write( json.encode(out) )

		# 管理者にメール
		sender_address = "*****@*****.**"
		recipient = "*****@*****.**"
		subject = "通報を確認してください。"
		targetKey_str = str( target_obj.key.id() )
		modelName = target_model.capitalize().encode()
		gql = "SELECT * FROM "+ modelName +" where __key__ = Key( '"+ modelName +"', "+ targetKey_str +" )"

		body = """
通報がありました。
ターゲットのkeyは %(targetKey_str)s です

検索用 GQL は以下のとおりです。
%(gql)s

""" % locals()
		mail.send_mail( sender_address, recipient, subject, body )
예제 #23
0
def load_inherited_models(app):
    """ Load correct modules to resolve polymodels
    Returns the modules loaded
    """
    model_modules = []
    for game_name, game in app.config['games'].iteritems():
        model_modules.append(webapp2.import_string(game['model']))
    return model_modules
예제 #24
0
파일: likes.py 프로젝트: noughts/openfish
	def create( self ):
		target_model = self.request.get( 'target_model', None );
		target_id = self.request.get( 'target_id', None );

		# パラメータが足りなかったらエラー
		if target_model is None or target_id is None:
			message = "parameter missing"
			logging.warn( message );
			out = {"meta": functions.createMetaData( status="fail", code=400, method_name="createLike", message=message )};
			self.response.out.write( json.encode(out) )
			return

		# ゲストならエラー
		if self.user is None:
			message = "login required"
			logging.warn( message );
			out = {"meta": functions.createMetaData( status="fail", code=401, method_name="createLike", message=message )};
			self.response.out.write( json.encode(out) )
			return

		# 文字列からターゲットのモデルクラス取得
		classPath_str = "models."+ target_model.capitalize()
		klass = webapp2.import_string( classPath_str )
		target_obj = klass.get_by_id( int(target_id) );

		# ターゲットオブジェクトがなければエラー	
		if target_obj is None:
			message = "target object not found"
			logging.warn( message );
			out = {"meta": functions.createMetaData( status="fail", code=400, method_name="createLike", message=message )};
			self.response.out.write( json.encode(out) )
			return

		# 重複チェック
		query = models.Like.query( models.Like.target_key==target_obj.key, models.Like.user_key==self.user.key, models.Like.is_deleted==False )
		if query.get():
			message = "already liked"
			logging.warn( message );
			out = {"meta": functions.createMetaData( status="fail", code=400, method_name="createLike", message=message )};
			self.response.out.write( json.encode(out) )
			return			

		# 保存
		entity = models.Like()
		entity.target_key = target_obj.key
		entity.user_key = self.user.key
		entity.put();

		# 出力
		out = {
			"meta": functions.createMetaData( status="ok", code=200, method_name="createLike" ),
			"response": {
				"likes":[
					entity.toDict(),
				],
			},
		};
		self.response.out.write( json.encode(out) )
예제 #25
0
def import_class(input_cls):
    if not isinstance(input_cls, str):
        # It's a class - return as-is
        return input_cls

    try:
        input_cls = webapp2.import_string(input_cls)
        return input_cls
    except Exception, exc:
        # Couldn't import the class
        raise ValueError("Couldn't import the model class '%s': %s: %s" %
                         (input_cls, Exception, exc))
예제 #26
0
	def create( self ):
		target_model = self.request.get( 'target_model', None );
		target_id = self.request.get( 'target_id', None );
		content = self.request.get( 'content', None );
		rating = self.request.get( 'rating', None );


		# パラメータが足りなかったらエラー
		if content is None or target_model is None or target_id is None:
			message = "parameter missing"
			logging.error( message )
			out = {
				"meta": functions.createMetaData( status="fail", code=400, method_name="createComment", message=message ),
			};
			self.response.out.write( json.encode(out) )
			return

		# 文字列からモデルクラス取得
		classPath_str = "models."+ target_model.capitalize()
		klass = webapp2.import_string( classPath_str )
		target_obj = klass.get_by_id( int(target_id) );


		# ターゲットオブジェクトがなければエラー	
		if target_obj is None:
			message = target_model +"#"+ target_id +" is not found"
			logging.error( message )
			out = {
				"meta": functions.createMetaData( status="fail", code=400, method_name="createComment", message=message ),
			};
			self.response.out.write( json.encode(out) )
			return

		# 保存
		comment = models.Comment()
		comment.content = content
		comment.rating = rating
		comment.target_key = target_obj.key
		if self.user:
			comment.user_key = self.user.key
		comment.put();

		# 出力
		out = {
			"meta": functions.createMetaData( status="ok", code=200, method_name="createComment" ),
			"response": {
				"comments":[
					comment.toDict(),
				],
			},
		};
		self.response.out.write( json.encode(out) )
예제 #27
0
파일: ext.py 프로젝트: MiCHiLU/gae-tap
def get_resource_code(resources):
  try:
    import fanstatic
  except ImportError:
    return ""
  needed = fanstatic.NeededResources(**tap.config.FANSTATIC)
  for resource in resources:
    if isinstance(resource, basestring):
      resource = webapp2.import_string(resource, silent=True)
      if resource is None:
        continue
    needed.need(resource)
  return needed.render_inclusions(needed.resources())
예제 #28
0
    def set_timezone_selector(self, func):
        """Sets the function that defines the timezone for a request.

        :param func:
            A callable that receives (request, store) and returns the timezone
            for a request.
        """
        if func is None:
            func = self._timezone_selector
        elif isinstance(func, basestring):
            func = webapp2.import_string(func)

        self.timezone_selector = func
예제 #29
0
        def __call__(self, request, remote_path, remote_method):

            ''' Handle a remote service call. '''

            global _middleware_cache

            self.request = request
            if request.method.lower() == 'options':
                return self.options()

            # Extract response
            request.clock = {}
            request.clock['threadstart'] = time.time()
            response = request.response

            # Manufacture service + handler
            service = self.service_factory()

            # Consider service middleware
            middleware = self._servicesConfig.get('middleware', False)
            if middleware is not False and len(middleware) > 0:

                for name, cfg in middleware:
                    self.logging.debug('Considering ' + str(name) + ' middleware...')
                    if cfg['enabled'] is True:
                        try:
                            if name not in _middleware_cache or ((not config) or config.debug):
                                middleware_class = webapp2.import_string(cfg['path'])
                            else:
                                middleware_class = _middleware_cache[name]

                            middleware_object = middleware_class(debug=cfg['debug'], config=self._servicesConfig, opts=cfg.get('args', {}))
                            service.middleware[name] = middleware_object

                            if hasattr(middleware_object, 'before_request'):
                                service, request, response = middleware_object.before_request(service, request, response)
                                continue
                            else:
                                self.logging.debug('Middleware ' + str(name) + ' does not have pre_request method. Continuing.')
                                continue

                        except Exception, e:
                            self.logging.error('Middleware "' + str(name) + '" raise an unhandled exception of type "' + str(e) + '".')
                            if (not config) or config.debug:
                                raise
                            else:
                                continue

                    else:
                        self.logging.debug('Middleware ' + str(name) + ' is disabled.')
                        continue
예제 #30
0
파일: __init__.py 프로젝트: MiCHiLU/gae-tap
def get_app():
  config_dict = config_to_dict(config)
  config_dict.update({
    "webapp2_extras.jinja2": {
      "compiled_path": tuple([os.path.join(ROOT_DIR_PATH, path) for path in config.JINJA2_COMPILED_PATH]),
      "template_path": tuple([os.path.join(ROOT_DIR_PATH, path) for path in config.JINJA2_TEMPLATE_PATH]),
      "environment_args": {"extensions": ["jinja2.ext.i18n"]},
      "force_compiled": config.JINJA2_FORCE_COMPILED,
    },
    "webapp2_extras.sessions": {
      "cookie_name": "__s",
      "secret_key": config.SECRET_KEY,
      "session_max_age": config.SESSION_MAX_AGE,
    },
  })
  config_WEBAPP2_CONFIG = config_dict.pop("WEBAPP2_CONFIG")
  if config_WEBAPP2_CONFIG is not None:
    config_dict.update(config_WEBAPP2_CONFIG)
  routes_list = list()
  routes_list.extend(config.ROUTES)
  routes_list.extend((
    webapp2.Route("/oauth/signout", handler="tap.ext.OAuth:_signout", name="oauth_signout"),
    webapp2.Route("/oauth/<provider>", handler="tap.ext.OAuth:_simple_auth", name="oauth_signin"),
    webapp2.Route("/oauth/<provider>/callback", handler="tap.ext.OAuth:_auth_callback", name="oauth_callback"),
    webapp2.Route("/_tap/i18n/<domain>.<language>.js", "tap.ext.I18Njs", name="I18Njs"),
  ))
  if config.BANG_REDIRECTOR:
    routes_list.append(webapp2.Route("/!<key:[^/]+>", "tap.ext.BangRedirector", name="bang-redirector"))
  for domain, values in config.APP.viewitems():
    app_routes_by_domain = list()
    for value in values:
      prefix, app, namespace = (value + (None,))[:3]
      module = webapp2.import_string(app)
      if hasattr(module, "routes"):
        app_routes = module.routes
      else:
        logging.warning("{0} has not `routes`".format(module))
        continue
      if namespace is not None:
        setattr(module, NAMESPACE_KEY, namespace)
      if prefix:
        app_routes = [routes.PathPrefixRoute(prefix, app_routes)]
      app_routes_by_domain.extend(app_routes)
    if domain:
      app_routes_by_domain = [routes.DomainRoute(domain, app_routes_by_domain)]
    routes_list.extend(app_routes_by_domain)
  if config.DRIVE_PROXY_UID is not None:
    routes_list.append(routes.DomainRoute(r"<domain:^.+?\.[a-zA-Z]{2,5}$>", [webapp2.Route(r"<path:.*>", "tap.ext.DriveProxy")]))
  elif config.DROPBOX_PROXY_UID is not None:
    routes_list.append(routes.DomainRoute(r"<domain:^.+?\.[a-zA-Z]{2,5}$>", [webapp2.Route(r"<path:.*>", "tap.ext.DropboxProxy")]))
  return webapp2.WSGIApplication(routes=routes_list, debug=config.DEBUG, config=config_dict)
예제 #31
0
    def set_timezone_selector(self, func):
        """Sets the function that defines the timezone for a request.

        :param func:
            A callable that receives (store, request) and returns the timezone
            for a request.
        """
        if func is None:
            self.timezone_selector = self.default_timezone_selector
        else:
            if isinstance(func, basestring):
                func = webapp2.import_string(func)

            self.timezone_selector = func.__get__(self, self.__class__)
예제 #32
0
파일: i18n.py 프로젝트: startup-one/cogofly
    def set_timezone_selector(self, func):
        """Sets the function that defines the timezone for a request.

        :param func:
            A callable that receives (store, request) and returns the timezone
            for a request.
        """
        if func is None:
            self.timezone_selector = self.default_timezone_selector
        else:
            if isinstance(func, six.string_types):
                func = webapp2.import_string(func)

            self.timezone_selector = func.__get__(self, self.__class__)
예제 #33
0
    def get_backend(self, name):
        """Returns a configured session backend, importing it if needed.

        :param name:
            The backend keyword.
        :returns:
            A :class:`BaseSessionFactory` subclass.
        """
        backends = self.config['backends']
        backend = backends[name]
        if isinstance(backend, basestring):
            backend = backends[name] = webapp2.import_string(backend)

        return backend
예제 #34
0
파일: sessions.py 프로젝트: tolsac/webapp3
    def get_backend(self, name):
        """Returns a configured session backend, importing it if needed.

        :param name:
            The backend keyword.
        :returns:
            A :class:`BaseSessionFactory` subclass.
        """
        backends = self.config['backends']
        backend = backends[name]
        if isinstance(backend, six.string_types):
            backend = backends[name] = webapp2.import_string(backend)

        return backend
예제 #35
0
파일: objects.py 프로젝트: noughts/openfish
    def query(self, class_name):
        if self.checkModel(class_name) == False:
            return

        page = self.request.get("page", 1)
        per_page = self.request.get("per_page", 10)
        limit = self.request.get("limit", 100)
        skip = self.request.get("skip", 0)
        where = self.request.get("where")
        order = self.request.get("order")
        mine = self.request.get("mine", None)
        response_json_depth = self.request.get("response_json_depth", 3)

        # 出力ひな形作成
        out = {
            "meta": functions.createMetaData(status="ok", code=200, method_name="queryCustomObjects"),
            "response": {"objects": []},
        }

        # 文字列からモデルクラス取得
        classPath_str = "models." + functions.convertFromSnakeCaseToCamelCase(class_name)
        klass = webapp2.import_string(classPath_str)

        gql_str = ""
        if where:
            gql_str = "WHERE " + where + " AND"
        else:
            gql_str = "WHERE"
        gql_str += " is_deleted=False"

        # モデルに is_public プロパティがあれば、それを暗黙で考慮する
        if hasattr(klass, "is_public") == True:
            gql_str += " AND is_public=True"

            # mine フラグがあったら自分の投稿したエントリーをフィルタ
        if (mine == "true") and (self.user is not None):
            gql_str += " AND user_key=" + self.user.key.id()

        if order:
            gql_str = gql_str + " ORDER BY " + order

        q = klass.gql(gql_str)
        results = q.fetch(int(limit))
        klass.prefetchReferences(results)

        for result in results:
            out["response"]["objects"].append(result.toDict(full=False))

        self.response.out.write(json.encode(out))
예제 #36
0
파일: i18n.py 프로젝트: startup-one/cogofly
    def set_locale_selector(self, func):
        """Sets the function that defines the locale for a request.

        :param func:
            A callable that receives (store, request) and returns the locale
            for a request.
        """
        if func is None:
            self.locale_selector = self.default_locale_selector
        else:
            if isinstance(func, six.string_types):
                func = webapp2.import_string(func)

            # Functions are descriptors, so bind it to this instance with
            # __get__.
            self.locale_selector = func.__get__(self, self.__class__)
예제 #37
0
    def set_locale_selector(self, func):
        """Sets the function that defines the locale for a request.

        :param func:
            A callable that receives (store, request) and returns the locale
            for a request.
        """
        if func is None:
            self.locale_selector = self.default_locale_selector
        else:
            if isinstance(func, basestring):
                func = webapp2.import_string(func)

            # Functions are descriptors, so bind it to this instance with
            # __get__.
            self.locale_selector = func.__get__(self, self.__class__)
예제 #38
0
파일: services.py 프로젝트: TYP30/apptools
	def __call__(self, request, remote_path, remote_method):
		
		''' Handle a remote service call. '''

		global _middleware_cache
		global_debug = config.debug

		## Extract response
		response = request.response

		## Manufacture service + handler
		service = self.service_factory()
		service._initializeRemoteService()

		## Consider service middleware
		middleware = self.servicesConfig.get('middleware', False)
		if middleware is not False and len(middleware) > 0:

			for name, cfg in middleware:
				self.log('Considering '+str(name)+' middleware...')
				if cfg['enabled'] is True:
					try:
						if name not in _middleware_cache or config.debug:
							middleware_class = webapp2.import_string(cfg['path'])
						else:
							middleware_class = _middleware_cache[name]

						middleware_object = middleware_class(debug=cfg['debug'], config=self.servicesConfig, opts=cfg.get('args', {}))
						service.middleware[name] = middleware_object

						if hasattr(middleware_object, 'before_request'):
							service, request, response = middleware_object.before_request(service, request, response)
							continue
						else:
							self.log('Middleware '+str(name)+' does not have pre_request method. Continuing.')
							continue

					except Exception, e:
						self.error('Middleware "'+str(name)+'" raise an unhandled exception of type "'+str(e)+'".')
						if config.debug:
							raise
						else:
							continue

				else:
					self.log('Middleware '+str(name)+' is disabled.')
					continue
예제 #39
0
	def query( self ):
		target_model = self.request.get( 'target_model', None );
		target_id = self.request.get( 'target_id', None );

		page = self.request.get( "page", 1 );
		per_page = self.request.get( "per_page", 10 );
		limit = self.request.get( "limit", 100 );
		skip = self.request.get( "skip", 0 );
		where = self.request.get( "where" );
		order = self.request.get( "order" );
		response_json_depth = self.request.get( "response_json_depth", 3 );


		# 文字列からモデルクラス取得
		classPath_str = "models."+ target_model.capitalize()
		klass = webapp2.import_string( classPath_str )


		gql_str = ""
		if where:
			gql_str = "WHERE "+ where +" AND is_deleted=False"
		else:
			gql_str = "WHERE is_deleted=False"
		gql_str = gql_str +" AND target_key = key('%s',%d)" % ( target_model.capitalize(), int(target_id) )


		if order:
			gql_str = gql_str +" ORDER BY "+ order


		q = models.Comment.gql( gql_str )
		results = q.fetch( int(limit) )
		klass.prefetchReferences( results )

		# 出力ひな形作成
		out = {
			"meta": functions.createMetaData( status="ok", code=200, method_name="queryComments" ),
			"response": {
				"comments":[],
			},
		};

		for result in results:
			out["response"]["comments"].append( result.toDict( full=False ) )

		self.response.out.write( json.encode(out) )
예제 #40
0
def _normalize_services(mixed_services):
    if isinstance(mixed_services, dict):
        mixed_services = mixed_services.iteritems()

    services = []
    for service_item in mixed_services:
        if isinstance(service_item, (list, tuple)):
            path, service = service_item
        else:
            path = None
            service = service_item

        if isinstance(service, basestring):
            # Lazily import the service class.
            service = webapp2.import_string(service)

        services.append((path, service))

    return services
예제 #41
0
def _normalize_services(mixed_services):
    if isinstance(mixed_services, dict):
        mixed_services = mixed_services.iteritems()

    services = []
    for service_item in mixed_services:
        if isinstance(service_item, (list, tuple)):
            path, service = service_item
        else:
            path = None
            service = service_item

        if isinstance(service, basestring):
            # Lazily import the service class.
            service = webapp2.import_string(service)

        services.append((path, service))

    return services
예제 #42
0
def get_rules():
    """Returns a list of URL rules for the application. The list can be
    defined entirely here or in separate ``urls.py`` files.

    :param app:
        The WSGI application instance.
    :return:
        A list of class:`tipfy.Rule` instances.
    """
    #  Here we show an example of joining all rules from the
    # ``apps_installed`` definition set in config.py.
    rules = []

    for app_module in config.get('webapp2')['apps_installed']:
        try:
            # Load the urls module from the app and extend our rules.
            app_rules = import_string('%s.routing' % app_module)
            rules.extend(app_rules.get_rules())
        except ImportError:
            pass

    return rules
예제 #43
0
파일: urls.py 프로젝트: sgammon/openfire
def get_rules():

    ''' Get installed apps, get each one's rules. Also include URL mappings for builtin AppTools apps. '''

    rules = []

    for app_module in config.get('webapp2')['apps_installed'] + dispatch.get_builtin_apps():
        if not isinstance(app_module, webapp2.WSGIApplication):
            try:
                # Load the urls module from the app and extend our rules.
                app_rules = import_string('%s.routing' % app_module)
                rules.extend(app_rules.get_rules())
            except ImportError:
                continue
        else:
            try:
                # Load the urls from the app itself.
                app_rules = app_module.router.match_routes
                rules.extend(app_rules)
            except (AttributeError, TypeError):
                continue

    return rules
예제 #44
0
# marty mc fly imports
from __future__ import absolute_import

# stdlib imports
import itertools

# third-party imports
import webapp2

# local imports
from nacelle.conf import settings

# use webapp2's import_string function to lazily import required modules for
# WSGI config
try:
    routes = webapp2.import_string(settings.ROUTES_MODULE)
except webapp2.ImportStringError:
    routes = []
dispatcher = webapp2.import_string(settings.DISPATCHER_MODULE)
error_handler_404 = webapp2.import_string(settings.ERROR_HANDLER_MODULE_404)
error_handler_500 = webapp2.import_string(settings.ERROR_HANDLER_MODULE_500)
secret_key_store = webapp2.import_string(
    'nacelle.core.sessions.models.SecretKey')

# some of nacelle's contrib apps have routes, so we need to make sure and
# append those to our routes list before passing it into the WSGI app
mail_routes = webapp2.import_string('nacelle.contrib.mail.routes.ROUTES')
routes = list(itertools.chain(routes, mail_routes))

# Define our WSGI app so GAE can run it
wsgi = webapp2.WSGIApplication(routes,
예제 #45
0
 def __init__(self):
     try:
         self._user_settings = webapp2.import_string('settings')
     except webapp2.ImportStringError:
         self._user_settings = None
     self._default_settings = webapp2.import_string('nacelle.conf.default_settings')
예제 #46
0
 def test_get_valid_setting(self):
     """Test getting a setting that exists
     """
     settings = webapp2.import_string('nacelle.conf.settings')
     self.assertEqual(settings.TEST_SETTING, '12345')
예제 #47
0
 def test_get_invalid_setting(self):
     """Test that getting a setting that doesn't exist throws an AttributeError
     """
     settings = webapp2.import_string('nacelle.conf.settings')
     with self.assertRaises(AttributeError):
         settings.UNDEFINED_MADE_UP_SETTING
예제 #48
0
    ('/r_json_unencodable', r_json_unencodable),
]

wsgi = webapp2.WSGIApplication(routes,
                               debug=True,
                               config={
                                   'webapp2_extras.sessions': {
                                       'secret_key': 'xxxxxxxxxxxxxxxxxxxxxx'
                                   },
                                   'webapp2_extras.jinja2': {
                                       'template_path': 'tests/templates'
                                   },
                               })

# attach dispatcher and error_handler to the WSGI app
dispatcher = webapp2.import_string(settings.DISPATCHER_MODULE)
wsgi.router.set_dispatcher(dispatcher)


class RenderJinja2DecoratorTests(NacelleTestCase):
    def test_render_jinja2_existing_template(self):
        """Test rendering a template with Jinja2
        """
        response = wsgi.get_response('/r_jinja2')
        self.assertEqual(200, response.status_int)
        self.assertIn('<!DOCTYPE html>', response.body)

    def test_render_jinja2_override_response(self):
        """Test that a webapp2.Response is rendered when explicitly returned from a jinja2 handler
        """
        response = wsgi.get_response('/r_jinja2_r')
예제 #49
0
    lockdown_username = '******'
    lockdown_password = '******'

    def get(self):
        self.response.write('success')


# Define our WSGI app so GAE can run it
routes = [('/', locked_handler), ('/ld', LDTestHandler)]

wsgi = webapp2.WSGIApplication(routes, debug=True, config={
    'webapp2_extras.sessions': {'secret_key': 'xxxxxxxxxxxxxxxxxxxxxx'}
})

# attach dispatcher and error_handler to the WSGI app
dispatcher = webapp2.import_string('nacelle.core.dispatcher.nacelle_dispatcher')
wsgi.router.set_dispatcher(dispatcher)


class LockdownDecoratorTests(NacelleTestCase):

    def test_properly_returns_401_when_no_headers(self):
        """@locked_down decorator returns a 401 when no auth headers present
        """
        response = wsgi.get_response('/')
        self.assertEqual(401, response.status_int)
        self.assertIn('WWW-Authenticate', response.headers)
        self.assertIn('Could not verify your access level for that URL. '
                      'You have to login with proper credentials', response.body)

    def test_properly_unlocks_when_valid_headers(self):