class UserAvatar(db.Model):
__tablename__ = 'user_avatars'
__table_args__ = (db.UniqueConstraint('user_id',
'avatar_id',
name='UC_user_id_avatar_id'), )
id = db.Column(db.BigInteger, primary_key=True)
user_id = db.Column(db.BigInteger, db.ForeignKey('users.id'))
user = db.relationship('User')
avatar_id = db.Column(db.BigInteger, db.ForeignKey('avatars.id'))
avatar = db.relationship('Avatar')
gem_payment_id = db.Column(db.BigInteger, db.ForeignKey('gem_payments.id'))
gem_payment = db.relationship('GemPayment')
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.avatar.title + " به قیمت " + str(
self.avatar.price
) + " به کاربر " + self.user.username + " اختصاص دارد "
return self.avatar.title
class Weather(db.Model):
__tablename__ = 'weathers'
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime, nullable=False)
city = db.Column(db.String(50), nullable=False)
max_temp = db.Column(db.Float)
min_temp = db.Column(db.Float)
wind = db.Column(db.Float)
rain = db.Column(db.Float)
daylight = db.Column(db.Float)
__table_args__ = (db.UniqueConstraint('date', 'city'), )
def __init__(self, **kwargs):
super(Weather, self).__init__(**kwargs)
def to_json(self):
return {
'date': self.date.strftime("%Y/%m/%d"),
'city': self.city,
'max_temp': self.max_temp,
'min_temp': self.min_temp,
'wind': self.wind,
'rain': self.rain,
'daylight': self.daylight
}
class IntelReference(PaginatedAPIMixin, db.Model):
__tablename__ = 'intel_reference'
__table_args__ = (db.UniqueConstraint('intel_source_id', 'reference'), )
id = db.Column(db.Integer, primary_key=True, nullable=False)
user = db.relationship('User')
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
reference = db.Column(db.String(512), index=True, nullable=False)
source = db.relationship('IntelSource')
intel_source_id = db.Column(db.Integer,
db.ForeignKey('intel_source.id'),
nullable=False)
"""
viewonly is set to True on this relationship so that if any indicator exists that uses this
reference, the reference cannot be deleted due to a foreign key constraint.
"""
indicators = db.relationship('Indicator',
secondary=indicator_reference_association,
viewonly=True,
lazy='dynamic')
def __str__(self):
return str('{} : {}'.format(self.source, self.reference))
def to_dict(self):
return {
'id': self.id,
'reference': self.reference,
'source': self.source.value,
'user': self.user.username
}
class Serata(db.Model):
__tablename__ = "serata"
__table_args__ = (db.UniqueConstraint("id",
"data",
name="contraint_serata"), )
id = db.Column(db.Integer(), primary_key=True)
nome = db.Column(db.String(255), nullable=False)
descrizione = db.Column(db.String(255), nullable=False)
data = db.Column(db.DateTime(), nullable=False)
link_partecipazione = db.Column(db.String(255), nullable=True)
link_registrazione = db.Column(db.String(255), nullable=True)
corso_id = db.Column(db.Integer(), db.ForeignKey("corso.id"))
def __init__(self,
nome,
descrizione,
data,
link_partecipazione='',
link_registrazione=''):
self.nome = nome
self.descrizione = descrizione
self.data = data
self.link_partecipazione = link_partecipazione
self.link_registrazione = link_registrazione
def __repr__(self):
return "<Descrizione '{}'. Link registrazione>".format(
self.descrizione, self.link_registrazione)
class Level(db.Model):
__tablename__ = 'levels'
__table_args__ = (db.UniqueConstraint('number', name='levels_number_uc'), )
id = db.Column(db.BigInteger, primary_key=True)
title = db.Column(db.String(length=255), nullable=False)
number = db.Column(db.Integer(), nullable=False)
description = db.Column(db.Text, nullable=False)
required_points = db.Column(db.Integer(), default=0, nullable=False)
offered_gems = db.Column(db.Integer(), default=0, nullable=False)
points_per_win = db.Column(db.Integer(), default=0)
image = db.Column(db.Text, nullable=False)
users = db.relationship("User")
auctions = db.relationship("Auction")
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):
return self.title + " شامل " + str(self.required_points) + " امتیاز "
class S3InputFiles(db.Model):
"""
Model for storing input files, urls, and status
"""
__tablename__ = 's3_input'
file_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer)
filename = db.Column(db.String(128))
url = db.Column(db.String(128), unique=True)
deleted = db.Column(db.Boolean, default=False)
db.UniqueConstraint('user_id', 'filename')
def __init__(self, user_id, filename, url):
self.user_id = user_id
self.filename = filename
self.url = url
class Serata(db.Model):
__tablename__ = "serata"
__table_args__ = (db.UniqueConstraint("id", "data", name="constraint_serata"),)
id = db.Column(db.Integer(), primary_key=True)
nome = db.Column(db.String(255), nullable=False)
descrizione = db.Column(db.String(255), nullable=False)
data = db.Column(db.DateTime(), nullable=False)
link_partecipazione = db.Column(db.String(255), nullable=True)
link_registrazione = db.Column(db.String(255), nullable=True)
corso_id = db.Column(db.Integer(), db.ForeignKey("corso.id"))
def __init__(self, nome, descrizione, data, link_partecipazione='', link_registrazione=''):
self.nome = nome
self.descrizione = descrizione
self.data = data
self.link_partecipazione = link_partecipazione
self.link_registrazione = link_registrazione
def __repr__(self):
return "<Descrizione '{}'. Link registrazione>".format(self.descrizione, self.link_registrazione)
@staticmethod
def insert_test_serate():
lista_serate = [
("Flask 1", "Introduzione a Flask e ai web server con Jinja Base", datetime.datetime(2020, 10, 12, hour=20), '', 'https://www.youtube.com/watch?v=FPI5-oGKiVI&t=759s'),
("Flask 2", "Jinja avanzato e Forms", datetime.datetime(2020, 10, 19, hour=20), '', 'https://www.youtube.com/watch?v=C-iEkd-BpE4'),
("Flask 3", "Flask con Database", datetime.datetime(2020, 10, 26, hour=20), '', 'https://www.youtube.com/watch?v=rCXhuSiOcZU'),
("Flask 4", "Review con Andrea", datetime.datetime(2020, 11, 2, hour=20), '', 'https://www.youtube.com/watch?v=izIKXOrbI5U'),
("Flask 5", "Review con Mario", datetime.datetime(2020, 11, 9, hour=20), '', 'https://vimeo.com/478050019'),
("Flask 6", "Blueprints, refactoring e tests con Mario", datetime.datetime(2020, 11, 16, hour=20), 'https://zoom.us/j/99953652561?pwd=NFpGVzBJazJXOW5MMEQvNFBrVnNLUT09', ''),
]
corso_flask = Corso.query.filter_by(nome="Flask").first()
for serata in lista_serate:
serata_db = Serata.query.filter_by(nome=serata[0]).first()
if serata_db is None:
serata_db = Serata(*serata)
serata_db.corso_id = corso_flask.id
db.session.add(serata_db)
db.session.commit()
class S3ClassifiedFiles(db.Model):
"""
Model for storing classified files, urls, status, and foreign input files
"""
__tablename__ = 's3_classified'
file_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer)
filename = db.Column(db.String(128))
url = db.Column(db.String(128), unique=True)
deleted = db.Column(db.Boolean, default=False)
input_files = db.Column(ARRAY(db.Integer, db.ForeignKey('S3InputFiles.file_id')))
db.UniqueConstraint('user_id', 'filename')
# INPUT FILES IS A LIST OF FILE_ID REFERENCES, FROM S3INPUTFILES TABLE
def __init__(self, user_id, filename, url, input_files):
self.user_id = user_id
self.filename = filename
self.url = url
self.input_files = input_files
class Post(db.Model):
__tablename__ = "posts"
# author_account = db.Column(db.Integer, db.ForeignKey('account.id'), nullable=True)
id = db.Column(db.Integer, primary_key=True)
author = db.Column(db.String, nullable=False)
permlink = db.Column(db.String, nullable=False)
block_number = db.Column(db.Integer, nullable=False)
created = db.Column(db.DateTime, nullable=True)
category = db.Column(db.String, nullable=True,
default='') # todo - force not null, when bug found
tags = db.Column(db.String, nullable=False, default='')
is_nsfw = db.Column(db.Boolean, nullable=False, default=False)
has_declined_payout = db.Column(db.Boolean, nullable=False, default=False)
title = db.Column(db.String, nullable=False, default='')
has_paidout = db.Column(db.Boolean, nullable=False, default=False)
pending_payout_value = db.Column(db.Numeric,
nullable=True) # move to steem_json?
total_payout_value = db.Column(db.Numeric,
nullable=True) # move to steem_json?
steem_json = db.Column(db.JSON, nullable=True)
video_type = db.Column(db.String, nullable=True)
video_id = db.Column(db.String, nullable=True)
video_info = db.Column(
db.JSON, nullable=True) # whether unlisted etc, different scores?
trending_score = db.Column(db.Integer, nullable=True,
default=0) # to define/index later
hot_score = db.Column(db.Integer, nullable=True,
default=0) # to define/index later
other_score = db.Column(db.Integer, nullable=True,
default=0) # to define/index later
steem_thumbnail_image_url = db.Column(db.String, nullable=True)
video_thumbnail_image_url = db.Column(db.String, nullable=True)
video_provider_channel_id = db.Column(db.String, nullable=True)
video_duration_seconds = db.Column(db.Integer, nullable=True)
video_post_publish_delay_seconds = db.Column(db.Integer, nullable=True)
description = db.Column(db.String, nullable=True)
# fields for basic collaborative filter and votes sparkline
voters_list = db.Column(db.String, nullable=True)
voters_list_ts_vector = create_tsvector(
cast(func.coalesce(func.lower(voters_list), ''), postgresql.TEXT))
fts_index_voters_list = db.Index('idx_post_index_voters_fts',
voters_list_ts_vector,
postgresql_using='gin')
votes_sparkline_data = db.Column(db.JSON, nullable=True)
pending_steem_info_update = db.Column(db.Boolean,
nullable=False,
default=True)
pending_video_info_update = db.Column(db.Boolean,
nullable=False,
default=True)
steem_info_update_requested = db.Column(db.DateTime,
nullable=True,
default=datetime.now())
video_info_update_requested = db.Column(db.DateTime,
nullable=True,
default=datetime.now())
# for full text title search
title_ts_vector = create_tsvector(
cast(func.coalesce(func.lower(title), ''), postgresql.TEXT))
fts_index_1 = db.Index('idx_post_title_fts',
title_ts_vector,
postgresql_using='gin')
# for full text description search
description_ts_vector = create_tsvector(
cast(func.coalesce(func.lower(description), ''), postgresql.TEXT))
fts_index_2 = db.Index('idx_post_description_fts',
description_ts_vector,
postgresql_using='gin')
# for full text tags search
tags_ts_vector = create_tsvector(
cast(func.coalesce(func.lower(tags), ''), postgresql.TEXT))
fts_index_3 = db.Index('idx_tags_fts',
tags_ts_vector,
postgresql_using='gin')
u_key = db.UniqueConstraint(author, permlink, name='posts_unique')
index_0 = db.Index('posts_idx_0', author, permlink)
index_1 = db.Index('posts_idx_1', trending_score)
index_2 = db.Index('posts_idx_2', hot_score)
index_4 = db.Index('posts_idx_4', pending_payout_value)
index_9 = db.Index('posts_idx_9', created.desc())
index_11 = db.Index('posts_idx_11',
pending_video_info_update,
video_info_update_requested,
postgresql_where=(pending_video_info_update))
index_12 = db.Index('posts_idx_12',
pending_steem_info_update,
steem_info_update_requested,
postgresql_where=(pending_steem_info_update))
channel_posts = db.relationship("ChannelPost", backref="channelpost_post")
from project import db
from datetime import datetime
# from project.users.models import User
Likes = db.Table(
'likes', db.Column('id', db.Integer, primary_key=True),
db.Column('user_id', db.Integer,
db.ForeignKey('users.id', ondelete="cascade")),
db.Column('message_id', db.Integer,
db.ForeignKey('messages.id', ondelete="cascade")),
db.UniqueConstraint('user_id', 'message_id', name="one_time_like"))
class Message(db.Model):
__tablename__ = 'messages'
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(140))
timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'))
user_likes = db.relationship('User',
secondary=Likes,
backref=db.backref('message_likes'))
def __init__(self, text, user_id, timestamp=datetime.utcnow()):
self.text = text
self.user_id = user_id
self.timestamp = timestamp
class Serata(db.Model):
__tablename__ = "serata"
__table_args__ = (db.UniqueConstraint("id",
"data",
name="constraint_serata"), )
id = db.Column(db.Integer(), primary_key=True)
nome = db.Column(db.String(255), nullable=False)
descrizione = db.Column(db.String(255), nullable=False)
data = db.Column(db.DateTime(), nullable=False)
link_partecipazione = db.Column(db.String(255), nullable=True)
link_registrazione = db.Column(db.String(255), nullable=True)
corso_id = db.Column(db.Integer(), db.ForeignKey("corso.id"))
def __init__(self,
nome,
descrizione,
data,
link_partecipazione="",
link_registrazione=""):
self.nome = nome
self.descrizione = descrizione
self.data = data
self.link_partecipazione = link_partecipazione
self.link_registrazione = link_registrazione
def __repr__(self):
return "<Descrizione '{}'. Link registrazione>".format(
self.descrizione, self.link_registrazione)
# Per la gestione API - Serializing Resources to JSON
def to_json(self):
json_serata = {
"id": self.id,
"nome": self.nome,
"descrizione": self.descrizione,
"data": self.data,
"link_partecipazione": self.link_partecipazione,
"link_registrazione": self.link_registrazione,
}
return json_serata
@staticmethod
def insert_test_serate():
lista_serate = [
(
"Flask 1",
"Introduzione a Flask e ai web server con Jinja Base",
datetime.datetime(2020, 10, 12, hour=20),
"",
"https://youtu.be/QrxCia2bvC8",
),
(
"Flask 2",
"Jinja avanzato e Forms",
datetime.datetime(2020, 10, 19, hour=20),
"",
"https://youtu.be/7v39odgWmS4",
),
(
"Flask 3",
"Flask con Database",
datetime.datetime(2020, 10, 26, hour=20),
"",
"https://youtu.be/t4HoAmFiTqY",
),
(
"Flask 4",
"Review con Andrea",
datetime.datetime(2020, 11, 2, hour=20),
"",
"https://youtu.be/Ap_2Ocp_qdA",
),
(
"Flask 5",
"Review con Mario",
datetime.datetime(2020, 11, 9, hour=20),
"",
"https://youtu.be/-K3L0QkTs_4",
),
(
"Flask 6",
"Blueprints, refactoring e tests con Mario",
datetime.datetime(2020, 11, 16, hour=20),
"https://zoom.us/j/99953652561?pwd=NFpGVzBJazJXOW5MMEQvNFBrVnNLUT09",
"https://youtu.be/LNHedPR4r74",
),
(
"Flask 7",
"Autenticazione con Mario",
datetime.datetime(2020, 11, 23, hour=20),
"https://zoom.us/j/95155339456?pwd=Zk1wcVViazMvdkt0SlhJZENyZ0Iydz09",
"https://youtu.be/bwOsvfnOjVo",
),
(
"Flask 8",
"Profili, ruoli e blog con Mario",
datetime.datetime(2020, 11, 30, hour=20),
"https://zoom.us/j/98250996690?pwd=UzhPUFRHUjJmdy9uWWNKUDBCak5rQT09",
"https://youtu.be/al0kBJQzv7c",
),
(
"Flask 9",
"Config, Heroku e Docker: deploy in produzione con Andrea",
datetime.datetime(2020, 12, 7, hour=20),
"https://zoom.us/j/98193137080?pwd=bWFEVm9obEZNc2Rjb2tqSXhTS0xkQT09",
"https://youtu.be/1Tf8bt_oE7I",
),
(
"Flask 10",
"REST API con Mario",
datetime.datetime(2020, 12, 14, hour=20),
"https://zoom.us/j/95665293446?pwd=QWZIaEJ2VTNtRCszc0ZLcy9FKzJHdz09",
"https://youtu.be/RcNbXuHovXs",
),
]
corso_flask = Corso.query.filter_by(nome="Flask").first()
for serata in lista_serate:
serata_db = Serata.query.filter_by(nome=serata[0]).first()
if serata_db is None:
serata_db = Serata(*serata)
serata_db.corso_id = corso_flask.id
db.session.add(serata_db)
db.session.commit()
class User(db.Model, UserMixin):
def __init__(self, username):
try:
return cls.query.get(uid)
except:
return None
random.seed(time.time())
__tablename__ = 'users'
__table_args__ = (db.UniqueConstraint('username',
name='users_username_uc'), )
__table_args__ = (db.UniqueConstraint('mobile', name='users_mobilr_uc'), )
id = db.Column(db.BigInteger, primary_key=True)
activation_code = db.Column(db.String(length=10),
nullable=False,
default=random.randint(100000, 1000000))
is_verified = db.Column(db.Boolean, nullable=False, default=False)
is_active = db.Column(db.Boolean, nullable=False, default=True)
is_banned = db.Column(db.Boolean, nullable=False, default=False)
verification_attempts = db.Column(db.Integer, nullable=False, default=0)
login_attempts = db.Column(db.Integer, nullable=False, default=0)
send_sms_attempts = db.Column(db.Integer, nullable=False, default=0)
username = db.Column(db.String(length=255), nullable=False)
# alias_name = db.Column(db.String(128), nullable = True)
full_name = db.Column(db.String(length=100))
# first_name = db.Column(db.String(length=100))
# last_name = db.Column(db.String(length=100))
work_place = db.Column(db.String(length=100))
mobile = db.Column(db.String(length=15), nullable=False)
email = db.Column(db.String(length=255))
password = db.Column(db.String(length=100), nullable=False)
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)
invitor = db.Column(db.String(length=255))
points = db.Column(db.Integer(), default=0, nullable=False)
coins = db.Column(db.Integer(), default=0, nullable=False)
gems = db.Column(db.Integer(), default=0, nullable=False)
address_id = db.Column(db.BigInteger, db.ForeignKey('addresses.id'))
address = db.relationship('Address')
avatars = db.relationship('Avatar',
secondary='user_avatars',
back_populates='users',
lazy='dynamic')
plans = db.relationship('UserPlan', lazy='dynamic')
user_gems = db.relationship('UserGem', lazy='dynamic')
payments = db.relationship('Payment')
gem_payments = db.relationship('GemPayment')
messages = db.relationship('UserMessage', lazy='dynamic')
short_messages = db.relationship('UserSMS')
orders = db.relationship('Order')
roles = db.relationship('Role',
secondary='user_roles',
back_populates='users')
coupons = db.relationship('Coupon',
secondary='user_coupons',
back_populates='users',
lazy='dynamic')
level_id = db.Column(db.BigInteger, db.ForeignKey('levels.id'))
level = db.relationship('Level')
avatar_id = db.Column(db.BigInteger, db.ForeignKey('avatars.id'))
avatar = db.relationship('Avatar')
notifications = db.relationship('Notification',
secondary='user_notifications',
back_populates='users',
lazy='dynamic')
auctions = db.relationship('Auction',
lazy='dynamic',
secondary='user_auction_participations',
back_populates='participants')
auction_views = db.relationship('Auction',
secondary='user_auction_views',
back_populates='views')
auction_likes = db.relationship('Auction',
secondary='user_auction_likes',
back_populates='likes',
lazy='dynamic')
def __str__(self):
return self.username
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_mobile(cls, mobile):
return cls.query.filter_by(mobile=mobile).first()
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash):
return sha256.verify(password, hash)
def is_admin(self):
admin = False
for role in self.roles:
if (role.name == 'admin'):
admin = True
return admin
def has_auction(self, id):
try:
return next(a for a in self.auctions if a.id == id)
except Exception as e:
return None
def has_role(self, name):
try:
return next(a for a in self.roles if a.name == name), None
except Exception as e:
return None
def save_to_db(self):
#add default role to created user
role = Role.query.filter_by(name='regular').first()
if (role):
self.roles.append(role)
db.session.add(self)
db.session.commit()
from project import db
from datetime import datetime
favorites = db.Table(
'favorites',
db.Column('users_recipient_id', db.String(18),
db.ForeignKey('users.recipient_id')),
db.Column('songs_track_id', db.String(18),
db.ForeignKey('songs.track_id')),
db.UniqueConstraint('users_recipient_id',
'songs_track_id',
name='UC_user_id_song_id'))
class User(db.Model):
__tablename__ = 'users'
recipient_id = db.Column(db.String(18), primary_key=True)
first_name = db.Column(db.String(64))
last_name = db.Column(db.String(120))
created_at = db.Column(db.DateTime, default=datetime.utcnow)
last_connection = db.Column(db.DateTime, default=datetime.utcnow)
songs_list = db.relationship('Song',
secondary=favorites,
backref=db.backref('songs_list',
lazy='dynamic'))
def __init__(self, recipient_id, first_name, last_name):
self.recipient_id = recipient_id
self.first_name = first_name
self.last_name = last_name
