class Interviewer(db.Model):
__tablename__ = "interviewer"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
firstname = db.Column(db.String(32), nullable=False)
lastname = db.Column(db.String(32), nullable=True)
email = db.Column(db.String(128), nullable=False, unique=True)
interview = db.relationship('Interview', secondary="interviewer_assigned")
# Class constructor
def __init__(self, firstname, lastname, email):
self.firstname = firstname
self.lastname = lastname
self.email = email
# Returning class attribute in a json format
def to_json(self):
return {
'id': self.id,
'firstname': self.firstname,
'lastname': self.lastname,
'email': self.email
}
class VehicleScores(db.Model):
__tablename__ = 'vehiclescores'
id = db.Column(db.Integer, primary_key=True)
score = db.Column(db.Integer, nullable=True)
username = db.Column(db.String(128), primary_key=True, nullable=False)
def __init__(self, id, score, username):
self.id = id
self.score = score
self.username = username
def to_json(self):
return {'id': self.id, 'score': self.score, 'username': self.username}
class Address(db.Model):
"""Test relationship between tables"""
__tablename__ = 'address'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), nullable=False)
person_id = db.Column(db.Integer,
db.ForeignKey('person.id'),
nullable=False)
def __init__(self, email, person_id):
self.email = email
self.person_id = person_id
class Book(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(160), nullable=False)
publish_date = db.Column(db.Date, nullable=False)
avg_rating = db.Column(db.Float, nullable=False, default=0)
num_rating = db.Column(db.Integer, nullable=False, default=0)
author_ids = db.relationship('Author',
secondary=book_authors,
lazy='subquery',
backref=db.backref('books', lazy=True))
def __repr__(self):
return '<Bookname %r>' % self.title
class ComplainVO(db.Model):
__tablename__ = 'complainmaster'
complainId = db.Column('complainId',
db.Integer,
primary_key=True,
autoincrement=True)
complainSubject = db.Column('complainSubject', db.String(100))
complainDescription = db.Column('complainDescription', db.String(500))
complainDate = db.Column('complainDate', db.Date)
complainTime = db.Column('complainTime', db.Time)
complainFilename = db.Column('complainFilename', db.String(500))
complainFilePath = db.Column('complainFilePath', db.String(1000))
complainStatus = db.Column('complainStatus', db.String(100))
replysubject = db.Column('replysubject', db.String(100))
replyDescription = db.Column('replyDescription', db.String(500))
replyFilename = db.Column('replyFilename', db.String(500))
replyFilePath = db.Column('replyFilePath', db.String(500))
replyDate = db.Column('replyDate', db.Date)
replyTime = db.Column('replyTime', db.Time)
complainFrom_LoginId = db.Column('complainFrom_LoginId', db.Integer,
db.ForeignKey(LoginVO.loginId))
complainTo_LoginId = db.Column('complainTo_LoginId', db.Integer,
db.ForeignKey(LoginVO.loginId))
def as_dict(self):
return {
'complainId': self.complainId,
'complainSubject': self.complainSubject,
'complainDescription': self.complainDescription,
'complainDate': self.complainDate,
'complainTime': self.complainTime,
'complainFilename': self.complainFilename,
'complainFilePath': self.complainFilePath,
'complainStatus': self.complainStatus,
'replysubject': self.replysubject,
'replyDescription': self.replyDescription,
'replyFilename': self.replyFilename,
'replyFilePath': self.replyFilePath,
'replyDate': self.replyDate,
'replyTime': self.replyTime,
'complainFrom_LoginId': self.complainFrom_LoginId,
'complainTo_LoginId': self.complainTo_LoginId
}
class User(db.Model):
# __tablename__ = 'myuser' 指定表名字
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(80), unique=True)
password = db.Column(db.String(32))
salt = db.Column(db.String(32))
head_url = db.Column(db.String(256))
images = db.relationship('Image', backref='user', lazy='dynamic')
def __init__(self, username, password, salt=''):
self.username = username
self.password = password # 暂时明文，下节课讲解加密
self.salt = salt
self.head_url = 'http://images.nowcoder.com/head/' + str(
random.randint(0, 1000)) + 't.png'
def __repr__(self):
return ('<User %d %s>' % (self.id, self.username)).encode('gbk')
# Flask Login接口
@property
def is_authenticated(self):
# print 'is_authenticated'
return True
@property
def is_active(self):
# print 'is_active'
return True
@property
def is_anonymous(self):
# print 'is_anonymous'
return False
def get_id(self):
# print 'get_id'
return self.id
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), unique=True, nullable=False)
username = db.Column(db.String(120), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
accessCode = db.Column(db.String(6), nullable=False)
is_lecturer = db.Column(db.Boolean, default=True, nullable=False)
assignments = db.relationship('Assignment_Posted', backref='ass')
updates = db.relationship('Update', backref='upt')
studs = db.relationship('User',
secondary=comms,
primaryjoin=(comms.c.lecturer_id == id),
secondaryjoin=(comms.c.student_id == id))
# backref=db.backref('lecStudent', lazy='dynamic'), lazy='dynamic')
received_assignment = db.relationship('Assignment_Received',
backref='assReceived')
def __repr__(self):
return format("User(" + self.name + "," + self.username + "," +
self.email + "," + self.accessCode + "," +
str(self.is_lecturer) + ")")
class Order(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(16), nullable=False, default=token_urlsafe(16))
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
buyer_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=True) #ak je anonymny tak id bude 0
info_id = db.Column(db.Integer, db.ForeignKey("info.id"), nullable=False)
total_price = db.Column(db.Integer, nullable=False)
books = db.relationship("Book", secondary=transactions , backref=db.backref("orders", lazy="dynamic"))
def __repr__(self):
return f"Order num:{self.number}"
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
alt_id = db.Column(db.String(64), unique=True)
username = db.Column(db.String(50), nullable=False, unique=True)
name = db.Column(db.String(50), nullable=False)
surname = db.Column(db.String(50), nullable=False)
email = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(128), nullable=False)
networks = db.relationship("Network", backref="user", lazy=True)
reg_date = db.Column(db.DateTime, nullable=False)
operator = db.Column(db.Boolean, nullable=False, default=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
groups = db.relationship("Group",
secondary=membership_table,
back_populates='users')
def __init__(self,
username,
password,
email,
name,
surname,
admin=False,
operator=False):
self.username = username
self.password = bcrypt.generate_password_hash(password).decode('utf-8')
self.email = email
self.name = name
self.surname = surname
self.admin = admin
self.operator = operator
self.reg_date = datetime.datetime.now()
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return str(self.alt_id)
@staticmethod
def ldap_login(email, password):
if includes_crlf(email):
return False
if includes_crlf(password):
return False
ld = ldap.initialize("ldap://{}:{}".format(LDAP_SERVER, LDAP_PORT))
return ld.simple_bind_s(email, password)
def __repr__(self):
return '<username: {}>'.format(self.username)
class User(db.Model, AbstractModelWithId):
email = db.Column(db.String(255), nullable=False)
password_hash = db.Column(db.String(255), nullable=False)
first_name = db.Column(db.String(150), nullable=False)
last_name = db.Column(db.String(255), nullable=False)
role = db.Column(SQLEnum(RoleName), db.ForeignKey("role.name"), default=RoleName.USER)
# tokens = db.relationship("Token", uselist=True)
wish_list = db.relationship('UserToProduct', uselist=True, lazy=True)
__table_args__ = (UniqueConstraint('email', 'remove_date', name='unique_user_email'),)
def hash_password(self, clear_password):
self.password_hash = pwd_context.hash(clear_password)
def verify_password(self, password):
return pwd_context.verify(password, self.password_hash)
def follow_product(self, product_id, difference_trigger=None):
relation = UserToProduct(product_id=product_id, user_id=self.id, difference_trigger=difference_trigger)
# relation.create()
self.wish_list.append(relation)
db.session.flush()
def unfollow_product(self, product_id):
relation = UserToProduct.find_one({'product_id': product_id, 'user_id': self.id})
self.wish_list.remove(relation)
# db.session.flush()
@classmethod
def filter(cls, filters):
query = AbstractModelWithId.filter(cls, filters)
if 'email' in filters:
query = query.filter_by(email=filters['email'])
elif 'role' in filters:
query = query.filter_by(role=filters['role'])
elif 'first_name' in filters:
query = query.filter_by(first_name=filters['first_name'])
return query
class Praise(db.Model):
__tablename__ = "Praise"
id = db.Column(db.String(16), primary_key=True)
card_id = db.Column(db.String(16), nullable=False)
user_id = db.Column(db.String(16), nullable=False)
def create_praise(self, user_id, card_id):
if not Praise.query.filter(Praise.card_id == card_id, Praise.user_id
== user_id).first():
self.id = str(uuid.uuid1()).split("-")[0]
self.card_id = card_id
self.user_id = user_id
db.session.add(self)
db.session.commit()
return True
else:
return False
def del_praise(self, user_id, card_id):
try:
i = self.query.filter_by(card_id=card_id, user_id=user_id).first()
db.session.delete(i)
db.session.commit()
except:
return False
else:
return True
def find_praise_number(card_id): # 查找某卡片的获赞的数量
_all = Praise.query.filter(Praise.card_id == card_id).all()
p_number = len(_all)
return p_number
def check_praise(user_id, card_id):
if Praise.query.filter(Praise.user_id == user_id,
Praise.card_id == card_id).first():
return True
else:
return False
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), nullable=False)
password = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
created_date = db.Column(db.DateTime, default=func.now(), nullable=False)
def __init__(self, username="", email="", password=""):
self.username = username
self.email = email
self.password = bcrypt.generate_password_hash(
password, current_app.config.get("BCRYPT_LOG_ROUNDS")).decode()
def encode_token(self, user_id, token_type):
if token_type == "access":
seconds = current_app.config.get("ACCESS_TOKEN_EXPIRATION")
else:
seconds = current_app.config.get("REFRESH_TOKEN_EXPIRATION")
payload = {
"exp":
datetime.datetime.utcnow() + datetime.timedelta(seconds=seconds),
"iat": datetime.datetime.utcnow(),
"sub": user_id,
}
return jwt.encode(payload,
current_app.config.get("SECRET_KEY"),
algorithm="HS256")
@staticmethod
def decode_token(token):
payload = jwt.decode(token,
current_app.config.get("SECRET_KEY"),
algorithms=["HS256"])
return payload["sub"]
class FeedbackVO(db.Model):
__tablename__ = 'feedbackmaster'
feedbackId = db.Column('feedbackId', db.Integer, primary_key=True, autoincrement=True)
feedbackDate = db.Column('feedbackDate', db.Date)
feedbackTime = db.Column('feedbackTime', db.Time)
feedbackSubject = db.Column('feedbackSubject', db.String(100))
feedbackDescription = db.Column('feedbackDescription', db.String(500))
feedbackRating = db.Column('feedbackRating', db.Integer)
feedbackFrom_LoginId = db.Column('feedbackFrom_LoginId', db.Integer, db.ForeignKey(LoginVO.loginId))
feedbackTo_LoginId = db.Column('feedbackTO_LoginId', db.Integer, db.ForeignKey(LoginVO.loginId))
def as_dict(self):
return {
'feedbackId': self.feedbackId,
'feedbackDate': self.feedbackDate,
'feedbackTime': self.feedbackTime,
'feedbackSubject': self.feedbackSubject,
'feedbackDescription': self.feedbackDescription,
'feedbackRating': self.feedbackRating,
'feedbackFrom_LoginId': self.feedbackFrom_LoginId,
'feedbackTo_LoginId': self.feedbackTo_LoginId
}
class P02(db.Model):
__tablename__ = 'proveedores'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False)
address = db.Column(db.String(128), nullable=False)
ruc = db.Column(db.Integer, nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
created_date = db.Column(db.DateTime, default=func.now(), nullable=False)
def to_json(self):
return {
'id': self.id,
'name': self.name,
'address': self.address,
'ruc': self.ruc,
'active': self.active
}
def __init__(self, name, address, ruc):
self.name = name
self.address = address
self.ruc = ruc
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
password_hash = db.Column(db.String(128))
access_token = db.Column(db.String(300), default='')
refresh_token = db.Column(db.String(300), default='')
invisible = db.Column(db.Boolean, default=False)
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def set_access_token(self, token):
self.access_token = token
def set_refresh_token(self, token):
self.refresh_token = token
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
created_date = db.Column(db.DateTime, default=func.now(), nullable=False)
def to_json(self):
return {
'id': self.id,
'username': self.username,
'email': self.email,
'active': self.active
}
def __init__(self, username, email):
self.username = username
self.email = email
class Template(db.Model):
__tablename__ = "templates"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False, unique=True)
meraki_id = db.Column(db.String(64), unique=True)
reg_date = db.Column(db.DateTime, nullable=False)
networks = db.relationship("Network", backref="template", lazy=True)
def __init__(self, template_name, template_n_id):
self.name = template_name
self.meraki_id = template_n_id
self.reg_date = datetime.datetime.now()
def update(self, template_name, template_n_id):
self.name = template_name
self.meraki_id = template_n_id
self.reg_date = datetime.datetime.now()
def __repr__(self):
return '<template_name: {}>'.format(self.name)
class Business(db.Model):
__tablename__ = "Businesses"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
business_name = db.Column(db.String(80), nullable=False, unique=True)
business_category = db.Column(db.String(80), nullable=False)
business_addr = db.Column(db.String(80), nullable=False)
business_desc = db.Column(db.String(5000), nullable=False)
created_by = db.Column(db.String(80), nullable=False)
created_at = db.Column(db.DateTime,
default=datetime.datetime.utcnow(),
nullable=False)
def __init__(self,
business_name,
business_category,
business_addr,
business_desc,
created_by,
created_at=datetime.datetime.utcnow()):
self.business_name = business_name
self.business_category = business_category
self.business_addr = business_addr
self.business_desc = business_desc
self.created_by = created_by
self.created_at = datetime.datetime.now()
def delete(self):
"""
Delete a business
"""
db.session.delete(self)
db.session.commit()
def save(self):
"""
Save a business into the db
"""
db.session.add(self)
db.session.commit()
class Student(db.Model, UserMixin):
__tablename__ = 'Student'
rollno = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
branch = db.Column(db.String(64))
official_email = db.Column(db.String(64), unique=True)
password_hash = db.Column(db.String(128))
def __init__(self, rollno, name, branch, official_email, password):
self.rollno = rollno
self.name = name
self.branch = branch
self.official_email = official_email
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def get_id(self):
return (self.rollno)
class Announcement(db.Model):
__tablename__ = "announcements"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
created_date = db.Column(db.DateTime, default=func.now(), nullable=False)
content = db.Column(db.String(1024), nullable=False)
sponsor_name = db.Column(db.String, nullable=False)
def __init__(self, content="", sponsor_name=""):
self.content = content
self.sponsor_name = sponsor_name
class Drink(db.Model):
__tablename__ = 'drinks'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(140))
username = db.Column(db.String)
img = db.Column(db.String)
ing1 = db.Column(db.String)
ing2 = db.Column(db.String)
ing3 = db.Column(db.String)
ing4 = db.Column(db.String)
ing5 = db.Column(db.String)
ing6 = db.Column(db.String)
garnish = db.Column(db.String)
instructions = db.Column(db.String)
likes = db.Column(db.Integer)
dislikes = db.Column(db.Integer)
favorite = db.Column(db.Integer)
user_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete='CASCADE'))
def __init__(self, user_id, measurments="", username="", ing1="", name="", ing3="", ing4="", ing5="", ing6="", garnish="", instructions="", likes=0, dislikes=0, favorite=0, img="", ing2=""):
if img is "":
img = choice(['http://s3.amazonaws.com/auteurs_production/images/film/cocktail/w1280/cocktail.jpg',
'https://s-media-cache-ak0.pinimg.com/originals/d6/90/37/d69037f83ebde80a94cd2e23d8a8a617.jpg',
'http://i.dailymail.co.uk/i/pix/2014/11/09/1415515863112_wps_42_Shark_Bite.jpg'
])
ing1 = None if ing1 == "" else "{} {}".format(measurments[0], ing1)
ing2 = None if ing2 == "" else "{} {}".format(measurments[0], ing2)
ing3 = None if ing3 == "" else "{} {}".format(measurments[0], ing3)
ing4 = None if ing4 == "" else "{} {}".format(measurments[0], ing4)
ing5 = None if ing5 == "" else "{} {}".format(measurments[0], ing5)
ing6 = None if ing6 == "" else "{} {}".format(measurments[0], ing6)
self.user_id = user_id
self.name = name
self.username = username
self.ing1 = ing1
self.ing2 = ing2
self.ing3 = ing3
self.ing4 = ing4
self.ing5 = ing5
self.ing6 = ing6
self.garnish = garnish
self.instructions = instructions
self.likes = likes
self.dislikes = dislikes
self.favorite = favorite
self.img = img
class DroneTelemetry(db.Model):
__tablename__ = "drone_telemetry"
# Column's definition
id = db.Column(db.Integer, primary_key=True)
airspeed = db.Column(db.Float(precision=2))
alt = db.Column(db.Float(precision=2))
battery_perc = db.Column(db.Float(precision=2))
dist_home = db.Column(db.Float(precision=2))
compass1_x = db.Column(db.Integer)
compass1_y = db.Column(db.Integer)
compass1_z = db.Column(db.Integer)
compass2_x = db.Column(db.Integer)
compass2_y = db.Column(db.Integer)
compass2_z = db.Column(db.Integer)
compass_variance = db.Column(db.Float(precision=2))
current = db.Column(db.Float(precision=2))
fix_type = db.Column(db.Integer)
flight_mode = db.Column(db.String(300))
gps_sats = db.Column(db.Integer)
gps_fix = db.Column(db.Integer)
gps2_sats = db.Column(db.Integer)
gps2_fix = db.Column(db.Integer)
irlock_x = db.Column(db.Float(precision=2))
irlock_y = db.Column(db.Float(precision=2))
irlock_status = db.Column(db.Boolean)
lat = db.Column(db.Float(precision=8))
lon = db.Column(db.Float(precision=8))
num_gps = db.Column(db.Integer)
pos_horiz_variance = db.Column(db.Float(precision=2))
pos_vert_variance = db.Column(db.Float(precision=2))
rcout1 = db.Column(db.Integer)
rcout2 = db.Column(db.Integer)
rcout3 = db.Column(db.Integer)
rcout4 = db.Column(db.Integer)
rcout5 = db.Column(db.Integer)
rcout6 = db.Column(db.Integer)
rcout7 = db.Column(db.Integer)
rcout8 = db.Column(db.Integer)
sonar_dist = db.Column(db.Float(precision=2))
throttle = db.Column(db.Integer)
vibrations_x = db.Column(db.Float(precision=10))
vibrations_y = db.Column(db.Float(precision=10))
vibrations_z = db.Column(db.Float(precision=10))
voltage = db.Column(db.Float(precision=2))
velocity_variance = db.Column(db.Float(precision=2))
terrain_alt_variance = db.Column(db.Float(precision=2))
waypoint = db.Column(db.Integer)
yaw = db.Column(db.Integer)
timestamp = db.Column(db.DateTime)
qhawax_id = db.Column(db.Integer, db.ForeignKey("qhawax.id"))
class Question(db.Model):
id = db.Column(db.Integer, primary_key=True)
question = db.Column(db.String(256), nullable=False)
answer = db.Column(db.String(256), nullable=False)
choices = db.Column(db.String(256), nullable=False)
def check_answer(self, answer):
return answer.lower() == self.answer.lower()
@classmethod
def fetch_quiz(cls, limit=10):
return cls.query.order_by(func.random()).limit(limit).all()
@classmethod
def check_answers(cls, key_name, answers, current_user):
# making sure, user does not send more than 10 answers
assert len(answers) == 10
score = 0
# answered questions
questions = []
for key, value in answers.items():
q_id = key.strip(key_name)
question = cls.query.get(int(q_id))
if question.check_answer(value):
score += 1
questions.append(question)
Score.save_record(current_user.id, score)
return questions, score
def __repr__(self):
return f'<Question: {self.question}'
def __init__(self, **kwargs):
self.question = kwargs['question']
self.answer = kwargs['answer']
self.choices = kwargs['choices']
class Education(BaseMixin, ExperienceMixin, db.Model):
title = db.Column(db.String(50), nullable=False)
school = db.Column(db.String(50), default='')
extent = db.Column(db.String(50), default='')
description = db.Column(db.String(), default='')
type = db.Column(ChoiceType(EducationType, impl=db.String()),
default=EducationType.education.value)
startdate = db.Column(db.DateTime())
enddate = db.Column(db.DateTime())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User',
foreign_keys=[user_id],
backref='educations')
@property
def _descriptive(self):
return self.title + (', {}'.format(self.school)
if self.school != '' else '')
def add_activity(self, new, session):
if not new:
return
origin = self.user.name
target = self._descriptive
action = '{origin} added the work experience {target}'
activity = Activity(
**{
'action': action,
'user_id': self.user.id,
'education_id': self.id,
'origin': 'user',
'target': 'education'
})
session.add(activity)
class Qhawax(db.Model):
__tablename__ = 'qhawax'
# Column's definition
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(300), nullable=False, unique=True)
main_aqi = db.Column(db.Float)
main_inca = db.Column(db.Float)
qhawax_type = db.Column(db.String(100), nullable=False, unique=True)
state = db.Column(db.String(5), nullable=False, unique=True)
availability = db.Column(db.String(100), nullable=False, unique=True)
mode = db.Column(db.String(100), nullable=False, unique=True)
processed_measurements = db.relationship('ProcessedMeasurement',
backref='qhawax',
lazy='subquery',
cascade='delete, delete-orphan')
air_quality_measurements = db.relationship('AirQualityMeasurement',
backref='qhawax',
lazy='subquery',
cascade='delete, delete-orphan')
gas_sensors = db.relationship(
'GasSensor', backref='qhawax',
lazy='subquery') # Don't delete gas sensor if qhawax is deleted
gas_inca = db.relationship('GasInca',
backref='qhawax',
lazy='subquery',
cascade='delete, delete-orphan')
qhawax_installation_historys = db.relationship(
'QhawaxInstallationHistory',
backref='qhawax',
lazy='subquery',
cascade='delete, delete-orphan')
bitacoras = db.relationship('Bitacora',
backref='qhawax',
lazy='subquery',
cascade='delete, delete-orphan')
class Asset(db.Model):
__tablename__ = "asset"
media_id = db.Column(db.String(11), primary_key=True, nullable=False)
title = db.Column(db.String(100), nullable=False)
profiles = db.relationship(
"Profile", secondary=asset_profile, lazy="subquery",
backref=db.backref("asset_profiles", lazy=True)
)
provider_id = db.Column(
db.Integer,
db.ForeignKey(
"provider.provider_id", onupdate="CASCADE", ondelete="CASCADE"
),
nullable=False
)
duration_in_seconds = db.Column(db.Integer, nullable=False)
licensing_window_start = db.Column(db.DateTime, nullable=False)
licensing_window_end = db.Column(db.DateTime, nullable=False)
def to_json(self):
provider = Provider.query.filter_by(
provider_id=self.provider_id).first()
asset_dict = {
"title": self.title,
"provider": provider.provider_id,
"providerId": provider.name,
"refreshRateInSeconds": provider.refresh_rate_in_seconds,
"media": {
"mediaId": self.media_id,
"durationInSeconds": self.duration_in_seconds
},
"licensingWindow": {
"start": self.licensing_window_start.isoformat(),
"end": self.licensing_window_end.isoformat()
},
"profileIds": [str(profile.profile_id) for profile in self.profiles]
}
return asset_dict
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String, nullable=False)
lastname = db.Column(db.String, nullable=False)
username = db.Column(db.String, unique=True, nullable=False)
email = db.Column(db.String, unique=True, nullable=False)
password = db.Column(db.String, nullable=False)
role = db.Column(db.String, default='user')
image_file = db.Column(db.String(20), nullable=False, default='user.png')
sub_plan = db.Column(db.String(20), default='NONE')
def __init__(self, FirstName, LastName, UserName, email, password, role):
self.username = UserName
self.firstname = FirstName
self.lastname = LastName
self.email = email
self.password = password
self.role = role
def __repr__(self):
return '<User {0}>'.format(self.name)
def toDict(self):
return {
'id': self.id,
'first_name': self.firstname,
'last_name': self.lastname,
'username': self.username,
'email': self.email,
'password': self.password,
'role': self.role,
'Plan': self.sub_plan
}
class UsedCar(db.Model):
__tablename__ = 'used_car'
index = db.Column(db.Integer,
primary_key=True,
unique=True,
nullable=False)
year = db.Column(db.Integer, unique=False, nullable=False)
brand = db.Column(db.String(16), unique=False, nullable=False)
model = db.Column(db.String(16), unique=False, nullable=False)
title = db.Column(db.String(200), unique=False, nullable=False)
miles = db.Column(db.Integer, unique=False, nullable=False)
vendor = db.Column(db.String(100), unique=False, nullable=False)
photos = db.Column(db.Integer, unique=False, nullable=False)
video = db.Column(db.Integer, unique=False, nullable=False)
exterior_color = db.Column(db.String(16), unique=False, nullable=False)
interior_color = db.Column(db.String(16), unique=False, nullable=False)
transmission = db.Column(db.String(16), unique=False, nullable=False)
drivetrain = db.Column(db.String(16), unique=False, nullable=False)
star = db.Column(db.Float, unique=False, nullable=False)
review_no = db.Column(db.String(16), unique=False, nullable=False)
price = db.Column(db.Integer, unique=False, nullable=False)
def __repr__(self):
rtform = "<UsedCar(id = '%s', year = '%s', brand = '%s', model = '%s',title = '%s', miles = '%s', vendor = '%s', photos = '%s', video = '%s', exterior_color = '%s', interior_color = '%s', transmission = '%s', drivertrain = '%s', star = '%s', review_no = '%s', price = '%s)>"
return rtform % (
self.index,
self.year,
self.brand,
self.model,
self.title,
self.miles,
self.vendor,
self.photos,
self.video,
self.exterior_color,
self.interior_color,
self.transmission,
self.drivetrain,
self.star,
self.review_no,
self.price,
)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(50), nullable=False, unique=True)
first_name = db.Column(db.String(20))
last_name = db.Column(db.String(20))
password = db.Column(db.String(50), nullable=False)
def __str__(self):
return self.email
def save_to_db(self):
db.session.add(self)
db.session.commit()
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
class Detconsulta(db.Model):
__tablename__ = 'detconsultas'
id = db.Column(db.Integer, primary_key=True)
iddoctor = db.Column(db.Integer, db.ForeignKey('doctors.id'), index=True)
idconsulta = db.Column(db.Integer, db.ForeignKey('consultas.id'),index= True)
respuesta = db.Column(db.String(128), nullable=False)
estado = db.Column(db.String(1), nullable=True)
def to_json(self):
return {
'id': self.id,
'iddoctor': self.iddoctor,
'idconsulta': self.idconsulta,
'respuesta': self.respuesta,
'estado': self.estado
}
def __init__(self, iddoctor, idconsulta, respuesta, estado):
self.iddoctor = iddoctor
self.idconsulta = idconsulta
self.respuesta = respuesta
self.estado = estado
