class Book(db.Model):
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
name = db.Column(db.String(50),nullable=False)
status = db.Column(db.Enum('on borrow','off borrow'),default=True,server_default="off borrow")
created_at = db.Column(db.DateTime(timezone=True),nullable=True)
updated_at = db.Column(db.DateTime(timezone=True),nullable=True)
def __init__(self, name, status = 'off borrow'):
self.name = name
self.status = status
def __repr__(self):
return '<Book name={self.name} status={self.status}>'
class User(db.Model):
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
username = db.Column(db.String(50),nullable=False)
email = db.Column(db.String(50),nullable=False,index=True)
password = db.Column(db.Text,nullable=False)
role = db.Column(db.Enum('admin','user'),default=True,server_default="user")
photo = db.Column(db.String(50),default=True,server_default="user.png")
created_at = db.Column(db.DateTime(timezone=True),nullable=True)
updated_at = db.Column(db.DateTime(timezone=True),nullable=True)
def __init__(self, username, email, password, role = "user", photo = "user.png"):
self.username = username
self.email = email
self.password = password
self.role = role
self.photo = photo
def __repr__(self):
return '<User username={self.username} email={self.email} password={self.password} photo={self.photo} role={self.role}>'
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
dob = db.Column(db.Date())
email = db.Column(db.VARCHAR(50), unique=True)
password = db.Column(db.VARCHAR(50))
phone = db.Column(db.VARCHAR(15), unique=True)
urole = db.Column(db.Enum(Roles), default=Roles.BOTOWNER)
activated = db.Column(db.Boolean(False))
def __init__(self, name, dob, email, password, phone, urole):
self.name = name
self.dob = dob
self.email = email
self.password = password
self.phone = phone
self.activated = False
self.urole = urole
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return unicode(self.id)
def get_urole(self):
return self.urole
def __repr__(self):
return '<User %r>' % (self.name)
def activate(self):
self.activated = True
db.session.add(self)
db.session.commit()
class cron(db.Model):
__tablename__ = "cron"
id = db.Column(db.Integer, primary_key=True)
class types(enum.IntEnum):
RSS_feeed = 0
HTML = 1
type = db.Column(db.Enum(types))
districts = db.relationship("districts",
secondary=districtHasCron,
back_populates="cron")
#district_id = db.Column(db.Integer, db.ForeignKey('districts.id'))
#district = db.relationship("districts")
url = db.Column(db.String(100))
last_change_time = db.Column(db.DateTime)
last_cron_time = db.Column(db.DateTime)
unread_change = db.Column(db.Boolean)
referenceHtml_lastCron = db.Column(db.Text)
referenceHtml_lastRead = db.Column(db.Text)
commands = db.Column(db.JSON)
cron_error_log = db.Column(db.Text)
def __init__(self, type, url, commands={}):
self.type = type
self.url = url
self.unread_change = False
self.last_change_time = datetime.fromtimestamp(0)
self.last_cron_time = datetime.fromtimestamp(0)
self.commands = commands
self.referenceHtml_lastCron = ""
self.referenceHtml_lastRead = ""
def run(self):
res = runJob(self)
if res == None:
return False
else:
db.session.flush()
return True
def difference(self):
return (list(difflib.Differ().compare(
BeautifulSoup(self.referenceHtml_lastRead,
'html.parser').prettify().split("\n"),
BeautifulSoup(self.referenceHtml_lastCron,
'html.parser').prettify().split("\n"))))
#TODO: Test this method!
#TODO: This method might not work because of different inclines
def set_as_read(self):
self.referenceHtml_lastRead = self.referenceHtml_lastCron
self.unread_change = False
#TODO: Test this method!
def cron_error(self):
if self.cron_error_log == None:
return False
else:
return True
#TODO: Test this method!
def add_error_log(self, report):
if self.cron_error_log == None:
self.cron_error_log = report
else:
self.cron_error_log += "\n" + report
db.session.flush()
class Event(BaseEventTemplate):
_tablename_ = "event"
status = db.Column(db.Enum(EventStatus),
nullable=False,
default=EventStatus.approved)
start_date = db.Column(db.Date(), nullable=True, default=None)
submission_date = db.Column(db.DateTime(), nullable=True, default=None)
decision_date = db.Column(db.DateTime(), nullable=True, default=None)
cancelled_date = db.Column(db.DateTime(), nullable=True, default=None)
external_events = db.relationship("ExternalEvent")
def __repr__(self):
return f"Event('{self.title}', '{self.start_date}')"
def startDateTime(self):
dt = datetime.combine(self.start_date, self.start_time)
return dt
def startDate(self):
return self.startDateTime().date()
def startTime(self):
return self.startDateTime().time()
def endDateTime(self):
dt = datetime.combine(self.start_date, self.start_time)
dt = dt + self.duration
return dt
def endDate(self):
return self.endDateTime().date()
def endTime(self):
return self.endDateTime().time()
def registrationURL(self):
for ext_event in self.external_events:
if ext_event.primary_event:
return ext_event.ext_event_url
return None
def addExternalEvent(self, platform_name, external_id, external_url):
platform = Platform.query.filter_by(name=platform_name).first()
ext_event = ExternalEvent(event_id=self.id,
platform_id=platform.id,
ext_event_id=external_id,
ext_event_url=external_url)
self.external_events.append(ext_event)
return ext_event
def getExternalEventByPlatformName(self, platform_name):
ext_event = next(event for event in self.external_events
if event.platformName() == platform_name)
return ext_event
def fullySynced(self):
synced = True
ext_event_platforms = [ext.platform_id for ext in self.external_events]
# check for out of date external events
for ext_event in self.external_events:
if ext_event.sync_date < self.modified_date:
synced = False
# check for uninitialized external events
for platform in self.platforms:
if platform.id not in ext_event_platforms:
synced = False
# check for deleted external events
for platform_id in ext_event_platforms:
if platform_id not in [platform.id for platform in self.platforms]:
synced = False
return synced
def htmlSummary(self, all_links=False, omit=[]):
desc = ""
if 'time' not in omit:
desc += "<b>Time:</b> " \
+ self.startDateTime().strftime('%b %d %I:%M %p - ') \
+ self.endTime().strftime('%I:%M %p')
if 'instr' not in omit:
desc += f"<br><b>Instructor:</b> {self.host_name}"
if all_links:
for ext_event in self.external_events:
platform_name = Platform.query.get(ext_event.platform_id).name
desc += f"<br><b>{platform_name}:</b> <a href='{ext_event.ext_event_url}'>" \
f"link</a>"
else:
if self.external_events and 'reg' not in omit:
reg_url = self.registrationURL()
if reg_url:
desc += f"<br><b>Register:</b> <a href='{reg_url}'>" \
f"{reg_url}</a>"
if 'price' not in omit:
for price in self.prices:
desc += f"<br><b>Price:</b> {price.name} - ${price.value:.2f}"
if 'age' not in omit:
if self.min_age and not self.max_age:
desc += f"<br><b>Ages</b>: {self.min_age} and up"
elif self.max_age and not self.min_age:
desc += f"<br><b>Ages</b>: {self.max_age} and under"
elif self.min_age and self.max_age:
desc += f"<br><b>Ages</b>: {self.min_age} to {self.max_age}"
if self.authorizations and 'auth' not in omit:
desc += f"<br><b>Required Authorizations:</b> " \
+ f"{', '.join([auth.name for auth in self.authorizations])}"
desc += '<br><br>' + '<br>'.join(self.description.split('\n'))
return desc
class BaseEventTemplate(BaseModel):
__abstract__ = True
event_type = db.Column(db.Enum(EventType),
nullable=False,
default=EventType._class)
title = db.Column(db.String(100), unique=False, nullable=False)
description = db.Column(db.String(4000), nullable=False)
host_email = db.Column(db.String(120), unique=False, nullable=True)
host_name = db.Column(db.String(60))
location = db.Column(db.String(120))
start_time = db.Column(db.Time(), nullable=True, default=None)
duration = db.Column(db.Interval(),
nullable=False,
default=timedelta(hours=1))
image_file = db.Column(db.String(40), nullable=True, default='default.jpg')
@declared_attr
def tags(cls):
resource_association = db.Table(
'%s_tags' % cls.__tablename__,
cls.metadata,
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id')),
db.Column('%s_id' % cls.__tablename__, db.Integer,
db.ForeignKey('%s.id' % cls.__tablename__)),
)
return db.relationship(Tag,
secondary=resource_association,
backref="%s_parents" % cls.__name__.lower())
@declared_attr
def resources(cls):
resource_association = db.Table(
'%s_resources' % cls.__tablename__,
cls.metadata,
db.Column('resource_id', db.Integer, db.ForeignKey('resource.id')),
db.Column('%s_id' % cls.__tablename__, db.Integer,
db.ForeignKey('%s.id' % cls.__tablename__)),
)
return db.relationship(Resource,
secondary=resource_association,
backref="%s_parents" % cls.__name__.lower())
@declared_attr
def platforms(cls):
platform_association = db.Table(
'%s_platform' % cls.__tablename__,
cls.metadata,
db.Column('platform_id', db.Integer, db.ForeignKey('platform.id')),
db.Column('%s_id' % cls.__tablename__, db.Integer,
db.ForeignKey('%s.id' % cls.__tablename__)),
)
return db.relationship(Platform, secondary=platform_association)
# Restrictions
min_age = db.Column(db.Integer(), nullable=True)
max_age = db.Column(db.Integer(), nullable=True)
registration_limit = db.Column(db.Integer(), nullable=True)
@declared_attr
def prices(cls):
price_association = db.Table(
'%s_price' % cls.__tablename__,
cls.metadata,
db.Column('price_id', db.Integer, db.ForeignKey('price.id')),
db.Column('%s_id' % cls.__tablename__, db.Integer,
db.ForeignKey('%s.id' % cls.__tablename__)),
)
return db.relationship(Price, secondary=price_association)
@declared_attr
def authorizations(cls):
authorization_association = db.Table(
'%s_authorization' % cls.__tablename__,
cls.metadata,
db.Column('authorization_id', db.Integer,
db.ForeignKey('authorization.id')),
db.Column('%s_id' % cls.__tablename__, db.Integer,
db.ForeignKey('%s.id' % cls.__tablename__)),
)
return db.relationship(Authorization,
secondary=authorization_association)
# # Grants
# def grant_auths(cls):
# authorization_association = db.Table(
# '%s_authorization' % cls.__tablename__,
# cls.metadata,
# db.Column('authorization_id', db.Integer, db.ForeignKey('authorization.id')),
# db.Column('%s_id' % cls.__tablename__,
# db.Integer, db.ForeignKey('%s.id' % cls.__tablename__)),
# )
# return db.relationship(Authorization, secondary=authorization_association)
def __repr__(self):
return f"Event Template('{self.title}')"