class Task(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
sender_id = db.Column(db.Integer, db.ForeignKey('user.id'))
recipient_id = db.Column(db.Integer, db.ForeignKey('user.id'))
title = db.Column(db.String(100))
body = db.Column(db.Text())
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
last_message_read_time = db.Column(db.DateTime)
final = db.Column(db.Boolean, default=False, nullable=False)
def __repr__(self):
return f"'{self.title}', '{self.body}'"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100),
nullable=False) #cant be null, must exist
content = db.Column(db.Text, nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
user_id = db.Column(
db.Integer, db.ForeignKey('user.id'), nullable=False
) # relates to the 'id' column of 'user' table (which explains the lowercase 'user')
def __init__(self, title, content, user_id):
self.title = title
self.content = content
self.user_id = user_id
def __repr__(self):
return f"Blog post('{self.title}', '{self.author.username}', '{self.date_posted}')"
class User(db.Model,
UserMixin): # we can import UserMixin from the flask-login classes
id = db.Column(db.Integer, primary_key=True) # id is a primary key
username = db.Column(
db.String(20), unique=True,
nullable=False) # username has to be: 20 chars, unique, not null
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default="default.jpg") # default value
password = db.Column(db.String(60), nullable=False)
posts = db.relationship(
"Post", backref="author", lazy=True
) # the lazy argument means that sql aclehmy will load the data from the db one object at a time
def __repr__(
self,
): # this is how our object is printed when someone requets the object
return f"User('{self.username}', '{self.email}'"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
image_file = db.Column(db.String(20), nullable=False,
default='default.jpg')
Posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def encode_auth_token(self, user_id):
app = create_app()
try:
payload = {
'exp': datetime.utcnow() + timedelta(days=0, seconds=5),
'iat': datetime.utcnow(),
'sub': user_id
}
return jwt.encode(
payload,
app.config.get('SECRET_KEY'),
algorithm='HS256'
)
except Exception as e:
return e
@staticmethod
def decode_auth_token(token):
app = create_app()
try:
#id = jwt.decode(token, app.config['SECRET_KEY'],algorithms=['HS256'])['reset_password']
payload = jwt.decode(token, app.config.get('SECRET_KEY'), algorithm='HS256')
return payload['sub']
except:
return
class Patient(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(30), nullable=True)
last_name = db.Column(db.String(30), nullable=True)
age = db.Column(db.String(30), nullable=True)
gender = db.Column(db.String(6), nullable=True)
latitude = db.Column(db.String(20), nullable=True)
longitude = db.Column(db.String(20), nullable=True)
file = db.Column(db.String(90), nullable=True)
date_posted = db.Column(db.DateTime,
nullable=True,
default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True)
def __repr__(self):
return f(
"Patient('{self.first_name}', '{self.last_name}', '{self.age}', "
"'{self.gender}','{self.latitude}','{self.longitude}', '{self.file}', '{self.date_posted}')"
)
class Post(db.Model):
"""
Post models for post information for blog site.
user_id has a relationship with user.id of user class as author
"""
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
"""
for the debug purpose by shell script
:return:tile, date_posted
"""
return "Post('{}', '{}')".format(self.title, self.date_posted)
class Post(db.Model):
__tablename__ = 'post'
__searchable__ = ['title', 'content']
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
Salary = db.Column(db.Text, nullable=False)
skillsrequired = db.Column(db.Text, nullable=False)
minskillsrequired = db.Column(db.Text, nullable=False)
Category = db.Column(db.String(100), nullable=False)
candi_ids = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}','{self.minskillsrequired}', '{self.skillsrequired}','{self.Category}', '{self.Salary}')"
class User(
db.Model, UserMixin
): # define the table fields for the class below. Automatically creates a table name of lowercase user
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
# backref creates a relationship that allows us to get author attribute. Lazy is when it loads the data. Allows for pulling all posts from an author
# posts is not a column. It is the relationship table creation that runs as necessary (lazy)
# Posts is uppercase since we are referencing the actual POST class
# Reference for object oriented programming in Python
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
firstname = db.Column(db.String(20), unique=False, nullable=False)
lastname = db.Column(db.String(20), unique=False, nullable=False)
gender = db.Column(db.String(20), unique=False, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpeg')
password = db.Column(db.String(60), nullable=False)
albums = db.relationship('Album', backref='author', lazy=True)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def get_reset_token(self, expires_sec=1800):
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
class Machine(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
machine_number = db.Column(db.Integer, nullable=False)
game_number = db.Column(db.Integer, nullable=False)
true_prob = db.Column(db.Float, nullable=False)
success_count = db.Column(db.Integer, default=0)
total_count = db.Column(db.Integer, default=0)
max_attempts = db.Column(db.Integer, nullable=False)
def __repr__(self):
return f"Machine('{self.user_id}', '{self.machine_number}', '{self.game_number})"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=True)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
def __json__(self):
return {
'title': self.title,
'date_posted': self.date_posted.timestamp()
}
for_json = __json__ # supported by simplejson
class Order(db.Model):
order_id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
billing_address = db.Column(db.String(250), nullable=False)
billing_postcode = db.Column(db.String(10), nullable=False)
delivery_address = db.Column(db.String(250), nullable=False)
deliver_postcode = db.Column(db.String(10), nullable=False)
book_id = db.Column(db.Integer, db.ForeignKey('purchased_book.id'), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
price = db.Column(db.Float(4,2), nullable=False, default=00.00)
# seller_id = db.Column(db.Integer, db.ForeignKey('book.userID', nullable=False))
book_details = db.relationship('PurchasedBook', backref='book_deets', lazy=True)
def __repr__(self):
return f"Order('{self.order_id}', '{self.date}')"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
Username = db.Column(db.String(50), nullable=False)
Address = db.Column(db.String(100), nullable=True)
PhoneNumber = db.Column(db.String(13), unique=True, nullable=False)
PlotNumber = db.Column(db.String(10), unique=True, nullable=False)
FlatNumber = db.Column(db.String(10), nullable=True)
PaymentStatus = db.Column(db.String(10), nullable=False, default="False")
Role = db.Column(db.String(10), nullable=False, default="User")
Date_created = db.Column(db.DateTime,
nullable=False,
default=datetime.today())
payment = db.relationship('Payment', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.Username}', '{self.PhoneNumber}', '{self.PlotNumber}','{self.PaymentStatus}','{self.Role}','{self.Date_created}')"
class Grade(db.Model):
id = db.Column(db.Integer, primary_key=True)
assignment = db.Column(db.String(20), nullable=False)
user = db.Column(db.String(20),
nullable=False) #student for whom the grade is posted
grade = db.Column(db.Integer(), nullable=False)
points = db.Column(db.Integer(), nullable=False)
total_points = db.Column(db.Integer(), nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
teacher = db.Column(db.String(20), nullable=False) #grader
user_id = db.Column(db.Integer, nullable=False)
def __repr__(self):
return "Grade({}, {})".format(self.assignment, self.grade)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
# The backref allows the Post class to access the corresponding User
# through the name 'author'.
# Posts does NOT get assigned a column in the Database.
posts = db.relationship('Post', backref=('author'), lazy=True)
# Example of a magic function, read up.
# Function responsible for printing when
# we use CLI to access Database.
def __repr__(self):
return f"User('{self.username}','{self.email})"
# ? There are no security issues here, even if multiple
# ? Users try to simult. try reset passwords, because
# ? of the simple reason that this is a method (segregation of OOP)
# ? Each user will be given different tokens.
def get_reset_token(self, expires_sec=1800):
s = Serializer(current_app.config["SECRET_KEY"], expires_sec)
return s.dumps({"user_id": self.id}).decode('utf-8')
# * This method returns a user if valid token, or None if invalid.
# ? You need to explicitly define as static, if not using the self variable.
@staticmethod
def verify_reset_token(token):
# No need to pass in expiration timer here. This just verifies.
s = Serializer(current_app.config["SECRET_KEY"])
try:
# ? The token that this method is passed, will only have a single user_id
# ? associated with it. Multiple tokens may exist however if multiple users
# ? try to reset passwords.
user_id = s.loads(token)["user_id"]
except:
return None
return User.query.get(user_id)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post',
foreign_keys='Post.user_id',
backref='author',
lazy=True)
liked = db.relationship('PostLike', lazy='dynamic')
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}','{self.email}','{self.image_file}')"
def like_post(self, post):
if not self.has_liked_post(post):
like = PostLike(user_id=self.id, post_id=post.id)
db.session.add(like)
def unlike_post(self, post):
if self.has_liked_post(post):
PostLike.query.filter_by(user_id=self.id, post_id=post.id).delete()
def has_liked_post(self, post):
return PostLike.query.filter(PostLike.user_id == self.id,
PostLike.post_id == post.id).count() > 0
class Address(db.Model):
id = db.Column(db.Integer, primary_key=True)
line_1 = db.Column(db.String(250), nullable=False)
line_2 = db.Column(db.String(250), nullable=False)
line_3 = db.Column(db.String(250), nullable=False)
city = db.Column(db.String(250), nullable=False)
state = db.Column(db.String(250), nullable=False)
country_code = db.Column(db.String(2), nullable=False)
postal_code = db.Column(db.String(10), nullable=False)
def __repr__(self):
return f"Post('{self.line_1}', '{self.line_2}', '{self.line_3}', '{self.city}',"\
f" '{self.state}', '{self.country_code}', '{self.postal_code}')"
class User(db.Model, UserMixin):
#we have to inherit from the UserMixin class in order to activate the extension
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship(
'Post', backref='author', lazy=True
) #defines when sqlachemy loads the data from the db. True means
#sqlalchemy will load the data as necessary in one go. Will use the
#post attribute to get the posts posted by an indivudual user
#backref 'author' creates a column author in the posts table
def __repr__(self):
return f"User('{self.username}','{self.email}','{self.image_file}')"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
url = db.Column(db.String(100), nullable=False)
language = db.Column(db.String(100), nullable=False)
platform = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
is_private = db.Column(db.Boolean, default=False, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpeg')
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
album_id = db.Column(db.Integer, db.ForeignKey('album.id'), nullable=False)
likes = db.Column(db.Integer, nullable=False)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
# we will hash the image_file url to a string of length 20
# also we will have a default profile pic for every user
password = db.Column(db.String(60), nullable=False)
# we will hash the password given by user to a string of length 60
posts = db.relationship('Post', backref='author', lazy=True)
# 'Post' is the class name
# 'backref' creates a column named author in the post table, and using this we can get the author of a particular post using the 'author' attribute
# 'lazy' argument defines when Sqlalchemy loads the data into the database, so True means sqlalchemy will load the data necessary in one go
# with this relationship, we will be able to get all the post created by a single user.
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Post(db.Model):
''' ______________
| POSTS |
| id |
| title |
| date_posted|
| content |
| user_id |
|____________|
'''
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
class LeaveApplication(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('staff_member.id'), nullable=False)
category = db.Column(db.Enum(LeaveType), nullable=False)
pre_authorisation = db.Column(db.Boolean, nullable=False, default=False)
personal_message = db.Column(db.Text, nullable=False)
leave_date_from = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
leave_date_to = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
approved = db.Column(db.Boolean, nullable=False, default=False)
def __str__(self):
return f"{self.category} ---- {self.leave_date_from} - {self.leave_date_to}"
class Direccion(db.Model):
id = db.Column(db.Integer, primary_key=True)
sector = db.Column(db.String())
calle = db.Column(db.String())
numero_muni = db.Column(db.String())
comuna = db.Column(db.String())
unidad = db.Column(db.String())
n_unidad = db.Column(db.String())
cliente_id = db.Column(db.Integer, db.ForeignKey('cliente.id'))
cliente = db.relationship("Cliente", back_populates="direccion")
def __repr__(self):
return f"Direccion('{self.id}', '{self.calle}', '{self.comuna}')"
class Cotizacion(db.Model):
__table_name = 'cotizacion'
__table_args__ = {'schema': 'rosarsa_crm'}
id = db.Column(db.Integer, primary_key=True)
fechacotizacion = db.Column(db.Date,
nullable=False,
default=datetime.utcnow)
fechacreacion = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
cliente = db.relationship('Cliente', backref='cotizacion', lazy=True)
idcliente = db.Column(db.Integer,
db.ForeignKey('rosarsa_crm.cliente.id'),
nullable=False)
email_destino = db.Column(db.String(500), nullable=True)
precio_total = db.Column(db.Integer, nullable=False, default=0)
observaciones = db.Column(db.Text, nullable=True)
texto_email = db.Column(db.Text, nullable=True)
enviado = db.Column(db.Boolean, nullable=False, default=False)
activo = db.Column(db.Boolean, nullable=False, default=True)
class Timetable(db.Model):
'''
The timetable table from which current time table will be fetched
'''
day = db.Column(db.String(20),
primary_key=True,
unique=True,
nullable=False)
p1 = db.Column(db.String(20), unique=False, nullable=True)
p2 = db.Column(db.String(20), unique=False, nullable=True)
p3 = db.Column(db.String(20), unique=False, nullable=True)
p4 = db.Column(db.String(20), unique=False, nullable=True)
p5 = db.Column(db.String(20), unique=False, nullable=True)
p6 = db.Column(db.String(20), unique=False, nullable=True)
p7 = db.Column(db.String(20), unique=False, nullable=True)
p8 = db.Column(db.String(20), unique=False, nullable=True)
p9 = db.Column(db.String(20), unique=False, nullable=True)
def __repr__(self):
return f"Day: {self.day}, P1: {self.p1}, P2: {self.p2}, P3: {self.p3},\
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.png')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
# backref 는 Post class에 Column을 새로 추가(아래 코드에서는 author라는 Column)하는것과 비슷한 역할.
# backref를 사용함으로써 Post가 생성되었을 때 We can simply use this 'author' attribute to get the user who created the post.
# lazy argument just defines when SQLalchemy loads the data from database. So 'True' means that SQLalchemy will load the data
# as necessary in one go. This is conveninet because with this relationship we'll be able to simply use this post attribute
# to get all of the post created by an individual user. Notice that this is a relationship not a column. If we would actually
# look at our actual database structure in some kind of SQL client, we wouldn't see this 'posts' column here. This is actually ust running an
# additional query at the background that will get all of the posts this user has created.
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Article(db.Model):
id = db.Column(db.Integer, primary_key=True)
article_id = db.Column(db.String(50), nullable=False)
title = db.Column(db.String(80), nullable=False)
description = db.Column(db.Text, nullable=False)
creator_id = db.Column(db.Integer,
db.ForeignKey("user.id"),
nullable=False)
def __str__(self):
return f'the article id is {self.id}'
def articleObject(self):
article = {}
article[article_id] = self.article_id
article[title] = article.title
article[description] = article.description
return article
class Event(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.Date, nullable=False)
time = db.Column(db.Time, nullable=False)
cost = db.Column(db.Float, nullable=False, default='To be defined')
np = db.Column(db.Integer, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
club_id = db.Column(db.Integer, db.ForeignKey('club.id'), nullable=False)
sport_id = db.Column(db.Integer, db.ForeignKey('sport.id'), nullable=False)
level = db.Column(db.String(60))
participant2 = db.relationship('Participant',
foreign_keys=[Participant.e_id],
backref='part',
lazy=True)
def __repr__(self):
return '<Event %r %r %r>' % self.date % self.time % self.np
