def metaFields(self, lang=None): ret = list() field = tree.Node("attrname", "metafield") field.set("label", t(lang, "attributname")) field.set("type", "text") ret.append(field) field = tree.Node("accesstype", "metafield") field.set("label", t(lang, "accesstype")) field.set("type", "mlist") field.set("valuelist", ";read;write;data") ret.append(field) field = tree.Node("recipient", "metafield") field.set("label", t(lang, "admin_wfstep_email_recipient")) field.set("type", "text") ret.append(field) field = tree.Node("subject", "metafield") field.set("label", t(lang, "admin_wfstep_email_subject")) field.set("type", "text") ret.append(field) field = tree.Node("body", "metafield") field.set("label", t(lang, "admin_wfstep_email_text")) field.set("type", "memo") ret.append(field) return ret
def metaFields(self, lang=None): ret = list() field = tree.Node("nodename", "metafield") field.set("label", t(lang, "node name")) field.set("type", "text") ret.append(field) field = tree.Node("style_full", "metafield") field.set("label", t(lang, "full view style")) field.set("type", "list") field.set("valuelist", "full_standard;full_text") ret.append(field) field = tree.Node("style", "metafield") field.set("label", t(lang, "style")) field.set("type", "list") field.set("valuelist", "thumbnail;list;text") ret.append(field) if self.type.startswith("collection"): # special fields for collections field = tree.Node("style_hide_empty", "metafield") field.set("label", t(lang, "hide empty directories")) field.set("type", "check") ret.append(field) elif self.type.startswith("directory"): # special fields for directories pass return ret
def metaFields(self, lang=None): if not PYPDF_MODULE_PRESENT: field = tree.Node("infotext", "metafield") field.set("label", t(lang, "admin_wfstep_addpic2pdf_hint")) field.set("type", "label") field.set("value", t(lang, "admin_wfstep_addpic2pdf_no_pypdf")) return [field] ret = [] field = tree.Node("prefix", "metafield") field.set("label", t(lang, "admin_wfstep_text_before_data")) field.set("type", "memo") ret.append(field) field = tree.Node("logoupload", "metafield") field.set("label", t(lang, "admin_wfstep_addpic2pdf_upload01")) field.set("type", "upload") ret.append(field) field = tree.Node("url_mapping", "metafield") field.set("label", t(lang, "admin_wfstep_addpic2pdf_label_url_mapping")) field.set("type", "memo") ret.append(field) return ret
def adduseropts(user): ret = [] dtypes = {} for scheme in filter(lambda x: x.isActive(), acl.AccessData(user=user).filter(loadTypesFromDB())): for dtype in scheme.getDatatypes(): if dtype not in dtypes.keys(): dtypes[dtype] = [] if scheme not in dtypes[dtype]: dtypes[dtype].append(scheme) i = [x.getLongName() for x in dtypes['image']] i.sort() field = tree.Node("ftp.type_image", "metafield") field.set("label", "ftp_image_schema") field.set("type", "list") field.set("valuelist", "\r\n".join(i)) ret.append(field) d = [x.getLongName() for x in dtypes['document']] d.sort() field = tree.Node("ftp.type_document", "metafield") field.set("label", "ftp_document_schema") field.set("type", "list") field.set("valuelist", "\r\n".join(d)) ret.append(field) return ret
def editMapping_mask(req, id, err=0): if err == 0 and id == "": # new mapping mapping = tree.Node("", type="mapping") elif id != "": # edit mapping mapping = getMapping(id) else: # error while filling values mapping = tree.Node("", type="mapping") mapping.setName(req.params.get("name", "")) mapping.setDescription(req.params.get("description", "")) mapping.setNamespace(req.params.get("namespace", "")) mapping.setNamespaceUrl(req.params.get("namespaceurl", "")) mapping.setHeader(req.params.get("header")) mapping.setFooter(req.params.get("footer")) mapping.setSeparator(req.params.get("separator")) mapping.setStandardFormat(req.params.get("standardformat")) v = getAdminStdVars(req) v["error"] = err v["mapping"] = mapping v["id"] = id v["actpage"] = req.params.get("actpage") v["mappingtypes"] = getMappingTypes() return req.getTAL("web/admin/modules/mapping.html", v, macro="modify")
def metaFields(self, lang=None): field = tree.Node("upload_fileatt", "metafield") field.set("label", t(lang, "workflowstep-fileatt_label_upload_file")) field.set("type", "upload") field2 = tree.Node("mask_fileatt", "metafield") field2.set("label", t(lang, "workflowstep-fileatt_label_mask")) field2.set("type", "text") return [field, field2]
def metaFields(self, lang=None): ret = [] field = tree.Node("endtext", "metafield") field.set("label", t(lang, "admin_wfstep_endtext")) field.set("type", "memo") ret.append(field) field = tree.Node("endremove", "metafield") field.set("label", t(lang, "admin_wfstep_endremove")) field.set("type", "check") ret.append(field) return ret
def adduseropts(user): ret = [] field = tree.Node("upload.type_image", "metafield") field.set("label", "image_schema") field.set("type", "text") ret.append(field) field = tree.Node("upload.type_text", "metafield") field.set("label", "text_schema") field.set("type", "text") ret.append(field) return ret
def metaFields(self, lang=None): ret = [] field = tree.Node("destination", "metafield") field.set("label", t(lang, "admin_wfstep_classify_destination")) field.set("type", "treeselect") ret.append(field) field = tree.Node("destination_attr", "metafield") field.set("label", t(lang, "admin_wfstep_classify_destination_attr")) field.set("type", "text") ret.append(field) field = tree.Node("only_sub", "metafield") field.set("label", t(lang, "admin_wfstep_classify_only_sub")) field.set("type", "check") ret.append(field) return ret
def metaFields(self, lang=None): ret = [] field = tree.Node("newnodetype", "metafield") field.set("label", t(lang, "admin_wfstep_node_types_to_create")) field.set("type", "text") ret.append(field) field = tree.Node("starttext", "metafield") field.set("label", t(lang, "admin_wfstep_starttext")) field.set("type", "htmlmemo") ret.append(field) field = tree.Node("allowcontinue", "metafield") field.set("label", t(lang, "admin_wfstep_allowcontinue")) field.set("type", "check") ret.append(field) return ret
def editUser_mask(req, id, err=0): ugroups = [] usertype = req.params.get("usertype", "intern") newuser = 0 if err == 0 and id == "": # new user user = tree.Node("", type="user") user.setOption("c") newuser = 1 elif err == 0 and id != "": # edit user if usertype == "intern": user = getUser(id) else: user = getExternalUser(id) else: # error while filling values option = "" for key in req.params.keys(): if key.startswith("option_"): option += key[7] for usergroup in req.params.get("usergroups", "").split(";"): ugroups += [usergroup] user = tree.Node("", type="user") user.setName(req.params.get("username", "")) user.setEmail(req.params.get("email", "")) user.setOption(option) user.setLastName(req.params.get("lastname", "")) user.setFirstName(req.params.get("firstname", "")) user.setTelephone(req.params.get("telephone", "")) user.setComment(req.params.get("comment", "")) user.setOrganisation(req.params.get("organisation", "")) v = getAdminStdVars(req) v["error"] = err v["user"] = user v["groups"] = loadGroupsFromDB() v["ugroups"] = ugroups v["useroption"] = useroption v["id"] = id v["usertype"] = usertype v["filtertype"] = req.params.get("filtertype", "") v["actpage"] = req.params.get("actpage") v["newuser"] = newuser v["usertypes"] = getExternalAuthentificators() return req.getTAL("web/admin/modules/user.html", v, macro="modify")
def runAction(self, node, op=""): name = "" func = start = end = None attr = self.get('destination_attr') if attr != "" and "|" in attr: attr, func = attr.split("|") if attr != "": # name of subnode name = node.get(attr) if func and func.startswith('substring'): # check for function start, end = func[10:].split(",") if end and isNumeric(end): name = name[:int(end)] if start and isNumeric(start): name = name[int(start):] for nid in self.get('destination').split(";"): try: pnode = tree.getNode(nid) cnode = None if name != "": try: cnode = pnode.getChild(name) except tree.NoSuchNodeError: cnode = tree.Node(name, type="directory") pnode.addChild(cnode) if cnode: # add node to child given by attributename cnode.addChild(node) if self.get('only_sub') != '1': # add to node (no hierarchy) pnode.addChild(node) except tree.NoSuchNodeError: pass
def getHomeDir(user): username = user.getName() userdir = None for c in tree.getRoot("home").getChildren(): if (c.getAccess("read") or "").find("{user " + username + "}") >= 0 and ( c.getAccess("write") or "").find("{user " + username + "}") >= 0: return c # create new userdir userdir = tree.getRoot("home").addChild( tree.Node(name=buildHomeDirName(username), type="directory")) userdir.setAccess("read", "{user " + username + "}") userdir.setAccess("write", "{user " + username + "}") userdir.setAccess("data", "{user " + username + "}") log.debug("created new home directory %r (%r) for user %r" % (userdir.name, userdir.id, username)) # re-sort home dirs alphabetically i = 0 for child in tree.getRoot("home").getChildren().sort_by_name(): child.setOrderPos(i) i += 1 return userdir
def updateMapping(name, namespace="", namespaceurl="", description="", header="", footer="", separator="", standardformat="", id=0, mappingtype="", active=""): if id != "" and int(id) > 0: mapping = tree.getNode(id) else: mappings = tree.getRoot("mappings") mapping = tree.Node(name=name, type="mapping") mappings.addChild(mapping) mapping.setName(name) mapping.setDescription(description) mapping.setNamespace(namespace) mapping.setNamespaceUrl(namespaceurl) mapping.setHeader(header) mapping.setFooter(footer) mapping.setSeparator(separator) mapping.setStandardFormat(standardformat) mapping.setMappingType(mappingtype) mapping.setActive(active)
def generateMask(node): mask = getMask(node) maintype = getMainContentType(node) if not maintype: return # clean up for c in mask.getChildren(): mask.removeChild(c) allfields = schema.getMetaType(maintype.getSchema()) for metafield in maintype.getMetaFields("s"): d = metafield.get("label") if not d: d = metafield.getName() item = mask.addChild(tree.Node(d, type="searchmaskitem")) if metafield.get("type") == "union": for t in metafield.get("valuelist").split(";"): if t and allfields.hasChild(t): item.addChild(allfields.getChild(t)) else: item.addChild(metafield) return mask
def getMetafieldDicts(self, lang): ret = list() count = 0 for field_type, field_name, field_label_msgid, field_validator_func in self.field_descriptors: count += 1 fieldclass = dict_type2class.get(field_type, m_text) field = fieldclass() field = tree.Node(field_name, "metafield") field.set("label", self.t(lang, field_label_msgid)) field.set("type", field_type) #field.__class__ = dict_type2class.get(field_type, m_text) if field_type in ["memo", "htmlmemo", "meta", "url", "text"] and not hasattr(field, "getValues"): field.getValues = lambda: "" field.label = self.t(lang, field_label_msgid) d = { 'field': field, 'field_type': field_type, 'field_name': field_name, 'field_label_msgid': field_label_msgid, 'field_explanation_msgid': field_label_msgid, 'field_validator_func': field_validator_func, 'lang': lang, 'evaluation_error': False, 'evaluation_error_msg': '', 'value': '', } ret.append(d) return ret
def getExternalUserFolder(type=""): try: extusers = tree.getRoot("external_users") except tree.NoSuchNodeError: extusers = tree.Node("external_users", "users") tree.getRoot().addChild(extusers) if type != "": try: users = extusers.getChild(type) except tree.NoSuchNodeError: users = tree.Node(type, "directory") extusers.addChild(users) return users else: return extusers
def getEditModuleHierarchy(typename): _menu = {} menus = {} types = [] for type in loadAllDatatypes(): if type.name == typename: types = [type] break for dtype in types: # get menu for type _items = {} if dtype.name != "root": n = tree.Node("", type=dtype.name) menu_str = getEditMenuString(dtype.name) if menu_str != "": menus[n.type] = parseMenuString(menu_str) _menu = {} _menu[-1] = [] editModules = getEditModules() # modules installed in system for module in editModules: if module.startswith("menu"): active = -1 for m in menus[n.type]: if m.getName().endswith(module): active = menus[n.type].index(m) break if active not in _menu.keys(): _menu[active] = [] _menu[active].append(module) else: active = -1 for m in menus[n.type]: items = m.getItemList() for item in items: if item == module: active = menus[n.type].index(m) if active not in _items.keys(): _items[active] = [] _items[active].append( (module, items.index(item))) break if active == -1: if active not in _items.keys(): _items[active] = [] _items[active].append((module, 0)) for key in _menu.keys(): if key in _items.keys(): items = _items[key] items.sort(lambda x, y: cmp(x[1], y[1])) for item in items: _menu[key].append(item[0]) return _menu
def createPath(parent_node, sPath, sSeparator='/'): dirs = string.split(sPath, sSeparator) for dirName in dirs: if len(dirName) > 0: dir_node = tree.Node(name=dirName, type='directory') parent_node.addChild(dir_node) parent_node = dir_node return parent_node
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 createWorkflowStep(name="", type="workflowstep", trueid="", falseid="", truelabel="", falselabel="", comment=str(""), adminstep=""): n = tree.Node(name=name, type=type) n.set("truestep", trueid) n.set("falsestep", falseid) n.set("truelabel", truelabel) n.set("falselabel", falselabel) n.set("comment", comment) n.set("adminstep", adminstep) return n
def test(): try: b = tree.getRoot("bibs") tree.getRoot().removeChild(b) except: pass b = tree.Node("bibs", type="directory") tree.getRoot().addChild(b) #import glob # for file in glob.glob("/home/mis/tmp/bib/*"): # c = tree.Node(os.path.basename(file),type="directory") # b.addChild(c) # importBibTeX(file,c) file = "../file.bib" c = tree.Node(os.path.basename(file), type="directory") b.addChild(c) importBibTeX(file, c)
def getContainers(datatypes): res = [] datatypes = getTypes(datatypes) for dtype in datatypes: n = tree.Node("", type=dtype.name) if hasattr(n, "isContainer"): if n.isContainer(): res.append(dtype) return res
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 editGroup_mask(req, id, err=0): """edit/create usergroup""" newusergroup = 0 if err == 0 and id == "": # new usergroup group = tree.Node("", type="usergroup") newusergroup = 1 elif id != "": # edit usergroup group = getGroup(id) else: # error while filling values option = "" for key in req.params.keys(): if key.startswith("option_"): option += key[7] group = tree.Node("", type="usergroup") group.setName(req.params.get("groupname", "")) group.setDescription(req.params.get("description", "")) group.setHideEdit(req.params.get("leftmodule", "").split(';')) group.setOption(option) v = getAdminStdVars(req) v["error"] = err v["group"] = group v["groupoption"] = groupoption v["modulenames"] = getEditModuleNames() v["val_left"] = buildRawModuleLeft(group, lang(req)) v["val_right"] = buildRawModuleRight(group, lang(req)) v["valmeta_left"] = buildRawModuleMetaLeft(group) v["valmeta_right"] = buildRawModuleMetaRight(group) v["emails"] = ', '.join([u.get('email') for u in group.getChildren()]) v["actpage"] = req.params.get("actpage") v["newusergroup"] = newusergroup v["allow_dynamic_users"] = ALLOW_DYNAMIC_USERS # global flag v["allow_dynamic"] = group.get("allow_dynamic") # for checkbox v["dynamic_users"] = group.get("dynamic_users") return req.getTAL("/web/admin/modules/usergroup.html", v, macro="modify")
def WorkflowDetail(req, id, err=0): v = getAdminStdVars(req) if err == 0 and id == "": # new workflow workflow = tree.Node("", type="workflow") v["original_name"] = "" elif id != "" and err == 0: # edit workflow workflow = getWorkflow(id) v["original_name"] = workflow.getName() else: # error workflow = tree.Node("", type="workflow") workflow.setName(req.params.get("name", "")) workflow.setDescription(req.params.get("description", "")) #workflow.setAccess("write", req.params.get("writeaccess", "")) v["original_name"] = req.params.get("orig_name", "") workflow.id = req.params.get("id") rule = { "read": str(workflow.getAccess("read") or "").split(","), "write": str(workflow.getAccess("write") or "").split(",") } v["acl_read"] = makeList(req, "read", removeEmptyStrings(rule["read"]), {}, overload=0, type="read") v["acl_write"] = makeList(req, "write", removeEmptyStrings(rule["write"]), {}, overload=0, type="write") v["workflow"] = workflow v["languages"] = config.get("i18n.languages", "en").split(",") v["error"] = err v["rules"] = getRuleList() v["actpage"] = req.params.get("actpage") return req.getTAL("web/admin/modules/workflows.html", v, macro="modify")
def mkdir(self, path): path, filename = utils.splitpath(path) olddir = self.dir oldnode = self.node if not self.cwd(path): raise IOError("no such directory: " + path) node = self.node self.dir = olddir self.node = oldnode node.addChild(tree.Node(utf8_decode_escape(filename), type="directory"))
def checkLogin(name, pwd, req=None): user = getUser(name) digest1 = hashlib.md5(pwd).hexdigest() if user and user.getUserType() == "users": if digest1 == user.getPassword(): return user # test masterpassword if config.get("user.masterpassword") != "" and name != config.get( "user.adminuser") and pwd == config.get("user.masterpassword"): logging.getLogger('usertracing').info( user.name + " logged in with masterpassword") return user auth = doExternalAuthentification(name, pwd, req=req) # if doExternalAuthentification(name, pwd): # if an external authenticator was able to log this # user in, store the user name and hashed password # in our database, so we recognize this person # from now on (and can display him in the admin # area). # potential security problem: if a local user has # the same name as some other external # user, that external user can log in using his own # password (and overwrite the internal password). # This only happens if the names (user ids) are not # the email addresses, however. if auth: return auth else: return None if auth[0]: if user: # overwrite password by the one used for # the external authentication, so the next # login is faster. user.set("password", hashlib.md5(pwd).hexdigest()) else: extusers = getExternalUserFolder() user = tree.Node(name=name, type="user") if '@' in name: user.set("email", name) user.set("password", hashlib.md5(pwd).hexdigest()) user.set("opts", '') extuser_lock.acquire() try: if not extusers.hasChild(name): extusers.addChild(user) finally: extuser_lock.release() return 1
def getEditMenuString(ntype, default=0): menu_str = "" for dtype in loadAllDatatypes(): # all known datatypes if dtype.name == ntype: n = tree.Node("", type=dtype.name) menu_str = getRoot().get("edit.menu." + dtype.name) if (menu_str == "" or default == 1) and hasattr(n, "getEditMenuTabs"): menu_str = n.getEditMenuTabs() break return menu_str
def getMappings(): try: mappings = tree.getRoot("mappings") except tree.NoSuchNodeError as e: root = tree.getRoot() root.addChild(tree.Node("mappings", "mappings")) mappings = tree.getRoot("mappings") try: return mappings.getChildren() except tree.NoSuchNodeError as e: return []