Beispiel #1
0
class BskRECORDCOMMENT(db.Model):
    """Represents a BskRECORDCOMMENT record."""
    __tablename__ = 'bskRECORDCOMMENT'
    id = db.Column(db.Integer(15, unsigned=True), nullable=False,
                primary_key=True, autoincrement=True)
    id_bibrec_or_bskEXTREC = db.Column(db.Integer(16), nullable=False,
                server_default='0')
    id_bskBASKET = db.Column(db.Integer(15, unsigned=True),
                db.ForeignKey(BskBASKET.id), nullable=False,
                server_default='0')
    id_user = db.Column(db.Integer(15, unsigned=True), db.ForeignKey(User.id),
                nullable=False, server_default='0')
    title = db.Column(db.String(255), nullable=False,
                server_default='')
    body = db.Column(db.Text, nullable=False)
    date_creation = db.Column(db.DateTime, nullable=False,
                server_default='1900-01-01 00:00:00', index=True)
    priority = db.Column(db.Integer(15), nullable=False,
                server_default='0')
    in_reply_to_id_bskRECORDCOMMENT = db.Column(db.Integer(15, unsigned=True),
                db.ForeignKey(id), nullable=False, server_default='0')
    reply_order_cached_data = db.Column(db.Binary, nullable=True)
    in_reply_to = db.relationship('BskRECORDCOMMENT')
    basket = db.relationship(BskBASKET, backref='RECORDCOMMENTs')
    user = db.relationship(User)

    __table_args__ = (db.Index('bskRECORDCOMMENT_reply_order_cached_data',
                               reply_order_cached_data, mysql_length=[40]),
                      db.Model.__table_args__)
Beispiel #2
0
class OaiHARVESTLOG(db.Model):
    """Represents a OaiHARVESTLOG record."""

    __tablename__ = 'oaiHARVESTLOG'
    id_oaiHARVEST = db.Column(db.MediumInteger(9, unsigned=True),
                              db.ForeignKey(OaiHARVEST.id),
                              nullable=False)
    id_bibrec = db.Column(db.MediumInteger(8, unsigned=True),
                          db.ForeignKey(Bibrec.id),
                          nullable=False,
                          server_default='0')
    bibupload_task_id = db.Column(db.Integer(11),
                                  db.ForeignKey(SchTASK.id),
                                  nullable=False,
                                  server_default='0',
                                  primary_key=True)
    oai_id = db.Column(db.String(40),
                       nullable=False,
                       server_default='',
                       primary_key=True)
    date_harvested = db.Column(db.DateTime,
                               nullable=False,
                               server_default='1900-01-01 00:00:00',
                               primary_key=True)
    date_inserted = db.Column(db.DateTime,
                              nullable=False,
                              server_default='1900-01-01 00:00:00')
    inserted_to_db = db.Column(db.Char(1), nullable=False, server_default='P')
    bibrec = db.relationship(Bibrec, backref='harvestlogs')
    schtask = db.relationship(SchTASK)
Beispiel #3
0
class AccAuthorization(db.Model):
    """Represent an authorization."""

    __tablename__ = 'accROLE_accACTION_accARGUMENT'
    id = db.Column(db.Integer(15, unsigned=True),
                   primary_key=True,
                   autoincrement=True)
    id_accROLE = db.Column(db.Integer(15, unsigned=True),
                           db.ForeignKey(AccROLE.id),
                           nullable=True,
                           index=True)
    id_accACTION = db.Column(db.Integer(15, unsigned=True),
                             db.ForeignKey(AccACTION.id),
                             nullable=True,
                             index=True)
    _id_accARGUMENT = db.Column(db.Integer(15),
                                db.ForeignKey(AccARGUMENT.id),
                                nullable=True,
                                name="id_accARGUMENT",
                                index=True)
    argumentlistid = db.Column(db.MediumInteger(8), nullable=True)

    role = db.relationship(AccROLE, backref='authorizations')
    action = db.relationship(AccACTION, backref='authorizations')
    argument = db.relationship(AccARGUMENT, backref='authorizations')

    @db.hybrid_property
    def id_accARGUMENT(self):
        """get id_accARGUMENT."""
        return self._id_accARGUMENT

    @id_accARGUMENT.setter
    def id_accARGUMENT(self, value):
        """set id_accARGUMENT."""
        self._id_accARGUMENT = value or None
Beispiel #4
0
class CrcPURCHASE(db.Model):
    """Represents a CrcPURCHASE record."""
    def __init__(self):
        pass

    __tablename__ = 'crcPURCHASE'
    id = db.Column(db.Integer(15, unsigned=True),
                   nullable=False,
                   primary_key=True,
                   autoincrement=True)
    id_bibrec = db.Column(db.MediumInteger(8, unsigned=True),
                          db.ForeignKey(Bibrec.id),
                          nullable=False,
                          server_default='0')
    id_crcVENDOR = db.Column(db.Integer(15, unsigned=True),
                             db.ForeignKey(CrcVENDOR.id),
                             nullable=False,
                             server_default='0')
    ordered_date = db.Column(db.DateTime,
                             nullable=False,
                             server_default='1900-01-01 00:00:00')
    expected_date = db.Column(db.DateTime,
                              nullable=False,
                              server_default='1900-01-01 00:00:00')
    price = db.Column(db.String(20), nullable=False, server_default='0')
    status = db.Column(db.String(20), nullable=False, server_default='')
    notes = db.Column(db.Text, nullable=True)
    bibrec = db.relationship(Bibrec, backref='purchases')
    vendor = db.relationship(CrcVENDOR, backref='purchases')
Beispiel #5
0
class FieldTag(db.Model):
    """Represent a FieldTag record."""
    __tablename__ = 'field_tag'
    id_field = db.Column(db.MediumInteger(9, unsigned=True),
                         db.ForeignKey('field.id'),
                         nullable=False,
                         primary_key=True)
    id_tag = db.Column(db.MediumInteger(9, unsigned=True),
                       db.ForeignKey('tag.id'),
                       nullable=False,
                       primary_key=True)
    score = db.Column(db.TinyInteger(4, unsigned=True),
                      nullable=False,
                      server_default='0')
    tag = db.relationship(Tag, backref='fields', order_by=score)
    field = db.relationship(Field, backref='tags', order_by=score)

    def __init__(self, score=None, tup=None, *args, **kwargs):
        if score is not None:
            self.score = score
        if tup is not None:
            self.tag = Tag(tup)
        super(FieldTag, self).__init__(*args, **kwargs)

    @property
    def as_tag(self):
        """ Returns Tag record directly."""
        return self.tag
Beispiel #6
0
class RnkDOWNLOADS(db.Model):
    """Represent a RnkDOWNLOADS record."""

    __tablename__ = 'rnkDOWNLOADS'
    id = db.Column(db.Integer,
                   primary_key=True,
                   nullable=False,
                   autoincrement=True)
    id_bibrec = db.Column(db.MediumInteger(8, unsigned=True),
                          db.ForeignKey(Bibrec.id),
                          nullable=True)
    download_time = db.Column(db.DateTime,
                              nullable=True,
                              server_default='1900-01-01 00:00:00')
    client_host = db.Column(db.Integer(10, unsigned=True), nullable=True)
    id_user = db.Column(db.Integer(15, unsigned=True),
                        db.ForeignKey(User.id),
                        nullable=True)
    id_bibdoc = db.Column(db.MediumInteger(9, unsigned=True),
                          db.ForeignKey(Bibdoc.id),
                          nullable=True)
    file_version = db.Column(db.SmallInteger(2, unsigned=True), nullable=True)
    file_format = db.Column(db.String(50), nullable=True)
    bibrec = db.relationship(Bibrec, backref='downloads')
    bibdoc = db.relationship(Bibdoc, backref='downloads')
    user = db.relationship(User, backref='downloads')
Beispiel #7
0
class CollectionCollection(db.Model):
    """Represent a CollectionCollection record."""

    __tablename__ = 'collection_collection'
    id_dad = db.Column(db.MediumInteger(9, unsigned=True),
                       db.ForeignKey(Collection.id),
                       primary_key=True)
    id_son = db.Column(db.MediumInteger(9, unsigned=True),
                       db.ForeignKey(Collection.id),
                       primary_key=True)
    type = db.Column(db.Char(1), nullable=False, server_default='r')
    score = db.Column(db.TinyInteger(4, unsigned=True),
                      nullable=False,
                      server_default='0')
    son = db.relationship(
        Collection,
        primaryjoin=id_son == Collection.id,
        backref='dads',
        # FIX
        # collection_class=db.attribute_mapped_collection('score'),
        order_by=db.asc(score))
    dad = db.relationship(Collection,
                          primaryjoin=id_dad == Collection.id,
                          backref='sons',
                          order_by=db.asc(score))
Beispiel #8
0
class PageList(db.Model):
    """Represent association between page and list."""
    __tablename__ = 'pagesLIST'

    id = db.Column(db.Integer(15, unsigned=True),
                   nullable=False,
                   primary_key=True,
                   autoincrement=True)
    """PageList identifier."""

    list_id = db.Column(db.Integer(15, unsigned=True),
                        db.ForeignKey(Page.id),
                        nullable=False)
    """Id of a list."""

    page_id = db.Column(db.Integer(15, unsigned=True),
                        db.ForeignKey(Page.id),
                        nullable=False)
    """Id of a page."""

    order = db.Column(db.Integer(15, unsigned=True), nullable=False)

    list = db.relationship(Page,
                           backref=db.backref("pages",
                                              cascade="all, delete-orphan"),
                           foreign_keys=[list_id])
    """Relation to the list."""

    page = db.relationship(Page,
                           backref=db.backref("lists",
                                              cascade="all, delete-orphan"),
                           foreign_keys=[page_id])
    """Relation to the page."""
Beispiel #9
0
class IdxINDEXIdxINDEX(db.Model):

    """Represent an IdxINDEXIdxINDEX record."""

    __tablename__ = 'idxINDEX_idxINDEX'
    id_virtual = db.Column(db.MediumInteger(9, unsigned=True),
                           db.ForeignKey(IdxINDEX.id), nullable=False,
                           server_default='0', primary_key=True)
    id_normal = db.Column(db.MediumInteger(9, unsigned=True),
                          db.ForeignKey(IdxINDEX.id), nullable=False,
                          server_default='0', primary_key=True)

    virtual = db.relationship(
        IdxINDEX,
        backref=db.backref('normal'),
        primaryjoin="and_(IdxINDEXIdxINDEX.id_virtual==IdxINDEX.id)"
    )

    normal = db.relationship(
        IdxINDEX,
        backref=db.backref('virtual'),
        primaryjoin="and_(IdxINDEXIdxINDEX.id_normal==IdxINDEX.id)"
    )

    @staticmethod
    def is_virtual(id_virtual):
        """Check if index is virtual."""
        return db.session.query(
            IdxINDEXIdxINDEX.query.filter_by(
                id_virtual=id_virtual).exists()).scalar()
Beispiel #10
0
class KnwKBDDEF(db.Model):
    """Represent a KnwKBDDEF record."""

    __tablename__ = 'knwKBDDEF'
    id_knwKB = db.Column(db.MediumInteger(8, unsigned=True),
                         db.ForeignKey(KnwKB.id),
                         nullable=False,
                         primary_key=True)
    id_collection = db.Column(db.MediumInteger(unsigned=True),
                              db.ForeignKey(Collection.id),
                              nullable=True)
    output_tag = db.Column(db.Text, nullable=True)
    search_expression = db.Column(db.Text, nullable=True)
    kb = db.relationship(KnwKB,
                         backref=db.backref('kbdefs',
                                            uselist=False,
                                            cascade="all, delete-orphan"),
                         single_parent=True)
    collection = db.relationship(Collection, backref=db.backref('kbdefs'))

    def to_dict(self):
        """Return a dict representation of KnwKBDDEF."""
        return {
            'field': self.output_tag,
            'expression': self.search_expression,
            'coll_id': self.id_collection,
            'collection': self.collection.name if self.collection else None
        }
Beispiel #11
0
class AccAuthorization(db.Model):
    """Represent an authorization."""

    __tablename__ = 'accROLE_accACTION_accARGUMENT'
    id_accROLE = db.Column(db.Integer(15, unsigned=True),
                           db.ForeignKey(AccROLE.id),
                           nullable=True,
                           autoincrement=False,
                           primary_key=True,
                           index=True)
    id_accACTION = db.Column(db.Integer(15, unsigned=True),
                             db.ForeignKey(AccACTION.id),
                             nullable=True,
                             autoincrement=False,
                             primary_key=True,
                             index=True)
    id_accARGUMENT = db.Column(db.Integer(15),
                               db.ForeignKey(AccARGUMENT.id),
                               nullable=True,
                               primary_key=True,
                               autoincrement=False,
                               index=True)
    argumentlistid = db.Column(db.MediumInteger(8),
                               nullable=True,
                               autoincrement=False,
                               primary_key=True)

    role = db.relationship(AccROLE, backref='authorizations')
    action = db.relationship(AccACTION, backref='authorizations')
    argument = db.relationship(AccARGUMENT, backref='authorizations')
Beispiel #12
0
class BskREC(db.Model):
    """Represents a BskREC record."""

    __tablename__ = 'bskREC'
    id_bibrec_or_bskEXTREC = db.Column(db.Integer(16),
                                       nullable=False,
                                       server_default='0',
                                       primary_key=True,
                                       index=True)
    id_bskBASKET = db.Column(db.Integer(15, unsigned=True),
                             db.ForeignKey(BskBASKET.id),
                             nullable=False,
                             server_default='0',
                             primary_key=True)
    id_user_who_added_item = db.Column(db.Integer(15, unsigned=True),
                                       db.ForeignKey(User.id),
                                       nullable=False,
                                       server_default='0')
    score = db.Column(db.Integer(15), nullable=False, server_default='0')
    date_added = db.Column(db.DateTime,
                           nullable=False,
                           index=True,
                           server_default='1900-01-01 00:00:00')
    basket = db.relationship(BskBASKET, backref='RECs')
    user_who_added_item = db.relationship(User)
Beispiel #13
0
class BibdocBibdoc(db.Model):
    """Represent a BibdocBibdoc record."""

    __tablename__ = 'bibdoc_bibdoc'
    id = db.Column(db.MediumInteger(9, unsigned=True),
                   primary_key=True,
                   nullable=False,
                   autoincrement=True)
    id_bibdoc1 = db.Column(db.MediumInteger(9, unsigned=True),
                           db.ForeignKey(Bibdoc.id),
                           nullable=True)
    version1 = db.Column(db.TinyInteger(4, unsigned=True))
    format1 = db.Column(db.String(50))
    id_bibdoc2 = db.Column(db.MediumInteger(9, unsigned=True),
                           db.ForeignKey(Bibdoc.id),
                           nullable=True)
    version2 = db.Column(db.TinyInteger(4, unsigned=True))
    format2 = db.Column(db.String(50))
    rel_type = db.Column(db.String(255), nullable=True)
    bibdoc1 = db.relationship(Bibdoc,
                              backref='bibdoc2s',
                              primaryjoin=Bibdoc.id == id_bibdoc1)
    bibdoc2 = db.relationship(Bibdoc,
                              backref='bibdoc1s',
                              primaryjoin=Bibdoc.id == id_bibdoc2)
Beispiel #14
0
class IdxINDEXField(db.Model):
    """Represent a IdxINDEXField record."""

    __tablename__ = 'idxINDEX_field'
    id_idxINDEX = db.Column(db.MediumInteger(9, unsigned=True),
                            db.ForeignKey(IdxINDEX.id),
                            primary_key=True)
    id_field = db.Column(db.MediumInteger(9, unsigned=True),
                         db.ForeignKey(Field.id),
                         primary_key=True)
    regexp_punctuation = db.Column(db.String(255),
                                   nullable=False,
                                   server_default='[.,:;?!"]')
    regexp_alphanumeric_separators = db.Column(db.String(255),
                                               nullable=False)  # FIX ME ,
    # server_default='[!"#$\\%&''()*+,-./:;<=>?@[\\]^\\_`{|}~]')
    idxINDEX = db.relationship(IdxINDEX,
                               backref='fields',
                               lazy='joined',
                               innerjoin=True)
    field = db.relationship(Field,
                            backref='idxINDEXes',
                            lazy='joined',
                            innerjoin=True)

    @classmethod
    def get_field_tokenizers(cls):
        """Get field tokenizers."""
        return db.session.query(Field.name, IdxINDEX.tokenizer).all()
Beispiel #15
0
class CollectionFieldFieldvalue(db.Model):
    """Represent a CollectionFieldFieldvalue record."""

    __tablename__ = 'collection_field_fieldvalue'
    id_collection = db.Column(db.MediumInteger(9, unsigned=True),
                              db.ForeignKey(Collection.id),
                              primary_key=True,
                              nullable=False)
    id_field = db.Column(db.MediumInteger(9, unsigned=True),
                         db.ForeignKey(Field.id),
                         primary_key=True,
                         nullable=False)
    id_fieldvalue = db.Column(db.MediumInteger(9, unsigned=True),
                              db.ForeignKey(Fieldvalue.id),
                              primary_key=True,
                              nullable=True)
    type = db.Column(db.Char(3), nullable=False, server_default='src')
    score = db.Column(db.TinyInteger(4, unsigned=True),
                      nullable=False,
                      server_default='0')
    score_fieldvalue = db.Column(db.TinyInteger(4, unsigned=True),
                                 nullable=False,
                                 server_default='0')

    collection = db.relationship(Collection,
                                 backref='field_fieldvalues',
                                 order_by=score)
    field = db.relationship(Field,
                            backref='collection_fieldvalues',
                            lazy='joined')
    fieldvalue = db.relationship(Fieldvalue,
                                 backref='collection_fields',
                                 lazy='joined')
Beispiel #16
0
class UserBskBASKET(db.Model):
    """Represents a UserBskBASKET record."""
    __tablename__ = 'user_bskBASKET'
    id_user = db.Column(db.Integer(15, unsigned=True), db.ForeignKey(User.id),
                nullable=False, server_default='0', primary_key=True)
    id_bskBASKET = db.Column(db.Integer(15, unsigned=True),
                db.ForeignKey(BskBASKET.id), nullable=False,
                server_default='0', primary_key=True)
    topic = db.Column(db.String(50), nullable=False, server_default='')
    user = db.relationship(User, backref='user_baskets')
    user_basket = db.relationship(BskBASKET, backref='users')
Beispiel #17
0
class WtgTAGRecord(db.Model, Serializable):

    """Connection between Tag and Record."""

    __tablename__ = 'wtgTAG_bibrec'
    __public__ = set(['id_tag', 'id_bibrec', 'date_added'])

    # tagTAG.id
    id_tag = db.Column(db.Integer(15, unsigned=True),
                       db.ForeignKey(WtgTAG.id),
                       nullable=False,
                       primary_key=True)

    # Bibrec.id
    id_bibrec = db.Column(db.Integer(15, unsigned=True),
                          db.ForeignKey(Bibrec.id),
                          nullable=False,
                          primary_key=True)

    # Annotation
    annotation = db.Column(
        db.Text(convert_unicode=True),
        default='')

    # Creation date
    date_added = db.Column(db.DateTime,
                           default=datetime.now)

    # Relationships
    tag = db.relationship(WtgTAG,
                          backref=db.backref('records_association',
                                             cascade='all'))

    tag_query = db.relationship(WtgTAG,
                                backref=db.backref('records_association_query',
                                                   cascade='all',
                                                   lazy='dynamic'))

    bibrec = db.relationship(Bibrec,
                             backref=db.backref('tags_association',
                                                cascade='all'))

    bibrec_query = db.relationship(Bibrec,
                                   backref=db.backref('tags_association_query',
                                                      cascade='all',
                                                      lazy='dynamic'))

    def __init__(self, bibrec=None, **kwargs):
        """TODO."""
        super(WtgTAGRecord, self).__init__(**kwargs)

        if bibrec is not None:
            self.bibrec = bibrec
Beispiel #18
0
class CollectionClsMETHOD(db.Model):
    """Represents a Collection_clsMETHOD record."""
    __tablename__ = 'collection_clsMETHOD'
    id_collection = db.Column(db.MediumInteger(9, unsigned=True),
                              db.ForeignKey(Collection.id),
                              primary_key=True,
                              nullable=False)
    id_clsMETHOD = db.Column(db.MediumInteger(9, unsigned=True),
                             db.ForeignKey(ClsMETHOD.id),
                             primary_key=True,
                             nullable=False)
    collection = db.relationship(Collection, backref='clsMETHODs')
    clsMETHOD = db.relationship(ClsMETHOD, backref='collections')
Beispiel #19
0
class CollectionExample(db.Model):

    """Represent a CollectionExample record."""

    __tablename__ = 'collection_example'
    id_collection = db.Column(db.MediumInteger(9, unsigned=True),
                              db.ForeignKey(Collection.id), primary_key=True)
    id_example = db.Column(db.MediumInteger(9, unsigned=True),
                           db.ForeignKey(Example.id), primary_key=True)
    score = db.Column(db.TinyInteger(4, unsigned=True), nullable=False,
                      server_default='0')
    collection = db.relationship(Collection, backref='_examples',
                                 order_by=score)
    example = db.relationship(Example, backref='collections', order_by=score)
Beispiel #20
0
class NwsSTORY(db.Model):
    """Represents a nwsSTORY record."""
    __tablename__ = 'nwsSTORY'
    id = db.Column(db.Integer(11, unsigned=True), nullable=False, primary_key=True,autoincrement=True)
    title = db.Column(db.String(256), nullable=False, default='')
    body = db.Column(db.Text, nullable=False, default='')
    created = db.Column(db.TIMESTAMP, nullable=False)
    document_status=db.Column(db.String(45), nullable=False, default='SHOW')
    remote_ip=db.Column(db.String(100), nullable=False, default='0.0.0.0')
    email=db.Column(db.String(100), nullable=False, default='*****@*****.**')
    nickname=db.Column(db.String(100), nullable=False, default='admin')
    uid=db.Column(db.Integer(11, unsigned=True), nullable=False)
    nwsToolTip = db.relationship('NwsToolTip', backref='nwsSTORY',cascade='all, delete, delete-orphan')
    nwsTAG = db.relationship('NwsTAG', backref='nwsSTORY',cascade='all, delete, delete-orphan')
Beispiel #21
0
class ExpJOBExpQUERY(db.Model):
    """Represents a ExpJOBExpQUERY record."""
    __tablename__ = 'expJOB_expQUERY'
    id_expJOB = db.Column(db.Integer(15, unsigned=True),
                          db.ForeignKey(ExpJOB.id),
                          nullable=False,
                          primary_key=True)
    id_expQUERY = db.Column(db.Integer(15, unsigned=True),
                            db.ForeignKey(ExpQUERY.id),
                            nullable=False,
                            primary_key=True)

    query = db.relationship(ExpQUERY, backref='jobs')
    job = db.relationship(ExpJOB, backref='queries')
Beispiel #22
0
class UserAccROLE(db.Model):

    """Represent an user role relationship."""

    __tablename__ = 'user_accROLE'
    id_user = db.Column(db.Integer(15, unsigned=True), db.ForeignKey(User.id),
                        nullable=False, primary_key=True)
    id_accROLE = db.Column(db.Integer(15, unsigned=True),
                           db.ForeignKey(AccROLE.id), nullable=False,
                           primary_key=True)
    expiration = db.Column(db.DateTime, nullable=False,
                           server_default='9999-12-31 23:59:59')

    user = db.relationship(User, backref='roles')
    role = db.relationship(AccROLE, backref='users')
Beispiel #23
0
class BsrMETHODDATABUCKET(db.Model):

    """Represent a BsrMETHODDATABUCKET record."""

    __tablename__ = 'bsrMETHODDATABUCKET'

    id_bsrMETHOD = db.Column(db.MediumInteger(9, unsigned=True),
                             db.ForeignKey(BsrMETHOD.id), autoincrement=False,
                             primary_key=True, nullable=False)
    bucket_no = db.Column(db.TinyInteger(2), primary_key=True, nullable=False,
                          autoincrement=False)
    bucket_data = db.Column(db.LargeBinary)
    bucket_last_value = db.Column(db.String(255))
    last_updated = db.Column(db.DateTime)

    method = db.relationship(BsrMETHOD, backref=db.backref(
        "buckets",
        collection_class=attribute_mapped_collection("bucket_no"),
        cascade="all, delete-orphan"
        )
    )

    @property
    def data(self):
        """Return bucket data as intbitset."""
        return intbitset(self.bucket_data)
Beispiel #24
0
 def _collection_type(type_):
     return db.relationship(
         Collection,
         primaryjoin=lambda: db.and_(
             CollectionExternalcollection.id_collection == Collection.id,
             CollectionExternalcollection.type == type_),
         backref='_externalcollections_{0}'.format(str(type_)))
Beispiel #25
0
class FeaturedCommunity(db.Model):
    """Featured community representation."""

    __tablename__ = 'communityFEATURED'

    id = db.Column(db.Integer(15, unsigned=True),
                   primary_key=True,
                   autoincrement=True)
    """Featured community identifier."""

    id_community = db.Column(db.String(100),
                             db.ForeignKey(Community.id),
                             nullable=False)
    """Specific community."""

    start_date = db.Column(db.DateTime(), nullable=False, default=datetime.now)
    """The date from which it should start to take effect."""

    community = db.relationship(Community, backref="featuredcommunity")
    """Relation to the community."""
    @classmethod
    def get_current(cls, start_date=None):
        """Get the latest featured community."""
        start_date = start_date or datetime.now()

        return cls.query.options(
            db.joinedload_all('community.collection')).filter(
                cls.start_date <= start_date).order_by(
                    cls.start_date.desc()).first()
Beispiel #26
0
class PidLog(db.Model):

    """Audit log of actions happening to persistent identifiers.

    This model is primarily used through PersistentIdentifier.log and rarely
    created manually.
    """

    __tablename__ = 'pidLOG'
    __table_args__ = (
        db.Index('idx_action', 'action'),
    )

    id = db.Column(db.Integer(15, unsigned=True), primary_key=True)
    """Id of persistent identifier entry."""

    id_pid = db.Column(
        db.Integer(15, unsigned=True), db.ForeignKey(PersistentIdentifier.id),
        nullable=True,
    )
    """PID."""

    timestamp = db.Column(db.DateTime(), nullable=False, default=datetime.now)
    """Creation datetime of entry."""

    action = db.Column(db.String(10), nullable=False)
    """Action identifier."""

    message = db.Column(db.Text(), nullable=False)
    """Log message."""

    # Relationship
    pid = db.relationship("PersistentIdentifier", backref="logs")
Beispiel #27
0
class CollectionExternalcollection(db.Model):
    """Represent a CollectionExternalcollection record."""

    __tablename__ = 'collection_externalcollection'
    id_collection = db.Column(db.MediumInteger(9, unsigned=True),
                              db.ForeignKey(Collection.id),
                              primary_key=True,
                              server_default='0')
    id_externalcollection = db.Column(db.MediumInteger(9, unsigned=True),
                                      db.ForeignKey(Externalcollection.id),
                                      primary_key=True,
                                      server_default='0')
    type = db.Column(db.TinyInteger(4, unsigned=True),
                     server_default='0',
                     nullable=False)

    def _collection_type(type_):
        return db.relationship(
            Collection,
            primaryjoin=lambda: db.and_(
                CollectionExternalcollection.id_collection == Collection.id,
                CollectionExternalcollection.type == type_),
            backref='_externalcollections_{0}'.format(str(type_)))

    collection_0 = _collection_type(0)
    collection_1 = _collection_type(1)
    collection_2 = _collection_type(2)

    externalcollection = db.relationship(Externalcollection)
Beispiel #28
0
 def _make_field_fieldvalue(type_):
     return db.relationship(
         lambda: CollectionFieldFieldvalue,
         primaryjoin=lambda: db.and_(
             Collection.id == CollectionFieldFieldvalue.id_collection,
             CollectionFieldFieldvalue.type == type_),
         order_by=lambda: CollectionFieldFieldvalue.score)
Beispiel #29
0
 def _make_field_fieldvalue(type_):
     return db.relationship(
         lambda: CollectionFieldFieldvalue,
         primaryjoin=lambda: db.and_(
             Collection.id == CollectionFieldFieldvalue.id_collection,
             CollectionFieldFieldvalue.type == type_),
         order_by=lambda: CollectionFieldFieldvalue.score)
Beispiel #30
0
class Bibfmt(db.Model):
    """Represent a Bibfmt record."""

    __tablename__ = 'bibfmt'

    id_bibrec = db.Column(db.MediumInteger(8, unsigned=True),
                          db.ForeignKey(Bibrec.id),
                          nullable=False,
                          server_default='0',
                          primary_key=True,
                          autoincrement=False)

    format = db.Column(db.String(10),
                       nullable=False,
                       server_default='',
                       primary_key=True,
                       index=True)

    kind = db.Column(db.String(10),
                     nullable=False,
                     server_default='',
                     index=True)

    last_updated = db.Column(db.DateTime,
                             nullable=False,
                             server_default='1900-01-01 00:00:00',
                             index=True)

    value = db.Column(db.iLargeBinary)

    needs_2nd_pass = db.Column(db.TinyInteger(1), server_default='0')

    bibrec = db.relationship(Bibrec, backref='bibfmt')
Beispiel #31
0
class nwsTOOLTIP(db.Model):
    """
    CREATE TABLE 'nwsTOOLTIP' (
     'id' int(11) NOT NULL AUTO_INCREMENT,
     'id_story' int(11) NOT NULL,
     'body' varchar(512) NOT NULL,
     'target_element' varchar(256) NOT NULL DEFAULT '',
     'target_page' varchar(256) NOT NULL DEFAULT '',
     PRIMARY KEY ('id'),
     KEY 'id_story' ('id_story'),
     CONSTRAINT 'nwsTOOLTIP_ibfk_1' FOREIGN KEY ('id_story') REFERENCES 'nwsSTORY' ('id')
    );
    """
    __tablename__ = 'nwsTOOLTIP'

    id = db.Column(db.Integer(11),
                   nullable=False,
                   primary_key=True,
                   autoincrement=True)
    id_story = db.Column(db.Integer(11), db.ForeignKey(nwsSTORY.id))
    body = db.Column(db.String(512), nullable=False)
    target_element = db.Column(db.String(256), nullable=False, default='')
    target_page = db.Column(db.String(256), nullable=False, default='')

    idstory = db.relationship('nwsSTORY', foreign_keys='nwsTOOLTIP.id_story')
Beispiel #32
0
 def _collection_type(type_):
     return db.relationship(
         Collection,
         primaryjoin=lambda: db.and_(
             CollectionExternalcollection.id_collection == Collection.id,
             CollectionExternalcollection.type == type_),
         backref='_externalcollections_{0}'.format(str(type_))
     )
Beispiel #33
0
 def bibxxx(cls):
     return db.relationship(cls._bibxxx, backref='bibrecs')
Beispiel #34
0
    __tablename__ = 'user_accROLE'
    id_user = db.Column(db.Integer(15, unsigned=True), db.ForeignKey(User.id),
                        nullable=False, primary_key=True)
    id_accROLE = db.Column(db.Integer(15, unsigned=True),
                           db.ForeignKey(AccROLE.id), nullable=False,
                           primary_key=True)
    expiration = db.Column(db.DateTime, nullable=False,
                           server_default='9999-12-31 23:59:59')

    user = db.relationship(User, backref='roles')
    role = db.relationship(AccROLE, backref='users')

User.active_roles = db.relationship(
    UserAccROLE,
    lazy="dynamic",
    primaryjoin=db.and_(
        User.id == UserAccROLE.id_user,
        UserAccROLE.expiration >= db.func.now()
    )
)

User.has_admin_role = property(
    lambda self:
    self.has_super_admin_role or db.object_session(self).query(
        db.func.count(User.id) > 0
    ).join(
        User.active_roles,
        UserAccROLE.role,
        AccROLE.authorizations
    ).filter(
        AccAuthorization.id_accACTION.in_(
            db.select([AccACTION.id]).where(
Beispiel #35
0
                                 onupdate=datetime.now)
    user = db.relationship(
        User,
        backref=db.backref('usergroups'))
    usergroup = db.relationship(
        Usergroup,
        backref=db.backref('users', cascade="all, delete-orphan"))

    def is_admin(self):
        """Return True if user is a admin."""
        return self.user_status == self.USER_STATUS['ADMIN']

# define query to get admins
Usergroup.admins = db.relationship(
    UserUsergroup,
    lazy="dynamic",
    primaryjoin=db.and_(
        Usergroup.id == UserUsergroup.id_usergroup,
        UserUsergroup.user_status == UserUsergroup.USER_STATUS['ADMIN']))


class UserEXT(db.Model):

    """Represent a UserEXT record."""

    __tablename__ = 'userEXT'

    id = db.Column(db.VARBINARY(255), primary_key=True, nullable=False)
    method = db.Column(db.String(50), primary_key=True, nullable=False)
    id_user = db.Column(db.Integer(15, unsigned=True),
                        db.ForeignKey(User.id), nullable=False)
Beispiel #36
0
 def bibrec(cls):
     return db.relationship(Record)