def annotate_fetch_documents(cls, effect):
cls._fetch_documents_set = True
cls._fetch_documents = model._validate_effect(effect)
def annotate_db_connection(cls, effect):
cls._connection_getter = model._validate_effect(effect)
def annotate_static_conditions(cls, effect):
cls._static_conditions = model._validate_effect(effect)
def annotate_view_factory(cls, factory, allowed_fields=[],
static_conditions=None,
fetch_documents=None):
cls._view = IQueryViewFactory(factory)
cls._static_conditions = (static_conditions and
model._validate_effect(static_conditions))
if not fetch_documents:
cls._fetch_documents_set = False
fetch_documents = effect.identity
else:
cls._fetch_documents_set = True
fetch_documents = fetch_documents
for x in allowed_fields:
if not cls._view.has_field(x):
raise ValueError("%r doesn't define a field: '%s'" % (cls, x))
cls._allowed_fields = allowed_fields
# define query action
name = utils.mk_class_name(cls._view.name, "Query")
QueryValue = MetaQueryValue.new(name, cls._view, cls._allowed_fields)
name = utils.mk_class_name(cls._view.name, "Sorting")
SortingValue = MetaSortingValue.new(name, cls._allowed_fields)
result_info = value.Model()
def get_static_conditions(value, context, *args, **kwargs):
def build_query(static_conditions, factory, q):
subquery = query.Query(factory, *static_conditions)
return query.Query(factory, q, query.Operator.AND, subquery)
cls = type(context['model'])
if cls._static_conditions:
d = cls._static_conditions(None, context)
d.addCallback(build_query, cls._view, kwargs['query'])
return d
return defer.succeed(kwargs['query'])
SelectAction = action.MetaAction.new(
utils.mk_class_name(cls._view.name, "Select"),
ActionCategories.retrieve,
is_idempotent=False, result_info=result_info,
effects=[
get_static_conditions,
call.model_perform('do_select'),
fetch_documents,
call.model_filter('render_select_response')],
params=[action.Param('query', QueryValue()),
action.Param('sorting', SortingValue(), is_required=False),
action.Param('skip', value.Integer(0), is_required=False),
action.Param('limit', value.Integer(), is_required=False)])
cls.annotate_action(u"select", SelectAction)
# define count action
CountAction = action.MetaAction.new(
utils.mk_class_name(cls._view.name, "Count"),
ActionCategories.retrieve,
effects=[
get_static_conditions,
call.model_perform('do_count')],
result_info=value.Integer(),
is_idempotent=False,
params=[action.Param('query', QueryValue())])
cls.annotate_action(u"count", CountAction)
