class UserModel(db.Model,UserMixin):
'''user model : representing user information in sql table'''
__tablename__='users'
id=db.Column(db.Integer,primary_key=True)
email=db.Column(db.String(50),unique=True,nullable=False)
password=db.Column(db.String(256),nullable=False)
mobile_no=db.Column(db.String(10),nullable=False)
billing_address=db.Column(db.Text,nullable=True)
delivery_address=db.Column(db.Text,nullable=True)
products=db.relationship('ProductModel',backref='user',lazy=True,cascade='all,delete')
def __init__(self,email,password,mobile_no):
self.email=email
self.password=bcrypt.generate_password_hash(password).decode('utf-8')
self.mobile_no=mobile_no
def update_password(self,password):
'''update password'''
self.password=bcrypt.generate_password_hash(password).decode('utf-8')
def __repr__(self):
return f"hello i am {self.email}"
def check_password(self,password):
'''check users password'''
return bcrypt.check_password_hash(self.password,password)
class ProductModel(BaseModel):
# table name
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True)
shop_id = db.Column(db.Integer, db.ForeignKey('shops.id', ondelete='CASCADE'), nullable=False)
name = db.Column(db.String(128), nullable=False)
description = db.Column(db.String(128), nullable=False)
price = db.Column(db.Float, nullable=False)
# class constructor
def __init__(self, data):
"""
Class constructor
"""
self.shop_id = data.get('shop_id')
self.name = data.get('name')
self.description = data.get('description')
self.price = data.get('price')
@staticmethod
def get_product(product_id):
response = ProductModel.query.get(product_id)
if not response:
raise NotFoundException("Invalid ID")
return response
class Film(db.Model):
__tablename__ = 'films'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(128), nullable=False)
release_date = db.Column(db.Date, index=True, nullable=False)
uuid = db.Column(db.String(36), unique=True)
description = db.Column(db.Text)
distributed_by = db.Column(db.String(120), nullable=False)
length = db.Column(db.Float)
rating = db.Column(db.Float)
def __routes__(self, title, release_date, description, distributed_by,
length, rating):
self.title = title
self.release_date = release_date
self.description = description
self.distributed_by = distributed_by
self.length = length
self.rating = rating
self.uuid = str(uuid.uuid4())
def __repr__(self):
return f'Film({self.title}, {self.uuid}, {self.distributed_by}, {self.release_date})'
def to_dict(self):
return {
'title': self.title,
'uuid': self.uuid,
'release_date': self.release_date.strftime('%Y-%m-%d'),
'description': self.description,
'distributed_by': self.distributed_by,
'length': self.length,
'rating': self.rating
}
class User(db.Model):
user_id = db.Column(db.BIGINT(), primary_key=True)
user_name = db.Column(db.String(255), unique=False, nullable=False)
login = db.Column(db.String(255), unique=True, nullable=True)
def __repr__(self):
return '<User %r>' % self.login
class NormalUserModel(UserModel):
# table name
__tablename__ = 'normal_users'
user_id = db.Column(db.Integer,
db.ForeignKey('users.user_id'),
primary_key=True)
suscripcion = db.Column(db.String(128), nullable=False)
picture = db.Column(db.String(256), nullable=True)
make_favours = db.Column(db.Boolean, nullable=False)
__mapper_args__ = {
'polymorphic_identity': 'normal_users',
}
# class constructor
def __init__(self, data):
"""
Class constructor
"""
super(NormalUserModel, self).__init__(data)
self.suscripcion = data.get('suscripcion')
self.picture = data.get('picture')
self.make_favours = data.get('make_favours', True)
@staticmethod
def get_user(user_id):
response = NormalUserModel.query.get(user_id)
if not response:
raise NotFoundException("Invalid ID")
return response
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
def __repr__(self):
return '<User %r>' % self.username
class Posts(db.Model):
id = db.Column(db.Integer, primary_key=True)
deleted = db.Column(db.Boolean, default=False)
deleted_at = db.Column(db.DateTime, default=None)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
onupdate=datetime.datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
title = db.Column(db.String(200), nullable=False)
thumbnail = db.Column(db.Text)
slug = db.Column(db.String(200), nullable=False, unique=True)
brief = db.Column(db.Text, nullable=False)
content = db.Column(db.Text, nullable=False)
last_edited_at = db.Column(db.DateTime)
user = db.relationship('Users', backref=db.backref('posts', lazy=True))
votes = db.relationship("Votes", back_populates="post")
tags = db.relationship('Tags',
secondary=post_tags,
lazy='subquery',
backref=db.backref('posts', lazy=True))
def __repr__(self):
return '<Posts %r>' % self.title
class Creator(db.Model):
__tablename__ = 'creator'
id = db.Column(db.Integer(), primary_key=True)
firstName = db.Column(db.String(100))
middleName = db.Column(db.String(100))
lastName = db.Column(db.String(100))
suffix = db.Column(db.String(100))
fullName = db.Column(db.String(100))
modified = db.Column(db.DateTime())
comics = db.relationship(Comics,
secondary=creator_comics,
backref=db.backref('creators', lazy=True))
def __init__(self, id, firstName, middleName, lastName, suffix, fullName,
modified, comics):
self.id = id
self.firstName = firstName
self.middleName = middleName
self.lastName = lastName
self.suffix = suffix
self.fullName = fullName
self.modified = modified
self.comics = comics
def create(self):
db.session.add(self)
db.session.commit()
return self
class Name(db.Model):
__tablename__ = 'name'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(400))
disposition = db.Column(db.String(400))
hat_id = db.Column(db.Integer, db.ForeignKey('hat.id'))
class Project(db.Model):
__tablename__ = 'Projects'
__table_args__ = {'extend_existing': True}
name = db.Column(db.String(50), primary_key=True, index=True)
descriptions = db.Column(db.String(75), index=True)
def __repr__(self):
return f"<Project: name: {self.full_name}, descriptions: {self.descriptions}>"
class Goal(db.Model):
__tablename__ = 'goals'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
description = db.Column(db.String(255))
icon = db.Column(db.String(255))
teachers = db.relationship('Teacher',
secondary=teacher_goals,
back_populates='goals')
class Reports(db.Model):
__tablename__ = 'reports'
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
xml_path = db.Column(db.String(200))
pdf_path = db.Column(db.String(200))
active = db.Column(db.Integer, default=0)
processing = db.Column(db.Integer, default=0)
created = db.Column(db.DateTime, default=datetime.utcnow)
updated = db.Column(db.DateTime)
class Brand(db.Model):
brand_id = db.Column(db.BIGINT(), primary_key=True, nullable=False)
brand_name = db.Column(db.String(511), nullable=False)
email = db.Column(db.String(255))
phone = db.Column(db.String(15))
address = db.Column(db.String(511))
archived = db.Column(db.Boolean(), nullable=False, default=False)
def __repr__(self):
return '<Brand %r>' % self.brand_name
class PackingType(db.Model):
packing_type_id = db.Column(db.BIGINT(), primary_key=True, nullable=False)
packing_label_url = db.Column(db.String(1023))
code_iso = db.Column(db.String(15))
code_gost = db.Column(db.String(15))
packing_description = db.Column(db.String(511))
packing_examples = db.Column(db.String(511))
archived = db.Column(db.Boolean(), nullable=False, default=False)
def __repr__(self):
return '<Packing_Type %r>' % self.brand_name
class CarModel(db.Model):
__tablename__ = 'cars'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
make = db.Column(db.String(120), nullable=False)
model = db.Column(db.String(120), nullable=False)
time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow)
owner_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
owner = db.relationship('UserModel', back_populates='cars')
def persist(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_marshaller():
return {
'id': fields.Integer,
'name': fields.String,
'make': fields.String,
'model': fields.String,
'time_created': fields.DateTime,
'time_updated': fields.DateTime,
'owner': fields.Nested(UserModel.get_marshaller())
}
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def return_all(cls):
return CarModel.query.all()
@classmethod
def return_all_for_user(cls, user_id):
return CarModel.query.filter(cls.owner_id == user_id).all()
@classmethod
def delete_all(cls):
db.session.query(cls).delete()
db.session.commit()
@classmethod
def delete_by_id(cls, id):
car = db.session.query(cls).filter(cls.id == id).first()
if car:
db.session.delete(car)
db.session.commit()
else:
raise NoData
class Professor(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), unique=False, nullable=False)
surname = db.Column(db.String(30), unique=False, nullable=False)
# Rank of the teacher eg. PhD...
merits = db.Column(db.String(20), unique=False, nullable=False)
# Relationship for foreign key in a different table
study_classes = db.relationship('StudyClass', backref='professor')
discipline = db.relationship('Discipline', backref='professor')
def __repr__(self):
return f'{self.merits} {self.name} {self.surname}'
class Teacher(db.Model):
__tablename__ = 'teachers'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
about = db.Column(db.Text)
rating = db.Column(db.Float)
picture = db.Column(db.String(255))
price = db.Column(db.Integer)
goals = db.relationship('Goal',
secondary=teacher_goals,
back_populates='teachers')
free = db.Column(JSON)
class Records(db.Model):
__tablename__ = 'records'
__table_args__ = {'extend_existing': True}
uuid = db.Column(UUID(as_uuid=True), primary_key=True)
country_iso = db.Column(db.String(100), index=True)
country_name = db.Column(db.String(100))
date = db.Column(DATE)
confirmed = db.Column(db.INTEGER)
deaths = db.Column(db.INTEGER)
recovered = db.Column(db.INTEGER)
def __repr__(self):
return f'<Record ID: {self.uuid}, ISO: {self.country_iso}, Country: {self.country_name}, Date: {self.date}, {self.confirmed, self.deaths, self.deaths}>'
class Books(db.Model):
__tablename__ = "books"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(150))
author = db.Column(db.String(100))
created_on = db.Column(db.DateTime, server_default=db.func.now())
updated_on = db.Column(db.DateTime,
server_default=db.func.now(),
server_onupdate=db.func.now())
def __repr__(self):
return "<Books id={}, title={}, author={}>".format(
self.id, self.title, self.author)
class StudyClass(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(10), unique=True, nullable=False)
year_of_study = db.Column(db.String(2), unique=False, nullable=False)
schedule_id = db.Column(db.Integer, db.ForeignKey('schedule.id'))
professor_id = db.Column(db.Integer, db.ForeignKey('professor.id'))
schedule = db.relationship('Schedule',
backref=db.backref('classes', lazy=True))
discipline = db.relationship('Discipline', backref='study_class')
def __repr__(self):
return f'{self.name} {self.year_of_study}'
class Tags(db.Model):
id = db.Column(db.Integer, primary_key=True)
deleted = db.Column(db.Boolean, default=False)
deleted_at = db.Column(db.DateTime, default=None)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
onupdate=datetime.datetime.utcnow)
name = db.Column(db.String(80), nullable=False, unique=True)
slug = db.Column(db.String(200), nullable=False, unique=True)
def __repr__(self):
return '<Tags %r>' % self.name
class Discipline(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=False, nullable=False)
# Day of the week + hour interval of the class
course_schedule = db.Column(db.String(50), unique=False, nullable=True)
lab_schedule = db.Column(db.String(50), unique=False, nullable=True)
seminary_schedule = db.Column(db.String(50), unique=False, nullable=True)
schedule_id = db.Column(db.Integer, db.ForeignKey('schedule.id'))
study_class_id = db.Column(db.Integer, db.ForeignKey('study_class.id'))
professor_id = db.Column(db.Integer, db.ForeignKey('professor.id'))
def __repr__(self):
return f'{self.name} {self.course_schedule} {self.lab_schedule} {self.seminary_schedule}'
class User(UserMixin, Base):
__tablename__ = 'auth_user'
first_name = db.Column(db.String(128), nullable=False)
last_name = db.Column(db.String(128), nullable=False)
# Identification data
email = db.Column(db.String(128), nullable=False, unique=True)
password_hash = db.Column(db.String(192), nullable=False)
# Authorization data
# role = db.Column(db.SmallInteger, nullable=False)
# status = db.Column(db.SmallInteger, nullable=False)
# Initialization procedure for new instances
# def __init__(self, first_name, last_name, email, password):
# self.first_name = first_name
# self.last_name = last_name
# self.email = email
# self.password_hash = password_hash
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def generate_auth_token(self, expiration=600):
s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
@staticmethod
def verify_auth_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
user = User.query.get(data['id'])
return user
except SignatureExpired:
return None
except BadSignature:
return None
def __repr__(self):
return f'<User {self.first_name} {self.email}>'
class Employee(db.Model):
id = db.Column(db.Integer, primary_key=True)
department_id = db.Column(db.Integer, db.ForeignKey("department.id"))
name = db.Column(db.String(250))
surname = db.Column(db.String(250))
slug = db.Column(db.String(250))
salary = db.Column(db.Integer)
birth_date = db.Column(db.Date)
def __init__(self, *args, **kwargs):
super(Employee, self).__init__(*args, **kwargs)
self.slug = slugify(self.name + self.surname)
def __repr__(self):
return f"<Employee : name: {self.name}, surname: {self.surname}, department: {self.department_id}>"
class User(UserMixin, db.Model):
"""Model for user accounts."""
# __tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64),
index=False,
unique=False,
nullable=False)
password = db.Column(db.String(200),
primary_key=False,
unique=False,
nullable=False)
email = db.Column(db.String(80), index=True, unique=False, nullable=False)
admin = db.Column(db.Boolean, index=False, unique=False, nullable=False)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
name = db.Column(db.String(120), nullable=False)
surname = db.Column(db.String(120), nullable=False)
email = db.Column(EmailType, unique=True, nullable=False)
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def return_all(cls):
def to_json(x):
return {
'username': x.username,
'password': x.password
}
return {'users': list(map(to_json, User.query.all()))}
@classmethod
def delete_all(cls):
try:
num_rows_deleted = db.session.query(cls).delete()
db.session.commit()
return {'message': f'{num_rows_deleted} row(s) deleted'}
except Exception as e:
return {'message': 'Something went wrong'}
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash):
return sha256.verify(password, hash)
class Character(db.Model):
__tablename__ = 'character'
id = db.Column(db.Integer, primary_key=True)
available = db.Column(db.Integer)
collectionURI = db.Column(db.String(140))
returned = db.Column(db.Integer)
comic_id = db.Column(db.Integer, db.ForeignKey('comics.id'))
class Department(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
slug = db.Column(db.String(255))
employees = db.relationship("Employee")
def __init__(self, *args, **kwargs):
super(Department, self).__init__(*args, **kwargs)
self.generate_slug()
def generate_slug(self):
if self.name:
self.slug = slugify(self.name)
def __repr__(self):
return f"<Department : name={self.name}, id={self.id}>"
class ActivityLog(db.Model):
"""
Describes an activity by (optional) user (and/or) on some (optional) post,
or just a message about what was done
"""
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=True)
post_id = db.Column(db.Integer, db.ForeignKey("post.id"), nullable=True)
action = db.Column(db.String(255))
date = db.Column(db.Date, default=datetime.date.today())
time = db.Column(db.Time, default=datetime.datetime.now().time())
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def __repr__(self):
return f"<Activity: id={self.id}, user={self.user_id}, post={self.post_id}, " \
f"action={self.action}, date={self.date}, time={self.time}>"
def json(self):
return {
"user_id": self.user_id,
"post_id": self.post_id,
"action": self.action,
"date": str(self.date),
"time": str(self.time)
}
class Build(db.Model):
_id = db.Column(db.Integer, primary_key=True) # ID in database (is unique)
id = db.Column(
db.Integer) # ID in job, together with job_id is an unique tuple
description = db.Column(db.Text)
commands = db.Column(db.Text)
output = db.Column(db.Text)
status = db.Column(db.String(32))
job_id = db.Column(db.Integer, db.ForeignKey("job.id"))
node_id = db.Column(db.Integer, db.ForeignKey("node.id"))
created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def to_dict(self):
return {
'id': self.id,
'description': self.description,
'commands': self.commands,
'output': self.output,
'status': self.status,
'job_id': self.job_id,
'node_id': self.node_id,
'created_date': self.created_date.strftime("%m/%d/%Y, %H:%M:%S")
}
def __repr__(self):
return f"<id {self.id}, description : {self.description}>"
