class Bookmark(db.Model, RightMixin): """ Represent a bookmark. """ id = db.Column(db.Integer(), primary_key=True) href = db.Column(db.String(), default="") title = db.Column(db.String(), default="") description = db.Column(db.String(), default="") shared = db.Column(db.Boolean(), default=False) to_read = db.Column(db.Boolean(), default=False) time = db.Column(db.DateTime(), default=datetime.utcnow) user_id = db.Column(db.Integer(), db.ForeignKey("user.id")) # relationships tags = db.relationship( BookmarkTag, backref="of_bookmark", lazy="dynamic", cascade="all,delete-orphan", order_by=desc(BookmarkTag.text), ) tags_proxy = association_proxy("tags", "text") @validates("description") def validates_title(self, key, value): return str(value).strip() @validates("extended") def validates_description(self, key, value): return str(value).strip() def __repr__(self): return "<Bookmark %r>" % (self.href)
class User(db.Model, UserMixin): """ Represent a user. """ id = db.Column(db.Integer, primary_key=True) login = db.Column(db.String(30), unique=True, nullable=False) pwdhash = db.Column(db.String(), nullable=False) created_at = db.Column(db.DateTime(), default=datetime.utcnow()) last_seen = db.Column(db.DateTime(), default=datetime.utcnow()) # user rights is_active = db.Column(db.Boolean(), default=False) is_admin = db.Column(db.Boolean(), default=False) is_api = db.Column(db.Boolean(), default=False) def get_id(self): """ Return the id of the user. """ return self.id def check_password(self, password): """ Check the password of the user. """ return check_password_hash(self.pwdhash, password) def __str__(self): return self.login @validates('login') def validates_login(self, key, value): assert 3 <= len(value) <= 30, \ AssertionError("maximum length for login: 30") return re.sub('[^a-zA-Z0-9_\.]', '', value.strip())
class Bookmark(db.Model, RightMixin): """ Represent a bookmark. """ id = db.Column(db.Integer(), primary_key=True) href = db.Column(db.String(), default="") title = db.Column(db.String(), default="") description = db.Column(db.String(), default="") shared = db.Column(db.Boolean(), default=False) to_read = db.Column(db.Boolean(), default=False) time = db.Column(db.DateTime(), default=datetime.utcnow) user_id = db.Column(db.Integer(), db.ForeignKey('user.id')) # relationships tags = db.relationship(BookmarkTag, backref='of_bookmark', lazy='dynamic', cascade='all,delete-orphan', order_by=desc(BookmarkTag.text)) tags_proxy = association_proxy('tags', 'text') @validates('description') def validates_title(self, key, value): return str(value).strip() @validates('extended') def validates_description(self, key, value): return str(value).strip() def __repr__(self): return '<Bookmark %r>' % (self.href)
class Feed(db.Model, RightMixin): """ Represent a feed. """ id = db.Column(db.Integer(), primary_key=True) title = db.Column(db.String(), default="") description = db.Column(db.String(), default="FR") link = db.Column(db.String(), nullable=False) site_link = db.Column(db.String(), default="") enabled = db.Column(db.Boolean(), default=True) created_date = db.Column(db.DateTime(), default=datetime.utcnow) filters = db.Column(db.PickleType, default=[]) private = db.Column(db.Boolean(), default=False) # cache handling etag = db.Column(db.String(), default="") last_modified = db.Column(db.String(), default="") last_retrieved = db.Column(db.DateTime(), default=datetime(1970, 1, 1)) # error logging last_error = db.Column(db.String(), default="") error_count = db.Column(db.Integer(), default=0) # relationship icon_url = db.Column(db.String(), db.ForeignKey('icon.url'), default=None) user_id = db.Column(db.Integer(), db.ForeignKey('user.id')) category_id = db.Column(db.Integer(), db.ForeignKey('category.id')) articles = db.relationship(Article, backref='source', lazy='dynamic', cascade='all,delete-orphan', order_by=desc(Article.date)) # index idx_feed_uid_cid = Index('user_id', 'category_id') idx_feed_uid = Index('user_id') # api whitelists @staticmethod def _fields_base_write(): return { 'title', 'description', 'link', 'site_link', 'enabled', 'filters', 'last_error', 'error_count', 'category_id' } @staticmethod def _fields_base_read(): return {'id', 'user_id', 'icon_url', 'last_retrieved'} @validates('title') def validates_title(self, key, value): return str(value).strip() @validates('description') def validates_description(self, key, value): return str(value).strip() def __repr__(self): return '<Feed %r>' % (self.title)
class Shelter(db.Model): """ Represent a shelter. """ id = db.Column(db.Integer, primary_key=True) created_at = db.Column(db.DateTime(), default=datetime.now) updated_at = db.Column(db.DateTime(), default=datetime.now) is_published = db.Column(db.Boolean(), default=False) is_commercial = db.Column(db.Boolean(), default=False) # relationship user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) properties = db.relationship('Property', backref='shelter', lazy='noload', cascade='all, delete-orphan', order_by=desc('Property.id')) def get_values_of_attribute(self, attribute_id=None, attribute_name=None): """ """ if attribute_id: props = Property.query.filter( Property.shelter_id==self.id, Property.attribute_id==attribute_id) else: props = Property.query.filter( Property.shelter_id==self.id, Property.attribute.has(name=attribute_name)) for property_elem in props: if property_elem.attribute.id == attribute_id or \ property_elem.attribute.name == attribute_name: return property_elem.values else: empty_value = Value(name="") return [empty_value] def get_idvalues_of_attribute(self, attribute_id): return [value.id for value in self.get_values_of_attribute(attribute_id)] def get_property_of_attribute(self, attribute_id): prop = Property.query.filter( Property.shelter_id==self.id, Property.attribute_id==attribute_id) if prop: return prop.first() else: return 0 def __str__(self): """ Required for administrative interface. """ return str(self.id)
class Article(db.Model): "Represent an article from a feed." id = db.Column(db.Integer(), primary_key=True) entry_id = db.Column(db.String()) link = db.Column(db.String()) title = db.Column(db.String()) content = db.Column(db.String()) readed = db.Column(db.Boolean(), default=False) like = db.Column(db.Boolean(), default=False) date = db.Column(db.DateTime(), default=datetime.now) updated_date = db.Column(db.DateTime(), default=datetime.now) retrieved_date = db.Column(db.DateTime(), default=datetime.now) user_id = db.Column(db.Integer(), db.ForeignKey('user.id')) feed_id = db.Column(db.Integer(), db.ForeignKey('feed.id')) category_id = db.Column(db.Integer(), db.ForeignKey('category.id')) def previous_article(self): """ Returns the previous article (older). """ return Article.query.filter(Article.date < self.date, Article.feed_id == self.feed_id)\ .order_by(desc("date")).first() def next_article(self): """ Returns the next article (newer). """ return Article.query.filter(Article.date > self.date, Article.feed_id == self.feed_id)\ .order_by(asc("date")).first() def __repr__(self): return "<Article(id=%d, entry_id=%s, title=%r, " \ "date=%r, retrieved_date=%r)>" % (self.id, self.entry_id, self.title, self.date, self.retrieved_date) def dump(self): return { "id": self.id, "user_id": self.user_id, "entry_id": self.entry_id, "title": self.title, "link": self.link, "content": self.content, "readed": self.readed, "like": self.like, "date": self.date, "updated_date": self.updated_date, "retrieved_date": self.retrieved_date, "feed_id": self.feed_id, "category_id": self.category_id }
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(50), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False, server_default='') reset_password_token = db.Column(db.String(100), nullable=False, server_default='') email = db.Column(db.String(255), nullable=False, unique=True) confirmed_at = db.Column(db.DateTime()) active = db.Column('is_active', db.Boolean(), nullable=False, server_default='0') first_name = db.Column(db.String(100), nullable=False, server_default='') last_name = db.Column(db.String(100), nullable=False, server_default='') # edugain /cyclone toggle logged_in_edugain = db.Column('is_edugain', db.Boolean(), nullable=False, server_default='0') # children of a user contacts = db.relationship('Contact', backref='user', cascade='all, delete-orphan', lazy='joined') attributes = db.relationship('Attribute', backref='user', cascade='all, delete-orphan', lazy='joined') container = db.relationship('Container', backref='user', cascade='all, delete-orphan', lazy='joined') fitfiles = db.relationship('FitFile', backref='user', cascade='all, delete-orphan', lazy='joined') page_default = { 'name': 'My Dashboard', 'slug': 'my-dashboard', 'widgets': list() } pages = db.Column(db.Text, nullable=True, server_default=json.dumps([page_default])) # access token to authenticate against kex exchange service kex_access_token = db.Column(db.Text, nullable=False, server_default='')
class Article(db.Model, RightMixin): "Represent an article from a feed." id = db.Column(db.Integer(), primary_key=True) entry_id = db.Column(db.String(), nullable=False) link = db.Column(db.String()) title = db.Column(db.String()) content = db.Column(db.String()) readed = db.Column(db.Boolean(), default=False) like = db.Column(db.Boolean(), default=False) date = db.Column(db.DateTime(), default=datetime.utcnow) updated_date = db.Column(db.DateTime(), default=datetime.utcnow) retrieved_date = db.Column(db.DateTime(), default=datetime.utcnow) # foreign keys user_id = db.Column(db.Integer(), db.ForeignKey('user.id')) feed_id = db.Column(db.Integer(), db.ForeignKey('feed.id')) category_id = db.Column(db.Integer(), db.ForeignKey('category.id')) # relationships tag_objs = db.relationship('ArticleTag', back_populates='article', cascade='all,delete-orphan', lazy=False, foreign_keys='[ArticleTag.article_id]') tags = association_proxy('tag_objs', 'text') # indexes __table_args__ = (Index('user_id'), Index('user_id', 'category_id'), Index('user_id', 'feed_id'), Index('ix_article_uid_fid_eid', user_id, feed_id, entry_id)) # api whitelists @staticmethod def _fields_base_write(): return {'readed', 'like', 'feed_id', 'category_id'} @staticmethod def _fields_base_read(): return { 'id', 'entry_id', 'link', 'title', 'content', 'date', 'retrieved_date', 'user_id', 'tags' } @staticmethod def _fields_api_write(): return {'tags'} def __repr__(self): return "<Article(id=%d, entry_id=%s, title=%r, " \ "date=%r, retrieved_date=%r)>" % (self.id, self.entry_id, self.title, self.date, self.retrieved_date)
class Article(db.Model, RightMixin): "Represent an article from a feed." id = db.Column(db.Integer(), primary_key=True) entry_id = db.Column(db.String()) link = db.Column(db.String()) title = db.Column(db.String()) content = db.Column(db.String()) readed = db.Column(db.Boolean(), default=False) like = db.Column(db.Boolean(), default=False) date = db.Column(db.DateTime(), default=datetime.utcnow) retrieved_date = db.Column(db.DateTime(), default=datetime.utcnow) readability_parsed = db.Column(db.Boolean(), default=False) user_id = db.Column(db.Integer(), db.ForeignKey('user.id')) feed_id = db.Column(db.Integer(), db.ForeignKey('feed.id')) category_id = db.Column(db.Integer(), db.ForeignKey('category.id')) idx_article_uid = Index('user_id') idx_article_uid_cid = Index('user_id', 'category_id') idx_article_uid_fid = Index('user_id', 'feed_id') # api whitelists @staticmethod def _fields_base_write(): return {'readed', 'like', 'readability_parsed', 'feed_id', 'category_id'} @staticmethod def _fields_base_read(): return {'id', 'entry_id', 'link', 'title', 'content', 'date', 'retrieved_date', 'user_id'} def previous_article(self): """ Returns the previous article (older). """ return Article.query.filter(Article.date < self.date, Article.feed_id == self.feed_id)\ .order_by(desc("date")).first() def next_article(self): """ Returns the next article (newer). """ return Article.query.filter(Article.date > self.date, Article.feed_id == self.feed_id)\ .order_by(asc("date")).first() def __repr__(self): return "<Article(id=%d, entry_id=%s, title=%r, " \ "date=%r, retrieved_date=%r)>" % (self.id, self.entry_id, self.title, self.date, self.retrieved_date)
class User(db.Model, UserMixin): """ Represent a user. """ id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(), unique=True, nullable=False) name = db.Column(db.String(), default='') pwdhash = db.Column(db.String(), nullable=False) created_at = db.Column(db.DateTime(), default=datetime.now) last_seen = db.Column(db.DateTime(), default=datetime.now) is_admin = db.Column(db.Boolean(), default=False) is_active = db.Column(db.Boolean(), default=False) preferred_language = db.Column(db.String(), default='en') # relationships shelters = db.relationship('Shelter', backref='responsible', lazy='dynamic', cascade='all, delete-orphan', order_by=desc('Shelter.id')) @staticmethod def make_valid_name(name): return re.sub('[^a-zA-Z0-9_\.]', '', name) def get_id(self): """ Return the id of the user. """ return self.id def set_password(self, password): """ Hash the password of the user. """ self.pwdhash = generate_password_hash(password) def check_password(self, password): """ Check the password of the user. """ return check_password_hash(self.pwdhash, password) # def __eq__(self, other): # return self.id == other.id def __str__(self): """ Required for administrative interface. """ return self.name def __repr__(self): return '<User %r>' % (self.name)
class User(db.Model, UserMixin, RightMixin): """ Represent a user. """ id = db.Column(db.Integer, primary_key=True) login = db.Column(db.String(), unique=True) password = db.Column(db.String()) email = db.Column(db.String(254)) # user rights is_active = db.Column(db.Boolean(), default=True) is_admin = db.Column(db.Boolean(), default=False) is_api = db.Column(db.Boolean(), default=False) google_identity = db.Column(db.String()) twitter_identity = db.Column(db.String()) facebook_identity = db.Column(db.String()) linuxfr_identity = db.Column(db.String()) date_created = db.Column(db.DateTime(), default=datetime.utcnow) last_connection = db.Column(db.DateTime(), default=datetime.utcnow) feeds = db.relationship('Feed', backref='subscriber', lazy='dynamic', cascade='all,delete-orphan') readability_key = db.Column(db.String(), default='') renew_password_token = db.Column(db.String(), default='') categories = relationship('Category', cascade='all, delete-orphan') feeds = relationship('Feed', cascade='all, delete-orphan') articles = relationship('Article', cascade='all, delete-orphan') @staticmethod def _fields_base_write(): return { 'login', 'password', 'email', 'readability_key', 'google_identity', 'twitter_identity', 'facebook_identity' } @staticmethod def _fields_base_read(): return {'date_created', 'last_connection'} @validates('login') def validates_login(self, key, value): return re.sub('[^a-zA-Z0-9_\.]', '', value.strip())
class Feed(db.Model): """ Represent a feed. """ id = db.Column(db.Integer(), primary_key=True) title = db.Column(db.String(), default="") description = db.Column(db.String(), default="FR") link = db.Column(db.String()) site_link = db.Column(db.String(), default="") enabled = db.Column(db.Boolean(), default=True) created_date = db.Column(db.DateTime(), default=datetime.now) filters = db.Column(db.PickleType, default=[]) # cache handling etag = db.Column(db.String(), default="") last_modified = db.Column(db.String(), default="") last_retrieved = db.Column(db.DateTime(), default=datetime(1970, 1, 1)) # error logging last_error = db.Column(db.String(), default="") error_count = db.Column(db.Integer(), default=0) # relationship icon_url = db.Column(db.String(), db.ForeignKey('icon.url'), default=None) user_id = db.Column(db.Integer(), db.ForeignKey('user.id')) category_id = db.Column(db.Integer(), db.ForeignKey('category.id')) articles = db.relationship('Article', backref='source', lazy='dynamic', cascade='all,delete-orphan', order_by=desc("date")) def __repr__(self): return '<Feed %r>' % (self.title) def dump(self): return { "id": self.id, "user_id": self.user_id, "category_id": self.category_id, "title": self.title, "description": self.description, "link": self.link, "site_link": self.site_link, "etag": self.etag, "enabled": self.enabled, "filters": self.filters, "icon_url": self.icon_url, "error_count": self.error_count, "last_error": self.last_error, "created_date": self.created_date, "last_modified": self.last_modified, "last_retrieved": self.last_retrieved, "nb_articles": self.articles.count() }
class Project(db.Model): """Represent a project. """ id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(100), unique=True) short_description = db.Column(db.String(300), unique=True) description = db.Column(db.String(), unique=True) website = db.Column(db.String()) enabled = db.Column(db.Boolean(), default=True) last_updated = db.Column(db.DateTime(), default=datetime.utcnow()) # if cve_vendor is the empty string use the parent property # (organization.cve_vendor) cve_vendor = db.Column(db.String(), default='') cve_product = db.Column(db.String(), unique=True, nullable=False) automatic_release_tracking = db.Column(db.String()) notification_email = db.Column(db.String(), default='') required_informations = db.Column(JSON, default=None) # foreign keys organization_id = db.Column(db.Integer(), db.ForeignKey('organization.id')) manager_id = db.Column(db.Integer(), db.ForeignKey('user.id')) icon_url = db.Column(db.String(), db.ForeignKey('icon.url'), default=None) # relationships tag_objs = db.relationship('Tag', back_populates='project', cascade='all,delete-orphan', lazy=False, foreign_keys='[Tag.project_id]') tags = association_proxy('tag_objs', 'text') licenses = db.relationship("License", secondary=lambda: association_table, backref="projects") cves = db.relationship('CVE', backref='project', lazy='dynamic', cascade='all,delete-orphan') releases = db.relationship('Release', backref='project', lazy='dynamic', cascade='all,delete-orphan') @validates('name') def validates_name(self, key, value): assert len(value) <= 100, \ AssertionError("maximum length for name: 100") return value.replace(' ', '').strip() def __repr__(self): return '<Name %r>' % (self.name)
class Attribute(db.Model): """ Represent an attribute. """ id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(), nullable=False) uniqueid = db.Column(db.String(), nullable=False) multiple = db.Column(db.Boolean(), default=True) free_text = db.Column(db.Boolean(), default=False) is_editable = db.Column(db.Boolean(), default=True) is_mandatory = db.Column(db.Boolean(), default=False) user_can_add_values = db.Column(db.Boolean(), default=False) type = db.Column(db.String(), default='') display_position = db.Column(db.Integer, default=0) # relationships category_id = db.Column(db.Integer, db.ForeignKey('category.id'), nullable=False) category = db.relationship("Category", back_populates="attributes") associated_values = db.relationship('Value', backref='attribute', lazy='dynamic', cascade='all, delete-orphan', order_by=asc(Value.name)) properties = db.relationship("Property", back_populates="attribute") pictures = db.relationship('AttributePicture', backref='attribute', lazy='dynamic', cascade='all, delete-orphan') def __str__(self): """ Required for administrative interface. """ return self.name
class ShelterPicture(db.Model): """ Represent a picture for a shelter. """ id = db.Column(db.Integer, primary_key=True) file_name = db.Column(db.String(), default='') is_main_picture = db.Column(db.Boolean(), default=False) # relationship shelter_id = db.Column(db.Integer, db.ForeignKey('shelter.id'), nullable=False) category_id = db.Column(db.Integer, db.ForeignKey('category.id'), nullable=False)
class User(db.Model, UserMixin): """ Represent a user. """ id = db.Column(db.Integer, primary_key=True) login = db.Column(db.String(), unique=True, nullable=False) email = db.Column(db.String(254), default='') pwdhash = db.Column(db.String(), nullable=False) created_at = db.Column(db.DateTime(), default=datetime.utcnow()) last_seen = db.Column(db.DateTime(), default=datetime.utcnow()) public_profile = db.Column(db.Boolean(), default=True) # user rights is_active = db.Column(db.Boolean(), default=False) is_admin = db.Column(db.Boolean(), default=False) is_api = db.Column(db.Boolean(), default=False) # relationship positions = db.relationship('Project', backref='manager', lazy='dynamic') def get_id(self): """ Return the id of the user. """ return self.id def check_password(self, password): """ Check the password of the user. """ return check_password_hash(self.pwdhash, password) @validates('login') def validates_login(self, key, value): assert 3 <= len(value) <= 30, \ AssertionError("maximum length for login: 30") return re.sub('[^a-zA-Z0-9_\.]', '', value.strip())
class Request(db.Model, UserMixin): """Represent a request. """ id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(), nullable=False) firstname = db.Column(db.String(), nullable=False) lastname = db.Column(db.String(), nullable=False) checked = db.Column(db.Boolean(), default=False) notification_sent = db.Column(db.Boolean(), default=False) created_at = db.Column(db.DateTime(), default=datetime.utcnow) required_informations = db.Column(JSON) # foreign keys project_id = db.Column(db.Integer(), db.ForeignKey('project.id')) # relationships project = db.relationship('Project', backref="requests") @validates('email') def validates_email(self, key, value): assert len(value) <= 100, 'email too long' assert validate_email(value), 'email not valid' return str(value).strip() @validates('firstname') def validates_firstname(self, key, value): assert len(value) <= 100, 'firstname too long' return str(value).strip() @validates('lastname') def validates_lastname(self, key, value): assert len(value) <= 100, 'lastname too long' return str(value).strip()
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) # User Authentication information username = db.Column(db.String(50), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False, default='') reset_password_token = db.Column(db.String(100), nullable=False, default='') # User Email information email = db.Column(db.String(255), nullable=False, unique=True) confirmed_at = db.Column(db.DateTime()) # User information is_enabled = db.Column(db.Boolean(), nullable=False, default=False) first_name = db.Column(db.String(50), nullable=False, default='') last_name = db.Column(db.String(50), nullable=False, default='') def is_active(self): return self.is_enabled
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(50), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False, server_default='') reset_password_token = db.Column(db.String(100), nullable=False, server_default='') email = db.Column(db.String(255), nullable=False, unique=True) confirmed_at = db.Column(db.DateTime()) active = db.Column('is_active', db.Boolean(), nullable=False, server_default='0') first_name = db.Column(db.String(100), nullable=False, server_default='') last_name = db.Column(db.String(100), nullable=False, server_default='') keypairs = db.relationship('KeyPair', backref='owner', cascade='all, delete-orphan', lazy='joined')
class Article(db.Model, RightMixin): "Represent an article from a feed." id = db.Column(db.Integer(), primary_key=True) entry_id = db.Column(db.String(), nullable=False) link = db.Column(db.String()) title = db.Column(db.String()) content = db.Column(db.String()) readed = db.Column(db.Boolean(), default=False) like = db.Column(db.Boolean(), default=False) date = db.Column(db.DateTime(), default=datetime.utcnow) updated_date = db.Column(db.DateTime(), default=datetime.utcnow) retrieved_date = db.Column(db.DateTime(), default=datetime.utcnow) # foreign keys user_id = db.Column(db.Integer(), db.ForeignKey("user.id")) feed_id = db.Column(db.Integer(), db.ForeignKey("feed.id")) category_id = db.Column(db.Integer(), db.ForeignKey("category.id")) # relationships tag_objs = db.relationship( "ArticleTag", back_populates="article", cascade="all,delete-orphan", lazy=False, foreign_keys="[ArticleTag.article_id]", ) tags = association_proxy("tag_objs", "text") # indexes # __table_args__ = ( # Index('user_id'), # Index('user_id', 'category_id'), # Index('user_id', 'feed_id'), # Index('ix_article_uid_fid_eid', user_id, feed_id, entry_id) # ) # api whitelists @staticmethod def _fields_base_write(): return {"readed", "like", "feed_id", "category_id"} @staticmethod def _fields_base_read(): return { "id", "entry_id", "link", "title", "content", "date", "retrieved_date", "user_id", "tags", } @staticmethod def _fields_api_write(): return {"tags"} def __repr__(self): return ("<Article(id=%d, entry_id=%s, title=%r, " "date=%r, retrieved_date=%r)>" % (self.id, self.entry_id, self.title, self.date, self.retrieved_date))
class User(db.Model, UserMixin, RightMixin): """ Represent a user. """ id = db.Column(db.Integer, primary_key=True) nickname = db.Column(db.String(), unique=True) email = db.Column(db.String(254), index=True, unique=True) pwdhash = db.Column(db.String()) external_id = db.Column(db.String(), index=True, unique=True) automatic_crawling = db.Column(db.Boolean(), default=True) is_public_profile = db.Column(db.Boolean(), default=False) bio = db.Column(db.String(5000), default="") webpage = db.Column(db.String(), default="") twitter = db.Column(db.String(), default="") date_created = db.Column(db.DateTime(), default=datetime.utcnow) last_seen = db.Column(db.DateTime(), default=datetime.utcnow) # user rights is_active = db.Column(db.Boolean(), default=False) is_admin = db.Column(db.Boolean(), default=False) is_api = db.Column(db.Boolean(), default=False) # relationships categories = db.relationship('Category', backref='user', cascade='all, delete-orphan', foreign_keys=[Category.user_id]) feeds = db.relationship('Feed', backref='user', cascade='all, delete-orphan', foreign_keys=[Feed.user_id]) @staticmethod def _fields_base_write(): return {'login', 'password', 'email'} @staticmethod def _fields_base_read(): return {'date_created', 'last_connection'} @staticmethod def make_valid_nickname(nickname): return re.sub('[^a-zA-Z0-9_\.]', '', nickname) @validates('bio') def validates_bio(self, key, value): assert len(value) <= 5000, \ AssertionError("maximum length for bio: 5000") return value.strip() def get_id(self): """ Return the id of the user. """ return self.id def check_password(self, password): """ Check the password of the user. """ return check_password_hash(self.pwdhash, password) def __eq__(self, other): return self.id == other.id def __repr__(self): return '<User %r>' % (self.nickname)
class Feed(db.Model, RightMixin): """ Represent a feed. """ id = db.Column(db.Integer(), primary_key=True) title = db.Column(db.String(), default="") description = db.Column(db.String(), default="FR") link = db.Column(db.String(), nullable=False) site_link = db.Column(db.String(), default="") enabled = db.Column(db.Boolean(), default=True) created_date = db.Column(db.DateTime(), default=datetime.utcnow) filters = db.Column(db.PickleType, default=[]) private = db.Column(db.Boolean(), default=False) # cache handling etag = db.Column(db.String(), default="") last_modified = db.Column(db.String(), default="") last_retrieved = db.Column(db.DateTime(), default=datetime(1970, 1, 1)) # error logging last_error = db.Column(db.String(), default="") error_count = db.Column(db.Integer(), default=0) # relationship icon_url = db.Column(db.String(), db.ForeignKey("icon.url"), default=None) user_id = db.Column(db.Integer(), db.ForeignKey("user.id")) category_id = db.Column(db.Integer(), db.ForeignKey("category.id")) articles = db.relationship( Article, backref="source", lazy="dynamic", cascade="all,delete-orphan", order_by=desc(Article.date), ) # index idx_feed_uid_cid = Index("user_id", "category_id") idx_feed_uid = Index("user_id") # api whitelists @staticmethod def _fields_base_write(): return { "title", "description", "link", "site_link", "enabled", "filters", "last_error", "error_count", "category_id", } @staticmethod def _fields_base_read(): return {"id", "user_id", "icon_url", "last_retrieved"} @validates("title") def validates_title(self, key, value): return str(value).strip() @validates("description") def validates_description(self, key, value): return str(value).strip() def __repr__(self): return "<Feed %r>" % (self.title)
class User(db.Model, UserMixin, RightMixin): """ Represent a user. """ id = db.Column(db.Integer, primary_key=True) nickname = db.Column(db.String(), unique=True) pwdhash = db.Column(db.String()) automatic_crawling = db.Column(db.Boolean(), default=True) is_public_profile = db.Column(db.Boolean(), default=False) bio = db.Column(db.String(5000), default="") webpage = db.Column(db.String(), default="") twitter = db.Column(db.String(), default="") date_created = db.Column(db.DateTime(), default=datetime.utcnow) last_seen = db.Column(db.DateTime(), default=datetime.utcnow) # user rights is_active = db.Column(db.Boolean(), default=False) is_admin = db.Column(db.Boolean(), default=False) is_api = db.Column(db.Boolean(), default=False) # relationships categories = db.relationship( "Category", backref="user", cascade="all, delete-orphan", foreign_keys=[Category.user_id], ) feeds = db.relationship( "Feed", backref="user", cascade="all, delete-orphan", foreign_keys=[Feed.user_id], ) @staticmethod def _fields_base_write(): return {"login", "password"} @staticmethod def _fields_base_read(): return {"date_created", "last_connection"} @staticmethod def make_valid_nickname(nickname): return re.sub("[^a-zA-Z0-9_\.]", "", nickname) @validates("bio") def validates_bio(self, key, value): assert len(value) <= 5000, AssertionError( "maximum length for bio: 5000") return value.strip() def get_id(self): """ Return the id of the user. """ return self.id def check_password(self, password): """ Check the password of the user. """ return check_password_hash(self.pwdhash, password) def __eq__(self, other): return self.id == other.id def __repr__(self): return "<User %r>" % (self.nickname)