def update_user_inbox_for_reminders(uid): """ Updates user's inbox with any reminders that should have arrived @param uid: user id @return: integer number of new expired reminders """ now = convert_datestruct_to_datetext(localtime()) reminder_status = CFG_WEBMESSAGE_STATUS_CODE['REMINDER'] new_status = CFG_WEBMESSAGE_STATUS_CODE['NEW'] expired_reminders = db.session.query(UserMsgMESSAGE.id_msgMESSAGE).\ join(UserMsgMESSAGE.message).\ filter(db.and_( UserMsgMESSAGE.id_user_to==uid, UserMsgMESSAGE.status.like(reminder_status), MsgMESSAGE.received_date<=datetime.now() #MsgMESSAGE.received_date<=db.func.current_timestamp() )).all() if len(expired_reminders): filter = db.and_( UserMsgMESSAGE.id_user_to == uid, UserMsgMESSAGE.id_msgMESSAGE.in_([i for i, in expired_reminders])) res = UserMsgMESSAGE.query.filter(filter).\ update({UserMsgMESSAGE.status: new_status}, synchronize_session='fetch') return res
def expand(self, id_user): """Expands comment beloging to user.""" CmtCOLLAPSED.query.filter( db.and_(CmtCOLLAPSED.id_bibrec == self.id_bibrec, CmtCOLLAPSED.id_cmtRECORDCOMMENT == self.id, CmtCOLLAPSED.id_user == id_user)).delete( synchronize_session=False)
def _collection_type(type): return db.relationship( Collection, primaryjoin=lambda: db.and_( CollectionExternalcollection.id_collection == Collection.id, CollectionExternalcollection.type == type), backref='_externalcollections_' + str(type))
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 translation(self, lang): try: return db.object_session(self).query(Collectionname).\ with_parent(self).filter(db.and_(Collectionname.ln == lang, Collectionname.type == 'ln')).first().value except: return ""
def delete_all_messages(uid): """ Delete all messages of a user (except reminders) @param uid: user id @return: the number of messages deleted """ reminder_status = CFG_WEBMESSAGE_STATUS_CODE['REMINDER'] msg_ids = map(lambda (x, ): x, db.session.query(UserMsgMESSAGE.id_msgMESSAGE).\ filter(db.and_(UserMsgMESSAGE.id_user_to==uid, UserMsgMESSAGE.status!=reminder_status)).all()) nb_messages = UserMsgMESSAGE.query.\ filter(db.and_(UserMsgMESSAGE.id_user_to==uid, UserMsgMESSAGE.status!=reminder_status)).\ delete(synchronize_session=False) if len(msg_ids) > 0: check_if_need_to_delete_message_permanently(msg_ids) return nb_messages
def title(self): try: return db.object_session(self).query(LnkENTRYURLTITLE).\ filter(db.and_( LnkENTRYURLTITLE.url==self.origin_url, LnkENTRYURLTITLE.title<>"", LnkENTRYURLTITLE.broken==0)).first().title except: return self.origin_url
def get_all_drafts(user_id): drafts = dict( db.session.query( Workflow.name, db.func.count(db.func.distinct( WebDepositDraft.uuid))).join(WebDepositDraft.workflow).filter( db.and_(Workflow.user_id == user_id, Workflow.status != CFG_WORKFLOW_STATUS.FINISHED)).group_by( Workflow.name).all()) return drafts
def can_perform_action(self, action=None): cond = CmtACTIONHISTORY.id_user == self.uid \ if self.uid > 0 else \ CmtACTIONHISTORY.client_host == socket.inet_aton(request.remote_addr) if action in CFG_WEBCOMMENT_ACTION_CODE: cond = db.and_( cond, CmtACTIONHISTORY.action_code == CFG_WEBCOMMENT_ACTION_CODE[action]) return CmtACTIONHISTORY.query.filter( CmtACTIONHISTORY.id_cmtRECORDCOMMENT == self.id, cond).\ count() == 0
def reset_rec_cache(output_format, get_record, split_by=1000): """It either stores or does not store the output_format. If CFG_BIBUPLOAD_SERIALIZE_RECORD_STRUCTURE is changed, this function will adapt the database to either store or not store the output_format.""" import sys try: import cPickle as pickle except: import pickle from itertools import islice from invenio.config import CFG_BIBUPLOAD_SERIALIZE_RECORD_STRUCTURE from invenio.intbitset import intbitset from invenio.bibsched import server_pid, pidfile from invenio.sqlalchemyutils import db from invenio.bibedit_model import Bibrec, Bibfmt pid = server_pid(ping_the_process=False) if pid: print >> sys.stderr, "ERROR: bibsched seems to run with pid %d, according to %s." % (pid, pidfile) print >> sys.stderr, " Please stop bibsched before running this procedure." sys.exit(1) if CFG_BIBUPLOAD_SERIALIZE_RECORD_STRUCTURE: print ">>> Searching records which need %s cache resetting; this may take a while..." % (output_format, ) all_recids = intbitset(db.session.query(Bibrec.id).all()) #TODO: prevent doing all records? recids = all_recids print ">>> Generating %s cache..." % (output_format, ) tot = len(recids) count = 0 it = iter(recids) while True: rec_group = tuple(islice(it, split_by)) if not len(rec_group): break Bibfmt.query.filter(db.and_( Bibfmt.id_bibrec.in_(rec_group), Bibfmt.format == output_format)).delete(synchronize_session=False) db.session.commit() #TODO: Update the cache or wait for the first access map(get_record, rec_group) count += len(rec_group) print " ... done records %s/%s" % (count, tot) if len(rec_group) < split_by or count >= tot: break print ">>> %s cache generated successfully." % (output_format, ) else: print ">>> Cleaning %s cache..." % (output_format, ) Bibfmt.query.filter(Bibfmt.format == output_format).delete(synchronize_session=False) db.session.commit()
def menu(): uid = current_user.get_id() dbquery.update_user_inbox_for_reminders(uid) # join: msgMESSAGE -> user_msgMESSAGE, msgMESSAGE -> users # filter: all messages from user AND filter form # order: sorted by one of the table column messages = db.session.query(MsgMESSAGE, UserMsgMESSAGE).\ join(MsgMESSAGE.user_from, MsgMESSAGE.sent_to_users).\ filter(db.and_(dbquery.filter_all_messages_from_user(uid))).\ order_by(db.desc(MsgMESSAGE.received_date)).limit(5) #return dict(messages=messages.all()) return render_template('webmessage_menu.html', messages=messages.all())
def __str__(self): uid = current_user.get_id() dbquery.update_user_inbox_for_reminders(uid) unread = db.session.query(db.func.count(UserMsgMESSAGE.id_msgMESSAGE)).\ filter(db.and_( UserMsgMESSAGE.id_user_to == uid, UserMsgMESSAGE.status == CFG_WEBMESSAGE_STATUS_CODE['NEW'] )).scalar() out = '<div data-menu="click" data-menu-source="' + url_for('webmessage.menu') + '">' out += '<i class="icon-envelope icon-white"></i>' if unread: out += ' <span class="badge badge-important">%d</span>' % unread out += "</div>" return out
def index(sort=False, filter=None): uid = current_user.get_id() dbquery.update_user_inbox_for_reminders(uid) # join: msgMESSAGE -> user_msgMESSAGE, msgMESSAGE -> users # filter: all messages from user AND filter form # order: sorted by one of the table column messages = db.session.query(MsgMESSAGE, UserMsgMESSAGE).\ join(MsgMESSAGE.user_from, MsgMESSAGE.sent_to_users).\ filter(db.and_(dbquery.filter_all_messages_from_user(uid), (filter))).\ order_by(sort) return dict(messages=messages.all(), nb_messages=dbquery.count_nb_messages(uid), no_quota=is_no_quota_user(uid))
def decorated_function(*args, **kwargs): if not model or not columns: return f(*args, **kwargs) where = [] for column, op in columns.iteritems(): try: values = request.values.getlist(column) if not values: continue column_keys = column.split('.') if hasattr(model, column_keys[0]): cond = reduce( lambda x, y: getattr(x.property.table.columns, y), column_keys[1:], getattr(model, column_keys[0])) current_app.logger.info("Filtering by: %s = %s" % \ (cond, values)) # Multi-values support if len(values) > 0: # Ignore empty values when using start with, # contains or similar. # FIXME: add per field configuration values = [ value for value in values if len(value) > 0 or filter_empty ] if op == operators.eq: where.append(db.in_(values)) else: or_list = [] for value in values: or_list.append(op(cond, value)) where.append(db.or_(*or_list)) else: where.append(op(cond, value)) except: flash(_("Invalid filtering key '%s'.") % column) if form is not None: filter_form = form(request.values) @register_template_context_processor def inject_filter_form(): return dict(filter_form=filter_form) # Generate ClauseElement for filtered columns. kwargs['filter'] = db.and_(*where) return f(*args, **kwargs)
def widget(self): uid = current_user.get_id() unread = db.session.query(db.func.count(UserMsgMESSAGE.id_msgMESSAGE)).\ filter(db.and_( UserMsgMESSAGE.id_user_to == uid, UserMsgMESSAGE.status == CFG_WEBMESSAGE_STATUS_CODE['NEW'] )).scalar() total = db.session.query(db.func.count(UserMsgMESSAGE.id_msgMESSAGE)).\ filter( UserMsgMESSAGE.id_user_to == uid ).scalar() template = """ {{ _("You have %d new messages out of %d messages.") | format(unread, total) }} """ return render_template_to_string(template, _from_string=True, unread=unread, total=total)
def unsubscribe(recid=None): uid = current_user.get_id() if recid is None: recid = request.values.getlist('recid', type=int) else: recid = [recid] current_app.logger.info(recid) try: db.session.query(CmtSUBSCRIPTION).filter( db.and_(CmtSUBSCRIPTION.id_bibrec.in_(recid), CmtSUBSCRIPTION.id_user == uid)).delete( synchronize_session=False) db.session.commit() flash(_('You have been successfully unsubscribed'), 'success') except: flash(_('You are already unsubscribed'), 'error') if len(recid) == 1: return redirect(url_for('.comments', recid=recid[0])) else: return redirect(url_for('.subscriptions'))
def sent_to_group_names(self, value): old_group_names = self.group_names self._sent_to_group_names = value groups_to_add = set(self.group_names) - set(old_group_names) groups_to_del = set(old_group_names) - set(self.group_names) if len(groups_to_del): to_del = set([u.nickname for u in User.query.\ join(User.usergroups).filter( Usergroup.name.in_(groups_to_del)).\ all()])-set(self.user_nicks) is_to_del = lambda u: u.nickname in to_del remove_old = filter(is_to_del, self.recipients) for u in remove_old: self.recipients.remove(u) if len(groups_to_add): for u in User.query.join(User.usergroups).filter( db.and_(Usergroup.name.in_(groups_to_add), db.not_(User.nickname.in_( self.user_nicks)))).all(): if u not in self.recipients: self.recipients.append(u)
def reviews(recid): from invenio.access_control_config import VIEWRESTRCOLL from invenio.access_control_mailcookie import \ mail_cookie_create_authorize_action from invenio.webcomment import check_user_can_view_comments auth_code, auth_msg = check_user_can_view_comments(current_user, recid) if auth_code and current_user.is_guest: cookie = mail_cookie_create_authorize_action( VIEWRESTRCOLL, {'collection': g.collection}) url_args = {'action': cookie, 'ln': g.ln, 'referer': request.referrer} flash(_("Authorization failure"), 'error') return redirect(url_for('webaccount.login', **url_args)) elif auth_code: flash(auth_msg, 'error') abort(401) comments = CmtRECORDCOMMENT.query.filter( db.and_(CmtRECORDCOMMENT.id_bibrec == recid, CmtRECORDCOMMENT.in_reply_to_id_cmtRECORDCOMMENT == 0, CmtRECORDCOMMENT.star_score > 0)).all() return render_template('webcomment_reviews.html', comments=comments)
def draft_field_get_all(user_id, deposition_type): """ Returns a list with values of the field_names specified containing all the latest drafts of deposition of type=deposition_type """ ## Select drafts with max step from each uuid. subquery = \ db.session.query(WebDepositDraft.uuid, db.func.max(WebDepositDraft.step)). \ join(WebDepositDraft.workflow).\ filter(db.and_(Workflow.status != CFG_WORKFLOW_STATUS.FINISHED, Workflow.user_id == user_id, Workflow.name == deposition_type, Workflow.module_name == 'webdeposit')). \ group_by(WebDepositDraft.uuid) drafts = \ WebDepositDraft.query. \ filter(db.tuple_(WebDepositDraft.uuid, WebDepositDraft.step). in_(subquery)). \ order_by(db.desc(WebDepositDraft.timestamp)). \ all() return drafts
def index(recid): uid = current_user.get_id() linkbacks = LnkENTRY.query.filter( db.and_(LnkENTRY.id_bibrec == recid, LnkENTRY.status == CFG_WEBLINKBACK_STATUS['APPROVED'])).all() return render_template('weblinkback_index.html', linkbacks=linkbacks)
def get_export_formats(cls): return cls.query.filter(db.and_(Format.visibility == 1)).order_by( Format.name).all()
def is_collapsed(self, id_user): """Returns true if the comment is collapsed by user.""" return CmtCOLLAPSED.query.filter( db.and_(CmtCOLLAPSED.id_bibrec == self.id_bibrec, CmtCOLLAPSED.id_cmtRECORDCOMMENT == self.id, CmtCOLLAPSED.id_user == id_user)).count() > 0
def filter_by_user_status(uid, user_status, login_method='INTERNAL'): return db.and_(UserUsergroup.id_user == uid, UserUsergroup.user_status == user_status, Usergroup.login_method == login_method)
def get_export_formats(): return Format.query.filter(db.and_( Format.content_type != 'text/html', Format.visibility == 1) ).order_by(Format.name).all()
def get(self, name): s = Session.query.filter( db.and_( Session.session_key == name, Session.session_expiry >= db.func.current_timestamp())).one() return s.session_object
def get_export_formats(cls): return cls.query.filter( db.and_(Format.content_type != 'text/html', Format.visibility == 1)).order_by(Format.name).all()
class Collection(db.Model): """Represents a Collection record.""" def __repr__(self): return "%s(%s)" % (self.__class__.__name__, self.id) __tablename__ = 'collection' id = db.Column(db.MediumInteger(9, unsigned=True), primary_key=True) name = db.Column(db.String(255), unique=True, index=True, nullable=False) dbquery = db.Column(db.Text(20), nullable=True, index=True) nbrecs = db.Column(db.Integer(10, unsigned=True), server_default='0') #FIXME read only!!! reclist = db.Column( db.PickleType(pickler=IntbitsetPickle(), comparator=IntbitsetCmp)) _names = db.relationship( lambda: Collectionname, backref='collection', collection_class=attribute_mapped_collection('ln_type'), cascade="all, delete, delete-orphan") names = association_proxy( '_names', 'value', creator=lambda k, v: Collectionname(ln_type=k, value=v)) _formatoptions = association_proxy('formats', 'format') #@cache.memoize(make_name=lambda fname: fname + '::' + g.ln) def formatoptions(self): if len(self._formatoptions): return [dict(f) for f in self._formatoptions] else: return [{ 'code': 'hb', 'name': "HTML %s" % g._("brief"), 'content_type': 'text/html' }] formatoptions = property(formatoptions) _examples_example = association_proxy('_examples', 'example') @property #@cache.memoize(make_name=lambda fname: fname + '::' + g.ln) def examples(self): return list(self._examples_example) @property def name_ln(self): from invenio.search_engine import get_coll_i18nname return get_coll_i18nname(self.name, g.ln).decode('utf-8') # Another possible implementation with cache memoize # @cache.memoize #try: # return db.object_session(self).query(Collectionname).\ # with_parent(self).filter(db.and_(Collectionname.ln==g.ln, # Collectionname.type=='ln')).first().value #except: # return self.name @property #@cache.memoize(make_name=lambda fname: fname + '::' + g.ln) def portalboxes_ln(self): return db.object_session(self).query(CollectionPortalbox).\ with_parent(self).\ options(db.joinedload_all(CollectionPortalbox.portalbox)).\ filter(CollectionPortalbox.ln == g.ln).\ order_by(db.desc(CollectionPortalbox.score)).all() @property def most_specific_dad(self): return db.object_session(self).query(Collection).\ join(Collection.sons).\ filter(CollectionCollection.id_son == self.id).\ order_by(db.asc(Collection.nbrecs)).\ first() @property #@cache.memoize(make_name=lambda fname: fname + '::' + g.ln) def is_restricted(self): from invenio.search_engine import collection_restricted_p return collection_restricted_p(self.name) @property def type(self): p = re.compile("\d+:.*") if self.dbquery is not None and \ p.match(self.dbquery.lower()): return 'r' else: return 'v' _collection_children = db.relationship( lambda: CollectionCollection, #collection_class=OrderedList, collection_class=ordering_list('score'), primaryjoin=lambda: Collection.id == CollectionCollection.id_dad, foreign_keys=lambda: CollectionCollection.id_dad, order_by=lambda: db.asc(CollectionCollection.score)) _collection_children_r = db.relationship( lambda: CollectionCollection, #collection_class=OrderedList, collection_class=ordering_list('score'), primaryjoin=lambda: db.and_( Collection.id == CollectionCollection.id_dad, CollectionCollection. type == 'r'), foreign_keys=lambda: CollectionCollection.id_dad, order_by=lambda: db.asc(CollectionCollection.score)) _collection_children_v = db.relationship( lambda: CollectionCollection, #collection_class=OrderedList, collection_class=ordering_list('score'), primaryjoin=lambda: db.and_( Collection.id == CollectionCollection.id_dad, CollectionCollection. type == 'v'), foreign_keys=lambda: CollectionCollection.id_dad, order_by=lambda: db.asc(CollectionCollection.score)) collection_parents = db.relationship( lambda: CollectionCollection, #collection_class=OrderedList, collection_class=ordering_list('score'), primaryjoin=lambda: Collection.id == CollectionCollection.id_son, foreign_keys=lambda: CollectionCollection.id_son, order_by=lambda: db.asc(CollectionCollection.score)) collection_children = association_proxy('_collection_children', 'son') collection_children_r = association_proxy( '_collection_children_r', 'son', creator=lambda son: CollectionCollection(id_son=son.id, type='r')) collection_children_v = association_proxy( '_collection_children_v', 'son', creator=lambda son: CollectionCollection(id_son=son.id, type='v')) # _externalcollections = db.relationship( lambda: CollectionExternalcollection, # backref='collection', cascade="all, delete, delete-orphan") # # externalcollections = association_proxy( # '_externalcollections', # 'externalcollection') def _externalcollections_type(type): return association_proxy( '_externalcollections_' + str(type), 'externalcollection', creator=lambda ext: CollectionExternalcollection( externalcollection=ext, type=type)) externalcollections_0 = _externalcollections_type(0) externalcollections_1 = _externalcollections_type(1) externalcollections_2 = _externalcollections_type(2) externalcollections = db.relationship( lambda: CollectionExternalcollection, #backref='collection', collection_class=external_collection_mapper, cascade="all, delete, delete-orphan") # Search options _make_field_fieldvalue = lambda type: db.relationship( lambda: CollectionFieldFieldvalue, primaryjoin=lambda: db.and_( Collection.id == CollectionFieldFieldvalue.id_collection, CollectionFieldFieldvalue.type == type), order_by=lambda: CollectionFieldFieldvalue.score) _search_within = _make_field_fieldvalue('sew') _search_options = _make_field_fieldvalue('seo') @property #@cache.memoize(make_name=lambda fname: fname + '::' + g.ln) def search_within(self): """ Collect search within options. """ from invenio.search_engine_config import CFG_WEBSEARCH_SEARCH_WITHIN default = [('', g._('any field'))] found = [(o.field.code, o.field.name_ln) for o in self._search_within] if not found: found = [(f.name.replace(' ', ''), f.name_ln) for f in Field.query.filter( Field.name.in_(CFG_WEBSEARCH_SEARCH_WITHIN)).all()] return default + sorted(found, key=itemgetter(1)) @property #@cache.memoize(make_name=lambda fname: fname + '::' + g.ln) def search_options(self): return self._search_options @property #@cache.memoize(make_name=lambda fname: fname + '::' + g.ln) def ancestors_ids(self): """Get list of parent collection ids.""" output = intbitset([self.id]) for c in self.dads: ancestors = c.dad.ancestors_ids if self.id in ancestors: raise output |= ancestors return output @property #@cache.memoize(make_name=lambda fname: fname + '::' + g.ln) def descendants_ids(self): """Get list of child collection ids.""" output = intbitset([self.id]) for c in self.sons: descendants = c.son.descendants_ids if self.id in descendants: raise output |= descendants return output # Gets the list of localized names as an array collection_names = db.relationship( lambda: Collectionname, primaryjoin=lambda: Collection.id == Collectionname.id_collection, foreign_keys=lambda: Collectionname.id_collection) # Gets the translation according to the lang code def translation(self, lang): try: return db.object_session(self).query(Collectionname).\ with_parent(self).filter(db.and_(Collectionname.ln == lang, Collectionname.type == 'ln')).first().value except: return "" portal_boxes_ln = db.relationship( lambda: CollectionPortalbox, #collection_class=OrderedList, collection_class=ordering_list('score'), primaryjoin=lambda: \ Collection.id == CollectionPortalbox.id_collection, foreign_keys=lambda: CollectionPortalbox.id_collection, order_by=lambda: db.asc(CollectionPortalbox.score)) #@db.hybrid_property #def externalcollections(self): # return self._externalcollections #@externalcollections.setter #def externalcollections(self, data): # if isinstance(data, dict): # for k, vals in data.iteritems(): # for v in list(vals): # self._externalcollections[k] = v # else: # self._externalcollections = data def breadcrumbs(self, builder=None, ln=CFG_SITE_LANG): """Retunds breadcrumbs for collection.""" breadcrumbs = [] # Get breadcrumbs for most specific dad if it exists. if self.most_specific_dad is not None: breadcrumbs = self.most_specific_dad.breadcrumbs(builder=builder, ln=ln) if builder is not None: crumb = builder(self) else: crumb = (self.name_ln, 'search.collection', dict(name=self.name)) breadcrumbs.append(crumb) return breadcrumbs