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):
ret = list()
field = Metafield("attrname")
field.set("label", t(lang, "attributname"))
field.set("type", "text")
ret.append(field)
field = Metafield("accesstype")
field.set("label", t(lang, "accesstype"))
field.set("type", "mlist")
field.set("valuelist", ";read;write;data")
ret.append(field)
field = Metafield("recipient")
field.set("label", t(lang, "admin_wfstep_email_recipient"))
field.set("type", "text")
ret.append(field)
field = Metafield("subject")
field.set("label", t(lang, "admin_wfstep_email_subject"))
field.set("type", "text")
ret.append(field)
field = Metafield("body")
field.set("label", t(lang, "admin_wfstep_email_text"))
field.set("type", "memo")
ret.append(field)
return ret
def getContent(req, ids):
user = users.getUserFromRequest(req)
access = AccessData(req)
node = tree.getNode(ids[0])
if "sortfiles" in users.getHideMenusForUser(user) or not access.hasWriteAccess(node):
req.setStatus(httpstatus.HTTP_FORBIDDEN)
return req.getTAL("web/edit/edit.html", {}, macro="access_error")
c = getCollection(node)
if "globalsort" in req.params:
c.set("sortfield", req.params["globalsort"])
collection_sortfield = c.get("sortfield")
class SortChoice:
def __init__(self, label, value):
self.label = label
self.value = value
sortfields = [SortChoice(t(req, "off"), "")]
for ntype, num in c.getAllOccurences(AccessData(req)).items():
if ntype.getSortFields():
for sortfield in ntype.getSortFields():
sortfields += [SortChoice(sortfield.getLabel(), sortfield.getName())]
sortfields += [SortChoice(sortfield.getLabel() + t(req, "descending"), "-" + sortfield.getName())]
break
return req.getTAL("web/edit/modules/sortfiles.html", {"node": node, "collection_sortfield": collection_sortfield,
"sortchoices": sortfields, "name": c.getName()}, macro="edit_sortfiles")
def metaFields(self, lang=None):
if not PYPDF_MODULE_PRESENT:
field = Metafield("infotext")
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 = Metafield("prefix")
field.set("label", t(lang, "admin_wfstep_text_before_data"))
field.set("type", "memo")
ret.append(field)
field = Metafield("logoupload")
field.set("label", t(lang, "admin_wfstep_addpic2pdf_upload01"))
field.set("type", "upload")
ret.append(field)
field = Metafield("url_mapping")
field.set("label", t(lang, "admin_wfstep_addpic2pdf_label_url_mapping"))
field.set("type", "memo")
ret.append(field)
return ret
def metaFields(self, lang=None):
field = Metafield("upload_fileatt")
field.set("label", t(lang, "workflowstep-fileatt_label_upload_file"))
field.set("type", "upload")
field2 = Metafield("mask_fileatt")
field2.set("label", t(lang, "workflowstep-fileatt_label_mask"))
field2.set("type", "text")
return [field, field2]
def buildRawModuleRight(group, language):
ret = ""
hide = group.getHideEdit().split(';')
modulenames = getEditModuleNames()
modulenames.sort(lambda x, y: cmp(t(language, 'e_' + x).lower(), t(language, 'e_' + y).lower()))
for mod in modulenames:
if mod not in hide:
ret += '<option value="%s">%s</option>' % (mod, t(language, 'e_' + mod, ))
return ret
def buildRawModuleLeft(group, language):
ret = ""
if group.getHideEdit() == "":
return ret
hidelist = group.getHideEdit().split(';')
hidelist.sort(lambda x, y: cmp(t(language, 'e_' + x), t(language, 'e_' + y)))
for hide in hidelist:
ret += '<option value="%s">%s</option>' % (hide, t(language, 'e_' + hide, ))
return ret
def WorkflowStepList(req, wid):
global _cssclass, _page
workflow = getWorkflow(wid)
workflowsteps = list(workflow.getSteps())
order = getSortCol(req)
actfilter = getFilter(req)
# 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])')
workflowsteps = filter(lambda x: num.match(x.name), workflowsteps)
elif actfilter == "else" or actfilter == t(lang(req), "admin_filter_else"):
all = re.compile(r'([a-z]|[A-Z]|[0-9])')
workflowsteps = filter(lambda x: not all.match(x.name), workflowsteps)
else:
workflowsteps = filter(lambda x: x.name.lower().startswith(actfilter), workflowsteps)
pages = Overview(req, workflowsteps)
# sorting
if order != "":
if int(order[0]) == 0:
workflowsteps.sort(lambda x, y: cmp(x.name.lower(), y.name.lower()))
elif int(order[0]) == 1:
workflowsteps.sort(lambda x, y: cmp(x.type, y.type))
elif int(order[0]) == 2:
workflowsteps.sort(lambda x, y: cmp(x.getTrueId(), y.getTrueId()))
elif int(order[0]) == 3:
workflowsteps.sort(lambda x, y: cmp(x.getFalseId(), y.getFalseId()))
elif int(order[0]) == 4:
workflowsteps.sort(lambda x, y: cmp(len(x.get("description")), len(y.get("description"))))
# elif int(order[0]) == 5:
# workflowstep.sort(lambda x, y: cmp(x.getAccess("read"), y.getAccess("read")))
# elif int(order[0]) == 6:
# workflowstep.sort(lambda x, y: cmp(x.getAccess("write"), y.getAccess("write")))
if int(order[1]) == 1:
workflowsteps.reverse()
else:
workflowsteps.sort(lambda x, y: cmp(x.name.lower(), y.name.lower()))
v = getAdminStdVars(req)
v["sortcol"] = pages.OrderColHeader(
[
t(
lang(req), "admin_wfstep_col_1"), t(
lang(req), "admin_wfstep_col_2"), t(
lang(req), "admin_wfstep_col_3"), t(
lang(req), "admin_wfstep_col_4"), t(
lang(req), "admin_wfstep_col_5"), t(
lang(req), "admin_wfstep_col_6"), t(
lang(req), "admin_wfstep_col_7")])
v["workflow"] = workflow
v["workflowsteps"] = workflowsteps
v["pages"] = pages
v["actfilter"] = actfilter
v["csrf"] = req.csrf_token.current_token
return req.getTAL("web/admin/modules/workflows.html", v, macro="view_step")
def printPageAll(self):
if self.page != 0:
return '<button name="resetpage" title="' + \
t(self.language,
"admin_allelements_title") + '" class="admin_page" type="submit" value="">' + t(self.language,
"admin_allelements") + '</button>'
else:
return '<button name="firstpage" title="' + \
t(self.language,
"admin_pageelements_title") + '" class="admin_page" type="submit" value="">' + t(self.language,
"admin_pageelements_title") + '</button>'
def metaFields(self, lang=None):
ret = list()
field = Metafield("publishsetpublishedversion")
field.set("label", t(lang, "admin_wfstep_publishsetpublishedversion"))
field.set("type", "check")
ret.append(field)
field = Metafield("publishsetupdatetime")
field.set("label", t(lang, "admin_wfstep_publishsetupdatetime"))
field.set("type", "check")
ret.append(field)
return ret
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 get_edit_label(node, lang):
special_dir_type = get_special_dir_type(node)
if special_dir_type is None:
label = node.getLabel(lang=lang)
elif special_dir_type == "home":
label = t(lang, 'user_home')
if current_user.is_admin:
label += " (" + node.name + ")"
else:
label = t(lang, 'user_' + special_dir_type)
return label
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 = Metafield("newnodetype")
field.set("label", t(lang, "admin_wfstep_node_types_to_create"))
field.set("type", "text")
ret.append(field)
field = Metafield("starttext")
field.set("label", t(lang, "admin_wfstep_starttext"))
field.set("type", "htmlmemo")
ret.append(field)
field = Metafield("allowcontinue")
field.set("label", t(lang, "admin_wfstep_allowcontinue"))
field.set("type", "check")
ret.append(field)
return ret
def viewlist(req, id):
mapping = getMapping(id)
fields = list(mapping.getFields())
order = getSortCol(req)
actfilter = getFilter(req)
# filter
if actfilter != "":
if actfilter in ("all", "*", (lang(req), "admin_filter_all")):
None # all mappings
elif actfilter == "0-9":
num = re.compile(r'([0-9])')
fields = filter(lambda x: num.match(x.name), fields)
elif actfilter == "else" or actfilter == t(lang(req), "admin_filter_else"):
all = re.compile(r'([a-z]|[A-Z]|[0-9])')
fields = filter(lambda x: not all.match(x.name), fields)
else:
fields = filter(lambda x: x.name.lower().startswith(actfilter), fields)
pages = Overview(req, fields)
# sorting
if order != "":
if int(order[0:1]) == 0:
fields.sort(lambda x, y: cmp(x.name.lower(), y.name.lower()))
elif int(order[0:1]) == 1:
fields.sort(lambda x, y: cmp(x.getDescription().lower(), y.getDescription().lower()))
elif int(order[0:1]) == 2:
fields.sort(lambda x, y: cmp(x.getMandatory(), y.getMandatory()))
if int(order[1:]) == 1:
fields.reverse()
else:
fields.sort(lambda x, y: cmp(x.name.lower(), y.name.lower()))
v = getAdminStdVars(req)
v["sortcol"] = pages.OrderColHeader([t(lang(req), "admin_mappingfield_col_1"), t(lang(req), "admin_mappingfield_col_2"), t(
lang(req), "admin_mappingfield_col_3")], addparams="&detailof=" + unicode(mapping.id))
v["fields"] = fields
v["mapping"] = mapping
v["options"] = []
v["pages"] = pages
v["actfilter"] = actfilter
v["csrf"] = req.csrf_token.current_token
return req.getTAL("web/admin/modules/mapping.html", v, macro="viewlist")
def addChildren(self, children):
self.addData(Paragraph('%s:' % t(self.language, "print_view_children"), self.bp))
_head = 0 # count headers
for c in children:
if len(c) > 0 and c[0][3] == "header":
_head += 1
items = []
_c = 1
for c in children:
if len(c) > 0 and c[0][3] == "header":
for item in items:
self.addData(Paragraph("[%s/%s]: %s" % (_c, len(children) - _head, "; ".join(item)), self.bv))
_c += 1
self.addData(Paragraph(u(c[0][1]).replace('&', '&'), self.bf))
items = []
continue
values = []
for item in c:
if item[1].strip() != "":
values.append(item[1])
items.append(values)
for item in items:
try:
self.addData(Paragraph("[%s/%s]: %s" % (_c, len(children) - _head, ", ".join(item)), self.bv))
_c += 1
except:
self.addData(Paragraph("[%s/%s]: %s" % (_c, len(children) - _head, esc(", ".join(item))), self.bv))
def show_workflow_step(self, req):
access = acl.AccessData(req)
if not access.hasWriteAccess(self):
return "<i>" + t(lang(req), "permission_denied") + "</i>"
c = []
for item in self.getChildren():
c.append(
{
"id": str(item.id),
"creationtime": date.format_date(date.parse_date(item.get("creationtime")), "dd.mm.yyyy HH:MM:SS"),
"name": item.getName(),
}
)
c.sort(lambda x, y: cmp(x["name"], y["name"]))
return req.getTAL(
"workflow/workflow.html",
{
"children": c,
"workflow": self.getParents()[0],
"step": self,
"nodelink": "/mask?id=" + self.id + "&obj=",
"currentlang": lang(req),
},
macro="workflow_show",
)
def export(req):
p = req.path[1:].split("/")
if len(p) != 2:
req.error(404, "Object not found")
return
if p[0].isdigit():
try:
node = q(Data).get(p[0])
except:
return req.error(404, "Object not found")
else:
return req.error(404, "Object not found")
if not node.has_read_access():
req.write(t(req, "permission_denied"))
return
mask = node.metadatatype.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 NoResultFound:
return req.error(404, "Object not found")
else:
req.error(404, "Object not found")
return
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 view(req):
groups = list(loadGroupsFromDB())
order = getSortCol(req)
actfilter = getFilter(req)
# filter
if actfilter != "":
if actfilter in("all", t(lang(req), "admin_filter_all"), "*"):
None # all groups
elif actfilter == "0-9":
num = re.compile(r'([0-9])')
groups = filter(lambda x: num.match(x.getName()), groups)
elif actfilter == "else" or actfilter == t(lang(req), "admin_filter_else"):
all = re.compile(r'([a-z]|[A-Z]|[0-9])')
groups = filter(lambda x: not all.match(x.getName()), groups)
else:
groups = filter(lambda x: x.getName().lower().startswith(actfilter), groups)
pages = Overview(req, groups)
# sorting
if order != "":
if int(order[0:1]) == 0:
groups.sort(lambda x, y: cmp(x.getName().lower(), y.getName().lower()))
elif int(order[0:1]) == 1:
groups.sort(lambda x, y: cmp(getNumUsers(x.getName()), getNumUsers(y.getName())))
elif int(order[0:1]) == 2:
gl = {}
for g in groups:
gl[g.id] = g.getSchemas()
groups.sort(lambda x, y: cmp(len(gl[x.id]), len(gl[y.id])))
elif int(order[0:1]) == 3:
groups.sort(lambda x, y: cmp(x.getHideEdit() == "", y.getHideEdit() == ""))
if int(order[1:]) == 1:
groups.reverse()
# else:
# groups.sort(lambda x, y: cmp(x.getName().lower(),y.getName().lower()))
v = getAdminStdVars(req)
v["sortcol"] = pages.OrderColHeader([t(lang(req), "admin_usergroup_col_1"), t(lang(req), "admin_usergroup_col_2"), t(
lang(req), "admin_usergroup_col_3"), t(lang(req), "admin_usergroup_col_4")])
v["options"] = list(groupoption)
v["groups"] = groups
v["pages"] = pages
v["actfilter"] = actfilter
return req.getTAL("/web/admin/modules/usergroup.html", v, macro="view")
def build(self, style=1):
self.h1 = self.styleSheet['Heading1']
self.h1.fontName = 'Helvetica'
self.bv = self.styleSheet['BodyText']
self.bv.fontName = 'Helvetica'
self.bv.fontSize = 7
self.bv.spaceBefore = 0
self.bv.spaceAfter = 0
self.header = self.styleSheet['Heading3']
self.header.fontName = 'Helvetica'
self.data.append(Paragraph(translation.t(self.language, 'mediatumhelptitle'), self.h1))
self.data.append(Paragraph(self.path, self.bv))
self.data.append((FrameBreak()))
# format content
self.content = self.content.replace("\n", "")
repl = {'p': 'BodyText', 'h1': 'Heading1', 'h2': 'Heading2', 'h3': 'Heading3', 'h4': 'Heading4', 'h5': 'Heading5', 'li': 'Bullet'}
curstyle = "BodyText"
for item in re.split(r'<(p|h[1-5]|li)>|<(/p|/h[1-5]|/li)>', self.content):
if item and item != "":
if item in repl.keys():
curstyle = repl[item]
elif item[0] == "/" and item[1:] in repl.keys():
curstyle = ""
else:
if item.strip != "" and curstyle != "":
print 'add', item, "-->", curstyle
if curstyle == "Bullet":
item = "- " + item
print "bullet", item
self.data.append(Paragraph(item, self.styleSheet[curstyle]))
template = SimpleDocTemplate(config.get("paths.tempdir", "") + "help.pdf", showBoundary=0)
tFirst = PageTemplate(id='First', onPage=self.myPages, pagesize=defaultPageSize)
tNext = PageTemplate(id='Later', onPage=self.myPages, pagesize=defaultPageSize)
template.addPageTemplates([tFirst, tNext])
template.allowSplitting = 1
BaseDocTemplate.build(template, self.data)
template.canv.setAuthor(translation.t(self.language, "main_title"))
template.canv.setTitle("%s \n'%s' - %s: %s" % (translation.t(self.language, "edit_stats_header"),
'sdfsdfsdf', translation.t(self.language, "edit_stats_period_header"), '2003'))
return template.canv._doc.GetPDFData(template.canv)
def metaFields(self, lang=None):
metafields = Container.metaFields(self, lang=lang)
field = Metafield(u"style_hide_empty")
field.set("label", t(lang, "hide empty directories"))
field.set("type", u"check")
metafields.append(field)
return metafields
def show_workflow_notexist(self, node, req, template="workflow/workflow.html", macro="workflow_node"):
step = getNodeWorkflowStep(node)
link = ""
if step:
link = '/mask?id=%s&obj=%s' % (step.id, node.id)
return '<script language="javascript">document.location.href = "%s";</script> <a href="%s">%s</a>' % (link, link, step.name)
else:
return '<i>%s</i>' % (t(lang(req), "permission_denied"))
def show_workflow_node(self, node, req):
if "sendout" in req.params:
del req.params["sendout"]
if "from" in req.params:
node.set("system.mailtmp.from", req.params.get("from"))
if "to" in req.params:
node.set("system.mailtmp.to", req.params.get("to"))
if "subject" in req.params:
node.set("system.mailtmp.subject", req.params.get("subject"))
if "text" in req.params:
node.set("system.mailtmp.text", req.params.get("text"))
db.session.commit()
if(self.sendOut(node)):
return self.forwardAndShow(node, True, req)
if "gofalse" in req.params:
return self.forwardAndShow(node, False, req)
elif node.system_attrs.get("mailtmp.talerror", "") != "":
del node.system_attrs["mailtmp.talerror"]
db.session.commit()
self.runAction(node, "true")
if node.system_attrs.get("mailtmp.talerror", "") != "":
return """<pre>%s</pre>""" % node.system_attrs.get("mailtmp.talerror")
elif node.get("system.mailtmp.error"):
return '%s<br/><pre>%s</pre><br>><a href="%s">%s</a><' % (t(lang(req), "workflow_email_msg_1"), node.get(
"system.mailtmp.error"), req.makeSelfLink({"sendout": "true"}), t(lang(req), "workflow_email_resend"))
else:
xfrom = node.get("system.mailtmp.from")
to = node.get("system.mailtmp.to")
text = node.get("system.mailtmp.text")
subject = tal.getTALstr(node.get("system.mailtmp.subject"), {}, language=node.get("system.wflanguage"))
return req.getTAL("workflow/email.html", {"page": u"node?id={}&obj={}".format(self.id, node.id),
"from": xfrom,
"to": to,
"text": text,
"subject": subject,
"node": node,
"sendcondition": self.get("sendcondition"),
"wfnode": self,
"pretext": self.getPreText(lang(req)),
"posttext": self.getPostText(lang(req)),
"csrf": req.csrf_token.current_token,},
macro="sendmail")
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 popup_fullsize(self, req):
if not self.has_data_access() or not self.has_read_access():
req.write(t(req, "permission_denied"))
return
document = self.document
if document is not None:
req.sendFile(document.abspath, document.mimetype)
def show_attachmentbrowser(req):
nid = req.params.get("id")
node = q(Node).get(nid)
if not node.has_data_access():
req.write(t(req, "permission_denied"))
return
from core.attachment import getAttachmentBrowser
getAttachmentBrowser(node, req)
def setHeader(self, collection):
h1 = self.styleSheet['Heading1']
h1.fontName = 'Helvetica'
if not collection:
self.header = Paragraph(t(self.language, "print_view_header"), h1)
else:
p = Paragraph(t(self.language, collection.name), h1)
p.wrap(defaultPageSize[0], defaultPageSize[1])
self.headerWidth = p.getActualLineWidths0()[0]
self.header = p
self.addData(self.header)
self.addData(FrameBreak())
if len(collection.get("system.logo")) > 1:
for f in collection.getFiles():
fn = f.getName()
if fn.endswith(collection.get("system.logo")):
self.addImage(f.retrieveFile(), 1)
def metaFields(self, lang=None):
metafields = []
field = Metafield(u"nodename", attrs={
"label": t(lang, "node name"),
"type": u"text"
})
metafields.append(field)
return metafields
def getContent(req, ids):
user = users.getUserFromRequest(req)
access = AccessData(user=user)
language = lang(req)
node = tree.getNode(ids[0])
if not access.hasWriteAccess(node):
req.setStatus(httpstatus.HTTP_FORBIDDEN)
return req.getTAL("web/edit/edit.html", {}, macro="access_error")
if req.params.get("upload")=="uploadfile":
# try to import file
return import_new(req)
v = {"error":req.params.get("error")}
class SortChoice:
def __init__(self, label, value):
self.label = label
self.value = value
col = node
if "globalsort" in req.params:
col.set("sortfield", req.params.get("globalsort"))
v['collection_sortfield'] = col.get("sortfield")
sortfields = [SortChoice(t(req,"off"),"")]
if col.type not in ["root", "collections", "home"]:
for ntype, num in col.getAllOccurences(acl.AccessData(req)).items():
if ntype.getSortFields():
for sortfield in ntype.getSortFields():
sortfields += [SortChoice(sortfield.getLabel(), sortfield.getName())]
sortfields += [SortChoice(sortfield.getLabel()+t(req,"descending"), "-"+sortfield.getName())]
break
v['sortchoices'] = sortfields
v['ids'] = ids
v['count'] = len(node.getContentChildren())
v['nodelist'] = showdir(req, node)
v['language'] = lang(req)
v['t'] = t
_html = req.getTAL("web/edit/modules/imports.html", v, macro="upload_form")
return _html
def metaFields(self, lang=None):
field = tree.Node("mask", "metafield")
field.set("label", t(lang, "admin_wfstep_editor_mask"))
field.set("type", "text")
return [field]
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 action(req):
global editModules
language = lang(req)
user = current_user
trashdir = user.trash_dir
uploaddir = user.upload_dir
trashdir_parents = trashdir.parents
action = req.params.get("action", "")
changednodes = {}
if not user.is_editor:
req.write("""permission denied""")
req.setStatus(httpstatus.HTTP_FORBIDDEN)
return
if "tab" in req.params:
tab = req.params.get("tab").split("_")[-1]
return editModules[tab].getContent(req, [req.params.get("id")])
if action == "getlabels":
nids = req.params.get('ids', [])
nids = [nid.strip() for nid in nids.split(',') if nid.strip()]
for nid in set(nids + [_n.id for _n in [trashdir, uploaddir]]):
try:
changednodes[nid] = getTreeLabel(q(Node).get(nid), language)
except:
logg.exception(
"exception ignored: could not make fancytree label for node %s",
nid)
res_dict = {'changednodes': changednodes}
req.write(json.dumps(res_dict, indent=4, ensure_ascii=False))
return
else:
# all 'action's except 'getlabels' require a base dir (src)
# but expanding of a subdir in the edit-tree via fancytree has
# not a srcid, so no action is necessary
srcid = req.params.get("src")
if not srcid:
return
try:
src = q(Node).get(srcid)
except:
req.writeTAL("web/edit/edit.html", {"edit_action_error": srcid},
macro="edit_action_error")
return
if req.params.get('action') == 'addcontainer':
node = q(Node).get(srcid)
if not node.has_write_access():
# deliver errorlabel
req.writeTALstr('<tal:block i18n:translate="edit_nopermission"/>',
{})
return
# create new container
newnode_type = req.params.get('type')
if newnode_type in ['bare_collection', 'bare_directory']:
newnode_type = newnode_type.replace('bare_', '')
translated_label = t(lang(req), 'edit_add_' + newnode_type)
if translated_label.startswith('edit_add_'):
translated_label = t(lang(req),
'edit_add_container_default') + newnode_type
content_class = Node.get_class_for_typestring(newnode_type)
newnode = content_class(name=translated_label)
node.children.append(newnode)
newnode.set("creator", user.login_name)
newnode.set(
"creationtime",
unicode(
time.strftime('%Y-%m-%dT%H:%M:%S',
time.localtime(time.time()))))
newnode.set(
"nodename",
translated_label) # set attribute named "nodename" to label text
# place newnode at top of the children by setting the orderpos to the lowest orderpos - 1
# if the orderpos gets negative, shift the oderpos of all children by incrementing with a positive number
# make this number large enough, to avoid the next shifting of orderpos if more containers are added
if len(node.children) == 1:
# newnode is the only one child
newnode.orderpos = 1000
else:
newnode.orderpos = node.children[0].orderpos
newnode.orderpos = min([c.orderpos for c in node.children]) - 1
while newnode.orderpos < 0:
# in order to avoid negative orderpos, add a positive number to the orderpos of all children
# make this number large enough, so there is no shift of orderpos is necessary if the next
# container is added to the children
for c in node.children:
c.orderpos += 1000
db.session.commit()
req.params["dest"] = newnode.id
label = getTreeLabel(newnode, lang=language)
fancytree_nodedata = {
'title': label,
'key': newnode.id,
'isLazy': False,
'isFolder': True,
'icon': getEditorIconPath(newnode),
'readonly': 0,
'tooltip': '%s (%s)' % (label, newnode.id),
'children': [],
}
req.write(json.dumps(fancytree_nodedata, ensure_ascii=False))
logg.info("%s adding new container %s (%s) to %s (%s, %s)",
user.login_name, newnode.id, newnode.type, node.id,
node.name, node.type)
return
try:
destid = req.params.get("dest", None)
dest = q(Node).get(destid)
folderid = destid
except:
destid = None
dest = None
folderid = srcid
idlist = getIDs(req)
mysrc = None
errorobj = None
# try:
if action == "clear_trash":
for n in trashdir.children:
# if trashdir is it's sole parent, remove file from disk
# attn: this will not touch files from children of deleted
# containers
if len(n.parents) == 1:
logg.info(
"%s going to remove files from disk for node %s (%s, %s)",
user.login_name, n.id, n.name, n.type)
for f in n.files:
# dangerous ??? check this
f_path = f.abspath
if os.path.exists(f_path):
logg.info("%s going to remove file %r from disk",
user.login_name, f_path)
os.remove(f_path)
trashdir.children.remove(n)
db.session.commit()
dest = trashdir
changednodes[trashdir.id] = 1
_parent_descr = [(p.name, p.id, p.type) for p in trashdir_parents]
logg.info("%s cleared trash folder with id %s, child of %s",
user.login_name, trashdir.id, _parent_descr)
# return
else:
for id in idlist:
obj = q(Node).get(id)
mysrc = src
if isDirectory(obj) or isCollection(obj):
mysrc = obj.parents[0]
if action == "delete":
if mysrc.has_write_access() and obj.has_write_access():
if mysrc.id != trashdir.id:
mysrc.children.remove(obj)
changednodes[mysrc.id] = 1
trashdir.children.append(obj)
db.session.commit()
changednodes[trashdir.id] = 1
logg.info(
"%s moved to trash bin %s (%s, %s) from %s (%s, %s)",
user.login_name, obj.id, obj.name, obj.type,
mysrc.id, mysrc.name, mysrc.type)
dest = mysrc
else:
logg.info("%s has no write access for node %s",
user.login_name, mysrc.id)
req.writeTALstr(
'<tal:block i18n:translate="edit_nopermission"/>', {})
dest = mysrc
elif action in ["move", "copy"]:
if (dest != mysrc) and \
mysrc.has_write_access() and \
dest.has_write_access() and \
obj.has_write_access() and \
isinstance(dest, Container):
if not dest.is_descendant_of(obj):
if action == "move":
mysrc.children.remove(obj)
changednodes[mysrc.id] = 1 # getLabel(mysrc)
dest.children.append(obj)
changednodes[dest.id] = 1 # getLabel(dest)
db.session.commit()
if logg.isEnabledFor(logging.INFO):
_what = "%s %s %r (%s, %s) " % (user.login_name,
action, obj.id,
obj.name, obj.type)
_from = "from %s (%s, %s) " % (
mysrc.id, mysrc.name, mysrc.type)
_to = "to %s (%s, %s)" % (dest.id, dest.name,
dest.type)
logg.info(_what + _from + _to)
else:
logg.error("%s could not %s %s from %s to %s",
user.login_name, action, obj.id, mysrc.id,
dest.id)
else:
return
mysrc = None
if not mysrc:
mysrc = src
if action in ["move", "copy", "delete", "clear_trash"]:
for nid in changednodes:
try:
changednodes[nid] = getTreeLabel(q(Node).get(nid),
lang=language)
except:
logg.exception(
"exception ignored: could not make fancytree label for node %s",
nid)
res_dict = {'changednodes': changednodes}
req.write(json.dumps(res_dict, indent=4, ensure_ascii=False))
else:
try:
req.write(dest.id)
except:
req.write('no-node-id-specified (web.edit.edit.action)')
logg.exception(
'exception ignored, no-node-id-specified (web.edit.edit.action)'
)
return
return
filename = None
file_key = "m_upload_file_FOR_" + submitter
if file_key in req.params:
file = req.params[file_key]
del req.params[file_key]
filename = file.filename
filesize = file.filesize
filetempname = file.tempname
else:
msg = t(lang(req), "no file for this field submitted")
errors.append(msg)
if filename:
diskname = normalizeFilename(filename)
nodeFile = importFileToRealname(diskname,
filetempname,
prefix='m_upload_%s_' %
(submitter, ),
typeprefix="u_")
if not nodeFile:
msg = "metadata m_upload: could not create file node for request from '%s'" % (
ustr(req.ip))
errors.append(msg)
def frameset(req):
id = req.params.get("id", q(Collections).one().id)
page = int(req.params.get("page", 1))
nodes_per_page = req.params.get("nodes_per_page", "")
if nodes_per_page:
nodes_per_page = int(nodes_per_page)
sortfield = req.params.get("sortfield", "")
value = req.params.get("value", "")
tab = req.params.get("tab", None)
language = lang(req)
user = current_user
if not user.is_editor:
req.writeTAL("web/edit/edit.html", {}, macro="error")
req.writeTAL("web/edit/edit.html", {
"id": id,
"tab": (tab and "&tab=" + tab) or ""
},
macro="edit_notree_permission")
req.setStatus(httpstatus.HTTP_FORBIDDEN)
return
currentdir = q(Data).get(id)
if currentdir is None:
currentdir = q(Collections).one()
req.params["id"] = currentdir.id
id = req.params.get("id")
# use always the newest version
currentdir = currentdir.getActiveVersion()
if unicode(currentdir.id) != id:
req.params["id"] = unicode(currentdir.id)
id = req.params.get("id")
nodepath = []
n = currentdir
while n:
nodepath = [n] + nodepath
p = n.parents
if p:
n = p[0]
else:
n = None
path = ['%s' % p.id for p in nodepath]
containerpath = [('%s' % p.id) for p in nodepath
if isinstance(p, Container)]
spc = [Menu("sub_header_frontend", "../", target="_parent")]
if user.is_admin:
spc.append(
Menu("sub_header_administration", "../admin", target="_parent"))
if user.is_workflow_editor:
spc.append(Menu("sub_header_workflow", "../publish/",
target="_parent"))
spc.append(
Menu("sub_header_help",
"http://mediatum.readthedocs.io",
target="_blank"))
spc.append(Menu("sub_header_logout", "../logout", target="_parent"))
def getPathToFolder(node):
n = node
path = []
while n:
path = ['/%s' % n.id] + path
p = n.parents
if p:
n = p[0]
else:
n = None
return (node, "".join(path[2:]))
def _getIDPath(nid, sep="/", containers_only=True):
res = getIDPaths(nid, sep=sep, containers_only=containers_only)
return res
# does the user have a homedir? if not, create one
if user.home_dir is None:
user.create_home_dir()
db.session.commit()
logg.info("created new home dir for user #%s (%s)", user.id,
user.login_name)
folders = {
'homedir': getPathToFolder(user.home_dir),
'trashdir': getPathToFolder(user.trash_dir),
'uploaddir': getPathToFolder(user.upload_dir)
}
containertypes = Container.get_all_subclasses(
filter_classnames=("collections", "home", "container"))
if not user.is_admin:
# search all metadatatypes which are container
container_nodetype_names = [c.__name__.lower() for c in containertypes]
allowed_container_metadatanames = [
x[0] for x in q(Metadatatype.name).filter(
Metadatatype.name.in_(
container_nodetype_names)).filter_read_access()
]
# remove all elements from containertypes which names are not in container_metadatanames
new_containertypes = []
for ct in containertypes:
ct_name = ct.__name__
if ct_name.lower() in allowed_container_metadatanames:
new_containertypes += [ct]
containertypes = new_containertypes
cmenu_iconpaths = []
for ct in containertypes:
ct_name = ct.__name__
# translations of ct_name will be offered in editor tree context menu
cmenu_iconpaths.append([
ct_name.lower(),
t(language, ct_name),
get_editor_icon_path_from_nodeclass(ct)
])
homenodefilter = req.params.get('homenodefilter', '')
v = {
"id": id,
"page": page,
"nodes_per_page": nodes_per_page,
"sortfield": sortfield,
"value": value,
"searchitems": get_searchitems(req),
"tab": (tab and "&tab=" + tab) or "",
'user': user,
'spc': spc,
'folders': folders,
'collectionsid': q(Collections).one().id,
"basedirs": [q(Home).one(), q(Collections).one()],
'cmenu_iconpaths': cmenu_iconpaths,
'path': path,
'containerpath': containerpath,
'language': lang(req),
't': t,
'_getIDPath': _getIDPath,
'homenodefilter': homenodefilter,
}
req.writeTAL("web/edit/edit.html", v, macro="edit_main")
