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')))
