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 []
