class Address(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
line1 = db.Column(db.String(120))
line2 = db.Column(db.String(120))
city = db.Column(db.String(120))
state = db.Column(db.String(2))
zipcode = db.Column(db.String(16))
vendor = db.relationship("Vendor", backref='address')
class Patent(db.Model):
__tablename__ = "patent"
id = db.Column(db.Integer, primary_key=True)
human_id = db.Column(db.Integer, db.ForeignKey('human.id'), nullable=False)
title = db.Column(db.String(200), nullable=False)
description = db.Column(db.String(250), nullable=False)
patent_number = db.Column(db.String(20), nullable=False)
inventors = db.Column(db.String(250), nullable=False)
issue_date = db.Column(db.DateTime, nullable=True)
patent_office_id = db.Column(db.Integer, db.ForeignKey('patent_office.id'))
patent_office = db.relationship('PatentOffice', backref=db.backref('patent', lazy='dynamic'))
patent_status_id = db.Column(db.Integer, db.ForeignKey('patent_status.id'))
patent_status = db.relationship('PatentStatus', backref=db.backref('patent', lazy='dynamic'))
patent_url = db.Column(db.String(100), nullable=True)
def __repr__(self):
return self.status
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.Text, unique=True)
username = db.Column(db.Text, unique=True)
name = db.Column(db.Text)
image_url = db.Column(db.Text)
header_image_url = db.Column(db.Text)
bio = db.Column(db.Text)
# HEY THE BIO IS RIGHT HERE
location = db.Column(db.Text)
password = db.Column(db.Text)
messages = db.relationship('Message', backref='user', lazy='dynamic')
followers = db.relationship(
"User",
secondary=FollowersFollowee,
primaryjoin=(FollowersFollowee.c.follower_id == id),
secondaryjoin=(FollowersFollowee.c.followee_id == id),
backref=db.backref('following', lazy='dynamic'),
lazy='dynamic')
def __init__(self,
email,
username,
password,
image_url='/static/images/default-pic.png'):
self.email = email
self.username = username
self.image_url = image_url
self.password = bcrypt.generate_password_hash(password).decode('UTF-8')
likes = db.relationship("Message",
secondary=UserLikedMessages,
backref=db.backref('liked_by', lazy='dynamic'),
lazy='dynamic')
def __repr__(self):
return f"#{self.id}: email: {self.email} - username: {self.username}"
def is_followed_by(self, user):
return bool(self.followers.filter_by(id=user.id).first())
def is_following(self, user):
return bool(self.following.filter_by(id=user.id).first())
class Author(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(150), nullable=False)
bio = db.Column(db.Text, nullable=True)
books = db.relationship("Book", backref="writer", lazy="dynamic")
def __repr__(self):
return f"Author {self.name}"
class Device(db.Model):
__tablename__ = "devices"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
device_id = db.Column(db.String(128), unique=True, nullable=False)
device_type = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean, default=True, nullable=False)
pn_token = db.Column(db.String(256), unique=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User', backref=db.backref('devices', lazy='joined'))
created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow, onupdate=datetime.utcnow)
def __init__(self, device_id: str, device_type: str, pn_token: str=None, active: bool=True, user=None, created_at: datetime=datetime.utcnow()):
self.device_id = device_id
self.device_type = device_type # "apple" "android"
self.pn_token = pn_token
self.active = active
self.user = user
self.created_at = created_at
self.updated_at = created_at
# noinspection PyPep8
@staticmethod
def query_active_devices_for_user(user: User):
return Device.query.filter(Device.user_id == user.id, Device.active == True, Device.pn_token.isnot(None))
# noinspection PyPep8
@staticmethod
def query_active_devices_for_group(group: Group, discard_user_ids:List[int]=None):
discard_user_ids = discard_user_ids or []
user_ids = [user.user_id for user in group.associated_users if user.user_id not in discard_user_ids]
return Device.query.filter(Device.user_id.in_(tuple(user_ids)), Device.active == True,
Device.pn_token.isnot(None))
@staticmethod
def create_or_update(device_id, device_type: str, user:User=None, active: bool = True, pn_token: str=None):
device = Device.first_by(device_id=device_id)
if not device:
device = Device(device_id=device_id, device_type=device_type, user=user, active=active, pn_token=pn_token)
db.session.add(device)
else:
device.device_type = device_type
device.active = active
if user:
device.user = user
if pn_token:
device.pn_token = pn_token
return device
@staticmethod
def first_by(**kwargs):
"""Get first db device that match to device_id"""
return Device.query.filter_by(**kwargs).first()
@staticmethod
def first(*criterion):
"""Get first db entity that match to criterium"""
return Device.query.filter(*criterion)
class Ruolo(db.Model):
__tablename__ = 'ruoli'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
default = db.Column(db.Boolean, default=False, index=True)
permissions = db.Column(db.Integer)
# n utenti hanno un certo ruolo
users = db.relationship('Utente', backref='ruolo', lazy='dynamic')
def __init__(self, **kwargs):
super(Ruolo, self).__init__(**kwargs)
# Since SQLAlchemy will set this field to None by default,
# a class constructor is added that sets it to 0
# if an initial value isn’t provided in the constructor arguments.
if self.permissions is None:
self.permissions = 0
'''
Inserimento dei ruoli nel db; User è il default
'''
@staticmethod
def insert_roles():
roles = {
'User': [Permission.FOLLOW, Permission.COMMENT, Permission.WRITE],
'Administrator': [
Permission.FOLLOW, Permission.COMMENT, Permission.WRITE,
Permission.MODERATE, Permission.ADMIN
],
}
default_role = 'User'
for r in roles:
role = Ruolo.query.filter_by(name=r).first()
if role is None:
role = Ruolo(name=r)
role.reset_permissions()
for perm in roles[r]:
role.add_permission(perm)
role.default = (role.name == default_role)
db.session.add(role)
db.session.commit()
def add_permission(self, perm):
if not self.has_permission(perm):
self.permissions += perm
def remove_permission(self, perm):
if self.has_permission(perm):
self.permissions -= perm
def reset_permissions(self):
self.permissions = 0
def has_permission(self, perm):
return self.permissions & perm == perm
def __repr__(self):
return '<Ruolo %r>' % self.name
class Event(OutputMixin, db.Model):
__tablename__ = "event"
id = Column(
UUID(as_uuid=True),
primary_key=True,
server_default=sqlalchemy.text("uuid_generate_v4()"),
)
name = Column(db.String(128), nullable=False)
description = Column(db.String(50000), nullable=False)
url = Column(db.String(2048), nullable=False)
start = Column(db.DateTime, nullable=False)
end = Column(db.DateTime, nullable=False)
duration = Column(Integer, nullable=False)
category = Column(db.String(256), nullable=False)
topics = db.relationship("Topic", secondary=event_topic_table)
entry = db.relationship("Entry", secondary=event_entry_table)
created = Column(db.DateTime, default=datetime.utcnow, nullable=False)
updated = Column(db.DateTime, default=datetime.utcnow, nullable=False)
deleted = Column(db.DateTime, nullable=True)
source = Column(db.String(50), nullable=False)
def __init__(
self,
name,
description,
url,
start,
end,
duration,
topics,
entry,
category,
source,
):
self.name = name
self.description = description
self.url = url
self.start = start
self.end = end
self.duration = duration
self.topics = topics
self.entry = entry
self.category = category
self.source = source
class UserCoin(db.Model):
__tablename__ = 'user_coins'
id = db.Column(db.BigInteger,primary_key=True)
user_id = db.Column(db.BigInteger,db.ForeignKey('users.id'))
user = db.relationship('User')
coin_id = db.Column(db.BigInteger,db.ForeignKey('coins.id'))
coin = db.relationship('Coin')
payment_id = db.Column(db.BigInteger,db.ForeignKey('payments.id'))
payment = db.relationship('Payment',cascade="all,delete",backref="user_coins")
created = db.Column(db.TIMESTAMP, default=datetime.datetime.now, nullable=False)
updated = db.Column(db.TIMESTAMP, default=datetime.datetime.now, nullable=False, onupdate=datetime.datetime.now)
def __str__(self):
if(self.user):
return " سکه " + self.coin.title +" به قیمت "+ str(self.coin.price) + " به کاربر "+ self.user.username + " اختصاص دارد "
return self.coin.title
class QueryVideoMM(db.Model):
__tablename__ = "query_video_mm"
youtube_query_id = db.Column(db.Integer,
db.ForeignKey('youtube_queries.id'),
primary_key=True)
video_id = db.Column(db.VARCHAR(12),
db.ForeignKey('video.id'),
primary_key=True)
video = db.relationship("YoutubeVideo")
class Companies(db.Model):
__tablename__ = "Companies"
id = db.Column(db.Integer, primary_key=True)
companyName = db.Column(db.String)
user_id = db.relationship("Users", backref="Companies")
def __init__(self, companyName):
self.companyName = companyName
class Outfit(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), index=True, nullable=True)
note = db.Column(db.String(140), nullable=True)
owner_id = db.Column(db.Integer, db.ForeignKey("user.id"))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
outerwear_id = db.Column(db.Integer, db.ForeignKey("clothes.id"))
top_1_id = db.Column(db.Integer, db.ForeignKey("clothes.id"))
top_2_id = db.Column(db.Integer, db.ForeignKey("clothes.id"))
bottom_id = db.Column(db.Integer, db.ForeignKey("clothes.id"))
outerwear = db.relationship("Clothes", foreign_keys="Outfit.outerwear_id")
top_1 = db.relationship("Clothes", foreign_keys="Outfit.top_1_id")
top_2 = db.relationship("Clothes", foreign_keys="Outfit.top_2_id")
bottom = db.relationship("Clothes", foreign_keys="Outfit.bottom_id")
def __repr__(self):
return f"<Outfit {self.name}>"
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(120))
posts = db.relationship('Post', backref='author', lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
class IlluminationSchedules(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
start_time = db.Column(db.DateTime, nullable=False)
end_time = db.Column(db.DateTime, nullable=False)
machine_id = db.Column(db.Integer, db.ForeignKey('machines.id'))
machine = db.relationship("Machines",
back_populates="illumination_schedules")
class Workout(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), index=True)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
exercises = db.relationship('Exercise', backref='workout', cascade="all, delete-orphan", lazy='dynamic')
def __repr__(self):
return '<Workout {}>'.format(self.title)
class Tag(db.Model):
__tablename__ = "tags"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False, unique=True)
groups = db.relationship("Group",
secondary=group_tag_table,
back_populates='tags')
networks = db.relationship("Network",
secondary=network_tag_table,
back_populates='tags')
def __init__(self, tag_name):
self.name = tag_name
def __repr__(self):
return '<tag_name: {}>'.format(self.name)
class Game(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
publisher = db.Column(db.String(50), nullable=False)
director = db.Column(db.String(50), nullable=False)
genres = db.relationship('Genres', backref='game', lazy=True)
def __repr__(self):
return f"Game('{self.id}: {self.name}', '{self.publisher}')"
class IrrigationsHistory(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
irrigation_date = db.Column(db.DateTime, nullable=False)
irrigation_mode = db.Column(db.Integer, nullable=False)
planting_id = db.Column(db.Integer, db.ForeignKey('plantings.id'))
planting = db.relationship("Plantings",
back_populates="irrigations_history")
class Ministry(db.Model):
id = db.Column(db.Integer, primary_key=True)
ministry_id = db.Column(db.String(20), index=True)
name = db.Column(db.String(64), index=True)
password_hash = db.Column(db.String(128))
rides = db.relationship('Ride', backref='ministry', lazy='dynamic')
def __repr__(self):
return '<Ministry> {} {}'.format(self.ministry_id, self.name)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.Text, unique=True, nullable=False)
password = db.Column(db.Text, nullable=False)
lists = db.relationship('List', backref='user', lazy='dynamic')
blacklisted_sites = db.relationship(
'BlacklistedSite',
secondary=blacklisted_site_user_join_table,
backref=db.backref('users'))
def __init__(self, email, password):
self.email = email
self.password = bcrypt.generate_password_hash(password).decode('UTF-8')
def calc_punctuality_percentage(self):
pass
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)
password = db.Column(db.String(60), nullable=False)
Book = db.relationship('Book', backref='user', lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}')"
class Transaction(Base):
__tablename__ = "transaction"
component_id = db.Column(db.Integer,
db.ForeignKey('component.id'),
nullable=False)
component = db.relationship("Component", backref="transactions")
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
notes = db.Column(db.String(40))
qty = db.Column(db.Integer, nullable=False)
class UserAuctionParticipation(db.Model):
__tablename__ = 'user_auction_participations'
id = db.Column(db.BigInteger, primary_key=True)
auction_id = db.Column(db.BigInteger, db.ForeignKey('auctions.id'))
auction = db.relationship('Auction')
user_id = db.Column(db.BigInteger, db.ForeignKey('users.id'))
user = db.relationship('User')
created = db.Column(db.TIMESTAMP,
default=datetime.datetime.now,
nullable=False)
updated = db.Column(db.TIMESTAMP,
default=datetime.datetime.now,
nullable=False,
onupdate=datetime.datetime.now)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, unique=True, nullable=False)
email = db.Column(db.String, unique=True, nullable=False)
password = db.Column(db.String, nullable=False)
tasks = db.relationship('Task', backref='poster')
messages = db.relationship('Message', backref='poster')
role = db.Column(db.String, default='user')
def __init__(self, name, email, password):
self.name = name
self.email = email
self.password = password
def __repr__(self):
return '<User {0}>'.format(self.name)
class GitHubContributions(db.Model, AddUpdateDelete):
__tablename__ = 'githubcontributions'
id = db.Column(db.Integer, primary_key=True)
swag_id = db.Column(db.Integer, db.ForeignKey('swag.id'))
time_logged = db.Column(db.DateTime(timezone=True), unique=False)
github_url = db.Column(db.Text, unique=False)
point_value = db.Column(db.Integer)
swag = db.relationship("Swag")
class CarClass(db.Model):
__tablename__ = 'car_classes'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
game_id = db.Column(db.Integer, db.ForeignKey('games.id'))
# Foreign keys
cars = db.relationship('Car', backref='car_class', lazy='dynamic')
class Music(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(120))
person_id = db.Column(db.Integer, db.ForeignKey("person.id"), nullable=False)
person = db.relationship("Person", backref="musics")
def __init__(self, title, person_id):
self.title = title
self.person_id = person_id
class Follower(db.Model):
"""Provide a follower or following relationship."""
__tablename__ = 'followers'
follower_id = db.Column(
db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'),
primary_key=True
)
followed_id = db.Column(
db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'),
primary_key=True
)
created_at = db.Column(db.DateTime, server_default=utcnow())
updated_at = db.Column(
db.DateTime, server_default=utcnow(), onupdate=utcnow()
)
is_snoozed = db.Column(db.Boolean, server_default='f')
# Snooze timer expiration
expiration = db.Column(db.DateTime)
follower = db.relationship('User', foreign_keys=follower_id)
followed = db.relationship('User', foreign_keys=followed_id)
def __repr__(self):
try:
return '<{} {}, {}>'.format(
self.__class__.__name__,
self.follower.first_name,
self.followed.first_name
)
except AttributeError:
return super().__repr__()
@classmethod
def delete(cls, id_1, id_2):
"""Remove the relationship."""
return cls.query.filter_by(
follower_id=id_1, followed_id=id_2
).delete(synchronize_session=False)
class Company(db.Model):
__tablename__ = "companies"
id = db.Column(db.Integer, autoincrement=True)
uid = db.Column(db.String(), primary_key=True, nullable=False)
company_name = db.Column(db.String(256), nullable=True)
address = db.Column(db.String(), nullable=True)
email_address = db.Column(db.String(), nullable=True)
company_phone = db.Column(db.Integer, nullable=True)
password = db.Column(db.String(), nullable=True)
city = db.Column(db.String(), nullable=True)
state = db.Column(db.String(), nullable=True)
zipcode = db.Column(db.Integer, nullable=True)
structure = db.Column(db.String(), nullable=True)
industry = db.Column(db.String(), nullable=True)
established_date = db.Column(db.Date, nullable=True)
annual_revenue = db.Column(db.Integer, nullable=True)
loan_amount_applied = db.Column(db.Integer, nullable=True)
loan_type = db.Column(db.String(), nullable=True)
loan_reason = db.Column(db.String(), nullable=True)
ein = db.Column(db.Integer, nullable=True)
duns = db.Column(db.Integer, nullable=True)
bank_account = db.Column(db.String, nullable=True)
accounting_account = db.Column(db.String, nullable=True)
loan_approved = db.Column(db.Integer, nullable=True)
ml_inputs = db.relationship("Input",
backref="company_inputs",
cascade="all, delete-orphan",
lazy='dynamic')
gro_scores = db.relationship("Gro_Score",
backref="company_score",
cascade="all, delete-orphan",
lazy='dynamic')
active = db.Column(db.Boolean(), default=True, nullable=False)
admin = db.Column(db.Boolean(), default=False, nullable=False)
created_at = db.Column(db.DateTime, nullable=False)
def __init__(self, company_name, address, city, state, zipcode):
self.company_name = company_name
self.address = address
self.city = city
self.state = state
self.zipcode = zipcode
self.uid = str(uuid.uuid4())
self.created_at = datetime.datetime.utcnow()
class Post(db.Model):
__tablename__ = 'blog_post'
id = db.Column('post_id', db.Integer, primary_key=True)
uuid = db.Column('uuid', db.String(SIZE_UUID), unique=True)
slug = db.Column('slug', db.String(SIZE_TITLE), unique=True, index=True)
description = db.Column('description', db.String(SIZE_META), default='')
keywords = db.Column('keywords', db.String(SIZE_META), default='')
status = db.Column('status', db.SmallInteger, default=POST_STATUS_DRAFT)
added = db.Column('added', db.DateTime)
published = db.Column('published', db.DateTime)
sticked = db.Column('sticked', db.Boolean, default=False)
ping = db.Column('ping', db.Boolean, default=False)
comments_enabled = db.Column('comments_enabled', db.Boolean, default=True)
comments_moderated = db.Column('comments_moderated',
db.Boolean,
default=False)
template = db.Column('template',
db.SmallInteger,
default=POST_TEMPLATE_TEXT)
title = db.Column('title', db.String(SIZE_TITLE), index=True, default='')
teaser = db.Column('teaser', db.Text, default='')
content = db.Column('content', db.Text, default='')
prev = db.Column('prev', db.Text, default='')
tags = db.relationship('Tag',
secondary=tags,
backref=db.backref('posts', lazy='dynamic'))
categories = db.relationship('Category',
secondary=categories,
backref=db.backref('posts', lazy='dynamic'))
user_id = db.Column(db.Integer, db.ForeignKey('users.user_id'))
def __init__(self):
self.uuid = str(uuid4())
self.added = datetime.utcnow()
def __repr__(self):
return '<Post: %s>' % self.title
@staticmethod
def exist(slug):
if Post.query.filter_by(slug=slug).first() is None:
return False
else:
return True
class News(BaseModel, db.Model):
"""新闻"""
__tablename__ = "info_news"
id = db.Column(db.Integer, primary_key=True) # 新闻编号
title = db.Column(db.String(256), nullable=False) # 新闻标题
source = db.Column(db.String(64), nullable=False) # 新闻来源
digest = db.Column(db.String(512), nullable=False) # 新闻摘要
content = db.Column(db.Text, nullable=False) # 新闻内容
clicks = db.Column(db.Integer, default=0) # 浏览量
index_image_url = db.Column(db.String(256)) # 新闻列表图片路径
category_id = db.Column(db.Integer, db.ForeignKey("info_category.id"))
user_id = db.Column(db.Integer, db.ForeignKey("info_user.id")) # 当前新闻的作者id
status = db.Column(db.Integer,
default=0) # 当前新闻状态 如果为0代表审核通过，1代表审核中，-1代表审核不通过
reason = db.Column(db.String(256)) # 未通过原因，status = -1 的时候使用
# 当前新闻的所有评论
comments = db.relationship("Comment", lazy="dynamic")
def to_review_dict(self):
resp_dict = {
"id": self.id,
"title": self.title,
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"status": self.status,
"reason": self.reason if self.reason else ""
}
return resp_dict
def to_basic_dict(self):
resp_dict = {
"id": self.id,
"title": self.title,
"source": self.source,
"digest": self.digest,
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"index_image_url": self.index_image_url,
"clicks": self.clicks,
}
return resp_dict
def to_dict(self):
resp_dict = {
"id": self.id,
"title": self.title,
"source": self.source,
"digest": self.digest,
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"content": self.content,
"comments_count": self.comments.count(),
"clicks": self.clicks,
"category": self.category.to_dict(),
"index_image_url": self.index_image_url,
"author": self.user.to_dict() if self.user else None
}
return resp_dict
