class Role(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(30), unique=True) users = db.relationship('User', back_populates='role') permissions = db.relationship('Permission', secondary=roles_permissions, back_populates='roles') @staticmethod def init_role(): roles_permissions_map = { 'Locked': ['FOLLOW', 'COLLECT'], 'User': ['FOLLOW', 'COLLECT', 'COMMENT', 'UPLOAD'], 'Moderator': ['FOLLOW', 'COLLECT', 'COMMENT', 'UPLOAD', 'MODERATE'], 'Administrator': [ 'FOLLOW', 'COLLECT', 'COMMENT', 'UPLOAD', 'MODERATE', 'ADMINISTER' ] } for role_name in roles_permissions_map: role = Role.query.filter_by(name=role_name).first() if role is None: role = Role(name=role_name) db.session.add(role) role.permissions = [] for permission_name in roles_permissions_map[role_name]: permission = Permission.query.filter_by( name=permission_name).first() if permission is None: permission = Permission(name=permission_name) db.session.add(permission) role.permissions.append(permission) db.session.commit()
class CurrencyPair(db.Model, BaseModel): __tablename__ = 'currency_pair' symbol = db.Column(db.String(15), unique=True, nullable=False) from_currency_id = db.Column(db.Integer, db.ForeignKey('currency.id'), nullable=False) from_currency = db.relationship("Currency", foreign_keys=[from_currency_id], lazy='subquery') to_currency_id = db.Column(db.Integer, db.ForeignKey('currency.id'), nullable=False) to_currency = db.relationship("Currency", foreign_keys=[to_currency_id], lazy='subquery') @classmethod def get_by_symbol(cls, symbol): currency_pair = cls.query.filter_by(symbol=symbol).first() if not currency_pair: raise NoCurrencyPairBySymbolException(symbol) return currency_pair def __repr__(self): return self.symbol def get_market_repr(self, market_name): if market_name == "Binance": return self.binance_repr elif market_name == "Bitmex": return self.bitmex_repr return self.symbol def get_market_order_repr(self, market_name): if market_name == "Binance": return self.binance_order_repr elif market_name == "Bitmex": return self.bitmex_repr return self.symbol @property def bitmex_repr(self): return "{}/{}".format(self.to_currency.short_name.upper(), self.from_currency.short_name.upper()) @property def binance_repr(self): return "{}{}".format(self.to_currency.short_name.upper(), self.from_currency.short_name.upper()) @property def binance_order_repr(self): return "{}/{}".format(self.to_currency.short_name.upper(), self.from_currency.short_name.upper())
class AnalysisModel(BaseModel): __tablename__ = 'analysis' #:Primary key of the Model id = db.Column(db.Integer, primary_key=True) #:The IAP ID of the Analyis results in IAP iap_id = db.Column(db.String, unique=True) #:The path, as SMB URL, where the exported IAP results are stored export_path = db.Column(db.String, nullable=True) #:The id of the IAP pipeline with which this analysis has been processed pipeline_id = db.Column(db.String, nullable=False) #:Timestamp to indicate the start time of the analysis started_at = db.Column(db.DateTime, nullable=True) #:Timestamp to indicate the end time of the analysis finished_at = db.Column(db.DateTime, nullable=True) #:Foreign key to the corresponding Timestamp timestamp_id = db.Column(db.Integer, db.ForeignKey('timestamp.id'), nullable=False) #:SQLAlchemy relationship to the corresponding Timestamp timestamp = db.relationship("TimestampModel", back_populates="analyses", single_parent=True) #:SQLAlchemy relationship to all Postprocessings which have been applied to this analysis postprocessings = db.relationship("PostprocessModel", back_populates="analysis", cascade="all, delete-orphan") #:SQLAlchemy relationship to all Snapshots processed by this analysis db.UniqueConstraint(timestamp_id, pipeline_id, name=u'uq_analysis_timestamp_id_pipeline_id') @staticmethod def get_or_create(timestamp_id, pipeline_id, session=None): if session is None: session = db.session try: return session.query(AnalysisModel).filter_by(timestamp_id=timestamp_id, pipeline_id=pipeline_id).one(), False except NoResultFound: entry = AnalysisModel(timestamp_id, pipeline_id) try: session.add(entry) session.flush() return entry, True except IntegrityError: session.rollback() return session.query(AnalysisModel).filter_by(timestamp_id=timestamp_id, pipeline_id=pipeline_id).one(), False def purge(self): shared_folder_map = current_app.config['SHARED_FOLDER_MAP'] for postprocess in self.postprocessings: postprocess.purge() local_path = get_local_path_from_smb(self.report_path, shared_folder_map) shutil.rmtree(local_path) for image in self.timestamp.snapshots.images.where(ImageModel.type == 'segmented'): db.session.delete(image) def __init__(self, timestamp_id, pipeline_id): self.timestamp_id = timestamp_id self.pipeline_id = pipeline_id def __repr__(self): return '<Analysis %d with Pipeline %r of timestamp %d>' % (self.id, self.pipeline_id, self.timestamp_id)
class SnapshotModel(BaseModel): __tablename__ = 'snapshot' #:Primary key of the Model id = db.Column(db.Integer, primary_key=True) #:Metadata for IAP measurement_tool = db.Column(db.String) #:The ID of the phenobox which was used to create this snapshot phenobox_id = db.Column(UUID(as_uuid=True), nullable=False) #:Metadata for IAP camera_position = db.Column( ENUM('vis.side', 'vis.top', 'fluo.top', 'fluo.side', 'nir.top', 'nir.side', 'ir.top', 'ir.side', name='camera_position_enum'), nullable=False, server_default='vis.side') #:Flag used to exclude this snapshot from analysis excluded = db.Column(db.Boolean, server_default='f', default=False, nullable=False) #:Foreign key to the corresponding Timestamp timestamp_id = db.Column(db.Integer, db.ForeignKey('timestamp.id'), nullable=False) #:SQLAlchemy relationship to the corresponding Timestamp timestamp = db.relationship("TimestampModel", back_populates="snapshots", single_parent=True) #:Foreign key to the corresponding Timestamp plant_id = db.Column(db.Integer, db.ForeignKey('plant.id'), nullable=False) #:SQLAlchemy relationship to the corresponding Plant plant = db.relationship("PlantModel", back_populates="snapshots", single_parent=True) #:SQLAlchemy relationship to all images belonging to this snapshot images = db.relationship("ImageModel", back_populates="snapshot", cascade="all, delete-orphan", lazy='dynamic') #:SQLAlchemy relationship to all analyses performed on this snapshot postprocesses = db.relationship("PostprocessModel", secondary='postprocess_snapshot', back_populates='snapshots') db.UniqueConstraint(plant_id, timestamp_id, name=u'uq_snapshot_plant_id_timestamp_id') def purge(self): # Only allow to delete a snapshot from an uncompleted timestamp if not self.timestamp.completed: shared_folder_map = current_app.config['SHARED_FOLDER_MAP'] raw_image_path = None for image in self.images: if image.type == 'raw': if raw_image_path is None: raw_image_path = get_local_path_from_smb(image.path, shared_folder_map) os.remove(os.path.join(raw_image_path, image.filename)) db.session.delete(image) db.session.delete(self) db.session.commit() return True else: return False # TODO throw exceptions instead of returning true or false def __init__(self, plant_id, timestamp_id, camera_position, measurement_tool, phenobox_id): self.plant_id = plant_id self.timestamp_id = timestamp_id self.camera_position = camera_position self.measurement_tool = measurement_tool self.phenobox_id = phenobox_id def __repr__(self): return '<Snapshot %d of plant %r>' % (self.id, self.plant.name)
class Tourister(Base): """ defines what a tourister can be """ __tablename__ = 'touristers' user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) firstname = db.Column(db.String(30), nullable=False) lastname = db.Column(db.String(30), nullable=False) middlename = db.Column(db.String(30)) username = db.Column(db.String(30), nullable=False) mainLocation = db.Column(db.String(30)) story = db.Column(db.String(800)) occupations = db.relationship('Occupation', backref='tourister', lazy='dynamic') languages = db.relationship('Language', backref='tourister', lazy='dynamic') trips = db.relationship('Trip', backref='tourister', lazy='dynamic') paypalInfo = db.relationship('PaypalInfo', backref='tourister') education = db.relationship('Education', backref='tourister', lazy='dynamic') socialNetworks = db.relationship("SocialNetwork", backref='tourister', lazy='dynamic') testimonials = db.relationship("Testimonial", backref='tourister', lazy='dynamic') activities = db.relationship('Activity', backref='tourister', lazy='dynamic') images = db.relationship("Image", secondary='tourister_images')
class Service(Base): """ services a tourister can offer """ __tablename__ = 'services' trip_id = db.Column(db.Integer, db.ForeignKey('trips.id'), nullable=False) type = db.Column(db.String(30)) perks = db.relationship('ServicePerks', backref='service', lazy='dynamic') details = db.relationship('RideshareDetail', backref='service', uselist=False)
class User(UserMixin, db.Model, BaseModel): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) first_name = db.Column(db.String, nullable=True) last_name = db.Column(db.String, nullable=True) full_name = db.Column(db.String, nullable=True) avatar_url = db.Column(db.String, nullable=True) is_active = db.Column(db.Boolean, nullable=False, default=True) # password_hash = db.Column(db.String(255), nullable=False) registered_on = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) # admin = db.Column(db.Boolean, nullable=False, default=False) roles = db.relationship('UserRole', secondary='users_user_roles', lazy='dynamic', backref=db.backref('users', lazy=True)) symbols = db.relationship('CurrencyPair', secondary=symbol_subscribers, lazy='subquery', backref=db.backref('users', lazy=True)) buy_percentage = db.Column(db.Float, nullable=True, default=0.5) sell_percentage = db.Column(db.Float, nullable=True, default=0.5) close_bet_interval_in_minutes = db.Column(db.Float, nullable=True, default=10) def __repr__(self): return '<User {0}>'.format(self.email) def add_role(self, role_name): try: role = UserRole.query.filter_by(role_name=role_name).first() if role not in self.roles: return self.roles.append(role) else: return self.roles except exc.IdentifierError: pass def get_full_name(self): return "{0} {1}".format(self.first_name, self.last_name) @property def get_user_roles_names_list(self): return [each.role_name for each in self.roles]
class Collect(db.Model): collector_id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True) collected_id = db.Column(db.Integer, db.ForeignKey('photo.id'), primary_key=True) timestamp = db.Column(db.DateTime, default=datetime.utcnow) collector = db.relationship('User', back_populates='collections', lazy='joined') collected = db.relationship('Photo', back_populates='collectors', lazy='joined')
class ImageModel(BaseModel): __tablename__ = 'image' #:Primary key of the Model id = db.Column(db.Integer, primary_key=True) #:The path, as SMB URL, to the image file path = db.Column(db.String, nullable=False) #:The filename of the image filename = db.Column(db.String, nullable=False) #:The type of the image. Indicates whether this image was processed or not type = db.Column(ENUM('raw', 'segmented', name='image_type_enum'), default="raw", server_default='raw', nullable=False) #:The angle at which the image was taken angle = db.Column(db.Integer, nullable=False) #:Foreign key to the corresponding Snapshot snapshot_id = db.Column(db.Integer, db.ForeignKey('snapshot.id'), nullable=False) #:SQLAlchemy relationship to the corresponding Snapshot snapshot = db.relationship("SnapshotModel", back_populates="images", single_parent=True) # TODO add unique constraint for snapshot_id and path+filename def __init__(self, snapshot_id, path, filename, angle, image_type): self.snapshot_id = snapshot_id self.path = path self.filename = filename self.type = image_type self.angle = angle def __repr__(self): return '<Image %d of plant %r>' % (self.id, self.filename)
class Transaction(BaseExchangeMixin, db.Model, BaseModel): __tablename__ = 'transactions' price = db.Column(db.Float, nullable=False) sell_amount = db.Column(db.Float, nullable=False) buy_amount = db.Column(db.Float, nullable=False) fee = db.Column(db.Float, nullable=False) previous_balance_from = db.Column(db.Float, nullable=False) previous_balance_to = db.Column(db.Float, nullable=False) after_balance_from = db.Column(db.Float, nullable=False) after_balance_to = db.Column(db.Float, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) user = db.relationship("User", foreign_keys=[user_id]) is_completed = db.Column(db.Boolean, unique=False, default=False) # average price buy/sell avg_buy_price = db.Column(db.Float, nullable=True, unique=False) avg_sell_price = db.Column(db.Float, nullable=True, unique=False) def __init__(self): pass def __repr__(self): return '<pair: {}>, <buy amount: {}>, <price: {}>, <fee: {}>, complete: {}'.format( self.currency_pair.symbol, self.buy_amount, self.price, self.fee, self.is_completed)
class Task(db.Model): __tablename__ = 'tasks' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(250), unique=True, nullable=False) description = db.Column(db.String) creation_date = db.Column(db.TIMESTAMP, server_default=db.func.current_timestamp(), nullable=False) status = db.Column(db.Integer, nullable=False, default=0) # Relationships users = db.relationship('User', secondary=task_users, backref=db.backref('tasks')) @hybrid_property def nr_users(self): return len(self.annotations) def update_users(self, user_ids): new_users = db.session.query(User).filter(User.id.in_(user_ids)).all() self.users = new_users db.session.commit() def __init__(self, name, status=0): self.name = name self.status = status
class Follow(db.Model): follower_id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True) followed_id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True) timestamp = db.Column(db.DateTime, default=datetime.utcnow) follower = db.relationship('User', foreign_keys=[follower_id], back_populates='following', lazy='joined') followed = db.relationship('User', foreign_keys=[followed_id], back_populates='followers', lazy='joined')
class Portfolio(db.Model, TimestampMixin): __tablename__ = "portfolio" id = db.Column(db.Integer(), db.Sequence("portfolio_id_seq"), primary_key=True) name = db.Column(db.String(50), nullable=False) info = db.Column(db.Text()) user_id = db.Column( UUID(as_uuid=True), db.ForeignKey("users.id", ondelete="CASCADE"), nullable=False, ) stocks = db.relationship("Stock", secondary="portfolio_stocks", backref="portfolio") holdings = db.relationship("Holding", cascade="all,delete", backref="portfolio", uselist=True) __table_args__ = (UniqueConstraint("name", "user_id", name="uq_portfolio_name_user_id"), ) def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) @property def json_short(self): return { "id": self.id, "name": self.name, "holdings": [holding.json for holding in self.holdings], "stocks": [stock.json_short for stock in self.stocks], } @property def json(self): return { "id": self.id, "name": self.name, "holdings": [holding.json for holding in self.holdings], "stocks": [stock.json for stock in self.stocks], }
class Post(ResourceMixin, db.Model): __tablename__ = 'posts' # Relationships comments = db.relationship('Comment', backref=db.backref('post', uselist=False), passive_deletes=True, lazy='dynamic') # Properties id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(100), index=True, unique=True, nullable=False) body = db.Column(db.ARRAY(db.String), nullable=False) summary = db.Column(db.String(250), nullable=False) img_src = db.Column(db.String(200)) thumbnail_src = db.Column(db.String(200)) view_count = db.Column(db.Integer, server_default='0') # Foreign Keys author_id = db.Column(db.Integer, db.ForeignKey('staff.id')) practice_area_id = db.Column(db.Integer, db.ForeignKey('practice_areas.id')) def __init__(self, **kwargs): # Call Flask-SQLAlchemy's constructor. super(Post, self).__init__(**kwargs) @hybrid_property def slug(self): return slugify(self.title) @classmethod def find_by_title(cls, title): """ Find client by user ID. :param user_id: user ID :type title: str :return: Client instance """ return cls.query.filter(cls.title == title).first() def to_json(self): return { 'id': self.id, 'title': self.title, 'author': self.author.user.first_last_name, 'body': self.body, 'summary': self.summary, 'practiceArea': self.practice_area.area, 'imgSrc': self.img_src, 'thumbnailSrc': self.thumbnail_src, 'created': self.created_on, 'updated': self.updated_on, 'views': self.view_count, 'authorPhoto': self.author.user.photo, 'slug': self.slug }
class Comment(db.Model): id = db.Column(db.Integer, primary_key=True) body = db.Column(db.Text) timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True) flag = db.Column(db.Integer, default=0) replied_id = db.Column(db.Integer, db.ForeignKey('comment.id')) author_id = db.Column(db.Integer, db.ForeignKey('user.id')) photo_id = db.Column(db.Integer, db.ForeignKey('photo.id')) photo = db.relationship('Photo', back_populates='comments') author = db.relationship('User', back_populates='comments') replies = db.relationship('Comment', back_populates='replied', cascade='all') replied = db.relationship('Comment', back_populates='replies', remote_side=[id])
class Notification(db.Model): id = db.Column(db.Integer, primary_key=True) message = db.Column(db.Text, nullable=False) is_read = db.Column(db.Boolean, default=False) timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True) receiver_id = db.Column(db.Integer, db.ForeignKey('user.id')) receiver = db.relationship('User', back_populates='notifications')
class Trip(Base): """ trips a tourister has done """ __tablename__ = 'trips' tourister_id = db.Column(db.Integer, db.ForeignKey('touristers.id'), nullable=False) name = db.Column(db.String(30)) summary = db.Column(db.String(500)) city = db.Column(db.String(30)) highlights = db.relationship('TripHighlight', backref='service', lazy='dynamic') pricing = db.relationship('TripPricing', backref='service', uselist=False) services = db.relationship('Service', backref='service', lazy='dynamic')
class Testimonial(Base): """ testimonials given by touristees """ tourister_id = db.Column(db.Integer, db.ForeignKey('touristers.id'), nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) user = db.relationship("User", uselist=False) story = db.Column(db.String(800), nullable=False)
class Photo(db.Model): id = db.Column(db.Integer, primary_key=True) description = db.Column(db.String(500)) filename = db.Column(db.String(64)) filename_s = db.Column(db.String(64)) filename_m = db.Column(db.String(64)) timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True) can_comment = db.Column(db.Boolean, default=True) flag = db.Column(db.Integer, default=0) author_id = db.Column(db.Integer, db.ForeignKey('user.id')) author = db.relationship('User', back_populates='photos') comments = db.relationship('Comment', back_populates='photo', cascade='all') collectors = db.relationship('Collect', back_populates='collected', cascade='all') tags = db.relationship('Tag', secondary=tagging, back_populates='photos')
class PlantModel(BaseModel): __tablename__ = 'plant' #:Primary key of the Model id = db.Column(db.Integer, primary_key=True) #:The detailed name of the plant name = db.Column(db.String(80)) #:The index of the plant in the group index = db.Column(db.Integer) #:Foreign key to the corresponding Sample Group sample_group_id = db.Column(db.Integer, db.ForeignKey('sample_group.id')) #:SQLAlchemy relationship to the corresponding Sample Group sample_group = db.relationship("SampleGroupModel", back_populates="plants", single_parent=True) #:SQLAlchemy relationship to all Snapshots that belong to this plant snapshots = db.relationship("SnapshotModel", back_populates="plant", cascade="all, delete-orphan") db.UniqueConstraint(index, sample_group_id, name=u'uq_plant_index_sample_group_id') @hybrid_property def full_name(self): if self.name != '': return '{}_{}_{}'.format(self.sample_group.name, self.index, self.name) else: return '{}_{}'.format(self.sample_group.name, self.index) def purge(self): for snapshot in self.snapshots: snapshot.purge() def __init__(self, index, name, sample_group_id): self.index = index self.name = name self.sample_group_id = sample_group_id def __repr__(self): return '<Plant %r>' % self.name
class Activity(Base): """ activities a tourister has done """ tourister_id = db.Column(db.Integer, db.ForeignKey('touristers.id'), nullable=False) image_id = db.Column(db.Integer, db.ForeignKey('image.id'), nullable=False) detail = db.Column(db.String(300), nullable=False) image = db.relationship("Image", uselist=False)
class UserUserRole(db.Model, BaseModel): __tablename__ = 'users_user_roles' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id')) product_id = db.Column(db.Integer, db.ForeignKey('user_roles.id')) creation_date = db.Column(db.DateTime, default=datetime.utcnow) user = db.relationship(User, lazy='subquery', backref=db.backref("users_user_roles", cascade="all, delete-orphan", lazy=True)) user_role = db.relationship(UserRole, lazy='subquery', backref=db.backref( "users_user_roles", cascade="all, delete-orphan", lazy=True))
class TimestampModel(BaseModel): __tablename__ = 'timestamp' #:Primary key of the Model id = db.Column(db.Integer, primary_key=True) #:The IAP ID of the correspond File Import in IAP iap_exp_id = db.Column(db.String, unique=True) #: Indicates whether this timestamp is completed and a new one should created for future snapshots completed = db.Column(db.Boolean, server_default='f', default=False, nullable=False) #:Foreign key to the Experiment experiment_id = db.Column(db.Integer, db.ForeignKey('experiment.id'), nullable=False) #:SQLAlchemy relationship to the experiment experiment = db.relationship("ExperimentModel", back_populates="timestamps", single_parent=True) #:SQLAlchemy relationship to all corresponding snapshots snapshots = db.relationship("SnapshotModel", order_by="SnapshotModel.created_at", back_populates="timestamp", cascade="all, delete-orphan") #:SQLAlchemy relationship to all corresponding analyses analyses = db.relationship("AnalysisModel", order_by="AnalysisModel.created_at", back_populates="timestamp", cascade="all, delete-orphan") __table_args__ = (Index('idx_unique_open_timestamp', 'experiment_id', 'completed', unique=True, postgresql_where=Column('completed') == False), ) def __init__(self, experiment_id): self.experiment_id = experiment_id def __repr__(self): return '<Timestamp of experiment %r>' % self.experiment_id
class File(db.Model): id = db.Column(db.Integer, primary_key=True) description = db.Column(db.String(500)) filename = db.Column(db.String(64)) timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True) can_comment = db.Column(db.Boolean, default=True) flag = db.Column(db.Integer, default=0) author_id = db.Column(db.Integer, db.ForeignKey('user.id')) enc_flag = db.Column(db.Boolean, default=False) enc_policy = db.Column(db.String(200)) author = db.relationship('User', back_populates='files')
class User(db.Model, TimestampMixin): __tablename__ = "users" id = db.Column(UUID(as_uuid=True), primary_key=True, nullable=False, default=uuid4) email = db.Column(db.String(255), nullable=False) first_name = db.Column(db.String(255), nullable=False) last_name = db.Column(db.String(255), nullable=False) password = db.Column(PasswordType(schemes=["bcrypt"])) is_active = db.Column(db.Boolean(), nullable=False, server_default="1") confirmed = db.Column(db.Boolean(), nullable=False, server_default="0") email_confirmed_at = db.Column(db.DateTime()) last_logged_in = db.Column(db.DateTime()) roles = db.relationship("Role", secondary="user_roles") __table_args__ = (UniqueConstraint("email", name="uq_users_email"), ) def __init__(self, *args, **kwargs): super(User, self).__init__(*args, **kwargs) if not self.password: self.password = binascii.hexlify(os.urandom(24)).decode() @classmethod def auth(cls, **kwargs): email = kwargs.get("email") password = kwargs.get("password") if not email or not password: return None user = cls.query.filter_by(email=email).first() if not user or user.password != password: return None return user @property def json(self): return { "id": self.id, "first_name": self.first_name, "last_name": self.last_name, "email": self.email, # "portfolios": [portfolio.json for portfolio in self.portfolios], } def __repr__(self): return ( f"User(id={self.id}, email={self.email}, first_name={self.first_name}, " f"last_name={self.last_name}), confirmed={self.confirmed}")
class PracticeArea(ResourceMixin, db.Model): __tablename__ = 'practice_areas' # Relationships posts = db.relationship('Post', backref=db.backref('practice_area', lazy="joined"), lazy='dynamic') matters = db.relationship('Matter', backref='practice_areas', secondary=practice_area_matter) # Properties id = db.Column(db.Integer, primary_key=True) area = db.Column(db.String(128), nullable=False, unique=True, index=True) img_src = db.Column(db.String(200)) thumbnail_src = db.Column(db.String(200)) description = db.Column(db.ARRAY(db.String), nullable=False) slug = db.Column(db.String(128), nullable=False, unique=True, index=True) @classmethod def get_by_slug(cls, slug): return PracticeArea.query.filter(PracticeArea.slug == slug).first() def to_json_short(self): return { 'id': self.id, 'area': self.area } def to_json(self): return { 'id': self.id, 'area': self.area, 'imgSrc': self.img_src, 'thumbnailSrc': self.thumbnail_src, 'posts': [post.id for post in self.posts], 'matters': [matter.id for matter in self.matters], 'staff': [staff_member.id for staff_member in self.staff], 'description': self.description, 'slug': self.slug }
class User(Base): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) tourister = db.relationship('Tourister', backref='user', uselist=False) def __init__(self, email, password, admin=False): self.email = email self.password = bcrypt.generate_password_hash( password, app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8') self.admin = admin
class RememberedPoints(BaseModel, db.Model): __tablename__ = 'remembered_points' timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow, nullable=False) price = db.Column(db.Float, nullable=False) bet_id = db.Column(db.Integer, db.ForeignKey('prediction_bets.id'), nullable=False, index=True) bet = db.relationship("PredictionBet", foreign_keys=[bet_id], lazy='subquery')
class UserRole(db.Model, BaseModel): """This model created for custom permission role_name: is the permissions' name. It can be "owner" or screens' name ("order history") for which user has permission""" __tablename__ = 'user_roles' id = db.Column(db.Integer, primary_key=True, autoincrement=True) role_name = db.Column(db.String, unique=True, nullable=False) roles = db.relationship('User', secondary='users_user_roles', lazy='dynamic', backref=db.backref('user_roles', lazy=True)) def __repr__(self): return '<Role {0}>'.format(self.role_name)
class User(ResourceMixin, db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(24), unique=True, index=True) password = db.Column(db.String(128), nullable=False, server_default='') comments = db.relationship(Comment, backref='users', passive_deletes=True) def __init__(self, **kwargs): # Call Flask-SQLAlchemy's constructor. super(User, self).__init__(**kwargs) self.password = self.encrypt_password(kwargs.get('password', '')) def encrypt_password(cls, plaintext_password): """ Hash a plaintext string. :param plaintext_password: Password in plain text :type plaintext_password: str :return: str """ if plaintext_password: return pwd_context.encrypt(plaintext_password) return None def verify_password(self, password): return pwd_context.verify(password, self.password) def serialize(self): """ Return JSON fields to render the user. :return: dict """ params = { 'id': self.id, 'username': self.username, 'comments': [ _c.serialize(lite=True) for _c in Comment.query.filter(Comment.user_id == self.id) ] } return params