def test_version_manager_get_raises_exception_if_object_does_not_exist(
self, mock_get_by_id):
# Arrange
mock_absent_id = ObjectId()
mock_get_by_id.side_effect = mongoengine_errors.DoesNotExist
# Act + Assert
with self.assertRaises(mongoengine_errors.DoesNotExist):
version_manager_api.get(mock_absent_id)
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[]')
# create new object
template = Template(filename=filename,
content=_get_xsd_content_from_html(xsd_content))
init_template_with_dependencies(
template, _get_dependencies_dict(schema_locations, dependencies))
# get the version manager or create a new one
if version_manager_id != '':
template_version_manager = version_manager_api.get(
version_manager_id)
else:
template_version_manager = TemplateVersionManager(title=name)
template_version_manager_api.insert(template_version_manager, template)
except Exception, e:
return HttpResponseBadRequest(e.message)
def upload_template_version(request, version_manager_id):
"""Upload template version.
Args:
request:
version_manager_id:
Returns:
"""
assets = {
"js": [
{
"path":
"core_main_app/admin/js/templates/upload/dependency_resolver.js",
"is_raw": True,
},
{
"path":
"core_main_app/admin/js/templates/upload/dependencies.js",
"is_raw": False,
},
]
}
template_version_manager = version_manager_api.get(version_manager_id,
request=request)
context = {
"object_name":
"Template",
"version_manager":
template_version_manager,
"url":
reverse(
"admin:core_main_app_upload_template_version",
kwargs={"version_manager_id": template_version_manager.id},
),
"redirect_url":
reverse(
"admin:core_main_app_manage_template_versions",
kwargs={"version_manager_id": template_version_manager.id},
),
}
# method is POST
if request.method == "POST":
form = UploadVersionForm(request.POST, request.FILES)
context["upload_form"] = form
if form.is_valid():
return _save_template_version(request, assets, context,
template_version_manager)
else:
# Display errors from the form
return _upload_template_response(request, assets, context)
# method is GET
else:
# render the form to upload a template
context["upload_form"] = UploadVersionForm()
return _upload_template_response(request, assets, context)
def manage_template_versions(request, version_manager_id):
"""View that allows template versions management
Args:
request:
version_manager_id:
Returns:
"""
try:
# get the version manager
version_manager = version_manager_api.get(version_manager_id,
request=request)
if not request.user.is_staff and version_manager.user != str(
request.user.id):
raise Exception(
"You do not have the rights to perform this action.")
context = get_context_manage_template_versions(version_manager)
if "core_parser_app" in settings.INSTALLED_APPS:
context.update({"module_url": "core_parser_app_template_modules"})
assets = {
"js": [
{
"path":
"core_main_app/common/js/templates/versions/set_current.js",
"is_raw": False,
},
{
"path":
"core_main_app/common/js/templates/versions/restore.js",
"is_raw": False,
},
{
"path":
"core_main_app/common/js/templates/versions/modals/disable.js",
"is_raw": False,
},
]
}
modals = ["core_main_app/admin/templates/versions/modals/disable.html"]
return render(
request,
"core_main_app/common/templates/versions.html",
assets=assets,
modals=modals,
context=context,
)
except Exception as e:
return render(
request,
"core_main_app/common/commons/error.html",
context={"error": str(e)},
)
def upload_type_version(request, version_manager_id):
"""Upload type version.
Args:
request:
version_manager_id:
Returns:
"""
assets = {
"js": [{
"path": 'core_main_app/admin/js/templates/upload/dependencies.js',
"is_raw": False
}, {
"path": 'core_composer_app/admin/js/types/upload/dependencies.js',
"is_raw": False
}, {
"path":
'core_composer_app/admin/js/types/upload/dependency_resolver.js',
"is_raw": False
}, {
"path":
'core_composer_app/admin/js/types/upload/dependencies.raw.js',
"is_raw": True
}]
}
type_version_manager = version_manager_api.get(version_manager_id)
context = {
'object_name':
"Type",
'version_manager':
type_version_manager,
'url':
reverse("admin:core_composer_app_upload_type_version",
kwargs={'version_manager_id': type_version_manager.id}),
'redirect_url':
reverse("admin:core_composer_app_manage_type_versions",
kwargs={'version_manager_id': type_version_manager.id})
}
# method is POST
if request.method == 'POST':
form = UploadVersionForm(request.POST, request.FILES)
context['upload_form'] = form
if form.is_valid():
return _save_type_version(request, assets, context,
type_version_manager)
else:
# Display errors from the form
return _upload_type_response(request, assets, context)
# method is GET
else:
# render the form to upload a template
context['upload_form'] = UploadVersionForm()
return _upload_type_response(request, assets, context)
def manage_type_buckets(request, version_manager_id):
"""Manage buckets of a type.
Args:
request:
version_manager_id:
Returns:
"""
# get the version manager
version_manager = None
try:
version_manager = version_manager_api.get(version_manager_id,
request=request)
except ModelError as e:
logger.error("manage_type_buckets threw a ModelError: {0}".format(
str(e)))
return admin_render(
request,
"core_main_app/common/commons/error.html",
context={"error": str(e)},
)
except DoesNotExist as e:
# TODO: catch exception, redirect to error page
logger.warning(
"manage_type_buckets threw a DoesNotExist exception: {0}".format(
str(e)))
context = {
"version_manager": version_manager,
"buckets": bucket_api.get_all()
}
assets = {
"css": ["core_composer_app/common/css/bucket.css"],
"js": [{
"path": "core_main_app/common/js/backtoprevious.js",
"is_raw": True
}],
}
if request.method == "POST":
form = EditTypeBucketsForm(request.POST)
if form.is_valid():
buckets = request.POST.getlist("buckets")
bucket_api.update_type_buckets(version_manager, buckets)
return redirect(reverse("admin:core_composer_app_types"))
else:
form = EditTypeBucketsForm()
context["form"] = form
return admin_render(
request,
"core_composer_app/admin/buckets/edit.html",
assets=assets,
context=context,
)
def manage_type_versions(request, version_manager_id):
"""View that allows type versions management.
Args:
request:
version_manager_id:
Returns:
"""
try:
# get the version manager
version_manager = version_manager_api.get(version_manager_id)
context = get_context_manage_template_versions(version_manager)
# updating context regarding the installed apps
# default back_url initialization
context.update({"back_url": "admin:core_composer_app_types"})
if 'core_parser_app' in settings.INSTALLED_APPS:
context.update(
{"module_url": "admin:core_composer_app_type_modules"})
if 'core_dashboard_app' in settings.INSTALLED_APPS:
# the dashboard exposes the user's version managers
# in this view, we come from the dashboard
if version_manager.user:
context.update({"back_url": "admin:core_dashboard_types"})
assets = {
"js": [{
"path":
'core_main_app/common/js/templates/versions/set_current.js',
"is_raw": False
}, {
"path":
'core_main_app/common/js/templates/versions/restore.js',
"is_raw": False
}, {
"path":
'core_main_app/common/js/templates/versions/modals/disable.js',
"is_raw": False
}]
}
modals = ["core_main_app/admin/templates/versions/modals/disable.html"]
return admin_render(request,
'core_composer_app/admin/types/versions.html',
assets=assets,
modals=modals,
context=context)
except Exception, e:
return admin_render(request,
'core_main_app/common/commons/error.html',
context={'error': e.message})
def test_version_manager_get_returns_version_manager(self, mock_get_by_id):
# Arrange
mock_version_manager = _create_mock_version_manager(title="Schema")
mock_get_by_id.return_value = mock_version_manager
# Act
result = version_manager_api.get(mock_version_manager.id)
# Assert
self.assertIsInstance(result, VersionManager)
def update(self, instance, validated_data):
instance.set_spec = validated_data.get('set_spec', instance.set_spec)
instance.set_name = validated_data.get('set_name', instance.set_name)
templates_manager = validated_data.get('templates_manager', [])
if len(templates_manager) > 0:
templates_manager = [
version_manager_api.get(id_) for id_ in templates_manager
]
instance.templates_manager = templates_manager
instance.description = validated_data.get('description',
instance.description)
return oai_provider_set_api.upsert(instance)
def update(self, instance, validated_data):
instance.set_spec = validated_data.get("set_spec", instance.set_spec)
instance.set_name = validated_data.get("set_name", instance.set_name)
templates_manager = validated_data.get("templates_manager", [])
if len(templates_manager) > 0:
templates_manager = [
version_manager_api.get(id_, request=self.context["request"])
for id_ in templates_manager
]
instance.templates_manager = templates_manager
instance.description = validated_data.get("description",
instance.description)
return oai_provider_set_api.upsert(instance)
def get_object(self, pk):
""" Get template version manager from db
Args:
pk:
Returns:
"""
try:
return version_manager_api.get(pk)
except exceptions.DoesNotExist:
raise Http404
def test_version_manager_get_returns_version_manager(self, mock_get_by_id):
# Arrange
mock_user = create_mock_user("1", is_superuser=True)
mock_request = create_mock_request(mock_user)
mock_version_manager = _create_mock_version_manager(title="Schema")
mock_get_by_id.return_value = mock_version_manager
# Act
result = version_manager_api.get(mock_version_manager.id,
request=mock_request)
# Assert
self.assertIsInstance(result, VersionManager)
def manage_template_versions(request, version_manager_id):
"""View that allows template versions management
Args:
request:
version_manager_id:
Returns:
"""
# get the version manager
version_manager = None
try:
version_manager = version_manager_api.get(version_manager_id)
except:
# TODO: catch good exception, redirect to error page
pass
if not request.user.is_staff and version_manager.user != str(
request.user.id):
raise Exception("You don't have the rights to perform this action.")
context = get_context_manage_template_versions(version_manager)
assets = {
"js": [{
"path":
'core_main_app/common/js/templates/versions/set_current.js',
"is_raw": False
}, {
"path": 'core_main_app/common/js/templates/versions/restore.js',
"is_raw": False
}, {
"path":
'core_main_app/common/js/templates/versions/modals/disable.js',
"is_raw": False
}, {
"path": 'core_main_app/common/js/backtoprevious.js',
"is_raw": True
}]
}
modals = ["core_main_app/admin/templates/versions/modals/disable.html"]
return render(request,
'core_main_app/common/templates/versions.html',
assets=assets,
modals=modals,
context=context)
def manage_type_versions(request, version_manager_id):
"""View that allows type versions management.
Args:
request:
version_manager_id:
Returns:
"""
try:
# get the version manager
version_manager = version_manager_api.get(version_manager_id, request=request)
context = get_context_manage_template_versions(version_manager, "Type")
if "core_parser_app" in settings.INSTALLED_APPS:
context.update({"module_url": "core_composer_app_type_modules"})
assets = {
"js": [
{
"path": "core_main_app/common/js/templates/versions/set_current.js",
"is_raw": False,
},
{
"path": "core_main_app/common/js/templates/versions/restore.js",
"is_raw": False,
},
{
"path": "core_main_app/common/js/templates/versions/modals/disable.js",
"is_raw": False,
},
]
}
modals = ["core_main_app/admin/templates/versions/modals/disable.html"]
return render(
request,
"core_composer_app/user/types/versions.html",
assets=assets,
modals=modals,
context=context,
)
except Exception as e:
return render(
request,
"core_main_app/common/commons/error.html",
context={"error": str(e)},
)
def get_object(self, pk):
""" Get template version manager from db
Args:
pk:
Returns:
"""
try:
template_version_manager_object = version_manager_api.get(pk)
can_user_modify_template_version_manager(template_version_manager_object, self.request.user)
return template_version_manager_object
except exceptions.DoesNotExist:
raise Http404
def restore_version_manager(request):
"""Restore a disabled version manager.
Args:
request:
Returns:
"""
try:
version_manager = version_manager_api.get(request.GET['id'])
version_manager_api.restore(version_manager)
except Exception, e:
return HttpResponseBadRequest(e.message,
content_type='application/javascript')
def get_object(self, pk, request):
"""Get TemplateVersionManager from db
Args:
pk: ObjectId
request:
Returns:
TemplateVersionManager
"""
try:
return version_manager_api.get(pk, request=request)
except exceptions.DoesNotExist:
raise Http404
def disable_version_manager(request):
"""Disable a version manager.
Args:
request:
Returns:
"""
try:
version_manager = version_manager_api.get(request.GET['id'])
version_manager_api.disable(version_manager)
except Exception as e:
return HttpResponseBadRequest(str(e), content_type='application/javascript')
return HttpResponse(json.dumps({}), content_type='application/javascript')
def get_object(self, pk):
"""Get template version manager from db
Args:
pk: ObjectId
Returns:
TemplateVersionManager
"""
try:
template_version_manager_object = version_manager_api.get(
pk, request=self.request)
return template_version_manager_object
except exceptions.DoesNotExist:
raise Http404
def manage_type_buckets(request, version_manager_id):
"""Manage buckets of a type.
Args:
request:
version_manager_id:
Returns:
"""
# get the version manager
version_manager = None
try:
version_manager = version_manager_api.get(version_manager_id)
except:
# TODO: catch good exception, redirect to error page
pass
context = {
'version_manager': version_manager,
'buckets': bucket_api.get_all()
}
assets = {
"css": ['core_composer_app/common/css/bucket.css'],
"js": [{
"path": 'core_main_app/common/js/backtoprevious.js',
"is_raw": True
}]
}
if request.method == 'POST':
form = EditTypeBucketsForm(request.POST)
if form.is_valid():
buckets = request.POST.getlist('buckets')
bucket_api.update_type_buckets(version_manager, buckets)
return redirect(reverse('admin:core_composer_app_types'))
else:
form = EditTypeBucketsForm()
context['form'] = form
return admin_render(request,
'core_composer_app/admin/buckets/edit.html',
assets=assets,
context=context)
def manage_type_versions(request, version_manager_id):
"""View that allows type versions management.
Args:
request:
version_manager_id:
Returns:
"""
try:
# get the version manager
version_manager = version_manager_api.get(version_manager_id)
context = get_context_manage_template_versions(version_manager)
if 'core_parser_app' in settings.INSTALLED_APPS:
context.update({"module_url": "core_composer_app_type_modules"})
assets = {
"js": [
{
"path": 'core_main_app/common/js/templates/versions/set_current.js',
"is_raw": False
},
{
"path": 'core_main_app/common/js/templates/versions/restore.js',
"is_raw": False
},
{
"path": 'core_main_app/common/js/templates/versions/modals/disable.js',
"is_raw": False
}
]
}
modals = ["core_main_app/admin/templates/versions/modals/disable.html"]
return render(request,
'core_composer_app/user/types/versions.html',
assets=assets,
modals=modals,
context=context)
except Exception, e:
return render(request,
'core_main_app/common/commons/error.html',
context={'error': e.message})
def manage_template_versions(request, version_manager_id):
"""View that allows template versions management.
Args:
request:
version_manager_id:
Returns:
"""
# get the version manager
version_manager = None
try:
version_manager = version_manager_api.get(version_manager_id)
except:
# TODO: catch good exception, redirect to error page
pass
context = get_context_manage_template_versions(version_manager)
assets = {
"js": [{
"path":
'core_main_app/common/js/templates/versions/set_current.js',
"is_raw": False
}, {
"path": 'core_main_app/common/js/templates/versions/restore.js',
"is_raw": False
}, {
"path":
'core_main_app/common/js/templates/versions/modals/disable.js',
"is_raw": False
}]
}
modals = ["core_main_app/admin/templates/versions/modals/disable.html"]
return admin_render(request,
'core_main_app/admin/templates/versions.html',
assets=assets,
modals=modals,
context=context)
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")
