def login(request):
"""
Renders the login page (GET) or processes a login form submission
(POST). A successful login redirects to the URL specified by
?next=... or, failing that, the home page.
"""
d = {"menu_item": "ui_null.null"}
if request.method == "GET":
if "next" in request.GET:
try:
m = django.core.urlresolvers.resolve(request.GET["next"])
if m.app_name == "admin":
messages.error(
request,
_("You must be logged in as an administrator to view this page."
),
)
except django.core.urlresolvers.Resolver404:
pass
d["next"] = request.GET["next"]
else:
d["next"] = django.core.urlresolvers.reverse("ui_home.index")
return uic.render(request, "account/login", d)
elif request.method == "POST":
if ("username" not in request.POST or "password" not in request.POST
or "next" not in request.POST):
return uic.badRequest(request)
d.update(uic.extract(request.POST, ["username", "password", "next"]))
user = userauth.authenticate(d["username"], d["password"], request)
if type(user) is str:
messages.error(request, uic.formatError(user))
return uic.render(request, "account/login", d)
if user != None:
# 'extra_tags' used for recording a Google Analytics event
messages.add_message(
request,
messages.SUCCESS,
_("Login successful."),
extra_tags='Accounts Submit Login',
)
if django.utils.http.is_safe_url(url=d["next"],
host=request.get_host()):
return redirect(d["next"])
else:
return redirect("ui_home.index")
else:
messages.error(request, _("Login failed."))
return uic.render(request, "account/login", d)
else:
return uic.methodNotAllowed(request)
def results(request):
""" Display different page or columns from search results page """
d = {'menu_item': 'ui_search.results'}
d['q'] = queryDict(request)
d['form'] = form_objects.BaseSearchIdForm(d['q'])
d = search(d, request)
return uic.render(request, 'search/results', 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 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 contact(request):
d = {'menu_item': 'ui_null.contact'}
localized = False
host = request.META.get("HTTP_HOST", "default")
if host not in django.conf.settings.LOCALIZATIONS: host = "default"
if host != "default":
localized = True
if request.method == "POST":
P = request.POST
d['form'] = form_objects.ContactForm(P, localized=localized)
if (not 'url' in P or ('url' in P and P['url'] != '')) or (
P['question'] and not re.match("(2|two)", P['question'])):
#url is hidden. If it's filled in then probably a spam bot
pass
elif d['form'].is_valid():
emails = __emails(request)
title = "EZID contact form email"
if 'HTTP_REFERER' in request.META:
message = 'Sent FROM: ' + request.META[
'HTTP_REFERER'] + "\r\n\r\n"
else:
message = ''
message += "Name: " + P['your_name'] + "\r\n\r\n" + \
"Email: " + P['email'] + "\r\n\r\n"
if 'affiliation' in P:
message += "Institution: " + P['affiliation'] + "\r\n\r\n"
message += "Reason for contact: " + P['contact_reason'] + "\r\n\r\n" + \
"Comment:\r\n" + P['comment'] + "\r\n\r\n" + \
"Heard about from: " + P['hear_about'] + "\r\n\r\n"
if 'newsletter' in P:
if P['newsletter'] == 'on':
message += "YES, I'd like to subscribe to the EZID newsletter."
else:
message += "Newsletter option NOT checked."
try:
django.core.mail.send_mail(title, message, P['email'], emails)
# 'extra_tags' used for recording a Google Analytics event
messages.add_message(
request,
messages.SUCCESS,
_("Thank you for your message. We will respond as soon as possible."
),
extra_tags='Forms Submit Contact')
d['form'] = form_objects.ContactForm() # Build an empty form
except:
messages.error(request,
_("There was a problem sending your email"))
elif not d['form'].is_valid():
err = _(
"Form could not be sent. Please check the highlighted field(s) below for details."
)
messages.error(request, err)
# fall through to re-render page; form already contains error info
elif request.method == "GET":
d['form'] = form_objects.ContactForm(
None, localized=localized) # Build an empty form
else:
return uic.methodNotAllowed(request)
return uic.render(request, 'contact', d)
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 no_menu(request, template_name):
if request.method != "GET": return uic.methodNotAllowed(request)
d = {'menu_item': 'ui_home.null'}
try:
loader.get_template('info/' + template_name + ".html")
except:
return uic.error(request, 404)
return uic.render(request, 'info/' + template_name, d)
def index(request):
""" (Public) Search Page """
if request.method != "GET":
return uic.methodNotAllowed(request)
d = {'menu_item': 'ui_search.index'}
d['collapse_advanced_search'] = "collapsed"
d['q'] = queryDict(request)
d['form'] = form_objects.BaseSearchIdForm(d['q'])
# if users are coming back to an advanced search, auto-open adv. search block
if 'modify_search' in d['q'] and d['q']['modify_search'] == 't':
if 'keywords' in d['q'] and d['q']['keywords'].strip() == '':
d['collapse_advanced_search'] = "" # Leaving this empty actually opens advanced search block
else:
if d['q']:
d['p'] = 1
d = search(d, request)
if d['search_success'] == True:
d['REQUEST'] = request.GET
return uic.render(request, 'search/results', d)
return uic.render(request, 'search/index', d)
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 index(request):
if request.method not in ["GET", "POST"]:
return uic.methodNotAllowed(request)
d = {'menu_item': 'ui_home.index'}
d['prefixes'] = sorted(uic.testPrefixes,
key=lambda p: p['namespace'].lower())
d['form_placeholder'] = True
d = ui_create.simple_form(request, d)
result = d['id_gen_result']
if result == 'edit_page':
return uic.render(request, 'index', d) # ID Creation page
elif result == 'bad_request':
return uic.badRequest(request)
elif result.startswith('created_identifier:'):
return redirect(
"/id/" + urllib.quote(result.split()[1], ":/")) # ID Details page
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 doc(request):
"""
Renders UTF-8 encoded HTML documentation and plain text Python code
files.
"""
if request.method != "GET": return uic.methodNotAllowed(request)
assert request.path_info.startswith("/doc/")
file = request.path_info[5:]
path = os.path.join(django.conf.settings.PROJECT_ROOT, "templates", "doc",
file)
if os.path.exists(path):
if file.endswith(".html"):
return uic.render(request, os.path.join("doc", file[:-5]),
{"menu_item": "ui_home.learn"})
else:
f = open(path)
content = f.read()
f.close()
return uic.staticTextResponse(content)
else:
return uic.error(request, 404)
def open_source(request):
if request.method != "GET": return uic.methodNotAllowed(request)
d = {'menu_item': 'ui_home.learn'}
return uic.render(request, 'info/open_source', d)
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 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 pwreset(request, pwrr):
"""
Handles all GET and POST interactions related to password resets.
"""
if pwrr: # Change password here after receiving email
d = {'menu_item': 'ui_null.null'}
r = decodePasswordResetRequest(pwrr)
if not r:
messages.error(request, _("Invalid password reset request."))
return uic.redirect("/")
username, t = r
if int(time.time()) - t >= 24 * 60 * 60:
messages.error(request, _("Password reset request has expired."))
return uic.redirect("/")
d['pwrr'] = pwrr
if request.method == "GET":
d['username'] = username
d['form'] = form_objects.BasePasswordForm(None,
username=username,
pw_reqd=True)
elif request.method == "POST":
if "pwnew" not in request.POST or "pwconfirm" not in request.POST:
return uic.badRequest(request)
password = request.POST["pwnew"]
d['form'] = form_objects.BasePasswordForm(request.POST,
username=username,
pw_reqd=True)
if not d['form'].is_valid():
err = _(
"Changes could not be made. Please check the highlighted field(s) below for details."
)
messages.error(request, err)
else:
user = ezidapp.models.getUserByUsername(username)
if user == None or user.isAnonymous:
messages.error(request, _("No such user."))
return uic.render(request, "account/pwreset2", d)
with django.db.transaction.atomic():
user.setPassword(password)
user.save()
ezidapp.admin.scheduleUserChangePostCommitActions(user)
messages.success(request, _("Password changed."))
return uic.redirect("/")
else:
return uic.methodNotAllowed(request)
return uic.render(request, "account/pwreset2", d)
else:
# First step: enter your username and email to get sent an email containing link for password change
d = {'menu_item': 'ui_null.null'}
if request.method == "GET":
d['form'] = form_objects.PwResetLandingForm()
return uic.render(request, "account/pwreset1", d)
elif request.method == "POST":
P = request.POST
if "username" not in P or "email" not in P:
return uic.badRequest(request)
username = P["username"].strip()
email = P["email"].strip()
d['form'] = form_objects.PwResetLandingForm(P)
if not d['form'].is_valid():
return uic.render(request, "account/pwreset1", d)
else:
r = sendPasswordResetEmail(username, email)
if type(r) in (str, unicode):
messages.error(request, r)
return uic.render(request, "account/pwreset1", d)
else:
messages.success(request, _("Email sent."))
return uic.redirect("/")
else:
return uic.methodNotAllowed(request)
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)
def learn(request):
if request.method != "GET": return uic.methodNotAllowed(request)
d = {'menu_item': 'ui_home.learn'}
return uic.render(request, 'learn', d)
def crossref_faq(request):
if request.method != "GET": return uic.methodNotAllowed(request)
d = {'menu_item': 'ui_home.learn'}
return uic.render(request, 'info/crossref_faq', d)
def doi_services_faq(request):
if request.method != "GET": return uic.methodNotAllowed(request)
d = {'menu_item': 'ui_home.learn'}
return uic.render(request, 'info/doi_services_faq', d)
def id_concepts(request):
if request.method != "GET": return uic.methodNotAllowed(request)
d = {'menu_item': 'ui_home.learn'}
return uic.render(request, 'info/id_concepts', d)
def suffix_passthrough(request):
if request.method != "GET": return uic.methodNotAllowed(request)
d = {'menu_item': 'ui_home.learn'}
return uic.render(request, 'info/suffix_passthrough', d)
