async def test_register_behavior(container_requester):
cur_count = len(
configure.get_configurations("guillotina.tests", "behavior"))
from guillotina.interfaces import IResource
from guillotina import schema
class IMyBehavior(Interface):
foobar = schema.Text()
class IMyBehavior2(Interface):
foobar = schema.Text()
configure.behavior(
title="MyBehavior",
provides=IMyBehavior,
factory="guillotina.behaviors.instance.AnnotationBehavior",
for_="guillotina.interfaces.IResource",
)()
configure.behavior(
title="MyBehavior2",
provides=IMyBehavior2,
factory="guillotina.behaviors.instance.AnnotationBehavior",
for_="guillotina.interfaces.IResource",
)()
assert len(configure.get_configurations("guillotina.tests",
"behavior")) == cur_count + 2
class IMyType(IResource):
pass
class MyType(Item):
pass
configure.register_configuration(
MyType,
dict(context=IContainer,
schema=IMyType,
type_name="MyType2",
behaviors=[IMyBehavior]),
"contenttype",
)
root = get_utility(IApplication, name="root")
config = root.app.config
# now test it...
configure.load_configuration(config, "guillotina.tests", "contenttype")
configure.load_configuration(config, "guillotina.tests", "behavior")
config.execute_actions()
async with container_requester as requester:
response, status = await requester("GET", "/db/guillotina/@types")
type_ = [s for s in response if s["title"] == "MyType2"][0]
assert "foobar" in type_["definitions"][
"guillotina.tests.test_configure.IMyBehavior"]["properties"]
# also get_all_possible_schemas_for_type should come with this new behavior
behaviors_schemas = get_all_possible_schemas_for_type("MyType2")
assert IMyBehavior2 in behaviors_schemas
def get_mappings(schemas=None, schema_info=False):
if schemas is None:
schemas = []
for name, _ in get_utilities_for(IResourceFactory):
# For each type
for schema in get_all_possible_schemas_for_type(name):
schemas.append(schema)
schemas = set(schemas)
mappings = {}
schema_field_mappings = {}
for schema in schemas:
index_fields = merged_tagged_value_dict(
schema, guillotina.directives.index.key)
for field_name, catalog_info in index_fields.items():
index_name = catalog_info.get('index_name', field_name)
catalog_type = catalog_info.get('type', 'text')
field_mapping = catalog_info.get('field_mapping', None)
if field_mapping is None:
field_mapping = CATALOG_TYPES[catalog_type].copy()
if 'store' in catalog_info:
field_mapping['store'] = catalog_info['store']
if schema_info:
if '_schemas' not in field_mapping:
field_mapping['_schemas'] = []
if schema.__identifier__ not in field_mapping['_schemas']:
field_mapping['_schemas'].append(schema.__identifier__)
if (index_name in mappings
and mappings[index_name] != field_mapping):
existing_addon_idx = _addon_index(
schema_field_mappings[index_name])
field_addon_idx = _addon_index(catalog_info['__schema__'])
if existing_addon_idx > field_addon_idx:
# we're keeping current value
continue
elif existing_addon_idx == field_addon_idx:
# we are customizing same field mapping in same addon!
# this should not be allowed
raise Exception(
f'''Unresolvable index mapping conflict: {index_name}
Registered schema: {schema_field_mappings[index_name].__identifier__}
Registered mapping: {mappings[index_name]}
Conflicted schema: {catalog_info['__schema__'].__identifier__}
Registered mapping: {field_mapping}
''')
schema_field_mappings[index_name] = catalog_info['__schema__']
mappings[index_name] = field_mapping
return {
'properties': mappings,
'dynamic': False,
'_all': {
'enabled': False
}
}
async def test_register_behavior(container_requester):
cur_count = len(
configure.get_configurations('guillotina.tests', 'behavior'))
from guillotina.interfaces import IFormFieldProvider, IResource
from zope.interface import provider
from guillotina import schema
@provider(IFormFieldProvider)
class IMyBehavior(Interface):
foobar = schema.Text()
class IMyBehavior2(Interface):
foobar = schema.Text()
configure.behavior(
title="MyBehavior",
provides=IMyBehavior,
factory="guillotina.behaviors.instance.AnnotationBehavior",
for_="guillotina.interfaces.IResource"
)()
configure.behavior(
title="MyBehavior2",
provides=IMyBehavior2,
factory="guillotina.behaviors.instance.AnnotationBehavior",
for_="guillotina.interfaces.IResource"
)()
assert len(configure.get_configurations('guillotina.tests', 'behavior')) == cur_count + 2
class IMyType(IResource):
pass
class MyType(Item):
pass
configure.register_configuration(MyType, dict(
context=IContainer,
schema=IMyType,
type_name="MyType2",
behaviors=[IMyBehavior]
), 'contenttype')
root = getUtility(IApplication, name='root')
config = root.app.config
# now test it...
configure.load_configuration(config, 'guillotina.tests', 'contenttype')
configure.load_configuration(config, 'guillotina.tests', 'behavior')
config.execute_actions()
async with await container_requester as requester:
response, status = await requester('GET', '/db/guillotina/@types')
type_ = [s for s in response if s['title'] == 'MyType2'][0]
assert 'foobar' in type_['definitions']['IMyBehavior']['properties']
# also get_all_possible_schemas_for_type should come with this new behavior
behaviors_schemas = get_all_possible_schemas_for_type('MyType2')
assert IMyBehavior2 in behaviors_schemas
def get_mappings(schemas=None, schema_info=False):
if schemas is None:
schemas = []
for name, _ in get_utilities_for(IResourceFactory):
# For each type
for schema in get_all_possible_schemas_for_type(name):
schemas.append(schema)
schemas = set(schemas)
mappings = {}
schema_field_mappings = {}
for schema in schemas:
index_fields = merged_tagged_value_dict(
schema, guillotina.directives.index.key)
for field_name, catalog_info in index_fields.items():
index_name = catalog_info.get("index_name", field_name)
catalog_type = catalog_info.get("type", "text")
field_mapping = catalog_info.get("field_mapping", None)
if field_mapping is None:
field_mapping = CATALOG_TYPES[catalog_type].copy()
if "store" in catalog_info:
field_mapping["store"] = catalog_info["store"]
if schema_info:
if "_schemas" not in field_mapping:
field_mapping["_schemas"] = []
if schema.__identifier__ not in field_mapping["_schemas"]:
field_mapping["_schemas"].append(schema.__identifier__)
if index_name in mappings and mappings[index_name] != field_mapping:
existing_addon_idx = _addon_index(
schema_field_mappings[index_name])
field_addon_idx = _addon_index(catalog_info["__schema__"])
if existing_addon_idx > field_addon_idx:
# we're keeping current value
continue
elif existing_addon_idx == field_addon_idx:
# we are customizing same field mapping in same addon!
# this should not be allowed
raise Exception(
f"""Unresolvable index mapping conflict: {index_name}
Registered schema: {schema_field_mappings[index_name].__identifier__}
Registered mapping: {mappings[index_name]}
Conflicted schema: {catalog_info['__schema__'].__identifier__}
Registered mapping: {field_mapping}
""")
schema_field_mappings[index_name] = catalog_info["__schema__"]
mappings[index_name] = field_mapping
return {"properties": mappings}
async def run(self, arguments, settings, app):
if arguments.schema:
self.selected_schemas = [
resolve_dotted_name(s) for s in arguments.schema]
if arguments.type:
if self.selected_schemas is None:
self.selected_schemas = []
for type_name in arguments.type:
for schema in get_all_possible_schemas_for_type(type_name):
self.selected_schemas.append(schema)
if self.arguments.summary:
self.summary()
else:
fields = get_mappings(self.selected_schemas, schema_info=True)['properties']
pprint(fields)
def get_index_fields():
schemas = []
for name, _ in get_utilities_for(IResourceFactory):
# For each type
for schema in get_all_possible_schemas_for_type(name):
schemas.append(schema)
schemas = set(schemas)
fields = []
for schema in schemas:
index_fields = guillotina.directives.merged_tagged_value_dict(
schema, guillotina.directives.index.key)
for field_name, catalog_info in index_fields.items():
index_name = catalog_info.get('index_name', field_name)
if index_name not in fields:
fields.append(index_name)
return fields
def _is_multi_valued(check_field_name):
if len(_stored_multi_valued) == 0:
# load types and cache, once
for name, _ in get_utilities_for(IResourceFactory):
# For each type
for schema in get_all_possible_schemas_for_type(name):
index_fields = guillotina.directives.merged_tagged_value_dict(
schema, guillotina.directives.index.key)
for field_name, catalog_info in index_fields.items():
index_name = catalog_info.get('index_name', field_name)
try:
field = schema[field_name]
_stored_multi_valued[index_name] = ICollection.providedBy(field) # noqa
except KeyError:
_stored_multi_valued[index_name] = False
if check_field_name in _stored_multi_valued:
return _stored_multi_valued[check_field_name]
return False
def get_mappings(schemas=None, schema_info=False):
if schemas is None:
schemas = []
for name, _ in get_utilities_for(IResourceFactory):
# For each type
for schema in get_all_possible_schemas_for_type(name):
schemas.append(schema)
schemas = set(schemas)
mappings = {}
for schema in schemas:
index_fields = guillotina.directives.merged_tagged_value_dict(
schema, guillotina.directives.index.key)
for field_name, catalog_info in index_fields.items():
index_name = catalog_info.get('index_name', field_name)
catalog_type = catalog_info.get('type', 'text')
field_mapping = catalog_info.get('field_mapping', None)
if field_mapping is None:
field_mapping = CATALOG_TYPES[catalog_type].copy()
if 'store' in catalog_info:
field_mapping['store'] = catalog_info['store']
if schema_info:
if '_schemas' not in field_mapping:
field_mapping['_schemas'] = []
if schema.__identifier__ not in field_mapping['_schemas']:
field_mapping['_schemas'].append(schema.__identifier__)
mappings[index_name] = field_mapping
return {
'properties': mappings,
'dynamic': False,
'_all': {
'enabled': False
}
}
def get_index_fields(type_name):
mapping = {}
for schema in get_all_possible_schemas_for_type(type_name):
# create mapping for content type
mapping.update(merged_tagged_value_dict(schema, index.key))
return mapping
def get_metadata_fields(type_name):
fields = []
for schema in get_all_possible_schemas_for_type(type_name):
# create mapping for content type
fields.extend(merged_tagged_value_list(schema, metadata.key))
return fields
def get_metadata_fields(type_name):
fields = []
for schema in get_all_possible_schemas_for_type(type_name):
# create mapping for content type
fields.extend(merged_tagged_value_list(schema, metadata.key))
return fields
def get_index_fields(type_name):
mapping = {}
for schema in get_all_possible_schemas_for_type(type_name):
# create mapping for content type
mapping.update(merged_tagged_value_dict(schema, index.key))
return mapping