class User(BaseMixin, db.Model, UserMixin, ReprMixin):
email = db.Column(db.String(127), unique=True, nullable=False)
password = db.Column(db.String(255), default='', nullable=False)
username = db.Column(db.String(127), nullable=True)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
roles = db.relationship('Role',
back_populates='users',
secondary='user_role')
permissions = db.relationship('Permission',
back_populates='users',
secondary='user_permission')
user_profile = db.relationship("UserProfile",
uselist=False,
back_populates="user",
cascade='all, delete-orphan',
lazy='subquery')
def has_permission(self, permission):
if isinstance(permission, str):
return permission in (permission.name
for permission in self.permissions)
else:
return permission in self.permissions
class User(db.Model, BaseMixin, UserMixin, ReprMixin):
email = db.Column(db.String(127), unique=True, nullable=False)
password = db.Column(db.String(255), default='', nullable=False)
name = db.Column(db.String(127), nullable=True)
mobile_number = db.Column(db.String(20), unique=True, nullable=False)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
roles = db.relationship('Role', back_populates='users', secondary='user_role')
retail_shops = db.relationship('RetailShop', back_populates='users', secondary='user_retail_shop', lazy='dynamic')
@hybrid_property
def name(self):
return '{0}'.format(self.user_profile.first_name) + (' {0}'.format(self.user_profile.last_name)) \
if self.user_profile.first_name else ''
@hybrid_property
def retail_shop_ids(self):
return [i[0] for i in self.retail_shops.with_entities(RetailShop.id).all()]
@hybrid_property
def brand_ids(self):
return set([i[0] for i in self.retail_shops.with_entities(RetailShop.retail_brand_id).all()])
class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String, nullable=False)
body = db.Column(db.String, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey(Member.id))
user = db.relationship(Member)
created_at = db.Column(db.DateTime(timezone=True),
server_default=db.func.now())
updated_at = db.Column(db.DateTime(timezone=True),
server_default=db.func.now(),
server_onupdate=db.func.now())
image_url = db.Column(db.Text)
view_count = db.Column(db.Integer)
### RELATION PART
comments = db.relationship("Comment", backref="post", lazy=True)
def render(self):
return {
"id": self.id,
"title": self.title,
"body": self.body,
"image": self.image_url,
"created_at": self.created_at,
"updated_at": self.updated_at,
"view_count": self.view_count,
"user_id": self.author.get_data(),
"comments": [comment.render() for comment in self.comments[::-1]]
}
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
user_email = db.Column(db.String(64), unique=True, index=True)
user_username = db.Column(db.String(64), unique=True, index=True)
user_posts = db.relationship('Topic', cascade="all, delete-orphan", backref='author', lazy='dynamic')
user_role = db.Column(db.String(10), index=True, default='User')
user_first_name = db.Column(db.String(64), index=True, nullable=True)
user_last_name = db.Column(db.String(64), index=True, nullable=True)
user_birthday = db.Column(db.DateTime(), index=True, nullable=True)
user_date = db.Column(db.DateTime(), index=True, nullable=True)
user_location = db.Column(db.String(64), index=True, nullable=True)
user_about = db.Column(db.String(140), index=True, nullable=True)
user_occupation = db.Column(db.String(100), index=True, nullable=True)
user_interests = db.Column(db.String(100), index=True, nullable=True)
password_hash = db.Column(db.String(128))
user_reply = db.relationship('Reply', cascade="all, delete-orphan", backref='reply_from', lazy='dynamic')
def __init__(self, user_email, user_username, user_password, user_role,
user_date):
self.user_email = user_email
self.user_username = user_username
self.user_role = user_role
self.password_hash = generate_password_hash(user_password)
self.user_date = user_date
def check_password(self, password):
return check_password_hash(self.password_hash, password)
class Rider(BaseMixin, ReprMixin, UserMixin, db.Model):
__repr_fields__ = ['id', 'first_name']
email = db.Column(db.String(127), unique=True, nullable=True, index=True)
password = db.Column(db.String(255), nullable=True)
first_name = db.Column(db.String(55), nullable=False)
last_name = db.Column(db.String(55), nullable=True)
mobile_number = db.Column(db.String(20),
unique=True,
nullable=False,
index=True)
company_name = db.Column(db.String(55), nullable=True)
counter = db.Column(db.Integer, nullable=True, default=0)
picture = db.Column(db.Text(), nullable=True, index=True)
active = db.Column(db.Boolean(), default=False)
confirmed_at = db.Column(db.DateTime(), default=datetime.utcnow)
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
device_limit = db.Column(db.Integer, nullable=True, default=0)
devices = db.relationship('Device',
back_populates='riders',
secondary='rider_device')
class Address(db.Model):
__tablename__ = 'address'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
person_id = db.Column(db.Integer, db.ForeignKey("person.id"), nullable=False)
neighborhood = db.Column(db.String(128), index=True)
street = db.Column(db.String(128), index=True)
number = db.Column(db.String(20), index=True)
complement = db.Column(db.String(128), index=True)
city = db.Column(db.String(128), index=True)
creation_date = db.Column(db.DateTime(), nullable=False, default=datetime.datetime.utcnow())
modification_date = db.Column(db.DateTime(), nullable=False, default=datetime.datetime.utcnow())
person = db.relationship("Person", back_populates="address")
def __init__(self, data):
self.person_id = data.get('person_id')
self.neighborhood = data.get('neighborhood')
self.street = data.get('street')
self.number = data.get('number')
self.complement = data.get('complement')
self.city = data.get('city')
def __repr__(self):
if self.city and self.neighborhood and self.street and self.number:
return f'<Address: {self.city}, {self.neighborhood}, {self.street}, {self.number}'
return f'<Address: id:{self.id}'
class User(db.Model):
__tablename__ = 'users'
# __table_args__ = (
# db.ForeignKeyConstraint(
# ["person_id"],
# ["person.id"],
# ),
# )
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
person_id = db.Column(db.Integer, db.ForeignKey('person.id'), nullable=False)
username = db.Column(db.String(40), nullable=False, unique=True, index=True)
password = db.Column(db.String(128), nullable=False)
is_admin = db.Column(db.Boolean())
creation_date = db.Column(db.DateTime(), nullable=False, default=datetime.datetime.utcnow())
modification_date = db.Column(db.DateTime(), nullable=False, default=datetime.datetime.utcnow())
userProfileSystem = db.relationship("UserProfileSystem", back_populates="users")
person = db.relationship("Person", back_populates="users")
def __init__(self, username, password, is_admin, person_id):
bcrypt = Bcrypt(current_app)
self.username = username
self.password = bcrypt.generate_password_hash(password).decode('utf-8')
self.is_admin = is_admin
self.person_id = person_id
def compare_password(self, password):
bcrypt = Bcrypt(current_app)
return bcrypt.check_password_hash(self.password, password)
def __repr__(self):
return f'<User: {self.username}'
class Contact(db.Model):
__tablename__ = 'contact'
__table_args__ = (
db.ForeignKeyConstraint(
["person_id", ],
["person.id",]
),
)
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
person_id = db.Column(db.Integer, primary_key=True)
person = db.relationship("Person")
email = db.Column(db.String(65))
cell_phone = db.Column(db.String(11))
phone = db.Column(db.String(11))
creation_date = db.Column(db.DateTime(), nullable=False, default=datetime.datetime.utcnow())
modification_date = db.Column(db.DateTime(), nullable=False, default=datetime.datetime.utcnow())
def __init__(self, person_id, email, cell_phone, phone):
self.person_id = person_id
self.email = email
self.cell_phone = cell_phone
self.phone = phone
def __repr__(self):
contact = 'id: {id}'
if email: contact+= f', email:{email}'
if cell_phone: contact+= f', cellphone:{cell_phone}'
return f'<Contact: {contact}'
class User(db.Model, BaseMixin, ReprMixin, UserMixin):
__repr_fields__ = ['id', 'username', 'email', 'mobile_number', 'roles']
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(40), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
mobile_number = db.Column(db.String(20),
unique=True,
nullable=False,
index=True)
password = db.Column(db.String(60), nullable=False)
where_from = db.Column(db.String(20), nullable=False)
where_to = db.Column(db.String(20), nullable=False)
previous_salary = db.Column(db.Integer, nullable=False)
expected_salary = db.Column(db.Integer, nullable=False)
active = db.Column(db.Boolean(), default=False)
confirmed_at = db.Column(db.DateTime(), default=datetime.utcnow)
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
roles = db.relationship('Role',
back_populates='users',
secondary='user_role')
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.String, nullable=False)
created_on = db.Column(db.DateTime(timezone=True),
server_default=db.func.now())
updated_on = db.Column(db.DateTime(timezone=True),
server_default=db.func.now(),
server_onupdate=db.func.now())
user_id = db.Column(db.Integer, db.ForeignKey(Users.id), nullable=False)
post_id = db.Column(db.Integer,
db.ForeignKey(Post.id, ondelete='CASCADE'),
nullable=False)
like_list = db.relationship('Like',
backref=db.backref('comment'),
passive_deletes="all",
lazy=True)
def render(self):
likes = [like.render() for like in self.like_list]
likers = [like['owner'] for like in likes]
return {
'comment_id': self.id,
'content': self.content,
'owner': self.user.user_name,
'owner_id': self.user.id,
"likes": {
'count': len(likes),
'liker_name': [like['owner'].user_name for like in likes],
'liker_id': [like['owner'].id for like in likes]
},
"created_on": self.created_on,
"updated_on": self.updated_on,
}
class ProfilePermission(db.Model):
__tablename__ = 'profilePermission'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
profile_system_id = db.Column(db.Integer,
db.ForeignKey("profileSystem.id"),
nullable=False)
system_permission_id = db.Column(db.Integer,
db.ForeignKey("systemPermission.id"),
nullable=False)
creation_date = db.Column(db.DateTime(),
nullable=False,
default=datetime.datetime.utcnow())
modification_date = db.Column(db.DateTime(),
nullable=False,
default=datetime.datetime.utcnow())
systemPermission = db.relationship("SystemPermission",
back_populates="profilePermission")
profileSystem = db.relationship("ProfileSystem",
back_populates="profilePermission")
def __init__(self, data):
self.system_permission_id = data.get('system_permission_id')
self.profile_system_id = data.get('profile_system_id')
def __repr__(self):
return f'<ProfilePermission: {self.id}'
class System(db.Model):
__tablename__ = 'system'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
name = db.Column(db.String(50), index=True, nullable=False, unique=True)
description = db.Column(db.String(200))
url = db.Column(db.String(200), index=True)
creation_date = db.Column(db.DateTime(),
nullable=False,
default=datetime.datetime.utcnow())
modification_date = db.Column(db.DateTime(),
nullable=False,
default=datetime.datetime.utcnow())
systemPermission = db.relationship("SystemPermission",
back_populates="system")
profileSystem = db.relationship("ProfileSystem", back_populates="system")
userProfileSystem = db.relationship("UserProfileSystem",
back_populates="system")
def __init__(self, data):
self.name = data.get('name')
self.description = data.get('description')
self.url = data.get('url')
def __repr__(self):
return f'<System: {self.name}'
class User(BaseMixin, UserMixin, ReprMixin, db.Model):
email = db.Column(db.String(127), unique=True, nullable=False)
password = db.Column(db.String(255), default='', nullable=False)
name = db.Column(db.String(55), nullable=False)
mobile_number = db.Column(db.String(20), unique=True, nullable=False)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
organisation_id = db.Column(db.ForeignKey('organisation.id'), index=True)
organisation = db.relationship('Organisation',
foreign_keys=[organisation_id],
back_populates='users')
roles = db.relationship('Role',
back_populates='users',
secondary='user_role')
permissions = db.relationship('Permission',
back_populates='users',
secondary='user_permission',
lazy='dynamic')
stores = db.relationship('Store',
back_populates='users',
secondary='user_store',
lazy='dynamic')
@hybrid_property
def store_ids(self):
return [i[0] for i in self.stores.with_entities(Store.id).all()]
@store_ids.expression
def store_ids(self):
return select([
UserStore.store_id
]).where(UserStore.user_id == self.id).label('store_ids').limit(1)
@hybrid_method
def has_shop_access(self, shop_id):
return db.session.query(
UserStore.query.filter(
UserStore.store_id == shop_id,
UserStore.user_id == self.id).exists()).scalar()
@hybrid_method
def has_permission(self, permission):
return db.session.query(
self.permissions.filter(
Permission.name == permission).exists()).scalar()
@hybrid_property
def is_owner(self):
return self.has_role('owner')
class PointStoreModelMixin(db.Model):
__abstract__ = True
value = db.Column(db.Float(), nullable=True)
value_original = db.Column(db.Float(), nullable=True)
value_raw = db.Column(db.String(), nullable=True)
fault = db.Column(db.Boolean(), default=False, nullable=False)
fault_message = db.Column(db.String())
ts_value = db.Column(db.DateTime())
ts_fault = db.Column(db.DateTime())
class Temperature(db.Model):
id = db.Column(db.Integer(), primary_key=True)
sensorID = db.Column(db.String(64), nullable=False)
createdAt = db.Column(db.DateTime(), index=True, nullable=False)
takenAt = db.Column(db.DateTime(), index=True, nullable=False)
temperature = db.Column(db.String(3), nullable=False)
def __repr__(self):
return '<Temperature {}>'.format(self.id)
class User(BaseMixin, ReprMixin, UserMixin, db.Model):
__repr_fields__ = ['id', 'first_name']
email = db.Column(db.String(127), unique=True, nullable=True, index=True)
password = db.Column(db.String(255), nullable=True)
first_name = db.Column(db.String(55), nullable=False)
last_name = db.Column(db.String(55), nullable=True)
mobile_number = db.Column(db.String(20),
unique=True,
nullable=False,
index=True)
business_name = db.Column(db.String(55), nullable=True)
counter = db.Column(db.Integer, nullable=True, default=0)
#picture = db.Column(db.Text(), nullable=True, index=True)
active = db.Column(db.Boolean(), default=False)
confirmed_at = db.Column(db.DateTime(), default=datetime.utcnow)
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
parent_id = db.Column(db.ForeignKey('user.id'), nullable=True)
parent = db.relationship('User',
foreign_keys=[parent_id],
uselist=False,
remote_side='User.id')
children = db.relationship(
'User',
remote_side='User.parent_id',
lazy='dynamic',
order_by="User.first_name",
)
roles = db.relationship('Role',
back_populates='users',
secondary='user_role')
devices = db.relationship('Device',
back_populates='users',
secondary='user_device')
@hybrid_property
def get_children_list(self):
beginning_getter = User.query.with_entities(User.id) \
.filter(User.id == self.id).cte(name='children_for', recursive=True)
with_recursive = beginning_getter.union_all(
User.query.with_entities(
User.id).filter(User.parent_id == beginning_getter.c.id))
return [i[0] for i in db.session.query(with_recursive).all()]
@hybrid_property
def get_immediate_children_list(self):
return [i[0] for i in self.children.with_entities(User.id).all()]
class Comment(db.Model):
__tablename__ = "comments"
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text, nullable=False)
image_url = db.Column(db.Text)
author = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False)
timestamp = db.Column(db.DateTime(timezone=True), server_default = db.func.now())
updated = db.Column(db.DateTime(timezone=True), server_default = db.func.now(), server_onupdate=db.func.now())
def __repr__(self):
return '<Task>' % self.id
class Post(db.Model):
__tablename__ = "posts"
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text, nullable=False)
image_url = db.Column(db.Text)
author = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
timestamp = db.Column(db.DateTime(timezone=True), server_default = db.func.now())
updated = db.Column(db.DateTime(timezone=True), server_default = db.func.now(), server_onupdate=db.func.now()) ## same as above, but with updating timestamp
views_count = db.Column(db.Integer, default=0)
def __repr__(self):
return '<Task>' % self.id
class User(db.Model):
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(length=255))
email = db.Column(db.String(length=255))
password = db.Column(db.String(length=255))
created_at = db.Column(db.DateTime())
updated_at = db.Column(db.DateTime())
def __init__(self, username, email, password, created_at):
self.username = username
self.email = email
self.password = password
self.created_at = created_at
class Order(db.Model):
__tablename__ = 'orders'
id = db.Column(db.Integer, primary_key=True)
client_id = db.Column(db.Integer, db.ForeignKey('users.id'))
orderitems = db.relationship('Orderitem', backref='order')
isPaid = db.Column(db.Boolean, default=False)
timestamp = db.Column(db.DateTime(timezone=True), server_default = db.func.now())
class Image(db.Model):
__tablename__ = 'images'
id = db.Column(db.Integer, primary_key=True)
image_name = db.Column(db.String(200))
image_url = db.Column(db.Text, nullable=False)
event_id = db.Column(db.Integer, db.ForeignKey('events.id'))
timestamp = db.Column(db.DateTime(timezone=True), server_default = db.func.now())
class Article(db.Model):
__tablename__ = 'article'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200))
body = db.Column(db.Text, nullable=False)
event_id = db.Column(db.Integer, db.ForeignKey('events.id'))
timestamp = db.Column(db.DateTime(timezone=True), server_default = db.func.now())
class Order(db.Model):
timestamp = db.Column(db.DateTime(timezone=True),
server_default=func.now())
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
restaurant_id = db.Column(db.Integer, db.ForeignKey('restaurant.id'))
status = db.Column(db.Integer, default=0) # payment or not yet
class Recipient(db.Model):
__tablename__ = 'recipients'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
index=True,
nullable=False)
email = db.Column(db.String(255), nullable=False)
name = db.Column(db.String(255), nullable=False)
state = db.Column(db.String(50), nullable=False)
last_send_date = db.Column(db.DateTime())
form_data = db.relationship("FormData", backref='recipient', lazy=True)
def __repr__(self):
return '<Recipient %r>' % self.name
def serialize(self):
return {
'id': self.id,
'email': self.email,
'name': self.name,
'user_name': self.user.username,
'state': self.state,
'last_send_date': self.last_send_date
}
class Image(db.Model):
timestamp = db.Column(db.DateTime(timezone=True),
server_default=func.now())
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String, unique=True)
restaurants = db.relationship('Restaurant', backref='img', lazy=True)
dishs = db.relationship('Dish', backref='img', lazy=True)
class QRCode(db.Model):
__tablename__ = 'qrcode'
timestamp = db.Column(db.DateTime(timezone=True),
server_default=func.now())
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String, unique=True)
class Person(db.Model):
__tablename__ = 'person'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
type = db.Column(db.String(128), index=True, nullable=True)
birth_date = db.Column(db.Date())
name = db.Column(db.String(128), index=True)
surname = db.Column(db.String(128), index=True)
gender = db.Column(db.String(128))
cpf = db.Column(db.String(128), index=True)
company_name = db.Column(db.String(128), index=True)
cnpj = db.Column(db.String(128), index=True)
creation_date = db.Column(db.DateTime(),
nullable=False,
default=datetime.datetime.utcnow())
modification_date = db.Column(db.DateTime(),
nullable=False,
default=datetime.datetime.utcnow())
users = db.relationship("User", back_populates="person")
address = db.relationship("Address", back_populates="person")
def __init__(self, data_person):
_type = data_person.get('type')
birth_date = data_person.get('birth_date')
name = data_person.get('name')
surname = data_person.get('surname')
gender = data_person.get('gender')
cpf = data_person.get('cpf')
company_name = data_person.get('company_name')
cnpj = data_person.get('cnpj')
self.type = _type
self.birth_date = birth_date
self.name = name
self.surname = surname
self.gender = gender
self.cpf = cpf
self.company_name = company_name
self.cnpj = cnpj
def __repr__(self):
identification = ''
if self.name or self.surname or self.company_name:
identification = f'{self.name} {self.surname} {self.company_name}'
return f'<Person: {identification}'
class Engagement(db.Model):
__tablename__ = 'engagement'
engagementid = db.Column(db.Integer, primary_key=True)
capacity_in_days = db.Column(db.Integer, nullable=False)
hours_of_work = db.Column(db.Integer, nullable=False)
start_date = db.Column(db.DateTime(), nullable=False, default=datetime.now)
end_date = db.Column(db.DateTime(), nullable=False, default=datetime.now)
contract_rate = db.Column(db.String(), nullable=False)
profile_id = db.Column(db.Integer,
db.ForeignKey("profiles.profileid"),
nullable=False)
contract_id = db.Column(db.Integer,
db.ForeignKey("contracts.contractid"),
nullable=False)
def __repr__(self):
return f"<Engagement {self.title}>"
class Follow(db.Model):
__tablename__ = "follows"
id = db.Column(db.Integer, primary_key=True)
author = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
timestamp = db.Column(db.DateTime(timezone=True), server_default = db.func.now())
def __repr__(self):
return '<Task>' % self.id
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
comment = db.Column(db.Text(2000))
author = db.Column(db.String(150))
article = db.Column(db.ForeignKey('article.id'))
created_at = db.Column(db.DateTime(), default=datetime.utcnow)
def __repr__(self):
return f'{self.author}{self.comment}'
