class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64), index=True, unique=True) type = db.Column(db.String(64), index=True) __mapper_args__ = {'polymorphic_on': type} @classmethod def filter_by(cls, name, user_type=None): if user_type is None: return cls.query.filter_by(name=name).all() else: return cls.query.filter_by(name=name, type=user_type).all() def __repr__(self): return '<User id:{}, name:{}, type:{}>'.format(self.id, self.name, self.type) def create(self): db.session.add(self) db.session.commit() def serialize(self): return { 'id': self.id, 'name': self.name, 'type': self.type, }
class ConceptQueueEntry(db.Model): __tablename__ = 'concept_queues_entries' id = db.Column(db.Integer, primary_key=True) clientId = db.Column(db.Integer, db.ForeignKey('clients.id')) conceptQueueId = db.Column(db.Integer, db.ForeignKey('concept_queues.id')) state = db.Column(db.String(64), index=True) def __repr__(self): return '<ConceptQueueEntry id:{}, clientId:{}, conceptQueueId:{}, state:{}>'.\ format(self.id, self.clientId, self.conceptQueueId, self.state) def serialize(self): return { 'id': self.id, 'clientId': self.clientId, 'conceptQueueId': self.conceptQueueId, 'state': self.state } def serialize_external(self): return { "message": "Client has enqueued correctly", "position": self.get_concept_queue().position(self.clientId) } def get_concept_queue(self): return use_cases.get_queue(self.conceptQueueId) def create(self): db.session.add(self) db.session.commit() def delete(self): db.session.delete(self) db.session.commit()
class Product(db.Model): __tablename__ = "products" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String()) def __repr__(self): return '<id {}>'.format(self.id)
class Author(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64), index=True, unique=True) books = db.relationship('Book', backref='writer', lazy='dynamic') def __repr__(self): return '<{}>'.format(self.name)
class Product(db.Model): __tablename__ = "products" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String()) def __repr__(self): return f"<id {self.id} - {self.name}>"
class Source(db.Model): id = db.Column(db.Integer, primary_key=True) link = db.Column(db.String(1000)) articletitle = db.Column(db.String(1000)) author = db.Column(db.String(1000)) releaseyear = db.Column(db.Integer) parameter = db.relationship('Parameter', backref='source', lazy=True)
class Product(db.Model): __tablename__ = "products" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String()) description = db.Column(db.Text()) def __repr__(self): return f'<id {self.id}>'
class Tweet(db.Model): __tablename__ = "tweets" id = db.Column(db.Integer, primary_key=True) text = db.Column(db.String()) created_at = db.Column(db.String()) def __repr__(self): return '<id {}>'.format(self.id)
class Technology(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), unique=True, nullable=False) parameter = db.relationship('Parameter', backref='technology', lazy=True) level = db.Column(db.Integer, nullable=False) def __repr__(self): return self.name
class User(db.Model): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String()) api_token = db.Column(db.String(), default=uuid.uuid4) #tweets_id = Column(Integer, ForeignKey('tweets.id')) def __repr__(self): return '<id {}>'.format(self.id)
class Product(db.Model): __tablename__ = "products" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String()) description = db.Column(db.Text()) image_url = db.Column(db.String(), default='https://picsum.photos/180/50/') def __repr__(self): return '<id {}>'.format(self.id)
class Book(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(64)) genre = db.Column(db.String(64)) description = db.Column(db.String()) author_id = db.Column(db.Integer, db.ForeignKey('author.id')) def __repr__(self): return '<{}>'.format(self.title)
class User(db.Model): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String()) password = "******" email = db.Column(db.String()) api_key = db.Column(db.String()) def __repr__(self): return '<id {}>'.format(self.id)
class User(UserMixin, db.Model): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(120), index=True, unique=True) token = db.Column(db.String(128), index=True, unique=True) counter = db.Column(db.Integer, default=0) def __repr__(self): return f'<User {self.email}>' def set_token(self, email): self.token = generate_password_hash(email)
class Tweet(db.Model): __tablename__ = "tweets" id = db.Column(db.Integer, primary_key=True) text = db.Column(db.String()) created_at = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow) updated_at = db.Column(db.DateTime, onupdate=datetime.datetime.utcnow) created_by = db.Column(db.Integer, db.ForeignKey('users.id')) def __repr__(self): return '<id {}>'.format(self.id)
class Product(db.Model): __tablename__ = "products" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String()) description = db.Column(db.Text()) # def __init__(self, name, description): # self.name = name # self.description = description def __repr__(self): return '<id {}>'.format(self.id)
class RevokedTokenModel(db.Model): __tablename__ = 'revoked_tokens' id = db.Column(db.Integer, primary_key=True) jti = db.Column(db.String(120)) def add(self): db.session.add(self) db.session.commit() @classmethod def is_jti_blacklisted(cls, jti): query = cls.query.filter_by(jti=jti).first() return bool(query)
class MenuItem(db.Model): __tablename__ = 'menu_item' id = db.Column(db.Integer, primary_key=True) cook_time = db.Column(db.Integer) name = db.Column(db.String()) def __init__(self, name, cook_time): self.cook_time = cook_time self.name = name def __repr__(self): return '<name: {}, cook_time {}>'.format(self.name, self.cook_time)
class Document(Base): __tablename__ = 'documents' id = db.Column('id', db.Integer, primary_key=True) title = db.Column('title', db.String, nullable=False) content = db.Column('content', db.Text, nullable=False) created_at = db.Column('created_at', db.DateTime, nullable=False, default=db.func.now()) def __init__(self, title: str, content: str): self.title = title self.content = content
class OrderItem(db.Model): __tablename__ = 'order_item' id = db.Column(db.Integer, primary_key=True) order_id = db.Column(db.Integer, db.ForeignKey('received_order.id')) name = db.Column(db.String()) price_per_unit = db.Column(db.Integer) quantity = db.Column(db.Integer) status = db.Column(db.String()) created_at = db.Column(db.DateTime(), default=datetime.utcnow) completed_at = db.Column(db.DateTime(), default=None) def __init__(self, order_id, name, price_per_unit, quantity, status=CssConstants.ORDER_RECEIVED): self.order_id = order_id self.name = name self.price_per_unit = price_per_unit self.quantity = quantity self.status = status def __repr__(self): return '<order_id: {}, id {}>'.format(self.order_id, self.id)
class Result(db.Model): __tablename__ = 'results' id = db.Column(db.Integer, primary_key=True) url = db.Column(db.String()) result_all = db.Column(JSON) result_no_stop_words = db.Column(JSON) def __init__(self, url, result_all, result_no_stop_words): self.url = url self.result_all = result_all self.result_no_stop_words = result_no_stop_words def __repr__(self): return '<id {}>'.format(self.id)
class UserModel(General): __tablename__ = 'users' id = db.Column(db.String(120), primary_key=True, default=uuid.uuid4().__str__) username = db.Column(db.String(120), unique=True, nullable=True) email = db.Column(db.String(120), unique=True, nullable=False) password = db.Column(db.String(120), nullable=False) @staticmethod def generate_hash(password): return bcrypt.hashpw(password=password.encode(), salt=bcrypt.gensalt()) @staticmethod def verify_hash(password, hashed): return bcrypt.checkpw(password.encode(), hashed) def save_to_db(self): db.session.add(self) db.session.commit() @classmethod def find_user_by_email(cls, email): # return cls.query.filter_by(email=email).first() return cls.return_one({'col': 'email', 'value': email}, as_model=True) # @classmethod # def return_all(cls): # def to_json(x): # return { # 'email':x.email, # 'password':x.password.decode() # } # return { # 'users': list(map(lambda x: to_json(x), UserModel.query.all())) # } @classmethod def delete_all(cls): try: num_row_deleted = db.session.query(cls).delete() db.session.commit() return {"message": f"{num_row_deleted} row(s) was deleted"} except: return {"message": "Something went wrong"}, 500
class User(db.Model): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String()) password_hash = db.Column(db.String(128)) salt = db.Column(db.String, nullable=False, default=str(uuid.uuid4().hex)) #api_key = db.Column(db.String(128), nullable=False, default) tweet = db.relationship("Tweet") def __repr__(self): return '<id {}>'.format(self.id) def hash_password(self, password): saltPassword = password + str(self.salt) self.password_hash = pwd_context.encrypt(saltPassword) def verify_password(self, password): saltPassword = password + str(self.salt) return pwd_context.verify(saltPassword, self.password_hash)
class Parameter(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), nullable=False) value = db.Column(db.Float) technology_name = db.Column(db.String, db.ForeignKey('technology.name'), nullable=False) source_id = db.Column(db.Integer, db.ForeignKey('source.id'), nullable=False) unit = db.Column(db.String(50))
class CssOrder(db.Model): __tablename__ = 'received_order' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String()) service = db.Column(db.String()) status = db.Column(db.String()) items_in_order = db.Column(db.Integer()) completed_items_in_order = db.Column(db.Integer()) ordered_at = db.Column(db.DateTime()) created_at = db.Column(db.DateTime(), default=datetime.utcnow) completed_at = db.Column(db.DateTime(), default=None) def __init__(self, name, service, items_in_order, ordered_at, status=CssConstants.ORDER_RECEIVED, completed_items_in_order=0): self.name = name self.service = service self.items_in_order = items_in_order try: self.ordered_at = datetime.strptime(ordered_at, "%Y-%m-%dT%H:%M:%S") except ValueError: try: self.ordered_at = datetime.strptime(ordered_at, "%Y-%m-%dT%H:%M:%S.%f") except ValueError: self.ordered_at = datetime.utcnow() self.status = status self.completed_items_in_order = completed_items_in_order def __repr__(self): return '<id {}>'.format(self.id)
class User(db.Model): """Data model for user accounts.""" __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), index=True, unique=True, nullable=False) email = db.Column(db.String(80), index=True, unique=True, nullable=False) password = db.Column(db.String(200), index=False, unique=False, nullable=False) createdBy = db.Column(db.String(200), index=False, unique=False, nullable=False) createdAt = db.Column(db.DateTime, index=False, unique=False, nullable=False) @property def serialize(self): """Return object data in easily serializable format""" created_by = User.query.filter_by(id=int(self.createdBy)).first() created_by_name = '' if created_by: created_by_name = created_by.username return { 'id': self.id, 'username': self.username, 'email': self.email, 'password': self.password, 'createdBy': { 'id': self.createdBy, 'username': created_by_name }, 'createdAt': dump_datetime(self.createdAt) # This is an example how to deal with Many2Many relations } def __repr__(self): return "<User {}>".format(self.username)
class Beacon_dataset_table(db.Model): ''' The `Beacon_dataset_table class` inherits the Model class from SQLAlchemy and creates the schema for the table `beacon_dataset_table` ''' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50)) description = db.Column(db.String(800)) assemblyId = db.Column(db.String(20)) createDateTime = db.Column(db.DateTime, default=datetime.date.today()) updateDateTime = db.Column(db.DateTime) version = db.Column(db.String(5)) variantCount = db.Column(db.Integer) callCount = db.Column(db.Integer) sampleCount = db.Column(db.Integer) externalUrl = db.Column(db.String(50)) accessType = db.Column(db.String(10))
class Beacon_data_table(db.Model): ''' The `Beacon_data_table class` inherits the Model class from SQLAlchemy and creates the schema for the table `genomes` ''' __tablename__ = 'genomes' id = db.Column(db.Integer, primary_key=True) dataset_id = db.Column(db.String(200)) start = db.Column(db.Integer) chromosome = db.Column(db.String(100)) reference = db.Column(db.String(200)) alternate = db.Column(db.String(200)) end = db.Column(db.Integer) type = db.Column(db.String(100)) sv_length = db.Column(db.Integer) variantCount = db.Column(db.Integer) callCount = db.Column(db.Integer) sampleCount = db.Column(db.Integer) frequency = db.Column(db.Float)
class AsciiTable(db.Model): __tablename__ = 'ascii_table' title = db.Column(db.String(512), primary_key=True) art = db.Column(LONGTEXT) date_created = db.Column(db.DateTime, default=datetime.utcnow)
from wsgi import db clients_conceptqueues_table = db.Table( 'association', db.Base.metadata, db.Column('client_id', db.Integer, db.ForeignKey('clients.id')), db.Column('concept_queue_id', db.Integer, db.ForeignKey('concept_queues.id'))) owners_conceptqueues_table = db.Table( 'association', db.Base.metadata, db.Column('owner_id', db.Integer, db.ForeignKey('owners.id')), db.Column('concept_queue_id', db.Integer, db.ForeignKey('concept_queues.id')))