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 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)