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