class Community(SAFRSBase, db.Model):
'''
description: a community of SocialNetwork
'''
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(30), unique=True, nullable=False)
type = db.Column(db.String(30), nullable=False)
rating = db.Column(db.Integer, nullable=False, default=0)
creation_date = db.Column(db.DateTime,
nullable=False,
server_default=db.func.now())
banned_table = db.Table(
'banned_users', db.metadata,
db.Column('com_id',
db.Integer,
db.ForeignKey('community.id', ondelete='CASCADE'),
primary_key=True),
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
primary_key=True))
banned_users = db.relationship(
User,
secondary=banned_table,
passive_deletes=True,
backref=db.backref("banned_com", passive_deletes=True),
primaryjoin=banned_table.c.com_id == id,
secondaryjoin=banned_table.c.user_id == User.id)
subscribe_table = db.Table(
'subscribeUsers', db.metadata,
db.Column('com_id',
db.Integer,
db.ForeignKey(id, ondelete='CASCADE'),
primary_key=True),
db.Column('user_id',
db.Integer,
db.ForeignKey(User.id, ondelete='CASCADE'),
primary_key=True))
subscribe_user = db.relationship(
User,
secondary=subscribe_table,
passive_deletes=True,
backref=db.backref("user_subscribe", passive_deletes=True),
primaryjoin=subscribe_table.c.com_id == id,
secondaryjoin=subscribe_table.c.user_id == User.id)
moderators_users = db.relationship(
User,
secondary='moderator',
passive_deletes=True,
primaryjoin=Moderator.com_id == id,
secondaryjoin=Moderator.mod_id == User.id,
backref=db.backref("users_moderators", passive_deletes=True))
from config import db
from sqlalchemy.sql import func, desc
user_likes = db.Table("user_likes",
db.Column("user_like", db.Integer, db.ForeignKey("users.user_id"), primary_key = True),
db.Column("idea_liked", db.Integer, db.ForeignKey("ideas.idea_id"), primary_key = True)
)
friends_table = db.Table("friends",
db.Column("friender_id", db.Integer, db.ForeignKey("users.user_id"), primary_key=True),
db.Column("friendee_id", db.Integer, db.ForeignKey("users.user_id"), primary_key=True)
)
block_list = db.Table("blocked",
db.Column("blocker_id", db.Integer, db.ForeignKey("users.user_id"), primary_key=True),
db.Column("blockee_id", db.Integer, db.ForeignKey("users.user_id"), primary_key=True)
)
class User(db.Model):
__tablename__ = "users"
user_id = db.Column(db.Integer, primary_key = True)
f_name = db.Column(db.String(45))
l_name = db.Column(db.String(45))
email = db.Column(db.String(45))
password = db.Column(db.String(255))
admin_status = db.Column(db.Integer)
profile = db.Column(db.String(1600))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime, server_default=func.now(), onupdate=func.now())
liked_idea = db.relationship("Idea", secondary = "user_likes")
friends=db.relationship("User",
from sqlalchemy.sql import func
from config import app, db
books_authors = db.Table(
'books_authors',
db.Column('author_id',
db.Integer,
db.ForeignKey('authors.id'),
primary_key=True),
db.Column('book_id',
db.Integer,
db.ForeignKey('books.id'),
primary_key=True))
from flask import flash, session
from config import db, bcrypt, EMAIL_REGEX, PASS_REGEX
from sqlalchemy.sql import func
likes_table = db.Table(
'likes',
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True),
db.Column('tweet_id',
db.Integer,
db.ForeignKey('tweet.id', ondelete='cascade'),
primary_key=True),
db.Column('created_at', db.DateTime, server_default=func.now()),
db.Column('updated_at',
db.DateTime,
server_default=func.now(),
onupdate=func.now()))
follows_table = db.Table(
'follows',
db.Column('follower_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True),
db.Column('followed_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True),
db.Column('created_at', db.DateTime, server_default=func.now()),
from sqlalchemy.sql import func, desc
from config import db
likes_table = db.Table(
'likes',
db.Column('user_id',
db.Integer,
db.ForeignKey('users.id'),
primary_key=True),
db.Column('quote_id',
db.Integer,
db.ForeignKey('quotes.id'),
primary_key=True))
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255))
password = db.Column(db.String(255))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
quotes_this_user_likes = db.relationship('Quote', secondary=likes_table)
class Quote(db.Model):
__tablename__ = "quotes"
from sqlalchemy import true
from werkzeug.security import generate_password_hash, check_password_hash
from flask_login import UserMixin
from datetime import datetime
from marshmallow_sqlalchemy import fields
from config import db, ma, login
userSortie_a_venir = db.Table(
'userSortie_a_venir',
db.Column('id_user',
db.Integer,
db.ForeignKey('users.id'),
primary_key=True),
db.Column('id_sortie',
db.Integer,
db.ForeignKey('sorties.id_sortie'),
primary_key=True))
userSortie_finies = db.Table(
'userSortie_finies',
db.Column('id_user',
db.Integer,
db.ForeignKey('users.id'),
primary_key=True),
db.Column('id_sortie',
db.Integer,
db.ForeignKey('sorties.id_sortie'),
primary_key=True))
from datetime import datetime
from config import db, ma
import arrow
# association table
ta_assignment = db.Table(
"assistants",
# ForeignKey constraints that column to only allow values that are present in
# the corresponding table (almost always the primary key for their owning table)
db.Column("employee_id", db.Integer, db.ForeignKey("employee.id")),
db.Column("workshop_id", db.Integer, db.ForeignKey("workshop.id")),
)
class Employee(db.Model):
__tablename__ = "employee"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), db.ForeignKey("user.email"))
name = db.Column(db.String(64), unique=True)
join_date = db.Column(db.Date)
active = db.Column(db.Boolean, default=True, nullable=False)
degree = db.Column(db.String(32))
university = db.Column(db.String(64))
assigned_ta = db.relationship(
"Workshop",
secondary=ta_assignment,
backref=db.backref("assistants", lazy="dynamic"),
)
assigned_instructor = db.relationship("Workshop", backref=db.backref("instructor"))
def __repr__(self):
import sys
sys.path.append('..')
from config import db, ma
ingredient_table = db.Table(
'ingredients', db.Column('dish_id', db.Integer, db.ForeignKey('dish.id')),
db.Column('ingredient_id', db.Integer, db.ForeignKey('ingredient.id')))
class Ingredient(db.Model):
__tablename__ = 'ingredient'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), primary_key=True)
class Dish(db.Model):
__tablename__ = 'dish'
id = db.Column(db.Integer, primary_key=True)
restaurant_id = db.Column(db.Integer,
db.ForeignKey('restaurant.id'),
nullable=True)
ingredients = db.relationship('Ingredient',
secondary=ingredient_table,
backref='dishes')
description = db.Column(db.Text())
class DishSchema(ma.Schema):
class Meta:
model = Dish
from config import db
# This table is tested and working.
# Many to Many / User and KART and Item
users_cart_items = db.Table('users_cart_items',
db.Column('user_id', db.Integer,
db.ForeignKey('users.id'),
primary_key=True),
db.Column('item_id', db.Integer,
db.ForeignKey('items.id'),
primary_key=True))
import datetime
from config import Base, db
from werkzeug.security import generate_password_hash
contribs = db.Table('contribs',
db.Column('user_id', db.Integer, db.ForeignKey('user.id'), primary_key=True),
db.Column('note_id', db.Integer, db.ForeignKey('note.id'), primary_key=True)
)
class User(Base):
id = db.Column(db.INTEGER, primary_key=True)
username = db.Column(db.VARCHAR(20), nullable=False)
password = db.Column(db.VARCHAR(128), nullable=False)
def __init__(self, username, password):
self.username = username
self.password = generate_password_hash(password)
def __str__(self):
return f"<User: {self.username}>"
class Tag(Base):
id = db.Column(db.INTEGER, primary_key=True)
name = db.Column(db.VARCHAR(20), nullable=False)
def __str__(self):
return f"<Tag: {self.name}>"
from sqlalchemy.sql import func
from sqlalchemy import Table, Column, Integer, String, ForeignKey, DateTime
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base
from config import db
Base = declarative_base()
orders_products_table = db.Table(
'orders_products',
db.Column('order_id',
db.Integer,
db.ForeignKey('orders.id'),
primary_key=True),
db.Column('product_id',
db.Integer,
db.ForeignKey('products.id'),
primary_key=True))
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
f_name = db.Column(String(45))
l_name = db.Column(String(45))
email = db.Column(String(45))
pw = db.Column(String(45))
created_at = db.Column(DateTime, server_default=func.now())
updated_at = db.Column(DateTime,
server_default=func.now(),
onupdate=func.now())
from sqlalchemy.sql import func, and_, or_
from sqlalchemy.ext.automap import automap_base
def rankDefault(context):
return context.get_current_parameters()['picture_id']
album_has_pictures = db.Table(
'album_has_pictures',
db.Column('picture_id',
db.Integer,
db.ForeignKey('pictures.id', ondelete="cascade"),
primary_key=True),
db.Column('album_id',
db.Integer,
db.ForeignKey('albums.id', ondelete="cascade"),
primary_key=True),
db.Column('created_at', db.DateTime, server_default=func.now()),
db.Column('updated_at',
db.DateTime,
server_default=func.now(),
onupdate=func.now()),
db.Column('rank', db.Integer, default=rankDefault))
# To directly query album_has_pictures like this (returns a list of tuples [(1,),(2,)...(10,)]):
# q=db.session.query(album_has_pictures.columns.rank).filter(album_has_pictures.columns.album_id==2).all()
class Album_to_Pic:
# This class is a workaround to access the extra data in the album_has_pictures many to many Table.
# This was not the best solution to this. See the section on Association Object:
# https://docs.sqlalchemy.org/en/latest/orm/basic_relationships.html#relationships-many-to-many
from sqlalchemy.sql import func
from config import db, bcrypt
import re
from flask import session
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
add_jobs = db.Table(
'add_job',
db.Column('user_id',
db.Integer,
db.ForeignKey('users.id'),
primary_key=True),
db.Column('job_id', db.Integer, db.ForeignKey('jobs.id'),
primary_key=True),
db.Column('created_at', db.DateTime, server_default=func.now()))
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255), nullable=False)
last_name = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(255), nullable=False)
pw_hash = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
jobs_user_add = db.relationship('Job', secondary=add_jobs)
from marshmallow import fields, Schema
from config import db
from .items import ItemSchema
payment_items = db.Table(
'payment_items',
db.Column('item_id',
db.Integer,
db.ForeignKey('item.id'),
primary_key=True),
db.Column('payment_id',
db.Integer,
db.ForeignKey('payment.id'),
primary_key=True))
class Payment(db.Model):
id = db.Column(db.Integer, primary_key=True)
count_items = db.Column(db.Integer, nullable=False)
total_value = db.Column(db.Numeric(precision=8, scale=2), nullable=False)
items = db.relationship('Item',
secondary=payment_items,
lazy='subquery',
backref=db.backref('payments', lazy=True))
class PaymentSchema(Schema):
id = fields.Int(required=False, allow_none=False, allow_empty=False)
return age
class Follow(db.Model):
__tablename__ = "follows"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
user1 = db.relationship("User", backref="likes", cascade="all")
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
user2 = db.relationship("User", backref="likes", cascade="all")
created_at = db.Column(db.DateTime, server_default=func.now())
likes_table = db.Table(
'likes', db.Column('tweet_id',
db.ForeignKey('tweets.id'),
primary_key=True),
db.Column('user_id', db.ForeignKey('users.id'), primary_key=True))
db.Column('created_at', db.DateTime, server_default=func.now())
followers_table = db.Table(
'followers',
db.Column("follower_id",
db.Integer,
db.ForeignKey("users.id"),
primary_key=True),
db.Column("followed_id",
db.Integer,
db.ForeignKey("users.id"),
primary_key=True),
db.Column("created_at", db.DateTime, server_default=func.now()))
from config import db
# This table is tested and working.
# Many to Many / User and KART and Item
users_ideas = db.Table('users_ideas',
db.Column('user_id', db.Integer,
db.ForeignKey('users.id'),
primary_key=True),
db.Column('idea_id', db.Integer,
db.ForeignKey('ideas.id'),
primary_key=True))
from config import db
journey_version_role = db.Table('journey_version_role',
db.Column('journey_version_id', db.Integer, db.ForeignKey('journey_version.journey_version_id'), nullable=False),
db.Column('role_id', db.Integer, db.ForeignKey('role.role_id'), nullable=False),
db.PrimaryKeyConstraint('journey_version_id', 'role_id')
)
from config import db
subs = db.Table('subs',
db.Column('group_id', db.Integer, db.ForeignKey('group.id')),
db.Column('user_id', db.Integer, db.ForeignKey('user.id')))
fav_shops = db.Table(
'fav_shops',
db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('shop_id', db.Integer, db.ForeignKey('shop.id')),
)
sub_requests = db.Table(
'sub_requests', db.Column('group_id', db.Integer,
db.ForeignKey('group.id')),
db.Column('user_id', db.Integer, db.ForeignKey('user.id')))
class Post(db.Model):
group_id = db.Column(db.Integer,
db.ForeignKey('group.id'),
primary_key=True)
sender_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
primary_key=True)
date = db.Column(db.String(16),
primary_key=True) # Format 'dd/mm/yyyy-hh:mm'
content = db.Column(db.String(280))
user = db.relationship('User')
from flask import flash
from sqlalchemy.sql import func
from config import db
import re
name_REGEX = re.compile(r'^[a-zA-Z0-9]+$')
email_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
message_REGEX = re.compile(r'^[a-zA-Z][a-zA-Z0-9\s.]+$')
users_events = db.Table(
'users_events',
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True),
db.Column('event_id',
db.Integer,
db.ForeignKey('event.id'),
primary_key=True))
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(45))
last_name = db.Column(db.String(45))
email = db.Column(db.String(90))
password = db.Column(db.String(255))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
from flask import session, flash
from datetime import datetime
from config import db, bcrypt
from sqlalchemy.sql import func, or_
import re
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
user_instruments = db.Table(
'user_instruments',
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id', ondelete='cascade'),
primary_key=True),
db.Column('instrument_id',
db.Integer,
db.ForeignKey('instrument.id', ondelete='cascade'),
primary_key=True),
)
attendance = db.Table(
'attendance',
db.Column('attendee',
db.Integer,
db.ForeignKey('user.id', ondelete='cascade'),
primary_key=True),
db.Column('session_id',
db.Integer,
db.ForeignKey('jam_session.id', ondelete='cascade'),
primary_key=True))
from config import db
role_permission = db.Table(
'role_permission',
db.Column('role_id',
db.Integer,
db.ForeignKey('role.role_id'),
nullable=False),
db.Column('permission_id',
db.Integer,
db.ForeignKey('permission.permission_id'),
nullable=False),
db.PrimaryKeyConstraint('role_id', 'permission_id'))
from sqlalchemy.sql import func
from config import db, bcrypt, ma
players_table = db.Table(
'players',
db.Column('player_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True,
nullable=False),
db.Column('campaign_id',
db.Integer,
db.ForeignKey('campaign.id'),
primary_key=True,
nullable=False),
db.Column('created_at',
db.DateTime,
nullable=False,
server_default=func.now()),
db.Column('updated_at',
db.DateTime,
nullable=False,
server_default=func.now(),
onupdate=func.now()))
class Message(db.Model):
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
from config import db,app
class GenericModel(db.Model):
__abstract__ = True
created = db.Column(db.DateTime, default=db.func.current_timestamp())
updated = db.Column(db.DateTime, default=db.func.current_timestamp(),onupdate=db.func.current_timestamp())
active = db.Column('active', db.String(10),default='Yes')
menu_hotel = db.Table('menu_hotel',
db.Column('menu_id',db.ForeignKey('menu.menu_id'),unique=False),
db.Column('hotel_id',db.ForeignKey('hotel.hotel_id'),unique=False)
)
#Menu(id=991,name='XXXXX',price=394.45,hotelid=12)
class Menu(GenericModel):
id = db.Column('menu_id', db.Integer(), primary_key=True)
name = db.Column('menu_name', db.String(40),)
price = db.Column('menu_price', db.Float(),default=350.0)
href = db.relationship('Hotel',secondary=menu_hotel, backref=db.backref("menuref", lazy=True))
@staticmethod
def dummy_menu():
return Menu(id=0, name='', price=0.0)
room_hotel = db.Table('room_hotel',
db.Column('room_id',db.ForeignKey('room.room_id')),
db.Column('hotel_id',db.ForeignKey('hotel.hotel_id'))
)
#Hotel(id=1111,name='Sayaji',address='Pune,wakad',contact='020-12234453',website='www.sayaji.com')
class Hotel(GenericModel):
id = db.Column('hotel_id',db.Integer(),primary_key=True)
from sqlalchemy.sql import func
from config import db
likes_table = db.Table(
'likes',
db.Column('quote_id',
db.Integer,
db.ForeignKey('quotes.id', ondelete="cascade"),
primary_key=True),
db.Column('user_id',
db.Integer,
db.ForeignKey('users.id'),
primary_key=True),
db.Column('created_at', db.DateTime, server_default=func.now()))
from config import db, bcrypt
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy import func
import re
from flask import session
import os.path
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
tagged_table = db.Table(
'tagged',
db.Column('photo_id',
db.Integer,
db.ForeignKey('photos.id'),
primary_key=True),
db.Column('tag_id', db.Integer, db.ForeignKey('tags.id'),
primary_key=True))
class Users(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(45))
last_name = db.Column(db.String(45))
email = db.Column(db.String(45))
password = db.Column(db.String(45))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
def __repr__(self):
from flask import request, flash
from config import db, func, app
from flask_bcrypt import Bcrypt
import re
app.secret_key = 'secret'
bcrypt = Bcrypt(app)
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
PASSWORD_REGEX = re.compile(r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!#%*?&]{5,}$')
SpecialSym =['$', '@', '#', '%']
expenses = db.Table('expenses',
db.Column('id', db.Integer, primary_key=True),
db.Column('todo_id', db.Integer, default=0),
db.Column('user_id', db.Integer, db.ForeignKey('users.id', ondelete='cascade', onupdate='cascade')),
db.Column('category_id', db.Integer, db.ForeignKey('categories.id', ondelete='cascade', onupdate='cascade')),
db.Column('amount', db.Float),
db.Column('content', db.String),
db.Column('created_at', db.DateTime, server_default=func.now()),
db.Column('updated_at', db.DateTime, server_default=func.now(), onupdate=func.now()))
todos = db.Table('todos',
db.Column('id', db.Integer, primary_key=True),
db.Column('user_id', db.Integer, db.ForeignKey('users.id', ondelete='cascade', onupdate='cascade')),
db.Column('category_id', db.Integer, db.ForeignKey('categories.id', ondelete='cascade', onupdate='cascade')),
db.Column('amount', db.Float),
db.Column('content', db.String(255)),
db.Column('is_done', db.Boolean),
db.Column('created_at', db.DateTime, server_default=func.now()),
db.Column('updated_at', db.DateTime, server_default=func.now(), onupdate=func.now()))
# all we need from flask_login is UserMixin, so grab it here
from flask_login import UserMixin
# imported pretty print to pring objects of the classes below
from pprint import pformat
# from sqlalchemy.ext.declarative import delcarative_base
# Base = delcarative_base()
game_to_user = db.Table(
"game_to_user",
db.Column("game_id",
db.Integer,
db.ForeignKey("Game.id"),
primary_key=True),
db.Column("user_id",
db.Integer,
db.ForeignKey("User.id"),
primary_key=True),
)
class User(UserMixin, db.Model):
__tablename__ = "User"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30), unique=True)
password = db.Column(db.String(30))
email = db.Column(db.String(30))
account_type = db.Column(db.String(20))
games = db.relationship("Game", secondary=game_to_user)
class Base():
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.remove(self)
db.session.commit()
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
generoJogo = db.Table(
'generoJogo', db.Column('idJogo', db.Integer, db.ForeignKey('jogo.id')),
db.Column('idGenero', db.Integer, db.ForeignKey('genero.id')))
integrante = db.Table(
'integrante',
db.Column('idUsu', db.Integer, db.ForeignKey('usuario.id')),
db.Column('idGrupo', db.Integer, db.ForeignKey('grupo.id')),
)
class Usuario(db.Model, Base):
__tablename__ = 'usuario'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(50), nullable=False)
localizacao = db.Column(db.String(50))
idade = db.Column(db.Integer)
from config import db, login_manager
from flask_login import UserMixin
collects = db.Table('collects',
db.Column('listId', db.Integer, db.ForeignKey('list.id'), primary_key=True),
db.Column('productId', db.Integer, db.ForeignKey('product.id'), primary_key=True)
)
class User_own_product(db.Model):
__tablename__= 'user_own_product'
username = db.Column(db.String(140), db.ForeignKey('user.username'), primary_key=True)
productId = db.Column(db.Integer, db.ForeignKey('product.id'), primary_key=True)
quantity = db.Column(db.Integer)
rating = db.Column(db.String(5), default="0")
user = db.relationship('User', back_populates="products")
product = db.relationship('Product', back_populates="users")
tags = db.Table('tags',
db.Column('tag', db.Integer, db.ForeignKey('tag.tag'), primary_key=True),
db.Column('productId', db.Integer, db.ForeignKey('product.id'), primary_key=True)
)
concerns = db.Table('concerns',
db.Column('concernId', db.Integer, db.ForeignKey('concern.concern'), primary_key=True),
db.Column('username', db.Integer, db.ForeignKey('user.username'), primary_key=True)
)
class User(UserMixin, db.Model):
username = db.Column(db.String(140), primary_key=True)
password = db.Column(db.String(140))
from flask import flash, session
from sqlalchemy.sql import func
from config import db, EMAIL_REGEX, bcrypt
muscles_exercises_table = db.Table('muscles_exercises_relationship',
db.Column('muscles_id', db.Integer, db.ForeignKey('muscles.id'), primary_key=True),
db.Column('exercises_id', db.Integer, db.ForeignKey('exercises.id'), primary_key=True))
class Users(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(45))
last_name = db.Column(db.String(45))
username = db.Column(db.String(45))
email = db.Column(db.String(75))
password = db.Column(db.String(30))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime, server_default=func.now())
@classmethod
def validate_user(cls, user_data):
is_valid = True
if len(user_data['first_name']) < 1:
is_valid = False
flash("Enter a First Name")
if len(user_data['last_name']) < 1:
is_valid = False
flash("Enter a Last Name")
if len(user_data['username']) < 1:
is_valid = False
flash("Enter a Username")
if not EMAIL_REGEX.match(user_data['email']):
