def insert_data(self):
"""Insert a set of Types and Type Version Managers.
Returns:
"""
# Make a connexion with a mock database
self.type_1_1 = Type(
filename="type1_1.xsd",
content="content1_1",
hash="hash1_1",
is_complex=True,
).save()
self.type_1_2 = Type(
filename="type1_2.xsd",
content="content1_2",
hash="hash1_2",
is_complex=True,
).save()
self.type_1_3 = Type(
filename="type1_3.xsd",
content="content1_3",
hash="hash1_3",
is_complex=True,
).save()
self.type_2_1 = Type(
filename="type2_1.xsd",
content="content2_1",
hash="hash2_1",
is_complex=True,
).save()
self.type_vm_1 = TypeVersionManager(
title="type 1",
user=None,
versions=[
str(self.type_1_1.id),
str(self.type_1_2.id),
str(self.type_1_3.id),
],
current=str(self.type_1_3.id),
is_disabled=False,
disabled_versions=[str(self.type_1_2.id)],
).save()
self.type_vm_2 = TypeVersionManager(
title="type 2",
user="******",
versions=[str(self.type_2_1.id)],
current=str(self.type_2_1.id),
is_disabled=False,
disabled_versions=[],
).save()
self.type_vm_collection = [self.type_vm_1, self.type_vm_2]
def get_all_complex_type():
"""List all complex types.
Returns:
"""
return Type.get_all_complex_type()
def save_type(request):
"""Save the current type in the database.
Args:
request:
Returns:
"""
try:
type_name = request.POST['typeName']
template_id = request.POST['templateID']
xsd_string = request.session['newXmlTemplateCompose']
response_dict = {}
# can save as type if new type or from existing type
if template_id != "new":
try:
# check if the type exists, raises exception otherise
type_api.get(template_id)
except:
# the type does not exist
return _error_response(
"Unable to save an existing template as a type.")
try:
# remove root from tree if present
xsd_string = composer_xml_utils.remove_single_root_element(
xsd_string)
# build xsd tree
xsd_tree = XSDTree.build_tree(xsd_string)
# validate the schema
error = main_xml_utils.validate_xml_schema(xsd_tree)
if error is not None:
return _error_response('This is not a valid XML schema. ' +
error)
except Exception, e:
return _error_response('This is not a valid XML schema. ' +
e.message)
dependencies = _get_dependencies_ids(
request.session["includedTypesCompose"])
try:
# create type version manager
type_version_manager = TypeVersionManager(title=type_name,
user=str(
request.user.id))
# create type
type_object = Type(filename=type_name,
content=xsd_string,
dependencies=dependencies)
# save type in database
type_version_manager_api.insert(type_version_manager, type_object)
except exceptions.NotUniqueError, e:
return HttpResponseBadRequest(
"A type with the same name already exists. Please choose another name."
)
def create(self, validated_data):
"""
Create and return a new `Type` instance, given the validated data.
"""
type_object = Type(
filename=validated_data["filename"],
content=validated_data["content"],
user=validated_data["user"],
)
type_version_manager_object = validated_data["type_version_manager"]
# load dependencies
dependencies_dict = load_dependencies(validated_data)
# Update the content of the template with dependencies
init_template_with_dependencies(type_object,
dependencies_dict,
request=self.context["request"])
# Create the template and its template version manager
type_version_manager_api.insert(type_version_manager_object,
type_object,
request=self.context["request"])
return type_object
def _save_type(request, assets, context):
"""Save a type.
Args:
request:
assets:
context:
Returns:
"""
try:
# get the schema name
name = request.POST["name"]
# get the file from the form
xsd_file = request.FILES["xsd_file"]
# read the content of the file
xsd_data = read_xsd_file(xsd_file)
# get the buckets
buckets = request.POST.getlist("buckets")
type_object = Type(filename=xsd_file.name, content=xsd_data)
type_version_manager = TypeVersionManager(title=name)
type_version_manager_api.insert(type_version_manager,
type_object,
request=request,
list_bucket_ids=buckets)
return HttpResponseRedirect(reverse("admin:core_composer_app_types"))
except exceptions.XSDError as xsd_error:
return _handle_xsd_errors(request, assets, context, xsd_error,
xsd_data, xsd_file.name)
except Exception as e:
context["errors"] = html_escape(str(e))
return _upload_type_response(request, assets, context)
def _save_type_version(request, assets, context, type_version_manager):
"""Save a type version.
Args:
request:
assets:
context:
type_version_manager:
Returns:
"""
# get the file from the form
xsd_file = request.FILES["xsd_file"]
# read the content of the file
xsd_data = read_xsd_file(xsd_file)
try:
type_object = Type(filename=xsd_file.name, content=xsd_data)
type_version_manager_api.insert(type_version_manager,
type_object,
request=request)
return HttpResponseRedirect(
reverse(
"admin:core_composer_app_manage_type_versions",
kwargs={"version_manager_id": str(type_version_manager.id)},
))
except exceptions.XSDError as xsd_error:
return _handle_xsd_errors(request, assets, context, xsd_error,
xsd_data, xsd_file.name)
except Exception as e:
context["errors"] = html_escape(str(e))
return _upload_type_response(request, assets, context)
def _save_type(request, assets, context):
"""Save a type.
Args:
request:
assets:
context:
Returns:
"""
# get the schema name
name = request.POST['name']
# get the file from the form
xsd_file = request.FILES['xsd_file']
# read the content of the file
xsd_data = read_xsd_file(xsd_file)
# get the buckets
buckets = request.POST.getlist('buckets')
try:
type_object = Type(filename=xsd_file.name, content=xsd_data)
type_version_manager = TypeVersionManager(title=name)
type_version_manager_api.insert(type_version_manager, type_object,
buckets)
return HttpResponseRedirect(reverse("admin:core_composer_app_types"))
except exceptions.XSDError, xsd_error:
return _handle_xsd_errors(request, assets, context, xsd_error,
xsd_data, xsd_file.name)
def get_all():
"""List all types.
Returns:
"""
return Type.get_all()
def _save_type_version(request, assets, context, type_version_manager):
"""Save a type version.
Args:
request:
assets:
context:
type_version_manager:
Returns:
"""
# get the file from the form
xsd_file = request.FILES['xsd_file']
# read the content of the file
xsd_data = read_xsd_file(xsd_file)
try:
type_object = Type(filename=xsd_file.name, content=xsd_data)
type_version_manager_api.insert(type_version_manager, type_object)
return HttpResponseRedirect(
reverse(
"admin:core_composer_app_manage_type_versions",
kwargs={'version_manager_id': str(type_version_manager.id)}))
except exceptions.XSDError, xsd_error:
return _handle_xsd_errors(request, assets, context, xsd_error,
xsd_data, xsd_file.name)
def get(type_id):
"""Get a type.
Args:
type_id:
Returns:
"""
return Type.get_by_id(type_id)
def get(type_id, request):
"""Get a type.
Args:
type_id:
request:
Returns:
"""
return Type.get_by_id(type_id)
def _create_type(filename="", content=None):
"""Returns a type
Args:
filename:
content:
Returns:
"""
if content is None:
# set a valid content
content = (
"<schema xmlns='http://www.w3.org/2001/XMLSchema'><simpleType name='type'>"
"<restriction base='string'><enumeration value='test'/></restriction>"
"</simpleType></schema>")
return Type(id=ObjectId(), filename=filename, content=content)
def create(self, validated_data):
"""
Create and return a new `Type` instance, given the validated data.
"""
type_object = Type(filename=validated_data['filename'],
content=validated_data['content'])
type_version_manager_object = validated_data['type_version_manager']
# load dependencies
dependencies_dict = load_dependencies(validated_data)
# Update the content of the template with dependencies
init_template_with_dependencies(type_object, dependencies_dict)
# Create the template and its template version manager
type_version_manager_api.insert(type_version_manager_object, type_object)
return type_object
def _set_xsd_type(xsd_filename, xsd_data):
"""Register XSD type to Django.
Args:
xsd_filename:
xsd_data:
Returns:
"""
try:
type_object = Type(filename=xsd_filename, content=xsd_data)
type_version_manager = TypeVersionManager(title=xsd_filename)
type_version_manager_api.insert(type_version_manager, type_object)
logger.info("XSD type:" + xsd_filename + " registered as as type.")
except exceptions.CoreError as e:
logger.info(xsd_filename + " didn't registered as a type :" + str(e))
except exceptions.NotUniqueError as e:
logger.info(xsd_filename + " didn't registered as a type :" + str(e))
except Exception as e:
logger.info(xsd_filename + " didn't registered as a type :" + str(e))
def resolve_dependencies(request):
"""Resolve import/includes to avoid local references.
Args:
request:
Returns:
"""
try:
# Get the parameters
name = request.POST.get("name", None)
version_manager_id = request.POST.get("version_manager_id", "")
filename = request.POST["filename"]
xsd_content = request.POST["xsd_content"]
schema_locations = request.POST.getlist("schemaLocations[]")
dependencies = request.POST.getlist("dependencies[]")
buckets = request.POST.getlist("buckets[]")
# create new object
type_object = Type(filename=filename,
content=_get_xsd_content_from_html(xsd_content))
init_template_with_dependencies(
type_object,
_get_dependencies_dict(schema_locations, dependencies),
request=request,
)
# get the version manager or create a new one
if version_manager_id != "":
type_version_manager = version_manager_api.get(version_manager_id,
request=request)
else:
type_version_manager = TypeVersionManager(title=name)
type_version_manager_api.insert(type_version_manager,
type_object,
request=request,
list_bucket_ids=buckets)
except Exception as e:
return HttpResponseBadRequest(escape(str(e)),
content_type="application/javascript")
return HttpResponse(json.dumps({}), content_type="application/javascript")
def resolve_dependencies(request):
"""Resolve import/includes to avoid local references.
Args:
request:
Returns:
"""
try:
# Get the parameters
name = request.POST.get('name', None)
version_manager_id = request.POST.get('version_manager_id', '')
filename = request.POST['filename']
xsd_content = request.POST['xsd_content']
schema_locations = request.POST.getlist('schemaLocations[]')
dependencies = request.POST.getlist('dependencies[]')
buckets = request.POST.getlist('buckets[]')
# create new object
type_object = Type(filename=filename,
content=_get_xsd_content_from_html(xsd_content))
init_template_with_dependencies(
type_object, _get_dependencies_dict(schema_locations,
dependencies))
# get the version manager or create a new one
if version_manager_id != '':
type_version_manager = version_manager_api.get(version_manager_id)
else:
type_version_manager = TypeVersionManager(title=name)
type_version_manager_api.insert(type_version_manager, type_object,
buckets)
except Exception, e:
return HttpResponseBadRequest(e.message,
content_type='application/javascript')
def save_type(request):
"""Save the current type in the database.
Args:
request:
Returns:
"""
try:
type_name = request.POST["typeName"]
template_id = request.POST["templateID"]
xsd_string = request.session["newXmlTemplateCompose"]
response_dict = {}
# can save as type if new type or from existing type
if template_id != "new":
try:
# check if the type exists, raises exception otherwise
type_api.get(template_id, request=request)
except Exception as e:
# the type does not exist
logger.warning("save_type threw an exception: {0}".format(
str(e)))
return _error_response(
"Unable to save an existing template as a type.")
try:
# remove root from tree if present
xsd_string = composer_xml_utils.remove_single_root_element(
xsd_string)
# build xsd tree
xsd_tree = XSDTree.build_tree(xsd_string)
# validate the schema
error = main_xml_utils.validate_xml_schema(xsd_tree,
request=request)
if error is not None:
return _error_response("This is not a valid XML schema. " +
error)
except Exception as e:
return _error_response("This is not a valid XML schema. " + str(e))
dependencies = _get_dependencies_ids(
request.session["includedTypesCompose"], request=request)
try:
# create type version manager
type_version_manager = TypeVersionManager(title=type_name,
user=str(
request.user.id))
# create type
type_object = Type(
filename=type_name,
content=xsd_string,
dependencies=dependencies,
user=str(request.user.id),
)
# save type in database
type_version_manager_api.insert(type_version_manager,
type_object,
request=request)
except exceptions.NotUniqueError:
return HttpResponseBadRequest(
"A type with the same name already exists. Please choose another name."
)
except Exception as e:
return _error_response(escape(str(e)))
return HttpResponse(json.dumps(response_dict),
content_type="application/javascript")
except Exception as e:
return HttpResponseBadRequest(escape(str(e)),
content_type="application/javascript")
