def createTemplateWithTemplateVersion(self, templateVersionId):
hash = XSDhash.get_hash('<test>test xmldata</test>')
return Template(title='test',
filename='test',
content='<test>test xmldata</test>',
version=1,
templateVersion=templateVersionId,
hash=hash).save()
def test_getListNameFromDependencies_Template(self):
Template(title='testTemplate',
filename='filename',
content='content',
hash='hash').save()
self.assertEquals(
'testTemplate',
getListNameFromDependencies(
list(Template.objects(title='testTemplate'))))
def createTemplate(self):
hash = XSDhash.get_hash('<test>test xmldata</test>')
objectVersions = self.createTemplateVersion()
return Template(title='test',
filename='test',
content='<test>test xmldata</test>',
version=1,
templateVersion=str(objectVersions.id),
hash=hash).save()
def createTemplateWithTemplateVersionValidContent(self, templateVersionId):
hash = XSDhash.get_hash(TEMPLATE_VALID_CONTENT)
template = Template(title='test',
filename='test',
content=TEMPLATE_VALID_CONTENT,
version=1,
templateVersion=templateVersionId,
hash=hash).save()
TemplateVersion.objects.get(pk=templateVersionId).update(
set__current=template.id)
return template
def createTemplate(self, title='test', filename='test', user=None):
countTemplate = len(Template.objects())
hash = XSDhash.get_hash('<test>test xmldata</test>')
objectVersions = self.createTemplateVersion()
template = Template(title=title,
filename=filename,
content='<test>test xmldata</test>',
version=1,
templateVersion=str(objectVersions.id),
hash=hash,
user=str(user)).save()
self.assertEquals(len(Template.objects()), countTemplate + 1)
return template
def test_delete_type_with_dependencies(self):
type = self.createType()
Type(title='testType',
filename='filename',
content='content',
hash='hash',
dependencies=[str(type.id)]).save()
Template(title='testTemplate',
filename='filename',
content='content',
hash='hash',
dependencies=[str(type.id)]).save()
listDependencies = delete_type(str(type.id))
self.assertEquals(len(Type.objects()), 2)
self.assertEquals(len(TypeVersion.objects()), 1)
self.assertEquals(listDependencies, 'testType, testTemplate')
def save_version(request):
print 'BEGIN def saveVersion(request, objectType)'
versionFilename = None
versionContent = None
objectVersionID = None
objectType = None
if ('uploadVersionValid' in request.session
and request.session['uploadVersionValid'] == True
and 'uploadVersionID' in request.session
and request.session['uploadVersionID'] is not None
and 'uploadVersionType' in request.session
and request.session['uploadVersionType'] is not None
and 'uploadVersionFilename' in request.session
and request.session['uploadVersionFilename'] is not None
and 'uploadVersionContent' in request.session
and request.session['uploadVersionContent'] is not None):
versionFilename = request.session['uploadVersionFilename']
versionContent = request.session['uploadVersionContent']
objectVersionID = request.session['uploadVersionID']
objectType = request.session['uploadVersionType']
if 'uploadVersionFlat' in request.session and request.session[
'uploadVersionFlat'] is not None:
versionFlat = request.session['uploadVersionFlat']
else:
versionFlat = None
if 'uploadVersionAPIurl' in request.session and request.session[
'uploadVersionAPIurl'] is not None:
versionApiurl = request.session['uploadVersionAPIurl']
else:
versionApiurl = None
if 'uploadDependencies' in request.session and request.session[
'uploadDependencies'] is not None:
dependencies = request.session['uploadDependencies']
else:
dependencies = None
hash = XSDhash.get_hash(versionContent)
# save the object
if objectType == "Template":
objectVersions = TemplateVersion.objects.get(pk=objectVersionID)
objectVersions.nbVersions += 1
object = Template.objects.get(pk=objectVersions.current)
newObject = Template(title=object.title,
filename=versionFilename,
content=versionContent,
version=objectVersions.nbVersions,
templateVersion=objectVersionID,
hash=hash).save()
elif objectType == "Type":
objectVersions = TypeVersion.objects.get(pk=objectVersionID)
objectVersions.nbVersions += 1
object = Type.objects.get(pk=objectVersions.current)
newObject = Type(title=object.title,
filename=versionFilename,
content=versionContent,
version=objectVersions.nbVersions,
typeVersion=objectVersionID,
hash=hash).save()
objectVersions.versions.append(str(newObject.id))
objectVersions.save()
if versionFlat is not None and versionApiurl is not None and dependencies is not None:
MetaSchema(schemaId=str(newObject.id),
flat_content=versionFlat,
api_content=versionApiurl).save()
object.dependencies = dependencies
object.save()
clearVersion(request)
else:
response_dict = {'errors': 'True'}
return HttpResponse(json.dumps(response_dict),
content_type='application/javascript')
return HttpResponse(json.dumps({}), content_type='application/javascript')
def save_object(request):
print 'BEGIN def save_object(request)'
objectName = None
objectFilename = None
objectContent = None
objectType = None
objectFlat = None
objectApiurl = None
if ('uploadObjectValid' in request.session
and request.session['uploadObjectValid'] == True
and 'uploadObjectName' in request.session
and request.session['uploadObjectName'] is not None
and 'uploadObjectFilename' in request.session
and request.session['uploadObjectFilename'] is not None
and 'uploadObjectContent' in request.session
and request.session['uploadObjectContent'] is not None
and 'uploadObjectType' in request.session
and request.session['uploadObjectType'] is not None):
objectName = request.session['uploadObjectName']
objectFilename = request.session['uploadObjectFilename']
objectContent = request.session['uploadObjectContent']
objectType = request.session['uploadObjectType']
if 'uploadObjectFlat' in request.session and request.session[
'uploadObjectFlat'] is not None:
objectFlat = request.session['uploadObjectFlat']
else:
objectFlat = None
if 'uploadObjectAPIurl' in request.session and request.session[
'uploadObjectAPIurl'] is not None:
objectApiurl = request.session['uploadObjectAPIurl']
else:
objectApiurl = None
if 'uploadDependencies' in request.session and request.session[
'uploadDependencies'] is not None:
dependencies = request.session['uploadDependencies']
else:
dependencies = None
hash = XSDhash.get_hash(objectContent)
# save the object
if objectType == "Template":
objectVersions = TemplateVersion(nbVersions=1,
isDeleted=False).save()
object = Template(title=objectName,
filename=objectFilename,
content=objectContent,
version=1,
templateVersion=str(objectVersions.id),
hash=hash).save()
#We add default exporters
try:
exporters = Exporter.objects.filter(available_for_all=True)
object.exporters = exporters
except:
pass
elif objectType == "Type":
objectVersions = TypeVersion(nbVersions=1, isDeleted=False).save()
object = Type(title=objectName,
filename=objectFilename,
content=objectContent,
version=1,
typeVersion=str(objectVersions.id),
hash=hash).save()
buckets = request.POST.getlist('buckets[]')
for bucket_id in buckets:
bucket = Bucket.objects.get(pk=bucket_id)
bucket.types.append(str(objectVersions.id))
bucket.save()
objectVersions.versions = [str(object.id)]
objectVersions.current = str(object.id)
objectVersions.save()
object.save()
if objectFlat is not None and objectApiurl is not None and dependencies is not None:
MetaSchema(schemaId=str(object.id),
flat_content=objectFlat,
api_content=objectApiurl).save()
object.dependencies = dependencies
object.save()
clear_object(request)
else:
response_dict = {'errors': 'True'}
return HttpResponse(json.dumps(response_dict),
content_type='application/javascript')
return HttpResponse(json.dumps({}), content_type='application/javascript')
def load_templates():
"""
Loads templates/xslt for NMRR the first time
"""
# if templates are already present, initialization already happened
existing_templates = Template.objects()
if len(existing_templates) == 0:
templates = {
'all': 'AllResources.xsd',
'organization': 'Organization.xsd',
'datacollection': 'DataCollection.xsd',
'repository': 'Repository.xsd',
'projectarchive': 'ProjectArchive.xsd',
'database': 'Database.xsd',
'dataset': 'Dataset.xsd',
'document': 'Document.xsd',
'service': 'Service.xsd',
'informational': 'Informational.xsd',
'software': 'Software.xsd',
}
template_ids = []
template_results = {
'full': 'nmrr-full.xsl',
'detail': 'nmrr-detail.xsl',
}
template_results_id = {
'full': None,
'detail': None,
}
# connect to mongo
client = MongoClient(MONGODB_URI)
# connect to the db 'mgi'
db = client[MGI_DB]
# Add the templates
for template_name, template_path in templates.iteritems():
file = open(
os.path.join(SITE_ROOT, 'static', 'resources', 'xsd',
template_path), 'r')
templateContent = file.read()
hash = XSDhash.get_hash(templateContent)
#create template/ template version
objectVersions = TemplateVersion(nbVersions=1,
isDeleted=False).save()
object = Template(title=template_name,
filename=template_path,
content=templateContent,
version=1,
templateVersion=str(objectVersions.id),
hash=hash).save()
objectVersions.versions = [str(object.id)]
objectVersions.current = str(object.id)
objectVersions.save()
object.save()
# save template id
template_ids.append(str(object.id))
# Add xslt
xsl_col = db['result_xslt']
for xsl_name, xsl_path in template_results.iteritems():
file = open(
os.path.join(SITE_ROOT, 'static', 'resources', 'xsl',
xsl_path), 'r')
fileContent = file.read()
xsl = {}
xsl['name'] = xsl_name
xsl['filename'] = xsl_path
xsl['content'] = fileContent
xsl_id = xsl_col.insert(xsl)
template_results_id[xsl_name] = str(xsl_id)
templates = db['template']
results_xslt = {
'ResultXsltList': template_results_id['full'],
'ResultXsltDetailed': template_results_id['detail']
}
templates.update({}, {"$set": results_xslt}, upsert=False, multi=True)
# is it a valid XML schema ?
xmlSchema = etree.XMLSchema(flatTree)
except Exception, e:
response_dict['errors'] = e.message.replace("'", "")
return HttpResponse(json.dumps(response_dict),
content_type='application/javascript')
hash = XSDhash.get_hash(content)
dependencies = []
for uri in request.session["includedTypesCompose"]:
url = urlparse(uri)
id = url.query.split("=")[1]
dependencies.append(id)
template = Template(title=template_name,
filename=template_name,
content=content,
hash=hash,
user=str(request.user.id),
dependencies=dependencies)
#We add default exporters
try:
exporters = Exporter.objects.filter(available_for_all=True)
template.exporters = exporters
except:
pass
template.save()
MetaSchema(schemaId=str(template.id),
flat_content=flatStr,
api_content=content).save()
flatTree = etree.fromstring(flatStr)
try:
# is it a valid XML schema ?
xmlSchema = etree.XMLSchema(flatTree)
except Exception, e:
dajax.script("""
$("#new-template-error").html("<font color='red'>Not a valid XML schema.</font><br/>"""
+ e.message.replace("'", "") + """ ");
""")
return dajax.json()
hash = XSDhash.get_hash(content)
template = Template(title=templateName,
filename=templateName,
content=content,
hash=hash,
user=request.user.id)
template.save()
MetaSchema(schemaId=str(template.id),
flat_content=flatStr,
api_content=content).save()
dajax.script("""
saveTemplateCallback();
$("#dialog-save-template").dialog("close");
""")
return dajax.json()
