def test_low_level_login(data, self):
users = data.UserData
assert current_user.is_guest
login_user(users.admin.id)
assert current_user.get_id() == users.admin.id
logout_user()
assert current_user.get_id() != users.admin.id
assert current_user.is_guest
login_user(users.romeo.id)
assert not current_user.is_guest
assert current_user.get_id() == users.romeo.id
login_user(users.admin.id)
assert current_user.get_id() == users.admin.id
logout_user()
def delete(usercollection_id):
"""
Delete a collection
"""
# Check existence of collection
u = UserCollection.query.filter_by(id=usercollection_id).first_or_404()
uid = current_user.get_id()
# Check ownership
if u.id_user != uid:
abort(404)
deleteform = DeleteCollectionForm(request.values)
ctx = mycollections_ctx(uid)
ctx.update({
'deleteform': deleteform,
'is_new': False,
'usercollection': u,
})
if request.method == 'POST' and deleteform.validate():
u.delete_collections()
db.session.delete(u)
db.session.commit()
flash("Community collection was successfully deleted.", category='success')
return redirect(url_for('.index'))
else:
flash("Community collection could not be deleted.", category='warning')
return redirect(url_for('.edit', usercollection_id=u.id))
def edit(usercollection_id):
"""
Create or edit a collection.
"""
# Check existence of collection
u = UserCollection.query.filter_by(id=usercollection_id).first_or_404()
uid = current_user.get_id()
# Check ownership
if u.id_user != uid:
abort(404)
form = EditCollectionForm(request.values, u, crsf_enabled=False)
deleteform = DeleteCollectionForm()
ctx = mycollections_ctx(uid)
ctx.update({
'form': form,
'is_new': False,
'usercollection': u,
'deleteform': deleteform,
})
if request.method == 'POST' and form.validate():
for field, val in form.data.items():
setattr(u, field, val)
db.session.commit()
u.save_collections()
flash("Community collection successfully edited.", category='success')
return redirect(url_for('.edit', usercollection_id=u.id))
return render_template(
"usercollection_new.html",
**ctx
)
def new():
"""
Create or edit a collection.
"""
uid = current_user.get_id()
form = CollectionForm(request.values, crsf_enabled=False)
ctx = mycollections_ctx(uid)
ctx.update({
'form': form,
'is_new': True,
'usercollection': None,
})
if request.method == 'POST' and form.validate():
# Map form
data = form.data
data['id'] = data['identifier']
del data['identifier']
u = UserCollection(id_user=uid, **data)
db.session.add(u)
db.session.commit()
u.save_collections()
flash("Community collection was successfully created.", category='success')
return redirect(url_for('.index'))
return render_template(
"usercollection_new.html",
**ctx
)
def dropbox_upload(pub_id=None, fileurl=''):
"""
Dropbox upload backend
"""
if pub_id:
pub_id = pub_id.encode('utf8')
if fileurl:
fileurl = fileurl.encode('utf8')
uid = current_user.get_id()
if not fileurl:
abort(400)
if not (fileurl.startswith("https://dl.dropbox.com/")
or fileurl.startswith("https://dl.dropboxusercontent.com/")):
abort(400)
publication = OpenAIREPublication(uid)
if not is_editable(publication):
flash(
"You cannot upload new files when your upload has already been submitted!"
)
abort(400)
# Pre-fill user collection
c = request.values.get('c', None)
if c:
publication.add_usercollection(c)
uploaded_file = download_external_url(fileurl)
publication.add_a_fulltext(uploaded_file,
secure_filename(os.path.basename(fileurl)))
return redirect(url_for('deposit.edit', pub_id=publication.publicationid))
def plupload(deposition_type, uuid):
""" The file is splitted in chunks on the client-side
and it is merged again on the server-side
@return: the path of the uploaded file
"""
return deposit_files(current_user.get_id(), deposition_type, uuid)
def usercollections(bfo, is_owner=False, provisional=False, public=True, filter_zenodo=False):
"""
Maps collection identifiers to community collection objects
@param bfo: BibFormat Object
@param is_owner: Set to true to only return user collections which the
current user owns.
@oaram provisional: Return provisional collections (default to false)
@oaram public: Return public collections (default to true)
"""
colls = []
if is_owner and current_user.is_guest:
return colls
for cid in bfo.fields('980__a'):
# Remove zenodo collections from ab
if filter_zenodo and (cid == 'user-zenodo' or
cid == 'provisional-user-zenodo'):
continue
if provisional and cid.startswith('provisional-'):
colls.append(cid[len("provisional-user-"):])
elif public and cid.startswith('user-'):
colls.append(cid[len("user-"):])
query = [UserCollection.id.in_(colls)]
if is_owner:
query.append(UserCollection.id_user == current_user.get_id())
return UserCollection.query.filter(*query).all()
def upload(pub_id=None):
"""
PLUpload backend
"""
if pub_id:
pub_id = pub_id.encode('utf8')
uid = current_user.get_id()
if 'file' not in request.files:
abort(400)
afile = request.files['file']
filename = secure_filename(afile.filename)
publication = OpenAIREPublication(uid, publicationid=pub_id)
# Pre-fill user collection:
c = request.values.get('c', None)
if c:
publication.add_usercollection(c)
if not is_editable(publication):
flash(
"You cannot upload new files when your upload has already been submitted!"
)
abort(400)
publication.add_a_fulltext(None, filename, req_file=afile)
return publication.publicationid
def delete(usercollection_id):
"""
Delete a collection
"""
# Check existence of collection
u = UserCollection.query.filter_by(id=usercollection_id).first_or_404()
uid = current_user.get_id()
# Check ownership
if u.id_user != uid:
abort(404)
deleteform = DeleteCollectionForm(request.values)
ctx = mycollections_ctx(uid)
ctx.update({
'deleteform': deleteform,
'is_new': False,
'usercollection': u,
})
if request.method == 'POST' and deleteform.validate():
u.delete_collections()
db.session.delete(u)
db.session.commit()
flash("Community collection was successfully deleted.",
category='success')
return redirect(url_for('.index'))
else:
flash("Community collection could not be deleted.", category='warning')
return redirect(url_for('.edit', usercollection_id=u.id))
def widget(self):
uid = current_user.get_id()
query_baskets = UserQueryBasket.query.filter(
UserQueryBasket.id_user == uid
).all()
template = """
{{ _('You own the following') }}
<div class="btn-group">
<a class="btn dropdown-toggle" data-toggle="dropdown" href="#">
<strong class="text-info">{{ query_baskets|length }}</strong>
{{ _('alerts') }}
<span class="caret"></span>
</a>
<ul class="dropdown-menu">
{%- for a in query_baskets -%}
<li>
<a href="#">
{{ a.alert_name }}
</a>
</li>
{%- endfor -%}
</ul>
</div>"""
return render_template_to_string(template, _from_string=True,
query_baskets=query_baskets)
def display_cloud():
""" List of user's private/group/public tags """
user = User.query.get(current_user.get_id())
tags = user.tags_query.order_by(WtgTAG.name).all()
# Calculate document count for each tag
min_count = 0
max_count = 0
for tag in tags:
if tag.record_count > max_count:
max_count = tag.record_count
if tag.record_count < min_count:
min_count = tag.record_count
difference = float(max_count - min_count)
if not difference:
difference = 1.0
# Assign sizes
min_size = 1.0
max_size = 2.0
for tag in tags:
size = min_size + \
float(max_size - min_size) * \
float(tag.record_count - min_count) / difference
tag.css_size = str(size*100)
return dict(user_tags=tags,
display_mode='cloud')
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 get_latest_or_new_workflow(deposition_type, user_id=None):
""" Creates new workflow or returns a new one """
user_id = user_id or current_user.get_id()
wf = deposition_metadata[deposition_type]["workflow"]
# get latest draft in order to get workflow's uuid
latest_workflow = db.session.query(Workflow).\
filter(
Workflow.user_id == user_id,
Workflow.name == deposition_type,
Workflow.module_name == 'webdeposit',
Workflow.status != CFG_WORKFLOW_STATUS.FINISHED).\
order_by(db.desc(Workflow.modified)).\
first()
if latest_workflow is None:
# We didn't find other workflows
# Let's create a new one
return DepositionWorkflow(deposition_type=deposition_type, workflow=wf)
# Create a new workflow
# based on the latest draft's uuid
uuid = latest_workflow.uuid
return DepositionWorkflow(deposition_type=deposition_type,
workflow=wf,
uuid=uuid)
def getfile(pub_id='', file_id='', action='view'):
"""
View for stream file or deleting it.
"""
pub_id = pub_id.encode('utf8')
file_id = file_id.encode('utf8')
action = action.encode('utf8')
uid = current_user.get_id()
if action not in ['view', 'delete']:
abort(404)
try:
pub = OpenAIREPublication(uid, pub_id)
fulltext = pub.fulltexts[file_id]
except (ValueError, KeyError):
abort(404)
if action == 'view':
return send_file(fulltext.get_full_path(),
attachment_filename=fulltext.get_full_name(),
as_attachment=True)
elif action == 'delete':
if not is_editable(pub):
flash("You cannot delete files when your upload has already been submitted!")
return redirect(url_for('.edit', pub_id=pub.publicationid))
if len(pub.fulltexts.keys()) > 1:
if pub.remove_a_fulltext(file_id):
flash("File was deleted", category='success')
else:
flash("File could not be deleted. Please contact support.", category='danger')
else:
flash("File cannot be deleted. You must provide minimum one file.")
return redirect(url_for('.edit', pub_id=pub.publicationid))
def tokenize(id_bibrec, q):
""" Data for tokeninput """
user = db.session.query(User).get(current_user.get_id())
# Output only tags unattached to this record
record = db.session.query(Bibrec).get(id_bibrec)
tags = db.session.query(WtgTAG)\
.filter_by(user=user)\
.filter(WtgTAG.name.like('%'+ q +'%'))\
.filter(db.not_(WtgTAG.records.contains(record)))\
.order_by(WtgTAG.name)
# If a tag with searched name does not exist, lets suggest creating it
# Clean the name
new_name = wash_tag(q)
add_new_name = True
response_tags = []
for tag in tags.all():
tag_json = tag.serializable_fields(['id', 'name'])
response_tags.append(tag_json)
# Check if it matches the search name
if tag_json['name'] == new_name:
add_new_name = False
#If the name was not found
if add_new_name:
tag_json = {'id': 0, 'name': new_name}
response_tags.append(tag_json)
return jsonify(dict(results=response_tags, query=q))
def dropbox_upload(pub_id=None, fileurl=''):
"""
Dropbox upload backend
"""
if pub_id:
pub_id = pub_id.encode('utf8')
if fileurl:
fileurl = fileurl.encode('utf8')
uid = current_user.get_id()
if not fileurl:
abort(400)
if not (fileurl.startswith("https://dl.dropbox.com/") or fileurl.startswith("https://dl.dropboxusercontent.com/")):
abort(400)
publication = OpenAIREPublication(uid)
if not is_editable(publication):
flash("You cannot upload new files when your upload has already been submitted!")
abort(400)
# Pre-fill user collection
c = request.values.get('c', None)
if c:
publication.add_usercollection(c)
uploaded_file = download_external_url(fileurl)
publication.add_a_fulltext(uploaded_file, secure_filename(os.path.basename(fileurl)))
return redirect(url_for('deposit.edit', pub_id=publication.publicationid))
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)
def _runtime_vars_init(self):
""" Initializes user_id, deposition type, uuid and form_type
"""
self.user_id = current_user.get_id()
if self.deposition_type is None:
self.runtime_deposition_type = cache.get(
str(self.user_id) + ":current_deposition_type")
else:
self.runtime_deposition_type = None
# The uuid is always defined on runtime
self.uuid = cache.get(str(self.user_id) + ":current_uuid")
if self.uuid is not None and self.form_type is None:
webdeposit_draft_query = \
db.session.query(WebDepositDraft).\
join(Workflow).\
filter(Workflow.user_id == self.user_id,
WebDepositDraft.uuid == self.uuid)
# get the draft with the max step
webdeposit_draft = max(webdeposit_draft_query.all(),
key=lambda w: w.step)
self.runtime_form_type = webdeposit_draft.form_type
else:
self.runtime_form_type = None
def plupload_delete(uuid):
if request.method == 'POST':
files = draft_field_get(current_user.get_id(), uuid, "files")
result = "File Not Found"
filename = request.form['filename']
files = draft_field_get(current_user.get_id(), uuid, "files")
for i, f in enumerate(files):
if filename == f['file'].split(
'/')[-1]: # get the unique name from the path
os.remove(f['file'])
del files[i]
result = str(files) + " "
draft_field_set(current_user.get_id(), uuid, "files", files)
result = "File " + f['name'] + " Deleted"
break
return result
class CmtSUBSCRIPTION(db.Model):
"""Represents a CmtSUBSCRIPTION record."""
__tablename__ = 'cmtSUBSCRIPTION'
id_bibrec = db.Column(db.MediumInteger(8, unsigned=True),
db.ForeignKey(Bibrec.id),
nullable=False,
primary_key=True)
id_user = db.Column(db.Integer(15, unsigned=True),
db.ForeignKey(User.id),
nullable=False,
primary_key=True)
creation_time = db.Column(db.DateTime,
nullable=False,
server_default='1900-01-01 00:00:00')
bibrec = db.relationship(Bibrec)
user = db.relationship(User, backref='comment_subscriptions')
user_commented_records = db.relationship(
Bibrec,
backref='user_comment_subscritions',
primaryjoin=lambda: db.and_(
CmtSUBSCRIPTION.id_bibrec == Bibrec.id, CmtSUBSCRIPTION.id_user ==
current_user.get_id()),
viewonly=True)
def edit(usercollection_id):
"""
Create or edit a collection.
"""
# Check existence of collection
u = UserCollection.query.filter_by(id=usercollection_id).first_or_404()
uid = current_user.get_id()
# Check ownership
if u.id_user != uid:
abort(404)
form = EditCollectionForm(request.values, u, crsf_enabled=False)
deleteform = DeleteCollectionForm()
ctx = mycollections_ctx(uid)
ctx.update({
'form': form,
'is_new': False,
'usercollection': u,
'deleteform': deleteform,
})
if request.method == 'POST' and form.validate():
for field, val in form.data.items():
setattr(u, field, val)
db.session.commit()
u.save_collections()
flash("Community collection successfully edited.", category='success')
return redirect(url_for('.edit', usercollection_id=u.id))
return render_template("usercollection_new.html", **ctx)
def new():
"""
Create or edit a collection.
"""
uid = current_user.get_id()
form = CollectionForm(request.values, crsf_enabled=False)
ctx = mycollections_ctx(uid)
ctx.update({
'form': form,
'is_new': True,
'usercollection': None,
})
if request.method == 'POST' and form.validate():
# Map form
data = form.data
data['id'] = data['identifier']
del data['identifier']
u = UserCollection(id_user=uid, **data)
db.session.add(u)
db.session.commit()
u.save_collections()
flash("Community collection was successfully created.",
category='success')
return redirect(url_for('.index'))
return render_template("usercollection_new.html", **ctx)
def upload(pub_id=None):
"""
PLUpload backend
"""
if pub_id:
pub_id = pub_id.encode('utf8')
uid = current_user.get_id()
if 'file' not in request.files:
abort(400)
afile = request.files['file']
filename = secure_filename(afile.filename)
publication = OpenAIREPublication(uid, publicationid=pub_id)
# Pre-fill user collection:
c = request.values.get('c', None)
if c:
publication.add_usercollection(c)
if not is_editable(publication):
flash("You cannot upload new files when your upload has already been submitted!")
abort(400)
publication.add_a_fulltext(None, filename, req_file=afile)
return publication.publicationid
def widget(self):
uid = current_user.get_id()
baskets = [] #FIXME add loading baskets
template = """
{{ _('You have') }}
<div class="btn-group">
<a class="btn dropdown-toggle" data-toggle="dropdown" href="#">
<strong class="text-info">{{ baskets|length }}</strong>
{{ _('personal baskets') }}
<span class="caret"></span>
</a>
<ul class="dropdown-menu">
{%- for b in baskets -%}
<li>
<a href="#">
{{ b.name }}
</a>
</li>
{%- endfor -%}
</ul>
</div>"""
return render_template_to_string(template,
_from_string=True,
baskets=baskets)
def curate():
"""
Index page with uploader and list of existing depositions
"""
action = request.values.get('action')
usercollection_id = request.values.get('collection')
recid = request.values.get('recid', 0, type=int)
# Allowed actions
if action not in ['accept', 'reject', 'remove']:
abort(400)
# Check recid
if not recid:
abort(400)
recid = int(recid)
# Does collection exists
u = UserCollection.query.filter_by(id=usercollection_id).first()
if not u:
abort(400)
# Check permission to perform action on this record
# - Accept and reject is done by community owner
# - Remove is done by record owner
if action in ['accept', 'reject', ]:
if u.id_user != current_user.get_id():
abort(403)
elif action == 'remove':
try:
email = get_fieldvalues(recid, '8560_f')[0]
if email != current_user['email']:
abort(403)
# User not allowed to remove from the zenodo user collection
if u.id == 'zenodo':
abort(403)
except (IndexError, KeyError):
abort(403)
# Prevent double requests (i.e. give bibupload a chance to make the change)
key = "usercoll_curate:%s_%s" % (usercollection_id, recid)
cache_action = cache.get(key)
if cache_action == action or cache_action in ['reject', 'remove']:
return jsonify({'status': 'success', 'cache': 1})
elif cache_action:
# Operation under way, but the same action
return jsonify({'status': 'failure', 'cache': 1})
if action == "accept":
res = u.accept_record(recid)
elif action == "reject" or action == "remove":
res = u.reject_record(recid)
if res:
# Set 5 min cache to allow bibupload/webcoll to finish
cache.set(key, action, timeout=5*60)
return jsonify({'status': 'success', 'cache': 0})
else:
return jsonify({'status': 'failure', 'cache': 0})
def __init__(self, keys, attr=None):
self._keys = keys
self._user = User.query.get(current_user.get_id())
self._attr = attr
if self._attr is None:
self._data = dict(self._user.settings)
else:
self._data = dict(self._user.settings.get(self._attr, {}))
def error_check(uuid):
""" Used for field error checking
"""
value = request.args.get('attribute')
field_name = request.args.get('name')
if field_name == "":
return "{}"
draft_field_set(current_user.get_id(), uuid, field_name, value)
check_result = draft_field_error_check(current_user.get_id(), uuid,
field_name, value)
try:
return jsonify(check_result)
except TypeError:
return jsonify({"error_message": "", "error": 0})
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 set_user_id(self, user_id=None):
if user_id is not None:
self.user_id = user_id
else:
from invenio.webuser_flask import current_user
self.user_id = current_user.get_id()
self.obj['user_id'] = self.user_id
def widget(self):
user = User.query.get(current_user.get_id())
email = user.email
email_field = "8560_"
deposit_count = len(perform_request_search(f=email_field, p=email, of="id"))
return render_template_to_string('deposits_user_settings.html',
email=email, email_field=email_field, deposit_count=deposit_count)
def index_deposition_types():
""" Renders the deposition types (workflows) list """
current_app.config['breadcrumbs_map'][request.endpoint] = [
(_('Home'), '')] + blueprint.breadcrumbs
drafts = get_all_drafts(current_user.get_id())
return render_template('webdeposit_index_deposition_types.html',
deposition_types=deposition_types,
drafts=drafts)
def index():
uid = current_user.get_id()
mg = Usergroup.query.join(Usergroup.users).\
filter(UserUsergroup.id_user==uid).all()
#filter_by_user_status(uid,
#CFG_WEBSESSION_USERGROUP_STATUS["MEMBER"])).\
#all()
return render_template('webgroup_index.html', member_groups=map(dict, mg))
def set(self, name, value, timeout=None):
session_expiry = datetime.utcnow() + timeout
s = Session()
s.uid = current_user.get_id()
s.session_key = name
s.session_object = value
s.session_expiry = session_expiry
#FIXME REPLACE OR UPDATE
db.session.merge(s)
db.session.commit()
def json_get(deposition_type):
if request.method == 'GET':
uuid = request.args['uuid']
user_id = current_user.get_id()
form_data = get_preingested_form_data(user_id, uuid)
# edit the form_data.pop('files') and return it with the actual url of
# the file
return jsonify(form_data)
else:
return ''
def log_comment_action(action_code, id, recid, uid=None):
action = CmtACTIONHISTORY(id_cmtRECORDCOMMENT=id,
id_bibrec=recid,
id_user=uid or current_user.get_id(),
client_host=socket.inet_aton(
request.remote_addr),
action_time=datetime.now(),
action_code=action_code)
db.session.add(action)
db.session.commit()
def create_workflow(deposition_type, user_id=None):
""" Creates a new workflow and returns it """
user_id = user_id or current_user.get_id()
try:
# Check if deposition type is valid.
deposition_metadata[deposition_type]
except KeyError, e:
# deposition type not found
raise InvenioWebDepositNoDepositionType(str(e))
def widget(self):
user = User.query.get(current_user.get_id())
tag_count = user.tags_query.count()
record_count = Bibrec.query.join(WtgTAGRecord).join(WtgTAG)\
.filter(WtgTAG.user == user).count()
return render_template_to_string('webtag_user_settings.html',
tag_count=tag_count,
record_count=record_count)
def validate_name_available(dummy_form, field):
""" Check if the user already has tag named this way """
if field.data:
uid = current_user.get_id()
copy_count = db.session.query(WtgTAG).\
filter_by(id_user=uid, name=field.data).count()
if copy_count > 0:
raise validators.ValidationError(
_('Tag with that name already exists.'))
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 process_recjson_new(deposition, recjson):
"""
Process exported recjson for a new record
"""
process_recjson(deposition, recjson)
# Owner of record (can edit/view the record)
email = current_user.info.get('email', '')
recjson['owner'] = dict(
email=email,
username=current_user.info.get('nickname', ''),
id=current_user.get_id(),
deposition_id=deposition.id,
)
# ===========
# Communities
# ===========
# Specific ZENODO user collection, used to curate content for
# ZENODO
if CFG_ZENODO_USER_COLLECTION_ID not in recjson['provisional_communities']:
recjson['provisional_communities'].append(
CFG_ZENODO_USER_COLLECTION_ID
)
# Specific ZENODO user collection for OpenAIRE (used to curate
# FP7 funded research)
if recjson.get('grants', []) and CFG_ECFUNDED_USER_COLLECTION_ID \
not in recjson['provisional_communities']:
recjson['provisional_communities'].append(
CFG_ECFUNDED_USER_COLLECTION_ID
)
# ==============================
# Files (sorting + restrictions)
# ==============================
fft_status = file_firerole(
email, recjson['access_right'], recjson.get('embargo_date', None)
)
# Calculate number of leading zeros needed in the comment.
file_commment_fmt = "%%0%dd" % len(str(len(recjson['fft'])))
for idx, f in enumerate(recjson['fft']):
f['restriction'] = fft_status
# Bibdocfile does not have any concept of ordering, nor will
# bibupload keep the order of FFT tags for the MARC field 8564.
# Hence, this trick stores the ordering of files for a record in
# the files comment, so files can be alphabetically sorted by their
# comment (i.e. we add leading zeros).
f['comment'] = file_commment_fmt % idx
return recjson
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 detail(usercollection_id=None):
"""
Index page with uploader and list of existing depositions
"""
# Check existence of collection
u = UserCollection.query.filter_by(id=usercollection_id).first_or_404()
uid = current_user.get_id()
ctx = mycollections_ctx(uid)
ctx.update({
'is_owner': u.id_user == uid,
'usercollection': u,
'detail': True,
})
return render_template(
"usercollection_detail.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 metadata(recid, of='hd'):
register_page_view_event(recid, current_user.get_id(), str(request.remote_addr))
if get_output_format_content_type(of) != 'text/html':
return redirect('/%s/%d/export/%s' % (CFG_SITE_RECORD, recid, of))
return render_template('record_metadata.html', of=of)
def edit(pub_id=u'', action=u'edit'):
"""
Edit an upload
"""
uid = current_user.get_id()
if action not in ['edit', 'save', 'delete', 'reserve-doi']:
abort(404)
try:
pub = OpenAIREPublication(uid, publicationid=pub_id)
title = pub.metadata.get('title', 'Untitled') or 'Untitled'
editable = is_editable(pub)
except ValueError:
abort(404)
# All POST requests change the publication, and are not allowed if the
# publication is not editable anymore.
if request.method == 'POST':
if not editable:
flash("You cannot edit an already submitted upload. Please contact %s if you would like to make changes!" % CFG_SITE_SUPPORT_EMAIL)
return redirect(url_for('.edit', pub_id=pub.publicationid))
#
# Action handling
#
ctx = {}
if action == 'reserve-doi':
#
# Reserve DOI action (AjAX)
#
if request.method == 'POST':
doi = pub.create_doi()
return json.dumps({'doi': doi})
else:
abort(405)
elif action == 'delete':
#
# Delete action
#
if not editable:
flash("You cannot delete an already submitted upload. Please contact %s if you would like to have it removed!" % CFG_SITE_SUPPORT_EMAIL)
return redirect(url_for('.edit', pub_id=pub.publicationid))
pub.delete()
flash("Upload '%s' was deleted." % title, 'success')
return redirect(url_for('.index'))
elif action == 'edit':
#
# Edit action
#
upload_url = url_for('deposit.upload', pub_id=pub.publicationid)
dropbox_upload_url = url_for('deposit.dropbox_upload', pub_id=pub.publicationid)
ctx = {
'pub': pub,
'recid': pub.metadata.get('__recid__', None),
'title': title,
'is_editable': editable,
'upload_url': upload_url,
'dropbox_upload_url': dropbox_upload_url,
}
if request.method == 'POST':
form = DepositionForm(request.values, crsf_enabled=False)
mapper = DepositionFormMapper(pub)
pub = mapper.map(form)
form._pub = pub
if form.validate():
pub.save()
pub.upload_record()
flash("Upload was successfully submitted - it may take up 5 minutes before it has been fully integrated into %s." % CFG_SITE_NAME, category='success')
return redirect(url_for('.index'))
else:
pub.save()
ctx['form'] = form
ctx['form_message'] = "The form was saved, but there were errors. Please see below."
elif editable:
mapper = PublicationMapper()
form = DepositionForm(mapper.map(pub), crsf_enabled=False)
ctx['form'] = form
else:
ctx['record_hd'] = format_record(recID=pub.recid, xml_record=pub.marcxml, ln=g.ln, of='hd')
ctx['record_hdinfo'] = format_record(recID=pub.recid, xml_record=pub.marcxml, ln=g.ln, of='HDINFO')
elif action == 'save':
#
# Save action (AjAX)
#
if request.method == 'POST':
form = DepositionForm(request.values, crsf_enabled=False)
mapper = DepositionFormMapper(pub)
pub = mapper.map(form)
form._pub = pub
if form.validate():
pub.save()
return json.dumps({'status': 'success', 'form': 'Successfully saved.'})
else:
pub.save()
errors = dict([(x, '') for x in form._fields.keys()])
errors.update(form.errors)
return json.dumps({
'status': 'warning',
'form': 'The form was saved, but there were errors. Please see below.',
'fields': errors,
})
else:
abort(405)
return render_template(
"openaire_edit.html",
myresearch=get_exisiting_publications_for_uid(current_user.get_id()),
**ctx
)
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)
