from settings import db, login_manager
from flask_login import UserMixin
from datetime import datetime
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
task_user = db.Table(
"task_user", db.Column("user_id", db.Integer, db.ForeignKey("user.id")),
db.Column("task_id", db.Integer, db.ForeignKey("task.id")))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), unique=True, nullable=False)
email = db.Column(db.String(100), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
time = db.Column(db.Integer, nullable=True, default=0)
last_start = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
tasks = db.relationship("Task",
secondary=task_user,
backref=db.backref("users"),
lazy="dynamic")
def serialize(self):
return {
def get_id(self):
return unicode(self.id)
def is_active(self):
return True
def is_anonymous(self):
return False
def is_authenticated(self):
return True
tags = db.Table('tags', db.Column('tag_id', db.Integer,
db.ForeignKey('tag.id')),
db.Column('site_id', db.Integer, db.ForeignKey('site.id')))
class Site(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200), nullable=False)
website = db.Column(db.String(260), nullable=False)
description = db.Column(db.Text)
language = db.Column(db.String(50), default='English')
tags = db.relationship('Tag',
secondary=tags,
backref=db.backref('sites', lazy='dynamic'))
source_url = db.Column(db.String(500))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
submitted_at = db.Column(db.DateTime, default=datetime.utcnow)
from settings import db
dashboard_users = db.Table(
"dashboard_users", db.Model.metadata,
db.Column("user_id", db.Integer,
db.ForeignKey("users.chat_id", ondelete="CASCADE")),
db.Column("dashboard_id", db.Integer,
db.ForeignKey("dashboards.id", ondelete="CASCADE")))
task_users = db.Table(
"task_users", db.Model.metadata,
db.Column("user_id", db.Integer,
db.ForeignKey("users.chat_id", ondelete="CASCADE")),
db.Column("task_id", db.Integer,
db.ForeignKey("tasks.id", ondelete="CASCADE")))
user_subscriptions = db.Table(
"user_subscriptions", db.Model.metadata,
db.Column("user_id",
db.Integer,
db.ForeignKey("users.chat_id", ondelete="CASCADE"),
primary_key=True),
db.Column("event",
db.String,
db.ForeignKey("events.event", ondelete="CASCADE"),
primary_key=True))
class User(db.Model):
__tablename__ = 'users'
from settings import db
movie_booking = db.Table(
'movie_booking',
db.Column('movie_id', db.Integer, db.ForeignKey('movies.id')),
db.Column('booking_id', db.Integer, db.ForeignKey('booking.id')))
class Booking(db.Model):
id = db.Column(db.Integer, primary_key=True)
# user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
# date_id = db.Column(db.Integer, db.ForeignKey('dates.id'))
user_id = db.Column(db.Integer)
date_id = db.Column(db.Integer)
movie_booking = db.relationship('Movies',
secondary=movie_booking,
backref=db.backref('booking',
lazy='dynamic'))
@property
def serialize(self):
#d = Dates.query.filter_by(id=i.id).first().showtime
return {
'id': self.user_id,
'date': self.date_id,
'Movies': [i.id for i in self.movie_booking]
}
@property
def serialize_user(self):
#d = Dates.query.filter_by(id=i.id).first().showtime
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
def __repr__(self):
return '<User %r>' % self.username
def serialize(self) -> dict:
return {"id": self.id, "username": self.username, "email": self.email}
dashboard_users_table = db.Table(
"dashboard_users", db.Model.metadata,
db.Column('dashboard_id', db.Integer, db.ForeignKey("dashboards.id")),
db.Column('user_id', db.Integer, db.ForeignKey("users.id")))
class DashBoard(db.Model):
__tablename__ = 'dashboards'
id = db.Column(db.Integer, primary_key=True)
dashboard_name = db.Column(db.String(20), unique=True, nullable=False)
users = db.relationship("User",
secondary=dashboard_users_table,
backref="dashboard")
tasks = db.relationship("Task", backref="dashboard")
def serialize(self) -> dict:
backref=db.backref('restaurant_items', lazy=True))
name = db.Column(db.String(50), nullable=False)
description = db.Column(db.Text, nullable=True)
price = db.Column(db.Float)
def __repr__(self):
return '<MenuItem %r>' % self.name
class OrderStatus(enum.Enum):
open = 'open'
close = 'close'
order_tables = db.Table(
'order_tables', db.Column('table_id', db.Integer,
db.ForeignKey('table.id')),
db.Column('booked_id', db.Integer, db.ForeignKey('order.id')))
class Order(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_email = db.Column(db.String(120), nullable=False)
mobile = db.Column(db.Integer, nullable=True)
restaurant_id = db.Column(db.Integer,
db.ForeignKey('restaurant.id'),
nullable=False)
restaurant = db.relationship('Restaurant',
backref=db.backref('restaurant_orders',
lazy=True))
order_tables = db.relationship('Table',
secondary=order_tables,
from settings import db
users_dashboards_table = db.Table(
"users_dashboards", db.Model.metadata,
db.Column('user id', db.Integer, db.ForeignKey('users.id')),
db.Column('dashboard id', db.Integer, db.ForeignKey('dashboards.id'))
)
users_tasks_table = db.Table(
"users_tasks", db.Model.metadata,
db.Column('user id', db.Integer, db.ForeignKey('users.id')),
db.Column('task id', db.Integer, db.ForeignKey('tasks.id'))
)
class Task(db.Model):
__tablename__ = 'tasks'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), unique=True, nullable=False)
description = db.Column(db.String(50), nullable=True)
dashboard_id = db.Column(db.Integer, db.ForeignKey("dashboards.id"))
creator = db.Column(db.Integer, db.ForeignKey("users.id"))
users = db.relationship("User", secondary=users_tasks_table, backref="task")
status = db.Column(db.String(15), nullable=False, default="To do")
def __repr__(self):
return f'Table: {self.name}'
class Movies(db.Model):
id = db.Column(db.Integer,primary_key=True)
title = db.Column(db.String(200))
rating = db.Column(db.Integer)
def __init__(self,title):
self.title = title
def __repr__(self):
return '<Title %r>' %self.title
showtime = db.Table('showtime',
db.Column('movie_id',db.Integer, db.ForeignKey('movies.id')),
db.Column('date_id',db.Integer, db.ForeignKey('dates.id'))
)
class Dates(db.Model):
id = db.Column(db.Integer,primary_key=True)
date = db.Column(db.DateTime)
showtime = db.relationship('Movies', secondary=showtime,
backref=db.backref('dates', lazy='dynamic'))
def __init__(self,date):
self.date = date
def __repr__(self):
return '<Date: %r>' %self.date
from settings import db
from sqlalchemy.orm import relationship
events_dates = db.Table(
'events_dates',
db.Column('date_id',
db.Integer,
db.ForeignKey('date.id'),
primary_key=True),
db.Column('event_id',
db.Integer,
db.ForeignKey('event.id'),
primary_key=True))
class Date(db.Model):
__tablename__ = 'date'
id = db.Column(db.Integer, primary_key=True)
year = db.Column(
db.Integer) #?? nullable since some events may not know exact date yet
month = db.Column(db.Integer)
month_name = db.Column(db.String(9))
date = db.Column(db.Integer)
day = db.Column(db.String(8))
def __repr__(self):
return '<Date %r, %r, %r>' % (self.year, self.month_name, self.date)
class Event(db.Model):
__tablename__ = 'event'
from settings import db
volunteerMeets_table = db.Table(
'volunteerMeets',
db.Column('volunteer_id',
db.Integer,
db.ForeignKey('volunteer.id'),
primary_key=True),
db.Column('volunteer_meets_id',
db.Integer,
db.ForeignKey('meets.id'),
primary_key=True))
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), unique=True, nullable=False)
password = db.Column(db.String(10000), unique=True, nullable=False)
zipCode = db.Column(db.String(10), unique=False, nullable=False)
typesPref = db.Column(db.String(100), nullable=True)
phone_number = db.Column(db.Integer, unique=True, nullable=False)
address = db.Column(db.String(100), nullable=False)
__mapper_args__ = {
'polymorphic_identity': 'user',
}
class Elderly(User):
__tablename__ = "elderly"
id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True)
teacher = db.relationship("Teacher", backref="course", uselist=False)
def __repr__(self):
return f"{self.name}"
def serialize(self):
return {
"id": self.id,
"name": self.name,
"modules": str(self.module),
"teacher": str(self.teacher)
}
courses_students_table = db.Table(
"courses_students", db.Model.metadata,
db.Column('course_id', db.Integer, db.ForeignKey("courses.id")),
db.Column('student_id', db.Integer, db.ForeignKey("students.id")))
class Teacher(db.Model):
__tablename__ = "teachers"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), nullable=False, unique=True)
email = db.Column(db.String(45), nullable=False)
school_ = db.Column(db.Integer, db.ForeignKey("school.id"))
course_ = db.Column(db.Integer, db.ForeignKey("courses.id"))
# students = db.relationship("Student", backref="teacher")
def __repr__(self):
from marshmallow import fields
from flask_security import UserMixin, RoleMixin
from passlib.hash import sha256_crypt
from settings import db, ma
from sqlalchemy.ext.hybrid import hybrid_property, hybrid_method
roles_users = db.Table(
'roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('users.id', ondelete='CASCADE')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id', ondelete='CASCADE'))
)
# Role class
class Role(db.Model, RoleMixin):
# Our Role has three fields, ID, name and description
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
# __str__ is required by Flask-Admin, so we can have human-readable values for the Role when editing a User.
def __str__(self):
return self.name
# __hash__ is required to avoid the exception TypeError: unhashable type: 'Role' when saving a User
def __hash__(self):
return hash(self.name)
class User(db.Model, UserMixin):
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.orm import relationship
from werkzeug.security import generate_password_hash
from settings import db
authors = db.Table(
'authors',
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True),
db.Column('paper_id',
db.Integer,
db.ForeignKey('paper.id'),
primary_key=True))
class Score(db.Model):
__tablename__ = "score"
left_id = db.Column(db.Integer,
db.ForeignKey('paper.id'),
primary_key=True)
right_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
primary_key=True)
rating = db.Column(db.Integer, default=0)
is_rated = db.Column(db.Boolean, default=False)
# relationships
reviewer = relationship("User", back_populates="scored_papers")
paper = relationship("Paper", back_populates="reviewers")
