def permissions(node, kwargs):
def get_perms(node, kwargs):
return kwargs.get("permissions")
# Set if node is provided, else keep deferred. This allows binding the body
# on Resource first and bind permissions later if using SharableResource.
return get_perms(node, kwargs) or colander.deferred(get_perms)
def permissions(node, kwargs):
def get_perms(node, kwargs):
return kwargs.get("permissions")
# Set if node is provided, else keep deferred. This allows binding the body
# on Resource first and bind permissions later if using SharableResource.
return get_perms(node, kwargs) or colander.deferred(get_perms)
def metadata_schema_node(prop: InstrumentedAttribute,
model: DeclarativeMeta) -> colander.SequenceSchema:
"""Get the schema of a collection of metadata."""
# Deferred which returns a dictionary with metadata name as key and metadata definition as value.
# Needed to get the metadata types on UI side.
metadata_definitions_dict = colander.deferred(
lambda node, kw: {
m["name"]: _translate_available_metadata(m, kw["request"])
for m in metadata_definitions(kw["request"].registry.settings,
model)
})
return colander.SequenceSchema(
MetadataSchemaNode(
Metadata,
name="metadata",
metadata_definitions=metadata_definitions_dict,
validator=regex_validator,
widget=MappingWidget(template="metadata"),
overrides={"name": {
"widget": metadata_name_widget(model)
}},
),
name=prop.key,
title=prop.info["colanderalchemy"]["title"],
description=prop.info["colanderalchemy"]["description"],
metadata_definitions=metadata_definitions_dict,
widget=SequenceWidget(template="metadatas", category="structural"),
)
def children_schema_node(only_groups: bool = False) -> colander.SequenceSchema:
"""Geth the sequence to the children nodes."""
return colander.SequenceSchema(
ChildSchemaNode(
LayergroupTreeitem,
name="layergroup_treeitem",
widget=ChildWidget(
input_name="treeitem_id",
model=TreeItem,
label_field="name",
icon_class=lambda treeitem: f"icon-{treeitem.item_type}",
edit_url=treeitem_edit_url,
),
),
name="children_relation",
title=_("Children"),
description=Literal(
_(
"""
<div class="help-block">
<p>The ordered children elements.</p>
<hr>
</div>
"""
),
),
candidates=colander.deferred(partial(treeitems, only_groups=only_groups)),
validator=children_validator,
widget=ChildrenWidget(child_input_name="treeitem_id", add_subitem=True, orderable=True),
)
def permissions(node, kwargs):
def get_perms(node, kwargs):
return kwargs.get("permissions")
# Set if node is provided, else keep deferred. This allows binding the body
# on Resource first and bind permissions later.
# XXX: probably not necessary now that UserResource is gone.
return get_perms(node, kwargs) or colander.deferred(get_perms)
def parent_id_node(model):
return colander.SchemaNode(colander.Integer(),
name='parent_id',
missing=colander.drop,
validator=colander.deferred(
partial(base_deferred_parent_id_validator,
model=model)),
widget=deform.widget.HiddenWidget())
class PersonaSchema(CSRFSchema):
id = colander.SchemaNode(colander.Integer(),
widget=colander.deferred(
lambda node, kw: deform.widget.SelectWidget(
values=api.personas(kw['request']),
css_class='dropdown-menu pull-right',
template='tinyman'),
),
missing=-1)
def metadata_name_widget(model: DeclarativeMeta) -> colander.deferred:
"""Return a colander deferred which itself returns a widget for the metadata name field."""
def create_widget(node, kw):
del node
return MetadataSelectWidget(
values=[(m["name"], m["name"]) for m in sorted(
metadata_definitions(kw["request"].registry.settings, model),
key=lambda m: cast(str, m["name"]),
)])
return colander.deferred(create_widget)
def children_schema_node(only_groups=False):
return colander.SequenceSchema(
ChildSchemaNode(LayergroupTreeitem,
name="layergroup_treeitem",
widget=ChildWidget()),
name="children_relation",
title=_("Children"),
treeitems=colander.deferred(partial(treeitems,
only_groups=only_groups)),
validator=children_validator,
widget=ChildrenWidget(category="structural"),
)
def children_schema_node(only_groups=False):
return colander.SequenceSchema(
ChildSchemaNode(
LayergroupTreeitem,
name='layergroup_treeitem',
widget=ChildWidget()
),
name='children_relation',
treeitems=colander.deferred(partial(treeitems, only_groups=only_groups)),
validator=children_validator,
widget=ChildrenWidget()
)
def children_schema_node(only_groups=False):
return colander.SequenceSchema(
ChildSchemaNode(
LayergroupTreeitem,
name="layergroup_treeitem",
widget=ChildWidget(
input_name="treeitem_id",
model=TreeItem,
label_field="name",
icon_class=lambda treeitem: "icon-{}".format(treeitem.item_type
),
edit_url=treeitem_edit_url,
),
),
name="children_relation",
title=_("Children"),
candidates=colander.deferred(
partial(treeitems, only_groups=only_groups)),
validator=children_validator,
widget=ChildrenWidget(child_input_name="treeitem_id",
add_subitem=True,
orderable=True),
)
def functionalities_widget(model: DeclarativeMeta) -> colander.deferred:
"""Return a colander deferred which itself returns a widget for the functionalities field."""
def create_widget(node, kw):
del node
return RelationCheckBoxListWidget(
select([
Functionality.id,
concat(Functionality.name, "=",
Functionality.value).label("label"),
]).where(
Functionality.name.in_([
f["name"] for f in available_functionalities_for(
kw["request"].registry.settings, model)
])).alias("functionality_labels"),
"id",
"label",
order_by="label",
edit_url=lambda request, value: request.route_url(
"c2cgeoform_item", table="functionalities", id=value),
)
return colander.deferred(create_widget)
includes=["id"],
widget=ChildWidget(
input_name="id",
model=User,
label_field="username",
icon_class=lambda user: "******",
edit_url=lambda request, user: request.route_url(
"c2cgeoform_item",
table="users",
id=user.id,
),
),
),
name="users",
title=_("Users"),
candidates=colander.deferred(users),
widget=ChildrenWidget(child_input_name="id", orderable=False, category="structural"),
)
)
@view_defaults(match_param="table=roles")
class RoleViews(AbstractViews):
_list_fields = [
_list_field("id"),
_list_field("name"),
_list_field("description"),
_list_field(
"functionalities",
renderer=lambda role: ", ".join(["{}={}".format(f.name, f.value) for f in role.functionalities]),
),
def DeferredRelation(model):
def deferred_relation_type(node, kw):
db_session = kw['db_session']
return Relation(model, db_session)
return colander.deferred(deferred_relation_type)
colander.SequenceSchema(
GeoFormManyToManySchemaNode(
Layer,
name="layer",
includes=["id"],
widget=ChildWidget(
input_name="id",
model=Layer,
label_field="name",
icon_class=lambda layer: "icon-{}".format(layer.item_type),
edit_url=treeitem_edit_url,
),
),
name="layers",
title=_("Layers"),
candidates=colander.deferred(layers),
widget=ChildrenWidget(child_input_name="id", orderable=False),
))
@view_defaults(match_param="table=restriction_areas")
class RestrictionAreaViews(AbstractViews):
_list_fields = [
_list_field("id"),
_list_field("name"),
_list_field("description"),
_list_field("readwrite"),
_list_field("roles",
renderer=lambda restriction_area: ", ".join(
r.name for r in restriction_area.roles)),
_list_field(
# Unpack.
request = kw['request']
template_id_key = getattr(node, 'template_id_key', 'template_id')
should_render_config = getattr(node, 'should_render_config', False)
allow_remove = getattr(node, 'allow_remove', False)
category = getattr(node, 'category', None)
# Get signed config.
config_str, signature = get_signed_config(request, template_id_key)
# Return the widget.
return widget_cls(config_str=config_str, signature=signature,
allow_remove=allow_remove, category=category,
should_render_config=should_render_config)
transloadit_image_widget = colander.deferred(_transloadit_image_widget)
def _transloadit_config_widget(node, kw, get_config=None, widget_cls=None):
"""As with ``transloadit_image_widget`` but a ``TransloaditConfigWidget``."""
# Compose.
if get_config is None:
get_config = get_signed_config
if widget_cls is None:
widget_cls = TransloaditConfigWidget
# Unpack.
request = kw['request']
template_id_key = getattr(node, 'template_id_key', 'template_id')
should_render_config = getattr(node, 'should_render_config', True)
category = getattr(node, 'category', None)
def body(node, kwargs):
def get_body(node, kwargs):
return kwargs.get('body')
# Set if node is provided, else keep deferred (and allow bindind later)
return get_body(node, kwargs) or colander.deferred(get_body)
def body(node, kwargs):
def get_body(node, kwargs):
return kwargs.get("body")
# Set if node is provided, else keep deferred (and allow bindind later)
return get_body(node, kwargs) or colander.deferred(get_body)
available_functionality: Dict[str, Any],
request: pyramid.request.Request) -> Dict[str, Any]:
result = {}
result.update(available_functionality)
result["description"] = request.localizer.translate(
_(available_functionality.get("description", "").strip()))
return result
base_schema = GeoFormSchemaNode(
Functionality,
widget=FormWidget(fields_template="functionality_fields"),
functionalities=colander.deferred(
lambda node, kw: {
f["name"]: _translate_available_functionality(f, kw["request"])
for f in kw["request"].registry.settings["admin_interface"][
"available_functionalities"]
},
),
)
@view_defaults(match_param="table=functionalities")
class FunctionalityViews(AbstractViews): # type: ignore
"""The functionality administration view."""
_list_fields = [
_list_field("id"),
_list_field("name"),
_list_field("description"),
_list_field("value")
