def details(request):
""" ID Details page for a given ID """
d = {'menu_item': 'ui_manage.null'}
d["testPrefixes"] = uic.testPrefixes
identifier = request.path_info[len("/id/"):]
r = _getLatestMetadata(identifier,
request,
prefixMatch=(request.GET.get(
"prefix_match", "no").lower() == "yes"))
if type(r) is str:
django.contrib.messages.error(
request, uic.formatError(r + ": " + identifier))
# ToDo: Pass details in from previous screen so we know where to send redirect back to
if userauth.getUser(request) == None:
return redirect("ui_search.index")
else:
return redirect("ui_home.index")
s, id_metadata = r
assert s.startswith("success:")
if " in_lieu_of " in s:
newid = s.split()[1]
django.contrib.messages.info(
request,
"Identifier %s returned in lieu of %s." % (newid, identifier))
return redirect("/id/" + urllib.quote(newid, ":/"))
d['allow_update'] = policy.authorizeUpdateLegacy(
userauth.getUser(request, returnAnonymous=True), id_metadata["_owner"],
id_metadata["_ownergroup"])
d['identifier'] = id_metadata
d['id_text'] = s.split()[1]
d['id_as_url'] = util2.urlForm(d['id_text'])
d['is_test_id'] = _isTestId(d['id_text'], d['testPrefixes'])
d['internal_profile'] = metadata.getProfile('internal')
d['target'] = id_metadata['_target']
d['current_profile'] = metadata.getProfile(id_metadata['_profile']) or\
metadata.getProfile('erc')
d['recent_creation'] = identifier.startswith('doi') and \
(time.time() - float(id_metadata['_created']) < 60 * 30)
d['recent_update'] = identifier.startswith('doi') and \
(time.time() - float(id_metadata['_updated']) < 60 * 30)
if d['current_profile'].name == 'datacite' and 'datacite' in id_metadata:
r = datacite.dcmsRecordToHtml(id_metadata["datacite"])
if r:
d['datacite_html'] = r
if d['current_profile'].name == 'crossref' and 'crossref' in id_metadata and \
id_metadata['crossref'].strip() != "":
d['has_crossref_metadata'] = True
t_stat = [x.strip() for x in id_metadata['_status'].split("|", 1)]
d['pub_status'] = t_stat[0]
if t_stat[0] == 'unavailable' and len(t_stat) > 1:
d['stat_reason'] = t_stat[1]
if t_stat[0] == 'public' and identifier.startswith("ark:/"):
d['schemaDotOrgMetadata'] = _schemaDotOrgMetadata(
mapping.map(id_metadata), d['id_as_url'])
d['has_block_data'] = uic.identifier_has_block_data(id_metadata)
d['has_resource_type'] = True if (d['current_profile'].name == 'datacite' \
and 'datacite.resourcetype' in id_metadata \
and id_metadata['datacite.resourcetype'] != '') else False
return uic.render(request, "manage/details", d)
def _createAdvancedId(d, request, P):
""" Like _createSimpleId, but also checks for elements on advanced create page:
_status and _export variables; Adds datacite_xml if present. If no remainder
is supplied, simply mints an ID """
# ToDo: Clean this up
if d['current_profile'].name == 'datacite' and 'generated_xml' in d:
to_write = {
"_profile": 'datacite',
'_target': P['target'],
"_status": ("public" if P["publish"] == "True" else "reserved"),
"_export": ("yes" if P["export"] == "yes" else "no"),
"datacite": d['generated_xml'],
}
else:
to_write = uic.assembleUpdateDictionary(
request,
d['current_profile'],
{
'_target': P['target'],
"_status":
("public" if P["publish"] == "True" else "reserved"),
"_export": ("yes" if P["export"] == "yes" else "no"),
},
)
if P['remainder'] == '' or P[
'remainder'] == form_objects.REMAINDER_BOX_DEFAULT:
s = ezid.mintIdentifier(
P['shoulder'], userauth.getUser(request, returnAnonymous=True),
to_write)
else:
s = ezid.createIdentifier(
P['shoulder'] + P['remainder'],
userauth.getUser(request, returnAnonymous=True),
to_write,
)
if s.startswith("success:"):
new_id = s.split()[1]
django.contrib.messages.success(request, _("Identifier Created."))
d['id_gen_result'] = 'created_identifier: ' + new_id
else:
if "-" in s:
err_msg = re.search(r'^error: .+?- (.+)$', s).group(1)
else:
err_msg = re.search(r'^error: (.+)$', s).group(1)
django.contrib.messages.error(
request,
_("There was an error creating your identifier") + ": " + err_msg)
d['accordions_open'] = 'open'
d['id_gen_result'] = 'edit_page'
return d
def index(request):
""" Manage Page, listing all Ids owned by user, or if groupadmin, all group users """
d = {'menu_item': 'ui_manage.index'}
d['collapse_advanced_search'] = "collapsed"
if request.method != "GET":
return uic.methodNotAllowed(request)
noConstraintsReqd = True # Empty 'manage' form means search everything
d['q'] = ui_search.queryDict(request)
user = userauth.getUser(request)
d['owner_selected'] = (
_defaultUser(user)
if not ('owner_selected' in request.GET) or request.GET['owner_selected'] == ''
else request.GET['owner_selected']
)
d['form'] = form_objects.ManageSearchIdForm(d['q'])
# order_by and sort are initial sorting defaults. The request trumps these.
d['order_by'] = 'c_update_time'
d['sort'] = 'asc'
d['owner_names'] = uic.owner_names(user, "manage")
# Check if anything has actually been entered into search fields
searchfields = {
k: v
for k, v in d['q'].items()
if k not in [u'sort', u'ps', u'order_by', u'owner_selected']
}
searchfields = filter(None, searchfields.values())
if searchfields:
noConstraintsReqd = False
d[
'filtered'
] = True # Flag for template to provide option of searching on all IDs
d = ui_search.search(d, request, noConstraintsReqd, "manage")
return uic.render(request, 'manage/index', d)
def render(request, template, context={}):
global alertMessage, google_analytics_id, reload_templates
ctx = {
"session": request.session,
"authenticatedUser": userauth.getUser(request),
"alertMessage": alertMessage,
"feed_cache": newsfeed.getLatestItems(),
"google_analytics_id": google_analytics_id,
"debug": django.conf.settings.DEBUG,
}
ctx.update(context)
try:
templ = templates[template][0]
except (TypeError, LookupError):
templ = django.template.loader.get_template(templates[template][1])
# TODO: Remove this temporary workaround and modify dynamically generated HTML
# instead.
templ.backend.engine.autoescape = False
content = templ.render(ctx, request)
# By setting the content type ourselves, we gain control over the
# character encoding and can properly set the content length.
ec = content.encode("UTF-8")
r = django.http.HttpResponse(ec, content_type="text/html; charset=UTF-8")
r["Content-Length"] = len(ec)
return r
def download(request):
"""
Enqueue a batch download request and display link to user
"""
d = {'menu_item': 'ui_manage.null'}
q = django.http.QueryDict(
"format=csv&convertTimestamps=yes&compression=zip", mutable=True)
q.setlist('column', [
"_mappedTitle", "_mappedCreator", "_id", "_owner", "_created",
"_updated", "_status"
])
# In case you only want to download IDs based on owner selection:
# username = uic.getOwnerOrGroup(request.GET['owner_selected'])
# q['owner'] = ezidapp.models.StoreUser.objects.get(name=username)
user = userauth.getUser(request)
q['notify'] = d['mail'] = user.accountEmail
# ToDo make changes to download.enqueueRequest() to accept multiple groups
# if user.isRealmAdministrator: q['ownergroup'] = [g.groupname for g in user.realm.groups.all()]
if user.isGroupAdministrator: q['ownergroup'] = user.group.groupname
else: q['owner'] = user.username
s = ezid_download.enqueueRequest(user, q)
if not s.startswith("success:"):
django.contrib.messages.error(request, s)
return redirect("ui_manage.index")
else:
d['link'] = s.split()[1]
return uic.render(request, "manage/download", d)
def wrap(request, *args, **kwargs):
if userauth.getUser(request) == None:
django.contrib.messages.error(
request, _('You must be logged in to view this page.'))
return django.http.HttpResponseRedirect("/login?next=" +\
django.utils.http.urlquote(request.get_full_path()))
return f(request, *args, **kwargs)
def wrap(request, *args, **kwargs):
if not userauth.getUser(request, returnAnonymous=True).isSuperuser:
django.contrib.messages.error(
request,
_('You must be logged in as an administrator to view this page.'
))
return django.http.HttpResponseRedirect("/login?next=" +\
django.utils.http.urlquote(request.get_full_path()))
return f(request, *args, **kwargs)
def _getLatestMetadata(identifier, request, prefixMatch=False):
"""
The successful return is a pair (status, dictionary) where 'status' is a
string that includes the canonical, qualified form of the identifier, as in:
success: doi:10.5060/FOO
and 'dictionary' contains element (name, value) pairs.
"""
return ezid.getMetadata(
identifier, userauth.getUser(request, returnAnonymous=True), prefixMatch
)
def hasBrokenLinks(d, request):
"""
Flag if any IDs are found satisfying hasIssues=true and linkIsBroken=true
"""
user_id, group_id = uic.getOwnerOrGroup(d['owner_selected'] if 'owner_selected'\
in d else None)
c = _buildAuthorityConstraints(request, "issues", user_id, group_id)
c['hasIssues'] = True
c['linkIsBroken'] = True
return search_util.executeSearch(
userauth.getUser(request, returnAnonymous=True), c, 0, 1)
def dashboard(request):
"""
ID Issues and Crossref tables load for the first time w/o ajax
All subsequent searches are done via ajax (ajax_dashboard_table method below)
"""
d = {'menu_item': 'ui_admin.dashboard'}
user = userauth.getUser(request)
d['heading_user_display'] = user.displayName + "'s EZID " + _("Dashboard")
d['display_adminlink'] = user.isSuperuser
if request.method == "GET":
REQUEST = request.GET
elif request.method == "POST":
REQUEST = request.POST
else:
return uic.methodNotAllowed(request)
if not ('owner_selected' in REQUEST) or REQUEST['owner_selected'] == '':
d['owner_selected'] = (
None
if user.isSuperuser
else "realm_" + user.realm.name
if user.isRealmAdministrator
else "group_" + user.group.groupname
if user.isGroupAdministrator
else "user_" + user.username
)
else:
d['owner_selected'] = REQUEST['owner_selected']
d['owner_names'] = uic.owner_names(user, "dashboard")
d = _getUsage(REQUEST, user, d)
d['ajax'] = False
# Search: ID Issues
d = ui_search.search(d, request, NO_CONSTRAINTS, "issues")
# UI Tables need data named uniquely to distinguish them apart
d['results_issues'] = d['results']
d['total_pages_issues'] = d['total_pages']
d['field_display_types_issues'] = d['field_display_types']
d['fields_selected_issues'] = d['fields_selected']
d['has_broken_links'] = ui_search.hasBrokenLinks(d, request)
if d['has_broken_links']:
d['accountEmail'] = user.accountEmail
# Search: Crossref Submission Status
d = ui_search.search(d, request, NO_CONSTRAINTS, "crossref")
d['order_by'] = 'c_crossref_date'
d['sort'] = 'asc'
d['results_crossref'] = d['results']
d['total_pages_crossref'] = d['total_pages']
d['field_display_types_crossref'] = d['field_display_types']
d['fields_selected_crossref'] = d['fields_selected']
return uic.render(request, 'dashboard/index', d)
def ajax_dashboard_table(request):
if request.is_ajax():
user = userauth.getUser(request)
G = request.GET
d = {}
d['owner_selected'] = G[
'owner_selected'] if 'owner_selected' in G else user.username
d['p'] = G.get('p')
if 'name' in G and d['p'] is not None and d['p'].isdigit():
d['ajax'] = True
d['s_type'] = G['name']
d = ui_search.search(d, request, NO_CONSTRAINTS, G['name'])
return uic.render(request, "dashboard/_" + G['name'], d)
def advanced(request):
d = {'menu_item': 'ui_create.advanced'}
d["testPrefixes"] = uic.testPrefixes
user = userauth.getUser(request)
if user.isSuperuser:
shoulders = [
s for s in ezidapp.models.getAllShoulders() if not s.isTest
]
else:
shoulders = user.shoulders.all()
d["prefixes"] = sorted([{ "namespace": s.name, "prefix": s.prefix } for\
s in shoulders],
key=lambda p: ("%s %s" % (p["namespace"], p["prefix"])).lower())
if len(d['prefixes']) < 1:
return uic.render(request, 'create/no_shoulders', d)
d = adv_form(request, d)
return uic.renderIdPage(request, 'create/advanced', d)
def _createSimpleId(d, request, P):
s = ezid.mintIdentifier(
request.POST['shoulder'],
userauth.getUser(request, returnAnonymous=True),
uic.assembleUpdateDictionary(request, d['current_profile'], {
'_target': P['target'],
'_export': 'yes'
}))
if s.startswith("success:"):
new_id = s.split()[1]
django.contrib.messages.success(request, _("Identifier Created."))
d['id_gen_result'] = "created_identifier: " + new_id
else:
err = _("Identifier could not be created as submitted") + ": " + s
django.contrib.messages.error(request, err)
d['id_gen_result'] = 'edit_page'
return d
def _createSimpleId(d, request, P):
s = ezid.mintIdentifier(
request.POST["shoulder"],
userauth.getUser(request, returnAnonymous=True),
uic.assembleUpdateDictionary(request, d["current_profile"], {
"_target": P["target"],
"_export": "yes"
}),
)
if s.startswith("success:"):
new_id = s.split()[1]
django.contrib.messages.success(request, _("Identifier Created."))
d["id_gen_result"] = "created_identifier: " + new_id
else:
err = _("Identifier could not be created as submitted") + ": " + s
django.contrib.messages.error(request, err)
d["id_gen_result"] = "edit_page"
return d
def _buildAuthorityConstraints(request,
s_type="public",
owner=None,
ownergroup=None):
"""
A logged in user can use (public) Search page, but this would not limit the
results to just their IDs. It would also include all public IDs.
owner = username of owner; ownergroup = group name
"""
if s_type == "public" or userauth.getUser(request) == None:
c = {'publicSearchVisible': True}
else:
assert owner or ownergroup, "Owner information missing"
c = {
'owner': owner
} if (ownergroup == None) else {
'ownergroup': ownergroup
}
return c
def _updateEzid(request, d, stts, m_to_upgrade=None):
"""
Takes data from form fields in /manage/edit and applies them to IDs metadata
If m_to_upgrade is specified, converts record to advanced datacite
Returns ezid.setMetadata (successful return is the identifier string)
Also removes tags related to old profile if converting to advanced datacite
"""
m_dict = {
'_target': request.POST['target'],
'_status': stts,
'_export': ('yes' if
(not 'export' in d) or d['export'] == 'yes' else 'no')
}
if m_to_upgrade:
d['current_profile'] = metadata.getProfile('datacite')
# datacite_xml ezid profile is defined by presence of 'datacite' assigned to the
# '_profile' key and XML present in the 'datacite' key
m_dict['datacite'] = datacite.formRecord(d['id_text'], m_to_upgrade,
True)
m_dict['_profile'] = 'datacite'
# Old tag cleanup
if m_to_upgrade.get("_profile", "") == "datacite":
m_dict['datacite.creator'] = ''
m_dict['datacite.publisher'] = ''
m_dict['datacite.publicationyear'] = ''
m_dict['datacite.title'] = ''
m_dict['datacite.type'] = ''
if m_to_upgrade.get("_profile", "") == "dc":
m_dict['dc.creator'] = ''
m_dict['dc.date'] = ''
m_dict['dc.publisher'] = ''
m_dict['dc.title'] = ''
m_dict['dc.type'] = ''
if m_to_upgrade.get("_profile", "") == "erc":
m_dict['erc.who'] = ''
m_dict['erc.what'] = ''
m_dict['erc.when'] = ''
# ToDo: Using current_profile here, but isn't this confusing if executing simpleToAdvanced
to_write = uic.assembleUpdateDictionary(request, d['current_profile'],
m_dict)
return ezid.setMetadata(d['id_text'],
userauth.getUser(request, returnAnonymous=True),
to_write)
def render(request, template, context={}):
global alertMessage, google_analytics_id, reload_templates
c = {
"session": request.session,
"authenticatedUser": userauth.getUser(request),
"alertMessage": alertMessage,
"feed_cache": newsfeed.getLatestItems(),
"google_analytics_id": google_analytics_id,
"debug": django.conf.settings.DEBUG
}
c.update(context)
#this is to keep from having to restart the server every 3 seconds
#to see template changes in development, only reloads if set for optimal performance
if reload_templates:
templ = django.template.loader.get_template(templates[template][1])
else:
templ = templates[template][0]
content = templ.render(django.template.RequestContext(request, c))
# By setting the content type ourselves, we gain control over the
# character encoding and can properly set the content length.
ec = content.encode("UTF-8")
r = django.http.HttpResponse(ec, content_type="text/html; charset=UTF-8")
r["Content-Length"] = len(ec)
return r
def csvStats(request):
"""
Returns all statistics to which a user is entitled as a CSV file.
'requestor' is the user, and should be a StoreUser object. The
statistics include those for the requestor; and all users (if the
requestor is a superuser) or all users in the requestor's realm (if
the requestor is a realm administrator) or all users in the
requestor's group (if the requestor is a group administrator); plus
any users the requestor is a proxy for. The CSV file is returned as
a single string. The columns are:
owner
ownergroup
month
ARKs with metadata
ARKs without metadata
total ARKs
DOIs with metadata
DOIs without metadata
total DOIs
Rows are grouped by user; the order of users in the CSV file is
undefined. For a given user, rows are ordered by month, and the
rows are complete with respect to the range of months, as described
in stats.Stats.getTable().
"""
requestor = userauth.getUser(request)
users = set([requestor])
if requestor.isSuperuser:
for u in ezidapp.models.StoreUser.objects.all():
users.add(u)
elif requestor.isRealmAdministrator:
for g in requestor.realm.groups.all():
for u in g.users.all():
users.add(u)
elif requestor.isGroupAdministrator:
for u in requestor.group.users.all():
users.add(u)
for u in requestor.proxy_for.all():
users.add(u)
f = StringIO.StringIO()
w = csv.writer(f)
w.writerow(
[
"owner",
"ownergroup",
"month",
"ARKs with metadata",
"ARKs without metadata",
"ARKs total",
"DOIs with metadata",
"DOIs without metadata",
"DOIs total",
]
)
for u in users:
for r in stats.getTable(owner=u.pid):
outputRow = [u.username, u.group.groupname, r[0]]
for type in ["ARK", "DOI"]:
t = 0
for hasMetadata in [True, False]:
v = r[1].get((type, hasMetadata), 0)
outputRow.append(str(v))
t += v
outputRow.append(str(t))
w.writerow(outputRow)
fn = "EZID_" + requestor.username + datetime.now().strftime("%Y%m%d-%H%M%S")
return uic.csvResponse(f.getvalue(), fn)
def tombstone(request):
"""
Renders a tombstone (i.e., unavailable identifier) page.
"""
if request.method != "GET": return uic.methodNotAllowed(request)
assert request.path_info.startswith("/tombstone/id/")
id = request.path_info[14:]
if "auth" in request.session:
r = ezid.getMetadata(id, userauth.getUser(request,
returnAnonymous=True))
else:
r = ezid.getMetadata(id)
if type(r) is str:
messages.error(request, uic.formatError(r))
return uic.redirect("/")
s, m = r
assert s.startswith("success:")
id = s[8:].strip()
if not m["_status"].startswith("unavailable"):
return uic.redirect("/id/%s" % urllib.quote(id, ":/"))
status = m["_status"]
reason = tombstone_text
if "|" in m["_status"]:
status = m["_status"].split("|", 1)[0].strip()
# Translators: Output for tombstone page (unavailable IDs)
reason += " " + _("Reason:") + " " + m["_status"].split("|",
1)[1].strip()
htmlMode = False
if m["_profile"] == "datacite" and "datacite" in m:
md = datacite.dcmsRecordToHtml(m["datacite"])
if md:
htmlMode = True
root = lxml.etree.fromstring(md)
# Tack on an additional row displaying status
row = lxml.etree.Element("tr", attrib={"class": "dcms_element"})
c1 = lxml.etree.SubElement(row,
"th",
attrib={"class": "dcms_label"})
c1.text = _("Status:")
c2 = lxml.etree.SubElement(row,
"td",
attrib={"class": "dcms_value"})
c2.text = status
root.append(row)
md = lxml.etree.tostring(root)
if not htmlMode:
# This echoes the Merritt hack above.
if m["_profile"] == "erc" and m.get("erc", "").strip() != "":
md = [{"label": "ERC", "value": m["erc"].strip()}]
else:
p = metadata.getProfile(m["_profile"])
if not p: p = metadata.getProfile("erc")
md = []
for e in p.elements:
if "." not in e.name: continue
v = m.get(e.name, "").strip()
md.append({
"label": e.displayName,
"value": v if v != "" else "(no value)"
})
# Tack on an additional row displaying status
md.append({"label": _("Status"), "value": status})
return uic.render(
request, "tombstone", {
"identifier": id,
"identifierLink": "/id/%s" % urllib.quote(id, ":/"),
"reason": reason,
"htmlMode": htmlMode,
"metadata": md
})
def search(d, request, noConstraintsReqd=False, s_type="public"):
"""
Run query and organize result set for UI, used for Search, Manage, and Dashboard pages.
* noConstraintsReqd==True is used by pages that don't require form validation (dashboard, and
manage page, whose form is unbound/unvalidated if nothing has been entered/posted.
* If s_type=="public", don't include owner credentials in constraints.
* 'filtered' means form fields have been submitted w/a search request
(useful to know this for the manage page)
* use owner or ownergroup, not both, otherwise ownergroup takes precedence
"""
d['REQUEST'] = request.GET
d = _pageLayout(d, request.GET, s_type)
if noConstraintsReqd or 'form' in d and d['form'].is_valid():
# Build dictionary of search constraints
user_id, group_id = uic.getOwnerOrGroup(d['owner_selected'] if 'owner_selected'\
in d else None)
c = _buildAuthorityConstraints(request, s_type, user_id, group_id)
if s_type in ('public', 'manage'):
d['queries_urlencoded'] = queryUrlEncoded(
request) # Used for Google Analytics
q = d['q'] if 'q' in d and d['q'] else request.GET
q2 = {}
for k, v in q.iteritems():
q2[k] = q[k].strip() if isinstance(v, basestring) else q[k]
# Move searches for IDs in keyword field to identifier field. I wanted to put this in
# form's clean() function but unable to modify field values that route. I think I need to
# explicitly override the form's __init__ method
if 'keywords' in q2:
kw = re.sub('[\"\']', '', q2['keywords'])
if kw.lower().startswith(("doi:", "ark:/", "uuid:")) and \
(' ' not in kw) and uic.isEmptyStr(q2.get('identifier','')):
q2['keywords'] = ''
q2['identifier'] = kw
if d['filtered']:
c = _buildConstraints(c, q2, s_type)
c = _buildTimeConstraints(c, q2, s_type)
elif s_type == 'issues':
d['sort'] = 'asc' # Default sort is on update_time descending
c['hasIssues'] = True
c['crossref'] = False
elif s_type == 'crossref':
d['sort'] = 'asc'
c['crossref'] = True
c['crossrefStatus'] = [
ezidapp.models.Identifier.CR_RESERVED,
ezidapp.models.Identifier.CR_WORKING,
ezidapp.models.Identifier.CR_WARNING,
ezidapp.models.Identifier.CR_FAILURE
]
d['total_results'] = search_util.executeSearchCountOnly(
userauth.getUser(request, returnAnonymous=True), c)
d['total_results_str'] = format(d['total_results'], "n")
d['total_pages'] = int(
math.ceil(float(d['total_results']) / float(d['ps'])))
if d['p'] > d['total_pages']: d['p'] = d['total_pages']
d['p'] = max(d['p'], 1)
if d['order_by']:
orderColumn = FIELDS_MAPPED[d['order_by']][0]
if IS_ASCENDING[d['sort']]: orderColumn = "-" + orderColumn
else:
orderColumn = None
d['results'] = []
rec_beg = (d['p'] - 1) * d['ps']
rec_end = d['p'] * d['ps']
for id in search_util.executeSearch(
userauth.getUser(request, returnAnonymous=True), c, rec_beg,
rec_end, orderColumn):
if s_type in ('public', 'manage'):
result = {
"c_create_time": id.createTime,
"c_identifier": id.identifier,
"c_title": _truncateStr(id.resourceTitle),
"c_creator": _truncateStr(id.resourceCreator),
"c_owner": id.owner.username,
"c_object_type": id.resourceType,
"c_publisher": _truncateStr(id.resourcePublisher),
"c_pubyear": _truncateStr(id.resourcePublicationDate),
"c_id_status": id.get_status_display(),
"c_update_time": id.updateTime,
}
if id.isUnavailable and id.unavailableReason != "":
result["c_id_status"] += " | " + id.unavailableReason
elif s_type == 'issues':
result = {
"c_identifier": id.identifier,
"c_id_issue": "",
"c_title": _truncateStr(id.resourceTitle),
"c_update_time": id.updateTime,
}
ir = id.issueReasons()
if ir:
result["c_id_issue"] += "; ".join(ir)
elif s_type == 'crossref':
result = {
"c_identifier": id.identifier,
"c_crossref_date": id.createTime,
"c_crossref_descr": id.get_crossrefStatus_display(),
}
if id.isCrossrefGood and id.crossrefStatus in [
id.CR_WORKING, id.CR_RESERVED
]:
result["c_crossref_msg"] = _("No action necessary")
else:
result["c_crossref_msg"] = id.crossrefMessage
d['results'].append(result)
# end of result iteration loop
if s_type == "public":
rec_range = '0'
if d['total_results'] > 0:
rec_range = str(rec_beg + 1) + " " + _("to") + " " +\
str(min(rec_end, d['total_results'])) + " " + _("of") + " " + d['total_results_str']
d['heading_title'] = _("Showing") + " " + rec_range + " " + _(
"Search Results")
d['search_query'] = _buildQuerySyntax(c)
else:
if d['filtered']:
d['heading_title'] = d['total_results_str'] + " " + _(
"matches found")
else:
d['heading_title'] = _(
"Your Identifiers") + " (" + d['total_results_str'] + ")"
d['search_success'] = True
else: # Form did not validate
d['collapse_advanced_search'] = "" # Open up adv. search html block
if '__all__' in d['form'].errors:
# non_form_error, probably due to all fields being empty
all_errors = ''
errors = d['form'].errors['__all__']
for e in errors:
all_errors += e
django.contrib.messages.error(
request,
_("Could not complete search.") + " " + all_errors)
else:
err = _(
"Could not complete search. Please check the highlighted fields below for details."
)
django.contrib.messages.error(request, err)
d['search_success'] = False
return d
def edit(request, identifier):
""" Edit page for a given ID """
d = {'menu_item': 'ui_manage.null'}
d["testPrefixes"] = uic.testPrefixes
r = _getLatestMetadata(identifier, request)
if type(r) is str:
django.contrib.messages.error(request, uic.formatError(r))
return redirect("ui_manage.index")
s, id_metadata = r
if not policy.authorizeUpdateLegacy(
userauth.getUser(request, returnAnonymous=True),
id_metadata["_owner"],
id_metadata["_ownergroup"],
):
django.contrib.messages.error(
request,
_(
"You are not allowed to edit this identifier. "
+ "If this ID belongs to you and you'd like to edit, please log in."
),
)
return redirect("/id/" + urllib.quote(identifier, ":/"))
d['identifier'] = id_metadata
t_stat = [x.strip() for x in id_metadata['_status'].split("|", 1)]
d['pub_status'] = t_stat[0]
d['orig_status'] = t_stat[0]
d['stat_reason'] = None
if t_stat[0] == 'unavailable' and len(t_stat) > 1:
d['stat_reason'] = t_stat[1]
d['export'] = id_metadata['_export'] if '_export' in id_metadata else 'yes'
d['id_text'] = s.split()[1]
d['id_as_url'] = util2.urlForm(d['id_text'])
d['internal_profile'] = metadata.getProfile('internal')
d['profiles'] = metadata.getProfiles()[1:]
if request.method == "GET":
d['is_test_id'] = _isTestId(d['id_text'], d['testPrefixes'])
if '_profile' in id_metadata:
d['current_profile'] = metadata.getProfile(id_metadata['_profile'])
else:
d['current_profile'] = metadata.getProfile('dc')
if d['current_profile'].name == 'datacite' and 'datacite' in id_metadata:
d = _assignManualTemplate(d)
# Testing
# xml = datacite_xml.temp_mockxml()
# form_coll = datacite_xml.dataciteXmlToFormElements(xml)
form_coll = datacite_xml.dataciteXmlToFormElements(
d['identifier']['datacite']
)
# This is the only item from internal profile that needs inclusion in django form framework
form_coll.nonRepeating['target'] = id_metadata['_target']
d['form'] = form_objects.getIdForm_datacite_xml(form_coll, request)
if not form_objects.isValidDataciteXmlForm(d['form']):
django.contrib.messages.error(request, FORM_VALIDATION_ERROR_ON_LOAD)
else:
if "form_placeholder" not in d:
d['form_placeholder'] = None
d['form'] = form_objects.getIdForm(
d['current_profile'], d['form_placeholder'], id_metadata
)
if not d['form'].is_valid():
django.contrib.messages.error(request, FORM_VALIDATION_ERROR_ON_LOAD)
elif request.method == "POST":
P = request.POST
d['pub_status'] = P['_status'] if '_status' in P else d['pub_status']
d['stat_reason'] = P['stat_reason'] if 'stat_reason' in P else d['stat_reason']
d['export'] = P['_export'] if '_export' in P else d['export']
''' Profiles could previously be switched in edit template, thus generating
posibly two differing profiles (current vs original). So we previously did a
check here to confirm current_profile equals original profile before saving.'''
d['current_profile'] = metadata.getProfile(
P.get('original_profile', d['identifier']['_profile'])
)
if P['_status'] == 'unavailable':
stts = P['_status'] + " | " + P['stat_reason']
else:
stts = P['_status']
if d['current_profile'].name == 'datacite' and 'datacite' in id_metadata:
d = _assignManualTemplate(d)
d = ui_create.validate_adv_form_datacite_xml(request, d)
if 'id_gen_result' in d:
return uic.render(request, 'manage/edit', d) # ID Creation page
else:
assert 'generated_xml' in d
to_write = {
"_profile": 'datacite',
'_target': P['target'],
"_status": stts,
"_export": d['export'],
"datacite": d['generated_xml'],
}
s = ezid.setMetadata(
P['identifier'],
userauth.getUser(request, returnAnonymous=True),
to_write,
)
if s.startswith("success:"):
_alertMessageUpdateSuccess(request)
return redirect("/id/" + urllib.quote(identifier, ":/"))
else:
_alertMessageUpdateError(request, s)
else:
""" Even if converting from simple to advanced, let's make sure forms validate
and update identifier first, else don't upgrade.
"""
d['form'] = form_objects.getIdForm(d['current_profile'], None, P)
if d['form'].is_valid():
result = _updateEzid(request, d, stts)
if not result.startswith("success:"):
d['current_profile'] = metadata.getProfile(id_metadata['_profile'])
_alertMessageUpdateError(request, result)
return uic.render(request, "manage/edit", d)
else:
if 'simpleToAdvanced' in P and P['simpleToAdvanced'] == 'True':
# Convert simple ID to advanced (datacite with XML)
result = _updateEzid(request, d, stts, id_metadata)
r = _getLatestMetadata(identifier, request)
if type(r) is str:
django.contrib.messages.error(request, uic.formatError(r))
return redirect("ui_manage.index")
s, id_metadata = r
if not result.startswith("success:"):
# if things fail, just display same simple edit page with error
_alertMessageUpdateError(request, result)
else:
_alertMessageUpdateSuccess(request)
return redirect("/id/" + urllib.quote(identifier, ":/"))
else:
_alertMessageUpdateSuccess(request)
return redirect("/id/" + urllib.quote(identifier, ":/"))
else:
return uic.methodNotAllowed(request)
return uic.render(request, "manage/edit", d)
def edit(request):
"""Edit account information form"""
d = {'menu_item': 'ui_account.edit'}
user = userauth.getUser(request)
d["username"] = user.username
proxies_orig = [
u.username for u in user.proxies.all().order_by("username")
]
pusers = {u.username: u.displayName for u in\
allUsersInRealm(user) if u.displayName != user.displayName}
d['proxy_users_choose'] = sorted(pusers.items(),
key=operator.itemgetter(0))
if request.method == "GET":
d['primaryContactName'] = user.primaryContactName
d['primaryContactEmail'] = user.primaryContactEmail
d['primaryContactPhone'] = user.primaryContactPhone
d['secondaryContactName'] = user.secondaryContactName
d['secondaryContactEmail'] = user.secondaryContactEmail
d['secondaryContactPhone'] = user.secondaryContactPhone
d['accountDisplayName'] = user.displayName
d['accountEmail'] = user.accountEmail
d['crossrefEmail'] = user.crossrefEmail
proxy_for_list = user.proxy_for.all().order_by("username")
d['proxy_for'] = "<br/> ".join("[" + u.username + "] " + u.displayName \
for u in proxy_for_list) if proxy_for_list else "None"
d['proxies_default'] = proxies_default
d['proxy_users_picked_list'] = json.dumps(proxies_orig)
d['proxy_users_picked'] = ', '.join(
proxies_orig if proxies_orig else [proxies_default])
d['form'] = form_objects.UserForm(d,
user=user,
username=d['username'],
pw_reqd=False)
elif request.method == "POST":
d['form'] = form_objects.UserForm(request.POST,
initial=d,
user=user,
username=d['username'],
pw_reqd=False)
basic_info_changed = False
newProxies = None
if d['form'].is_valid():
if d['form'].has_changed():
basic_info_changed = any(ch in d['form'].changed_data
for ch in ACCOUNT_FIELDS_EDITABLE)
if request.POST['proxy_users_picked'] not in [
"", proxies_default
]:
newProxies = _getNewProxies(user, proxies_orig, [x.strip() for x in\
request.POST['proxy_users_picked'].split(",")])
_update_edit_user(request, user, newProxies, basic_info_changed)
else: # Form did not validate
if '__all__' in d['form'].errors:
# non_form_error, probably due to all fields being empty
all_errors = ''
errors = d['form'].errors['__all__']
for e in errors:
all_errors += e
messages.error(
request,
_("Change(s) could not be made. ") + all_errors)
else:
err = _(
"Change(s) could not be made. Please check the highlighted field(s) below for details."
)
messages.error(request, err)
else:
return uic.methodNotAllowed(request)
return uic.render(request, "account/edit", d)
