class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
def __repr__(self):
"""
Returns the User as an account on the application.
"""
return '<User {}>'.format(self.username)
def set_password(self, password):
"""
Generates a hash to track the pasword for 'self' aka the user.
"""
self.password_hash = generate_password_hash(password)
def check_password(self, password):
"""
Checks the hash corresponding to the pasword for 'self' aka the user.
"""
return check_password_hash(self.password_hash, password)
class Meetings(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
length = db.Column(db.String(7), index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Meetings length {}>'.format(self.length)
class Users(db.Model, UserMixin):
# __tablename__ = 'User'
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(120), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False)
class UserCache(db.Model):
"""
DB Model that holds member IDs in cached. Relationship with User (1) to many
"""
__tablename__ = "usercache"
cache_id = db.Column(db.String(16), primary_key=True)
active = db.Column(db.Boolean, default=False)
friendly_id = db.Column(db.Text)
# We want a backref here so that any updates to user as well as UserCache are reflected on both ends
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
profiles = db.relationship('LinkedInRecord', secondary=Cache_Records, lazy=True,
backref=db.backref('caches', lazy=True))
created = db.Column(db.DateTime, default=datetime.now())
def __init__(self):
self.cache_id = self.generate_string
@property
def generate_string(self):
"""
:return: Random ascii letters (string)
"""
l = ascii_letters
holder = []
for i in range(16):
holder.append(l[random.randrange(0, len(l))])
return ''.join(holder)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(128), index=True, unique=True)
password_hash = db.Column(db.String(128))
def set_password(self, password):
self.password_hash = generate_password_hash(password)
class Tag(db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(32), nullable=False)
message_id = db.Column(db.Integer,
db.ForeignKey('message.id'),
nullable=False)
message = db.relationship('Message', backref=db.backref('tags', lazy=True))
class Post(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(256))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Posts {}>'.format(self.body)
class Summary(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.Date, nullable=False)
total_calories = db.Column(db.Integer, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Food('{self.date}', '{self.total_calories}')"
class Availability(UserMixin, db.Model):
"""
Creates variable for user availability.
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
time_Range = db.Column(db.String(128))
meeting_Length = db.Column(db.String(128))
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
date_posted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
sentiment = db.Column(db.Float, 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 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 __repr__(self):
return f"User('{self.username}')"
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
userMessage = db.Column(db.String(512), index=True)
username = db.Column(db.String(64), index=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
userFrom = db.Column(db.String(64), index=True)
def __repr__(self):
return '<User {}>'.format(self.username)
class User(UserMixin, db.Model):
"""
Creates the ID, username, email, and password_hash variables for each user.
"""
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(128), index=True, unique=True)
password_hash = db.Column(db.String(128))
def set_password(self, password):
self.password_hash = generate_password_hash(password, method='sha256')
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(1024), nullable=False)
create_date = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
# date = db.Column(db.DateTime, onupdate=datetime.utcnow)
def __init__(self, text, tags): #, date):
self.text = text.strip()
self.tags = [Tag(text=tag.strip()) for tag in tags.split(',')]
class Appointments(db.Model):
"""
Creates the variables for user appointments.
"""
id = db.Column(db.Integer, primary_key=True)
creator = db.Column(db.String(64))
name = db.Column(db.String(64))
email = db.Column(db.String(64))
time = db.Column(db.String(16))
def __repr__(self):
return '<Appointments: {}>'.format(self.body)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(256))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
''' This function formats post.
Returns:
Will return a format.
'''
return '<Posts {}>'.format(self.body)
class Appointment(db.Model):
__tablename__ = 'appointment'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, index=True)
phonenumber = db.Column(db.String, index=True)
time = db.Column(db.Integer, index=True)
timelength = db.Column(db.Integer, index=True)
def __init__(self, name, phonenumber, time, timelength):
self.name = name
self.phonenumber = phonenumber
self.time = time
self.timelength = timelength
class User(db.Model):
""" Build in function to modify
Returns:
print variable in string
Changelog:
4/19 Ali
5/3 Dylan: Added events relationship
5/10 Dylan: Added salt
"""
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(128), index=True, unique=True)
salt = db.Column(db.String(32))
password_hash = db.Column(db.String(256), default = 'fatal-error')
start_time = db.Column(db.Time, default=datetime.time(9, 0))
end_time = db.Column(db.Time, default=datetime.time(22, 0))
meeting_length = db.Column(db.Integer, default=30)
events = db.relationship('Event', backref='creator', lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
family = db.Column(db.String(64), nullable=False)
password_hash = db.Column(db.String(128))
messages = db.relationship("Message", uselist=False, backref="user")
def __repr__(self):
return '<User {}>'.format(self.username)
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)
class Food(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
date = db.Column(db.Date, nullable=False)
quantity = db.Column(db.Integer, nullable=False)
calories = db.Column(db.Integer, nullable=False)
carbon = protein = db.Column(db.Integer, nullable=True)
protein = db.Column(db.Integer, nullable=True)
fat = db.Column(db.Integer, nullable=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Food('{self.name}', '{self.date}','{self.calories}','{self.quantity}')"
class Event(db.Model):
'''
Event database
@id unique id required for database
@user_id user's id that the event is for
@datetime date and time of the meeting
@guest_name name input by the person requesting the meeting
@description description of the meeting
Changelog:
5/3 Dylan: Initial Implementation
'''
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), index=True)
datetime = db.Column(db.DateTime(), index=True)
guest_name = db.Column(db.String(64), index=True)
description = db.Column(db.String(256), default = '')
def __repr(self):
return f'<Datetime: {datetime}, Guest: {guest_name}>'
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(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}')"
class User(UserMixin, db.Model):
'''This class models a user of this application and will hold a users Username and password hash'''
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(128), index=True, unique=True)
sendEmailConfirm = db.Column(db.String(128))
password_hash = db.Column(db.String(128))
availability = db.relationship("Availability", uselist=False, backref="user")
meetings = db.relationship("Meetings", uselist=False, backref="user")
appointments = db.relationship("listOfMeetings", uselist=False, backref="user")
usercal = db.relationship("CustomHTMLCalendar", uselist=False, backref="user")
posts = db.relationship('Post', backref="user")
def __repr__(self):
return '<User {}>'.format(self.username)
def print_username(self):
return '{}'.format(self.username)
def set_password(self, password):
''' This functions generates a hash based on a users account password.
Args:
password (String) : The password that a user chooses to associate with their account.
'''
self.password_hash = generate_password_hash(password)
def check_password(self, password):
''' This function checks if a input password corresponds with the hash associated with the account.
Args:
password (String) : The password that will be checked.
Returns:
True if the password corresponds with the hash associated with the users account.
'''
return check_password_hash(self.password_hash, password)
class CustomHTMLCalendar(UserMixin, HTMLCalendar, db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
# It's not being linked to the other table
username = ""
def set_username(self, user):
self.username = user
def formatday(self, day, weekday):
"""This method returns a line of html that is used to create the calendar. Each date of the calendar is a link that will open a new page and redirect you to google.com
This link can be changed to redirect to another website later on.
Args:
day (String): The date, such as 1, 2, 3 etc.
weekday (String): The day of the week such as mon, tue, wed, etc.
Returns:
A string corresponding to the html code that should be written for each day in the month. If the day is 0, this method will return html code to be blank.
If the day is within the date range of the month, the method will return the html to represent the day of the month with each day being a link.
"""
if day == 0:
return '<td class="noday"> </td>' # day outside month
else:
return '<td class="%s"><a href="%s" target="_blank">%d</a></td>' % (self.cssclasses[weekday], "{}/{}".format(self.username, day), day)
class Contact(db.Model):
__tablename__ = "contacts"
id = db.Column(db.Integer, primary_key=True)
is_email = db.Column(db.Boolean)
is_website = db.Column(db.Boolean)
is_personal = db.Column(db.Boolean)
address = db.Column(db.Text)
profile_id = db.Column(db.Integer, db.ForeignKey('profiles.member_id'))
class listOfMeetings(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
meetingDate = db.Column(db.String)
meetingTime = db.Column(db.String)
descriptionOfMeeting = db.Column(db.String(150))
participants = db.Column(db.String(64))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Appointment with{}, on {} from {}>'.format(self.participants, self.meetingDate, self.meetingTime)
class UserActivity(db.Model):
__tablename__ = "useractivity"
id = db.Column(db.Integer, primary_key=True)
active = db.Column(db.Boolean, default=True)
created = db.Column(db.DateTime, default=datetime.now())
# Tally from /profiles/
new_records = db.Column(db.Integer, default=0)
# Tally from /prune/
borrowed_records = db.Column(db.Integer, default=0)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
class Event(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True)
eventDate = db.Column(db.String(32), index=True)
eventTime = db.Column(db.String(32), index=True)
militaryTime = db.Column(db.String(32), index=True)
guestname = db.Column(db.String(64), index=True)
description = db.Column(db.String(128), index=True)
def __repr__(self):
''' This function will format username
Returns:
Will return a username.
'''
return '<User {}>'.format(self.username)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(128), index=True, unique=True)
password_hash = db.Column(db.String(128))
emailConfirmation = db.Column(db.String(2), index=True)
meetingLength = db.Column(db.String(32), index=True)
availabilityStart = db.Column(db.String(32), index=True)
availabilityEnd = db.Column(db.String(32), index=True)
posts = db.relationship('Post', backref='author', lazy='dynamic')
def __repr__(self):
''' This function will format username
Returns:
Will return a username.
'''
return '<User {}>'.format(self.username)
def set_password(self, password):
''' This function will generate a password hash.
Args:
password (string) : The user's password
'''
self.password_hash = generate_password_hash(password)
def check_password(self, password):
''' This function will check if password is valid
Args:
password (string) : The user's password
Returns:
Will return true or false depending on if the password is valid.
'''
return check_password_hash(self.password_hash, password)
class User(UserMixin, db.Model):
"""Contain the user details."""
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(256), unique=True)
