def getContent(req, ids):
user = users.getUserFromRequest(req)
access = AccessData(req)
language = lang(req)
node = tree.getNode(ids[0])
if "sort" in users.getHideMenusForUser(user) or not access.hasWriteAccess(node):
req.setStatus(httpstatus.HTTP_FORBIDDEN)
return req.getTAL("web/edit/edit.html", {}, macro="access_error")
msg_t = (user.getName(), node.id, node.name, node.type, req.params)
msg = "%s sorting subfolders of node %r (%r, %r): %r" % msg_t
logger.info(msg)
if "order" in req.params: # do reorder
ids = req.params.get('order').split(',')
children = []
for n in ids:
child = tree.getNode(n)
child.setOrderPos(ids.index(n))
children.append(child)
req.writeTAL('web/edit/modules/subfolder.html', {'nodelist': children, "language": language}, macro="ordered_list")
return ""
elif "sortdirection" in req.params: # do automatic re-order
i = 0
sort_dir = "" if req.params.get("sortdirection", "up") == "up" else "-"
sorted_children = node.getContainerChildren().sort_by_fields(sort_dir + req.params.get("sortattribute"))
for child in sorted_children:
child.setOrderPos(i)
i += 1
req.writeTAL('web/edit/modules/subfolder.html', {'nodelist': sorted_children, "language": language}, macro="ordered_list")
return ""
nodelist = []
attributes = []
fields = {}
i = 0
for child in list(node.getContainerChildren().sort_by_orderpos()):
i += 1 # count container children
nodelist.append(child)
if getMetaType(child.getSchema()):
for field in getMetaType(child.getSchema()).getMetaFields():
if not field in fields.keys():
fields[field] = 0
fields[field] += 1
for field in fields:
if i == fields[field]:
attributes.append(field)
ctx = {
"node": node,
"nodelist": nodelist,
"sortattributes": sorted(attributes, lambda x, y: cmp(x.getLabel().lower(), y.getLabel().lower())),
"language": language,
}
return req.getTAL("web/edit/modules/subfolder.html", ctx, macro="edit_subfolder")
def getContent(req, ids):
user = current_user
language = lang(req)
node = q(Node).get(ids[0])
if "sort" in user.hidden_edit_functions or not node.has_write_access():
req.setStatus(httpstatus.HTTP_FORBIDDEN)
return req.getTAL("web/edit/edit.html", {}, macro="access_error")
logg.info("%s sorting subfolders of node %s (%s, %s): %s", user.login_name, node.id, node.name, node.type, req.params)
if "order" in req.params: # do reorder
ids = req.params.get('order').split(',')
children = []
for n in ids:
child = q(Node).get(n)
child.orderpos = ids.index(n)
children.append(child)
db.session.commit()
req.writeTAL('web/edit/modules/subfolder.html', {'nodelist': children, "language": language, "csrf": req.csrf_token.current_token}, macro="ordered_list")
return ""
elif "sortdirection" in req.params: # do automatic re-order
sorted_children = node.container_children.order_by(Node.name).all()
if req.params.get("sortdirection", "up") != "up":
sorted_children.reverse()
for position, child in enumerate(sorted_children, start=1):
child.orderpos = position
db.session.commit()
req.writeTAL('web/edit/modules/subfolder.html', {'nodelist': sorted_children, "language": language, "csrf": req.csrf_token.current_token}, macro="ordered_list")
return ""
nodelist = []
attributes = []
fields = {}
i = 0
for child in list(node.container_children.sort_by_orderpos()):
i += 1 # count container children
nodelist.append(child)
if getMetaType(child.schema):
for field in getMetaType(child.schema).getMetaFields():
if not field in fields.keys():
fields[field] = 0
fields[field] += 1
for field in fields:
if i == fields[field]:
attributes.append(field)
ctx = {
"node": node,
"nodelist": nodelist,
"sortattributes": sorted(attributes, lambda x, y: cmp(x.getLabel().lower(), y.getLabel().lower())),
"language": language,
"csrf": req.csrf_token.current_token
}
return req.getTAL("web/edit/modules/subfolder.html", ctx, macro="edit_subfolder")
def create_meta_file(node):
"""
@param node
Creates and returns the path to the 'metadata file' needed to register the doi with datacite via api
"""
if 'doi' not in node.attributes:
raise Exception('doi not set')
else:
tmp = config.get('paths.tempdir')
filename = 'meta_file_%s.txt' % node.get('node.id')
path = os.path.join(tmp, filename)
if os.path.exists(path):
pass
else:
try:
with open(path, 'w') as f:
mask = getMetaType(node.getSchema()).getMask('doi')
xml = mask.getViewHTML([node], flags=8)
f.write(xml)
except AttributeError:
logging.getLogger('backend').error(
'Doi was not successfully registered: Doi-mask for Schema %s is missing and should be created' % node.getSchema())
node.removeAttribute('doi')
except IOError:
logging.getLogger('errors').error('Error creating %s' % path)
return path
def show_workflow_node(self, node, req):
print req.params
if self.getAccess('data') != self.getAccess('write'): # set access for download same as edit (only once needed)
self.setAccess('data', self.getAccess('write'))
if "gotrue" in req.params:
return self.forwardAndShow(node, True, req)
elif "gofalse" in req.params:
return self.forwardAndShow(node, False, req)
if self.getTrueLabel(language=node.get("system.wflanguage")) == "" and self.getFalseLabel(
language=node.get("system.wflanguage")) == "":
buttons = []
else:
buttons = self.tableRowButtons(node)
try:
mask = getMetaType(node.type).getMask(self.get("mask_fileatt"))
maskdata = mask.getViewHTML([node], VIEW_HIDE_EMPTY, language=lang(req))
except:
maskdata = ""
return req.getTAL("workflow/fileattachment.html",
{"buttons": buttons,
"files": self.getFiles(),
"wfnode": self,
"pretext": self.getPreText(lang(req)),
"posttext": self.getPostText(lang(req)),
"sidebar": self.getSidebarText(lang(req)),
'maskdata': maskdata},
macro="fileattachment_show_node")
def export(req):
p = req.path[1:].split("/")
access = AccessData(req)
if len(p) != 2:
req.error(404, "Object not found")
return
if p[0].isdigit():
try:
node = tree.getNode(p[0])
except:
return req.error(404, "Object not found")
else:
return req.error(404, "Object not found")
if not access.hasAccess(node, "read"):
req.write(t(req, "permission_denied"))
return
mask = getMetaType(node.getSchema()).getMask(p[1])
if mask:
try:
req.reply_headers['Content-Type'] = "text/plain; charset=utf-8"
req.write(mask.getViewHTML([node], flags=8)) # flags =8 -> export type
except tree.NoSuchNodeError:
return req.error(404, "Object not found")
else:
req.error(404, "Object not found")
return
def get_oai_export_mask_for_schema_name_and_metadataformat(
schema_name, metadataformat):
schema = getMetaType(schema_name)
if schema:
mask = schema.getMask(u"oai_" + metadataformat.lower())
else:
mask = None
return mask
def writeRecord(req, node, metadataformat):
if not SET_LIST:
initSetList(req)
updatetime = node.get(DATEFIELD)
if updatetime:
d = ISO8601(date.parse_date(updatetime))
else:
d = ISO8601(date.DateTime(EARLIEST_YEAR - 1, 12, 31, 23, 59, 59))
set_specs = getSetSpecsForNode(node)
if DEBUG:
timetable_update(req, " in writeRecord: getSetSpecsForNode: node: '%s, %s', metadataformat='%s' set_specs:%s" %
(str(node.id), node.type, metadataformat, str(set_specs)))
req.write("""
<record>
<header><identifier>%s</identifier>
<datestamp>%sZ</datestamp>
%s
</header>
<metadata>""" % (mkIdentifier(node.id), d, set_specs))
if DEBUG:
timetable_update(req, " in writeRecord: writing header: node.id='%s', metadataformat='%s'" % (str(node.id), metadataformat))
if metadataformat == "mediatum":
req.write(core.xmlnode.getSingleNodeXML(node))
# in [masknode.name for masknode in getMetaType(node.getSchema()).getMasks() if masknode.get('masktype')=='exportmask']:
elif nodeHasOAIExportMask(node, metadataformat.lower()):
mask = getMetaType(node.getSchema()).getMask("oai_" + metadataformat.lower())
if DEBUG:
timetable_update(
req,
""" in writeRecord: mask = getMetaType(node.getSchema()).getMask("oai_"+metadataformat.lower()): node.id='%s', metadataformat='%s'""" %
(str(
node.id),
metadataformat))
try:
req.write(fixXMLString(mask.getViewHTML([node], flags=8))) # fix xml errors
except:
req.write(mask.getViewHTML([node], flags=8))
if DEBUG:
timetable_update(
req,
" in writeRecord: req.write(mask.getViewHTML([node], flags=8)): node.id='%s', metadataformat='%s'" %
(str(
node.id),
metadataformat))
else:
req.write('<recordHasNoXMLRepresentation/>')
req.write('</metadata></record>')
if DEBUG:
timetable_update(req, "leaving writeRecord: node.id='%s', metadataformat='%s'" % (str(node.id), metadataformat))
def search_results(req, id):
access = AccessData(req)
user = users.getUserFromRequest(req)
if "search" in users.getHideMenusForUser(user):
req.writeTAL("web/edit/edit.html", {}, macro="access_error")
return ""
if "Reset" in req.params:
return search_form(req, id, "edit_search_reset_msg")
try:
searchvalues = req.session["esearchvals"]
except:
req.session["esearchvals"] = searchvalues = {}
node = tree.getNode(id)
objtype = req.params["objtype"]
type = getMetaType(objtype)
query = ""
if "full" in req.params:
value = req.params["full"]
searchvalues[objtype + ".full"] = value
for word in value.split(" "):
if word:
if query:
query += " and "
query += "full=" + protect(word)
for field in type.getMetaFields():
if field.Searchfield():
name = field.getName()
if name in req.params and req.params.get(name, "").replace(
"'", '').replace('"', '').strip() != "":
value = req.params[name].strip()
if value:
searchvalues[objtype + "." + field.getName()] = value
if field.getFieldtype() == "list" or field.getFieldtype(
) == "ilist" or field.getFieldtype() == "mlist":
if query:
query += " and "
query += name + "=" + protect(value)
else:
query += name + "=" + protect(value)
query += ' and schema="' + req.params.get("objtype", "*") + '"'
utrace.info(access.user.name + " search for " + query)
nodes = node.search(query)
req.session["nodelist"] = EditorNodeList(nodes)
if len(nodes):
return req.getTAL("web/edit/modules/search.html", {"id": id},
macro="start_new_search") + shownodelist(req, nodes)
return search_form(req, id, "edit_search_noresult_msg")
def MetatypeDetail(req, id, err=0):
v = getAdminStdVars(req)
if err == 0 and id == "":
# new metadatatype
metadatatype = Metadatatype(u"")
db.session.commit()
v["original_name"] = ""
elif id != "" and err == 0:
# edit metadatatype
metadatatype = getMetaType(id)
v["original_name"] = metadatatype.getName()
else:
# error
metadatatype = Metadatatype(req.params["mname"])
metadatatype.set("description", req.params["description"])
metadatatype.set("longname", req.params["mlongname"])
metadatatype.set("active", "mactive" in req.params)
metadatatype.set("datatypes",
req.params.get("mdatatypes", "").replace(";", ", "))
metadatatype.set("bibtexmapping", req.params.get("mbibtex", ""))
metadatatype.set("citeprocmapping", req.params.get("mciteproc", ""))
db.session.commit()
v["original_name"] = req.params["mname_orig"]
d = Data()
v["datatypes"] = d.get_all_datatypes()
v["datatypes"].sort(
lambda x, y: cmp(t(lang(req), x.__name__), t(lang(req), y.__name__)))
v["metadatatype"] = metadatatype
v["error"] = err
v["bibtextypes"] = getAllBibTeXTypes()
v["bibtexselected"] = metadatatype.get("bibtexmapping").split(";")
v["citeproctypes"] = citeproc.TYPES
v["citeprocselected"] = metadatatype.get("citeprocmapping").split(";")
try:
rules = [
r.ruleset_name
for r in metadatatype.access_ruleset_assocs.filter_by(
ruletype=u'read')
]
except:
rules = []
v["acl"] = makeList(req,
"read",
removeEmptyStrings(rules), {},
overload=0,
type="read")
v["filtertype"] = req.params.get("filtertype", "")
v["actpage"] = req.params.get("actpage")
v["csrf"] = req.csrf_token.current_token
return req.getTAL("web/admin/modules/metatype.html",
v,
macro="modify_type")
def show_workflow_node(self, node, req):
result = ""
error = ""
key = req.params.get("key", req.session.get("key", ""))
maskname = self.get("mask")
mask = None
if node.get('system.wflanguage') != '': # use correct language
mask = getMetaType(node.schema).getMask(
"%s.%s" % (node.get('system.wflanguage'), maskname))
if not mask:
mask = getMetaType(node.schema).getMask(maskname)
if "metaDataEditor" in req.params:
mask.update_node(node, req, current_user)
db.session.commit()
missing = mask.validate([node])
if not missing or "gofalse" in req.params:
op = "gotrue" in req.params
return self.forwardAndShow(node, op, req)
else:
error = '<p class="error">%s</p>' % (t(lang(req),
"workflow_error_msg"))
req.params["errorlist"] = missing
if mask:
maskcontent = mask.getFormHTML([node], req)
else:
maskcontent = req.getTAL("workflow/editmetadata.html", {},
macro="maskerror")
return req.getTAL("workflow/editmetadata.html", {
"name": self.name,
"error": error,
"key": key,
"mask": maskcontent,
"pretext": self.getPreText(lang(req)),
"posttext": self.getPostText(lang(req)),
"sidebartext": self.getSidebarText(lang(req)),
"buttons": self.tableRowButtons(node),
"csrf": req.csrf_token.current_token,
},
macro="workflow_metadateneditor")
def show_workflow_node(self, node, req):
if "gotrue" in req.params:
return self.forwardAndShow(node, True, req)
if "gofalse" in req.params:
return self.forwardAndShow(node, False, req)
key = req.params.get("key", req.session.get("key", ""))
masks = self.get("masks")
if not masks:
masklist = ["editmask"]
else:
masklist = masks.split(";")
fieldmap = []
mask = None
for maskname in masklist:
t = getMetaType(node.type)
if t:
if node.get('system.wflanguage') != '': # use correct language
mask = t.getMask("%s.%s" %
(node.get('system.wflanguage'), maskname))
if not mask:
mask = t.getMask(maskname)
try:
fieldmap += [
mask.getViewHTML([node],
VIEW_HIDE_EMPTY,
language=lang(req))
]
except:
print "error"
logging.getLogger("error").error(
"mask %s defined for workflow step not found." % mask)
return ""
filelist = ""
filelistshort = ""
if node.getFiles():
filelist = mkfilelist(node, request=req)
filelistshort = mkfilelistshort(node, request=req)
return req.getTAL("workflow/showdata.html", {
"key": key,
"filelist": filelist,
"filelistshort": filelistshort,
"fields": fieldmap,
"pretext": self.getPreText(lang(req)),
"posttext": self.getPostText(lang(req)),
"sidebar": self.getSidebarText(lang(req)),
"buttons": self.tableRowButtons(node)
},
macro="workflow_showdata")
def search_results(req,id):
access = AccessData(req)
user = users.getUserFromRequest(req)
if "search" in users.getHideMenusForUser(user):
req.writeTAL("web/edit/edit.html", {}, macro="access_error")
return ""
if "Reset" in req.params:
return search_form(req, id, "edit_search_reset_msg")
try:
searchvalues = req.session["esearchvals"]
except:
req.session["esearchvals"] = searchvalues = {}
node = tree.getNode(id)
objtype = req.params["objtype"]
type = getMetaType(objtype)
query = ""
if "full" in req.params:
value = req.params["full"]
searchvalues[objtype + ".full"] = value
for word in value.split(" "):
if word:
if query:
query += " and "
query += "full=" + protect(word)
for field in type.getMetaFields():
if field.Searchfield():
name=field.getName()
if name in req.params and req.params.get(name,"").replace("'",'').replace('"','').strip()!="":
value = req.params[name].strip()
if value:
searchvalues[objtype + "." + field.getName()] = value
if field.getFieldtype()=="list" or field.getFieldtype()=="ilist" or field.getFieldtype()=="mlist":
if query:
query += " and "
query += name + "=" + protect(value)
else:
query += name + "=" + protect(value)
query += ' and schema="'+req.params.get("objtype","*")+'"'
utrace.info(access.user.name + " search for "+query)
nodes = node.search(query)
req.session["nodelist"] = EditorNodeList(nodes)
if len(nodes):
return req.getTAL("web/edit/modules/search.html", {"id":id}, macro="start_new_search") + shownodelist(req, nodes)
return search_form(req, id, "edit_search_noresult_msg")
def showFieldOverview(req):
path = req.path[1:].split("/")
fields = getFieldsForMeta(path[1])
fields.sort(lambda x, y: cmp(x.orderpos, y.orderpos))
v = {}
v["metadatatype"] = getMetaType(path[1])
v["metafields"] = fields
v["fieldoptions"] = fieldoption
v["fieldtypes"] = getMetaFieldTypeNames()
v["csrf"] = req.csrf_token.current_token
return req.getTAL("web/admin/modules/metatype.html", v, macro="show_fieldoverview")
def showFieldOverview(req):
path = req.path[1:].split("/")
fields = getFieldsForMeta(path[1])
fields.sort(lambda x, y: cmp(x.getOrderPos(), y.getOrderPos()))
v = {}
v["metadatatype"] = getMetaType(path[1])
v["metafields"] = fields
v["fieldoptions"] = fieldoption
v["fieldtypes"] = getMetaFieldTypeNames()
return req.getTAL("web/admin/modules/metatype.html", v, macro="show_fieldoverview")
def show_workflow_node(self, node, req):
result = ""
error = ""
key = req.params.get("key", req.session.get("key", ""))
maskname = self.get("mask")
mask = None
if node.get('system.wflanguage') != '': # use correct language
mask = getMetaType(node.type).getMask("%s.%s" % (node.get('system.wflanguage'), maskname))
if not mask:
mask = getMetaType(node.type).getMask(maskname)
if "metaDataEditor" in req.params:
mask.updateNode([node], req)
missing = mask.validate([node])
if not missing or "gofalse" in req.params:
op = "gotrue" in req.params
return self.forwardAndShow(node, op, req)
else:
error = '<p class="error">%s</p>' % (t(lang(req), "workflow_error_msg"))
req.params["errorlist"] = missing
if mask:
maskcontent = mask.getFormHTML([node], req)
else:
maskcontent = req.getTAL("workflow/editmetadata.html", {}, macro="maskerror")
return req.getTAL("workflow/editmetadata.html",
{"name": self.getName(),
"error": error,
"key": key,
"mask": maskcontent,
"pretext": self.getPreText(lang(req)),
"posttext": self.getPostText(lang(req)),
"sidebartext": self.getSidebarText(lang(req)),
"buttons": self.tableRowButtons(node)},
macro="workflow_metadateneditor")
def show_workflow_node(self, node, req):
if "gotrue" in req.params:
return self.forwardAndShow(node, True, req)
if "gofalse" in req.params:
return self.forwardAndShow(node, False, req)
key = req.params.get("key", req.session.get("key", ""))
masks = self.get("masks")
if not masks:
masklist = ["editmask"]
else:
masklist = masks.split(";")
fieldmap = []
mask = None
for maskname in masklist:
t = getMetaType(node.type)
if t:
if node.get('system.wflanguage') != '': # use correct language
mask = t.getMask("%s.%s" % (node.get('system.wflanguage'), maskname))
if not mask:
mask = t.getMask(maskname)
try:
fieldmap += [mask.getViewHTML([node], VIEW_HIDE_EMPTY, language=lang(req))]
except:
print "error"
logging.getLogger("error").error("mask %s defined for workflow step not found." % mask)
return ""
filelist = ""
filelistshort = ""
if node.getFiles():
filelist = mkfilelist(node, request=req)
filelistshort = mkfilelistshort(node, request=req)
return req.getTAL("workflow/showdata.html",
{"key": key,
"filelist": filelist,
"filelistshort": filelistshort,
"fields": fieldmap,
"pretext": self.getPreText(lang(req)),
"posttext": self.getPostText(lang(req)),
"sidebar": self.getSidebarText(lang(req)),
"buttons": self.tableRowButtons(node)},
macro="workflow_showdata")
def MetatypeDetail(req, id, err=0):
v = getAdminStdVars(req)
if err == 0 and id == "":
# new metadatatype
metadatatype = tree.Node("", type="metadatatype")
v["original_name"] = ""
elif id != "" and err == 0:
# edit metadatatype
metadatatype = getMetaType(id)
v["original_name"] = metadatatype.getName()
else:
# error
metadatatype = tree.Node(req.params["mname"], type="metadatatype")
metadatatype.setDescription(req.params["description"])
metadatatype.setLongName(req.params["mlongname"])
metadatatype.setActive("mactive" in req.params)
metadatatype.setDatatypeString(req.params.get("mdatatypes", "").replace(";", ", "))
metadatatype.set("bibtexmapping", req.params.get("mbibtex", ""))
metadatatype.set("citeprocmapping", req.params.get("mciteproc", ""))
v["original_name"] = req.params["mname_orig"]
v["datatypes"] = loadNonSystemTypes()
v["datatypes"].sort(lambda x, y: cmp(t(lang(req), x.getLongName()), t(lang(req), y.getLongName())))
v["metadatatype"] = metadatatype
v["error"] = err
v["bibtextypes"] = getAllBibTeXTypes()
v["bibtexselected"] = metadatatype.get("bibtexmapping").split(";")
v["citeproctypes"] = citeproc.TYPES
v["citeprocselected"] = metadatatype.get("citeprocmapping").split(";")
rule = metadatatype.getAccess("read")
if rule:
rule = rule.split(",")
else:
rule = []
rights = removeEmptyStrings(rule)
v["acl"] = makeList(req, "read", rights, {}, overload=0, type="read")
v["filtertype"] = req.params.get("filtertype", "")
v["actpage"] = req.params.get("actpage")
return req.getTAL("web/admin/modules/metatype.html", v, macro="modify_type")
def MetatypeDetail(req, id, err=0):
v = getAdminStdVars(req)
if err == 0 and id == "":
# new metadatatype
metadatatype = Metadatatype(u"")
db.session.commit()
v["original_name"] = ""
elif id != "" and err == 0:
# edit metadatatype
metadatatype = getMetaType(id)
v["original_name"] = metadatatype.getName()
else:
# error
metadatatype = Metadatatype(req.params["mname"])
metadatatype.set("description", req.params["description"])
metadatatype.set("longname", req.params["mlongname"])
metadatatype.set("active", "mactive" in req.params)
metadatatype.set("datatypes", req.params.get("mdatatypes", "").replace(";", ", "))
metadatatype.set("bibtexmapping", req.params.get("mbibtex", ""))
metadatatype.set("citeprocmapping", req.params.get("mciteproc", ""))
db.session.commit()
v["original_name"] = req.params["mname_orig"]
d = Data()
v["datatypes"] = d.get_all_datatypes()
v["datatypes"].sort(lambda x, y: cmp(t(lang(req), x.__name__), t(lang(req), y.__name__)))
v["metadatatype"] = metadatatype
v["error"] = err
v["bibtextypes"] = getAllBibTeXTypes()
v["bibtexselected"] = metadatatype.get("bibtexmapping").split(";")
v["citeproctypes"] = citeproc.TYPES
v["citeprocselected"] = metadatatype.get("citeprocmapping").split(";")
try:
rules = [r.ruleset_name for r in metadatatype.access_ruleset_assocs.filter_by(ruletype=u'read')]
except:
rules = []
v["acl"] = makeList(req, "read", removeEmptyStrings(rules), {}, overload=0, type="read")
v["filtertype"] = req.params.get("filtertype", "")
v["actpage"] = req.params.get("actpage")
v["csrf"] = req.csrf_token.current_token
return req.getTAL("web/admin/modules/metatype.html", v, macro="modify_type")
def MaskDetails(req, pid, id, err=0):
mtype = getMetaType(pid)
if err == 0 and id == "":
# new mask
mask = Mask(u"")
db.session.commit()
elif id != "" and err == 0:
# edit mask
if id.isdigit():
mask = q(Mask).get(id)
db.session.commit()
else:
mask = mtype.getMask(id)
else:
# error filling values
mask = Mask(req.params.get("mname", ""))
mask.setDescription(req.params.get("mdescription", ""))
mask.setMasktype(req.params.get("mtype"))
mask.setLanguage(req.params.get("mlanguage", ""))
mask.setDefaultMask(req.params.get("mdefault", False))
db.session.commit()
v = getAdminStdVars(req)
v["mask"] = mask
v["mappings"] = getMappings()
v["mtype"] = mtype
v["error"] = err
v["pid"] = pid
v["masktypes"] = getMaskTypes()
v["id"] = id
v["langs"] = config.languages
v["actpage"] = req.params.get("actpage")
try:
rules = [r.ruleset_name for r in mask.access_ruleset_assocs.filter_by(ruletype=u'read')]
except:
rules = []
v["acl"] = makeList(req, "read", removeEmptyStrings(rules), {}, overload=0, type=u"read")
v["csrf"] = req.csrf_token.current_token
return req.getTAL("web/admin/modules/metatype_mask.html", v, macro="modify_mask")
def MaskDetails(req, pid, id, err=0):
mtype = getMetaType(pid)
if err == 0 and id == "":
# new mask
mask = tree.Node("", type="mask")
elif id != "" and err == 0:
# edit mask
if id.isdigit():
mask = tree.getNode(id)
else:
mask = mtype.getMask(id)
else:
# error filling values
mask = tree.Node(req.params.get("mname", ""), type="mask")
mask.setDescription(req.params.get("mdescription", ""))
mask.setMasktype(req.params.get("mtype"))
mask.setLanguage(req.params.get("mlanguage", ""))
mask.setDefaultMask(req.params.get("mdefault", False))
v = getAdminStdVars(req)
v["mask"] = mask
v["mappings"] = getMappings()
v["mtype"] = mtype
v["error"] = err
v["pid"] = pid
v["masktypes"] = getMaskTypes()
v["id"] = id
v["langs"] = config.get("i18n.languages").split(",")
v["actpage"] = req.params.get("actpage")
rule = mask.getAccess("read")
if rule:
rule = rule.split(",")
else:
rule = []
rights = removeEmptyStrings(rule)
v["acl"] = makeList(req, "read", rights, {}, overload=0, type="read")
return req.getTAL("web/admin/modules/metatype_mask.html", v, macro="modify_mask")
def event_metadata_changed(self):
""" Handles metadata content if changed.
Creates a 'new' original [old == upload].
"""
upload_file = None
original_path = None
original_file = None
for f in self.getFiles():
if f.getType() == 'original':
original_file = f
if os.path.exists(f.retrieveFile()):
original_path = f.retrieveFile()
if os.path.basename(original_path).startswith('-'):
return
if f.getType() == 'upload':
if os.path.exists(f.retrieveFile()):
upload_path = os.path.abspath(f.retrieveFile())
if not original_file:
logging.getLogger('editor').info('No original upload for writing IPTC.')
return
if not upload_file:
upload_path = '{}_upload{}'.format(os.path.splitext(original_path)[0], os.path.splitext(original_path)[-1])
shutil.copy(original_path, upload_path)
self.addFile(FileNode(upload_path, 'upload', original_file.mimetype))
tag_dict = {}
for field in getMetaType(self.getSchema()).getMetaFields():
if field.get('type') == "meta" and field.getValueList()[0] != '' and 'on' in field.getValueList():
tag_name = field.getValueList()[0].split('iptc_')[-1]
field_value = self.get('iptc_{}'.format(field.getName()))
if field.getValueList()[0] != '' and 'on' in field.getValueList():
tag_dict[tag_name] = field_value
lib.iptc.IPTC.write_iptc_tags(original_path, tag_dict)
def display(req):
if "jsonrequest" in req.params:
handle_json_request(req)
return
req.session["area"] = ""
content = getContentArea(req)
content.feedback(req)
try: # add export mask data of current node to request object
mask = getMetaType(content.actNode().getSchema()).getMask('head_meta')
req.params['head_meta'] = mask.getViewHTML([content.actNode()],
flags=8)
except:
req.params['head_meta'] = ''
navframe = getNavigationFrame(req)
navframe.feedback(req)
contentHTML = content.html(req)
contentHTML = modify_tex(contentHTML, 'html')
navframe.write(req, contentHTML)
# set status code here...
req.setStatus(content.status())
def show_workflow_node(self, node, req):
print req.params
if self.getAccess('data') != self.getAccess(
'write'
): # set access for download same as edit (only once needed)
self.setAccess('data', self.getAccess('write'))
if "gotrue" in req.params:
return self.forwardAndShow(node, True, req)
elif "gofalse" in req.params:
return self.forwardAndShow(node, False, req)
if self.getTrueLabel(language=node.get(
"system.wflanguage")) == "" and self.getFalseLabel(
language=node.get("system.wflanguage")) == "":
buttons = []
else:
buttons = self.tableRowButtons(node)
try:
mask = getMetaType(node.type).getMask(self.get("mask_fileatt"))
maskdata = mask.getViewHTML([node],
VIEW_HIDE_EMPTY,
language=lang(req))
except:
maskdata = ""
return req.getTAL("workflow/fileattachment.html", {
"buttons": buttons,
"files": self.getFiles(),
"wfnode": self,
"pretext": self.getPreText(lang(req)),
"posttext": self.getPostText(lang(req)),
"sidebar": self.getSidebarText(lang(req)),
'maskdata': maskdata
},
macro="fileattachment_show_node")
def export_shoppingbag_bibtex(req):
"""
Export the metadata of selected nodes in a BibTeX-format
"""
from web.frontend.streams import sendBibFile
from schema.schema import getMetaType
import core.config as config
import random
import os
items = [] # list of nodes to be exported
for key in req.params.keys():
if key.startswith("select_"):
items.append(key[7:])
dest = config.get("paths.tempdir") + str(random.random()) + ".bib"
f = open(dest, "a")
for item in items:
node = tree.getNode(item)
mask = getMetaType(node.getSchema()).getMask("bibtex")
if mask is not None:
f.write(mask.getViewHTML([node], flags=8)) # flags =8 -> export type
else:
f.write("The selected document type doesn't have any bibtex export mask")
f.write("\n")
f.close()
if len(items) > 0:
sendBibFile(req, dest)
for root, dirs, files in os.walk(dest, topdown=False):
for name in files:
os.remove(os.path.join(root, name))
for name in dirs:
os.rmdir(os.path.join(root, name))
if os.path.isdir(dest):
os.rmdir(dest)
def show_workflow_step(self, req):
typenames = self.get("newnodetype").split(";")
wfnode = self.parents[0]
redirect = ""
message = ""
# check existence of metadata types listed in the definition of the start node
mdts = q(Metadatatypes).one()
for schema in typenames:
if not mdts.children.filter_by(name=schema.strip().split("/")[-1]).scalar():
return ('<i>%s: %s </i>') % (schema, t(lang(req), "permission_denied"))
if "workflow_start" in req.params:
switch_language(req, req.params.get('workflow_language'))
content_class = Node.get_class_for_typestring(req.params.get('selected_schema').split('/')[0])
node = content_class(name=u'', schema=req.params.get('selected_schema').split('/')[1])
self.children.append(node)
# create user group named '_workflow' if it doesn't exist
workflow_group = q(UserGroup).filter_by(name=u'_workflow').scalar()
if workflow_group is None:
workflow_group = UserGroup(name=u'_workflow', description=u'internal dummy group for nodes in workflows')
db.session.add(workflow_group)
# create access rule with '_workflow' user group
workflow_rule = get_or_add_access_rule(group_ids=[workflow_group.id])
special_access_ruleset = node.get_or_add_special_access_ruleset(ruletype=u'read')
special_access_ruleset.rule_assocs.append(AccessRulesetToRule(rule=workflow_rule))
node.set("creator", "workflow-" + self.parents[0].name)
node.set("creationtime", date.format_date())
node.set("system.wflanguage", req.params.get('workflow_language', req.Cookies.get('language')))
node.set("key", mkKey())
node.set("system.key", node.get("key")) # initial key identifier
req.session["key"] = node.get("key")
db.session.commit()
return self.forwardAndShow(node, True, req)
elif "workflow_start_auth" in req.params: # auth node by id and key
try:
node = q(Node).get(req.params.get('nodeid'))
# startkey, but protected
if node.get('system.key') == req.params.get('nodekey') and node.get('key') != req.params.get('nodekey'):
message = "workflow_start_err_protected"
elif node.get('key') == req.params.get('nodekey'):
redirect = "/pnode?id=%s&key=%s" % (node.id, node.get('key'))
else:
message = "workflow_start_err_wrongkey"
except:
logg.exception("exception in workflow step start (workflow_start_auth)")
message = "workflow_start_err_wrongkey"
types = []
for a in typenames:
if a:
m = getMetaType(a)
# we could now check m.isActive(), but for now let's
# just take all specified metatypes, so that edit area
# and workflow are independent on this
types += [(m, a)]
cookie_error = t(lang(req), "Your browser doesn't support cookies")
js = """
<script language="javascript">
function cookie_test() {
if (document.cookie=="")
document.cookie = "CookieTest=Erfolgreich";
if (document.cookie=="") {
alert("%s");
}
}
cookie_test();
</script>""" % cookie_error
return req.getTAL("workflow/start.html",
{'types': types,
'id': self.id,
'js': js,
'starttext': self.get('starttext'),
'languages': self.parents[0].getLanguages(),
'currentlang': lang(req),
'sidebartext': self.getSidebarText(lang(req)),
'redirect': redirect,
'message': message,
'allowcontinue': self.get('allowcontinue'),
"csrf": req.csrf_token.current_token,},
macro="workflow_start")
def writeRecord(req, node, metadataformat):
if not SET_LIST:
initSetList(req)
updatetime = node.get(DATEFIELD)
if updatetime:
d = ISO8601(date.parse_date(updatetime))
else:
d = ISO8601(date.DateTime(EARLIEST_YEAR - 1, 12, 31, 23, 59, 59))
set_specs = getSetSpecsForNode(node)
if DEBUG:
timetable_update(
req,
" in writeRecord: getSetSpecsForNode: node: '%s, %s', metadataformat='%s' set_specs:%s"
% (str(node.id), node.type, metadataformat, str(set_specs)))
req.write("""
<record>
<header><identifier>%s</identifier>
<datestamp>%sZ</datestamp>
%s
</header>
<metadata>""" % (mkIdentifier(node.id), d, set_specs))
if DEBUG:
timetable_update(
req,
" in writeRecord: writing header: node.id='%s', metadataformat='%s'"
% (str(node.id), metadataformat))
if metadataformat == "mediatum":
req.write(core.xmlnode.getSingleNodeXML(node))
# in [masknode.name for masknode in getMetaType(node.getSchema()).getMasks() if masknode.get('masktype')=='exportmask']:
elif nodeHasOAIExportMask(node, metadataformat.lower()):
mask = getMetaType(node.getSchema()).getMask("oai_" +
metadataformat.lower())
if DEBUG:
timetable_update(
req,
""" in writeRecord: mask = getMetaType(node.getSchema()).getMask("oai_"+metadataformat.lower()): node.id='%s', metadataformat='%s'"""
% (str(node.id), metadataformat))
try:
req.write(fixXMLString(mask.getViewHTML(
[node], flags=8))) # fix xml errors
except:
req.write(mask.getViewHTML([node], flags=8))
if DEBUG:
timetable_update(
req,
" in writeRecord: req.write(mask.getViewHTML([node], flags=8)): node.id='%s', metadataformat='%s'"
% (str(node.id), metadataformat))
else:
req.write('<recordHasNoXMLRepresentation/>')
req.write('</metadata></record>')
if DEBUG:
timetable_update(
req, "leaving writeRecord: node.id='%s', metadataformat='%s'" %
(str(node.id), metadataformat))
def showEditor(req):
path = req.path[1:].split("/")
mtype = getMetaType(path[1])
editor = mtype.getMask(path[2])
req.params["metadatatype"] = mtype
for key in req.params.keys():
if req.params.get("op", "") == "cancel":
if "savedetail" in req.params.keys():
del req.params["savedetail"]
break
if key.startswith("up_"):
changeOrder(
q(Node).get(key[3:-2]).parents[0],
q(Node).get(key[3:-2]).orderpos, -1)
break
if key.startswith("down_"):
changeOrder(
q(Node).get(key[5:-2]).parents[0], -1,
q(Node).get(key[5:-2]).orderpos)
break
if key.startswith("delete_"):
editor.deleteMaskitem(key[7:-2])
break
if key.startswith("edit_"):
op = key[5:-2]
req.params["edit"] = op
req.params["op"] = "edit"
break
if key.startswith("new_"):
req.params["edit"] = " "
break
if key.startswith("newdetail_"):
req.params["pid"] = key[10:-2]
req.params["op"] = "newdetail"
req.params["edit"] = " "
if req.params.get("type") in ("vgroup", "hgroup"):
req.params["type"] = "field"
req.params["op"] = "new"
if "savedetail" in req.params.keys():
del req.params["savedetail"]
break
if req.params.get("op", "") == "group":
# create new group for selected objects
req.params["op"] = "new"
req.params["edit"] = " "
req.params["type"] = req.params.get("group_type")
req.params["pid"] = q(Node).get(
req.params.get("sel_id").split(";")[0]).parents[0].id
if "saveedit" in req.params.keys() and req.params.get("op",
"") != "cancel":
# update node
label = req.params.get("label", "-new-")
if req.params.get("op", "") == "edit":
item = q(Node).get(req.params.get("id"))
item.setLabel(req.params.get("label", ""))
db.session.commit()
if "mappingfield" in req.params.keys():
# field of export mask
item.set("attribute", req.params.get("attribute"))
item.set("fieldtype", req.params.get("fieldtype"))
mf = req.params.get("mappingfield").split(";")
if req.params.get(
"fieldtype"
) == "mapping": # mapping field of mapping definition selected
item.set("mappingfield", mf[0])
else: # attribute name as object name
item.set("mappingfield", ";".join(mf[1:]))
db.session.commit()
else:
f = q(Node).get(long(req.params.get("field")))
field = item.children
try:
field = list(field)[0]
if ustr(field.id) != req.params.get("field"):
item.children.remove(field)
item.children.append(f)
field.setValues(
req.params.get(u"{}_value".format(field.get("type")), u""))
db.session.commit()
except:
logg.exception("exception in showEditor / saveedit, ignore")
pass
elif req.params.get("op", "") == "new":
if req.params.get("fieldtype",
"") == "common" and req.params.get("field"):
# existing field used
fieldid = long(req.params.get("field"))
elif "mappingfield" in req.params.keys():
# new mapping field
fieldid = "" # long(req.params.get("mappingfield"))
label = "mapping"
else:
# create new metaattribute
parent = req.params.get("metadatatype").getName()
fieldvalue = req.params.get(
req.params.get("newfieldtype", "") + '_value', "")
if req.params.get("type") == "label":
# new label
fieldid = ""
else:
# normal field
updateMetaField(parent,
req.params.get("fieldname"),
label,
0,
req.params.get("newfieldtype"),
option="",
description=req.params.get(
"description", ""),
fieldvalues=fieldvalue,
fieldvaluenum="",
fieldid="")
fieldid = ustr(
getMetaField(parent, req.params.get("fieldname")).id)
item = editor.addMaskitem(label, req.params.get("type"), fieldid,
req.params.get("pid", "0"))
if "mappingfield" in req.params.keys():
item.set("attribute", req.params.get("attribute"))
item.set("fieldtype", req.params.get("fieldtype"))
mf = req.params.get("mappingfield").split(";")
if req.params.get(
"fieldtype"
) == "mapping": # mapping field of mapping definition selected
item.set("mappingfield", mf[0])
else: # attribute name as object name
item.set("mappingfield", ";".join(mf[1:]))
db.session.commit()
position = req.params.get("insertposition", "end")
if position == "end":
# insert at the end of existing mask
item.orderpos = len(
q(Node).get(req.params.get("pid")).children) - 1
db.session.commit()
else:
# insert at special position
fields = editor.getMaskFields()
fields.all().sort(lambda x, y: cmp(x.orderpos, y.orderpos))
for f in fields:
if f.orderpos >= q(Node).get(
position).orderpos and f.id != item.id:
f.orderpos = f.orderpos + 1
item.orderpos = q(Node).get(position).orderpos - 1
db.session.commit()
item.setWidth(req.params.get("width", u'400'))
item.setUnit(req.params.get("unit", u""))
item.setDefault(req.params.get("default", u""))
item.setFormat(req.params.get("format", u""))
item.setSeparator(req.params.get("separator", u""))
item.setDescription(req.params.get("description", u""))
item.setTestNodes(req.params.get("testnodes", u""))
item.setMultilang(req.params.get("multilang", u""))
db.session.commit()
if "required" in req.params.keys():
item.setRequired(unicode(1))
else:
item.setRequired(unicode(0))
db.session.commit()
if "savedetail" in req.params.keys():
label = req.params.get("label", "-new-")
# save details (used for hgroup)
if req.params.get("op", "") == "edit":
item = q(Node).get(req.params.get("id"))
item.setLabel(req.params.get("label", ""))
elif req.params.get("op", "") == "new":
if req.params.get("sel_id", "") != "":
item = editor.addMaskitem(label, req.params.get("type"),
req.params.get("sel_id", "")[:-1],
long(req.params.get("pid", "0")))
else:
item = editor.addMaskitem(label, req.params.get("type"), 0,
long(req.params.get("pid", "0")))
db.session.commit()
# move selected elementd to new item-container
if req.params.get("sel_id", "") != "":
pos = 0
for i in req.params.get("sel_id")[:-1].split(";"):
n = q(Node).get(i) # node to move
n.setOrderPos(pos)
p = q(Node).get(n.parents()[0].id) # parentnode
p.children.remove(n)
item.children.append(n) # new group
pos += 1
db.session.commit()
# position:
position = req.params.get("insertposition", "end")
if position == "end":
# insert at the end of existing mask
item.setOrderPos(
len(q(Node).get(req.params.get("pid")).children) - 1)
db.session.commit()
else:
# insert at special position
fields = []
pidnode = q(Node).get(req.params.get("pid"))
for field in pidnode.getChildren():
if field.getType().getName(
) == "maskitem" and field.id != pidnode.id:
fields.append(field)
fields.sort(lambda x, y: cmp(x.orderpos, y.orderpos))
for f in fields:
if f.orderpos >= q(Node).get(
position).orderpos and f.id != item.id:
f.orderpos = f.orderpos + 1
item.orderpos = q(Node).get(position).orderpos - 1
db.session.commit()
if "edit" not in req.params.keys():
item.set("type", req.params.get("type", u""))
item.setWidth(req.params.get("width", u'400'))
item.setUnit(req.params.get("unit", u""))
item.setDefault(req.params.get("default", u""))
item.setFormat(req.params.get("format", u""))
item.setSeparator(req.params.get("separator", u""))
item.setDescription(req.params.get("description", u""))
if "required" in req.params.keys():
item.setRequired(unicode(1))
else:
item.setRequired(unicode(0))
db.session.commit()
v = {}
v["edit"] = req.params.get("edit", "")
if req.params.get("edit", "") != "":
v["editor"] = editor.editItem(req)
else:
# show metaEditor
v["editor"] = ""
try:
v["editor"] = req.getTALstr(editor.getMetaMask(req), {})
except:
logg.exception("exception in showEditor")
v["editor"] = editor.getMetaMask(req)
v["title"] = editor.name
v["csrf"] = req.csrf_token.current_token
return req.getTAL("web/admin/modules/metatype.html",
v,
macro="editor_popup")
def validate(req, op):
path = req.path[1:].split("/")
if len(path) == 3 and path[2] == "overview":
return showFieldOverview(req)
if len(path) == 4 and path[3] == "editor":
res = showEditor(req)
return res
if len(path) == 5 and path[3] == "editor" and path[4] == "show_testnodes":
raise NotImplementedError("")
template = req.params.get('template', '')
testnodes_list = req.params.get('testnodes', '')
width = req.params.get('width', '400')
item_id = req.params.get('item_id', None)
mdt_name = path[1]
mask_name = path[2]
mdt = q(Metadatatypes).one().children.filter_by(name=mdt_name).one()
mask = mdt.children.filter_by(name=mask_name).one()
sectionlist = []
for nid in [x.strip() for x in testnodes_list.split(',') if x.strip()]:
section_descr = {}
section_descr['nid'] = nid
section_descr['error_flag'] = '' # in case of no error
node = q(Node).get(nid)
section_descr['node'] = node
if node and node.has_data_access():
try:
node_html = mask.getViewHTML(
[node],
VIEW_DEFAULT,
template_from_caller=[template, mdt, mask, item_id])
section_descr['node_html'] = node_html
except:
logg.exception("exception while evaluating template")
error_text = str(sys.exc_info()[1])
template_line = 'for node id ' + ustr(
nid) + ': ' + error_text
with suppress(Exception, warn=False):
m = re.match(
r".*line (?P<line>\d*), column (?P<column>\d*)",
error_text)
if m:
mdict = m.groupdict()
line = int(mdict.get('line', 0))
column = int(mdict.get('column', 0))
error_text = error_text.replace(
'line %d' % line,
'template line %d' % (line - 1))
template_line = 'for node id ' + ustr(
nid
) + '<br/>' + error_text + '<br/><code>' + esc(
template.split("\n")[line - 2][0:column - 1]
) + '<span style="color:red">' + esc(
template.split("\n")[line -
2][column -
1:]) + '</span></code>'
section_descr[
'error_flag'] = 'Error while evaluating template:'
section_descr['node_html'] = template_line
elif node and not node.has_data_access():
section_descr['error_flag'] = 'no access'
section_descr['node_html'] = ''
if node is None:
section_descr['node'] = None
section_descr['error_flag'] = 'NoSuchNodeError'
section_descr['node_html'] = 'for node id ' + ustr(nid)
sectionlist.append(section_descr)
# remark: error messages will be served untranslated in English
# because messages from the python interpreter (in English) will be added
return req.getTAL("web/admin/modules/metatype.html", {
'sectionlist': sectionlist,
'csrf': req.csrf_token.current_token
},
macro="view_testnodes")
if len(path) == 2 and path[1] == "info":
return showInfo(req)
if "file" in req.params and hasattr(
req.params["file"],
"filesize") and req.params["file"].filesize > 0:
# import scheme from xml-file
importfile = req.params.get("file")
if importfile.tempname != "":
xmlimport(req, importfile.tempname)
if req.params.get("acttype", "schema") == "schema":
# section for schema
for key in req.params.keys():
# create new metadatatype
if key.startswith("new"):
return MetatypeDetail(req, "")
# edit metadatatype
elif key.startswith("edit_"):
return MetatypeDetail(req, key[5:-2])
# delete metadata
elif key.startswith("delete_"):
deleteMetaType(key[7:-2])
break
# show details for given metadatatype
elif key.startswith("detaillist_"):
return showDetailList(req, key[11:-2])
# show masklist for given metadatatype
elif key.startswith("masks_"):
return showMaskList(req, key[6:-2])
# save schema
if "form_op" in req.params.keys():
if req.params.get("form_op", "") == "cancel":
return view(req)
if req.params.get("mname", "") == "" or req.params.get(
"mlongname", "") == "" or req.params.get("mdatatypes",
"") == "":
return MetatypeDetail(req, req.params.get("mname_orig", ""),
1) # no name was given
elif not checkString(req.params.get("mname", "")):
return MetatypeDetail(
req, req.params.get("mname_orig", ""),
4) # if the name contains wrong characters
elif req.params.get("mname_orig", "") != req.params.get(
"mname", "") and existMetaType(req.params.get("mname")):
return MetatypeDetail(req, req.params.get("mname_orig", ""),
2) # metadata still existing
_active = 0
if req.params.get("mactive", "") != "":
_active = 1
updateMetaType(req.params.get("mname", ""),
description=req.params.get("description", ""),
longname=req.params.get("mlongname", ""),
active=_active,
datatypes=req.params.get("mdatatypes",
"").replace(";", ", "),
bibtexmapping=req.params.get("mbibtex", ""),
citeprocmapping=req.params.get("mciteproc", ""),
orig_name=req.params.get("mname_orig", ""))
mtype = q(Metadatatype).filter_by(
name=req.params.get("mname")).scalar()
if mtype:
new_ruleset_names = set(req.form.getlist("leftread"))
add_remove_rulesets_from_metadatatype(mtype, new_ruleset_names)
db.session.commit()
elif req.params.get("acttype") == "field":
# section for fields
for key in req.params.keys():
# create new meta field
if key.startswith("newdetail_"):
return FieldDetail(req, req.params.get("parent"), "")
# edit meta field
elif key.startswith("editdetail_"):
return FieldDetail(req, req.params.get("parent"), key[11:-2])
# delete metafield: key[13:-2] = pid | n
elif key.startswith("deletedetail_"):
deleteMetaField(req.params.get("parent"), key[13:-2])
return showDetailList(req, req.params.get("parent"))
# change field order up
if key.startswith("updetail_"):
moveMetaField(req.params.get("parent"), key[9:-2], -1)
return showDetailList(req, req.params.get("parent"))
# change field order down
elif key.startswith("downdetail_"):
moveMetaField(req.params.get("parent"), key[11:-2], 1)
return showDetailList(req, req.params.get("parent"))
if "form_op" in req.params.keys():
if req.params.get("form_op", "") == "cancel":
return showDetailList(req, req.params.get("parent"))
if existMetaField(req.params.get("parent"), req.params.get("mname")) and \
(req.params.get("form_op", "") == "save_newdetail" or req.params.get("mname") != req.params.get("mname_orig")):
return FieldDetail(req, req.params.get("parent"),
req.params.get("orig_name", ""),
3) # field still existing
elif req.params.get("mname", "") == "" or req.params.get(
"mlabel", "") == "":
return FieldDetail(req, req.params.get("parent"),
req.params.get("orig_name", ""), 1)
elif not checkString(req.params.get("mname", "")):
# if the name contains wrong characters
return FieldDetail(req, req.params.get("parent"),
req.params.get("orig_name", ""), 4)
_option = ""
for o in req.params.keys():
if o.startswith("option_"):
_option += o[7]
_fieldvalue = ""
if req.params.get("mtype", "") + "_value" in req.params.keys():
_fieldvalue = req.params.get(
req.params.get("mtype") + "_value")
_filenode = None
if "valuesfile" in req.params.keys():
valuesfile = req.params.pop("valuesfile")
_filenode = importFileToRealname(valuesfile.filename,
valuesfile.tempname)
_attr_dict = {}
if req.params.get("mtype",
"") + "_handle_attrs" in req.params.keys():
attr_names = [
s.strip() for s in req.params.get(
req.params.get("mtype", "") +
"_handle_attrs").split(",")
]
key_prefix = req.params.get("mtype", "") + "_attr_"
for attr_name in attr_names:
attr_value = req.params.get(key_prefix + attr_name, "")
_attr_dict[attr_name] = attr_value
updateMetaField(req.params.get("parent", ""),
req.params.get("mname", ""),
req.params.get("mlabel", ""),
req.params.get("orderpos", ""),
req.params.get("mtype", ""),
_option,
req.params.get("mdescription", ""),
_fieldvalue,
fieldid=req.params.get("fieldid", ""),
filenode=_filenode,
attr_dict=_attr_dict)
return showDetailList(req, req.params.get("parent"))
elif req.params.get("acttype") == "mask":
# section for masks
for key in req.params.keys():
# new mask
if key.startswith("newmask_"):
return MaskDetails(req, req.params.get("parent"), "")
# edit metatype masks
elif key.startswith("editmask_"):
return MaskDetails(req,
req.params.get("parent"),
key[9:-2],
err=0)
# delete mask
elif key.startswith("deletemask_"):
mtype = getMetaType(req.params.get("parent"))
mtype.children.remove(q(Node).get(key[11:-2]))
db.session.commit()
return showMaskList(req, req.params.get("parent"))
# create autmatic mask with all fields
elif key.startswith("automask_"):
generateMask(getMetaType(req.params.get("parent")))
return showMaskList(req, req.params.get("parent"))
# cope selected mask
if key.startswith("copymask_"):
k = key[9:-2]
if k.isdigit():
mask = q(Mask).get(k)
else:
mtype = getMetaType(req.params.get("parent"))
mask = mtype.getMask(k)
cloneMask(mask, u"copy_" + mask.name)
return showMaskList(req, req.params.get("parent"))
if "form_op" in req.params.keys():
if req.params.get("form_op", "") == "cancel":
return showMaskList(req, req.params.get("parent"))
if req.params.get("mname", "") == "":
return MaskDetails(req,
req.params.get("parent", ""),
req.params.get("morig_name", ""),
err=1)
elif not checkString(req.params.get("mname", "")):
# if the name contains wrong characters
return MaskDetails(req,
req.params.get("parent", ""),
req.params.get("morig_name", ""),
err=4)
mtype = q(Metadatatype).filter_by(
name=q(Node).get(req.params.get("parent", "")).name).one()
if req.params.get("form_op") == "save_editmask":
mask = mtype.get_mask(req.params.get("mname", ""))
# in case of renaming a mask the mask cannot be detected via the new mname
# then detect mask via maskid
if not mask:
mtype = getMetaType(req.params.get("parent"))
mask = mtype.children.filter_by(
id=req.params.get("maskid", "")).scalar()
elif req.params.get("form_op") == "save_newmask":
mask = Mask(req.params.get("mname", ""))
mtype.children.append(mask)
db.session.commit()
mask.name = req.params.get("mname")
mask.setDescription(req.params.get("mdescription"))
mask.setMasktype(req.params.get("mtype"))
mask.setSeparator(req.params.get("mseparator"))
db.session.commit()
if req.params.get("mtype") == "export":
mask.setExportMapping(req.params.get("exportmapping") or "")
mask.setExportHeader(req.params.get("exportheader"))
mask.setExportFooter(req.params.get("exportfooter"))
_opt = ""
if "types" in req.params.keys():
_opt += "t"
if "notlast" in req.params.keys():
_opt += "l"
mask.setExportOptions(_opt)
db.session.commit()
mask.setLanguage(req.params.get("mlanguage", ""))
mask.setDefaultMask("mdefault" in req.params.keys())
for r in mask.access_ruleset_assocs.filter_by(ruletype=u'read'):
db.session.delete(r)
for key in req.params.keys():
if key.startswith("left"):
for r in req.params.get(key).split(';'):
mask.access_ruleset_assocs.append(
NodeToAccessRuleset(ruleset_name=r,
ruletype=key[4:]))
break
db.session.commit()
return showMaskList(req, ustr(req.params.get("parent", "")))
return view(req)
def getContent(req, ids):
def getSchemes(req):
schemes = AccessData(req).filter(loadTypesFromDB())
return filter(lambda x: x.isActive(), schemes)
ret = ""
v = {"message": ""}
if len(ids) >= 0:
ids = ids[0]
v["id"] = ids
if "do_action" in req.params.keys(): # process nodes
fieldname = req.params.get("fields")
old_values = u(req.params.get("old_values", "")).split(";")
new_value = u(req.params.get("new_value"))
basenode = q(Node).get(ids)
entries = getAllAttributeValues(fieldname, req.params.get("schema"))
c = 0
for old_val in old_values:
for n in AccessData(req).filter(
q(Node).filter(Node.id.in_(entries[old_val])).all()):
with suppress(Exception, warn=False):
n.set(
fieldname,
replaceValue(n.get(fieldname), u(old_val),
u(new_value)))
c += 1
v["message"] = req.getTAL("web/edit/modules/manageindex.html",
{"number": c},
macro="operationinfo")
if "style" in req.params.keys(): # load schemes
if req.params.get("action", "") == "schemes":
v["schemes"] = getSchemes(req)
req.writeTAL("web/edit/modules/manageindex.html",
v,
macro="schemes_dropdown")
return ""
elif req.params.get(
"action", "").startswith("indexfields__"): # load index fields
schema = getMetaType(req.params.get("action", "")[13:])
fields = []
for field in schema.getMetaFields():
if field.getFieldtype() == "ilist":
fields.append(field)
v["fields"] = fields
v["schemaname"] = schema.getName()
req.writeTAL("web/edit/modules/manageindex.html",
v,
macro="fields_dropdown")
return ""
elif req.params.get("action", "").startswith(
"indexvalues__"): # load values of selected indexfield
node = q(Node).get(ids)
fieldname = req.params.get("action").split("__")[-2]
schema = req.params.get("action").split("__")[-1]
v["entries"] = []
if node:
v["entries"] = getAllAttributeValues(fieldname, schema)
v["keys"] = v["entries"].keys()
v["keys"].sort(lambda x, y: cmp(x.lower(), y.lower()))
req.writeTAL("web/edit/modules/manageindex.html",
v,
macro="fieldvalues")
return ""
elif req.params.get("action", "").startswith(
"children__"): # search for children of current collection
scheme = req.params.get("action", "").split("__")[1]
fieldname = req.params.get("action", "").split("__")[2]
values = req.params.get("action",
"").split("__")[3].split(";")[:-1]
all_values = getAllAttributeValues(fieldname, scheme)
def isChildOf(access, node, basenodeid):
for ls in getPaths(node):
if basenodeid in [unicode(n.id) for n in ls]:
return 1
return 0
subitems = {}
for value in values:
value = u(value)
if value in all_values:
subitems[value] = []
for l in all_values[value]:
if isChildOf(AccessData(req), q(Node).get(l), ids):
subitems[value].append(l)
v["items"] = subitems
v["keys"] = subitems.keys()
v["keys"].sort()
req.writeTAL("web/edit/modules/manageindex.html",
v,
macro="valueinfo")
return ""
else:
v["csrf"] = req.csrf_token.current_token
return req.getTAL("web/edit/modules/manageindex.html",
v,
macro="manageform")
def validate(req, op):
path = req.path[1:].split("/")
if len(path) == 3 and path[2] == "overview":
return showFieldOverview(req)
if len(path) == 4 and path[3] == "editor":
res = showEditor(req)
return res
if len(path) == 5 and path[3] == "editor" and path[4] == "show_testnodes":
raise NotImplementedError("")
template = req.params.get('template', '')
testnodes_list = req.params.get('testnodes', '')
width = req.params.get('width', '400')
item_id = req.params.get('item_id', None)
mdt_name = path[1]
mask_name = path[2]
mdt = q(Metadatatypes).one().children.filter_by(name=mdt_name).one()
mask = mdt.children.filter_by(name=mask_name).one()
sectionlist = []
for nid in [x.strip() for x in testnodes_list.split(',') if x.strip()]:
section_descr = {}
section_descr['nid'] = nid
section_descr['error_flag'] = '' # in case of no error
node = q(Node).get(nid)
section_descr['node'] = node
if node and node.has_data_access():
try:
node_html = mask.getViewHTML([node], VIEW_DEFAULT, template_from_caller=[template, mdt, mask, item_id])
section_descr['node_html'] = node_html
except:
logg.exception("exception while evaluating template")
error_text = str(sys.exc_info()[1])
template_line = 'for node id ' + ustr(nid) + ': ' + error_text
with suppress(Exception, warn=False):
m = re.match(r".*line (?P<line>\d*), column (?P<column>\d*)", error_text)
if m:
mdict = m.groupdict()
line = int(mdict.get('line', 0))
column = int(mdict.get('column', 0))
error_text = error_text.replace('line %d' % line, 'template line %d' % (line - 1))
template_line = 'for node id ' + ustr(nid) + '<br/>' + error_text + '<br/><code>' + esc(
template.split(
"\n")[line - 2][0:column - 1]) + '<span style="color:red">' + esc(
template.split("\n")[line - 2][column - 1:]) + '</span></code>'
section_descr['error_flag'] = 'Error while evaluating template:'
section_descr['node_html'] = template_line
elif node and not node.has_data_access():
section_descr['error_flag'] = 'no access'
section_descr['node_html'] = ''
if node is None:
section_descr['node'] = None
section_descr['error_flag'] = 'NoSuchNodeError'
section_descr['node_html'] = 'for node id ' + ustr(nid)
sectionlist.append(section_descr)
# remark: error messages will be served untranslated in English
# because messages from the python interpreter (in English) will be added
return req.getTAL("web/admin/modules/metatype.html", {'sectionlist': sectionlist, 'csrf': req.csrf_token.current_token}, macro="view_testnodes")
if len(path) == 2 and path[1] == "info":
return showInfo(req)
if "file" in req.params and hasattr(req.params["file"], "filesize") and req.params["file"].filesize > 0:
# import scheme from xml-file
importfile = req.params.get("file")
if importfile.tempname != "":
xmlimport(req, importfile.tempname)
if req.params.get("acttype", "schema") == "schema":
# section for schema
for key in req.params.keys():
# create new metadatatype
if key.startswith("new"):
return MetatypeDetail(req, "")
# edit metadatatype
elif key.startswith("edit_"):
return MetatypeDetail(req, key[5:-2])
# delete metadata
elif key.startswith("delete_"):
deleteMetaType(key[7:-2])
break
# show details for given metadatatype
elif key.startswith("detaillist_"):
return showDetailList(req, key[11:-2])
# show masklist for given metadatatype
elif key.startswith("masks_"):
return showMaskList(req, key[6:-2])
# save schema
if "form_op" in req.params.keys():
if req.params.get("form_op", "") == "cancel":
return view(req)
if req.params.get("mname", "") == "" or req.params.get("mlongname", "") == "" or req.params.get("mdatatypes", "") == "":
return MetatypeDetail(req, req.params.get("mname_orig", ""), 1) # no name was given
elif not checkString(req.params.get("mname", "")):
return MetatypeDetail(req, req.params.get("mname_orig", ""), 4) # if the name contains wrong characters
elif req.params.get("mname_orig", "") != req.params.get("mname", "") and existMetaType(req.params.get("mname")):
return MetatypeDetail(req, req.params.get("mname_orig", ""), 2) # metadata still existing
_active = 0
if req.params.get("mactive", "") != "":
_active = 1
updateMetaType(req.params.get("mname", ""),
description=req.params.get("description", ""),
longname=req.params.get("mlongname", ""), active=_active,
datatypes=req.params.get("mdatatypes", "").replace(";", ", "),
bibtexmapping=req.params.get("mbibtex", ""),
citeprocmapping=req.params.get("mciteproc", ""),
orig_name=req.params.get("mname_orig", ""))
mtype = q(Metadatatype).filter_by(name=req.params.get("mname")).scalar()
if mtype:
new_ruleset_names = set(req.form.getlist("leftread"))
add_remove_rulesets_from_metadatatype(mtype, new_ruleset_names)
db.session.commit()
elif req.params.get("acttype") == "field":
# section for fields
for key in req.params.keys():
# create new meta field
if key.startswith("newdetail_"):
return FieldDetail(req, req.params.get("parent"), "")
# edit meta field
elif key.startswith("editdetail_"):
return FieldDetail(req, req.params.get("parent"), key[11:-2])
# delete metafield: key[13:-2] = pid | n
elif key.startswith("deletedetail_"):
deleteMetaField(req.params.get("parent"), key[13:-2])
return showDetailList(req, req.params.get("parent"))
# change field order up
if key.startswith("updetail_"):
moveMetaField(req.params.get("parent"), key[9:-2], -1)
return showDetailList(req, req.params.get("parent"))
# change field order down
elif key.startswith("downdetail_"):
moveMetaField(req.params.get("parent"), key[11:-2], 1)
return showDetailList(req, req.params.get("parent"))
if "form_op" in req.params.keys():
if req.params.get("form_op", "") == "cancel":
return showDetailList(req, req.params.get("parent"))
if existMetaField(req.params.get("parent"), req.params.get("mname")) and \
(req.params.get("form_op", "") == "save_newdetail" or req.params.get("mname") != req.params.get("mname_orig")):
return FieldDetail(req, req.params.get("parent"), req.params.get("orig_name", ""), 3) # field still existing
elif req.params.get("mname", "") == "" or req.params.get("mlabel", "") == "":
return FieldDetail(req, req.params.get("parent"), req.params.get("orig_name", ""), 1)
elif not checkString(req.params.get("mname", "")):
# if the name contains wrong characters
return FieldDetail(req, req.params.get("parent"), req.params.get("orig_name", ""), 4)
_option = ""
for o in req.params.keys():
if o.startswith("option_"):
_option += o[7]
_fieldvalue = ""
if req.params.get("mtype", "") + "_value" in req.params.keys():
_fieldvalue = req.params.get(req.params.get("mtype") + "_value")
_filenode = None
if "valuesfile" in req.params.keys():
valuesfile = req.params.pop("valuesfile")
_filenode = importFileToRealname(valuesfile.filename, valuesfile.tempname)
_attr_dict = {}
if req.params.get("mtype", "") + "_handle_attrs" in req.params.keys():
attr_names = [s.strip() for s in req.params.get(req.params.get("mtype", "") + "_handle_attrs").split(",")]
key_prefix = req.params.get("mtype", "") + "_attr_"
for attr_name in attr_names:
attr_value = req.params.get(key_prefix + attr_name, "")
_attr_dict[attr_name] = attr_value
updateMetaField(req.params.get("parent", ""), req.params.get("mname", ""),
req.params.get("mlabel", ""), req.params.get("orderpos", ""),
req.params.get("mtype", ""), _option, req.params.get("mdescription", ""),
_fieldvalue, fieldid=req.params.get("fieldid", ""),
filenode=_filenode,
attr_dict=_attr_dict)
return showDetailList(req, req.params.get("parent"))
elif req.params.get("acttype") == "mask":
# section for masks
for key in req.params.keys():
# new mask
if key.startswith("newmask_"):
return MaskDetails(req, req.params.get("parent"), "")
# edit metatype masks
elif key.startswith("editmask_"):
return MaskDetails(req, req.params.get("parent"), key[9:-2], err=0)
# delete mask
elif key.startswith("deletemask_"):
mtype = getMetaType(req.params.get("parent"))
mtype.children.remove(q(Node).get(key[11:-2]))
db.session.commit()
return showMaskList(req, req.params.get("parent"))
# create autmatic mask with all fields
elif key.startswith("automask_"):
generateMask(getMetaType(req.params.get("parent")))
return showMaskList(req, req.params.get("parent"))
# cope selected mask
if key.startswith("copymask_"):
k = key[9:-2]
if k.isdigit():
mask = q(Mask).get(k)
else:
mtype = getMetaType(req.params.get("parent"))
mask = mtype.getMask(k)
cloneMask(mask, u"copy_" + mask.name)
return showMaskList(req, req.params.get("parent"))
if "form_op" in req.params.keys():
if req.params.get("form_op", "") == "cancel":
return showMaskList(req, req.params.get("parent"))
if req.params.get("mname", "") == "":
return MaskDetails(req, req.params.get("parent", ""), req.params.get("morig_name", ""), err=1)
elif not checkString(req.params.get("mname", "")):
# if the name contains wrong characters
return MaskDetails(req, req.params.get("parent", ""), req.params.get("morig_name", ""), err=4)
mtype = q(Metadatatype).filter_by(name=q(Node).get(req.params.get("parent", "")).name).one()
if req.params.get("form_op") == "save_editmask":
mask = mtype.get_mask(req.params.get("mname", ""))
# in case of renaming a mask the mask cannot be detected via the new mname
# then detect mask via maskid
if not mask:
mtype = getMetaType(req.params.get("parent"))
mask = mtype.children.filter_by(id =req.params.get("maskid", "")).scalar()
elif req.params.get("form_op") == "save_newmask":
mask = Mask(req.params.get("mname", ""))
mtype.children.append(mask)
db.session.commit()
mask.name = req.params.get("mname")
mask.setDescription(req.params.get("mdescription"))
mask.setMasktype(req.params.get("mtype"))
mask.setSeparator(req.params.get("mseparator"))
db.session.commit()
if req.params.get("mtype") == "export":
mask.setExportMapping(req.params.get("exportmapping") or "")
mask.setExportHeader(req.params.get("exportheader"))
mask.setExportFooter(req.params.get("exportfooter"))
_opt = ""
if "types" in req.params.keys():
_opt += "t"
if "notlast" in req.params.keys():
_opt += "l"
mask.setExportOptions(_opt)
db.session.commit()
mask.setLanguage(req.params.get("mlanguage", ""))
mask.setDefaultMask("mdefault" in req.params.keys())
for r in mask.access_ruleset_assocs.filter_by(ruletype=u'read'):
db.session.delete(r)
for key in req.params.keys():
if key.startswith("left"):
for r in req.params.get(key).split(';'):
mask.access_ruleset_assocs.append(NodeToAccessRuleset(ruleset_name=r, ruletype=key[4:]))
break
db.session.commit()
return showMaskList(req, ustr(req.params.get("parent", "")))
return view(req)
def showDetailList(req, id):
metadatatype = getMetaType(id)
metafields = metadatatype.getMetaFields()
order = getSortCol(req)
actfilter = getFilter(req)
# resets filter to all if adding mask in /metatype view
# if req.params.get('acttype') == 'mask' or req.params.get('acttype') == 'schema':
# if req.path == '/metatype' and 'filterbutton' not in req.params:
# actfilter = '*'
# resets filter when going to a new view
if 'filterbutton' not in req.params:
actfilter = '*'
# filter
if actfilter != "":
if actfilter in ("all", "*", t(lang(req), "admin_filter_all")):
None # all users
elif actfilter == "0-9":
num = re.compile(r'([0-9])')
if req.params.get("filtertype", "") == "name":
metafields = filter(lambda x: num.match(x.getName()), metafields)
else:
metafields = filter(lambda x: num.match(x.getLabel()), metafields)
elif actfilter == "else" or actfilter == t(lang(req), "admin_filter_else"):
all = re.compile(r'([a-z]|[A-Z]|[0-9]|\.)')
if req.params.get("filtertype", "") == "name":
metafields = filter(lambda x: not all.match(x.getName()), metafields)
else:
metafields = filter(lambda x: not all.match(x.getLabel()), metafields)
else:
if req.params.get("filtertype", "") == "name":
metafields = filter(lambda x: x.getName().lower().startswith(actfilter), metafields)
else:
metafields = filter(lambda x: x.getLabel().lower().startswith(actfilter), metafields)
pages = Overview(req, metafields)
# sorting
if order != "":
if int(order[0:1]) == 0:
metafields.sort(lambda x, y: cmp(x.orderpos, y.orderpos))
elif int(order[0:1]) == 1:
metafields.sort(lambda x, y: cmp(x.getName().lower(), y.getName().lower()))
elif int(order[0:1]) == 2:
metafields.sort(lambda x, y: cmp(x.getLabel().lower(), y.getLabel().lower()))
elif int(order[0:1]) == 3:
metafields.sort(
lambda x, y: cmp(getMetaFieldTypeNames()[ustr(x.getFieldtype())], getMetaFieldTypeNames()[ustr(y.getFieldtype())]))
if int(order[1:]) == 1:
metafields.reverse()
else:
metafields.sort(lambda x, y: cmp(x.orderpos, y.orderpos))
v = getAdminStdVars(req)
v["filterattrs"] = [("name", "admin_metafield_filter_name"), ("label", "admin_metafield_filter_label")]
v["filterarg"] = req.params.get("filtertype", "name")
v["sortcol"] = pages.OrderColHeader(
["", t(lang(req), "admin_metafield_col_1"), t(lang(req), "admin_metafield_col_2"), t(lang(req), "admin_metafield_col_3")])
v["metadatatype"] = metadatatype
v["metafields"] = metafields
v["fieldoptions"] = fieldoption
v["fieldtypes"] = getMetaFieldTypeNames()
v["pages"] = pages
v["order"] = order
v["actfilter"] = actfilter
v["actpage"] = req.params.get("actpage")
if ustr(req.params.get("page", "")).isdigit():
v["actpage"] = req.params.get("page")
return req.getTAL("web/admin/modules/metatype_field.html", v, macro="view_field")
def runAction(self, node, op=""):
fnode = None
for fnode in node.files:
if fnode.filetype == "document":
break
def reformatAuthors(s):
authors = s.strip().split(";")
if len(authors) > 1:
authors = ", ".join(authors[:-1]) + " and " + authors[-1]
else:
authors = authors[0]
return authors
# get pdf form appended to this workflow step through upload field 'upload_pdfform'
current_workflow = getNodeWorkflow(node)
current_workflow_step = getNodeWorkflowStep(node)
formfilelist, formfilelist2 = getFilelist(current_workflow_step,
'upload_pdfform')
pdf_fields_editable = current_workflow_step.get("pdf_fields_editable")
pdf_form_separate = current_workflow_step.get("pdf_form_separate")
pdf_form_overwrite = current_workflow_step.get("pdf_form_overwrite")
if pdf_fields_editable.lower() in ["1", "true"]:
pdf_fields_editable = True
else:
pdf_fields_editable = False
if pdf_form_separate.lower() in ["1", "true"]:
pdf_form_separate = True
else:
pdf_form_separate = False
fields = []
f_retrieve_path = None
schema = getMetaType(node.schema)
if formfilelist:
# take newest (mtime)
f_mtime, f_name, f_mimetype, f_size, f_type, f_retrieve_path, f = formfilelist[
-1]
for field_dict in parse_pdftk_fields_dump(
get_pdftk_fields_dump(f_retrieve_path)):
fieldname = field_dict.get('FieldName', None)
if fieldname:
value = ''
if fieldname in dict(node.attrs.items()):
schemafield = schema.children.filter_by(
name=fieldname).first()
value = schemafield.getFormattedValue(node)[1]
if fieldname.find('author') >= 0:
value = reformatAuthors(value)
elif fieldname.lower() == 'node.schema':
value = getMetaType(node.schema).getLongName()
elif fieldname.lower() == 'node.id':
value = unicode(node.id)
elif fieldname.lower() == 'node.type':
value = node.type
elif fieldname.lower() == 'date()':
value = format_date(now(), format='%d.%m.%Y')
elif fieldname.lower() == 'time()':
value = format_date(now(), format='%H:%M:%S')
elif fieldname.find("+") > 0:
for _fn in fieldname.split('+'):
value = node.get(_fn)
if value:
break
elif '[att:' in fieldname:
value = fieldname
while '[att:' in value:
m = re.search('(?<=\[att:)([^&\]]+)', value)
if m:
if m.group(0) == 'id':
v = unicode(node.id)
elif m.group(0) == 'type':
v = node.type
elif m.group(0) == 'schema':
v = getMetaType(node.schema).getLongName()
else:
schemafield = schema.children.filter_by(
name=m.group(0)).first()
v = schemafield.getFormattedValue(node)[0]
value = value.replace(
'[att:%s]' % (m.group(0)), v)
else:
logg.warning(
"workflowstep %s (%s): could not find attribute for pdf form field '%s' - node: '%s' (%s)",
current_workflow_step.name,
current_workflow_step.id, fieldname, node.name,
node.id)
fields.append((fieldname, remove_tags(desc(value))))
if not pdf_form_separate and fnode and f_retrieve_path and os.path.isfile(
f_retrieve_path):
pages = fillPDFForm(f_retrieve_path,
fields,
input_is_fullpath=True,
editable=pdf_fields_editable)
if pages == "": # error in pdf creation -> forward to false operation
logg.error(
"workflowstep %s (%s): could not create pdf file - node: '%s' (%s)"
% (current_workflow_step.name, current_workflow_step.id,
node.name, node.id))
self.forward(node, False)
return
origname = fnode.abspath
outfile = addPagesToPDF(pages, origname)
for f in node.files:
node.files.remove(f)
fnode.path = outfile.replace(config.get("paths.datadir"), "")
node.files.append(fnode)
node.files.append(
File(origname, 'upload',
'application/pdf')) # store original filename
node.event_files_changed()
db.session.commit()
logg.info(
"workflow '%s' (%s), workflowstep '%s' (%s): added pdf form to pdf (node '%s' (%s)) fields: %s",
current_workflow.name, current_workflow.id,
current_workflow_step.name, current_workflow_step.id,
node.name, node.id, fields)
elif pdf_form_separate and f_retrieve_path and os.path.isfile(
f_retrieve_path):
pages = fillPDFForm(f_retrieve_path,
fields,
input_is_fullpath=True,
editable=pdf_fields_editable)
if pages == "": # error in pdf creation -> forward to false operation
logg.error(
"workflowstep %s (%s): could not create pdf file - node: '%s' (%s)"
% (current_workflow_step.name, current_workflow_step.id,
node.name, node.id))
self.forward(node, False)
return
importdir = getImportDir()
try:
new_form_path = join_paths(importdir,
"%s_%s" % (node.id, f_name))
counter = 0
if not pdf_form_overwrite: # build correct filename
while os.path.isfile(new_form_path):
counter += 1
new_form_path = join_paths(
importdir, "%s_%s_%s" % (node.id, counter, f_name))
# copy new file and remove tmp
shutil.copy(pages, new_form_path)
if os.path.exists(pages):
os.remove(pages)
except Exception:
logg.exception(
"workflowstep %s (%s): could not copy pdf form to import directory - node: '%s' (%s), import directory: '%s'",
current_workflow_step.name, current_workflow_step.id,
node.name, node.id, importdir)
found = 0
for fn in node.files:
if fn.abspath == new_form_path:
found = 1
break
if found == 0 or (found == 1 and not pdf_form_overwrite):
node.files.append(
File(new_form_path, 'pdf_form', 'application/pdf'))
db.session.commit()
logg.info(
"workflow '%s' (%s), workflowstep '%s' (%s): added separate pdf form to node (node '%s' (%s)) fields: %s, path: '%s'",
current_workflow.name, current_workflow.id,
current_workflow_step.name, current_workflow_step.id,
node.name, node.id, fields, new_form_path)
else:
logg.warning(
"workflowstep %s (%s): could not process pdf form - node: '%s' (%s)",
current_workflow_step.name, current_workflow_step.id,
node.name, node.id)
self.forward(node, True)
def showEditor(req):
path = req.path[1:].split("/")
mtype = getMetaType(path[1])
editor = mtype.getMask(path[2])
req.params["metadatatype"] = mtype
for key in req.params.keys():
if req.params.get("op", "") == "cancel":
if "savedetail" in req.params.keys():
del req.params["savedetail"]
break
if key.startswith("up_"):
changeOrder(q(Node).get(key[3:-2]).parents[0], q(Node).get(key[3:-2]).orderpos, -1)
break
if key.startswith("down_"):
changeOrder(q(Node).get(key[5:-2]).parents[0], -1, q(Node).get(key[5:-2]).orderpos)
break
if key.startswith("delete_"):
editor.deleteMaskitem(key[7:-2])
break
if key.startswith("edit_"):
op = key[5:-2]
req.params["edit"] = op
req.params["op"] = "edit"
break
if key.startswith("new_"):
req.params["edit"] = " "
break
if key.startswith("newdetail_"):
req.params["pid"] = key[10:-2]
req.params["op"] = "newdetail"
req.params["edit"] = " "
if req.params.get("type")in("vgroup", "hgroup"):
req.params["type"] = "field"
req.params["op"] = "new"
if "savedetail" in req.params.keys():
del req.params["savedetail"]
break
if req.params.get("op", "") == "group":
# create new group for selected objects
req.params["op"] = "new"
req.params["edit"] = " "
req.params["type"] = req.params.get("group_type")
req.params["pid"] = q(Node).get(req.params.get("sel_id").split(";")[0]).parents[0].id
if "saveedit" in req.params.keys() and req.params.get("op", "") != "cancel":
# update node
label = req.params.get("label", "-new-")
if req.params.get("op", "") == "edit":
item = q(Node).get(req.params.get("id"))
item.setLabel(req.params.get("label", ""))
db.session.commit()
if "mappingfield" in req.params.keys():
# field of export mask
item.set("attribute", req.params.get("attribute"))
item.set("fieldtype", req.params.get("fieldtype"))
mf = req.params.get("mappingfield").split(";")
if req.params.get("fieldtype") == "mapping": # mapping field of mapping definition selected
item.set("mappingfield", mf[0])
else: # attribute name as object name
item.set("mappingfield", ";".join(mf[1:]))
db.session.commit()
else:
f = q(Node).get(long(req.params.get("field")))
field = item.children
try:
field = list(field)[0]
if ustr(field.id) != req.params.get("field"):
item.children.remove(field)
item.children.append(f)
field.setValues(req.params.get(u"{}_value".format(field.get("type")), u""))
db.session.commit()
except:
logg.exception("exception in showEditor / saveedit, ignore")
pass
elif req.params.get("op", "") == "new":
if req.params.get("fieldtype", "") == "common" and req.params.get("field"):
# existing field used
fieldid = long(req.params.get("field"))
elif "mappingfield" in req.params.keys():
# new mapping field
fieldid = "" # long(req.params.get("mappingfield"))
label = "mapping"
else:
# create new metaattribute
parent = req.params.get("metadatatype").getName()
fieldvalue = req.params.get(req.params.get("newfieldtype", "") + '_value', "")
if req.params.get("type") == "label":
# new label
fieldid = ""
else:
# normal field
updateMetaField(parent, req.params.get("fieldname"), label, 0,
req.params.get("newfieldtype"), option="", description=req.params.get("description", ""),
fieldvalues=fieldvalue, fieldvaluenum="", fieldid="")
fieldid = ustr(getMetaField(parent, req.params.get("fieldname")).id)
item = editor.addMaskitem(label, req.params.get("type"), fieldid, req.params.get("pid", "0"))
if "mappingfield" in req.params.keys():
item.set("attribute", req.params.get("attribute"))
item.set("fieldtype", req.params.get("fieldtype"))
mf = req.params.get("mappingfield").split(";")
if req.params.get("fieldtype") == "mapping": # mapping field of mapping definition selected
item.set("mappingfield", mf[0])
else: # attribute name as object name
item.set("mappingfield", ";".join(mf[1:]))
db.session.commit()
position = req.params.get("insertposition", "end")
if position == "end":
# insert at the end of existing mask
item.orderpos = len(q(Node).get(req.params.get("pid")).children) - 1
db.session.commit()
else:
# insert at special position
fields = editor.getMaskFields()
fields.all().sort(lambda x, y: cmp(x.orderpos, y.orderpos))
for f in fields:
if f.orderpos >= q(Node).get(position).orderpos and f.id != item.id:
f.orderpos = f.orderpos + 1
item.orderpos = q(Node).get(position).orderpos - 1
db.session.commit()
item.setWidth(req.params.get("width", u'400'))
item.setUnit(req.params.get("unit", u""))
item.setDefault(req.params.get("default", u""))
item.setFormat(req.params.get("format", u""))
item.setSeparator(req.params.get("separator", u""))
item.setDescription(req.params.get("description", u""))
item.setTestNodes(req.params.get("testnodes", u""))
item.setMultilang(req.params.get("multilang", u""))
db.session.commit()
if "required" in req.params.keys():
item.setRequired(unicode(1))
else:
item.setRequired(unicode(0))
db.session.commit()
if "savedetail" in req.params.keys():
label = req.params.get("label", "-new-")
# save details (used for hgroup)
if req.params.get("op", "") == "edit":
item = q(Node).get(req.params.get("id"))
item.setLabel(req.params.get("label", ""))
elif req.params.get("op", "") == "new":
if req.params.get("sel_id", "") != "":
item = editor.addMaskitem(label, req.params.get("type"), req.params.get(
"sel_id", "")[:-1], long(req.params.get("pid", "0")))
else:
item = editor.addMaskitem(label, req.params.get("type"), 0, long(req.params.get("pid", "0")))
db.session.commit()
# move selected elementd to new item-container
if req.params.get("sel_id", "") != "":
pos = 0
for i in req.params.get("sel_id")[:-1].split(";"):
n = q(Node).get(i) # node to move
n.setOrderPos(pos)
p = q(Node).get(n.parents()[0].id) # parentnode
p.children.remove(n)
item.children.append(n) # new group
pos += 1
db.session.commit()
# position:
position = req.params.get("insertposition", "end")
if position == "end":
# insert at the end of existing mask
item.setOrderPos(len(q(Node).get(req.params.get("pid")).children) - 1)
db.session.commit()
else:
# insert at special position
fields = []
pidnode = q(Node).get(req.params.get("pid"))
for field in pidnode.getChildren():
if field.getType().getName() == "maskitem" and field.id != pidnode.id:
fields.append(field)
fields.sort(lambda x, y: cmp(x.orderpos, y.orderpos))
for f in fields:
if f.orderpos >= q(Node).get(position).orderpos and f.id != item.id:
f.orderpos = f.orderpos + 1
item.orderpos = q(Node).get(position).orderpos - 1
db.session.commit()
if "edit" not in req.params.keys():
item.set("type", req.params.get("type", u""))
item.setWidth(req.params.get("width", u'400'))
item.setUnit(req.params.get("unit", u""))
item.setDefault(req.params.get("default", u""))
item.setFormat(req.params.get("format", u""))
item.setSeparator(req.params.get("separator", u""))
item.setDescription(req.params.get("description", u""))
if "required" in req.params.keys():
item.setRequired(unicode(1))
else:
item.setRequired(unicode(0))
db.session.commit()
v = {}
v["edit"] = req.params.get("edit", "")
if req.params.get("edit", "") != "":
v["editor"] = editor.editItem(req)
else:
# show metaEditor
v["editor"] = ""
try:
v["editor"] = req.getTALstr(editor.getMetaMask(req), {})
except:
logg.exception("exception in showEditor")
v["editor"] = editor.getMetaMask(req)
v["title"] = editor.name
v["csrf"] = req.csrf_token.current_token
return req.getTAL("web/admin/modules/metatype.html", v, macro="editor_popup")
def showDetailList(req, id):
metadatatype = getMetaType(id)
metafields = metadatatype.getMetaFields()
order = getSortCol(req)
actfilter = getFilter(req)
# resets filter to all if adding mask in /metatype view
# if req.params.get('acttype') == 'mask' or req.params.get('acttype') == 'schema':
# if req.path == '/metatype' and 'filterbutton' not in req.params:
# actfilter = '*'
# resets filter when going to a new view
if 'filterbutton' not in req.params:
actfilter = '*'
# filter
if actfilter != "":
if actfilter in ("all", "*", t(lang(req), "admin_filter_all")):
None # all users
elif actfilter == "0-9":
num = re.compile(r'([0-9])')
if req.params.get("filtertype", "") == "name":
metafields = filter(lambda x: num.match(x.getName()), metafields)
else:
metafields = filter(lambda x: num.match(x.getLabel()), metafields)
elif actfilter == "else" or actfilter == t(lang(req), "admin_filter_else"):
all = re.compile(r'([a-z]|[A-Z]|[0-9]|\.)')
if req.params.get("filtertype", "") == "name":
metafields = filter(lambda x: not all.match(x.getName()), metafields)
else:
metafields = filter(lambda x: not all.match(x.getLabel()), metafields)
else:
if req.params.get("filtertype", "") == "name":
metafields = filter(lambda x: x.getName().lower().startswith(actfilter), metafields)
else:
metafields = filter(lambda x: x.getLabel().lower().startswith(actfilter), metafields)
pages = Overview(req, metafields)
# sorting
if order != "":
if int(order[0:1]) == 0:
metafields.sort(lambda x, y: cmp(x.getOrderPos(), y.getOrderPos()))
elif int(order[0:1]) == 1:
metafields.sort(lambda x, y: cmp(x.getName().lower(), y.getName().lower()))
elif int(order[0:1]) == 2:
metafields.sort(lambda x, y: cmp(x.getLabel().lower(), y.getLabel().lower()))
elif int(order[0:1]) == 3:
metafields.sort(
lambda x, y: cmp(getMetaFieldTypeNames()[str(x.getFieldtype())], getMetaFieldTypeNames()[str(y.getFieldtype())]))
if int(order[1:]) == 1:
metafields.reverse()
else:
metafields.sort(lambda x, y: cmp(x.getOrderPos(), y.getOrderPos()))
v = getAdminStdVars(req)
v["filterattrs"] = [("name", "admin_metafield_filter_name"), ("label", "admin_metafield_filter_label")]
v["filterarg"] = req.params.get("filtertype", "name")
v["sortcol"] = pages.OrderColHeader(
["", t(lang(req), "admin_metafield_col_1"), t(lang(req), "admin_metafield_col_2"), t(lang(req), "admin_metafield_col_3")])
v["metadatatype"] = metadatatype
v["metafields"] = metafields
v["fieldoptions"] = fieldoption
v["fieldtypes"] = getMetaFieldTypeNames()
v["pages"] = pages
v["order"] = order
v["actfilter"] = actfilter
v["actpage"] = req.params.get("actpage")
if str(req.params.get("page", "")).isdigit():
v["actpage"] = req.params.get("page")
return req.getTAL("web/admin/modules/metatype_field.html", v, macro="view_field")
def validate(req, op):
path = req.path[1:].split("/")
if len(path) == 3 and path[2] == "overview":
return showFieldOverview(req)
if len(path) == 4 and path[3] == "editor":
res = showEditor(req)
# mask may have been edited: flush masks cache
flush_maskcache(req=req)
return res
if len(path) == 5 and path[3] == "editor" and path[4] == "show_testnodes":
template = req.params.get('template', '')
testnodes_list = req.params.get('testnodes', '')
width = req.params.get('width', '400')
item_id = req.params.get('item_id', None)
mdt_name = path[1]
mask_name = path[2]
mdt = tree.getRoot('metadatatypes').getChild(mdt_name)
mask = mdt.getChild(mask_name)
access = AccessData(req)
sectionlist = []
for nid in [x.strip() for x in testnodes_list.split(',') if x.strip()]:
section_descr = {}
section_descr['nid'] = nid
section_descr['error_flag'] = '' # in case of no error
try:
node = tree.getNode(nid)
section_descr['node'] = node
if access.hasAccess(node, "data"):
try:
node_html = mask.getViewHTML([node], VIEW_DEFAULT, template_from_caller=[template, mdt, mask, item_id], mask=mask)
section_descr['node_html'] = node_html
except:
error_text = str(sys.exc_info()[1])
template_line = 'for node id ' + str(nid) + ': ' + error_text
try:
m = re.match(r".*line (?P<line>\d*), column (?P<column>\d*)", error_text)
if m:
mdict = m.groupdict()
line = int(mdict.get('line', 0))
column = int(mdict.get('column', 0))
error_text = error_text.replace('line %d' % line, 'template line %d' % (line - 1))
template_line = 'for node id ' + str(nid) + '<br/>' + error_text + '<br/><code>' + esc(template.split(
"\n")[line - 2][0:column - 1]) + '<span style="color:red">' + esc(template.split("\n")[line - 2][column - 1:]) + '</span></code>'
except:
pass
section_descr['error_flag'] = 'Error while evaluating template:'
section_descr['node_html'] = template_line
else:
section_descr['error_flag'] = 'no access'
section_descr['node_html'] = ''
except tree.NoSuchNodeError:
section_descr['node'] = None
section_descr['error_flag'] = 'NoSuchNodeError'
section_descr['node_html'] = 'for node id ' + str(nid)
sectionlist.append(section_descr)
# remark: error messages will be served untranslated in English
# because messages from the python interpreter (in English) will be added
return req.getTAL("web/admin/modules/metatype.html", {'sectionlist': sectionlist}, macro="view_testnodes")
if len(path) == 2 and path[1] == "info":
return showInfo(req)
if "file" in req.params and hasattr(req.params["file"], "filesize") and req.params["file"].filesize > 0:
# import scheme from xml-file
importfile = req.params.get("file")
if importfile.tempname != "":
xmlimport(req, importfile.tempname)
if req.params.get("acttype", "schema") == "schema":
# section for schema
for key in req.params.keys():
# create new metadatatype
if key.startswith("new"):
return MetatypeDetail(req, "")
# edit metadatatype
elif key.startswith("edit_"):
return MetatypeDetail(req, str(key[5:-2]))
# delete metadata
elif key.startswith("delete_"):
deleteMetaType(key[7:-2])
break
# show details for given metadatatype
elif key.startswith("detaillist_"):
return showDetailList(req, str(key[11:-2]))
# show masklist for given metadatatype
elif key.startswith("masks_"):
return showMaskList(req, str(key[6:-2]))
# reindex search index for current schema
elif key.startswith("indexupdate_") and "cancel" not in req.params.keys():
schema = tree.getNode(key[12:])
searcher.reindex(schema.getAllItems())
break
# save schema
if "form_op" in req.params.keys():
if req.params.get("form_op", "") == "cancel":
return view(req)
if req.params.get("mname", "") == "" or req.params.get("mlongname", "") == "" or req.params.get("mdatatypes", "") == "":
return MetatypeDetail(req, req.params.get("mname_orig", ""), 1) # no name was given
elif not checkString(req.params.get("mname", "")):
return MetatypeDetail(req, req.params.get("mname_orig", ""), 4) # if the name contains wrong characters
elif req.params.get("mname_orig", "") != req.params.get("mname", "") and existMetaType(req.params.get("mname")):
return MetatypeDetail(req, req.params.get("mname_orig", ""), 2) # metadata still existing
_active = 0
if req.params.get("mactive", "") != "":
_active = 1
updateMetaType(req.params.get("mname", ""),
description=req.params.get("description", ""),
longname=req.params.get("mlongname", ""), active=_active,
datatypes=req.params.get("mdatatypes", "").replace(";", ", "),
bibtexmapping=req.params.get("mbibtex", ""),
citeprocmapping=req.params.get("mciteproc", ""),
orig_name=req.params.get("mname_orig", ""))
mtype = getMetaType(req.params.get("mname"))
if mtype:
mtype.setAccess("read", "")
for key in req.params.keys():
if key.startswith("left"):
mtype.setAccess(key[4:], req.params.get(key).replace(";", ","))
break
elif req.params.get("acttype") == "field":
# section for fields
for key in req.params.keys():
# create new meta field
if key.startswith("newdetail_"):
return FieldDetail(req, req.params.get("parent"), "")
# edit meta field
elif key.startswith("editdetail_"):
return FieldDetail(req, req.params.get("parent"), key[11:-2])
# delete metafield: key[13:-2] = pid | n
elif key.startswith("deletedetail_"):
deleteMetaField(req.params.get("parent"), key[13:-2])
return showDetailList(req, req.params.get("parent"))
# change field order up
if key.startswith("updetail_"):
moveMetaField(req.params.get("parent"), key[9:-2], -1)
return showDetailList(req, req.params.get("parent"))
# change field order down
elif key.startswith("downdetail_"):
moveMetaField(req.params.get("parent"), key[11:-2], 1)
return showDetailList(req, req.params.get("parent"))
if "form_op" in req.params.keys():
if req.params.get("form_op", "") == "cancel":
return showDetailList(req, req.params.get("parent"))
if existMetaField(req.params.get("parent"), req.params.get("mname")) and req.params.get("form_op", "") == "save_newdetail":
return FieldDetail(req, req.params.get("parent"), req.params.get("orig_name", ""), 3) # field still existing
elif req.params.get("mname", "") == "" or req.params.get("mlabel", "") == "":
return FieldDetail(req, req.params.get("parent"), req.params.get("orig_name", ""), 1)
elif not checkString(req.params.get("mname", "")):
# if the name contains wrong characters
return FieldDetail(req, req.params.get("parent"), req.params.get("orig_name", ""), 4)
_option = ""
for o in req.params.keys():
if o.startswith("option_"):
_option += o[7]
_fieldvalue = ""
if req.params.get("mtype", "") + "_value" in req.params.keys():
_fieldvalue = str(req.params.get(req.params.get("mtype") + "_value"))
_filenode = None
if "valuesfile" in req.params.keys():
valuesfile = req.params.pop("valuesfile")
_filenode = importFileToRealname(valuesfile.filename, valuesfile.tempname)
_attr_dict = {}
if req.params.get("mtype", "") + "_handle_attrs" in req.params.keys():
attr_names = [s.strip() for s in req.params.get(req.params.get("mtype", "") + "_handle_attrs").split(",")]
key_prefix = req.params.get("mtype", "") + "_attr_"
for attr_name in attr_names:
attr_value = req.params.get(key_prefix + attr_name, "")
_attr_dict[attr_name] = attr_value
updateMetaField(req.params.get("parent", ""), req.params.get("mname", ""),
req.params.get("mlabel", ""), req.params.get("orderpos", ""),
req.params.get("mtype", ""), _option, req.params.get("mdescription", ""),
_fieldvalue, fieldid=req.params.get("fieldid", ""),
filenode=_filenode,
attr_dict=_attr_dict)
return showDetailList(req, req.params.get("parent"))
elif req.params.get("acttype") == "mask":
# mask may have been edited: flush masks cache
flush_maskcache(req=req)
# section for masks
for key in req.params.keys():
# new mask
if key.startswith("newmask_"):
return MaskDetails(req, req.params.get("parent"), "")
# edit metatype masks
elif key.startswith("editmask_"):
return MaskDetails(req, req.params.get("parent"), key[9:-2], err=0)
# delete mask
elif key.startswith("deletemask_"):
mtype = getMetaType(req.params.get("parent"))
mtype.removeChild(tree.getNode(key[11:-2]))
return showMaskList(req, req.params.get("parent"))
# create autmatic mask with all fields
elif key.startswith("automask_"):
generateMask(getMetaType(req.params.get("parent")))
return showMaskList(req, req.params.get("parent"))
# cope selected mask
if key.startswith("copymask_"):
mtype = getMetaType(req.params.get("parent"))
mask = mtype.getMask(key[9:-2])
cloneMask(mask, "copy_" + mask.getName())
return showMaskList(req, req.params.get("parent"))
if "form_op" in req.params.keys():
if req.params.get("form_op", "") == "cancel":
return showMaskList(req, req.params.get("parent"))
if req.params.get("mname", "") == "":
return MaskDetails(req, req.params.get("parent", ""), req.params.get("morig_name", ""), err=1)
elif not checkString(req.params.get("mname", "")):
# if the name contains wrong characters
return MaskDetails(req, req.params.get("parent", ""), req.params.get("morig_name", ""), err=4)
mtype = getMetaType(req.params.get("parent", ""))
if req.params.get("form_op") == "save_editmask":
mask = mtype.getMask(req.params.get("maskid", ""))
elif req.params.get("form_op") == "save_newmask":
mask = tree.Node(req.params.get("mname", ""), type="mask")
mtype.addChild(mask)
mask.setName(req.params.get("mname"))
mask.setDescription(req.params.get("mdescription"))
mask.setMasktype(req.params.get("mtype"))
mask.setSeparator(req.params.get("mseparator"))
if req.params.get("mtype") == "export":
mask.setExportMapping(req.params.get("exportmapping") or "")
mask.setExportHeader(req.params.get("exportheader"))
mask.setExportFooter(req.params.get("exportfooter"))
_opt = ""
if "types" in req.params.keys():
_opt += "t"
if "notlast" in req.params.keys():
_opt += "l"
mask.setExportOptions(_opt)
mask.setLanguage(req.params.get("mlanguage", ""))
mask.setDefaultMask("mdefault" in req.params.keys())
mask.setAccess("read", "")
for key in req.params.keys():
if key.startswith("left"):
mask.setAccess(key[4:], req.params.get(key).replace(";", ","))
break
return showMaskList(req, str(req.params.get("parent", "")))
return view(req)
def show_workflow_step(self, req):
typenames = self.get("newnodetype").split(";")
wfnode = self.getParents()[0]
redirect = ""
message = ""
# check existence of metadata types listed in the definition of the start node
mdts = tree.getRoot("metadatatypes")
for schema in typenames:
if not mdts.hasChild(schema.strip().split("/")[-1]):
return ('<i>%s: %s </i>') % (schema,
t(lang(req), "permission_denied"))
if "workflow_start" in req.params:
switch_language(req, req.params.get('workflow_language'))
node = tree.Node(name="", type=req.params.get('selected_schema'))
self.addChild(node)
node.setAccess("read", "{user workflow}")
node.set("creator", "workflow-" + self.getParents()[0].getName())
node.set("creationtime", date.format_date())
node.set(
"system.wflanguage",
req.params.get('workflow_language',
req.session.get('language')))
node.set("key", mkKey())
node.set("system.key", node.get("key")) # initial key identifier
req.session["key"] = node.get("key")
return self.forwardAndShow(node, True, req)
elif "workflow_start_auth" in req.params: # auth node by id and key
try:
node = tree.getNode(req.params.get('nodeid'))
# startkey, but protected
if node.get('system.key') == req.params.get(
'nodekey'
) and node.get('key') != req.params.get('nodekey'):
message = "workflow_start_err_protected"
elif node.get('key') == req.params.get('nodekey'):
redirect = "/pnode?id=%s&key=%s" % (node.id,
node.get('key'))
else:
message = "workflow_start_err_wrongkey"
except:
message = "workflow_start_err_wrongkey"
types = []
for a in typenames:
if a:
m = getMetaType(a)
# we could now check m.isActive(), but for now let's
# just take all specified metatypes, so that edit area
# and workflow are independent on this
types += [(m, a)]
cookie_error = t(lang(req), "Your browser doesn't support cookies")
js = """
<script language="javascript">
function cookie_test() {
if (document.cookie=="")
document.cookie = "CookieTest=Erfolgreich";
if (document.cookie=="") {
alert("%s");
}
}
cookie_test();
</script>""" % cookie_error
return req.getTAL("workflow/start.html", {
'types': types,
'id': self.id,
'js': js,
'starttext': self.get('starttext'),
'languages': self.getParents()[0].getLanguages(),
'currentlang': lang(req),
'sidebartext': self.getSidebarText(lang(req)),
'redirect': redirect,
'message': message,
'allowcontinue': self.get('allowcontinue')
},
macro="workflow_start")
def show_printview(req):
""" create a pdf preview of given node (id in path e.g. /print/[id]/[area])"""
p = req.path[1:].split("/")
try:
nodeid = int(p[1])
except ValueError:
raise ValueError("Invalid Printview URL: " + req.path)
if len(p) == 3:
if p[2] == "edit":
req.reply_headers['Content-Type'] = "application/pdf"
editprint = printmethod(req)
if editprint:
req.write(editprint)
else:
req.write("")
return
# use objects from session
if str(nodeid) == "0":
children = []
if "contentarea" in req.session:
try:
nodes = req.session["contentarea"].content.files
except:
c = req.session["contentarea"].content
nodes = c.resultlist[c.active].files
for n in nodes:
c_mtype = getMetaType(n.getSchema())
c_mask = c_mtype.getMask("printlist")
if not c_mask:
c_mask = c_mtype.getMask("nodesmall")
_c = c_mask.getViewHTML([n], VIEW_DATA_ONLY + VIEW_HIDE_EMPTY)
if len(_c) > 0:
children.append(_c)
req.reply_headers['Content-Type'] = "application/pdf"
req.write(printview.getPrintView(lang(req), None, [["", "", t(lang(req), "")]], [], 3, children))
else:
node = getNode(nodeid)
if node.get("system.print") == "0":
return 404
access = AccessData(req)
if not access.hasAccess(node, "read"):
req.write(t(req, "permission_denied"))
return
style = int(req.params.get("style", 2))
# nodetype
mtype = getMetaType(node.getSchema())
mask = None
metadata = None
if mtype:
for m in mtype.getMasks():
if m.getMasktype() == "fullview":
mask = m
if m.getMasktype() == "printview":
mask = m
break
if not mask:
mask = mtype.getMask("nodebig")
if mask:
metadata = mask.getViewHTML([node], VIEW_DATA_ONLY + VIEW_HIDE_EMPTY)
if not metadata:
metadata = [['nodename', node.getName(), 'Name', 'text']]
files = node.getFiles()
imagepath = None
for file in files:
if file.getType().startswith("presentati"):
imagepath = file.retrieveFile()
# children
children = []
if node.isContainer():
ret = []
getPrintChildren(req, node, ret)
for c in ret:
if not c.isContainer():
# items
c_mtype = getMetaType(c.getSchema())
c_mask = c_mtype.getMask("printlist")
if not c_mask:
c_mask = c_mtype.getMask("nodesmall")
_c = c_mask.getViewHTML([c], VIEW_DATA_ONLY)
if len(_c) > 0:
children.append(_c)
else:
# header
items = getPaths(c, AccessData(req))
p = []
for item in items[0]:
p.append(u(item.getName()))
p.append(u(c.getName()))
children.append([(c.id, " > ".join(p[1:]), u(c.getName()), "header")])
if len(children) > 1:
col = []
order = []
try:
sort = getCollection(node).get("sortfield")
except:
sort = ""
for i in range(0, 2):
col.append((0, ""))
order.append(1)
if req.params.get("sortfield" + str(i)) != "":
sort = req.params.get("sortfield" + str(i), sort)
if sort != "":
if sort.startswith("-"):
sort = sort[1:]
order[i] = -1
_i = 0
for c in children[0]:
if c[0] == sort:
col[i] = (_i, sort)
_i += 1
if col[i][1] == "":
col[i] = (0, children[0][0][0])
# sort method for items
def myCmp(x, y, col, order):
cx = ""
cy = ""
for item in x:
if item[0] == col[0][1]:
cx = item[1]
break
for item in y:
if item[0] == col[0][1]:
cy = item[1]
break
if cx.lower() > cy.lower():
return 1 * order[0]
return -1 * order[0]
sorted_children = []
tmp = []
for item in children:
if item[0][3] == "header":
if len(tmp) > 0:
tmp.sort(lambda x, y: myCmp(x, y, col, order))
sorted_children.extend(tmp)
tmp = []
sorted_children.append(item)
else:
tmp.append(item)
tmp.sort(lambda x, y: myCmp(x, y, col, order))
sorted_children.extend(tmp)
children = sorted_children
req.reply_headers['Content-Type'] = "application/pdf"
req.write(printview.getPrintView(lang(req), imagepath, metadata, getPaths(
node, AccessData(req)), style, children, getCollection(node)))
def getContent(req, ids):
user = users.getUserFromRequest(req)
if "lza" in users.getHideMenusForUser(user):
req.setStatus(httpstatus.HTTP_FORBIDDEN)
return req.getTAL("web/edit/edit.html", {}, macro="access_error")
v = {}
v['error'] = ""
nodes = []
for id in ids:
node = tree.getNode(id)
access = acl.AccessData(req)
if not access.hasWriteAccess(node):
req.setStatus(httpstatus.HTTP_FORBIDDEN)
return req.getTAL("web/edit/edit.html", {}, macro="access_error")
nodes.append(node)
if "createlza" in req.params:
# remove old file if existing
for f in node.getFiles():
if f.getType()=="lza":
node.removeFile(f)
# create new file
for f in node.getFiles():
if f.getType() in ("original", "document"):
try:
archive = l.LZA(f.retrieveFile())
schema = node.getSchema()
# test for lza export mask
if (getMetaType(schema).getMask("lza")):
m = getMetaType(schema).getMask("lza")
meta = l.LZAMetadata(m.getViewHTML([node], 8))
else:
# generate error message
meta = l.LZAMetadata("""
<?xpacket begin="\xef\xbb\xbf" id="mediatum_metadata"?>
<lza:data>
<lza:error>-definition missing-</lza:error>
</lza:data><?xpacket end="w"?>
""")
archive.writeMediatumData(meta)
node.addFile(tree.
FileNode(archive.buildLZAName(),"lza", f.getMimeType()))
except l.FiletypeNotSupported:
v['error'] = "edit_lza_wrongfiletype"
elif "removelza" in req.params:
for f in node.getFiles():
if f.getType()=="lza":
node.removeFile(f)
v['id'] = req.params.get("id","0")
v['tab'] = req.params.get("tab", "")
v['ids'] = ids
v['nodes'] = nodes
v['t'] = t
v['language'] = lang(req)
meta = {}
for id in ids:
node = tree.getNode(id)
for f in node.getFiles():
if f.getType()=="lza":
try:
archive = l.LZA(f.retrieveFile(), f.getMimeType())
meta[id] = archive.getMediatumData()
except IOError:
v['error'] = "edit_lza_ioerror"
v['meta'] = meta
return req.getTAL("web/edit/modules/lza.html", v, macro="edit_lza")
def show_workflow_step(self, req):
typenames = self.get("newnodetype").split(";")
wfnode = self.parents[0]
redirect = ""
message = ""
# check existence of metadata types listed in the definition of the start node
mdts = q(Metadatatypes).one()
for schema in typenames:
if not mdts.children.filter_by(
name=schema.strip().split("/")[-1]).scalar():
return ('<i>%s: %s </i>') % (schema,
t(lang(req), "permission_denied"))
if "workflow_start" in req.params:
switch_language(req, req.params.get('workflow_language'))
content_class = Node.get_class_for_typestring(
req.params.get('selected_schema').split('/')[0])
node = content_class(
name=u'',
schema=req.params.get('selected_schema').split('/')[1])
self.children.append(node)
# create user group named '_workflow' if it doesn't exist
workflow_group = q(UserGroup).filter_by(name=u'_workflow').scalar()
if workflow_group is None:
workflow_group = UserGroup(
name=u'_workflow',
description=u'internal dummy group for nodes in workflows')
db.session.add(workflow_group)
# create access rule with '_workflow' user group
workflow_rule = get_or_add_access_rule(
group_ids=[workflow_group.id])
special_access_ruleset = node.get_or_add_special_access_ruleset(
ruletype=u'read')
special_access_ruleset.rule_assocs.append(
AccessRulesetToRule(rule=workflow_rule))
node.set("creator", "workflow-" + self.parents[0].name)
node.set("creationtime", date.format_date())
node.set(
"system.wflanguage",
req.params.get('workflow_language',
req.Cookies.get('language')))
node.set("key", mkKey())
node.set("system.key", node.get("key")) # initial key identifier
req.session["key"] = node.get("key")
db.session.commit()
return self.forwardAndShow(node, True, req)
elif "workflow_start_auth" in req.params: # auth node by id and key
try:
node = q(Node).get(req.params.get('nodeid'))
# startkey, but protected
if node.get('system.key') == req.params.get(
'nodekey'
) and node.get('key') != req.params.get('nodekey'):
message = "workflow_start_err_protected"
elif node.get('key') == req.params.get('nodekey'):
redirect = "/pnode?id=%s&key=%s" % (node.id,
node.get('key'))
else:
message = "workflow_start_err_wrongkey"
except:
logg.exception(
"exception in workflow step start (workflow_start_auth)")
message = "workflow_start_err_wrongkey"
types = []
for a in typenames:
if a:
m = getMetaType(a)
# we could now check m.isActive(), but for now let's
# just take all specified metatypes, so that edit area
# and workflow are independent on this
types += [(m, a)]
cookie_error = t(lang(req), "Your browser doesn't support cookies")
js = """
<script language="javascript">
function cookie_test() {
if (document.cookie=="")
document.cookie = "CookieTest=Erfolgreich";
if (document.cookie=="") {
alert("%s");
}
}
cookie_test();
</script>""" % cookie_error
return req.getTAL("workflow/start.html", {
'types': types,
'id': self.id,
'js': js,
'starttext': self.get('starttext'),
'languages': self.parents[0].getLanguages(),
'currentlang': lang(req),
'sidebartext': self.getSidebarText(lang(req)),
'redirect': redirect,
'message': message,
'allowcontinue': self.get('allowcontinue'),
"csrf": req.csrf_token.current_token,
},
macro="workflow_start")
def runAction(self, node, op=""):
fnode = None
for fnode in node.files:
if fnode.filetype == "document":
break
def reformatAuthors(s):
authors = s.strip().split(";")
if len(authors) > 1:
authors = ", ".join(authors[:-1]) + " and " + authors[-1]
else:
authors = authors[0]
return authors
# get pdf form appended to this workflow step through upload field 'upload_pdfform'
current_workflow = getNodeWorkflow(node)
current_workflow_step = getNodeWorkflowStep(node)
formfilelist, formfilelist2 = getFilelist(current_workflow_step, 'upload_pdfform')
pdf_fields_editable = current_workflow_step.get("pdf_fields_editable")
pdf_form_separate = current_workflow_step.get("pdf_form_separate")
pdf_form_overwrite = current_workflow_step.get("pdf_form_overwrite")
if pdf_fields_editable.lower() in ["1", "true"]:
pdf_fields_editable = True
else:
pdf_fields_editable = False
if pdf_form_separate.lower() in ["1", "true"]:
pdf_form_separate = True
else:
pdf_form_separate = False
fields = []
f_retrieve_path = None
schema = getMetaType(node.schema)
if formfilelist:
# take newest (mtime)
f_mtime, f_name, f_mimetype, f_size, f_type, f_retrieve_path, f = formfilelist[-1]
for field_dict in parse_pdftk_fields_dump(get_pdftk_fields_dump(f_retrieve_path)):
fieldname = field_dict.get('FieldName', None)
if fieldname:
value = ''
if fieldname in dict(node.attrs.items()):
schemafield = schema.children.filter_by(name=fieldname).first()
value = schemafield.getFormattedValue(node)[1]
if fieldname.find('author') >= 0:
value = reformatAuthors(value)
elif fieldname.lower() == 'node.schema':
value = getMetaType(node.schema).getLongName()
elif fieldname.lower() == 'node.id':
value = unicode(node.id)
elif fieldname.lower() == 'node.type':
value = node.type
elif fieldname.lower() == 'date()':
value = format_date(now(), format='%d.%m.%Y')
elif fieldname.lower() == 'time()':
value = format_date(now(), format='%H:%M:%S')
elif fieldname.find("+") > 0:
for _fn in fieldname.split('+'):
value = node.get(_fn)
if value:
break
elif '[att:' in fieldname:
value = fieldname
while '[att:' in value:
m = re.search('(?<=\[att:)([^&\]]+)', value)
if m:
if m.group(0) == 'id':
v = unicode(node.id)
elif m.group(0) == 'type':
v = node.type
elif m.group(0) == 'schema':
v = getMetaType(node.schema).getLongName()
else:
schemafield = schema.children.filter_by(name=m.group(0)).first()
v = schemafield.getFormattedValue(node)[0]
value = value.replace('[att:%s]' % (m.group(0)), v)
else:
logg.warning("workflowstep %s (%s): could not find attribute for pdf form field '%s' - node: '%s' (%s)",
current_workflow_step.name, current_workflow_step.id, fieldname, node.name, node.id)
fields.append((fieldname, remove_tags(desc(value))))
if not pdf_form_separate and fnode and f_retrieve_path and os.path.isfile(f_retrieve_path):
pages = fillPDFForm(f_retrieve_path, fields, input_is_fullpath=True, editable=pdf_fields_editable)
if pages == "": # error in pdf creation -> forward to false operation
logg.error("workflowstep %s (%s): could not create pdf file - node: '%s' (%s)" %
(current_workflow_step.name, current_workflow_step.id, node.name, node.id))
self.forward(node, False)
return
origname = fnode.abspath
outfile = addPagesToPDF(pages, origname)
for f in node.files:
node.files.remove(f)
fnode.path = outfile.replace(config.get("paths.datadir"), "")
node.files.append(fnode)
node.files.append(File(origname, 'upload', 'application/pdf')) # store original filename
node.event_files_changed()
db.session.commit()
logg.info("workflow '%s' (%s), workflowstep '%s' (%s): added pdf form to pdf (node '%s' (%s)) fields: %s",
current_workflow.name, current_workflow.id, current_workflow_step.name, current_workflow_step.id, node.name, node.id, fields)
elif pdf_form_separate and f_retrieve_path and os.path.isfile(f_retrieve_path):
pages = fillPDFForm(f_retrieve_path, fields, input_is_fullpath=True, editable=pdf_fields_editable)
if pages == "": # error in pdf creation -> forward to false operation
logg.error("workflowstep %s (%s): could not create pdf file - node: '%s' (%s)" %
(current_workflow_step.name, current_workflow_step.id, node.name, node.id))
self.forward(node, False)
return
importdir = getImportDir()
try:
new_form_path = join_paths(importdir, "%s_%s" % (node.id, f_name))
counter = 0
if not pdf_form_overwrite: # build correct filename
while os.path.isfile(new_form_path):
counter += 1
new_form_path = join_paths(importdir, "%s_%s_%s" % (node.id, counter, f_name))
# copy new file and remove tmp
shutil.copy(pages, new_form_path)
if os.path.exists(pages):
os.remove(pages)
except Exception:
logg.exception("workflowstep %s (%s): could not copy pdf form to import directory - node: '%s' (%s), import directory: '%s'",
current_workflow_step.name, current_workflow_step.id, node.name, node.id, importdir)
found = 0
for fn in node.files:
if fn.abspath == new_form_path:
found = 1
break
if found == 0 or (found == 1 and not pdf_form_overwrite):
node.files.append(File(new_form_path, 'pdf_form', 'application/pdf'))
db.session.commit()
logg.info(
"workflow '%s' (%s), workflowstep '%s' (%s): added separate pdf form to node (node '%s' (%s)) fields: %s, path: '%s'",
current_workflow.name, current_workflow.id, current_workflow_step.name,
current_workflow_step.id, node.name, node.id, fields, new_form_path)
else:
logg.warning("workflowstep %s (%s): could not process pdf form - node: '%s' (%s)",
current_workflow_step.name, current_workflow_step.id, node.name, node.id)
self.forward(node, True)
def buildNodeDescriptor(req,
node,
indent=None,
written=None,
children=True,
children_access=None,
parents=False):
nd = []
d = {}
if written is None:
written = {}
nodedict = {}
nodedict['id'] = node.id
mask = req.params.get('mask', 'none').lower()
attrlist = req.params.get('attrlist', [])
if attrlist:
attrlist = attrlist.split(',')
attrspec = req.params.get('attrspec', 'default_mask')
# 'all': no restriction, send all attributes
# 'none': to not send any attribute at all
# 'default_mask' (default): only send attributes that correspond to the default mask fields
#
# remark: attributes specified comma separated in 'attrlist' are added to those specified by 'attrspec'
#
if mask == 'default':
maskcachetype = req.params.get('maskcache',
'deep') # 'deep', 'shallow', 'none'
nodedict['defaultexport'] = node.show_node_text(
labels=1,
language=req.params.get('lang', ''),
cachetype=maskcachetype)
# except:
# logging.getLogger('services').error('Error: web.services.jsonnode: could not get default mask content')
# nodedict['defaultexport'] = []
elif mask not in ["", "none"]: # deliver every mask
try:
mask_obj = getMetaType(node.getSchema()).getMask(mask)
if mask_obj:
nodedict['defaultexport'] = mask_obj.getViewHTML([node],
flags=8)
else:
nodedict['defaultexport'] = "mask not found"
except:
nodedict['defaultexport'] = "error"
if children:
nodedict['children'] = []
for c in node.getChildren().sort_by_orderpos():
if (not children_access) or (children_access and
children_access.hasAccess(c, 'read')):
nodedict['children'].append({
'id': str(c.id),
'type': c.type,
'name': esc(c.name)
})
if parents:
nodedict['parents'] = []
for c in node.getParents().sort_by_orderpos():
if (not children_access) or (children_access and
children_access.hasAccess(c, 'read')):
nodedict['parents'].append({
'id': str(c.id),
'type': c.type,
'name': esc(c.name)
})
nd.append(nodedict)
if (children):
for c in node.getChildren().sort_by_orderpos():
if (not children_access) or (children_access and
children_access.hasAccess(c, 'read')):
if c.id not in written:
written[c.id] = None
childnodedict = buildNodeDescriptor(
req, c, indent, children_access=children_access)
nd.append(childnodedict)
# if node.read_access:
# nodedict['read'] = esc(node.read_access)
# if node.write_access:
# nodedict['write'] = esc(node.write_access)
# if node.data_access:
# nodedict['data'] = esc(node.data_access)
nodeattributes_dict = {}
if attrspec == 'none':
# no attributes should be sent
pass
elif attrspec == 'default_mask' or attrspec not in ['none', 'all']:
from contenttypes.default import make_lookup_key, get_maskcache_entry, maskcache
language = req.params.get('lang', '')
lookup_key = make_lookup_key(node, language=language, labels=False)
if lookup_key not in maskcache:
# fill cache
node.show_node_text(labels=False,
language=language,
cachetype='deep')
field_descriptors = get_maskcache_entry(lookup_key)
try:
mask = field_descriptors[0]
for field_descriptor in field_descriptors[1:]:
field_attribute = field_descriptor[0]
#fd = field_descriptor[1]
if field_attribute not in attrlist:
# attrlist may be an empty list or filled from the request parameters
attrlist.append(field_attribute)
except:
# no mask for this metadata type
msg = "no 'nodesmall' or 'shortview' for node %s" % str(node.id)
logging.getLogger("services").warning(msg)
elif attrspec == 'all':
nodeattributes_dict_all_attributes = node.attributes.copy()
if nodeattributes_dict_all_attributes:
for k in filter(attribute_name_filter,
nodeattributes_dict_all_attributes.keys()):
nodeattributes_dict[k] = u2(
(nodeattributes_dict_all_attributes[k]))
if attrlist:
for attr in filter(attribute_name_filter, attrlist):
nodeattributes_dict[attr] = u2(node.get(attr))
if nodeattributes_dict:
nodedict['attributes'] = nodeattributes_dict
if 'files' in req.params:
nodedict['files'] = []
for file in node.getFiles():
if file.type == "metadata" or file.type == "statistic":
continue
mimetype = file.mimetype
if mimetype is None:
mimetype = "application/x-download"
nodedict['files'].append({
'filename': esc(file.getName()),
'mime-type': mimetype,
'type': file.type
})
if 'nodename' in req.params:
nodedict['name'] = node.name
if 'nodetype' in req.params:
if node.type is None:
nodedict['type'] = 'node'
else:
nodedict['type'] = node.type
return nd
def FieldDetail(req, pid, id, err=0):
_option = ""
for key in req.params.keys():
if key.startswith("option_"):
_option += key[7]
if err == 0 and id == "":
# new field
field = tree.Node("", type="metafield")
elif id != "":
# edit field
field = getMetaField(pid, id)
else:
# error filling values
_fieldvalue = ""
if req.params.get('mtype', '') + "_value" in req.params.keys():
_fieldvalue = str(req.params[req.params.get('mtype', '') + "_value"])
if (req.params.get("mname") == ""):
field = tree.Node(req.params.get("orig_name"), type="metafield")
else:
field = tree.Node(req.params.get("mname"), type="metafield")
field.setLabel(req.params.get("mlabel"))
field.setOrderPos(req.params.get("orderpos"))
field.setFieldtype(req.params.get("mtype"))
field.setOption(_option)
field.setValues(_fieldvalue)
field.setDescription(req.params.get("mdescription"))
attr = {}
metadatatype = getMetaType(pid)
for t in metadatatype.getDatatypes():
node = tree.Node(type=t)
try:
attr.update(node.getTechnAttributes())
except AttributeError:
continue
metafields = {}
for fields in getFieldsForMeta(pid):
if fields.getType() != "union":
metafields[fields.getName()] = fields
v = getAdminStdVars(req)
v["metadatatype"] = metadatatype
v["metafield"] = field
v["error"] = err
v["fieldtypes"] = getMetaFieldTypeNames()
v["dateoptions"] = dateoption
v["datatypes"] = attr
v["requiredoptions"] = requiredoption
v["fieldoptions"] = fieldoption
v["metafields"] = metafields
v["filtertype"] = req.params.get("filtertype", "")
v["actpage"] = req.params.get("actpage")
v["icons"] = {"externer Link": "/img/extlink.png", "Email": "/img/email.png"}
v["url_targets"] = {"selbes Fenster": "same", "neues Fenster": "_blank"}
v["valuelist"] = ("", "", "", "")
if field.getFieldtype() == "url":
v["valuelist"] = field.getValueList()
while len(v["valuelist"]) != 4:
v["valuelist"].append("")
else:
v["valuelist"] = field.getValueList()
v["field"] = None
if field.id:
v["field"] = field
v["adminfields"] = []
for t in getMetaFieldTypeNames():
f = getMetadataType(t)
if 'attr_dict' in inspect.getargspec(f.getMaskEditorHTML).args:
attr_dict = dict(field.items())
v["adminfields"] .append(f.getMaskEditorHTML(v["field"], metadatatype=metadatatype, language=lang(req), attr_dict=attr_dict))
else:
v["adminfields"] .append(f.getMaskEditorHTML(v["field"], metadatatype=metadatatype, language=lang(req)))
return req.getTAL("web/admin/modules/metatype_field.html", v, macro="modify_field")
def event_files_changed(self):
print "Postprocessing node", self.id
if "image" in self.type:
for f in self.getFiles():
if f.getName().lower().endswith('svg'):
self.svg_to_png(f.retrieveFile(), f.retrieveFile()[:-4] + ".png")
self.removeFile(f)
self.addFile(FileNode(name=f.retrieveFile(), type="original", mimetype=f.mimetype))
self.addFile(FileNode(name=f.retrieveFile(), type="image", mimetype=f.mimetype))
self.addFile(FileNode(name=f.retrieveFile()[:-4] + ".png", type="tmppng", mimetype="image/png"))
break
orig = 0
thumb = 0
for f in self.getFiles():
if f.type == "original":
orig = 1
if f.type == "thumb":
thumb = 1
if orig == 0:
for f in self.getFiles():
if f.type == "image":
if f.mimetype == "image/tiff" or ((f.mimetype is None or f.mimetype == "application/x-download")
and (f.getName().lower().endswith("tif") or f.getName().lower().endswith("tiff"))):
# move old file to "original", create a new png to be used as "image"
self.removeFile(f)
path, ext = splitfilename(f.retrieveFile())
pngname = path + ".png"
if not os.path.isfile(pngname):
makeOriginalFormat(f.retrieveFile(), pngname)
width, height = getImageDimensions(pngname)
self.set("width", width)
self.set("height", height)
else:
width, height = getImageDimensions(pngname)
self.set("width", width)
self.set("height", height)
print 'png: ', pngname
self.addFile(FileNode(name=pngname, type="image", mimetype="image/png"))
self.addFile(FileNode(name=f.retrieveFile(), type="original", mimetype="image/tiff"))
break
else:
self.addFile(FileNode(name=f.retrieveFile(), type="original", mimetype=f.mimetype))
# retrieve technical metadata.
for f in self.getFiles():
if (f.type == "image" and not f.getName().lower().endswith("svg")) or f.type == "tmppng":
width, height = getImageDimensions(f.retrieveFile())
self.set("origwidth", width)
self.set("origheight", height)
self.set("origsize", f.getSize())
if f.mimetype == "image/jpeg":
self.set("jpg_comment", iso2utf8(getJpegSection(f.retrieveFile(), 0xFE).strip()))
if thumb == 0:
for f in self.getFiles():
if (f.type == "image" and not f.getName().lower().endswith("svg")) or f.type == "tmppng":
basename = hashlib.md5(str(random.random())).hexdigest()[0:8]
path = os.path.join(getImportDir(), basename)
thumbname = path + ".thumb"
thumbname2 = path + ".thumb2"
print 'tumb: ', thumbname
print 'presentation: ', thumbname2
assert not os.path.isfile(thumbname)
assert not os.path.isfile(thumbname2)
width, height = getImageDimensions(f.retrieveFile())
makeThumbNail(f.retrieveFile(), thumbname)
makePresentationFormat(f.retrieveFile(), thumbname2)
if f.mimetype is None:
if f.getName().lower().endswith("jpg"):
f.mimetype = "image/jpeg"
else:
f.mimetype = "image/tiff"
self.addFile(FileNode(name=thumbname, type="thumb", mimetype="image/jpeg"))
self.addFile(FileNode(name=thumbname2, type="presentation", mimetype="image/jpeg"))
self.set("width", width)
self.set("height", height)
# fetch unwanted tags to be omitted
unwanted_attrs = self.unwanted_attributes()
# Exif
try:
files = self.getFiles()
for file in files:
if file.type == "original":
f = open(file.retrieveFile(), 'rb')
tags = EXIF.process_file(f)
tags.keys().sort()
for k in tags.keys():
# don't set unwanted exif attributes
if any(tag in k for tag in unwanted_attrs):
continue
if tags[k] != "" and k != "JPEGThumbnail":
self.set("exif_" + k.replace(" ", "_"),
utf8_decode_escape(str(tags[k])))
elif k == "JPEGThumbnail":
if tags[k] != "":
self.set("Thumbnail", "True")
else:
self.set("Thumbnail", "False")
except:
None
if dozoom(self) == 1:
tileok = 0
for f in self.getFiles():
if f.type.startswith("tile"):
tileok = 1
if not tileok and self.get("width") and self.get("height"):
zoom.getImage(self.id, 1)
for f in self.getFiles():
if f.getType() == 'original':
wanted_tags = lib.iptc.IPTC.get_wanted_iptc_tags()
tags_in_upload = lib.iptc.IPTC.get_iptc_values(f.retrieveFile(), wanted_tags)
with_value = []
for field in getMetaType(self.getSchema()).getMetaFields():
if field.get('type') == "meta" and len(field.getValueList()) > 1:
value = self.get('iptc_{}'.format(field.getName()))
if len(value) > 0:
with_value.append(field.getName())
if tags_in_upload:
for key in tags_in_upload.keys():
if tags_in_upload[key] != '':
if key not in with_value:
self.set('iptc_{}'.format(key.replace(' ', '_')),
tags_in_upload[key])
for f in self.getFiles():
if f.getName().lower().endswith("png") and f.type == "tmppng":
self.removeFile(f)
break
def FieldDetail(req, pid, id, err=0):
_option = ""
for key in req.params.keys():
if key.startswith("option_"):
_option += key[7]
if err == 0 and id == "":
# new field
field = Metafield(u"")
db.session.commit()
elif id != "":
# edit field
field = q(Metadatatype).get(pid).children.filter_by(name=id, type=u'metafield').scalar()
else:
# error filling values
_fieldvalue = ""
if req.params.get('mtype', '') + "_value" in req.params.keys():
_fieldvalue = ustr(req.params[req.params.get('mtype', '') + "_value"])
if (req.params.get("mname") == ""):
field = Metafield(req.params.get("orig_name"))
else:
field = Metafield(req.params.get("mname"))
field.setLabel(req.params.get("mlabel"))
field.setOrderPos(req.params.get("orderpos"))
field.setFieldtype(req.params.get("mtype"))
field.setOption(_option)
field.setValues(_fieldvalue)
field.setDescription(req.params.get("mdescription"))
db.session.commit()
attr = {}
metadatatype = getMetaType(pid)
for t in metadatatype.getDatatypes():
content_class = Node.get_class_for_typestring(t)
node = content_class(name=u'')
try:
attr.update(node.getTechnAttributes())
except AttributeError:
logg.exception("attribute error in FieldDetail, continue")
continue
metafields = {}
for fields in getFieldsForMeta(pid):
if fields.getType() != "union":
metafields[fields.name] = fields
v = getAdminStdVars(req)
v["metadatatype"] = metadatatype
v["metafield"] = field
v["error"] = err
v["fieldtypes"] = getMetaFieldTypeNames()
v["dateoptions"] = dateoption
v["datatypes"] = attr
v["requiredoptions"] = requiredoption
v["fieldoptions"] = fieldoption
v["metafields"] = metafields
v["filtertype"] = req.params.get("filtertype", "")
v["actpage"] = req.params.get("actpage")
v["icons"] = {"externer Link": "/img/extlink.png", "Email": "/img/email.png"}
v["url_targets"] = {"selbes Fenster": "same", "neues Fenster": "_blank"}
v["valuelist"] = ("", "", "", "")
if field.getFieldtype() == "url":
v["valuelist"] = field.getValueList()
while len(v["valuelist"]) != 4:
v["valuelist"].append("")
else:
v["valuelist"] = field.getValueList()
v["field"] = None
if field.id:
v["field"] = field
v["adminfields"] = []
for t in getMetaFieldTypeNames():
f = getMetadataType(t)
if 'attr_dict' in inspect.getargspec(f.getMaskEditorHTML).args:
attr_dict = dict(field.attrs.items())
v["adminfields"] .append(f.getMaskEditorHTML(v["field"], metadatatype=metadatatype, language=lang(req), attr_dict=attr_dict))
else:
v["adminfields"] .append(f.getMaskEditorHTML(v["field"], metadatatype=metadatatype, language=lang(req)))
db.session.commit()
return req.getTAL("web/admin/modules/metatype_field.html", v, macro="modify_field")
def show_workflow_step(self, req):
typenames = self.get("newnodetype").split(";")
wfnode = self.getParents()[0]
redirect = ""
message = ""
# check existence of metadata types listed in the definition of the start node
mdts = tree.getRoot("metadatatypes")
for schema in typenames:
if not mdts.hasChild(schema.strip().split("/")[-1]):
return ("<i>%s: %s </i>") % (schema, t(lang(req), "permission_denied"))
if "workflow_start" in req.params:
switch_language(req, req.params.get("workflow_language"))
node = tree.Node(name="", type=req.params.get("selected_schema"))
self.addChild(node)
node.setAccess("read", "{user workflow}")
node.set("creator", "workflow-" + self.getParents()[0].getName())
node.set("creationtime", date.format_date())
node.set("system.wflanguage", req.params.get("workflow_language", req.session.get("language")))
node.set("key", mkKey())
node.set("system.key", node.get("key")) # initial key identifier
req.session["key"] = node.get("key")
return self.forwardAndShow(node, True, req)
elif "workflow_start_auth" in req.params: # auth node by id and key
try:
node = tree.getNode(req.params.get("nodeid"))
# startkey, but protected
if node.get("system.key") == req.params.get("nodekey") and node.get("key") != req.params.get("nodekey"):
message = "workflow_start_err_protected"
elif node.get("key") == req.params.get("nodekey"):
redirect = "/pnode?id=%s&key=%s" % (node.id, node.get("key"))
else:
message = "workflow_start_err_wrongkey"
except:
message = "workflow_start_err_wrongkey"
types = []
for a in typenames:
if a:
m = getMetaType(a)
# we could now check m.isActive(), but for now let's
# just take all specified metatypes, so that edit area
# and workflow are independent on this
types += [(m, a)]
cookie_error = t(lang(req), "Your browser doesn't support cookies")
js = (
"""
<script language="javascript">
function cookie_test() {
if (document.cookie=="")
document.cookie = "CookieTest=Erfolgreich";
if (document.cookie=="") {
alert("%s");
}
}
cookie_test();
</script>"""
% cookie_error
)
return req.getTAL(
"workflow/start.html",
{
"types": types,
"id": self.id,
"js": js,
"starttext": self.get("starttext"),
"languages": self.getParents()[0].getLanguages(),
"currentlang": lang(req),
"sidebartext": self.getSidebarText(lang(req)),
"redirect": redirect,
"message": message,
"allowcontinue": self.get("allowcontinue"),
},
macro="workflow_start",
)
def getContent(req, ids):
user = users.getUserFromRequest(req)
if "lza" in users.getHideMenusForUser(user):
req.setStatus(httpstatus.HTTP_FORBIDDEN)
return req.getTAL("web/edit/edit.html", {}, macro="access_error")
v = {}
v['error'] = ""
nodes = []
for id in ids:
node = tree.getNode(id)
access = acl.AccessData(req)
if not access.hasWriteAccess(node):
req.setStatus(httpstatus.HTTP_FORBIDDEN)
return req.getTAL("web/edit/edit.html", {}, macro="access_error")
nodes.append(node)
if "createlza" in req.params:
# remove old file if existing
for f in node.getFiles():
if f.getType() == "lza":
node.removeFile(f)
# create new file
for f in node.getFiles():
if f.getType() in ("original", "document"):
try:
archive = l.LZA(f.retrieveFile())
schema = node.getSchema()
# test for lza export mask
if (getMetaType(schema).getMask("lza")):
m = getMetaType(schema).getMask("lza")
meta = l.LZAMetadata(m.getViewHTML([node], 8))
else:
# generate error message
meta = l.LZAMetadata("""
<?xpacket begin="\xef\xbb\xbf" id="mediatum_metadata"?>
<lza:data>
<lza:error>-definition missing-</lza:error>
</lza:data><?xpacket end="w"?>
""")
archive.writeMediatumData(meta)
node.addFile(
tree.FileNode(archive.buildLZAName(), "lza",
f.getMimeType()))
except l.FiletypeNotSupported:
v['error'] = "edit_lza_wrongfiletype"
elif "removelza" in req.params:
for f in node.getFiles():
if f.getType() == "lza":
node.removeFile(f)
v['id'] = req.params.get("id", "0")
v['tab'] = req.params.get("tab", "")
v['ids'] = ids
v['nodes'] = nodes
v['t'] = t
v['language'] = lang(req)
meta = {}
for id in ids:
node = tree.getNode(id)
for f in node.getFiles():
if f.getType() == "lza":
try:
archive = l.LZA(f.retrieveFile(), f.getMimeType())
meta[id] = archive.getMediatumData()
except IOError:
v['error'] = "edit_lza_ioerror"
v['meta'] = meta
return req.getTAL("web/edit/modules/lza.html", v, macro="edit_lza")
def buildNodeDescriptor(params, node, indent=None, written=None, children=True, parents=False):
nd = []
d = {}
if written is None:
written = {}
nodedict = {}
nodedict['id'] = node.id
mask = params.get('mask', 'none').lower()
attrlist = params.get('attrlist', [])
if attrlist:
attrlist = attrlist.split(',')
attrspec = params.get('attrspec', 'default_mask')
# 'all': no restriction, send all attributes
# 'none': to not send any attribute at all
# 'default_mask' (default): only send attributes that correspond to the default mask fields
#
# remark: attributes specified comma separated in 'attrlist' are added to those specified by 'attrspec'
#
if mask == 'default':
nodedict['defaultexport'] = node.show_node_text(labels=1, language=params.get('lang', ''))
# except:
# logg.error('Error: web.services.jsonnode: could not get default mask content')
# nodedict['defaultexport'] = []
elif mask not in ["", "none"]: # deliver every mask
try:
mask_obj = getMetaType(node.getSchema()).getMask(mask)
if mask_obj:
nodedict['defaultexport'] = mask_obj.getViewHTML([node], flags=8)
else:
nodedict['defaultexport'] = "mask not found"
except Exception as e:
logg.exception("exception in buildNodeDescriptor")
nodedict['defaultexport'] = "error"
if children:
nodedict['children'] = []
for c in node.getChildren().sort_by_orderpos():
nodedict['children'].append({'id': ustr(c.id), 'type': c.type, 'name': esc(c.name)})
if parents:
nodedict['parents'] = []
for c in node.getParents().sort_by_orderpos():
nodedict['parents'].append({'id': ustr(c.id), 'type': c.type, 'name': esc(c.name)})
nd.append(nodedict)
if(children):
for c in node.getChildren().sort_by_orderpos():
if c.id not in written:
written[c.id] = None
childnodedict = buildNodeDescriptor(params, c, indent)
nd.append(childnodedict)
nodeattributes_dict = {}
if attrspec == 'none':
# no attributes should be sent
pass
elif attrspec == 'default_mask' or attrspec not in ['none', 'all']:
from contenttypes.data import make_lookup_key, get_maskcache_entry
from core.transition.globals import request
language = params.get('lang', '')
lookup_key = make_lookup_key(node, language=language, labels=False)
if 'maskcache' not in request.app_cache or lookup_key not in request.app_cache['maskcache']:
# fill cache
node.show_node_text(labels=False, language=language)
mask_id, field_descriptors = get_maskcache_entry(lookup_key, request.app_cache['maskcache'], request.app_cache['maskcache_accesscount'])
try:
for field_descriptor in field_descriptors:
field_attribute = field_descriptor[0]
if field_attribute not in attrlist:
# attrlist may be an empty list or filled from the request parameters
attrlist.append(field_attribute)
except:
# no mask for this metadata type
logg.exception("exception in buildNodeDescriptor, no 'nodesmall' or 'shortview' for node %s", node.id)
elif attrspec == 'all':
nodeattributes_dict_all_attributes = node.attributes.copy()
if nodeattributes_dict_all_attributes:
for k in filter(attribute_name_filter, nodeattributes_dict_all_attributes.keys()):
nodeattributes_dict[k] = nodeattributes_dict_all_attributes[k]
if attrlist:
for attr in filter(attribute_name_filter, attrlist):
if attr == "nodename":
value = node.name
else:
value = node.get(attr)
nodeattributes_dict[attr] = value
if nodeattributes_dict:
nodedict['attributes'] = nodeattributes_dict
if 'files' in params:
nodedict['files'] = []
for file in node.getFiles():
if file.type == "metadata" or file.type == "statistic":
continue
mimetype = file.mimetype
if mimetype is None:
mimetype = "application/x-download"
nodedict['files'].append({'filename': esc(file.getName()), 'mime-type': mimetype, 'type': file.type})
if 'nodename' in params:
nodedict['name'] = node.name
if 'nodetype' in params:
nodedict['type'] = node.type
if 'nodeschema' in params:
nodedict['schema'] = node.schema
return nd
def showMaskList(req, id):
metadatatype = getMetaType(id)
masks = metadatatype.getMasks()
order = getSortCol(req)
actfilter = getFilter(req)
# resets filter to all if adding mask in /metatype view
# if req.params.get('acttype') == 'mask' or req.params.get('acttype') == 'schema':
# if req.path == '/metatype' and 'filterbutton' not in req.params:
# actfilter = '*'
# resets filter when going to a new view
if 'filterbutton' not in req.params:
actfilter = '*'
# filter
if actfilter != "":
if actfilter in ("all", "*", t(lang(req), "admin_filter_all")):
None # all users
elif actfilter == "0-9":
num = re.compile(r'([0-9])')
masks = filter(lambda x: num.match(x.getName()), masks)
elif actfilter == "else" or actfilter == t(lang(req), "admin_filter_else"):
all = re.compile(r'([a-z]|[A-Z]|[0-9])')
masks = filter(lambda x: not all.match(x.getName()), masks)
else:
masks = filter(lambda x: x.getName().lower().startswith(actfilter), masks)
pages = Overview(req, masks)
defaults = {}
for mask in masks:
if mask.getDefaultMask():
defaults[mask.getMasktype()] = mask.id
# sorting
if order != "":
if int(order[0:1]) == 0:
masks.sort(lambda x, y: cmp(x.getName().lower(), y.getName().lower()))
elif int(order[0:1]) == 1:
masks.sort(lambda x, y: cmp(x.getMasktype(), y.getMasktype()))
elif int(order[0:1]) == 2:
masks.sort(lambda x, y: cmp(x.getDescription(), y.getDescription()))
elif int(order[0:1]) == 3:
masks.sort(lambda x, y: cmp(x.getDefaultMask(), y.getDefaultMask()))
elif int(order[0:1]) == 4:
masks.sort(lambda x, y: cmp(x.getLanguage(), y.getLanguage()))
if int(order[1:]) == 1:
masks.reverse()
else:
masks.sort(lambda x, y: cmp(x.getOrderPos(), y.getOrderPos()))
v = getAdminStdVars(req)
v["filterattrs"] = []
v["filterarg"] = req.params.get("filtertype", "name")
v["sortcol"] = pages.OrderColHeader(
[
t(
lang(req), "admin_mask_col_1"), t(
lang(req), "admin_mask_col_2"), t(
lang(req), "admin_mask_col_3"), t(
lang(req), "admin_mask_col_4"), t(
lang(req), "admin_mask_col_5"), t(
lang(req), "admin_mask_col_6")])
v["metadatatype"] = metadatatype
v["masktypes"] = getMaskTypes()
v["lang_icons"] = {"de": "/img/flag_de.gif", "en": "/img/flag_en.gif", "no": "/img/emtyDot1Pix.gif"}
v["masks"] = masks
v["pages"] = pages
v["order"] = order
v["defaults"] = defaults
v["order"] = order
v["actfilter"] = actfilter
return req.getTAL("web/admin/modules/metatype_mask.html", v, macro="view_mask")
def buildNodeDescriptor(req, node, indent=None, written=None, children=True, children_access=None, parents=False):
nd = []
d = {}
if written is None:
written = {}
nodedict = {}
nodedict['id'] = node.id
mask = req.params.get('mask', 'none').lower()
attrlist = req.params.get('attrlist', [])
if attrlist:
attrlist = attrlist.split(',')
attrspec = req.params.get('attrspec', 'default_mask')
# 'all': no restriction, send all attributes
# 'none': to not send any attribute at all
# 'default_mask' (default): only send attributes that correspond to the default mask fields
#
# remark: attributes specified comma separated in 'attrlist' are added to those specified by 'attrspec'
#
if mask == 'default':
maskcachetype = req.params.get('maskcache', 'deep') # 'deep', 'shallow', 'none'
nodedict['defaultexport'] = node.show_node_text(labels=1, language=req.params.get('lang', ''), cachetype=maskcachetype)
# except:
# logging.getLogger('services').error('Error: web.services.jsonnode: could not get default mask content')
# nodedict['defaultexport'] = []
elif mask not in ["", "none"]: # deliver every mask
try:
mask_obj = getMetaType(node.getSchema()).getMask(mask)
if mask_obj:
nodedict['defaultexport'] = mask_obj.getViewHTML([node], flags=8)
else:
nodedict['defaultexport'] = "mask not found"
except:
nodedict['defaultexport'] = "error"
if children:
nodedict['children'] = []
for c in node.getChildren().sort_by_orderpos():
if (not children_access) or (children_access and children_access.hasAccess(c, 'read')):
nodedict['children'].append({'id': str(c.id), 'type': c.type, 'name': esc(c.name)})
if parents:
nodedict['parents'] = []
for c in node.getParents().sort_by_orderpos():
if (not children_access) or (children_access and children_access.hasAccess(c, 'read')):
nodedict['parents'].append({'id': str(c.id), 'type': c.type, 'name': esc(c.name)})
nd.append(nodedict)
if(children):
for c in node.getChildren().sort_by_orderpos():
if (not children_access) or (children_access and children_access.hasAccess(c, 'read')):
if c.id not in written:
written[c.id] = None
childnodedict = buildNodeDescriptor(req, c, indent, children_access=children_access)
nd.append(childnodedict)
# if node.read_access:
# nodedict['read'] = esc(node.read_access)
# if node.write_access:
# nodedict['write'] = esc(node.write_access)
# if node.data_access:
# nodedict['data'] = esc(node.data_access)
nodeattributes_dict = {}
if attrspec == 'none':
# no attributes should be sent
pass
elif attrspec == 'default_mask' or attrspec not in ['none', 'all']:
from contenttypes.default import make_lookup_key, get_maskcache_entry, maskcache
language = req.params.get('lang', '')
lookup_key = make_lookup_key(node, language=language, labels=False)
if lookup_key not in maskcache:
# fill cache
node.show_node_text(labels=False, language=language, cachetype='deep')
field_descriptors = get_maskcache_entry(lookup_key)
try:
mask = field_descriptors[0]
for field_descriptor in field_descriptors[1:]:
field_attribute = field_descriptor[0]
#fd = field_descriptor[1]
if field_attribute not in attrlist:
# attrlist may be an empty list or filled from the request parameters
attrlist.append(field_attribute)
except:
# no mask for this metadata type
msg = "no 'nodesmall' or 'shortview' for node %s" % str(node.id)
logging.getLogger("services").warning(msg)
elif attrspec == 'all':
nodeattributes_dict_all_attributes = node.attributes.copy()
if nodeattributes_dict_all_attributes:
for k in filter(attribute_name_filter, nodeattributes_dict_all_attributes.keys()):
nodeattributes_dict[k] = u2((nodeattributes_dict_all_attributes[k]))
if attrlist:
for attr in filter(attribute_name_filter, attrlist):
nodeattributes_dict[attr] = u2(node.get(attr))
if nodeattributes_dict:
nodedict['attributes'] = nodeattributes_dict
if 'files' in req.params:
nodedict['files'] = []
for file in node.getFiles():
if file.type == "metadata" or file.type == "statistic":
continue
mimetype = file.mimetype
if mimetype is None:
mimetype = "application/x-download"
nodedict['files'].append({'filename': esc(file.getName()), 'mime-type': mimetype, 'type': file.type})
if 'nodename' in req.params:
nodedict['name'] = node.name
if 'nodetype' in req.params:
if node.type is None:
nodedict['type'] = 'node'
else:
nodedict['type'] = node.type
return nd
def show_printview(req):
""" create a pdf preview of given node (id in path e.g. /print/[id]/[area])"""
p = req.path[1:].split("/")
try:
nodeid = int(p[1])
except ValueError:
raise ValueError("Invalid Printview URL: " + req.path)
if len(p) == 3:
if p[2] == "edit":
req.reply_headers['Content-Type'] = "application/pdf"
editprint = printmethod(req)
if editprint:
req.write(editprint)
else:
req.write("")
return
# use objects from session
if str(nodeid) == "0":
children = []
if "contentarea" in req.session:
try:
nodes = req.session["contentarea"].content.files
except:
c = req.session["contentarea"].content
nodes = c.resultlist[c.active].files
for n in nodes:
c_mtype = getMetaType(n.getSchema())
c_mask = c_mtype.getMask("printlist")
if not c_mask:
c_mask = c_mtype.getMask("nodesmall")
_c = c_mask.getViewHTML([n], VIEW_DATA_ONLY + VIEW_HIDE_EMPTY)
if len(_c) > 0:
children.append(_c)
req.reply_headers['Content-Type'] = "application/pdf"
req.write(
printview.getPrintView(lang(req), None,
[["", "", t(lang(req), "")]], [], 3,
children))
else:
node = getNode(nodeid)
if node.get("system.print") == "0":
return 404
access = AccessData(req)
if not access.hasAccess(node, "read"):
req.write(t(req, "permission_denied"))
return
style = int(req.params.get("style", 2))
# nodetype
mtype = getMetaType(node.getSchema())
mask = None
metadata = None
if mtype:
for m in mtype.getMasks():
if m.getMasktype() == "fullview":
mask = m
if m.getMasktype() == "printview":
mask = m
break
if not mask:
mask = mtype.getMask("nodebig")
if mask:
metadata = mask.getViewHTML([node],
VIEW_DATA_ONLY + VIEW_HIDE_EMPTY)
if not metadata:
metadata = [['nodename', node.getName(), 'Name', 'text']]
files = node.getFiles()
imagepath = None
for file in files:
if file.getType().startswith("presentati"):
imagepath = file.retrieveFile()
# children
children = []
if node.isContainer():
ret = []
getPrintChildren(req, node, ret)
for c in ret:
if not c.isContainer():
# items
c_mtype = getMetaType(c.getSchema())
c_mask = c_mtype.getMask("printlist")
if not c_mask:
c_mask = c_mtype.getMask("nodesmall")
_c = c_mask.getViewHTML([c], VIEW_DATA_ONLY)
if len(_c) > 0:
children.append(_c)
else:
# header
items = getPaths(c, AccessData(req))
p = []
for item in items[0]:
p.append(u(item.getName()))
p.append(u(c.getName()))
children.append([(c.id, " > ".join(p[1:]), u(c.getName()),
"header")])
if len(children) > 1:
col = []
order = []
try:
sort = getCollection(node).get("sortfield")
except:
sort = ""
for i in range(0, 2):
col.append((0, ""))
order.append(1)
if req.params.get("sortfield" + str(i)) != "":
sort = req.params.get("sortfield" + str(i), sort)
if sort != "":
if sort.startswith("-"):
sort = sort[1:]
order[i] = -1
_i = 0
for c in children[0]:
if c[0] == sort:
col[i] = (_i, sort)
_i += 1
if col[i][1] == "":
col[i] = (0, children[0][0][0])
# sort method for items
def myCmp(x, y, col, order):
cx = ""
cy = ""
for item in x:
if item[0] == col[0][1]:
cx = item[1]
break
for item in y:
if item[0] == col[0][1]:
cy = item[1]
break
if cx.lower() > cy.lower():
return 1 * order[0]
return -1 * order[0]
sorted_children = []
tmp = []
for item in children:
if item[0][3] == "header":
if len(tmp) > 0:
tmp.sort(lambda x, y: myCmp(x, y, col, order))
sorted_children.extend(tmp)
tmp = []
sorted_children.append(item)
else:
tmp.append(item)
tmp.sort(lambda x, y: myCmp(x, y, col, order))
sorted_children.extend(tmp)
children = sorted_children
req.reply_headers['Content-Type'] = "application/pdf"
req.write(
printview.getPrintView(lang(req), imagepath, metadata,
getPaths(node, AccessData(req)), style,
children, getCollection(node)))
def getContent(req, ids):
def getSchemes(req):
schemes = AccessData(req).filter(loadTypesFromDB())
return filter(lambda x: x.isActive(), schemes)
ret = ""
v = {"message": ""}
if len(ids) >= 0:
ids = ids[0]
v["id"] = ids
if "do_action" in req.params.keys(): # process nodes
fieldname = req.params.get("fields")
old_values = u(req.params.get("old_values", "")).split(";")
new_value = u(req.params.get("new_value"))
basenode = tree.getNode(ids)
entries = getAllAttributeValues(fieldname, req.params.get("schema"))
c = 0
for old_val in old_values:
for n in AccessData(req).filter(tree.NodeList(entries[old_val])):
try:
n.set(fieldname, replaceValue(n.get(fieldname), u(old_val), u(new_value)))
n.setDirty()
c += 1
except:
pass
v["message"] = req.getTAL("web/edit/modules/manageindex.html", {"number": c}, macro="operationinfo")
if "style" in req.params.keys(): # load schemes
if req.params.get("action", "") == "schemes":
v["schemes"] = getSchemes(req)
req.writeTAL("web/edit/modules/manageindex.html", v, macro="schemes_dropdown")
return ""
elif req.params.get("action", "").startswith("indexfields__"): # load index fields
schema = getMetaType(req.params.get("action", "")[13:])
fields = []
for field in schema.getMetaFields():
if field.getFieldtype() == "ilist":
fields.append(field)
v["fields"] = fields
v["schemaname"] = schema.getName()
req.writeTAL("web/edit/modules/manageindex.html", v, macro="fields_dropdown")
return ""
elif req.params.get("action", "").startswith("indexvalues__"): # load values of selected indexfield
node = tree.getNode(ids)
fieldname = req.params.get("action").split("__")[-2]
schema = req.params.get("action").split("__")[-1]
v["entries"] = []
if node:
v["entries"] = getAllAttributeValues(fieldname, schema)
v["keys"] = v["entries"].keys()
v["keys"].sort(lambda x, y: cmp(x.lower(), y.lower()))
req.writeTAL("web/edit/modules/manageindex.html", v, macro="fieldvalues")
return ""
elif req.params.get("action", "").startswith("children__"): # search for children of current collection
scheme = req.params.get("action", "").split("__")[1]
fieldname = req.params.get("action", "").split("__")[2]
values = req.params.get("action", "").split("__")[3].split(";")[:-1]
all_values = getAllAttributeValues(fieldname, scheme)
def isChildOf(access, node, basenodeid):
for ls in getPaths(node, access):
if str(basenodeid) in tree.NodeList(ls).getIDs():
return 1
return 0
subitems = {}
for value in values:
value = u(value)
if value in all_values:
subitems[value] = []
for l in all_values[value]:
if isChildOf(AccessData(req), tree.getNode(l), ids):
subitems[value].append(l)
v["items"] = subitems
v["keys"] = subitems.keys()
v["keys"].sort()
req.writeTAL("web/edit/modules/manageindex.html", v, macro="valueinfo")
return ""
else:
return req.getTAL("web/edit/modules/manageindex.html", v, macro="manageform")
def showMaskList(req, id):
metadatatype = getMetaType(id)
masks = metadatatype.getMasks()
order = getSortCol(req)
actfilter = getFilter(req)
# resets filter to all if adding mask in /metatype view
# if req.params.get('acttype') == 'mask' or req.params.get('acttype') == 'schema':
# if req.path == '/metatype' and 'filterbutton' not in req.params:
# actfilter = '*'
# resets filter when going to a new view
if 'filterbutton' not in req.params:
actfilter = '*'
# filter
if actfilter != "":
if actfilter in ("all", "*", t(lang(req), "admin_filter_all")):
None # all users
elif actfilter == "0-9":
num = re.compile(r'([0-9])')
masks = filter(lambda x: num.match(x.name), masks)
elif actfilter == "else" or actfilter == t(lang(req), "admin_filter_else"):
all = re.compile(r'([a-z]|[A-Z]|[0-9])')
masks = filter(lambda x: not all.match(x.name), masks)
else:
masks = filter(lambda x: x.name.lower().startswith(actfilter), masks)
pages = Overview(req, masks)
defaults = {}
for mask in masks:
if mask.getDefaultMask():
defaults[mask.getMasktype()] = mask.id
# sorting
if order != "":
if int(order[0:1]) == 0:
masks.sort(lambda x, y: cmp(x.name.lower(), y.name.lower()))
elif int(order[0:1]) == 1:
masks.sort(lambda x, y: cmp(x.getMasktype(), y.getMasktype()))
elif int(order[0:1]) == 2:
masks.sort(lambda x, y: cmp(x.getDescription(), y.getDescription()))
elif int(order[0:1]) == 3:
masks.sort(lambda x, y: cmp(x.getDefaultMask(), y.getDefaultMask()))
elif int(order[0:1]) == 4:
masks.sort(lambda x, y: cmp(x.getLanguage(), y.getLanguage()))
if int(order[1:]) == 1:
masks.reverse()
else:
masks.sort(lambda x, y: cmp(x.getOrderPos(), y.getOrderPos()))
v = getAdminStdVars(req)
v["filterattrs"] = []
v["filterarg"] = req.params.get("filtertype", "name")
v["sortcol"] = pages.OrderColHeader(
[
t(
lang(req), "admin_mask_col_1"), t(
lang(req), "admin_mask_col_2"), t(
lang(req), "admin_mask_col_3"), t(
lang(req), "admin_mask_col_4"), t(
lang(req), "admin_mask_col_5"), t(
lang(req), "admin_mask_col_6")])
v["metadatatype"] = metadatatype
v["masktypes"] = getMaskTypes()
v["lang_icons"] = {"de": "/img/flag_de.gif", "en": "/img/flag_en.gif", "no": "/img/emtyDot1Pix.gif"}
v["masks"] = masks
v["pages"] = pages
v["order"] = order
v["defaults"] = defaults
v["order"] = order
v["actfilter"] = actfilter
return req.getTAL("web/admin/modules/metatype_mask.html", v, macro="view_mask")
def buildNodeDescriptor(params,
node,
indent=None,
written=None,
children=True,
parents=False):
nd = []
d = {}
if written is None:
written = {}
nodedict = {}
nodedict['id'] = node.id
mask = params.get('mask', 'none').lower()
attrlist = params.get('attrlist', [])
if attrlist:
attrlist = attrlist.split(',')
attrspec = params.get('attrspec', 'default_mask')
# 'all': no restriction, send all attributes
# 'none': to not send any attribute at all
# 'default_mask' (default): only send attributes that correspond to the default mask fields
#
# remark: attributes specified comma separated in 'attrlist' are added to those specified by 'attrspec'
#
if mask == 'default':
nodedict['defaultexport'] = node.show_node_text(labels=1,
language=params.get(
'lang', ''))
# except:
# logg.error('Error: web.services.jsonnode: could not get default mask content')
# nodedict['defaultexport'] = []
elif mask not in ["", "none"]: # deliver every mask
try:
mask_obj = getMetaType(node.getSchema()).getMask(mask)
if mask_obj:
nodedict['defaultexport'] = mask_obj.getViewHTML([node],
flags=8)
else:
nodedict['defaultexport'] = "mask not found"
except Exception as e:
logg.exception("exception in buildNodeDescriptor")
nodedict['defaultexport'] = "error"
if children:
nodedict['children'] = []
for c in node.getChildren().sort_by_orderpos():
nodedict['children'].append({
'id': ustr(c.id),
'type': c.type,
'name': esc(c.name)
})
if parents:
nodedict['parents'] = []
for c in node.getParents().sort_by_orderpos():
nodedict['parents'].append({
'id': ustr(c.id),
'type': c.type,
'name': esc(c.name)
})
nd.append(nodedict)
if (children):
for c in node.getChildren().sort_by_orderpos():
if c.id not in written:
written[c.id] = None
childnodedict = buildNodeDescriptor(params, c, indent)
nd.append(childnodedict)
nodeattributes_dict = {}
if attrspec == 'none':
# no attributes should be sent
pass
elif attrspec == 'default_mask' or attrspec not in ['none', 'all']:
from contenttypes.data import make_lookup_key, get_maskcache_entry
from core.transition.globals import request
language = params.get('lang', '')
lookup_key = make_lookup_key(node, language=language, labels=False)
if 'maskcache' not in request.app_cache or lookup_key not in request.app_cache[
'maskcache']:
# fill cache
node.show_node_text(labels=False, language=language)
mask_id, field_descriptors = get_maskcache_entry(
lookup_key, request.app_cache['maskcache'],
request.app_cache['maskcache_accesscount'])
try:
for field_descriptor in field_descriptors:
field_attribute = field_descriptor[0]
if field_attribute not in attrlist:
# attrlist may be an empty list or filled from the request parameters
attrlist.append(field_attribute)
except:
# no mask for this metadata type
logg.exception(
"exception in buildNodeDescriptor, no 'nodesmall' or 'shortview' for node %s",
node.id)
elif attrspec == 'all':
nodeattributes_dict_all_attributes = node.attributes.copy()
if nodeattributes_dict_all_attributes:
for k in filter(attribute_name_filter,
nodeattributes_dict_all_attributes.keys()):
nodeattributes_dict[k] = nodeattributes_dict_all_attributes[k]
if attrlist:
for attr in filter(attribute_name_filter, attrlist):
if attr == "nodename":
value = node.name
else:
value = node.get(attr)
nodeattributes_dict[attr] = value
if nodeattributes_dict:
nodedict['attributes'] = nodeattributes_dict
if 'files' in params:
nodedict['files'] = []
for file in node.getFiles():
if file.type == "metadata" or file.type == "statistic":
continue
mimetype = file.mimetype
if mimetype is None:
mimetype = "application/x-download"
nodedict['files'].append({
'filename': esc(file.getName()),
'mime-type': mimetype,
'type': file.type
})
if 'nodename' in params:
nodedict['name'] = node.name
if 'nodetype' in params:
nodedict['type'] = node.type
if 'nodeschema' in params:
nodedict['schema'] = node.schema
return nd
