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 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 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)
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 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 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 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 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 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 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 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 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 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)
import random
from datetime import date, datetime
from string import ascii_letters
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))
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
