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 test_template_get_raises_exception_if_object_does_not_exist(self, mock_get_by_id):
# Arrange
mock_absent_id = ObjectId()
mock_get_by_id.side_effect = exceptions.DoesNotExist('')
# Act + Assert
with self.assertRaises(exceptions.DoesNotExist):
type_api.get(mock_absent_id)
def test_template_get_raises_exception_if_object_does_not_exist(
self, mock_get_by_id):
# Arrange
mock_user = create_mock_user("1", is_superuser=True)
mock_request = create_mock_request(user=mock_user)
mock_absent_id = ObjectId()
mock_get_by_id.side_effect = exceptions.DoesNotExist("")
# Act + Assert
with self.assertRaises(exceptions.DoesNotExist):
type_api.get(mock_absent_id, request=mock_request)
def _get_dependencies_ids(list_dependencies):
"""Return list of type ids from list of dependencies.
Args:
list_dependencies:
Returns:
"""
# declare list of dependencies
dependencies = []
# get pattern to match a template download
pattern = get_template_download_pattern()
# get all type ids
for uri in list_dependencies:
# parse dependency url
url = urlparse(uri)
try:
# get object id from url
object_id = pattern.match(url.path).group('pk')
# get type by id, exception raised if not found
type_object = type_api.get(object_id)
# add id to list of internal dependencies
dependencies.append(type_object)
except:
# id not found, don't add it to list of dependencies
pass
return dependencies
def _get_dependencies_ids(list_dependencies, request):
"""Return list of type ids from list of dependencies.
Args:
list_dependencies:
Returns:
"""
# declare list of dependencies
dependencies = []
# get pattern to match a template download
pattern = get_template_download_pattern()
# get all type ids
for uri in list_dependencies:
# parse dependency url
url = urlparse(uri)
try:
# get object id from url
object_id = pattern.match(url.path).group("pk")
# get type by id, exception raised if not found
type_object = type_api.get(object_id, request=request)
# add id to list of internal dependencies
dependencies.append(type_object)
except Exception as e:
# id not found, don't add it to list of dependencies
logger.warning(
"_get_dependencies_ids threw an exception: {0}".format(str(e)))
return dependencies
def insert_element_sequence(request):
"""Insert the type in the original schema.
Args:
request:
Returns:
"""
try:
type_id = request.POST["typeID"]
type_name = request.POST["typeName"]
xpath = request.POST["xpath"]
namespace = request.POST["namespace"]
path = request.POST["path"]
# get link to the type to include
xsd_string = request.session["newXmlTemplateCompose"]
if type_id == "built_in_type":
# insert built-in type into xsd string
new_xsd_str = composer_xml_utils.insert_element_built_in_type(
xsd_string, xpath, type_name, request=request)
else:
# get type from database
type_object = type_api.get(type_id, request=request)
# generate include url
include_url = main_xml_utils._get_schema_location_uri(str(type_id))
# insert element in xsd string
new_xsd_str = composer_xml_utils.insert_element_type(
xsd_string,
xpath,
type_object.content,
type_name,
include_url,
request=request,
)
# add the id of the type if not already present
if include_url not in request.session["includedTypesCompose"]:
request.session["includedTypesCompose"].append(include_url)
# save the tree in the session
request.session["newXmlTemplateCompose"] = new_xsd_str
template = loader.get_template(
"core_composer_app/user/builder/new_element.html")
context = {
"namespace": namespace,
"path": path,
"type_name": type_name
}
new_element_html = template.render(context)
return HttpResponse(
json.dumps({"new_element": new_element_html}),
content_type="application/json",
)
except Exception as e:
return HttpResponseBadRequest(escape(str(e)),
content_type="application/javascript")
def test_type_get_returns_type(self, mock_get_by_id):
# Arrange
type_filename = "Schema"
mock_type = _create_mock_type(type_filename)
mock_get_by_id.return_value = mock_type
# Act
result = type_api.get(mock_type.id)
# Assert
self.assertIsInstance(result, Type)
def insert_element_sequence(request):
"""Insert the type in the original schema.
Args:
request:
Returns:
"""
try:
type_id = request.POST['typeID']
type_name = request.POST['typeName']
xpath = request.POST['xpath']
namespace = request.POST['namespace']
path = request.POST['path']
# get link to the type to include
xsd_string = request.session['newXmlTemplateCompose']
if type_id == 'built_in_type':
# insert built-in type into xsd string
new_xsd_str = composer_xml_utils.insert_element_built_in_type(
xsd_string, xpath, type_name)
else:
# get type from database
type_object = type_api.get(type_id)
# generate include url
include_url = main_xml_utils._get_schema_location_uri(str(type_id))
# insert element in xsd string
new_xsd_str = composer_xml_utils.insert_element_type(
xsd_string, xpath, type_object.content, type_name, include_url)
# add the id of the type if not already present
if include_url not in request.session['includedTypesCompose']:
request.session['includedTypesCompose'].append(include_url)
# save the tree in the session
request.session['newXmlTemplateCompose'] = new_xsd_str
template = loader.get_template(
'core_composer_app/user/builder/new_element.html')
context = {
'namespace': namespace,
'path': path,
'type_name': type_name
}
new_element_html = template.render(context)
return HttpResponse(json.dumps({'new_element': new_element_html}),
content_type='application/json')
except Exception, e:
return HttpResponseBadRequest(e.message,
content_type='application/javascript')
def test_type_get_returns_type(self, mock_get_by_id):
# Arrange
mock_user = create_mock_user("1", is_superuser=True)
mock_request = create_mock_request(user=mock_user)
type_filename = "Schema"
mock_type = _create_mock_type(type_filename)
mock_get_by_id.return_value = mock_type
# Act
result = type_api.get(mock_type.id, request=mock_request)
# Assert
self.assertIsInstance(result, Type)
def test_post_owner_is_global(self):
# Arrange
user = create_mock_user('1', is_staff=True)
# Act
response = RequestMock.do_request_post(views.GlobalTypeList.as_view(),
user,
data=self.data)
# get type version manager from posted type
type_id = response.data['id']
type_object = type_api.get(type_id)
type_version_manager = vm_api.get_from_version(type_object)
# Assert
self.assertEqual(type_version_manager.user, None)
def test_post_owner_is_user(self):
# Arrange
user = create_mock_user("1")
mock_request = create_mock_request(user=user)
# Act
response = RequestMock.do_request_post(views.UserTypeList.as_view(),
user,
data=self.data)
# get type version manager from posted type
type_id = response.data["id"]
type_object = type_api.get(type_id, request=mock_request)
type_version_manager = vm_api.get_from_version(type_object,
request=mock_request)
# Assert
self.assertEqual(type_version_manager.user, user.id)
def get(self, request, *args, **kwargs):
""" Method GET
Args:
request:
args:
kwargs:
Returns:
"""
# Get types
if self.administration:
type_versions = type_version_manager_api.get_all_version_manager()
else:
type_versions = type_version_manager_api.get_version_managers_by_user(
request.user.id)
detailed_types = []
for type_version in type_versions:
# If the version manager doesn't have a user, the type is global.
if type_version.user is not None:
detailed_types.append({
'type_version':
type_version,
'type':
type_api.get(type_version.current),
'user':
user_api.get_user_by_id(type_version.user).username,
'title':
type_version.title
})
context = {
'number_total': len(type_versions),
'user_form': UserForm(request.user),
'document': dashboard_constants.FUNCTIONAL_OBJECT_ENUM.TYPE,
'object_name': dashboard_constants.FUNCTIONAL_OBJECT_ENUM.TYPE,
'template': dashboard_constants.DASHBOARD_TYPES_TEMPLATE_TABLE,
'menu': False,
'user_data': detailed_types
}
modals = [
"core_main_app/admin/templates/list/modals/disable.html",
EditTemplateVersionManagerView.get_modal_html_path()
]
assets = {
"css":
dashboard_constants.CSS_COMMON,
"js": [{
"path": 'core_main_app/common/js/templates/list/restore.js',
"is_raw": False
}, {
"path":
'core_main_app/common/js/templates/list/modals/disable.js',
"is_raw": False
},
EditTemplateVersionManagerView.get_modal_js_path()]
}
return self.common_render(request,
self.template,
context=context,
assets=assets,
modals=modals)
def get(self, request, *args, **kwargs):
"""Method GET
Args:
request:
args:
kwargs:
Returns:
"""
try:
# Get types
if self.administration:
type_versions = type_version_manager_api.get_all_version_manager(
request=request
)
else:
type_versions = type_version_manager_api.get_version_managers_by_user(
request=request
)
detailed_types = []
for type_version in type_versions:
# If the version manager doesn't have a user, the type is global.
if type_version.user is not None:
try:
username = user_api.get_user_by_id(type_version.user).username
except ObjectDoesNotExist:
username = "******"
detailed_types.append(
{
"type_version": type_version,
"type": type_api.get(type_version.current, request=request),
"user": username,
"title": type_version.title,
}
)
context = {
"number_total": len(detailed_types),
"user_form": UserForm(request.user),
"document": dashboard_constants.FUNCTIONAL_OBJECT_ENUM.TYPE.value,
"object_name": dashboard_constants.FUNCTIONAL_OBJECT_ENUM.TYPE.value,
"template": dashboard_constants.DASHBOARD_TYPES_TEMPLATE_TABLE,
"menu": False,
"user_data": detailed_types,
}
modals = [
"core_main_app/admin/templates/list/modals/disable.html",
EditTemplateVersionManagerView.get_modal_html_path(),
]
assets = {
"css": dashboard_constants.CSS_COMMON,
"js": [
{
"path": "core_main_app/common/js/templates/list/restore.js",
"is_raw": False,
},
{
"path": "core_main_app/common/js/templates/list/modals/disable.js",
"is_raw": False,
},
EditTemplateVersionManagerView.get_modal_js_path(),
],
}
return self.common_render(
request, self.template, context=context, assets=assets, modals=modals
)
except AccessControlError:
return self.common_render(
request,
"core_main_app/common/commons/error.html",
context={"error": "Access Forbidden", "status_code": 403},
)
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")