def test_best_match():
accept = Accept("text/html, foo/bar")
assert accept.best_match(["text/html", "foo/bar"]) == "text/html"
assert accept.best_match(["foo/bar", "text/html"]) == "foo/bar"
assert accept.best_match([("foo/bar", 0.5), "text/html"]) == "text/html"
assert accept.best_match([("foo/bar", 0.5), ("text/html", 0.4)]) == "foo/bar"
assert_raises(ValueError, accept.best_match, ["text/*"])
def generate_response(self, environ, start_response):
if self.content_length is not None:
del self.content_length
headerlist = list(self.headerlist)
accept_value = environ.get('HTTP_ACCEPT', '')
accept = Accept(accept_value)
match = accept.best_match(['application/json', 'text/html',
'text/plain'], default_match='text/plain')
if match == 'text/html':
content_type = 'text/html'
body = self.html_body(environ)
elif match == 'application/json':
content_type = 'application/json'
body = self.json_body(environ)
else:
content_type = 'text/plain'
body = self.plain_body(environ)
extra_kw = {}
if isinstance(body, text_type):
extra_kw.update(charset='utf-8')
resp = Response(body,
status=self.status,
headerlist=headerlist,
content_type=content_type,
**extra_kw
)
resp.content_type = content_type
return resp(environ, start_response)
def test_accept_match():
accept = Accept('Content-Type', 'text/html')
#FIXME: Accept._match should be standalone function _match that is
# attached as Accept._match during Accept.__init__.
assert accept._match('*', 'text/html')
assert accept._match('text/html', 'text/html')
assert accept._match('TEXT/HTML', 'text/html')
assert not accept._match('foo/bar', 'text/html')
def test_best_match_with_complex_q():
accept = Accept("text/html, foo/bar;q=0.55, baz/gort;q=0.59")
assert accept.best_match(["text/html", "foo/bar"]) == "text/html"
accept = Accept("text/html;q=0.5, foo/bar;q=0.586, baz/gort;q=0.5966")
assert "baz/gort;q=0.597" in str(accept)
assert "foo/bar;q=0.586" in str(accept)
assert "text/html;q=0.5" in str(accept)
assert accept.best_match(["text/html", "baz/gort"]) == "baz/gort"
def test_best_match():
accept = Accept('Content-Type', 'text/html, foo/bar')
assert accept.best_match(['text/html', 'foo/bar']) == 'text/html'
assert accept.best_match(['foo/bar', 'text/html']) == 'foo/bar'
assert accept.best_match([('foo/bar', 0.5),
'text/html']) == 'text/html'
assert accept.best_match([('foo/bar', 0.5),
('text/html', 0.4)]) == 'foo/bar'
assert_raises(ValueError, accept.best_match, ['text/*'])
def lookup_template_engine(self, tgl):
"""Return the template engine data.
Provides a convenience method to get the proper engine,
content_type, template, and exclude_names for a particular
tg_format (which is pulled off of the request headers).
"""
request = tgl.request
response = tgl.response
try:
render_custom_format = request._render_custom_format[self.controller]
except:
render_custom_format = self.render_custom_format
if render_custom_format:
(content_type, engine, template, exclude_names, render_params
) = self.custom_engines[render_custom_format]
else:
if self.default_engine:
content_type = self.default_engine
elif self.engines:
if request._response_type and request._response_type in self.engines:
accept_types = request._response_type
else:
accept_types = request.headers.get('accept', '*/*')
content_type = Accept(accept_types).best_match(self.engines_keys, self.engines_keys[0])
else:
content_type = 'text/html'
# check for overridden content type from the controller call
try:
controller_content_type = response.headers['Content-Type']
# make sure we handle content_types like 'text/html; charset=utf-8'
content_type = controller_content_type.split(';')[0]
except KeyError:
pass
# check for overridden templates
try:
cnt_override_mapping = request._override_mapping[self.controller]
engine, template, exclude_names, render_params = cnt_override_mapping[content_type.split(";")[0]]
except (AttributeError, KeyError):
(engine, template, exclude_names, render_params
) = self.engines.get(content_type, (None,) * 4)
if 'charset' not in content_type and (content_type.startswith('text')
or content_type in ('application/xhtml+xml',
'application/xml', 'application/json')):
content_type += '; charset=utf-8'
return content_type, engine, template, exclude_names, render_params
def offer_sort_key(value):
"""
(type_weight, params_weight)
type_weight:
- index of specific ``type/subtype`` in order list
- ``max_weight * 2`` if no match is found
params_weight:
- index of specific ``type/subtype;params`` in order list
- ``max_weight`` if not found
- ``max_weight + 1`` if no params at all
"""
parsed = Accept.parse_offer(value)
type_w = find_order_index(
parsed.type + '/' + parsed.subtype, max_weight
)
if parsed.params:
param_w = find_order_index(value, max_weight)
else:
param_w = max_weight + 1
return (type_w, param_w)
def test_best_matches_with_fallback():
accept = Accept('Content-Type', 'text/html, foo/bar')
assert accept.best_matches('xxx/yyy') == ['text/html',
'foo/bar',
'xxx/yyy']
accept = Accept('Content-Type', 'text/html;q=0.5, foo/bar')
assert accept.best_matches('xxx/yyy') == ['foo/bar',
'text/html',
'xxx/yyy']
assert accept.best_matches('foo/bar') == ['foo/bar']
assert accept.best_matches('text/html') == ['foo/bar', 'text/html']
def test_nil_add():
nilaccept = NilAccept()
accept = Accept('text/html')
assert nilaccept + accept is accept
new_accept = nilaccept + nilaccept
assert isinstance(new_accept, accept.__class__)
assert new_accept.header_value == ''
new_accept = nilaccept + 'foo'
assert isinstance(new_accept, accept.__class__)
assert new_accept.header_value == 'foo'
def test_accept_match_lang():
accept = Accept('Accept-Language', 'da, en-gb;q=0.8, en;q=0.7')
#FIXME: Accept._match_lang should be standalone function _match_lang
# that is attached as Accept._match during Accept.__init__.
assert accept._match('*', 'da')
assert accept._match('da', 'DA')
assert accept._match('en', 'en-gb')
assert accept._match('en-gb', 'en-gb')
assert not accept._match('en-gb', 'fr-fr')
def test_unknown_laguage(self):
from pyramid.httpexceptions import HTTPInternalServerError
from c2cgeoportal.views.fulltextsearch import FullTextSearchView
from webob.acceptparse import Accept
request = self._create_dummy_request()
request.registry.settings["default_locale_name"] = "it"
request.accept_language = Accept("es")
fts = FullTextSearchView(request)
response = fts.fulltextsearch()
self.assertTrue(isinstance(response, HTTPInternalServerError))
def concept(request, lccn):
concept = get_object_or_404(m.Concept, lccn=lccn)
host = request.get_host()
accept = Accept('Accept', request.META.get('HTTP_ACCEPT', 'text/html'))
best_match = accept.best_match(['text/html', 'application/rdf+xml'])
if best_match == 'application/rdf+xml':
r = concept_rdf(request, lccn)
else:
alt_labels = concept.alternate_labels.all().order_by('text')
broader = concept.broader.all().order_by('pref_label')
extra_broader = concept.extra_broader()
narrower = concept.narrower.all().order_by('pref_label')
related = concept.related.all().order_by('pref_label')
r = render_to_response('concept.html', dictionary=locals(),
context_instance=RequestContext(request))
# let downstream caches know that the resonse can vary depending
# on the Accept header that the client sent
r['Vary'] = 'Accept'
return r
def test_best_match():
accept = Accept('text/html, foo/bar')
assert accept.best_match(['text/html', 'foo/bar']) == 'text/html'
assert accept.best_match(['foo/bar', 'text/html']) == 'foo/bar'
assert accept.best_match([('foo/bar', 0.5),
'text/html']) == 'text/html'
assert accept.best_match([('foo/bar', 0.5),
('text/html', 0.4)]) == 'foo/bar'
with pytest.raises(ValueError):
accept.best_match(['text/*'])
def test_compresses_streaming(self):
decompressed_body = b"foofoofoofoofoofoofoofoofoofoofoofoofoofoo"
compressed_body = b"".join(list(gzip_app_iter([decompressed_body])))
request = pretend.stub(accept_encoding=Accept("gzip"))
response = Response(app_iter=iter([decompressed_body]))
compressor(request, response)
assert response.content_encoding == "gzip"
assert response.content_length is None
assert response.body == compressed_body
def test_first_match():
accept = Accept('Content-Type', 'text/html, foo/bar')
assert accept.first_match(['text/html', 'foo/bar']) == 'text/html'
assert accept.first_match(['foo/bar', 'text/html']) == 'foo/bar'
assert accept.first_match(['xxx/xxx', 'text/html']) == 'text/html'
assert accept.first_match(['xxx/xxx']) == 'xxx/xxx'
assert accept.first_match([None, 'text/html']) is None
assert accept.first_match(['text/html', None]) == 'text/html'
assert accept.first_match(['foo/bar', None]) == 'foo/bar'
assert_raises(ValueError, accept.first_match, [])
def concept(request, lccn):
concept = get_object_or_404(m.Concept, lccn=lccn)
host = request.get_host()
accept = Accept('Accept', request.META.get('HTTP_ACCEPT', 'text/html'))
best_match = accept.best_match(['text/html', 'application/rdf+xml'])
if best_match == 'application/rdf+xml':
r = concept_rdf(request, lccn)
else:
alt_labels = concept.alternate_labels.all().order_by('text')
broader = concept.broader.all().order_by('pref_label')
extra_broader = concept.extra_broader()
narrower = concept.narrower.all().order_by('pref_label')
related = concept.related.all().order_by('pref_label')
r = render_to_response('concept.html',
dictionary=locals(),
context_instance=RequestContext(request))
# let downstream caches know that the resonse can vary depending
# on the Accept header that the client sent
r['Vary'] = 'Accept'
return r
def test_nil_add():
nilaccept = NilAccept('Connection-Close')
accept = Accept('Content-Type', 'text/html')
assert nilaccept + accept is accept
new_accept = nilaccept + nilaccept
assert isinstance(new_accept, accept.__class__)
assert new_accept.header_name == 'Connection-Close'
assert new_accept.header_value == ''
new_accept = nilaccept + 'foo'
assert isinstance(new_accept, accept.__class__)
assert new_accept.header_name == 'Connection-Close'
assert new_accept.header_value == 'foo'
def test_best_matches():
accept = Accept('Content-Type', 'text/html, foo/bar')
assert accept.best_matches() == ['text/html', 'foo/bar']
accept = Accept('Content-Type', 'text/html, foo/bar;q=0.5')
assert accept.best_matches() == ['text/html', 'foo/bar']
accept = Accept('Content-Type', 'text/html;q=0.5, foo/bar')
assert accept.best_matches() == ['foo/bar', 'text/html']
def _purge_old(self):
""" Delete any task on DB that has been completed for more than 3 days
"""
query_param = '{"literal":"(now()-finished_at) > \'P0Y0M3DT0H0M0S\'"}'
url = self.base_url + '?$$=' + query_param
params = {'$$': query_param}
request = DummyRequest(path=url, params=params)
request.method = 'DELETE'
from webob.acceptparse import Accept
request.accept = Accept("application/json")
request.matchdict = {'base': self.basename}
doc_view = DocumentCustomView(DocumentContextFactory(request), request)
response = doc_view.delete_collection()
def test_best_match_with_complex_q():
accept = Accept('text/html, foo/bar;q=0.55, baz/gort;q=0.59')
assert accept.best_match(['text/html', 'foo/bar']) == 'text/html'
accept = Accept('text/html;q=0.5, foo/bar;q=0.586, baz/gort;q=0.5966')
assert "baz/gort;q=0.597" in str(accept)
assert "foo/bar;q=0.586" in str(accept)
assert "text/html;q=0.5" in str(accept)
assert accept.best_match(['text/html', 'baz/gort']) == 'baz/gort'
def from_settings(cls, settings):
"""Create a new instance based on the `settings` dict.
The locales supported by the application are read from the
"locales" key. The format of the value is the same as that of
the Accept-Language header, i.e.:
<locale1>;q=<q1>,<locale2>;q=<q2>,...
The q-values indicate the quality of the locale, but are
optional.
"""
locales = list(Accept.parse(settings.get("locales", "")))
return cls(locales)
def process(self, environ, start_response):
self._begin = datetime.datetime.now()
if self._debug:
open("/tmp/cog_sql", "w")
try:
self.clear()
self._environ = environ
# open("/tmp/cog_tmp_xxx", "w").write("{}".format(environ))
self._script_name = self._environ.get('SCRIPT_NAME', '')
self._server_name = self._environ['HTTP_HOST']
self._url_scheme = self._environ['wsgi.url_scheme']
self._url = "{}://{}{}".format(
self._url_scheme, self._server_name, self._script_name)
self._path_info = self._environ['PATH_INFO'].lower()
alnum = "[a-z0-9]{4}"
oid_pattern = '^/{}{}-{}-{}-{}-{}{}{}$'.format(*(alnum,)*8)
if re.match(oid_pattern, self._path_info):
obj = self.db.get_elt_by_oid(self._path_info[1:])
self.add_json_res({'#page_ref':self.get_page_ref()})
self.direct_obj_ref = obj.w3display
self.load_site()
self.__request = Request(environ)
self.__lang = Accept(str(self.__request.accept_language))
self.i18n = gettext.translation(
'messages', '/usr/share/collorg/locale',
[self.__lang.best_match(('en', 'fr', 'fr-FR')) or 'en'])
if WebController.__static_body is None:
WebController.__tags = self.__get_tags()
WebController.__static_body = self.__get_static_body()
self.__response = Response()
self.__reset()
if not(self._cog_method is None and '#page_ref' in self._json_res):
self.add_json_res({'#page_ref':self.get_page_ref()})
self.__response.unicode_body = self._unicode(self.__exec())
if(self.__response.content_type != 'text/html' or
self.__response.status_int != 200):
# Not an HTML response, we don't want to
# do anything to it
return self.__response(environ, start_response)
# Make sure the content isn't gzipped:
self.__response.decode_content()
return self.__response(environ, start_response)
except Exception as err:
if self.db._cog_params['debug']:
response = Response()
response.unicode_body = self._unicode(err)
return response(environ, start_response)
if raise_error:
raise err
def create_dummy_request(additional_settings=None,
authentication=True,
user=None,
*args,
**kargs):
if additional_settings is None:
additional_settings = {}
from c2cgeoportal_geoportal import default_user_validator
from c2cgeoportal_geoportal import create_get_user_from_request
from c2cgeoportal_geoportal.lib.authentication import create_authentication
request = tests.create_dummy_request(
{
"host_forward_host": [],
"mapserverproxy": {
"default_ogc_server": "__test_ogc_server",
"external_ogc_server": "__test_external_ogc_server",
},
"functionalities": {
"registered": {},
"anonymous": {},
"available_in_templates": []
},
"layers": {
"geometry_validation": True
}
}, *args, **kargs)
request.accept_language = Accept("fr-CH,fr;q=0.8,en;q=0.5,en-US;q=0.3")
request.registry.settings.update(additional_settings)
request.referer = "http://example.com/app"
request.path_info_peek = lambda: "main"
request.interface_name = "main"
request.get_user = _get_user
request.registry.validate_user = default_user_validator
request.client_addr = None
request.c2c_request_id = 'test'
if authentication and user is None:
request._get_authentication_policy = lambda: create_authentication(
{
"authtkt_cookie_name": "__test",
"authtkt_secret": "123",
})
elif user is not None:
config.testing_securitypolicy(user)
request.set_property(create_get_user_from_request(
{"authorized_referers": [request.referer]}),
name="user",
reify=True)
return request
def test_compresses_non_streaming(self):
decompressed_body = b"foofoofoofoofoofoofoofoofoofoofoofoofoofoo"
compressed_body = b"".join(list(gzip_app_iter([decompressed_body])))
request = pretend.stub(accept_encoding=Accept("gzip"))
response = Response(body=decompressed_body)
response.md5_etag()
original_etag = response.etag
compressor(request, response)
assert response.content_encoding == "gzip"
assert response.content_length == len(compressed_body)
assert response.body == compressed_body
assert response.etag != original_etag
def lookup_template_engine(self, tgl):
"""Return the template engine data.
Provides a convenience method to get the proper engine,
content_type, template, and exclude_names for a particular
tg_format (which is pulled off of the request headers).
"""
request = tgl.request
response = tgl.response
try:
render_custom_format = request._render_custom_format[self.controller]
except:
render_custom_format = self.render_custom_format
if render_custom_format:
(content_type, engine, template, exclude_names, render_params
) = self.custom_engines[render_custom_format]
else:
if self.default_engine:
content_type = self.default_engine
elif self.engines:
if response.content_type is not None:
# Check for overridden content type from the controller call
accept_types = response.content_type
elif request._response_type and request._response_type in self.engines:
# Check for content type detected by request extensions
accept_types = request._response_type
else:
accept_types = request.headers.get('accept', '*/*')
content_type = Accept(accept_types).best_match(self.engines_keys, self.engines_keys[0])
else:
content_type = 'text/html'
# check for overridden templates
try:
cnt_override_mapping = request._override_mapping[self.controller]
engine, template, exclude_names, render_params = cnt_override_mapping[content_type.split(";")[0]]
except (AttributeError, KeyError):
(engine, template, exclude_names, render_params
) = self.engines.get(content_type, (None,) * 4)
return content_type, engine, template, exclude_names, render_params
def test_quality():
accept = Accept("text/html")
assert accept.quality("text/html") == 1
accept = Accept("text/html;q=0.5")
assert accept.quality("text/html") == 0.5
def normalize_accept_offer(offer):
return str(Accept.parse_offer(offer))
def normalize_accept_offer(offer, allow_range=False):
if allow_range and '*' in offer:
return offer.lower()
return str(Accept.parse_offer(offer))
def test_accept_str_with_q_not_1_multiple():
value = 'text/html;q=0.5, foo/bar'
accept = Accept(value)
assert str(accept) == value
def test_zero_quality():
assert Accept('bar, *;q=0').best_match(['foo']) is None
assert 'foo' not in Accept('*;q=0')
def test_accept_repr():
accept = Accept('text/html')
assert repr(accept) == "<Accept('text/html')>"
def test_init_accept_accept_charset_with_iso_8859_1():
accept = Accept('iso-8859-1')
assert accept._parsed == [('iso-8859-1', 1)]
class WebController(Controller):
"""
Web controller.
"""
__static_body = None
__topics = {} # topics are loaded on demand
__site = None
_d_topics = {} # all topics are loaded once!
__main_topic = None
def __init__(self, config_file):
self.__lang = None
self.i18n = None
self.direct_obj_ref = None
self.cog_exec_env = None
self.__env_set = False
self.__nsession = False
self._begin = None
self.__cog_target = None
self._cog_raw = None
self._cog_ajax = None
self._script_name = None
self._server_name = None
self._url_scheme = None
self._environ = None
self.__request = None
self._session_key = None
self.__session = None
self._user = None
self.__cog_environment = None
self.__get_request = None
self.cog_ref_obj = {}
Controller.__init__(self, config_file)
self.cache = Client(self)
self.cache.check()
def clear(self):
self.direct_obj_ref = None
self.cog_exec_env = None
self.__env_set = False
self.__nsession = False
self.__cog_target = None
self._cog_raw = None
self._cog_ajax = None
self._environ = None
self._user = None
self.__request = None
self._session_key = None
self.__session = None
self.__get_request = None
self._json_res = {}
self.cog_ref_obj = {}
Controller.clear(self)
@property
def env_set(self):
return self.__env_set
def __rt(self, template_name):
"""
reads the templates and returns it's content
"""
params = self.db._cog_params
tp = params['templates_path']
return open("%s/%s.html"%(tp, template_name)).read()
def __get_tags(self):
return self.db.table('collorg.communication.tag').search_links()
def __get_important_posts(self):
return self.db.table(
'collorg.communication.blog.view.by_post').important()
@property
def new_session(self):
self.__nsession = True
self._session_key = uuid.uuid4()
return self._session_key
def __get_static_body(self):
self.db.table('collorg.core.base_table')
dt = {} # templates dictionary
params = self.db._cog_params
html = self.__rt("html")
dt['head'] = self.__rt("head")
dt['title'] = self.db.name
dt['style'] = self.__rt("style")
dt['javascript'] = self.__rt("javascript")
dt['head'] = dt['head'] % (
self._charset, dt['style'], params['icon'], dt['title'],
dt['javascript'])
dt['ariadne'] = self.__rt("ariadne")
dt['top_search'] = self.__rt("top_search")
dt['body'] = self.__rt("body")
dt['header'] = self.__rt("header")
dt['homepage_link'] = self.__rt("homepage_link")
dt['homepage_link'] = "" #dt['homepage_link'] % (self._script_name)
dt['search'] = self.__rt("search")
dt['login_zone'] = self.__rt("login_zone")
dt['header'] %= (
dt['homepage_link'], dt['login_zone'])
dt['login_container'] = self.__rt("login_container")
dt['body_content'] = self.__rt("body_content")
dt['footer'] = self.__rt("footer")
dt['collorg_link'] = self.__rt("collorg_link")
dt['footer'] %= (dt['collorg_link'])
dt['body'] %= (
dt['ariadne'],
dt['top_search'],
dt['header'], dt['login_container'],
dt['body_content'],
dt['footer'])
dt['debug'] = self.__rt("debug")
dt['collorg_link'] = self.__rt("collorg_link")
html %= (dt['head'].decode(self._charset),
dt['body'].decode(self._charset))
return html
def __pfce(self, obj):
return html_escape(str(pformat(obj)))
def __oid_req(self, **kwargs):
"""
The controller received a cog_oid. The object representing one
and only one elt of the table is instanciated.
@returns: the method cog_method applied to this object.
@called by: self.__exec
"""
if not '_cog_fqtn_' in self.__dict__ or not self._cog_fqtn_:
obj = self.db.get_elt_by_oid(self._cog_oid_)
else:
obj = self.db.table(self._cog_fqtn_)
obj.cog_oid_.value = self._cog_oid_
obj.get()
self.check_action(obj, self._cog_method)
self.cog_exec_env = obj.get_environment()
if (self._user is None and obj._is_cog_post and
obj.visibility_.value == 'public' and
self._cog_method == 'w3display'):
cache = obj._cog_get_cache('w3display')
if cache is not None:
return cache
return eval("obj.{}(**kwargs)".format(self._cog_method))
def __fqtn_req(self, **kwargs):
"""
No cog_oid received by the controller but a cog_fqtn.
@returns: the method referenced by cog_method applied to the object
instantiated without intention (aka the whole table).
@called by: self.__exec
"""
obj = self.db.table(self._cog_fqtn_)
self.check_action(obj, self._cog_method)
return eval("obj.{}(**kwargs)".format(self._cog_method))
def load_site(self):
#XXX REFACTOR
path_info = self._path_info
if self.direct_obj_ref:
path_info = '/'
url = "{}{}".format(
self._environ['HTTP_HOST'], self._environ.get('SCRIPT_NAME', ''))
site = self.db.table("collorg.web.site")
if not (url, path_info) in self.__topics:
topic, w3display_topic = site.load_topic(
url, path_info)
if self.__site is None:
self.__site = site.get()
self.__topics[(url, path_info)] = (w3display_topic, topic)
### self._d_topics = self.__site.load_topics()
topic = self.__topics[(url, path_info)][1]
self._cog_cmd = self.__topics[(url, path_info)][0]
return topic
@property
def site(self):
return self.__site
@property
def main_topic(self):
# Post._w3get_recipient
if not self.__main_topic:
self.__main_topic = self.__site.load_topic()[0]
return self.__main_topic
@property
def _session(self):
return self._session_key
@property
def user(self):
return self._user
@property
def cog_environment(self):
return self.__cog_environment
def __dumps_json_res(self):
res = {}
for key, val in self._json_res.items():
res[key] = {'content':val, 'action':'html'}
return json.dumps(res)
def __get_query_params(self):
qs = {}
for query in self.__request.POST, self.__request.GET:
for key, val in query.items():
key = key.encode(self._charset)
val = val.encode(self._charset)
if key[-2:] == '[]':
key = key[:-2]
if key not in qs:
qs[key] = []
qs[key].append(val)
else:
qs[key] = val
return qs
def set_ref_obj_oid(self, obj_oid, ref_obj_oid):
if obj_oid:
self.cache.set_(
"ref_obj_oid", self._session_key, (obj_oid, ref_obj_oid))
def set_env(self, env):
if not self._session_key:
return
self.__env_set = True
if self.__nsession:
self.cache.set_("user", self._session_key, None)
self.cache.set_(
"creat_date", self._session_key, self._begin)
self.cache.set_(
"last_access_date", self._session_key, self._begin)
def __get_env(self):
if self._session_key:
self.cache.get_("last_access_date", self._session_key)
self.cache.set_(
"last_access_date", self._session_key, self._begin)
self.get_user()
def get_user(self):
if self._session_key:
user_oid = self.cache.get_("user", self._session_key)
if user_oid:
self._user = self.db.table(
'collorg.actor.user', cog_oid_ = user_oid).get()
else:
self.delete_cookie('cog_session')
def set_user(self, user_oid = None):
self.cache.set_("user", self._session_key, user_oid)
def del_user(self, key):
self.cache.del_("user", key)
def __get_params(self):
self._kwargs = self.__get_query_params()
self._cog_ajax = self._kwargs.get('cog_ajax')
self.__cog_target = self._kwargs.get('cog_target')
self._cog_raw = self._kwargs.get('cog_raw', None)
self._cog_method = self._kwargs.get('cog_method', None)
# cog_method must not contain non-word caracters
assert self._cog_method is None or \
re.search('\W', self._cog_method) is None
if self._cog_method is not None and self._cog_method[0] == '_':
# we never should receive a protected method...
self._cog_method = "w3error"
self._kwargs['cog_method'] = "w3error"
self._kwargs['cog_error'] = "Can't call a protected method!"
self._cog_ref_oid = self._kwargs.get('cog_ref_oid', None)
self._cog_oid_ = self._kwargs.get('cog_oid_', None)
self._session_key = None
if 'HTTP_COOKIE' in self._environ:
cookie_string = self._environ.get('HTTP_COOKIE')
cookie = SimpleCookie()
cookie.load(cookie_string)
if 'cog_session' in cookie:
self._session_key = cookie['cog_session'].value
self.__cog_environment = self.__get_env()
self._cog_fqtn_ = self._kwargs.get('cog_fqtn_', None)
if self._cog_ref_oid and self._cog_ref_oid == self._cog_oid_:
self._cog_oid_ = None
self._kwargs['cog_controller'] = self
self._kwargs['cog_first_call'] = True
def __reset(self):
"""
Some things that are always done first
"""
self._json_res['#cog_debug_link'] = ''
self._json_res['#cog_debug'] = ''
self.__get_params()
self.db._set_controller(self)
#self._cog_cmd = self.__environment
def get_page_ref(self, method = None, oid = None):
method = method or self._cog_method
oid = oid or self._cog_oid_
if oid:
ref = oid
else:
env = self._environ
if env and 'QUERY_STRING' in env:
ref = md5.new(env['QUERY_STRING']).hexdigest()
else:
ref = self.__site.cog_oid_.value
page_ref = "{}-{}".format(method, ref)
return page_ref
def __exec(self):
"""
constructs the call to the template.
the template receives
depends on the arguments passed.
Case of ajax:
* one of the three following arguments is expected
** a path (specific wsgi)
** an oid
** a fqtn
"""
_ = self.i18n.gettext
i18n_drag_drop = _(
"Drag & drop your links here<br>for future reference")
i18n_drop_drag = _(
"Drag & drop the link from the cart to \n"
"the page/textarea to add a reference.\n"
"(write access is mandatory)")
if self._cog_oid_:
self._cog_cmd = self.__oid_req
elif self._cog_fqtn_:
self._cog_cmd = self.__fqtn_req
elif self._cog_ajax is None and self.direct_obj_ref:
self._cog_cmd = self.direct_obj_ref
if self._cog_ajax is None:
actor = self.db.table('collorg.actor.user')
result = self.__static_body.format(
self.__site.w3map_link(),
_("search"), _("search"),
_("by tag"), _("by user"),
actor.w3login_link(),
_(i18n_drop_drag).decode(self._charset),
_(i18n_drag_drop).decode(self._charset))
page = self._cog_cmd(**self._kwargs)
if self._cog_raw:
return page
result %= (
"", #self._json_res['#cog_top_nav_ariadne']),
self._unicode(page))
return result
# ajax
try:
result = self._cog_cmd(**self._kwargs)
if self._cog_raw:
return result
duration = datetime.datetime.now() - self._begin
except Exception as err:
# open("/tmp/cog_error_log", "a+").write("{}\n".format(err))
if self.db._cog_params['debug']:
link, error = self.debug(err.__str__)
self._json_res['#cog_debug_link'] = link
self._json_res['#cog_debug'] = self._unicode(error)
return self.__dumps_json_res()
if raise_error:
raise "Web controller error: {}".format(err)
self._json_res['#cog_duration'] = "%s" % (duration)
if self._debug:
link, debug = self.debug()
self._json_res['#cog_debug_link'] = link
self._json_res['#cog_debug'] = self._unicode(debug)
self._json_res[self.__cog_target] = result
return self.__dumps_json_res()
def get_cookie(self, key):
return self._session_key
def delete_cookie(self, key):
self.__response.delete_cookie(key)
def set_cookie(self, key):
value = self.new_session
self.__response.set_cookie(key, bytes(value))
return value
def process(self, environ, start_response):
self._begin = datetime.datetime.now()
if self._debug:
open("/tmp/cog_sql", "w")
try:
self.clear()
self._environ = environ
# open("/tmp/cog_tmp_xxx", "w").write("{}".format(environ))
self._script_name = self._environ.get('SCRIPT_NAME', '')
self._server_name = self._environ['HTTP_HOST']
self._url_scheme = self._environ['wsgi.url_scheme']
self._url = "{}://{}{}".format(
self._url_scheme, self._server_name, self._script_name)
self._path_info = self._environ['PATH_INFO'].lower()
alnum = "[a-z0-9]{4}"
oid_pattern = '^/{}{}-{}-{}-{}-{}{}{}$'.format(*(alnum,)*8)
if re.match(oid_pattern, self._path_info):
obj = self.db.get_elt_by_oid(self._path_info[1:])
self.add_json_res({'#page_ref':self.get_page_ref()})
self.direct_obj_ref = obj.w3display
self.load_site()
self.__request = Request(environ)
self.__lang = Accept(str(self.__request.accept_language))
self.i18n = gettext.translation(
'messages', '/usr/share/collorg/locale',
[self.__lang.best_match(('en', 'fr', 'fr-FR')) or 'en'])
if WebController.__static_body is None:
WebController.__tags = self.__get_tags()
WebController.__static_body = self.__get_static_body()
self.__response = Response()
self.__reset()
if not(self._cog_method is None and '#page_ref' in self._json_res):
self.add_json_res({'#page_ref':self.get_page_ref()})
self.__response.unicode_body = self._unicode(self.__exec())
if(self.__response.content_type != 'text/html' or
self.__response.status_int != 200):
# Not an HTML response, we don't want to
# do anything to it
return self.__response(environ, start_response)
# Make sure the content isn't gzipped:
self.__response.decode_content()
return self.__response(environ, start_response)
except Exception as err:
if self.db._cog_params['debug']:
response = Response()
response.unicode_body = self._unicode(err)
return response(environ, start_response)
if raise_error:
raise err
def debug(self, error = None):
output = []
css_style = 'debug hidden toggle'
css_error = ''
if error:
css_style += ' debug_error'
css_error = 'debug_error'
title = error and "Error" or "debug"
link = ( '<span class="link toggle %s" '
'to_toggle="#cog_debug">%s</span>' % (css_error, title))
if error:
output.append('<h2>Error</h2>')
output.append('<pre>%s</pre>' % (self.__pfce(error)))
output.append("<h2>Traceback</h2>")
output.append("<pre>%s</pre>"%(
traceback.format_exc()))
output.append('<h2>Main variables</h2>')
output.append('<pre>')
output.append('cog_method = %s\n' % (self._cog_method))
output.append('cog_fqtn_ = %s\n' % (self._cog_fqtn_))
output.append('cog_oid_ = %s\n' % (self._cog_oid_))
output.append('cog_ref_oid = %s\n' % (self._cog_ref_oid))
output.append('</pre>')
if error:
post_error = self.db.table(
'collorg.application.communication.error')
try:
post_error.hit(
self._cog_fqtn_, self._cog_method, traceback.format_exc())
except Exception, err:
sys.stderr.write("Warning! {}\n".format(err))
# open("/tmp/cog_error_log", "a+").write("{}\n".format(err))
output.append('<h2>Query string</h2>')
output.append('<pre>qs = %s</pre>' % (self.__pfce(self.__get_request)))
output.append('<h2>Command executed</h2>')
output.append('<pre>cmd = %s</pre>' %(self.__pfce(self._cog_cmd)))
output.append('<h2>Environ</h2>')
output.append('<pre>%s</pre>' % (self.__pfce(self._environ)))
u_output = [self._unicode(elt) for elt in output]
return link, "\n".join(u_output)
def test_parse_accept_badq():
assert list(Accept.parse("value1; q=0.1.2")) == [('value1', 1)]
def test_quality():
accept = Accept('Content-Type', 'text/html')
assert accept.quality('text/html') == 1
accept = Accept('Content-Type', 'text/html;q=0.5')
assert accept.quality('text/html') == 0.5
def test_quality_not_found():
accept = Accept('Content-Type', 'text/html')
assert accept.quality('foo/bar') is None
def test_nil_radd_masterclass():
# Is this "reaching into" __radd__ legit?
nilaccept = NilAccept()
accept = Accept('text/html')
assert nilaccept.__radd__(accept) is accept
def test_contains_not():
accept = Accept('text/html')
assert not 'foo/bar' in accept
def test_init_accept_accept_charset_wildcard():
accept = Accept('*')
assert accept._parsed == [('*', 1)]
def test_quality():
accept = Accept('text/html')
assert accept.quality('text/html') == 1
accept = Accept('text/html;q=0.5')
assert accept.quality('text/html') == 0.5
def test_accept_str():
accept = Accept('text/html')
assert str(accept) == 'text/html'
def test_quality_not_found():
accept = Accept('text/html')
assert accept.quality('foo/bar') is None
def test_accept_str_with_q_not_1():
value = 'text/html;q=0.5'
accept = Accept(value)
assert str(accept) == value
def test_best_match_with_one_lower_q():
accept = Accept('text/html, foo/bar;q=0.5')
assert accept.best_match(['text/html', 'foo/bar']) == 'text/html'
accept = Accept('text/html;q=0.5, foo/bar')
assert accept.best_match(['text/html', 'foo/bar']) == 'foo/bar'
def test_accept_add_other_accept():
accept = Accept('text/html') + Accept('foo/bar')
assert str(accept) == 'text/html, foo/bar'
accept += Accept('bar/baz;q=0.5')
assert str(accept) == 'text/html, foo/bar, bar/baz;q=0.5'
def test_init_accept_content_type():
accept = Accept('text/html')
assert accept._parsed == [('text/html', 1)]
def test_best_match_with_one_lower_q():
accept = Accept("text/html, foo/bar;q=0.5")
assert accept.best_match(["text/html", "foo/bar"]) == "text/html"
accept = Accept("text/html;q=0.5, foo/bar")
assert accept.best_match(["text/html", "foo/bar"]) == "foo/bar"
def test_accept_match():
for mask in ['*', 'text/html', 'TEXT/HTML']:
assert 'text/html' in Accept(mask)
assert 'text/html' not in Accept('foo/bar')
def test_quality_not_found():
accept = Accept("text/html")
assert accept.quality("foo/bar") is None
def test_nil_radd():
nilaccept = NilAccept()
accept = Accept('text/html')
assert isinstance('foo' + nilaccept, accept.__class__)
assert ('foo' + nilaccept).header_value == 'foo'
def checkMimetype(acceptHeader):
accept = Accept('Accept', acceptHeader)
best = accept.best_match(['application/rdf', 'application/rdf+xml', 'text/n3', 'application/xml', 'application/json', 'text/xml', 'application/xhtml+xml'])
if best is None:
best = "text/html"
return best
def test_best_match_with_one_lower_q():
accept = Accept('Content-Type', 'text/html, foo/bar;q=0.5')
assert accept.best_match(['text/html', 'foo/bar']) == 'text/html'
accept = Accept('Content-Type', 'text/html;q=0.5, foo/bar')
assert accept.best_match(['text/html', 'foo/bar']) == 'foo/bar'
