class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(255), unique=True)
username = db.Column(db.String(255), unique=True)
password = db.Column(db.Binary(60), nullable=False)
bodyweight = db.Column(db.Integer())
one_rep_max = db.relationship("OneRepMax")
imperial = db.Column(db.Boolean())
sessions = db.relationship("UserSession", lazy="dynamic")
def __init__(self, email, password, imperial=True, bodyweight=-1):
self.email = email
self.active = True
self.password = User.hashed_password(password)
self.imperial = imperial
self.bodyweight = bodyweight
@staticmethod
def hashed_password(password):
return bcrypt.generate_password_hash(password)
@staticmethod
def get_user_with_email_and_password(email, password):
user = User.query.filter_by(email=email).first()
if user and bcrypt.check_password_hash(user.password, password):
return user
else:
return None
class TestCase(db.Model):
__tablename__ = "test_case"
test_case_id = db.Column(db.Integer, primary_key=True)
test_suite_id = db.Column(db.ForeignKey(TestSuite.test_suite_id))
test_id = db.Column(db.String(80), nullable=True)
test_status = db.Column(db.Integer, nullable=True)
test_case_detail = db.Column(LONGTEXT, nullable=True)
test_name = db.Column(db.String(80), nullable=True)
src_db_id = db.Column(db.ForeignKey('dbdetail.db_id'))
target_db_id = db.Column(db.ForeignKey('dbdetail.db_id'))
created = db.Column(db.DateTime, default=datetime.datetime.now)
test_suite = db.relationship(TestSuite,
back_populates='test_case',
lazy=True)
test_case_log = db.relationship("TestCaseLog",
back_populates='test_cases',
lazy=True)
src_db = db.relationship("DbDetail", foreign_keys=[src_db_id])
target_db = db.relationship("DbDetail", foreign_keys=[target_db_id])
def save_to_db(self):
db.session.add(self)
db.session.commit()
def __init__(self, test_suite_id, test_id, test_status, test_case_detail,
test_name, src_db_id, target_db_id):
self.test_suite_id = test_suite_id
self.test_id = test_id
self.test_status = test_status
self.test_name = test_name
self.test_case_detail = test_case_detail
self.src_db_id = src_db_id
self.target_db_id = target_db_id
class TestCase(db.Model):
__tablename__ = "test_case"
test_case_id = db.Column(db.Integer, primary_key=True)
test_suite_id = db.Column(db.ForeignKey('test_suite.test_suite_id'),
nullable=False,
index=True)
owner_id = db.Column(db.ForeignKey('user.user_id'), nullable=False)
test_case_class = db.Column(db.SMALLINT, nullable=False)
latest_execution_status = db.Column(
db.SMALLINT,
nullable=False,
default=ExecutionStatus().get_execution_status_id_by_name('new'))
is_deleted = db.Column(db.Boolean, nullable=False, default=False)
test_case_detail = db.Column(JSON, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now)
modified_at = db.Column(db.DateTime, default=datetime.now)
test_suite = db.relationship(TestSuite,
back_populates='test_case',
lazy=True)
test_case_log = db.relationship("TestCaseLog",
back_populates='test_cases',
lazy=True,
order_by='TestCaseLog.created_at')
def __init__(self, test_suite_id, owner_id, test_case_class,
test_case_detail):
self.test_suite_id = test_suite_id
self.owner_id = owner_id
self.test_case_class = test_case_class
self.test_case_detail = test_case_detail
def save_to_db(self):
db.session.add(self)
db.session.commit()
class City(db.Model):
__bind_key__ = 'wehomeproperty'
id = db.Column(db.Integer(), index=True, primary_key=True)
geoid = db.Column(db.String(255), index=True, unique=True)
area_geoid = db.Column(db.String(255), db.ForeignKey('area.geoid'), index=True)
state_geoid = db.Column(db.String(255), db.ForeignKey('state.geoid'),index=True)
zipcodes = db.relationship('Zipcode', backref='city')
neighbors = db.relationship('Neighbor', backref='city_')
name = db.Column(db.String(255), index=True)
lat = db.Column(db.Float())
lng = db.Column(db.Float())
properties = db.Column(JSON)
created_at = db.Column(db.DateTime(), default=datetime.datetime.now)
updated_at = db.Column(db.DateTime(), default=datetime.datetime.now, onupdate=datetime.datetime.now)
class Object(db.Model):
id = db.Column(db.Integer, primary_key=True)
object_name = db.Column(db.String(120), nullable=False)
object_parent_id = db.Column(db.Integer, nullable=True)
object_server_id = db.Column(db.Integer,
db.ForeignKey('server.id',
ondelete='CASCADE'),
nullable=False)
object_variables = db.relationship("Variable",
backref="object",
cascade="all, delete-orphan",
lazy='dynamic')
def has_child(self):
return True if Object.query.filter_by(
object_parent_id=self.id) else False
def is_parent(self):
return True if self.object_parent_id is None else False
def get_parent(self):
return Object.query.get(self.object_parent_id)
def get_child_objects(self):
return self.query.filter_by(
object_parent_id=self.id) if Object.query.filter_by(
object_parent_id=self.id) else False
def __repr__(self):
return "Object: {}".format(self.object_name)
class TestCaseLog(db.Model):
__tablename__ = "test_case_log"
test_case_log_id = db.Column(db.Integer, primary_key=True)
test_case_id = db.Column(db.ForeignKey('test_case.test_case_id'),
index=True)
job_id = db.Column(db.ForeignKey('job.job_id'), index=True)
execution_status = db.Column(db.SMALLINT, nullable=False)
dqi_percentage = db.Column(db.Float(precision=2), nullable=True)
execution_log = db.Column(JSON, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now)
modified_at = db.Column(db.DateTime, default=datetime.now, index=True)
test_cases = db.relationship(TestCase,
back_populates='test_case_log',
lazy=True)
def __init__(
self,
test_case_id,
job_id,
execution_status=ExecutionStatus().get_execution_status_id_by_name(
"new")):
self.test_case_id = test_case_id
self.job_id = job_id
self.execution_status = execution_status
def save_to_db(self):
db.session.add(self)
db.session.commit()
class ChallengeFollower(db.Model):
id = db.Column(db.Integer(), primary_key=True)
challenge_instance_id = db.Column(db.Integer(),
db.ForeignKey("challenge_instance.id"),
nullable=False)
challenge_instance = db.relationship('ChallengeInstance')
follower_id = db.Column(db.Integer(),
db.ForeignKey("user.id"),
nullable=False)
follower = db.relationship('User')
date_joined = db.Column(db.DateTime(), nullable=False)
def __init__(self, challenge, follower):
self.challenge_instance = challenge
self.follower = follower
self.date_joined = datetime.datetime.now()
class ToDoListModel(db.Model):
__tablename__ = 'todolists'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
todos = db.relationship('ToDoModel', lazy='dynamic')
def __init__(self, name):
self.name = name
def json(self):
return {
'id': self.id,
'name': self.name,
'todos': [item.json() for item in self.todos.all()]
}
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
ToDoModel.delete_by_list_id(self.id)
db.session.commit()
class TestSuite(db.Model):
__tablename__ = "test_suite"
test_suite_id = db.Column(db.Integer, primary_key=True)
project_id = db.Column(db.ForeignKey('project.project_id'),
nullable=False,
index=True)
owner_id = db.Column(db.ForeignKey('user.user_id'), nullable=False)
excel_name = db.Column(db.Text)
test_suite_name = db.Column(db.Text, nullable=False)
is_deleted = db.Column(db.Boolean, nullable=False, default=False)
created_at = db.Column(db.DateTime, default=datetime.now)
modified_at = db.Column(db.DateTime, default=datetime.now)
test_case = db.relationship("TestCase",
back_populates='test_suite',
lazy=True,
order_by='TestCase.created_at')
def __init__(self, project_id, owner_id, excel_name, test_suite_name):
self.project_id = project_id
self.owner_id = owner_id
self.excel_name = excel_name
self.test_suite_name = test_suite_name
def save_to_db(self):
db.session.add(self)
db.session.commit()
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
image_file = db.Column(db.String(32),
nullable=False,
default='default.jpg')
password = db.Column(db.String(64), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def get_reset_password_token(self, expires_in=900):
return jwt.encode(
{
'reset_password': self.id,
'exp_time': time() + expires_in
},
key=ConfigManager.SECRET_KEY,
algorithm='HS256').decode('utf-8')
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token,
key=ConfigManager.SECRET_KEY,
algorithms=['HS256'])['reset_password']
except:
return
else:
return User.query.get(id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
# User authentication information (required for Flask-User)
email = db.Column(db.Unicode(255),
nullable=False,
server_default=u'',
unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
actiu = db.Column(db.Boolean(), nullable=False, server_default='0')
# User information
actiu = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='0')
nom = db.Column(db.Unicode(50), nullable=False, server_default=u'')
# Relationships
roles = db.relationship('Role',
secondary='users_roles',
backref=db.backref('users', lazy='dynamic'))
def __str__(self):
return u"Nom : {name}; Email: {email})".format(name=self.nom,
email=self.email)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(120),
nullable=False,
default='default.jpg')
password = db.Column(db.String(120), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
#creating user token to reset the user password
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class ChallengeInstance(db.Model):
id = db.Column(db.Integer(), primary_key=True)
challenge_id = db.Column(db.Integer,
db.ForeignKey("challenge.id"),
nullable=False)
challenge = db.relationship('Challenge')
date_created = db.Column(db.DateTime(), nullable=False)
creator_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=True)
creator = db.relationship('User')
def __init__(self, challenge, creator):
self.challenge = challenge
self.date_created = datetime.datetime.utcnow()
self.creator = creator
class Tag(db.Model):
__tablename__ = 'Tag'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, unique=True, nullable=False)
photos = db.relationship('Photo',
secondary=photo_tags,
backref=db.backref('Tag', lazy=True))
class Order(db.Model):
__tablename__ = 'order'
id = db.Column(db.Integer(), primary_key=True)
uuid = db.Column(db.String(40), unique=True, index=True)
entries = db.relationship("Entry",
back_populates="order",
primaryjoin=(id == Entry.order_id))
create_time = db.Column(db.DateTime, default=db.func.now())
description = db.Column(db.Text(), nullable=False)
closes_at = db.Column(db.Text(), nullable=False)
restaurant_id = db.Column(db.Integer,
db.ForeignKey('restaurant.id'),
nullable=False)
restaurant = db.relationship("Restaurant", foreign_keys=restaurant_id)
def __init__(self, description, closes_at, restaurant):
self.description = description
self.closes_at = closes_at
self.restaurant = restaurant
self.uuid = str(uuid.uuid4())
def json(self):
return {
'id': self.uuid,
'description': self.description,
'closes_at': self.closes_at,
'restaurant_info': self.restaurant.info_json(),
'orders': map(lambda entry: entry.json(), self.entries)
}
def user_json(self, user_uuid):
entry = None
for e in self.entries:
if e.user_uuid == user_uuid:
entry = e
return {
'id': self.uuid,
'description': self.description,
'closes_at': self.closes_at,
'restaurant_info': self.restaurant.info_json(),
'order': None if entry is None else entry.json(),
'menu': self.restaurant.menu_json()
}
class Score(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(), nullable=True)
bars = db.Column(db.Text, nullable=True)
tracks = db.relationship('Track', backref='score', cascade="all, delete")
def __repr__(self):
return f"<Score {self.name}>"
class UserSet(db.Model):
__tablename__ = "user_set"
id = db.Column(db.Integer(), primary_key=True)
workout_id = db.Column(db.Integer(), db.ForeignKey("user_session.id"))
reps = db.relationship("UserRep")
rest = db.Column(db.Integer())
ordinal = db.Column(db.Integer())
completed = db.Column(db.Boolean())
effort_level = db.Column(db.Integer())
class Vokabel(db.Model):
id = db.Column('wort_id', db.Integer, primary_key=True)
wort = db.Column(db.String(45))
bedeutung = db.Column(db.String(45))
beispiel = db.Column(db.String(250))
quelle_id = db.Column(db.Integer, db.ForeignKey('quelle.id'))
quelle = db.relationship("Quelle", backref=db.backref("Vokabel", lazy=True))
class ChallengeInstanceVote(db.Model):
id = db.Column(db.Integer(), primary_key=True)
challenge_instance_id = db.Column(db.Integer(),
db.ForeignKey("challenge_instance.id"),
nullable=False)
challenge_instance = db.relationship('ChallengeInstance')
votee_id = db.Column(db.Integer,
db.ForeignKey("challenge_instance_media.id"),
nullable=False)
votee = db.relationship(
'ChallengeInstanceMedia'
) #since this is a temporary model, I won't add too many constraits
def __init__(self, challenge_instance, votee):
self.challenge_instance = challenge_instance
self.votee = votee
class UserSession(db.Model):
__tablename__ = "user_session"
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey("user.id"))
date = db.Column(db.Date())
sets = db.relationship("UserSet")
note = db.Column(db.Text())
grip = db.Column(db.String(255))
program = db.Column(db.Integer(), db.ForeignKey("program_template.id"))
class User(db.Model):
"""docstring for User"""
__tablename__ = "users"
id = db.Column('user_id', db.Integer, primary_key=True)
email = db.Column('email', db.String(80), unique=True)
username = db.Column('username', db.String(80), unique=True)
password = db.Column('password', db.String(80), nullable=False)
auth = db.Column('auth', db.String(300), nullable=False)
sync_token = db.Column('sync_token', db.String(150))
events = db.relationship('Event', backref='user', lazy='dynamic')
def __init__(self, email, username, password, sync_token, auth):
self.email = email
self.username = username
self.password = password
self.sync_token = sync_token
self.auth = auth
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return unicode(self.id)
def __repr__(self):
return '<User %r>' % (self.username)
# def hash_password(self, password):
# self.password_hash = pwd_context.encrypt(password)
# def verify_password(self, password):
# return pwd_context.verify(password, self.password_hash)
def get_id(self):
return unicode(self.id)
def __repr__(self):
return '<User %r>' % self.username
@staticmethod
def verify_email_password(email, password):
# user = User.verify_auth_token(username_or_token)
data = User.query.all()
print("hey from model", email, password)
user = User.query.filter_by(email=email).first()
print(user)
if user and user.password == password:
g.user = user
return user
else:
return None
class ChallengeParticipant(db.Model):
id = db.Column(db.Integer(), primary_key=True)
challenge_instance_id = db.Column(db.Integer(),
db.ForeignKey("challenge_instance.id"),
nullable=False)
challenge_instance = db.relationship('ChallengeInstance')
participant_id = db.Column(db.Integer(),
db.ForeignKey("user.id"),
nullable=False)
participant = db.relationship('User')
date_joined = db.Column(db.DateTime(), nullable=False)
def __init__(self, challenge, participant):
self.challenge_instance = challenge
self.participant = participant
self.date_joined = datetime.datetime.now()
class Document(db.Model, BlobMixin):
__tablename__ = 'documents'
id = db.Column(db.Integer, primary_key=True)
creat = db.Column(db.DateTime, server_default=db.func.now())
nom = db.Column(db.Unicode(length=255), nullable=False, unique=True)
compartit = db.Column(db.Boolean(), nullable=False, server_default='0')
clients = db.relationship('User',
secondary='users_documents',
backref=db.backref('documents', lazy='dynamic'))
tipus_id = db.Column(db.Integer(), db.ForeignKey('tipus_document.id'))
tipus = db.relationship('TipusDocument', foreign_keys=tipus_id)
def __str__(self):
return u"nom: {name}; document: {filename})".format(
name=self.nom, filename=self.filename)
def __lt__(self, other):
return self.creat > other.creat
class Item(db.Model):
__tablename__ = 'item'
category = db.relationship(Category)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
description = db.Column(db.String(1000), nullable=False)
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.String(80), nullable=False)
timestamp = db.Column(db.DateTime, default=datetime.datetime.utcnow)
user = db.relationship(Usercat)
user_id = db.Column(db.Integer, db.ForeignKey('usercat.id'))
def __init__(self, category_id, description, name, user_id):
self.category_id = category_id
self.description = description
self.name = name
self.user_id = user_id
def __repr__(self):
return '<id {}>'.format(self.id)
class User(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
offers = db.relationship('Offer', backref='user.creator')
requests = db.relationship('Request', backref='user.creator')
offers_history = db.relationship('Offer',
secondary=offers_history_table,
backref=db.backref('passenger_list',
lazy='dynamic'))
def __init__(self, name, email, password):
self.email = email
self.name = name
self.active = True
self.password = User.hashed_password(password)
@staticmethod
def hashed_password(password):
return bcrypt.generate_password_hash(password).decode("utf-8")
@staticmethod
def get_user_with_email_and_password(email, password):
user = User.query.filter_by(email=email).first()
if user and bcrypt.check_password_hash(user.password, password):
return user
else:
return None
@staticmethod
def get_users():
users = User.query.all()
#users = users.append([User.query.filter([User.requests] > None).all()])
print(users)
return {
x.id: {
'name': x.name,
'email': x.email + '@marlboro.edu'
}
for x in users
}
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Photo(db.Model):
__tablename__ = 'Photo'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('User.id'))
filename = db.Column(db.String, default=None, nullable=True)
url = db.Column(db.String, default=None, nullable=True)
date_created = db.Column(db.DateTime, default=datetime.utcnow)
date_updated = db.Column(db.DateTime, default=datetime.utcnow)
caption = db.Column(db.String, default=None, nullable=True)
tags = db.relationship('Tag',
secondary=photo_tags,
lazy='subquery',
backref=db.backref('Photo', lazy=True))
likes = db.relationship('Like', backref='Photo', lazy=True)
def __init__(self, user_id, filename=None, url=None, caption=None):
self.user_id = user_id
self.filename = filename
self.url = url
self.caption = caption
class DbDetail(db.Model):
__tablename__ = "dbdetail"
db_id = db.Column(INTEGER(unsigned=True),
autoincrement=True,
primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.user_id'),
nullable=False)
connection_name = db.Column(db.String(80))
db_type = db.Column(db.String(80), nullable=False)
db_name = db.Column(db.String(80), nullable=False)
db_hostname = db.Column(db.String(128), nullable=False)
db_username = db.Column(db.String(80), nullable=False)
db_password = db.Column(db.String(256)) #
users = db.relationship('User', back_populates='dbdetail', lazy=True)
created = db.Column(db.DateTime, default=datetime.datetime.now)
def __init__(self, connection_name, db_type, db_name, db_hostname,
db_username, db_password, user_id):
self.connection_name = connection_name
self.db_type = db_type
self.db_name = db_name
self.db_hostname = db_hostname
self.db_username = db_username
self.db_password = db_password
self.user_id = user_id
def save_to_db(self):
db.session.add(self)
db.session.commit()
def get_private_key(password1):
salt = b"this is a salt"
kdf = PBKDF2(password1, salt, 64, 1000)
key = kdf[:32]
return key
def encrypt(raw):
private_key = DbDetail.get_private_key(
app.config.get('DB_ENCRYPTION_KEY'))
raw = pad(raw)
iv = Random.new().read(AES.block_size)
cipher = AES.new(private_key, AES.MODE_CBC, iv)
return base64.b64encode(iv + cipher.encrypt(raw))
def decrypt(enc):
private_key = DbDetail.get_private_key(
app.config.get('DB_ENCRYPTION_KEY'))
enc = base64.b64decode(enc)
iv = enc[:16]
cipher = AES.new(private_key, AES.MODE_CBC, iv)
return unpad(cipher.decrypt(enc[16:]))
class State(db.Model):
__bind_key__ = 'wehomeproperty'
id = db.Column(db.Integer(), index=True, primary_key=True)
geoid = db.Column(db.String(255), index=True, unique=True)
name = db.Column(db.String(255))
name_abbr = db.Column(db.String(255))
lat = db.Column(db.Float())
lng = db.Column(db.Float())
properties = db.Column(JSON)
cities = db.relationship('City', backref='state')
created_at = db.Column(db.DateTime(), default=datetime.datetime.now)
updated_at = db.Column(db.DateTime(), default=datetime.datetime.now, onupdate=datetime.datetime.now)
class ChallengeInstanceMedia(db.Model):
id = db.Column(db.Integer(), primary_key=True)
data = db.Column(db.Text(), nullable=False)
challenge_instance_id = db.Column(db.Integer(),
db.ForeignKey("challenge_instance.id"),
nullable=False)
user_id = db.Column(db.Integer(), db.ForeignKey("user.id"), nullable=True)
challenge_instance = db.relationship('ChallengeInstance')
user = db.relationship('User')
def __init__(self, challenge_instance, user, data):
self.challenge_instance = challenge_instance
self.user = user
self.data = data
@staticmethod
def get_media(instance_id):
challenge_instance_media = ChallengeInstanceMedia.query.filter_by(
challenge_instance_id=instance_id)
return ChallengeInstanceMediaSchema.dump(challenge_instance_media)
