class Empresa(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
razon_social = db.Column(db.String, nullable=False)
class User(Base):
__tablename__ = 'users'
name = db.Column(db.String(128))
email = db.Column(db.String(128), nullable=False, unique=True)
class User(db.Model):
""" User model """
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
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,
username,
email,
password,
created_at=datetime.datetime.utcnow()
):
""" __init__
:param username:
:param email:
:param password:
:param created_at:
"""
self.username = username
self.email = email
self.password = bcrypt.generate_password_hash(
password,
current_app.config.get('BCRYPT_LOG_ROUNDS')
).decode()
self.created_at = created_at
def to_json(self):
return {
'id': self.id,
'username': self.username,
'email': self.email,
'active': self.active,
'admin': self.admin,
'created_at': self.created_at
}
def encode_jwt(self, user_id):
""" Generates the jwt token.
:param user_id:
:return: bytes|error
"""
try:
return jwt.encode(
{
'exp': datetime.datetime.utcnow() + datetime.timedelta(
days=current_app.config.get(
'TOKEN_EXPIRATION_DAYS'
),
seconds=current_app.config.get(
'TOKEN_EXPIRATION_SECONDS'
)
),
'iat': datetime.datetime.utcnow(),
'sub': user_id
},
current_app.config.get('SECRET_KEY'),
algorithm='HS256'
)
except Exception as e:
return e
@staticmethod
def decode_jwt(token):
""" Decodes the jwt token.
:param token:
:return: integer|string
"""
try:
payload = jwt.decode(token, current_app.config.get('SECRET_KEY'))
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Signin again.'
except jwt.InvalidTokenError:
return 'Invalid token. Signin again.'
class SiteModel(db.Model):
"""
Database model
"""
__tablename__ = "sites"
id = db.Column(db.Integer, primary_key=True)
full_link = db.Column(db.String, nullable=False)
short_link = db.Column(db.String, nullable=False)
expired_date = db.Column(db.DateTime, nullable=True)
is_working = db.Column(db.Boolean, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey(
'users.id'), nullable=False)
user = db.relationship(
'User',
backref=db.backref('users', lazy=True))
def __init__(self, full_link, short_link, user_id):
self.full_link = full_link
self.short_link = short_link
self.expired_date = datetime.now() + timedelta(hours=1)
self.is_working = True
self.user_id = user_id
def __repr__(self):
return 'full {}, short{}, expired{}, working{}'.format(
self.full_link,
self.short_link,
self.expired_date.strftime("%Y-%m-%d %H:%M:%S"),
self.is_working
)
def set_date(self, date):
self.expired_date = date
def json(self):
"""
return item as json
"""
if isinstance(self.expired_date, datetime):
return {
'id': self.id,
'full_link': self.full_link,
'short_link': self.short_link,
'expiry_date': self.expired_date.strftime("%Y-%m-%d %H:%M:%S"),
'working': self.is_working
}
else:
return {
'id': self.id,
'full_link': self.full_link,
'short_link': self.short_link,
'expiry_date': None,
'working': self.is_working
}
@classmethod
def find_by_fullLink(cls, site_name):
"""
search if site exists by given site name
"""
return SiteModel.query.filter_by(full_link=site_name).first()
@classmethod
def return_link(cls, shortcut):
"""
return full link by given short code
"""
return SiteModel.query.filter_by(short_link=shortcut).first()
@classmethod
def check_dates(cls):
"""
check if site has expired
"""
for item in SiteModel.query.all():
if datetime.now() > item.expired_date:
item.is_working = False
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def check_duplicate(self, shortcut):
"""
check for duplicates
"""
duplicate = self.return_link(shortcut)
if duplicate is None:
return True
else:
return False
class Vitamin(db.Model):
"""Movment Screening Data"""
__tablename__ = "vitamins"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
shoulder_rotation = db.Column(db.Boolean, nullable=True)
shoulder_flextion = db.Column(db.Boolean, nullable=True)
ankle_mobility = db.Column(db.Boolean, nullable=True)
supine_squat = db.Column(db.Boolean, nullable=True)
leg_raise = db.Column(db.Boolean, nullable=True)
overhead_squat = db.Column(db.Boolean, nullable=True)
arms_extended_squat = db.Column(db.Boolean, nullable=True)
foot_collapse = db.Column(db.Boolean, nullable=True)
def __init__(self, user_id, shoulder_flextion, shoulder_rotation,
ankle_mobility, supine_squat, leg_raise, overhead_squat,
arms_extended_squat, foot_collapse):
self.user_id = user_id
self.shoulder_flextion = shoulder_flextion
self.shoulder_rotation = shoulder_rotation
self.ankle_mobility = ankle_mobility
self.supine_squat = supine_squat
self.leg_raise = leg_raise
self.overhead_squat = overhead_squat
self.arms_extended_squat = arms_extended_squat
self.foot_collapse = foot_collapse
def __repr__(self):
return '<id: {}, user_id: {}>'.format(self.id, self.user_id)
def get_url(self):
return url_for('recipes_api.api1_2_get_recipe',
recipe_id=self.id,
_external=True)
def export_data(self):
return {
'self_url': self.get_url(),
'shoulder_rotation': self.shoulder_rotation,
'shoulder_flextion': self.shoulder_flextion,
'ankle_mobility': self.ankle_mobility,
'supine_squat': self.supine_squat,
'leg_raise': self.leg_raise,
'overhead_squat': self.overhead_squat,
'arms_extended_squat': self.arms_extended_squat,
'foot_collapse': self.foot_collapse,
'user_id': self.user_id
}
def import_data(self, request):
"""Import the data for this users vitamins"""
try:
json_data = request.get_json()
self.shoulder_rotation = json_data['shoulder_rotation']
self.shoulder_flextion = json_data['shoulder_flextion']
self.ankle_mobility = json_data['ankle_mobility']
self.foot_collapse = json_data['foot_collapse']
self.arms_extended_squat = json_data['arms_overhead_squat']
self.overhead_squat = json_data['overhead_squat']
self.leg_raise = json_data['leg_raise']
self.supine_squat = json_data['supine_squat']
except KeyError as e:
raise ValidationError('Invalid recipe: missing ' + e.args[0])
return self
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 Location(db.Model):
__tablename__ = 'locations'
id = db.Column(db.Integer, primary_key=True)
lat = db.Column(db.Float, nullable=False)
lng = db.Column(db.Float, nullable=False)
time = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
class EcaNoise(db.Model):
__tablename__ = "eca_noise"
id = db.Column(db.Integer, primary_key=True)
area_name = db.Column(db.String(100))
max_daytime_limit = db.Column(db.Integer)
max_night_limit = db.Column(db.Integer)
class QhawaxInstallationHistory(db.Model):
__tablename__ = "qhawax_installation_history"
id = db.Column(db.Integer, primary_key=True)
lat = db.Column(db.Float)
lon = db.Column(db.Float)
installation_date_zone = db.Column(db.DateTime, nullable=False)
end_date_zone = db.Column(db.DateTime, nullable=False)
link_report = db.Column(db.String(500), nullable=False, unique=True)
observations = db.Column(db.String(300), nullable=False, unique=True)
qhawax_id = db.Column(db.Integer, db.ForeignKey("qhawax.id"))
district = db.Column(db.String(300), nullable=False, unique=True)
comercial_name = db.Column(db.String(300), nullable=False, unique=True)
address = db.Column(db.String(300), nullable=False, unique=True)
company_id = db.Column(db.Integer, db.ForeignKey("company.id"))
eca_noise_id = db.Column(db.Integer, db.ForeignKey("eca_noise.id"))
connection_type = db.Column(db.String(300), nullable=False, unique=True)
index_type = db.Column(db.String(100), nullable=False, unique=True)
measuring_height = db.Column(db.Integer)
season = db.Column(db.String(300), nullable=False, unique=True)
last_time_physically_turn_on_zone = db.Column(db.DateTime, nullable=False)
person_in_charge = db.Column(db.String(300), nullable=False, unique=True)
is_public = db.Column(db.String(10), nullable=False, unique=True)
last_registration_time_zone = db.Column(db.DateTime, nullable=False)
main_inca = db.Column(db.Float)
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 GasInca(db.Model):
__tablename__ = "gas_inca"
id = db.Column(db.Integer, primary_key=True)
timestamp_zone = db.Column(db.DateTime, nullable=False)
CO = db.Column(db.Float)
CO2 = db.Column(db.Float)
H2S = db.Column(db.Float)
NO = db.Column(db.Float)
NO2 = db.Column(db.Float)
O3 = db.Column(db.Float)
PM1 = db.Column(db.Float)
PM25 = db.Column(db.Float)
PM10 = db.Column(db.Float)
SO2 = db.Column(db.Float)
qhawax_id = db.Column(db.Integer, db.ForeignKey("qhawax.id"))
main_inca = db.Column(db.Float)
class ValidProcessedMeasurement(db.Model):
__tablename__ = "valid_processed_measurement"
id = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.DateTime, nullable=False)
timestamp_zone = db.Column(db.DateTime, nullable=False)
CO = db.Column(db.Float)
CO_ug_m3 = db.Column(db.Float)
CO2 = db.Column(db.Float)
H2S = db.Column(db.Float)
H2S_ug_m3 = db.Column(db.Float)
NO = db.Column(db.Float)
NO2 = db.Column(db.Float)
NO2_ug_m3 = db.Column(db.Float)
O3 = db.Column(db.Float)
O3_ug_m3 = db.Column(db.Float)
PM1 = db.Column(db.Float)
PM25 = db.Column(db.Float)
PM10 = db.Column(db.Float)
SO2 = db.Column(db.Float)
SO2_ug_m3 = db.Column(db.Float)
VOC = db.Column(db.Float)
UV = db.Column(db.Float)
UVA = db.Column(db.Float)
UVB = db.Column(db.Float)
SPL = db.Column(db.Float)
humidity = db.Column(db.Float)
pressure = db.Column(db.Float)
temperature = db.Column(db.Float)
lat = db.Column(db.Float)
lon = db.Column(db.Float)
alt = db.Column(db.Float)
I_temperature = db.Column(db.Float)
qhawax_installation_id = db.Column(
db.Integer, db.ForeignKey("qhawax_installation_history.id"))
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',
'https://vimeo.com/480155611'),
("Flask 7", "Autenticazione con Mario",
datetime.datetime(2020, 11, 23, hour=20), '', ''),
]
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()
from project import db, bcrypt
from flask_login import UserMixin
from project.preferences.models import Preference
UserPreference = db.Table(
'user_preferences', db.Column('id', db.Integer, primary_key=True),
db.Column('user_id', db.Integer,
db.ForeignKey('users.id', ondelete='cascade')),
db.Column('preference_id', db.Integer,
db.ForeignKey('preferences.id', ondelete='cascade')))
UserPodcast = db.Table(
'user_podcasts', db.Column('id', db.Integer, primary_key=True),
db.Column('user_id', db.Integer,
db.ForeignKey('users.id', ondelete='cascade')),
db.Column('podcast_id', db.Integer,
db.ForeignKey('podcasts.id', ondelete='cascade')))
LikedPodcasts = db.Table(
'liked_podcasts', db.Column('id', db.Integer, primary_key=True),
db.Column('id_of_user_who_liked_podcast', db.Integer,
db.ForeignKey('users.id', ondelete='cascade')),
db.Column('id_of_podcast_liked', db.Integer,
db.ForeignKey('podcasts.id', ondelete='cascade')))
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.Text, unique=True)
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")
class AirQualityMeasurement(db.Model):
__tablename__ = "air_quality_measurement"
id = db.Column(db.Integer, primary_key=True)
timestamp_zone = db.Column(db.DateTime, nullable=False)
CO = db.Column(db.Float)
CO_ug_m3 = db.Column(db.Float)
H2S = db.Column(db.Float)
H2S_ug_m3 = db.Column(db.Float)
NO2 = db.Column(db.Float)
NO2_ug_m3 = db.Column(db.Float)
O3 = db.Column(db.Float)
O3_ug_m3 = db.Column(db.Float)
PM25 = db.Column(db.Float)
PM10 = db.Column(db.Float)
SO2 = db.Column(db.Float)
SO2_ug_m3 = db.Column(db.Float)
uv = db.Column(db.Float)
uva = db.Column(db.Float)
uvb = db.Column(db.Float)
spl = db.Column(db.Float)
humidity = db.Column(db.Float)
pressure = db.Column(db.Float)
temperature = db.Column(db.Float)
lat = db.Column(db.Float)
lon = db.Column(db.Float)
alt = db.Column(db.Float)
I_temperature = db.Column(db.Float)
qhawax_id = db.Column(db.Integer, db.ForeignKey("qhawax.id"))
from uuid import uuid4
from datetime import datetime
from project import db
from .config import SIZE_NAME, SIZE_UUID, SIZE_TITLE, SIZE_META
from .config import POST_STATUS_DRAFT, POST_STATUS_PUBLISHED, POST_TEMPLATE_TEXT
tags = db.Table(
'blog_tags',
db.Column('tag_id', db.Integer, db.ForeignKey('blog_tag.tag_id')),
db.Column('post_id', db.Integer, db.ForeignKey('blog_post.post_id')))
categories = db.Table(
'blog_categories',
db.Column('category_id', db.Integer,
db.ForeignKey('blog_category.category_id')),
db.Column('post_id', db.Integer, db.ForeignKey('blog_post.post_id')))
class Tag(db.Model):
__tablename__ = 'blog_tag'
id = db.Column('tag_id', db.Integer, primary_key=True)
uuid = db.Column('uuid', db.String(SIZE_UUID), unique=True)
slug = db.Column('slug', db.String(SIZE_NAME), unique=True, index=True)
name = db.Column('name', db.String(SIZE_NAME), index=True)
added = db.Column('added', db.DateTime)
deleted = db.Column('deleted', db.Boolean, default=False)
def __init__(self, slug, name):
self.uuid = str(uuid4())
self.slug = slug
self.name = name
class Payment(db.Model):
__tablename__ = 'payments'
id = db.Column(db.Integer, primary_key=True)
GUID = db.Column(db.String(128),
default=random.randint(100000000000, 10000000000000000))
reference_id = db.Column(db.String(255),
default=random.randint(100000000000,
10000000000000000))
amount = db.Column(db.DECIMAL(precision=20, scale=4), nullable=False)
discount = db.Column(db.DECIMAL(precision=20, scale=4), nullable=False)
type = db.Column(db.String(64), default=PaymentType.NOTITLE)
status = db.Column(db.String(64), default=PaymentStatus.UNPAID)
sequence = db.Column(db.String(255),
nullable=False,
default=PaymentStatus.UNPAID)
details = db.Column(db.Text)
# payment_method_id = db.Column(db.BigInteger,db.ForeignKey('payment_methods.id'),nullable=False)
# payment_method = db.relationship('PaymentMethod')
# orders = db.relationship('Order' , secondary = 'payment_orders', back_populates='payments')
# sale_order_id = db.Column(db.String(255))
# sale_refrence_id = db.Column(db.String(255))
user_id = db.Column(db.BigInteger, db.ForeignKey('users.id'))
user = db.relationship('User')
# shipment = db.relationship('Shipment')
messages = db.relationship('PaymentMessage',
secondary='payment_message_payments',
back_populates='payments')
created = db.Column(db.TIMESTAMP, default=datetime.now, nullable=False)
updated = db.Column(db.TIMESTAMP,
default=datetime.now,
nullable=False,
onupdate=datetime.now)
def __str__(self):
return " پرداخت به کد رهگیری : " + str(
self.GUID) + " باوضعیت :" + str(
self.status) + " در تاریخ : " + str(self.created)
def __init__(self):
random.seed(datetime.now())
self.GUID = random.randint(100000000000, 10000000000000000)
self.reference_id = random.randint(10000000000, 100000000000000000)
class Allergy(db.Model):
"""Allergy model"""
__tablename__ = 'tbl_allergy'
id = db.Column(db.Integer, primary_key=True, unique=True)
uid = db.Column(db.String)
meta_tag_id = db.Column(db.Integer)
class Device(db.Model):
__tablename__ = "Device"
device_id = db.Column(db.Integer, autoincrement=True, primary_key=True)
name = db.Column(db.String(255), default="")
from project import db
import datetime
user_gifts = db.Table('chest_avatars', db.Model.metadata,
db.Column('chest_id', db.ForeignKey('chests.id')),
db.Column('avatar_id', db.ForeignKey('avatars.id')))
class User(db.Model):
"""Model for a user."""
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
admin = db.Column(db.Boolean(), default=False, nullable=False)
def __init__(self, username, email, password):
"""Initialize object."""
self.username = username
self.email = email
self.password = bcrypt.generate_password_hash(
password, current_app.config.get('BCRYPT_LOG_ROUNDS')).decode()
def to_json(self):
"""Return object as json."""
return {
'id': self.id,
'username': self.username,
'email': self.email,
'active': self.active,
'admin': self.admin
}
def encode_auth_token(self, user_id):
"""Generate the auth token."""
try:
payload = {
'exp':
datetime.datetime.utcnow() + datetime.timedelta(
days=current_app.config.get('TOKEN_EXPIRATION_DAYS'),
seconds=current_app.config.get(
'TOKEN_EXPIRATION_SECONDS')),
'iat':
datetime.datetime.utcnow(),
'sub':
user_id
}
return jwt.encode(payload,
current_app.config.get('SECRET_KEY'),
algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
"""
Decode an authentication token and return user ID.
:param auth_token: - :return: integer|string
"""
try:
payload = jwt.decode(auth_token,
current_app.config.get('SECRET_KEY'))
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
phone = db.Column(db.String(128), nullable=True)
username = db.Column(
db.String(128),
nullable=False,
unique=True,
)
password = db.Column(db.String(128), nullable=False)
address = db.Column(db.String(128), nullable=True)
register_on = db.Column(db.DateTime, nullable=True)
is_confirmed = db.Column(db.Boolean, nullable=True, default=False)
role = db.Column(db.String, default='user')
authenticated = db.Column(db.Boolean, default=False)
def __init__(self, username, password, role='user'):
self.username = username
self.password = password
self.phone = None
self.address = None
self.register_on = datetime.datetime.now()
self.is_confirmed = False
self.role = role
self.authenticated = False
@property
def is_authenticated(self):
"""Return True if the user is authenticated."""
return self.authenticated
@property
def is_active(self):
"""Always True, as all users are active."""
return True
def get_id(self):
"""Return the email address to satisfy Flask-Login's requirements."""
"""Requires use of Python 3"""
return str(self.id)
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash):
return sha256.verify(password, hash)
def __repr__(self):
return '<title {}'.format(self.username)
def to_json(self):
return {
'id': self.id,
'username': self.username,
'password': self.password
}
class Account(db.Model):
__tablename__ = "accounts"
owner = db.Column(db.String, primary_key=True)
password = db.Column(db.String, nullable=False)
channels = db.relationship("Channel", backref="channel_account")
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String, unique=True, nullable=False)
_password = db.Column(db.Binary(60), nullable=False)
authenticated = db.Column(db.Boolean, default=False)
email_confirmation_sent_on = db.Column(db.DateTime, nullable=True)
email_confirmed = db.Column(db.Boolean, nullable=True, default=False)
email_confirmed_on = db.Column(db.DateTime, nullable=True)
registered_on = db.Column(db.DateTime, nullable=True)
last_logged_in = db.Column(db.DateTime, nullable=True)
current_logged_in = db.Column(db.DateTime, nullable=True)
role = db.Column(db.String, default='user')
screen_data = db.relationship('vitamins', backref='user', lazy='dynamic')
def __init__(self,
email,
plaintext_password,
email_confirmation_sent_on=None,
role='user'):
self.email = email
self.password = plaintext_password
self.authenticated = False
self.email_confirmation_sent_on = email_confirmation_sent_on
self.email_confirmed = False
self.email_confirmed_on = None
self.registered_on = datetime.now()
self.last_logged_in = None
self.current_logged_in = datetime.now()
self.role = role
@hybrid_property
def password(self):
return self._password
@password.setter
def set_password(self, plaintext_password):
self._password = bcrypt.generate_password_hash(plaintext_password)
@hybrid_method
def is_correct_password(self, plaintext_password):
return bcrypt.check_password_hash(self.password, plaintext_password)
@property
def is_authenticated(self):
"""Return True if the user is authenticated."""
return self.authenticated
@property
def is_active(self):
"""Always True, as all users are active."""
return True
@property
def is_anonymous(self):
"""Always False, as anonymous users aren't supported."""
return False
def get_id(self):
"""Return the email address to satisfy Flask-Login's requirements."""
"""Requires use of Python 3"""
return str(self.id)
def generate_auth_token(self, expires_in=3600):
s = Serializer(app.config['SECRET_KEY'], expires_in=expires_in)
return s.dumps({'id': self.id}).decode('utf-8')
@staticmethod
def verify_auth_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return None
return User.query.get(data['id'])
def __repr__(self):
return '<User {}>'.format(self.email)
class ChannelPost(db.Model):
__tablename__ = "channel_posts"
id = db.Column(db.Integer, primary_key=True)
channel_id = db.Column(db.Integer, db.ForeignKey('channels.id'))
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'))
default_position = db.Column(db.Integer, nullable=True)
class Subscribers(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(200), unique=True, nullable=False)
def __repr__(self):
return format("Subscriber(" + str(self.id) + "," + self.email + ")")
class SteemAccount(db.Model):
__tablename__ = "steem_accounts"
author = db.Column(db.String, primary_key=True)
info = db.Column(db.JSON, nullable=True)
class Address(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
location = db.Column(db.String(255), nullable=False)
note = db.Column(db.String(255), nullable=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class Usuario(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
nombre = db.Column(db.String, nullable=False)
password = db.Column(db.String, nullable=False)
correo = db.Column(db.String, nullable=False)
fecha = db.Column(db.String, nullable=False)
sistema_o = db.Column(db.String, nullable=True)
procesador = db.Column(db.String, nullable=True)
almacenamiento = db.Column(db.String, nullable=True)
ram = db.Column(db.String, nullable=True)
grafica = db.Column(db.String, nullable=True)
direct_x = db.Column(db.String, nullable=True)
gusto = db.Column(db.String, nullable=True)
confirmation = db.Column(db.String, nullable=False)
age = db.Column(db.String, nullable=False)
def __init__(self, **kwargs):
super(Usuario, self).__init__(**kwargs)
self.password = self.generate_password_hash(**kwargs)
def generate_password_hash(self, **kwargs):
if 'password' in kwargs:
return bcrypt.generate_password_hash(kwargs['password']).decode()
return None
