def test_querystring_from_order_by_without_key(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = None
op = 'asc'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
qs.from_order_by(query)
assert len(request.errors.messages) == 1
def test_querystring_from_order_by_without_key(self):
registry = self.init_registry(None)
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = None
op = 'asc'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
qs.from_order_by(query)
self.assertEqual(len(request.errors.messages), 1)
def test_querystring_from_order_by_ko_bad_op(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = 'name'
op = 'unknown'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
qs.from_order_by(query)
assert ("ORDER_by operator 'unknown' does not exist."
in request.errors.messages)
def test_querystring_from_order_by_bad_key(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = 'badkey'
op = 'asc'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
qs.from_order_by(query)
assert ("Order 'badkey': 'badkey' does not exist in model "
"<class 'anyblok.model.factory.ModelSystemBlok'>."
in request.errors.messages)
def test_querystring_from_order_by_bad_key_relationship(self):
registry = self.init_registry(add_many2one_class)
request = MockRequest(self)
model = registry.Test2
query = model.query()
key = 'test.badkey'
op = 'asc'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
qs.from_order_by(query)
self.assertIn(
"Order 'test.badkey': 'badkey' does not exist in model "
"<class 'anyblok.model.ModelTest'>.", request.errors.messages)
def test_querystring_from_order_by_bad_key_relationship(
self, registry_blok_with_m2o):
registry = registry_blok_with_m2o
request = MockRequest(self)
model = registry.Test2
query = model.query()
key = 'test.badkey'
op = 'asc'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
qs.from_order_by(query)
assert ("Order 'test.badkey': 'badkey' does not exist in model "
"<class 'anyblok.model.factory.ModelTest'>."
in request.errors.messages)
def update_from_query_string(request, Model, query, adapter):
headers = request.response.headers
if request.params:
# TODO: Implement schema validation to use request.validated
querystring = QueryString(request, Model, adapter=adapter)
total_query = querystring.from_filter_by(query)
total_query = querystring.from_tags(total_query)
query = querystring.from_order_by(total_query)
query = querystring.from_limit(query)
query = querystring.from_offset(query)
# TODO: Advanced pagination with Link Header
# Link: '<https://api.github.com/user/repos?page=3&per_page=100>;
# rel="next",
# <https://api.github.com/user/repos?page=50&per_page=100>;
# rel="last"'
headers['X-Count-Records'] = str(query.count())
headers['X-Total-Records'] = str(total_query.count())
# TODO: Etag / timestamp / 304 if no changes
# TODO: Cache headers
return query
else:
# no querystring, returns all records (maybe we will want to apply
# some default filters values
headers['X-Count-Records'] = str(query.count())
headers['X-Total-Records'] = str(query.count())
return query
def test_querystring_from_order_by_ok(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = 'name'
op = 'asc'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
Q = qs.from_order_by(query)
assert Q.all().name == query.order_by(model.name.asc()).all().name
def test_querystring_from_order_by_ok(self):
registry = self.init_registry(None)
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = 'name'
op = 'asc'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
Q = qs.from_order_by(query)
self.assertEqual(Q.all().name,
query.order_by(model.name.asc()).all().name)
def test_querystring_from_order_by_ok_with_relationship(self):
registry = self.init_registry(add_many2one_class)
request = MockRequest(self)
model = registry.Test2
query = model.query()
key = 'test.name'
op = 'asc'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
Q = qs.from_order_by(query)
t1 = registry.Test(name='test')
t2 = registry.Test(name='other')
model.insert(test=t1)
model.insert(test=t2)
model.insert(test=t2)
model.insert(test=t1)
query = query.join(registry.Test2.test)
query = query.order_by(registry.Test.name.asc())
self.assertEqual(Q.all(), query.all())
def test_querystring_from_order_by_ok_with_relationship(
self, registry_blok_with_m2o):
registry = registry_blok_with_m2o
request = MockRequest(self)
model = registry.Test2
query = model.query()
key = 'test.name'
op = 'asc'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
Q = qs.from_order_by(query)
t1 = registry.Test(name='test')
t2 = registry.Test(name='other')
model.insert(test=t1)
model.insert(test=t2)
model.insert(test=t2)
model.insert(test=t1)
query = query.join(registry.Test2.test)
query = query.order_by(registry.Test.name.asc())
assert Q.all() == query.all()
def read(cls, request):
# check user is disconnected
# check user has access rigth to see this resource
model = request.params['context[model]']
fields = cls.parse_fields(
request.params['context[fields]'],
model,
request.authenticated_userid,
)
# TODO complex case of relationship
Model = cls.anyblok.get(model)
adapter = Model.get_furetui_adapter()
qs = QueryString(request, Model, adapter=adapter)
query = cls.anyblok.Pyramid.restrict_query_by_user(
qs.Model.query(), request.authenticated_userid)
query = qs.from_filter_by(query)
query = qs.from_filter_by_primary_keys(query)
query = qs.from_composite_filter_by(query)
query = qs.from_tags(query)
query2 = qs.from_order_by(query)
query2 = qs.from_limit(query2)
query2 = qs.from_offset(query2)
query2 = query2.options(*cls.add_options(deepcopy(fields), model))
data = []
pks = []
def append_result(fields, model_name, entry):
model = cls.anyblok.get(model_name)
fd = model.fields_description()
current_fields = fields.pop("__fields")
current_fields.extend(fields.keys())
data.append({
'type': 'UPDATE_DATA',
'model': model_name,
'pk': entry.to_primary_keys(),
'data': entry.to_dict(*current_fields),
})
for field, subfield in fields.items():
children_entries = getattr(entry, field)
if children_entries:
if fd[field]['type'] in ('Many2One', 'One2One'):
children_entries = [children_entries]
for child_entry in children_entries:
append_result(deepcopy(fields[field]),
fd[field]['model'], child_entry)
for entry in query2:
pks.append(entry.to_primary_keys())
append_result(deepcopy(fields), model, entry)
# query.count do a sub query, we do not want it, because mysql
# has a terrible support of subqueries
# total = query.with_entities(func.count('*')).scalar()
total = query.count()
return {
'pks': pks,
'total': total,
'data': data,
}
