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