def __call__(self, uri, **kwargs):
from invenio_jsonschemas import current_jsonschemas
from invenio_jsonschemas.errors import JSONSchemaNotFound
try:
return current_jsonschemas.get_schema(uri)
except JSONSchemaNotFound:
return super(TestJSONResolver, self).__call__(uri, *kwargs)
def get_record_schemas(self, obj):
deposit = CAPDeposit.get_record(obj['pid'].object_uuid)
schema = current_jsonschemas.get_schema(deposit.schema.record_path,
with_refs=True,
resolved=True)
uiSchema = deposit.schema.record_options
return dict(schema=copy.deepcopy(schema), uiSchema=uiSchema)
def get_schema(self, schema_path):
schema_data = current_jsonschemas.get_schema(schema_path,
with_refs=False,
resolved=False)
schema_data = JsonRef.replace_refs(
schema_data,
base_uri=current_jsonschemas.path_to_url(schema_path),
loader=internal_invenio_loader)
return current_jsonschemas.resolver_cls(schema_data)
def internal_invenio_loader(relative_schema, *args, **kwargs):
parts = urlsplit(relative_schema)
if not parts.netloc:
relative_schema = urlunparse(
(current_app.config['JSONSCHEMAS_URL_SCHEME'],
current_app.config['JSONSCHEMAS_HOST'], relative_schema, None,
None, None))
path = current_jsonschemas.url_to_path(relative_schema)
return current_jsonschemas.get_schema(path)
def __call__(self, uri, **kwargs):
"""Method invoked when an uri has to be resolved.
If URI is present in registered JSON schemas list, it resolves in the
common schemas, else lets the loader from jsonref do the job.
"""
if uri in current_jsonschemas.list_schemas():
return current_jsonschemas.get_schema(uri)
return super(CustomJsonLoader, self).__call__(uri, *kwargs)
def schemaform(document_type):
"""Return schema and form options for the editor."""
doc_type = document_type
doc_type = re.sub('ies$', 'y', doc_type)
doc_type = re.sub('s$', '', doc_type)
data = {}
schema = None
schema_name = None
try:
current_jsonschemas.get_schema.cache_clear()
schema_name = '{}/{}-v0.0.1.json'.format(document_type, doc_type)
schema = current_jsonschemas.get_schema(schema_name)
data['schema'] = prepare_jsonschema(schema)
except JSONSchemaNotFound:
abort(404)
try:
form = current_jsonschemas.get_schema(
'form_{}/{}-v0.0.1.json'.format(document_type, doc_type))
data['layout'] = prepare_form_option(form)
except JSONSchemaNotFound as e:
raise(e)
return jsonify(data)
def validate(vocabulary):
"""Validate vocabulary."""
if not isinstance(vocabulary, Vocabulary):
raise VocabularyError("{} is not a vocabulary".format(vocabulary))
# Validate vocabulary type
if vocabulary.type not in current_app.config["ILS_VOCABULARIES"]:
raise VocabularyError("Invalid vocabulary type: {}".format(
vocabulary.type))
# JSONSchema validation
schema = current_jsonschemas.get_schema(vocabulary._schema)
data = vocabulary.dumps()
validate_schema(data, schema)
def schemas(record_type):
"""Return schema for the editor.
:param record_type: Type of resource.
:returns: JSONified schema or a 404 if not found.
"""
rec_type = record_type
rec_type = re.sub('ies$', 'y', rec_type)
rec_type = re.sub('s$', '', rec_type)
try:
current_jsonschemas.get_schema.cache_clear()
schema_name = '{}/{}-v1.0.0.json'.format(record_type, rec_type)
schema = current_jsonschemas.get_schema(schema_name)
# TODO: Maybe find a proper way to do this.
if record_type in [
'users', 'documents'
] and not current_user.is_anonymous and current_user_record:
if record_type == 'users':
# If user is admin, restrict available roles list.
if current_user_record.is_admin:
reachable_roles = current_user_record.\
get_all_reachable_roles()
schema['properties']['role']['form']['options'] = []
for role in reachable_roles:
schema['properties']['role']['form']['options'].append(
{
'label': 'role_{role}'.format(role=role),
'value': role
})
schema['properties']['role'][
'enum'] = current_user_record.get_all_reachable_roles(
)
# User cannot select role
else:
schema['properties'].pop('role')
if 'role' in schema.get('propertiesOrder', []):
schema['propertiesOrder'].remove('role')
if not current_user_record.is_superuser:
schema['properties'].pop('organisation')
if 'organisation' in schema.get('propertiesOrder', []):
schema['propertiesOrder'].remove('organisation')
return jsonify({'schema': prepare_schema(schema)})
except JSONSchemaNotFound:
abort(404)
def _load_schema(self):
"""Process and return the JSON schema.
:returns: The schema corresponding to the resource.
"""
rec_type = self._resource_type
rec_type = re.sub('ies$', 'y', rec_type)
rec_type = re.sub('s$', '', rec_type)
current_jsonschemas.get_schema.cache_clear()
schema_name = f'{self._resource_type}/{rec_type}-v1.0.0.json'
if has_custom_resource(self._resource_type):
schema_name = f'{current_organisation["code"]}/{schema_name}'
self._schema = copy.deepcopy(
current_jsonschemas.get_schema(schema_name))
def schemaform(document_type):
"""Return schema and form options for the editor."""
doc_type = document_type
doc_type = re.sub('ies$', 'y', doc_type)
doc_type = re.sub('s$', '', doc_type)
data = {}
schema = None
schema_name = None
try:
if current_app.debug:
current_jsonschemas.get_schema.cache_clear()
schema_name = '{}/{}-v0.0.1.json'.format(document_type, doc_type)
schema = current_jsonschemas.get_schema(schema_name, with_refs=True)
data['schema'] = prepare_jsonschema(schema)
except JSONSchemaNotFound:
abort(404)
return jsonify(data)
def schema_docs(schemas):
"""Generates jsonschema docs for data models."""
for schema_path in schemas:
click.secho(f'Generating docs for schema {schema_path}')
schema = current_jsonschemas.get_schema(schema_path, with_refs=False, resolved=False)
schema = JsonRef.replace_refs(
schema,
jsonschema=True,
base_uri=current_app.config.get('JSONSCHEMAS_HOST'),
loader=_records_state.loader_cls(),
)
# TODO: this is necessary to resolve JSONRefs in allOf
schema = json.loads(json.dumps(schema, default=lambda x: x.__subject__))
# Generate and save html docs for the schema
with tempfile.NamedTemporaryFile(mode="w+") as schema_source:
schema_source.write(json.dumps(schema))
schema_source.flush()
with open(f'docs/schemas/{basename(schema_path.rstrip(".json"))}.html', mode='w+') as result_file:
click.secho(f'Writing schema docs to {result_file.name}', color='green')
generate_from_file_object(
schema_file=schema_source,
result_file=result_file,
minify=True,
expand_buttons=True
)
# Generate and save schema index page
index_md = r"""---
layout: default
---
# Data Models Schema Docs
"""
for f in os.listdir('docs/schemas/'):
if f.endswith('.html'):
index_md += f'- [{f.rstrip(".html")}](./{f})\n'
with open(f'docs/schemas/index.md', mode='w+') as index_file:
index_file.write(index_md)
def get_profile_countries():
"""Get country list from the jsonschema."""
schema = current_jsonschemas.get_schema('common/countries-v0.0.1.json')
options = schema['country']['form']['options']
return [(option.get('value'), _((option.get('label'))))
for option in options]
def get_deposit_schemas(self, obj):
ui_schema = obj['deposit'].schema.deposit_options
schema = current_jsonschemas.get_schema(
obj['deposit'].schema.deposit_path, with_refs=True, resolved=True)
return dict(schema=copy.deepcopy(schema), uiSchema=ui_schema)
