def _preload_items(env, entries):
by_stream = {}
for entry in entries:
by_stream.setdefault(entry.stream_name, [])
by_stream[entry.stream_name].append(entry.object_id)
by_stream_and_id = {}
for stream_name, ids in by_stream.items():
name = stream_name.split(':')[0]
if name not in env.streams:
continue
stream = env.streams[name]
lang = decode_stream_uid(stream_name)[1].get('lang')
stream_env = VersionedStorage(version="admin", lang=lang)
stream_env._storage._parent_storage = env
# XXX only for multi db! will fail on single db
stream_env.models = env.models_.admin
if lang:
stream_env.models = getattr(stream_env.models, lang)
M = stream.get_model(stream_env)
items = stream.item_query(stream_env).filter(M.id.in_(ids)).all()
for item in items:
by_stream_and_id[(stream_name, str(item.id))] = item
return by_stream_and_id
def _expand(env, obj, for_item=None):
# XXX all this is like a hack!
stream_name = obj.stream_name.split(':')[0]
if stream_name not in env.streams:
return {}
stream = env.streams[stream_name]
lang = decode_stream_uid(obj.stream_name)[1].get('lang')
if for_item is None:
stream_env = VersionedStorage(version="admin", lang=lang)
stream_env._storage._parent_storage = env
# XXX only for multi db! will fail on single db
stream_env.models = env.models.admin
if lang:
stream_env.models = getattr(stream_env.models, lang)
else:
stream_env = env
assert 'r' in stream.get_permissions(stream_env)
if for_item is None:
item = stream.item_query(stream_env).filter_by(id=obj.object_id).first()
else:
item = for_item
if item is not None:
item_title = getattr(item, 'title', unicode(item))
else:
item_title = u"<{}: удалённый или недоступный объект: {}>".format(
stream.title, obj.object_id)
return {"obj": obj,
"stream": stream,
"item": item,
"item_title": item_title,
"lang": lang,
"type": stream.edit_log_action.log_type_title(obj)}
def _preload_items(env, entries):
by_stream = {}
for entry in entries:
by_stream.setdefault(entry.stream_name, [])
by_stream[entry.stream_name].append(entry.object_id)
by_stream_and_id = {}
for stream_name, ids in by_stream.items():
name = stream_name.split(':')[0]
if name not in env.streams:
continue
stream = env.streams[name]
lang = decode_stream_uid(stream_name)[1].get('lang')
stream_env = VersionedStorage(version="admin", lang=lang)
stream_env._storage._parent_storage = env
# XXX only for multi db! will fail on single db
stream_env.models = env.models_.admin
if lang:
stream_env.models = getattr(stream_env.models, lang)
M = stream.get_model(stream_env)
items = stream.item_query(stream_env).filter(M.id.in_(ids)).all()
for item in items:
by_stream_and_id[(stream_name, str(item.id))] = item
return by_stream_and_id
def test_as_dict(self):
'VersionedStorage as_dict method'
vs = VersionedStorage(a=1)
a = vs._storage
b = vs._push(b=2)
c = vs._push(c=3, b=4)
self.assertEqual(a.as_dict(), {'a': 1})
self.assertEqual(b.as_dict(), {'a': 1, 'b': 2})
self.assertEqual(c.as_dict(), {'a': 1, 'b': 4, 'c': 3})
def test_as_dict(self):
'VersionedStorage as_dict method'
vs = VersionedStorage(a=1)
a = vs._storage
b = vs._push(b=2)
c = vs._push(c=3, b=4)
self.assertEqual(a.as_dict(), {'a': 1})
self.assertEqual(b.as_dict(), {'a': 1, 'b': 2})
self.assertEqual(c.as_dict(), {'a': 1, 'b': 4, 'c': 3})
def test_hasattr(self):
'VersionedStorage __getattr__ method'
vs = VersionedStorage(a=1)
vs._push(b=2)
vs._push(c=3, b=4)
self.assert_(hasattr(vs, 'a'))
self.assert_(hasattr(vs, 'b'))
self.assert_(hasattr(vs, 'c'))
self.assert_(not hasattr(vs, 'd'))
def env(self):
DIR = jnj.__file__
DIR = path.dirname(path.abspath(DIR))
TEMPLATES = [path.join(DIR, 'templates')]
jinja_loader = TemplateEngine(TEMPLATES)
template_loader = Template(engines={'html': jinja_loader}, *TEMPLATES)
env = VersionedStorage()
env.template = BoundTemplate(env, template_loader)
return env
def env(self):
DIR = jnj.__file__
DIR = path.dirname(path.abspath(DIR))
TEMPLATES = [path.join(DIR, "templates")]
jinja_loader = TemplateEngine(TEMPLATES)
template_loader = Template(engines={"html": jinja_loader}, *TEMPLATES)
env = VersionedStorage()
env.template = BoundTemplate(env, template_loader)
return env
def test_List(self):
'cases handle'
@F
def h1(env, data, nh):
self.assertEqual(env.count, 0)
env.count = env.count + 1
return nh(env, data)
@F
def h2(env, data, nh):
self.assertEqual(env.count, 0)
env.count = env.count + 1
return nh(env, data)
@F
def h3(env, data, nh):
self.assertEqual(env.count, 0)
env.count = env.count + 1
return nh(env, data)
chain = web.cases(h1, h2, h3)
env = VersionedStorage(count=0)
self.assert_(chain(env, VS()) is None)
self.assertEqual(env.count, 0)
def __call__(self, environ, start_response):
'''
WSGI interface method.
Creates webob and iktomi wrappers and calls `handle` method.
'''
# validating Host header to prevent problems with url parsing
if not is_host_valid(environ['HTTP_HOST']):
logger.warning('Unusual header "Host: {}", return HTTPNotFound'\
.format(environ['HTTP_HOST']))
return HTTPNotFound()(environ, start_response)
request = Request(environ, charset='utf-8')
env = VersionedStorage(self.env_class, request=request, root=self.root)
data = VersionedStorage()
response = self.handle(env, data)
try:
result = response(environ, start_response)
except Exception:
self.handle_error(env)
result = HTTPInternalServerError()(environ, start_response)
return result
def log_entry(self, env, data):
#insure_is_xhr(env)
if getattr(env, 'version', None) == 'front':
raise HTTPNotFound()
EditLog = env.edit_log_model
log = EditLog.query_for_item(env.db, data.item)\
.filter_by(id=data.log_id)\
.first()
if log is None:
raise HTTPNotFound()
rel_stream_name, params = decode_stream_uid(log.stream_name)
if rel_stream_name in env.streams:
rel_stream = env.streams[rel_stream_name]
else:
# Deleted or renamed stream
raise NotImplementedError("Deleted or renamed stream",
rel_stream_name)
rel_env = VersionedStorage(**params)
rel_env._storage._parent_storage = env
form_cls = rel_stream.config.ItemForm
item_cp = type(data.item)(id=data.item.id)
form1 = form_cls.load_initial(env, item_cp, initial={})
form2 = form_cls.load_initial(env, item_cp, initial={})
form1.model = form2.model = rel_stream.get_model(env)
form1.accept(log.before)
form2.accept(log.after)
# reset permissions
form1.permissions = form2.permissions = frozenset('r')
form1.fields = [field(parent=form1) for field in form1.fields]
form2.fields = [field(parent=form2) for field in form2.fields]
diff = form1.get_diff(form2)
diffs = diff['children'] if diff is not None else []
return env.render_to_response(
'edit_log/item',
dict(form1=form1,
form2=form2,
diffs=diffs,
log=log,
stream=self.stream,
item=data.item,
log_type=self.log_type_title(log)))
def expand_stream(env, obj):
stream_name, params = decode_stream_uid(obj.stream_name)
stream_env = VersionedStorage()
stream_env._storage._parent_storage = env
if 'lang' in params:
stream_env.models = getattr(env.models, params['lang'])
stream_env.lang = params['lang']
if stream_name not in env.streams:
# Deleted or renamed stream
raise NotImplementedError
stream = env.streams[stream_name]
item = stream.item_query(stream_env)\
.filter_by(id=obj.object_id).first()
if item is not None:
stream_title = stream.title
if 'lang' in params:
stream_title = I18nLabel(stream_title, params['lang'])
url = stream.url_for(stream_env, 'item',
item=obj.object_id, **params)
return (url, stream_title, stream, obj, item)
def expand_stream(env, obj):
stream_name, params = decode_stream_uid(obj.stream_name)
stream_env = VersionedStorage()
stream_env._storage._parent_storage = env
if 'lang' in params:
stream_env.models = getattr(env.models, params['lang'])
stream_env.lang = params['lang']
if stream_name not in env.streams:
# Deleted or renamed stream
raise NotImplementedError
stream = env.streams[stream_name]
item = stream.item_query(stream_env)\
.filter_by(id=obj.object_id).first()
if item is not None:
stream_title = stream.title
if 'lang' in params:
stream_title = I18nLabel(stream_title, params['lang'])
url = stream.url_for(stream_env, 'item',
item=obj.object_id, **params)
return (url, stream_title, stream, obj, item)
def _expand(env, obj, for_item=None):
# XXX all this is like a hack!
stream_name = obj.stream_name.split(':')[0]
if stream_name not in env.streams:
return {}
stream = env.streams[stream_name]
lang = decode_stream_uid(obj.stream_name)[1].get('lang')
if for_item is None:
stream_env = VersionedStorage(version="admin", lang=lang)
stream_env._storage._parent_storage = env
# XXX only for multi db! will fail on single db
stream_env.models = env.models.admin
if lang:
stream_env.models = getattr(stream_env.models, lang)
else:
stream_env = env
assert 'r' in stream.get_permissions(stream_env)
if for_item is None:
item = stream.item_query(stream_env).filter_by(
id=obj.object_id).first()
else:
item = for_item
if item is not None:
item_title = getattr(item, 'title', unicode(item))
else:
item_title = u"<{}: удалённый или недоступный объект: {}>".format(
stream.title, obj.object_id)
return {
"obj": obj,
"stream": stream,
"item": item,
"item_title": item_title,
"lang": lang,
"type": stream.edit_log_action.log_type_title(obj)
}
def command_generate(self):
from front.environment import FrontEnvironment, environment
from front.urls import app
env = VersionedStorage(FrontEnvironment,
Request.blank('/'),
Reverse.from_handler(app))
for lang in self.langs:
env.lang = Lang(env, lang)
env.models = getattr(models.front, lang)
for error in self.errors:
handler = environment | (
lambda env, data: env.render_to_string('errors/' + error, {}))
tmpl = handler(env, VersionedStorage()).encode('utf-8')
out = os.path.join(env.cfg.STATIC, lang, error+'.html')
if os.path.isfile(out):
with open(out, 'r') as f:
existing = f.read()
if existing == tmpl:
continue
with open(out, 'w') as f:
f.write(tmpl)
logger.info("Rendered %s/%s.html", lang, error)
def test_storage_properties(self):
class Env(StorageFrame):
@storage_cached_property
def storage_cached(self):
return self.value
@storage_cached_property
def storage_cached_2(self):
return self.value
@storage_property
def storage(self):
return self.value
@storage_method
def method(self):
return self.value
vs = VersionedStorage(Env)
vs._push(value=4)
self.assertEqual(vs.storage_cached, 4)
self.assertEqual(vs.storage, 4)
self.assertEqual(vs.method(), 4)
vs._push(value=1)
self.assertEqual(vs.storage_cached, 4)
self.assertEqual(vs.storage_cached_2, 1) # XXX is this right?
self.assertEqual(vs.storage, 1)
self.assertEqual(vs.method(), 1)
vs._pop()
vs._pop()
self.assertEqual(vs.storage_cached, 4)
self.assertEqual(vs.storage_cached_2, 1) # XXX is this right?
self.assertRaises(AttributeError, lambda: vs.storage)
self.assertRaises(AttributeError, vs.method)
def __call__(self, environ, start_response):
'''
WSGI interface method.
Creates webob and iktomi wrappers and calls `handle` method.
'''
request = self.create_request(environ)
env = self.create_environment(request)
data = VersionedStorage()
response = self.handle(env, data)
try:
result = response(environ, start_response)
except Exception:
self.handle_error(env)
result = HTTPInternalServerError()(environ, start_response)
return result
def test_hasattr(self):
'VersionedStorage __getattr__ method'
vs = VersionedStorage(a=1)
vs._push(b=2)
vs._push(c=3, b=4)
self.assert_(hasattr(vs, 'a'))
self.assert_(hasattr(vs, 'b'))
self.assert_(hasattr(vs, 'c'))
self.assert_(not hasattr(vs, 'd'))
def test_storage_properties(self):
class Env(StorageFrame):
@storage_cached_property
def storage_cached(self):
return self.value
@storage_cached_property
def storage_cached_2(self):
return self.value
@storage_property
def storage(self):
return self.value
@storage_method
def method(self):
return self.value
vs = VersionedStorage(Env)
vs._push(value=4)
self.assertEqual(vs.storage_cached, 4)
self.assertEqual(vs.storage, 4)
self.assertEqual(vs.method(), 4)
vs._push(value=1)
self.assertEqual(vs.storage_cached, 4)
self.assertEqual(vs.storage_cached_2, 1) # XXX is this right?
self.assertEqual(vs.storage, 1)
self.assertEqual(vs.method(), 1)
vs._pop()
vs._pop()
self.assertEqual(vs.storage_cached, 4)
self.assertEqual(vs.storage_cached_2, 1) # XXX is this right?
self.assertRaises(AttributeError, lambda: vs.storage)
self.assertRaises(AttributeError, vs.method)
def get_front_item_form(self, env, item):
front_models = _AdminReplicated.front
if getattr(env, "lang", None):
front_models = getattr(front_models, env.lang)
front_env = VersionedStorage(db=env.db,
models=front_models,
user=env.user,
version='front')
front_env._storage._parent_storage = env
form_cls = self.stream.config.ItemForm(front_env, {}, item._front_item)
form = form_cls.load_initial(env,
item._front_item,
initial={},
permissions='r')
form.model = self.stream.get_model(env)
return form
def call_with_front_env(env, data, nxt):
request = Request.blank(env._route_state.path+'?'+env.request.query_string,
charset='utf-8')
front_env = VersionedStorage(wsgi_app.env_class, request, wsgi_app.root)
# env.root is created in wsgi_app, we do not wrap front app in one,
# so we have to create env.root manually
front_env.root = env.root.front(version=env.version, lang=env.lang)\
.bind_to_env(front_env)
front_env.models = env.models
# we wave set language explicitly here, because language detection is based
# on subdomains, and we do not have ones in admin
front_env.langs = [Lang(front_env, n) for n in ['en', 'ru']]
front_env.lang = [x for x in front_env.langs if x == env.lang][0]
front_env.matched_domain = ''
front_env.db = env.db
front_data = VersionedStorage()
front_env.data = front_data
# XXX hack to make cfg configurable
_cfg = front_env.cfg
front_env.cfg = VersionedStorage()
front_env.cfg._storage._parent_storage = _cfg
_cfg._parent_storage = None
front_env.cfg.STATIC_URL = env.cfg.FRONT_STATIC_URL
front_env.cfg.PREVIEW = True
front_env.cfg.DOMAINS = [env.request.host.split(':', 1)[0]]
old_query = front_env.db._query_cls
try:
query_cls = AdminPublicQuery# if env.version == 'admin' else PublicQuery
# XXX hack!
front_env.db._query_cls = query_cls
return nxt(front_env, front_data)
finally:
front_env.db._query_cls = old_query
def get_data(self):
return VersionedStorage()
def test_setattr(self):
'VersionedStorage setattr and push/pop'
vs = VersionedStorage(a=1)
vs._push()
vs.b = 2
self.assertEqual(vs.as_dict(), {'a': 1, 'b': 2})
vs._push()
vs.c = 3
vs.b = 4
self.assertEqual(vs.as_dict(), {'a': 1, 'b': 4, 'c': 3})
vs._pop()
self.assertEqual(vs.as_dict(), {'a': 1, 'b': 2})
vs._pop()
self.assertEqual(vs.as_dict(), {'a': 1})
def test_push_pop(self):
'VersionedStorage push/pop'
vs = VersionedStorage(a=1)
self.assertEqual(vs.as_dict(), {'a': 1})
vs._push(b=2)
self.assertEqual(vs.as_dict(), {'a': 1, 'b': 2})
vs._push(c=3, b=4)
self.assertEqual(vs.as_dict(), {'a': 1, 'b': 4, 'c': 3})
vs._pop()
self.assertEqual(vs.as_dict(), {'a': 1, 'b': 2})
vs._pop()
self.assertEqual(vs.as_dict(), {'a': 1})
def test_push_pop(self):
'VersionedStorage push/pop'
vs = VersionedStorage(a=1)
self.assertEqual(vs.as_dict(), {'a': 1})
vs._push(b=2)
self.assertEqual(vs.as_dict(), {'a': 1, 'b': 2})
vs._push(c=3, b=4)
self.assertEqual(vs.as_dict(), {'a': 1, 'b': 4, 'c': 3})
vs._pop()
self.assertEqual(vs.as_dict(), {'a': 1, 'b': 2})
vs._pop()
self.assertEqual(vs.as_dict(), {'a': 1})
def create(cls, *args, **kwargs):
return VersionedStorage(cls, *args, **kwargs)
def test_setattr(self):
'VersionedStorage setattr and push/pop'
vs = VersionedStorage(a=1)
vs._push()
vs.b = 2
self.assertEqual(vs.as_dict(), {'a': 1, 'b': 2})
vs._push()
vs.c = 3
vs.b = 4
self.assertEqual(vs.as_dict(), {'a': 1, 'b': 4, 'c': 3})
vs._pop()
self.assertEqual(vs.as_dict(), {'a': 1, 'b': 2})
vs._pop()
self.assertEqual(vs.as_dict(), {'a': 1})
def env(self):
# XXX hack
env = super(LangLonerMenu, self).env
vs = VersionedStorage(lang=self.lang)
vs._storage._parent_storage = env
return vs
def publish_queue(self, env, data):
#insure_is_xhr(env)
changed = []
for stream in self.streams.values():
if isinstance(stream, I18nPublishStream):
for lang, lang_name in stream.langs:
subenv = VersionedStorage()
subenv._parent_storage = env
subenv.models = getattr(env.models.admin, lang)
subenv.version = 'admin'
subenv.lang = lang
items = stream.item_query(subenv)\
.filter_by(has_unpublished_changes=True)
if hasattr(stream.config.Model, 'state'):
items = items.filter_by(state=stream.config.Model.PUBLIC)
items = items.all()
changed += [(stream, subenv, item) for item in items]
elif isinstance(stream, PublishStream):
subenv = VersionedStorage()
subenv._parent_storage = env
subenv.models = env.models.admin
subenv.version = 'admin'
items = stream.item_query(subenv)\
.filter_by(has_unpublished_changes=True)
if hasattr(stream.config.Model, 'state'):
items = items.filter_by(state=stream.config.Model.PUBLIC)
items = items.all()
changed += [(stream, subenv, item) for item in items]
changed.sort(key=lambda x: x[2].updated_dt)
return env.render_to_response('publish_queue', dict(
changed = changed,
menu = env.current_location,
title = u'Очередь публикации',
))
def env_data(self, wsgi_app, path):
request = Request.blank(path)
env = VersionedStorage(wsgi_app.env_class, request, wsgi_app.root)
data = VersionedStorage()
return env, data
def get_env(self, request):
return VersionedStorage(self.env_class, request=request, app=self)
