def handle_error(request, response, exception):
    c = {"exception": str(exception), "url": request.url}

    if config.send_mail_developer is not False:
        # send email
        subject = config.app_name + " error."
        email_body_path = "emails/error.txt"
        message = "This error was looking for you: " + c["exception"] + " from " + c["url"]

        if c["exception"] is not "Error saving Email Log in datastore":
            template_val = {"app_name": config.app_name, "message": message}

            email_body = jinja2.get_jinja2(factory=jinja2_factory, app=webapp2.get_app()).render_template(
                email_body_path, **template_val
            )
            email_url = webapp2.uri_for("taskqueue-send-email")

            for dev in config.DEVELOPERS:
                taskqueue.add(
                    url=email_url,
                    params={"to": dev[1], "subject": subject, "body": email_body, "sender": config.contact_sender},
                )

    status_int = hasattr(exception, "status_int") and exception.status_int or 500
    template = config.error_templates[status_int]
    t = jinja2.get_jinja2(factory=jinja2_factory, app=webapp2.get_app()).render_template(template, **c)
    logging.error(str(status_int) + " - " + str(exception))
    response.write(t)
    response.set_status(status_int)

def handle_error(request, response, exception):
    c = {
        'exception': str(exception),
        'url': request.url,
        }

    if config.send_mail_developer is not False:
        # send email
        subject         = config.app_name + " error."
        email_body_path = "emails/error.txt"
        message         = 'This error was looking for you: ' + c['exception'] + ' from ' + c['url']

        if c['exception'] is not 'Error saving Email Log in datastore':
            template_val = {
                "app_name"  : config.app_name,
                "message"   : message,
                }

            email_body = jinja2.get_jinja2(factory=jinja2_factory, app=webapp2.get_app()).render_template(email_body_path, **template_val)
            email_url = webapp2.uri_for('taskqueue-send-email')

            for dev in config.DEVELOPERS:
                taskqueue.add(url = email_url, params={
                    'to':       dev[1],
                    'subject' : subject,
                    'body' :    email_body,
                    'sender' :  config.contact_sender,
                    })

    status_int = hasattr(exception, 'status_int') and exception.status_int or 500
    template = config.error_templates[status_int]
    t = jinja2.get_jinja2(factory=jinja2_factory, app=webapp2.get_app()).render_template(template, **c)
    logging.error(str(status_int) + " - " + str(exception))
    response.write(t)
    response.set_status(status_int)

def handle_error(request, response, exception):
    exc_type, exc_value, exc_tb = sys.exc_info()

    c = {"exception": str(exception), "url": request.url}

    if request.app.config.get("send_mail_developer") is not False:
        # send email
        subject = "[{}] ERROR {}".format(
            request.app.config.get("environment").upper(), request.app.config.get("app_name")
        )

        lines = traceback.format_exception(exc_type, exc_value, exc_tb)

        message = (
            "<strong>Type:</strong> "
            + exc_type.__name__
            + "<br />"
            + "<strong>Description:</strong> "
            + c["exception"]
            + "<br />"
            + "<strong>URL:</strong> "
            + c["url"]
            + "<br />"
            + "<strong>Traceback:</strong> <br />"
            + "<br />".join(lines)
        )

        email_body_path = "emails/error.txt"
        if c["exception"] is not "Error saving Email Log in datastore":
            template_val = {"app_name": request.app.config.get("app_name"), "message": message}

            email_body = jinja2.get_jinja2(factory=jinja2_factory, app=webapp2.get_app()).render_template(
                email_body_path, **template_val
            )
            email_url = webapp2.uri_for("taskqueue-send-email")

            for dev in request.app.config.get("developers"):
                taskqueue.add(
                    url=email_url,
                    params={
                        "to": dev[1],
                        "subject": subject,
                        "body": email_body,
                        "sender": request.app.config.get("contact_sender"),
                    },
                )

    status_int = hasattr(exception, "status_int") and exception.status_int or 500
    template = request.app.config.get("error_templates")[status_int]
    t = jinja2.get_jinja2(factory=jinja2_factory, app=webapp2.get_app()).render_template(template, **c)
    logging.error(str(status_int) + " - " + str(exception))
    response.write(t)
    response.set_status(status_int)

	def __init__(self, request, response):
		self.initialize( request, response )

		# ログインしてなかったらログイン画面に飛ばす
		if users.is_current_user_admin() == False:
			self.redirect( users.create_login_url(self.request.uri) )
			return

		# サイドバー HTML を jinja2 の globals に登録
		sidebar_str = jinja2.get_jinja2().render_template( 'sidebar.html', **{
			"customObjects": config.CUSTOM_OBJECTS,
		})
		jinja2.get_jinja2().environment.globals["sidebar"] = sidebar_str

def handle_500(request, response, exception):
    t = jinja2.get_jinja2(app=application).render_template(
        'errors/500.html', **{
            'exception': exception.message,
#            'application': Config.get('application'),
        })
    response.write(t)

 def jinja2(self):
     from webapp2_extras import jinja2
     # Returns a Jinja2 renderer cached in the app registry.
     j = jinja2.get_jinja2(app=self.app)
     j.environment.variable_start_string = '@{'
     j.environment.variable_end_string = '}@'
     return j

    def jinja2(self):
        # Returns a Jinja2 renderer cached in the app registry.
        jinja2_obj = jinja2.get_jinja2(app=self.app)

        jinja2_obj.environment.filters['format_currency'] = self.format_currency
        
        return jinja2_obj

def handle_error(request, response, exception):
    c = { 'exception': str(exception) }
    status_int = hasattr(exception, 'status_int') and exception.status_int or 500
    template = config.error_templates[status_int]
    t = jinja2.get_jinja2(app=app).render_template(template, **c)
    response.write(t)
    response.set_status(status_int)

  def render(self, name, value, attrs=None):
    # TODO: handle other data types
    # this currently only works for issubclass(self.property.item_type, db.Key)
    objects = []
    object_classes = self.object_classes

    keys = value or []
    for key in keys:
      if not key:
        continue
      # Turn string keys into Key objects
      if isinstance(key, basestring):
        key = db.Key(key)
      obj = db.get(key)
      objects.append((key, obj))
      object_classes[obj.__class__.__name__] = obj.__class__

    final_attrs = self.build_attrs(attrs, name=name)
    flat_attrs = flatatt(final_attrs)

    from .handlers import AdminHandler
    handler = AdminHandler()

    from webapp2_extras import jinja2

    return jinja2.get_jinja2().render_template(
      'widgets/ajax_list_property.html',
      flat_attrs=flat_attrs,
      objects=objects,
      object_classes=object_classes,
      get_item_edit_url=partial(self._get_item_edit_url, handler=handler),
      name=name,
      paged_selector=partial(self._paged_selector, handler=handler),
    )

 def test_set_jinja2(self):
     app = webapp2.WSGIApplication()
     self.assertEqual(len(app.registry), 0)
     jinja2.set_jinja2(jinja2.Jinja2(app), app=app)
     self.assertEqual(len(app.registry), 1)
     j = jinja2.get_jinja2(app=app)
     self.assertTrue(isinstance(j, jinja2.Jinja2))

    def jinja2(self):
        """Cached property holding a Jinja2 instance.

        Returns:
            A Jinja2 object for the current app.
        """
        return jinja2.get_jinja2(app=self.app)

def handle_404(request, response, exception):
    logging.exception(exception)
    
    renderer = jinja2.get_jinja2()
    response.write(renderer.render_template('errors/404.html'))
    
    response.set_status(404)

 def jinja2(self):
     def factory(app):
         config = jinja2.default_config
         config['template_path'] = app.config['template_path']
         config['environment_args']['line_statement_prefix'] = '%'
         return jinja2.Jinja2(app, config)
     return jinja2.get_jinja2(factory=factory, app=self.app)

	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 )

def ErrorHandler(request, response, exception, code):
    """A webapp2 implementation of error_handler."""
    logging.info('ErrorHandler code %s' % code)
    logging.info('Exception: %s' % exception)

    response.set_status(code)
    response.headers['Access-Control-Allow-Origin'] = \
        request.headers.get('Origin', '*')
    response.headers['Access-Control-Allow-Methods'] = \
        'GET, POST, OPTIONS, PUT'
    response.headers['Access-Control-Allow-Credentials'] = 'true'
    response.headers['Access-Control-Allow-Headers'] = \
        'Content-Type,X-Requested-With'

    # Default UA string is for unit tests.
    user_agent_string = request.headers.get(
        'USER_AGENT', settings.USER_AGENT)

    ua_dict = user_agent_parser.Parse(user_agent_string)
    logging.info('UA: %s' % ua_dict)
    tpl_data = {
        'error_code': code,
        'error_code_text': httplib.responses[code],
        'error_message': exception,
        'user_agent': ua_dict
    }
    jinja2_instance = jinja2.get_jinja2()
    rendered = jinja2_instance.render_template('error.html', **tpl_data)
    response.write(rendered)

 def handler(request, response, exception):
     logging.exception(exception)
     app = webapp2.get_app()
     j = jinja2.get_jinja2(app=app)
     rv = j.render_template("errors/" + str(code) + ".html")
     response.write(rv)
     response.set_status(code)

def error(request, response, exception):
    logging.exception(exception)
    params = {
        'error': exception
    }
    jinja = jinja2.get_jinja2()
    response.write(jinja.render_template('error.html', **params))

    def jinja2(self):
        jinja2.default_config['template_path'] = configuration.VIEW_PATH

        jinja2.default_config['globals'] = {
            'get_route': get_route
        }

        return jinja2.get_jinja2(app=self.app)

 def jinja2(self):
     """ xxx todo """
     j = jinja2.get_jinja2(app=self.app)
     # not good.
     j.environment.globals.update({
         'uri_for': self.uri_for,
         })
     return j

def handle_error(request, response, exception):
    c = { 'exception': str(exception) }
    status_int = hasattr(exception, 'status_int') and exception.status_int or 500
    template = config.error_templates[status_int]
    t = jinja2.get_jinja2(factory=jinja2_factory, app=webapp2.get_app()).render_template(template, **c)
    logging.error(str(status_int) + " - " + str(exception))
    response.write(t)
    response.set_status(status_int)