class ShelterDocument(db.Model): """ Represent a document for a shelter. """ id = db.Column(db.Integer, primary_key=True) file_name = db.Column(db.String(), default='') # 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 KeyPair(db.Model, Ext): id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column( db.Text, nullable=False, unique=True) # gives information about the receiver of the secret key secret_key = db.Column(db.Text, nullable=False) # the actual secret key user_id = db.Column( db.Integer, db.ForeignKey('user.id'), nullable=False) # gives information about the author of the secret key def __init__(self, email, secret_key, user_id): self.email = email self.secret_key = secret_key self.user_id = user_id
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 FeedSet(db.Model): """Represents a set of feeds. """ id = db.Column(db.Integer(), primary_key=True) title = db.Column(db.String(), default="") description = db.Column(db.String(), default="") date_created = db.Column(db.DateTime(), default=datetime.utcnow()) ui_position = db.Column(db.Integer(), default=0) # relationships feeds = db.relationship(Feed, backref='set', cascade='all, delete-orphan', foreign_keys=[Feed.set_id])
class Tag(db.Model): __table_args__ = {'schema': schema} id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String) value = db.Column(db.Text) feature_id = db.Column(db.Integer, db.ForeignKey(schema + '.feature.id')) feature = db.relationship('Feature', backref=db.backref('tags')) def __repr__(self): return u"Tag <%s:%s>" % (self.name.encode('utf-8'), self.value.encode('utf-8'))
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 Item(db.Model): id = db.Column(db.Integer, primary_key=True) detail = db.Column(db.String(80), nullable=False) free_space = db.Column(db.Boolean, nullable=False, default=False) project_id = db.Column(db.Integer, db.ForeignKey('project.id'), nullable=False) project = relationship('Project', back_populates='items') def __repr__(self): return str(self) def __str__(self): return f'{self.__class__.__name__}({self.id}): {self.detail}'
class Feature(db.Model): __table_args__ = {'schema': schema} id = db.Column(db.Integer, primary_key=True) gid = db.Column(db.Integer) name = db.Column(db.String) label = db.Column(db.Text) # rendering = db.Column(db.String) geom = db.Column(Geometry('POINT', srid=4326)) shape = ShapeProperty() version = db.Column(db.Integer, db.Sequence('feature_version_seq', schema=schema)) timestamp = db.Column(db.TIMESTAMP) last_contributor_id = db.Column(db.Integer, db.ForeignKey('user.id')) last_contributor = db.relationship('User') def tag(self, tag_name, value): tags = dict([(tag.name, tag) for tag in self.tags]) tag = tags.get(tag_name, None) if tag: tag.value = value else: tag = Tag() tag.feature = self tag.name = tag_name tag.value = value db.session.add(tag) def annotate(self, annotation): self.tag('annotation', annotation) def stamp(self): self.version = db.engine.execute( "SELECT nextval('%s.feature_version_seq')" % schema).scalar() self.timestamp = datetime.now() return self def __repr__(self): return 'Feature <%d> %s' % (self.id, self.name.encode('utf-8')) @property def properties(self): data = dict({ 'name': self.name, 'label': self.label, 'version': self.version, 'timestamp': self.timestamp.isoformat(), 'user_id': self.last_contributor_id, 'user_email': self.last_contributor and self.last_contributor.email or None }) tags = dict([(tag.name, tag.value) for tag in self.tags]) data['tags'] = tags return data
class Client(db.Model, Ext): name = db.Column(db.String(40)) description = db.Column(db.String(400)) user_id = db.Column(db.ForeignKey('user.id')) user = db.relationship('User') client_id = db.Column(db.String(40), primary_key=True) client_secret = db.Column(db.String(55), unique=True, index=True, nullable=False) is_confidential = db.Column(db.Boolean) _redirect_uris = db.Column(db.Text) _default_scopes = db.Column(db.Text) @property def client_type(self): if self.is_confidential: return 'confidential' return 'public' @property def redirect_uris(self): if self._redirect_uris: return self._redirect_uris.split() return [] @property def default_redirect_uri(self): return self.redirect_uris[0] @property def default_scopes(self): if self._default_scopes: return self._default_scopes.split() return []
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 BookmarkTag(db.Model): id = db.Column(db.Integer, primary_key=True) text = db.Column(db.String, unique=False) # foreign keys user_id = db.Column(db.Integer, db.ForeignKey('user.id', ondelete='CASCADE')) bookmark_id = db.Column(db.Integer, db.ForeignKey('bookmark.id', ondelete='CASCADE')) # relationships bookmark = db.relationship('Bookmark', back_populates='tags', cascade="all,delete", foreign_keys=[bookmark_id])
class Tag(db.Model): text = db.Column(db.String(), primary_key=True, unique=False) # foreign keys project_id = db.Column(db.Integer, db.ForeignKey('project.id', ondelete='CASCADE'), primary_key=True) # relationships project = db.relationship('Project', back_populates='tag_objs', foreign_keys=[project_id]) def __init__(self, text, project_id): self.text = text self.project_id = project_id
class ArticleTag(db.Model): text = db.Column(db.String, primary_key=True, unique=False) # foreign keys article_id = db.Column(db.Integer, db.ForeignKey("article.id", ondelete="CASCADE"), primary_key=True) # relationships article = db.relationship("Article", back_populates="tag_objs", foreign_keys=[article_id]) def __init__(self, text): self.text = text
class Category(db.Model, RightMixin): id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String()) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) idx_category_uid = Index('user_id') # api whitelists @staticmethod def _fields_base_read(): return {'id', 'user_id'} @staticmethod def _fields_base_write(): return {'name'}
class Book(db.Model): __tablename__ = "books" id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(255), unique=False, nullable=False) author = db.Column(db.String(255), unique=False, nullable=False) def __repr__(self): return f'Books {self.title}' def response(book): return jsonify({ 'id': book.id, 'title': book.title, 'author': book.author })
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 BookmarkTag(db.Model): id = db.Column(db.Integer, primary_key=True) text = db.Column(db.String, unique=False) # foreign keys user_id = db.Column(db.Integer, db.ForeignKey("user.id", ondelete="CASCADE")) bookmark_id = db.Column(db.Integer, db.ForeignKey("bookmark.id", ondelete="CASCADE")) # relationships bookmark = db.relationship( "Bookmark", back_populates="tags", cascade="all,delete", foreign_keys=[bookmark_id], )
class Organization(db.Model): """Represent an organization. """ id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(100), unique=True) description = db.Column(db.String()) website = db.Column(db.String()) last_updated = db.Column(db.DateTime(), default=datetime.utcnow()) cve_vendor = db.Column(db.String(), default='') # foreign keys icon_url = db.Column(db.String(), db.ForeignKey('icon.url'), default=None) # relationship projects = db.relationship(Project, backref='organization', lazy='dynamic', cascade='all,delete-orphan') @validates('name') def validates_bio(self, key, value): assert len(value) <= 100, \ AssertionError("maximum length for name: 100") return value.replace(' ', '').strip()
class Campaign(db.Model): # QeBWZ8BZBozoT8y id = db.Column(db.String(length=8), primary_key=True) title = db.Column(db.String(length=100)) description = db.Column(db.Text) schema = db.Column(db.String(length=32)) # feature_type_id = db.Column(db.Integer, db.ForeignKey('feature_type.id')) # feature_type = db.relationship('FeatureType') admin_id = db.Column(db.Integer, db.ForeignKey('user.id')) admin = db.relationship('User') admin_token = db.Column(db.String(length=16)) created_at = db.Column(db.Date) closing_at = db.Column(db.Date) closed = db.Column(db.Boolean)
class Section(db.Model): """ Represent a section. """ id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(), default='') # relationships categories = db.relationship('Category', backref='section', lazy='dynamic', cascade='all, delete-orphan') def __str__(self): """ Required for administrative interface. """ return self.name def __repr__(self): return '<User %r>' % (self.name)
class Value(db.Model): """ Represent a value of an attribute. """ id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(), nullable=False) # relationship attribute_id = db.Column(db.Integer, db.ForeignKey('attribute.id'), nullable=False) #properties = db.relationship('Property', backref='value', lazy='dynamic', #cascade='all, delete-orphan', #order_by=desc('Property.id')) def __str__(self): """ Required for administrative interface. """ return str(self.id)
class Category(db.Model, RightMixin): id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String()) # relationships user_id = db.Column(db.Integer, db.ForeignKey('user.id')) feeds = db.relationship('Feed', cascade='all,delete-orphan') articles = db.relationship('Article', cascade='all,delete-orphan') # index idx_category_uid = Index('user_id') # api whitelists @staticmethod def _fields_base_read(): return {'id', 'user_id'} @staticmethod def _fields_base_write(): return {'name'}
class Commune(db.Model): __tablename__ = "communes_wgs84" __table_args__ = { "schema": "bdtopo" } gid = db.Column(db.Integer, primary_key=True) id = db.Column(db.String) code_insee = db.Column(db.String(5)) nom = db.Column(db.String) geom = db.Column('geom_lowres', Geometry('MULTIPOLYGON', srid=4326)) centroid = db.Column(Geometry('POINT', srid=4326)) @property def shape(self): return shape.to_shape(self.geom) @property def properties(self): return { "id": self.id, "code_insee": self.code_insee, "nom": self.nom }
class Template(db.Model): """Message templates for our website""" pk = db.Column(db.Integer, primary_key=True) body = db.Column(db.String(120), nullable=False) message_type = db.Column(db.String, nullable=False) @validates("message_type") def validate_type(self, key, value): assert value in MESSAGE_TYPES return value def __init__(self, body, message_type): self.body = body self.message_type = message_type def to_dict(self): return { "pk": self.pk, "body": self.body, "message_type": self.message_type }
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 Product(db.Model): """Products for our website""" pk = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(60), nullable=False) price = db.Column(db.Float, nullable=False) description = db.Column(db.String(120)) def __init__(self, name, price, description): self.name = name self.price = price self.description = description def __repr__(self): return "Product {} @ {}".format(self.name, self.price) def to_dict(self): return { "pk": self.pk, "name": self.name, "price": self.price, "description": self.description, }
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 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 User(db.Model, UserMixin): """ 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()) roles = db.relationship('Role', backref='user', lazy='dynamic') activation_key = db.Column(db.String(128), default=hashlib.sha512( str(random.getrandbits(256)).encode("utf-8")).hexdigest()[:86]) date_created = db.Column(db.DateTime(), default=datetime.now) last_seen = db.Column(db.DateTime(), default=datetime.now) feeds = db.relationship('Feed', backref='subscriber', lazy='dynamic', cascade='all,delete-orphan') refresh_rate = db.Column(db.Integer, default=60) # in minutes @staticmethod def make_valid_nickname(nickname): return re.sub('[^a-zA-Z0-9_\.]', '', nickname) 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 is_admin(self): """ Return True if the user has administrator rights. """ return "admin" in [role.name for role in self.roles] def __eq__(self, other): return self.id == other.id def __repr__(self): return '<User %r>' % (self.nickname)
def create_mat_view(name, selectable, metadata=db.metadata): """Creates a materialized view table""" _mt = db.MetaData() # temp metadata just for initial Table object creation t = db.Table(name, _mt) # the actual mat view class is bound to db.metadata for c in selectable.c: t.append_column(db.Column(c.name, c.type, primary_key=c.primary_key)) db.event.listen( metadata, 'after_create', CreateMaterializedView(name, selectable) ) db.event.listen( metadata, 'before_drop', db.DDL('DROP MATERIALIZED VIEW IF EXISTS ' + name) ) return t