def render_param(param):
result = AsyncDict()
result.add("required", param.is_required)
result.add("info", render_value_info(param.value_info))
result.add_if_not_none("label", param.label)
result.add_if_not_none("desc", param.desc)
return result.wait()
def render_item(item, context):
result = AsyncDict()
result.add_if_not_none("label", item.label)
result.add_if_not_none("desc", item.desc)
result.add_if_true("metadata", render_metadata(item))
result.add_result("href", item.reference, "resolve", context)
args = (context, result)
return item.fetch().addCallbacks(render_attribute, filter_errors,
callbackArgs=args, errbackArgs=args)
def render_compact_model(model, context):
if IAttribute.providedBy(model):
attr = IAttribute(model)
if attr.is_readable:
d = attr.fetch_value()
d.addCallback(render_value, context)
return d
return defer.succeed(None)
if render_as_list(model):
return render_model_as_list(model, context)
result = AsyncDict()
if model.reference:
result.add_result("href", model.reference, "resolve", context)
d = model.fetch_items()
d.addCallback(render_compact_items, context, result)
return d
def render_actions(actions, context):
result = AsyncDict()
for action in actions:
result.add(action.name, render_action(action, context))
return result.wait()
def render_items(items, context):
result = AsyncDict()
for item in items:
result.add(item.name, render_item(item, context))
return result.wait()
def render_verbose(model, context):
result = AsyncDict()
result.add("identity", model.identity)
result.add_if_not_none("name", model.name)
result.add_if_not_none("label", model.label)
result.add_if_not_none("desc", model.desc)
result.add_result("href", model.reference, "resolve", context)
result.add_if_true("metadata", render_metadata(model))
result.add_if_true("items", render_model_items(model, context))
result.add_if_true("actions", render_model_actions(model, context))
return render_attribute(model, context, result)
def render_params(params):
result = AsyncDict()
for param in params:
result.add(param.name, render_param(param))
return result.wait()
def render_value_info(value):
result = AsyncDict()
result.add("type", value.value_type.name)
if value.use_default:
result.add("default", value.default)
result.add_if_not_none("label", value.label)
result.add_if_not_none("desc", value.desc)
result.add_if_true("metadata", render_metadata(value))
if IEncodingInfo.providedBy(value):
encinfo = IEncodingInfo(value)
result.add_if_not_none("mimetype", encinfo.mime_type)
result.add_if_not_none("encoding", encinfo.encoding)
if IValueCollection.providedBy(value):
coll = IValueCollection(value)
allowed = [render_value_info(v) for v in coll.allowed_types]
result.add("allowed", defer.join(*allowed))
result.add("ordered", coll.is_ordered)
result.add_if_not_none("min_size", coll.min_size)
result.add_if_not_none("max_size", coll.max_size)
if IValueRange.providedBy(value):
vrange = IValueRange(value)
result.add("minimum", vrange.minimum)
result.add("maximum", vrange.maximum)
result.add_if_not_none("increment", vrange.increment)
if IValueOptions.providedBy(value):
options = IValueOptions(value)
result.add("restricted", options.is_restricted)
result.add("options", [{"label": o.label, "value": o.value}
for o in options.iter_options()])
return result.wait()
def render_action(action, context):
result = AsyncDict()
result.add_if_not_none("label", action.label)
result.add_if_not_none("desc", action.desc)
result.add_if_true("metadata", render_metadata(action))
result.add("method", context.get_action_method(action).name)
result.add_if_true("idempotent", bool(action.is_idempotent))
result.add("category", action.category.name)
result.add_result("href", action.reference, "resolve", context)
if action.result_info is not None:
result.add("result", render_value_info(action.result_info))
if action.parameters:
result.add("params", render_params(action.parameters))
return result.wait()
