def results(qid, p, of, so, rm):
"""
Generates results for cached query using POSTed filter.
@param qid: query indentifier
"""
try:
recIDsHitSet = get_current_user_records_that_can_be_displayed(qid)
except KeyError:
return 'KeyError'
except:
return _('Please reload the page')
try:
filter_data = json.loads(request.values.get('filter', '[]'))
except:
return _('Invalid filter data')
@check_collection(name_getter=functools.partial(
get_collection_name_from_cache, qid))
def make_results(collection):
recids = faceted_results_filter(recIDsHitSet, filter_data,
FACETS.elements)
recids = sort_and_rank_records(recids, so=so, rm=rm, p=p)
return response_formated_records(
recids,
collection,
of,
create_nearest_terms_box=_create_neareset_term_box)
return make_results()
def do_login_first(error=401):
"""Displays login page when user is not authorised."""
if request.is_xhr:
return _("Authorization failure"), 401
flash(_("Authorization failure"), 'error')
from invenio.webaccount_blueprint import login
return login(referer=request.url), 401
def add_comment(recid):
uid = current_user.get_id()
in_reply = request.args.get('in_reply', type=int)
if in_reply is not None:
comment = CmtRECORDCOMMENT.query.get(in_reply)
if comment.id_bibrec != recid or comment.is_deleted:
abort(401)
if comment is not None:
c = CmtRECORDCOMMENT()
c.title = _('Re: ') + comment.title
c.body = email_quote_txt(comment.body or '')
c.in_reply_to_id_cmtRECORDCOMMENT = in_reply
form = AddCmtRECORDCOMMENTForm(request.form, obj=c)
return render_template('webcomment_add.html', form=form)
form = AddCmtRECORDCOMMENTForm(request.values)
if form.validate_on_submit():
c = CmtRECORDCOMMENT()
form.populate_obj(c)
c.id_bibrec = recid
c.id_user = uid
c.date_creation = datetime.now()
c.star_score = 0
try:
db.session.add(c)
db.session.commit()
flash(_('Comment was sent'), "info")
return redirect(url_for('webcomment.comments', recid=recid))
except:
db.session.rollback()
return render_template('webcomment_add.html', form=form)
def edit(name):
if name not in _USER_SETTINGS:
flash(_('Invalid plugin name'), 'error')
return redirect(url_for('.index'))
plugin = _USER_SETTINGS[name]()
form = None
if request.method == 'POST':
if plugin.form_builder:
form = plugin.form_builder(request.form)
if not form or form.validate():
if form:
# use the form to interpret data
settings_data = form.data
else:
# no form provided, save the POST request values
settings_data = flatten_multidict(request.values)
plugin.store(settings_data)
plugin.save()
flash(_('Data has been saved.'), 'success')
return redirect(url_for('.index'))
flash(_('Please, corrent errors.'), 'error')
# get post data or load data from settings
if not form and plugin.form_builder:
form = plugin.build_form()
return render_template(getattr(plugin, 'edit_template', '')
or 'webaccount_edit.html',
plugin=plugin,
form=form)
def edit(name):
if name not in _USER_SETTINGS:
flash(_('Invalid plugin name'), 'error')
return redirect(url_for('.index'))
plugin = _USER_SETTINGS[name]()
form = None
if request.method == 'POST':
if plugin.form_builder:
form = plugin.form_builder(request.form)
if not form or form.validate():
if form:
# use the form to interpret data
settings_data = form.data
else:
# no form provided, save the POST request values
settings_data = flatten_multidict(request.values)
plugin.store(settings_data)
plugin.save()
flash(_('Data has been saved.'), 'success')
return redirect(url_for('.index'))
flash(_('Please, corrent errors.'), 'error')
# get post data or load data from settings
if not form and plugin.form_builder:
form = plugin.build_form()
return render_template(getattr(plugin, 'edit_template', '') or
'webaccount_edit.html', plugin=plugin, form=form)
def edit(name):
if name not in _USER_SETTINGS:
flash(_('Invalid plugin name'), 'error')
return redirect(url_for('.index'))
plugin = _USER_SETTINGS[name]()
form = None
if request.method == 'POST':
if plugin.form_builder:
form = plugin.form_builder(request.form)
if not form or form.validate():
plugin.store(request.form)
plugin.save()
flash(_('Data has been saved.'), 'success')
return redirect(url_for('.index'))
flash(_('Please, corrent errors.'), 'error')
# get post data or load data from settings
if not form and plugin.form_builder:
form = plugin.form_builder(MultiDict(plugin.load()))
return render_template(getattr(plugin, 'edit_template', '')
or 'webaccount_edit.html',
plugin=plugin,
form=form)
def login(nickname=None,
password=None,
login_method=None,
action='',
remember_me=False,
referer=None):
if CFG_ACCESS_CONTROL_LEVEL_SITE > 0:
return abort(401) # page is not authorized
if action:
try:
action, arguments = mail_cookie_check_authorize_action(action)
except InvenioWebAccessMailCookieError:
pass
form = LoginForm(CombinedMultiDict([
ImmutableMultiDict({'referer': referer} if referer else {}),
request.values
]),
csrf_enabled=False)
try:
user = None
if not CFG_EXTERNAL_AUTH_USING_SSO:
if login_method is 'Local':
if form.validate_on_submit():
user = update_login(nickname, password, remember_me)
elif login_method in ['openid', 'oauth1', 'oauth2']:
pass
req = request.get_legacy_request()
(iden, nickname, password,
msgcode) = webuser.loginUser(req, nickname, password,
login_method)
if iden:
user = update_login(nickname)
else:
flash(_('Invalid login method.'), 'error')
else:
req = request.get_legacy_request()
# Fake parameters for p_un & p_pw because SSO takes them from the environment
(iden, nickname, password,
msgcode) = webuser.loginUser(req, '', '',
CFG_EXTERNAL_AUTH_USING_SSO)
if iden:
user = update_login(nickname)
if user:
flash(_("You are logged in as %s.") % user.nickname, "info")
if referer is not None:
# Change HTTP method to https if needed.
referer = referer.replace(CFG_SITE_URL, CFG_SITE_SECURE_URL)
return redirect(referer)
except:
flash(_("Problem with login."), "error")
current_app.config.update(
dict((k, v) for k, v in vars(websession_config).iteritems()
if "CFG_" == k[:4]))
return render_template('webaccount_login.html', form=form)
class RegisterForm(Form):
"""
User registration form
"""
email = TextField(_("Email address"),
validators=[Required(message=_("Email not provided"))],
description=_("Example") + ": [email protected]")
nickname = TextField(
_("Nickname"),
validators=[Required(message=_("Nickname not provided"))],
description=_("Example") + ": johnd")
password = PasswordField(
_("Password"),
description=_(
"The password phrase may contain punctuation, spaces, etc."))
password2 = PasswordField(_("Confirm password"), )
referer = HiddenField()
action = HiddenField(default='login')
submit = SubmitField(_("Register"))
def validate_nickname(self, field):
if nickname_valid_p(field.data) != 1:
raise validators.ValidationError(
_("Desired nickname %s is invalid.") % field.data)
# is nickname already taken?
try:
User.query.filter(User.nickname == field.data).one()
raise validators.ValidationError(
_("Desired nickname %s already exists in the database.") %
field.data)
except SQLAlchemyError:
pass
def validate_email(self, field):
field.data = field.data.lower()
if email_valid_p(field.data.lower()) != 1:
raise validators.ValidationError(
_("Supplied email address %s is invalid.") % field.data)
# is email already taken?
try:
User.query.filter(User.email == field.data).one()
raise validators.ValidationError(
_("Supplied email address %s already exists in the database.")
% field.data)
except SQLAlchemyError:
pass
def validate_password(self, field):
CFG_ACCOUNT_MIN_PASSWORD_LENGTH = 6
if len(field.data) < CFG_ACCOUNT_MIN_PASSWORD_LENGTH:
raise validators.ValidationError(
_("Password must be at least %d characters long." %
(CFG_ACCOUNT_MIN_PASSWORD_LENGTH, )))
def validate_password2(self, field):
if field.data != self.password.data:
raise validators.ValidationError(_("Both passwords must match."))
def check_for_software_updates(flash_message=False):
"""Check for a new release of Invenio.
@return: True if you have latest version, else False if you need to upgrade,
or None if server was not reachable.
"""
from invenio.config import CFG_VERSION
from invenio.webinterface_handler_flask_utils import _
try:
find = re.compile('Invenio v[0-9]+.[0-9]+.[0-9]+(\-rc[0-9])?'
' is released')
webFile = urllib.urlopen("http://invenio-software.org/repo"
"/invenio/tree/RELEASE-NOTES")
temp = ""
version = ""
version1 = ""
while 1:
temp = webFile.readline()
match1 = find.match(temp)
try:
version = match1.group()
break
except:
pass
if not temp:
break
webFile.close()
submatch = re.compile('[0-9]+.[0-9]+.[0-9]+(\-rc[0-9])?')
version1 = submatch.search(version)
web_version = version1.group().split(".")
local_version = CFG_VERSION.split(".")
if (web_version[0] > local_version[0]
or web_version[0] == local_version[0]
and web_version[1] > local_version[1]
or web_version[0] == local_version[0] and web_version[1]
== local_version[1] and web_version[2] > local_version[2]):
if flash_message:
flash(
_('A newer version of Invenio is available for '
'download. You may want to visit %s') %
('<a href=\"http://invenio-software.org/wiki'
'/Installation/Download\">http://invenio-software.org'
'/wiki/Installation/Download</a>'), 'warning')
return False
except Exception as e:
print e
if flash_message:
flash(
_('Cannot download or parse release notes from http://'
'invenio-software.org/repo/invenio/tree/RELEASE-NOTES'),
'error')
return None
return True
class WebSearchUserSettingsForm(InvenioBaseForm):
rg = SelectField(_('Results per page'),
choices=[('10', '10'), ('25', '25'), ('50', '50'),
('100', '100')])
websearch_hotkeys = SelectField(_('Hotkeys'),
choices=[('0', _('Disable')),
('1', _('Enable'))])
c = SelectMultipleField(_('Collections'), choices=GetCollections())
class AddCmtRECORDCOMMENTForm(InvenioBaseForm):
"""Defines form for writing new comment."""
title = TextField(_('Title'))
body = TextAreaField(_('Message'), [
validators.length(0, 10000,
message = _("Your message is too long, please edit it. Maximum size allowed is %i characters.") % \
(10000, ))])
in_reply_to_id_cmtRECORDCOMMENT = HiddenField()
class JournalForm(WTFormDefault):
name = QuerySelectField('',
get_pk=lambda i: i['key'],
get_label=lambda i: i['value'],
query_factory=lambda: [{
'key': '',
'value': _('Any journal')
}] + get_kb_mappings('EJOURNALS'))
vol = TextField(_('Vol'))
page = TextField(_('Pg'))
def validate_tag_exists(dummy_form, field):
""" Check if id_tag matches a tag in database """
if field.data:
try:
field.data = int(field.data)
except ValueError:
raise validators.ValidationError(_('Tag ID must be an integer.'))
if not db.session.query(WtgTAG).get(field.data):
raise validators.ValidationError(_('Tag does not exist.'))
def create_new(deposition_type):
""" Creates new deposition
"""
if deposition_type not in deposition_metadata:
flash(_('Invalid deposition type `%s`.' % deposition_type), 'error')
return redirect(url_for('.index_deposition_types'))
workflow = create_workflow(deposition_type, current_user.get_id())
uuid = workflow.get_uuid()
flash(deposition_type + _(' deposition created!'), 'info')
return redirect(
url_for("webdeposit.add", deposition_type=deposition_type, uuid=uuid))
class WebSearchUserSettingsForm(InvenioBaseForm):
rg = SelectField(_('Results per page'),
choices=[('10', '10'), ('25', '25'), ('50', '50'),
('100', '100')])
websearch_hotkeys = SelectField(_('Hotkeys'),
choices=[('0', _('Disable')),
('1', _('Enable'))])
c = QuerySelectMultipleField(_('Collections'),
query_factory=get_collection,
get_pk=lambda c: c.name,
get_label=lambda c: c.name_ln)
def delete(deposition_type, uuid):
""" Deletes the whole deposition with uuid=uuid
(including form drafts)
redirects to load another workflow
"""
if deposition_type not in deposition_metadata:
flash(_('Invalid deposition type `%s`.' % deposition_type), 'error')
return redirect(url_for('.index_deposition_types'))
delete_workflow(current_user.get_id(), uuid)
flash(deposition_type + _(' deposition deleted!'), 'error')
return redirect(
url_for("webdeposit.index", deposition_type=deposition_type))
class LoginForm(Form):
nickname = TextField(
_("Nickname"),
validators=[Required(message=_("Nickname not provided")), validate_nickname_or_email])
password = PasswordField(_("Password"))
remember = BooleanField(_("Remember Me"))
referer = HiddenField()
login_method = HiddenField()
submit = SubmitField(_("Sign in"))
def validate_login_method(self, field):
field.data = wash_login_method(field.data)
def subscribe(recid):
uid = current_user.get_id()
subscription = CmtSUBSCRIPTION(id_bibrec=recid,
id_user=uid,
creation_time=datetime.now())
try:
db.session.add(subscription)
db.session.commit()
flash(_('You have been successfully subscribed'), 'success')
except:
flash(_('You are already subscribed'), 'error')
return redirect(url_for('.comments', recid=recid))
def validate_nickname(self, field):
if nickname_valid_p(field.data) != 1:
raise validators.ValidationError(
_("Desired nickname %s is invalid.") % field.data)
# is nickname already taken?
try:
User.query.filter(User.nickname == field.data).one()
raise validators.ValidationError(
_("Desired nickname %s already exists in the database.") %
field.data)
except SQLAlchemyError:
pass
def report(recid, id):
if CommentRights(id).can_perform_action():
CmtRECORDCOMMENT.query.filter(CmtRECORDCOMMENT.id == id).update(
dict(nb_abuse_reports=CmtRECORDCOMMENT.nb_abuse_reports + 1),
synchronize_session='fetch')
log_comment_action(CFG_WEBCOMMENT_ACTION_CODE['REPORT_ABUSE'], id,
recid)
flash(_('Comment has been reported.'), 'success')
else:
flash(_('Comment has been already reported.'), 'error')
return redirect(url_for('webcomment.comments', recid=recid))
def validate_email(self, field):
field.data = field.data.lower()
if email_valid_p(field.data.lower()) != 1:
raise validators.ValidationError(
_("Supplied email address %s is invalid.") % field.data)
# is email already taken?
try:
User.query.filter(User.email == field.data).one()
raise validators.ValidationError(
_("Supplied email address %s already exists in the database.")
% field.data)
except SQLAlchemyError:
pass
def delete_all(confirmed=0):
"""
Delete every message belonging a logged user.
@param confirmed: 0 will produce a confirmation message.
"""
uid = current_user.get_id()
if confirmed != 1:
return render_template('webmessage_confirm_delete.html')
if dbquery.delete_all_messages(uid):
flash(_("Your mailbox has been emptied."), "info")
else:
flash(_("Could not empty your mailbox."), "warning")
return redirect(url_for('.index'))
def vote(recid, id, value):
if CommentRights(id).can_perform_action():
value = 1 if int(value) > 0 else 0
CmtRECORDCOMMENT.query.filter(CmtRECORDCOMMENT.id == id).update(
dict(nb_votes_total=CmtRECORDCOMMENT.nb_votes_total + 1,
nb_votes_yes=CmtRECORDCOMMENT.nb_votes_yes + value),
synchronize_session='fetch')
log_comment_action(CFG_WEBCOMMENT_ACTION_CODE['VOTE'], id, recid)
flash(_('Thank you for your vote.'), 'success')
else:
flash(_('You can not vote for this comment.'), 'error')
return redirect(url_for('webcomment.comments', recid=recid))
def index(deposition_type):
if deposition_type not in deposition_metadata:
flash(_('Invalid deposition type `%s`.' % deposition_type), 'error')
return redirect(url_for('.index_deposition_types'))
current_app.config['breadcrumbs_map'][request.endpoint] = [
(_('Home'), '')
] + blueprint.breadcrumbs + [(deposition_type, None)]
user_id = current_user.get_id()
drafts = draft_field_get_all(user_id, deposition_type)
return render_template('webdeposit_index.html',
drafts=drafts,
deposition_type=deposition_type,
deposition_types=deposition_types)
def create_new(deposition_type):
""" Creates new deposition
"""
if deposition_type not in deposition_metadata:
flash(_('Invalid deposition type `%s`.' % deposition_type), 'error')
return redirect(url_for('.index_deposition_types'))
try:
workflow = create_workflow(deposition_type, current_user.get_id())
except InvenioWebDepositNoDepositionType:
flash(_('Deposition type `') + deposition_type + '` not found.',
'error')
return redirect(url_for('.index_deposition_types'))
uuid = workflow.get_uuid()
return redirect(url_for("webdeposit.add",
deposition_type=deposition_type,
uuid=uuid))
def decorated(*args, **kwargs):
uid = current_user.get_id()
name = name_getter()
if name:
collection = Collection.query.filter(
Collection.name == name).first_or_404()
elif default_collection:
collection = Collection.query.get_or_404(1)
else:
return abort(404)
if collection.is_restricted:
(auth_code,
auth_msg) = acc_authorize_action(uid,
VIEWRESTRCOLL,
collection=collection.name)
if auth_code:
flash(_('This collection is restricted.'), 'error')
if auth_code and current_user.is_guest:
return redirect(
url_for('webaccount.login', referer=request.url))
elif auth_code:
return abort(401)
return method(collection, *args, **kwargs)
class ZenodoEditForm(ZenodoForm, EditFormMixin):
"""
Specialized form for editing a record
"""
# Remove some fields.
doi = fields.DOIField(
label="Digital Object Identifier",
description="Optional. Did your publisher already assign a DOI to your"
" upload? If not, leave the field empty and we will register a new"
" DOI for you. A DOI allow others to easily and unambiguously cite"
" your upload.",
placeholder="e.g. 10.1234/foo.bar...",
validators=[
doi_syntax_validator,
minted_doi_validator(prefix=CFG_DATACITE_DOI_PREFIX),
invalid_doi_prefix_validator(prefix=CFG_DATACITE_DOI_PREFIX),
],
processors=[
local_datacite_lookup
],
export_key='doi',
)
prereserve_doi = None
plupload_file = None
_title = _('Edit upload')
template = "webdeposit_edit.html"
def __init__(self):
super(WebMessageSettings, self).__init__()
self.icon = 'envelope'
self.title = _('Messages')
self.view = url_for('webmessage.index')
if True or CFG_WEBMESSAGE_EMAIL_ALERT:
self.edit = url_for('webaccount.edit', name=self.name)
def validate_user_can_see_bibrec(dummy_form, field):
""" Check if user has rights to view bibrec """
if field.data:
(auth_code, msg) = check_user_can_view_record(current_user, field.data)
if auth_code > 0:
raise validators.ValidationError(
_('Unauthorized to view record: ') + msg)
def validate_user_owns_tag(dummy_form, field):
""" Check if id_tag matches a tag in database """
if field.data:
tag = db.session.query(WtgTAG).get(field.data)
if tag and tag.id_user != current_user.get_id():
raise validators.ValidationError(
_('You are not the owner of this tag.'))
def delete():
"""
Delete message specified by 'msgid' that belongs to logged user.
"""
uid = current_user.get_id()
msgids = request.values.getlist('msgid', type=int)
if len(msgids) <= 0:
flash(_('Sorry, no valid message specified.'), "error")
elif dbquery.check_user_owns_message(uid, msgids) < len(msgids):
flash(_('Sorry, this message (#%s) is not in your mailbox.') % (str(msgids), ), "error")
else:
if dbquery.delete_message_from_user_inbox(uid, msgids) == 0:
flash(_("The message could not be deleted."), "error")
else:
flash(_("The message was successfully deleted."), "info")
return redirect(url_for('.index'))
def __init__(self):
super(DepositsSettings, self).__init__()
self.icon = 'folder-open'
self.title = _('Deposits')
try:
user = User.query.get(current_user.get_id())
email = user.email
email_field = "8560_"
self.view = url_for('search.search', f=email_field, p=email)
except:
self.view = ''
def collection(name):
collection = Collection.query.filter(Collection.name == name).first_or_404()
#FIXME cache per language
b = get_collection_breadcrumbs(collection, [(_('Home'), '')], ln=g.ln)
current_app.config['breadcrumbs_map'][request.endpoint] = b
@register_template_context_processor
def index_context():
return dict(
format_record=cached_format_record,
easy_search_form=EasySearchForm(csrf_enabled=False),
get_creation_date=get_creation_date)
return dict(collection=collection)
def index():
"""
Index page with uploader and list of existing depositions
"""
uid = current_user.get_id()
ctx = mycollections_ctx(uid)
ctx.update({
'title': _('Community Collections'),
'usercollections': UserCollection.query.filter(UserCollection.title != 'ZENODO').order_by(UserCollection.title).all(),
})
return render_template(
"usercollection_index.html",
**ctx
)
def index(collection=None):
"""
Index page with uploader and list of existing depositions
"""
u = None
upload_url = url_for('deposit.upload')
dropbox_upload_url = url_for('deposit.dropbox_upload')
if 'c' in request.values:
u = UserCollection.query.get(request.values.get('c'))
if u:
upload_url = url_for('deposit.upload', c=u.id)
dropbox_upload_url = url_for('deposit.dropbox_upload', c=u.id)
return render_template(
"openaire_index.html",
title=_('Upload'),
myresearch=get_exisiting_publications_for_uid(current_user.get_id()),
pub=None,
usercollection=u,
upload_url=upload_url,
dropbox_upload_url=dropbox_upload_url,
)
def results(qid):
"""
Generates results for cached query using POSTed filter.
@param qid: query indentifier
"""
try:
recIDsHitSet = get_current_user_records_that_can_be_displayed(qid)
except KeyError:
return 'KeyError'
except:
return _('Please reload the page')
cc = search_results_cache.get(
get_search_results_cache_key_from_qid(qid) + '::cc')
try:
filter = json.loads(request.values.get('filter', '[]'))
except:
return _('Invalid filter data')
collection = Collection.query.filter(Collection.name == cc).first_or_404()
sortkeytype = lambda v: v[0]
sortfacet = lambda v: v[1]
data = sorted(filter, key=sortkeytype)
out = {}
for t, vs in groupby(data, key=sortkeytype):
out[t] = {}
for v, k in groupby(sorted(vs, key=sortfacet), key=sortfacet):
out[t][v] = map(lambda i: i[2], k)
filter = out
output = recIDsHitSet
FACET_DICTS = current_app.config.get('FACET_DICTS', {})
if '+' in filter:
values = filter['+']
for key, facet in FACET_DICTS.iteritems():
if key in values:
output.intersection_update(facet.get_facet_recids(values[key]))
if '-' in filter:
values = filter['-']
for key, facet in FACET_DICTS.iteritems():
if key in values:
output.difference_update(facet.get_facet_recids(values[key]))
#TODO sort
if request.values.get('so'):
recids = output.tolist()
recids.reverse()
elif request.values.get('rm'):
from invenio.bibrank_record_sorter import rank_records
ranked = rank_records(
request.values.get('rm'),
0, output, request.values.get('p', '').split())
if ranked[0]:
recids = ranked[0]
recids.reverse()
else:
recids = output.tolist()
else:
recids = output.tolist()
recids.reverse()
rg = request.values.get('rg', 10, type=int)
page = request.values.get('jrec', 1, type=int)
@register_template_context_processor
def index_context():
return dict(
collection=collection,
RecordInfo=RecordInfo,
create_nearest_terms_box=_create_neareset_term_box,
pagination=Pagination(int(ceil(page / float(rg))), rg, len(recids)),
rg=rg,
format_record=cached_format_record)
if len(recids):
return render_template('websearch_results.html',
recids=recids,
export_formats=get_export_formats())
else:
return _('Your search did not match any records. Please try again.')
def search():
"""
Renders search pages.
@FIXME: add parameter stream=True
"""
uid = current_user.get_id()
#url_args = SearchUrlargs(user=user, session=session, **request.args)
name = request.args.get('cc')
if name:
collection = Collection.query.filter(Collection.name == name).first_or_404()
else:
collection = Collection.query.get_or_404(1)
if collection.is_restricted:
(auth_code, auth_msg) = acc_authorize_action(uid,
VIEWRESTRCOLL,
collection=collection.name)
if auth_code and current_user.is_guest:
return redirect(url_for('webaccount.login',
referer=request.url))
elif auth_code:
return abort(401)
from invenio.websearch_webinterface import wash_search_urlargd
argd = argd_orig = wash_search_urlargd(request.args)
argd['of'] = 'id'
#FIXME
b = []
def _crumb_builder(collection):
qargs = request.args.to_dict()
qargs['cc'] = collection.name
return (collection.name_ln, 'search.search', qargs)
if collection.id > 1:
qargs = request.args.to_dict()
qargs['cc'] = Collection.query.get_or_404(1).name
b = get_collection_breadcrumbs(collection, [
(_('Home'), 'search.search', qargs)],
builder=_crumb_builder)
current_app.config['breadcrumbs_map'][request.endpoint] = b
rg = request.args.get('rg', 10, type=int)
page = request.args.get('jrec', 1, type=int)
qid = get_search_query_id(**argd)
recids = perform_request_search(req=request, **argd)
if (argd_orig.get('so') or argd_orig.get('rm')):
recids.reverse()
FACET_SORTED_LIST = current_app.config.get('FACET_SORTED_LIST', [])
facets = map(lambda x: x.get_conf(collection=collection, qid=qid),
FACET_SORTED_LIST)
@register_template_context_processor
def index_context():
return dict(collection=collection,
facets=facets,
RecordInfo=RecordInfo,
create_nearest_terms_box=lambda: _create_neareset_term_box(argd_orig),
pagination=Pagination(int(ceil(page / float(rg))), rg, len(recids)),
rg=rg,
qid=qid,
easy_search_form=EasySearchForm(csrf_enabled=False),
format_record=cached_format_record,
#FIXME: move to DB layer
export_formats=get_export_formats())
return dict(recids=recids)
from invenio.importutils import autodiscover_modules
from invenio.sqlalchemyutils import db
from invenio.webaccount_forms import LoginForm, RegisterForm
from invenio.websearch_model import Collection
from invenio.webinterface_handler_flask_utils import _, InvenioBlueprint
from invenio.websession_model import User
from invenio.websession_webinterface import wash_login_method
from invenio.webuser_flask import login_user, logout_user, current_user, UserInfo
CFG_HAS_HTTPS_SUPPORT = CFG_SITE_SECURE_URL.startswith("https://")
CFG_FULL_HTTPS = CFG_SITE_URL.lower().startswith("https://")
blueprint = InvenioBlueprint('webaccount', __name__,
url_prefix="/youraccount",
breadcrumbs=[(_("Your Account"),
'webaccount.index')],
menubuilder=[('personalize', _('Personalize'),
'webaccount.index')])
def update_login(nickname, password=None, remember_me=False):
where = [db.or_(User.nickname == nickname, User.email == nickname)]
if password is not None:
where.append(User.password == password)
user = User.query.filter(*where).one()
login_user(UserInfo(user.id), remember=remember_me)
return user
@blueprint.route('/login/', methods=['GET', 'POST'])
def register():
req = request.get_legacy_request()
# FIXME
if CFG_ACCESS_CONTROL_LEVEL_SITE > 0:
return webuser.page_not_authorized(req, "../youraccount/register?ln=%s" % g.ln,
navmenuid='youraccount')
form = RegisterForm(request.values, csrf_enabled=False)
#uid = current_user.get_id()
title = _("Register")
messages = []
state = ""
if form.validate_on_submit():
ruid = webuser.registerUser(req, form.email.data.encode('utf8'),
form.password.data.encode('utf8'),
form.nickname.data.encode('utf8'),
ln=g.ln)
if ruid == 0:
title = _("Account created")
messages.append(_("Your account has been successfully created."))
state = "success"
if CFG_ACCESS_CONTROL_NOTIFY_USER_ABOUT_NEW_ACCOUNT == 1:
messages.append(_("In order to confirm its validity, an email message containing an account activation key has been sent to the given email address."))
messages.append(_("Please follow instructions presented there in order to complete the account registration process."))
if CFG_ACCESS_CONTROL_LEVEL_ACCOUNTS >= 1:
messages.append(_("A second email will be sent when the account has been activated and can be used."))
elif CFG_ACCESS_CONTROL_NOTIFY_USER_ABOUT_NEW_ACCOUNT != 1:
user = User.query.filter(User.email == form.email.data.lower()).one()
login_user(user.get_id())
messages.append(_("You can now access your account."))
else:
title = _("Registration failure")
state = "danger"
if ruid == 5:
messages.append(_("Users cannot register themselves, only admin can register them."))
elif ruid == 6 or ruid == 1:
# Note, code 1 is used both for invalid email, and email sending
# problems, however the email address is validated by the form,
# so we only have to report a problem sending the email here
messages.append(_("The site is having troubles in sending you an email for confirming your email address."))
messages.append(_("The error has been logged and will be taken in consideration as soon as possible."))
else:
# Errors [-2, (1), 2, 3, 4] taken care of by form validation
messages.append(_("Internal error %s") % ruid)
elif request.method == 'POST':
title = _("Registration failure")
state = "warning"
return render_template('webaccount_register.html', form=form, title=title,
messages=messages, state=state)
## WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
## General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with Invenio; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
"""OpenAIRE Flask Blueprint"""
from flask import render_template
from invenio.webinterface_handler_flask_utils import InvenioBlueprint, _
blueprint = InvenioBlueprint('invenio_openaire', __name__,
url_prefix="",
menubuilder=[
('main.browse', _('Browse'), '', 2),
('main.browse.datasets', _('Datasets'), 'collection.datasets', 1),
('main.browse.images', _('Images'), 'collection.images', 2),
('main.browse.posters', _('Posters'), 'collection.posters', 3),
('main.browse.presentations', _('Presentations'), 'collection.presentations', 4),
('main.browse.publications', _('Publications'), 'collection.publications', 5),
('main.browse.software', _('Software'), 'collection.software', 6),
('main.browse.videos', _('Video/Audio'), 'collection.videos', 6),
('main.getstarted', _('Get started'), '', 4),
('main.getstarted.features', _('Features'), 'invenio_openaire.features', 1),
#('main.getstarted.deposit_data', _('Deposit data'), 'invenio_openaire.deposit_data', 2),
#('main.getstarted.use_data', _('Use data'), 'invenio_openaire.use_data', 3),
('main.getstarted.faq', _('FAQ'), 'invenio_openaire.faq', 4),
('footermenu_left.about', _('About'), 'invenio_openaire.about', 1),
('footermenu_left.contact', _('Contact'), 'invenio_openaire.contact', 2),
('footermenu_left.policies', _('Policies'), 'invenio_openaire.policies', 3),
def login(nickname=None, password=None, login_method=None, action='',
remember_me=False, referer=None):
if CFG_ACCESS_CONTROL_LEVEL_SITE > 0:
return abort(401) # page is not authorized
if action:
try:
action, arguments = mail_cookie_check_authorize_action(action)
except InvenioWebAccessMailCookieError:
pass
form = LoginForm(CombinedMultiDict([ImmutableMultiDict({'referer': referer}
if referer else {}),
request.values]),
csrf_enabled=False)
try:
user = None
if not CFG_EXTERNAL_AUTH_USING_SSO:
if login_method == 'Local':
if form.validate_on_submit():
user = update_login(nickname, password, remember_me)
elif login_method in ['openid', 'oauth1', 'oauth2']:
pass
req = request.get_legacy_request()
(iden, nickname, password, msgcode) = webuser.loginUser(req, nickname,
password,
login_method)
if iden:
user = update_login(nickname)
else:
flash(_('Invalid login method.'), 'error')
else:
req = request.get_legacy_request()
# Fake parameters for p_un & p_pw because SSO takes them from the environment
(iden, nickname, password, msgcode) = webuser.loginUser(req, '', '', CFG_EXTERNAL_AUTH_USING_SSO)
if iden:
user = update_login(nickname)
if user:
flash(_("You are logged in as %s.") % user.nickname, "info")
if referer is not None:
from urlparse import urlparse
# we should not redirect to these URLs after login
blacklist = [url_for('webaccount.register'),
url_for('webaccount.logout'),
url_for('webaccount.login')]
if not urlparse(referer).path in blacklist:
# Change HTTP method to https if needed.
referer = referer.replace(CFG_SITE_URL, CFG_SITE_SECURE_URL)
return redirect(referer)
return redirect('/')
except:
flash(_("Problem with login."), "error")
current_app.config.update(dict((k, v) for k, v in
vars(websession_config).iteritems()
if "CFG_" == k[:4]))
collection = Collection.query.get_or_404(1)
from invenio.b2share_utils import get_latest_deposits
latest_deposits = get_latest_deposits()
# @register_template_context_processor
# def index_context():
# return dict(
# easy_search_form=EasySearchForm(csrf_enabled=False),
# format_record=cached_format_record,
# get_creation_date=get_creation_date,
# unregistered=(not current_user.is_authenticated())
# )
return render_template('webaccount_login.html', form=form,
collection=collection, latest_deposits=latest_deposits)
from invenio.bibdocfile import download_external_url
from invenio.openaire_deposit_engine import get_exisiting_publications_for_uid,\
OpenAIREPublication
from werkzeug.datastructures import MultiDict
import invenio.template
import os
from invenio.openaire_forms import DepositionForm, DepositionFormMapper, PublicationMapper
import json
from invenio.config import CFG_SITE_SUPPORT_EMAIL, CFG_SITE_NAME
from invenio.usercollection_model import UserCollection
blueprint = InvenioBlueprint('deposit', __name__,
url_prefix="/deposit",
breadcrumbs=[
(_('Upload'), 'deposit.index'),
],
menubuilder=[
('main.deposit', _('Upload'), 'deposit.index', 1),
],
)
openaire_deposit_templates = invenio.template.load('openaire_deposit')
def is_editable(pub):
return pub.status in ['initialized', 'edited']
# - Wash url arg
# - check redirect to login on guest
def decorated(recid, *args, **kwargs):
# ensure recid to be integer
recid = int(recid)
g.collection = collection = Collection.query.filter(
Collection.name == guess_primary_collection_of_a_record(recid)).\
one()
(auth_code, auth_msg) = check_user_can_view_record(current_user, recid)
# only superadmins can use verbose parameter for obtaining debug information
if not current_user.is_super_admin and 'verbose' in kwargs:
kwargs['verbose'] = 0
if auth_code and current_user.is_guest:
cookie = mail_cookie_create_authorize_action(VIEWRESTRCOLL, {
'collection': guess_primary_collection_of_a_record(recid)})
url_args = {'action': cookie, 'ln': g.ln, 'referer': request.url}
flash(_("Authorization failure"), 'error')
return redirect(url_for('webaccount.login', **url_args))
elif auth_code:
flash(auth_msg, 'error')
abort(apache.HTTP_UNAUTHORIZED)
from invenio.bibfield import get_record
from invenio.search_engine import record_exists, get_merged_recid
# check if the current record has been deleted
# and has been merged, case in which the deleted record
# will be redirect to the new one
record_status = record_exists(recid)
merged_recid = get_merged_recid(recid)
if record_status == -1 and merged_recid:
return redirect(url_for('record.metadata', recid=merged_recid))
elif record_status == -1:
abort(apache.HTTP_GONE) # The record is gone!
g.bibrec = Bibrec.query.get(recid)
record = get_record(recid)
title = record.get('title.title', '')
b = [(_('Home'), '')] + collection.breadcrumbs()[1:]
b += [(title, 'record.metadata', dict(recid=recid))]
current_app.config['breadcrumbs_map'][request.endpoint] = b
g.record_tab_keys = []
tabs = []
counts = get_detailed_page_tabs_counts(recid)
for k, v in get_detailed_page_tabs(collection.id, recid,
g.ln).iteritems():
t = {}
b = 'record'
if k == '':
k = 'metadata'
if k == 'comments' or k == 'reviews':
b = 'webcomment'
if k == 'linkbacks':
b = 'weblinkback'
k = 'index'
t['key'] = b + '.' + k
t['count'] = counts.get(k.capitalize(), -1)
t.update(v)
tabs.append(t)
if v['visible']:
g.record_tab_keys.append(b + '.' + k)
if CFG_WEBLINKBACK_TRACKBACK_ENABLED:
@register_template_context_processor
def trackback_context():
from invenio.weblinkback_templates import get_trackback_auto_discovery_tag
return dict(headerLinkbackTrackbackLink=get_trackback_auto_discovery_tag(recid))
def _format_record(recid, of='hd', user_info=current_user, *args, **kwargs):
return print_record(recid, format=of, user_info=user_info, *args, **kwargs)
@register_template_context_processor
def record_context():
files = [f for f in BibRecDocs(recid, human_readable=True).list_latest_files(list_hidden=False) \
if not f.is_icon() and f.is_restricted(current_user)[0] == 0]
return dict(recid=recid,
record=record,
tabs=tabs,
title=title,
get_mini_reviews=lambda *args, **kwargs:
get_mini_reviews(*args, **kwargs).decode('utf8'),
collection=collection,
format_record=_format_record,
files=files
)
return f(recid, *args, **kwargs)
from invenio.access_control_config import VIEWRESTRCOLL
from invenio.sqlalchemyutils import db
from invenio.websearch_forms import EasySearchForm
from invenio.websearch_model import Collection, Format, Tag
from invenio.webinterface_handler_flask_utils import _, InvenioBlueprint, \
register_template_context_processor
from invenio.webuser_flask import current_user
from invenio.bibindex_engine import get_index_id_from_index_name
from invenio.search_engine import get_creation_date, perform_request_search,\
search_pattern, print_record, create_nearest_terms_box
blueprint = InvenioBlueprint('search', __name__, url_prefix="",
config='invenio.search_engine_config',
breadcrumbs=[],
menubuilder=[('main.search', _('Search'),
'search.index', 1)])
def insert(name):
def _bfe_element(bfo, **kwargs):
# convert to utf-8 for legacy app
kwargs = dict((k, v.encode('utf-8') if isinstance(v, unicode) else v)
for k, v in kwargs.iteritems())
format_element = get_format_element(name)
(out, dummy) = eval_format_element(format_element,
bfo,
kwargs)
# returns unicode for jinja2
return out.decode('utf-8')
return _bfe_element
redirect, url_for, jsonify
from invenio.webinterface_handler_flask_utils import InvenioBlueprint, _
from invenio.webuser_flask import current_user
from invenio.usercollection_forms import CollectionForm, EditCollectionForm, \
DeleteCollectionForm
from invenio.usercollection_model import UserCollection
from invenio.sqlalchemyutils import db
from invenio.search_engine import get_fieldvalues
from invenio.cache import cache
blueprint = InvenioBlueprint(
'usercollection',
__name__,
url_prefix="/communities",
breadcrumbs=[
(_('Communities'), 'usercollection.index'),
],
menubuilder=[
('main.usercollection', _('Communities'), 'usercollection.index', 2),
],
)
def mycollections_ctx(uid):
"""
Helper method for return ctx used by many views
"""
return {
'mycollections': UserCollection.query.filter_by(
id_user=uid).order_by(db.asc(UserCollection.title)).all()
}
## General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with SimpleStore; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
"""SimpleStore Flask Blueprint"""
from flask import request
from invenio.webinterface_handler_flask_utils import _, InvenioBlueprint
import invenio.simplestore_upload_handler as uph
import invenio.simplestore_deposit_handler as dep
blueprint = InvenioBlueprint('simplestore', __name__,
url_prefix='/deposit',
menubuilder=[('main.simplestore',
_('Deposit'),
'simplestore.deposit', 2)],
breadcrumbs=[(_('Deposit'),
'simplestore.deposit')])
@blueprint.route('/', methods=['GET'])
@blueprint.invenio_authenticated
def deposit():
return dep.deposit(request)
@blueprint.route('/addmeta/<sub_id>', methods=['POST'])
@blueprint.invenio_authenticated
def addmeta(sub_id):
return dep.addmeta(request, sub_id)
