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 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 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 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 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 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 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 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 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 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 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 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 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 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)
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 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 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 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 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 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 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)
class OAuth(db.Model, OAuthConsumerMixin):
"""Contain the associated Oauth."""
provider_user_id = db.Column(db.String(256), unique=True)
user_id = db.Column(db.Integer, db.ForeignKey(User.id))
user = db.relationship(User)
class LinkedInRecord(db.Model):
"""
DB Model for Profile Data
"""
__tablename__ = 'profiles'
member_id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(128))
last_name = db.Column(db.String(128))
summary = db.Column(db.Text)
metro = db.Column(db.Text)
postal_code = db.Column(db.Text)
country_code = db.Column(db.Text)
language = db.Column(db.Text)
industry = db.Column(db.Text)
skills = db.Column(db.Text)
companyName_0 = db.Column(db.Text)
companyUrl_0 = db.Column(db.Text)
title_0 = db.Column(db.Text)
start_date_0 = db.Column(db.Date)
end_date_0 = db.Column(db.Date)
summary_0 = db.Column(db.Text)
companyName_1 = db.Column(db.Text)
companyUrl_1 = db.Column(db.Text)
title_1 = db.Column(db.Text)
start_date_1 = db.Column(db.Date)
end_date_1 = db.Column(db.Date)
summary_1 = db.Column(db.Text)
companyName_2 = db.Column(db.Text)
companyUrl_2 = db.Column(db.Text)
title_2 = db.Column(db.Text)
start_date_2 = db.Column(db.Date)
end_date_2 = db.Column(db.Date)
summary_2 = db.Column(db.Text)
created = db.Column(db.Date, default=date.today())
updated = db.Column(db.Date, default=None)
education_school = db.Column(db.Text)
education_start = db.Column(db.Date)
education_end = db.Column(db.Date)
education_degree = db.Column(db.Text)
education_study_field = db.Column(db.Text)
first_graduation_date = db.Column(db.Date)
public_url = db.Column(db.Text)
recruiter_url = db.Column(db.Text)
isCompanyFollower = db.Column(db.Boolean)
careerInterests = db.Column(db.Boolean)
contacts = db.relationship("Contact")
def __init__(self, LinkedInProfile):
"""
:param LinkedInProfile:
"""
for k, v in LinkedInProfile.__dict__.items():
if k[0] == '_': # Include or exclude properties based on _prop naming convention
continue
if v:
pass # Avoids overwriting data with None
else:
continue
try:
setattr(self, k, v)
except AttributeError:
self._set_entry(k, v)
def _set_entry(self, k, v):
# Handles if Table object is intended to be internal
k_ = "_" + k
setattr(self, k_, v)
class User(UserMixin, db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
user_type = db.Column(db.Text, default='normal')
username = db.Column(db.String(128))
password_hash = db.Column(db.Text)
api_key = db.Column(db.Text)
current_session_user = db.Column(db.Integer, default=0)
caches = db.relationship('UserCache', backref='user', lazy='dynamic')
records = db.relationship('LinkedInRecord', secondary=User_Records, lazy=True,
backref=db.backref('users', lazy=True))
activities = db.relationship('UserActivity', backref='user', lazy='dynamic')
allowance = db.Column(db.Integer, default=450) # New records allowed per day
# Generating a random key to return to Extension after login success
@staticmethod
def verify_auth_token(token):
s = Serializer(app_run.config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired:
print("Expired Token")
return None # valid token, but expired
except BadSignature:
print("Bad Signature")
return None # invalid token
user = User.query.get(data['id'])
if user:
token_session = data['session']
if token_session == user.current_session_user:
return user
else:
print("Session does not match for user {}, generate new token".format(user.id))
return None
else:
return False
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def get_id(self):
return self.id
def get_activity(self):
"""
Queries a User for associated UserActivities.
Filters to UserActivities that are active=true
If UserActivity is active, but older than 1 day, it is set active=false
:return: UserActivity or False if no active, UserActivity < 1 day are found
"""
active_trackers = self.activities.filter_by(active=True).all()
if active_trackers:
pass
else:
return False # No active tracker
current_trackers = []
for t in active_trackers:
if (datetime.now() - t.created).days > 0:
t.active = False
db.session.add(t)
db.session.commit()
continue
else:
current_trackers.append(t)
if current_trackers:
return current_trackers[0]
else: # Will occur if 1 or more active trackers must be set inactive
return False
def generate_new_password(self, new_password):
self.password_hash = generate_password_hash(new_password)
self.current_session_user = self.current_session_user + 1
from flask_login import UserMixin
from itsdangerous import (TimedJSONWebSignatureSerializer
as Serializer, BadSignature, SignatureExpired)
from werkzeug.security import check_password_hash, generate_password_hash
from app_folder import app_run, db
from app_folder import login
User_Records = db.Table('user_records',
db.Column('user_id', db.Integer, db.ForeignKey('users.id'), primary_key=True),
db.Column('member_id', db.Integer, db.ForeignKey('profiles.member_id'), primary_key=True)
)
Cache_Records = db.Table('cache_records',
db.Column('cache_id', db.String(16), db.ForeignKey('usercache.cache_id'), primary_key=True),
db.Column('member_id', db.Integer, db.ForeignKey('profiles.member_id'), primary_key=True)
)
class LinkedInRecord(db.Model):
"""
DB Model for Profile Data
"""
__tablename__ = 'profiles'
member_id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(128))
last_name = db.Column(db.String(128))
summary = db.Column(db.Text)
metro = db.Column(db.Text)
class Availability(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
from_time = db.Column(db.String(7), index=True, default=datetime.utcnow)
to_time = db.Column(db.String(7), index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Availability from {} to {}>'.format(self.from_time,self.to_time)
# calculates the endtime of an appointment based off of the start time and meeting duration
def calculateEndTime(self, apptStartTime, meetingLength):
splitTime = apptStartTime.split(':')
splitMeetingminutes = meetingLength.split(':')
if int(splitMeetingminutes[0]) == 1:
endHour = int(splitTime[0]) + 1
endTime = str(endHour) + ':' + str(splitTime[1])
else:
endMinutes = int(splitTime[1]) + int(splitMeetingminutes[1])
if endMinutes >= 60:
endMinutes = endMinutes - 60
endHour = int(splitTime[0]) + 1
if endMinutes < 10 and endMinutes != 0:
endTime = str(endHour) + ':0' + str(endMinutes)
elif endMinutes == 0:
endTime = str(endHour) + ':00'
else:
endTime = str(endHour) + ':' + str(endMinutes)
else:
endHour = splitTime[0]
endTime = str(endHour) + ':' + str(endMinutes)
return endTime
# checks to see if the endtime is not past the user's available times
def in_range(self, availableEndTime, apptEndTime):
splitAvailEnd = availableEndTime.split(':')
splitApptEnd = apptEndTime.split(':')
# comparing end times of availability and appointment
endAvailInt = int(splitAvailEnd[0]) * 100 + int(splitAvailEnd[1])
endApptInt = int(splitApptEnd[0]) * 100 + int(splitApptEnd[1])
if endAvailInt < endApptInt:
return False
else:
return True
# add to an array to hold all the possible meeting intervals
def set_available_times(
self,
start_time,
incrementAmount,
end_time,
):
availAppts = []
apptEndTime = self.calculateEndTime(start_time, incrementAmount)
apptStartTime = start_time
while self.in_range(end_time, apptEndTime):
appointmentTime = apptStartTime + ' - ' + apptEndTime
availAppts.append((appointmentTime, appointmentTime))
apptStartTime = apptEndTime
apptEndTime = self.calculateEndTime(apptStartTime, incrementAmount)
return availAppts
def remove_busy_times(self, apptArray, listOfMadeMeetingsArray):
#this gets an array of the appointments that that user has on that day
something = []
for times in listOfMadeMeetingsArray:
if ((times.meetingTime, times.meetingTime)) in apptArray:
apptArray.remove((times.meetingTime, times.meetingTime))
return apptArray
