class User(BaseModel):
#table mapping
__tablename__ = "users"
##region column mapping
id = db.Column(db.Integer, primary_key=True)
user_name = db.Column(db.Text)
primary_email_id = db.Column(db.Integer, db.ForeignKey('user_emails.id'))
#Use model class instead of physical table name for db.ForeignKey() ref. http://stackoverflow.com/a/41633052/248616
from model.address import Address
billing_address_id = db.Column(db.Integer,
db.ForeignKey(Address.__table__.c['id']))
shipping_address_id = db.Column(db.Integer,
db.ForeignKey(Address.__table__.c['id']))
##endregion column mapping
##region relationship obj
emails = db.relationship('UserEmail',
primaryjoin='User.id==UserEmail.user_id',
back_populates='owner')
primaryEmail = db.relationship(
'UserEmail', primaryjoin='User.primary_email_id==UserEmail.id')
billingAddress = db.relationship(
'Address', primaryjoin='User.billing_address_id==Address.id')
shippingAddress = db.relationship(
'Address', primaryjoin='User.shipping_address_id==Address.id')
class Event(Base):
__tablename__ = 'event'
user_id = sqlalchemy.Column(sqlalchemy.Integer, sqlalchemy.ForeignKey('user.id'))
user = sqlalchemy.relationship("User", back_populates="events")
id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
pain_intensity = sqlalchemy.Column(sqlalchemy.Integer)
start_time = sqlalchemy.Column(sqlalchemy.DATETIME)
end_time = sqlalchemy.Column(sqlalchemy.DATETIME)
previous_night_sleep = sqlalchemy.Column(sqlalchemy.Float)
trigger = sqlalchemy.relationship("Trigger")
class Users(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True, nullable=False)
email = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(80), unique=True, nullable=False)
commentaires = relationship('Commentaire', backref='user')
like = db.relationship('Like', backref='user', uselist=False)
dislike = db.relationship('Dislike', backref='user', uselist=False)
def __repr__(self):
return '<Users %r>' % self.id
class Client(db.Model):
__tablename__ = "clients"
user_id = db.Column(db.Integer(),
db.ForeignKey('users.user_id'),
primary_key=True)
is_approved = db.Column(db.Boolean(), nullable=False)
requests = db.relationship('Request', backref='clients', lazy=True)
def upgrade():
op.add_column(
'users',
sa.Column('polls_voted_in',
sa.relationship(),
backref='polls_voted_in',
primaryjoin=id == Vote.id))
class ProposalStatus(db.Model):
__tablename__ = "proposal_status"
status_id = db.Column(db.Integer(), primary_key=True)
status_label = db.Column(db.String(256), nullable=False, unique=True)
proposals = db.relationship('Proposal',
backref='proposal_status',
lazy=True)
class Classes(db.Model):
class_id=db.Column(db.Integer,primary_key=True)
classname=db.Column(db.String(200),unique=True,nullable=False)
camera_name=db.Column(db.String(200),nullable=False)
course_sel=db.Column(db.Integer,db.ForeignKey('course.course_id'))
# roll=db.relationship('Students',backref='classroom')
attendance_id=db.relationship('Attendance_sys',backref='cla_attend')
class User(Base):
__tablename__ = 'user'
id = Column(String(20), primary_key=True)
name = Column(String(20))
# 一对多:
books = relationship('Book')
class PortletRow(DeclarativeBase, GenericSet):
__tablename__ = 'portlet_rows'
#{ Columns
layout_id = Column(Integer, ForeignKey('layouts.id'), nullable=False)
layout = relationship('Layout')
position = Column(SmallInteger, nullable=False, default=1)
portlet_id = Column(Integer, ForeignKey('portlets.id'))
class Brands(db.Model):
__tablename__ = 'Brands'
brand_id = db.Column('brand_id', db.Integer, primary_key=True)
brand_name = db.Column('brand_name', db.VARCHAR(50))
product = db.relationship('Products', backref='brand')
def __repr__(self):
return '<brands {}>'.format(self.brand_name)
class User(Base):
#表名字
#__tablename__ == 'user'
__tablename__ = 'user'
#表结构
id = Column(String(20), primary_key=True)
name = Column(String(20))
#设置一对多
books = relationship('Book')
class User(db.Model):
__tablename__ = "users"
user_id = db.Column(db.Integer(), primary_key=True)
user_name = db.Column(db.String(50), nullable=False, unique=True)
cat_id = db.Column(db.Integer(),
db.ForeignKey('user_cat.cat_id'),
nullable=False,
unique=False)
mail = db.Column(db.String(128), nullable=False, unique=True)
address = db.Column(db.String(256), nullable=False, unique=False)
providers = db.relationship('Provider',
uselist=False,
backref='users',
lazy=True)
clients = db.relationship('Client',
uselist=False,
backref='users',
lazy=True)
class Students(db.Model):
roll_no=db.Column(db.String(200),primary_key=True)
rank=db.Column(db.String(200),nullable=False)
first_name=db.Column(db.String(200),nullable=False)
last_name=db.Column(db.String(200),nullable=False)
phone=db.Column(db.Integer(),nullable=False)
attendance_id=db.relationship('Attendance_sys',backref='stud_attend')
# room_id=db.Column(db.Integer,db.ForeignKey('classes.class_id'))
course_sel=db.Column(db.Integer,db.ForeignKey('course.course_id'))
class Categories(db.Model):
__tablename__ = 'Categories'
category_id = db.Column('category_id', db.Integer, primary_key=True)
category_name = db.Column('category_name', db.VARCHAR(50))
category = db.relationship('Products', backref='category')
def __repr__(self):
return '<categories {}>'.format(self.category_name)
class Lectures(db.Model):
lecture_id=db.Column(db.Integer,primary_key=True)
#Comment lecture_name and check how to show timings
lecture_name=db.Column(db.String(200),nullable=False)
lecture_day=db.Column(db.String(200),nullable=False)
lecture_time=db.Column(db.String(200),nullable=False)
# lecture_datetime=db.Column(db.DateTime,default=datetime.utcnow())
# lecture_start_time=db.Column(db.Time)
# lecture_end_time=db.Column(db.Time)
attendance_id=db.relationship('Attendance_sys',backref='lec_attend')
class Provider(db.Model):
__tablename__ = "providers"
user_id = db.Column(db.Integer(),
db.ForeignKey('users.user_id'),
primary_key=True)
use_plastic_id_1 = db.Column(db.Integer(), nullable=False)
use_plastic_id_2 = db.Column(db.Integer(), nullable=False)
use_plastic_id_3 = db.Column(db.Integer(), nullable=False)
use_plastic_id_4 = db.Column(db.Integer(), nullable=False)
proposals = db.relationship('Proposal', backref='providers', lazy=True)
class Adress(Base):
__tablename__ = 'address'
id = Column(Integer, primary_key=True)
email_address = Column(String, nullable=False)
user_id = Column(Integer, ForeignKey('user.id'))
# backref set up Adress.user for each User.address.
# establish a one to many relationship.
user = relationship('User', backref='addresses')
def __repr__(self):
return '<Adress (%r)>' % self.email_address
class Result(Base):
__tablename__ = 'result'
id = db.Column(db.Integer, primary_key=True)
job_id = db.Column(db.Integer, db.ForeignKey('group.id'))
testcase_id = db.Column(db.Integer, db.ForeignKey('testcase.id'))
testcase_name = db.Column(db.Text)
groups = db.relationship("Group",
secondary='groups_to_results',
backref="results")
job = db.relation('Group') # , lazy = False)
testcase = db.relation('Testcase',
backref='results') # , lazy = False)
class Request(db.Model):
__tablename__ = "requests"
request_id = db.Column(db.Integer(), primary_key=True)
product_id = db.Column(db.Integer(),
db.ForeignKey('products.product_id'),
nullable=False)
client_id = db.Column(db.Integer(),
db.ForeignKey('clients.user_id'),
nullable=False)
request_quantity = db.Column(db.Integer(), nullable=False)
status_id = db.Column(db.Integer(),
db.ForeignKey('request_status.status_id'),
nullable=False)
proposals = db.relationship('Proposal', backref='requests', lazy=True)
class User(Base):
__tablename__ = 'users'
id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
first_name = sqlalchemy.Column(sqlalchemy.String)
last_name = sqlalchemy.Column(sqlalchemy.String)
email = sqlalchemy.Column(sqlalchemy.String)
google_id = sqlalchemy.Column(sqlalchemy.String)
location = sqlalchemy.Column(sqlalchemy.String)
sex = sqlalchemy.Column(sqlalchemy.String)
start_year = sqlalchemy.Column(sqlalchemy.Integer)
phone_number = sqlalchemy.Column(sqlalchemy.String)
height = sqlalchemy.Column(sqlalchemy.Integer)
weight = sqlalchemy.Column(sqlalchemy.Integer)
aura = sqlalchemy.Column(sqlalchemy.Boolean)
events = sqlalchemy.relationship("Event", back_populates="user")
class Employee(Base):
__tablename__ = 'employee'
id = Column(Integer, primary_key=True)
name = Column(String(30))
projects = relationship('Project',
secondary=Table(
'employee_project', Base.metadata,
Column('employee_id',
Integer,
ForeignKey('employee.id'),
primary_key=True),
Column('employee_id',
Integer,
ForeignKey('employee.id'),
primary_key=True)),
backref='employees')
class KeyWord(db.Model):
__tablename__ = 'KeyWord'
id = Column(String, primary_key=True) #id counts as the title of the word as well as the primary key
numFU = Column(Integer, nullable=False)
dateCreated = Column(DateTime(), nullable=False)
FuckID = relationship('F**k', backref='F**k', lazy=True)
def __init__(self, keyword, numFU):
self.id = keyword
self.dateCreated = datetime.now(timezone('UTC')).astimezone('US/Pacific')
self.numFU = 0
def insert(self):
try:
db.session.add(self)
db.session.commit()
except Exception as E:
print(E)
db.session.rollback()
def update(self):
try:
db.session.commit()
except Exception as E:
print(E)
db.session.rollback()
def delete(self):
try:
db.session.delete(self)
db.session.commit()
except Exception as E:
print(E)
db.session.rollback()
def format(self):
return{
'id':self.id,
'numFU':self.numFU
}
class User(db.Model):
__tablename__ = 'User'
id = Column(Integer, primary_key=True)
fName = Column(String(150), nullable=False)
lName = Column(String(150), nullable=False)
uName = Column(String(150), nullable=False)
dateCreated = Column(DateTime(), nullable=False)
fuckID = relationship('F**k', backref='F**k', lazy=True)
def __init__(self, fName, lName, uName):
self.fName = fName
self.lName = lName
self.uName = uName
self.dateCreated = datetime.now(timezone('UTC')).astimezone('US/Pacific')
def insert(self):dateCreated = Column(DateTime(), nullable=False)
try:
db.session.add(self)
db.session.commit()
except Exception as E:
print(E)
db.session.rollback()
class Product(db.Model):
__tablename__ = "products"
product_id = db.Column(db.Integer(), primary_key=True)
product_name = db.Column(db.String(256), nullable=False, unique=True)
requests = db.relationship('Request', backref='products', lazy=True)
class Trigger(Base):
__tablename__ = 'trigger'
event = sqlalchemy.relationship("Event")
id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
name = sqlalchemy.Column(sqlalchemy.String)
category = sqlalchemy.Column(sqlalchemy.String)
class Course(db.Model):
course_id=db.Column(db.Integer,primary_key=True)
course_name=db.Column(db.String(200),unique=True,nullable=False)
# stream=db.Column(db.String(200),nullable=False)
courses=db.relationship('Students',backref='courses',cascade = "all,delete, delete-orphan")
course_class=db.relationship('Classes',backref='course_class',cascade = "all,delete, delete-orphan")
class User(engine.Base):
__tablename__ = 'users'
id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
name = sqlalchemy.Column(sqlalchemy.String(50))
addresses = sqlalchemy.relationship("Address", backref="user")
class RequestStatus(db.Model):
__tablename__ = "request_status"
status_id = db.Column(db.Integer(), primary_key=True)
status_label = db.Column(db.String(256), nullable=False, unique=True)
requests = db.relationship('Request', backref='request_status', lazy=True)
class UserCat(db.Model):
__tablename__ = "user_cat"
cat_id = db.Column(db.Integer(), primary_key=True)
label = db.Column(db.String(256), nullable=False)
users = db.relationship('User', backref='user_cat', lazy=True)
