class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(50), unique=False, nullable=False)
last_name = db.Column(db.String(50), unique=False, nullable=False)
username = db.Column(db.String(50), unique=True, nullable=False)
email = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
role = db.Column(db.String(7), unique=False, nullable=False)
registered_date = db.Column(db.DateTime(), unique=False, nullable=False)
approved_date = db.Column(db.DateTime(), unique=False, nullable=False)
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)
def __repr__(self):
return f"User('{self.first_name}, {self.last_name}, {self.username}, {self.email})"
class Bot(db.Model):
__tablename__ = 'bots'
id = db.Column(db.Integer, primary_key=True)
bot_guid = db.Column(db.String(), unique=True)
user_id = db.Column(db.Integer, ForeignKey("users.id", ondelete="CASCADE"))
name = db.Column(db.String())
platforms = db.Column(JSON)
active_model = db.Column(db.String())
last_trained = db.Column(db.DateTime(timezone=False))
team = db.Column(JSON)
words = db.Column(db.String())
persona = db.Column(db.Integer, default=-1)
created = db.Column(db.DateTime(timezone=False))
used = db.Column(db.DateTime(timezone=False))
def __init__(self, user_id, name, persona=-1, words={},platforms={}):
self.bot_guid = str(uuid.uuid1())
self.user_id = user_id
self.name = name
self.platforms = platforms
self.created = datetime.datetime.utcnow()
self.used = datetime.datetime.utcnow()
self.last_trained = None
self.active_model = ""
self.words = words
self.persona = persona
self.team = {"admins":[{"user_id":user_id}],"developers":[]}
def __repr__(self):
return '<name {}>'.format(self.name)
class YoutubeComment(db.Model):
__tablename__ = 'comment'
video_id = db.Column(db.VARCHAR(12), db.ForeignKey('video.id'))
# Thread_id is either the ID of the commmentThread object, or
# the parentId of the commment snippet.
# In the case that these two values are the same,
# the item is a top-level comment.
thread_id = db.Column(db.VARCHAR(100))
id = db.Column(db.VARCHAR(100), primary_key=True)
# Snippet data
# There is a field 'textOriginal', but one is only guaranteed
# access to this if one is the original author (we never are)
textDisplay = db.Column(db.VARCHAR(1000))
# Only valid for top-level comments. Always 0 for replies
totalReplyCount = db.Column(db.Integer)
authorDisplayName = db.Column(db.VARCHAR(100))
authorProfileImageUrl = db.Column(db.VARCHAR(100))
authorChannelUrl = db.Column(db.VARCHAR(100))
authorChannelId = db.Column(db.VARCHAR(100))
authorGooglePlusProfileUrl = db.Column(db.VARCHAR(100))
likeCount = db.Column(db.Integer)
publishedAt = db.Column(db.DateTime(timezone=True))
updatedAt = db.Column(db.DateTime(timezone=True))
class WeighingManagementModel(db.Model):
__tablename__ = 'weighing_management'
weighing_management_id = db.Column(db.Integer, primary_key=True,
autoincrement=True)
date_and_hour_of_management = db.Column(db.DateTime(timezone=True),
nullable=False)
date_of_actual_weighing = db.Column(db.DateTime(timezone=True),
nullable=False)
date_of_old_weighing = db.Column(db.DateTime(timezone=True),
nullable=False)
old_weight = db.Column(db.Numeric(5, 2), nullable=False)
actual_weight = db.Column(db.Numeric(5, 2), nullable=False)
bovine_id = db.Column(db.Integer, db.ForeignKey('beef_cattle.bovine_id', ondelete='CASCADE'))
def __init__(self, date_of_old_weighing,
old_weight, actual_weight, bovine_id):
self.date_and_hour_of_management = datetime.utcnow()
self.date_of_old_weighing = date_of_old_weighing
self.date_of_actual_weighing = datetime.utcnow()
self.old_weight = old_weight
self.actual_weight = actual_weight
self.bovine_id = bovine_id
def to_json(self):
weighing_management = {
'weighing_management_id': self.weighing_management_id,
'date_and_hour_of_management': self.date_and_hour_of_management,
'date_of_old_weighing': self.date_of_old_weighing,
'date_of_actual_weighing': self.date_of_actual_weighing,
'bovine_id': self.bovine_id,
'old_weight': float(self.old_weight),
'actual_weight': float(self.actual_weight),
}
return weighing_management
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(80), unique=False, nullable=False)
second_name = db.Column(db.String(80), unique=False, nullable=False)
email = db.Column(db.String(100), nullable=False, unique=True)
password = db.Column(db.String(100), nullable=False)
group = db.Column(db.String(5), unique=False, nullable=True)
role = db.Column(db.Enum(UserRoleEnum),
default=UserRoleEnum.student,
nullable=False)
created_on = db.Column(db.DateTime(), default=datetime.utcnow)
updated_on = db.Column(db.DateTime(),
default=datetime.utcnow,
onupdate=datetime.utcnow)
def is_admin(self):
return self.role == User.ROLES['admin']
def allowed(self, access_level):
return self.role >= access_level
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def __repr__(self):
return f"{self.first_name} {self.second_name}"
class Tasks(db.Model):
id = db.Column(db.Integer, primary_key=True)
taskname = db.Column(db.String(50))
description = db.Column(db.String(300))
dateadded = db.Column(db.DateTime())
lastmodified = db.Column(db.DateTime())
duedate = db.Column(db.DateTime())
status = db.Column(db.String(10))
class Job(db.Model):
__tablename__ = 'jobs'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128))
description = db.Column(db.String(1000))
status = db.Column(db.String(128))
start_time = db.Column(db.DateTime())
end_time = db.Column(db.DateTime())
worker = db.Column(db.Integer, db.ForeignKey('users.id'))
worker_rating = db.Column(db.Float)
employer = db.Column(db.Integer, db.ForeignKey('users.id'))
employer_rating = db.Column(db.Float)
hourly_bitcoin_rate = db.Column(db.Float)
class Member(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(50), unique=False, nullable=False)
last_name = db.Column(db.String(50), unique=False, nullable=False)
street_num = db.Column(db.String(10), unique=False, nullable=False)
street_name = db.Column(db.String(50), unique=False, nullable=False)
city = db.Column(db.String(50), unique=False, nullable=False)
_state = db.Column(db.String(2), unique=False, nullable=False)
postal_code = db.Column(db.String(10), unique=False, nullable=False)
contact_num = db.Column(db.Integer, unique=False, nullable=False)
email = db.Column(db.String(50), unique=True, nullable=False)
birthdate = db.Column(db.DateTime(), nullable=False)
age = db.Column(db.Integer, nullable=True)
inserted_date = db.Column(db.DateTime(), nullable=False)
class Analytics(db.Model):
__tablename__ = 'analytics'
id = db.Column(db.Integer, primary_key=True)
bot_guid = db.Column(db.String(),
ForeignKey("bots.bot_guid", ondelete="CASCADE"))
message = db.Column(db.String())
intent = db.Column(db.String())
entities = db.Column(JSON)
confident = db.Column(Boolean, unique=False, default=False)
response_time = db.Column(db.String(), unique=False, default="0")
created = db.Column(db.DateTime(timezone=False))
def __init__(self,
bot_guid,
message="",
intent=None,
entities={},
user_data={},
confident=False,
response_time="0",
source="web",
is_human=1):
self.bot_guid = bot_guid
self.message = message
self.intent = intent
self.entities = entities
self.response_time = response_time
self.confident = confident
self.created = datetime.datetime.utcnow()
def __repr__(self):
return '<name {}>'.format(self.message)
class Case(db.Model):
__tablename__ = "Cases"
id = db.Column(db.Integer, primary_key=True)
info = db.Column(db.String(100), nullable=True)
url = db.Column(db.String(100), nullable=True)
created_time = db.Column(db.DateTime(), default=datetime.now())
comment = db.Column(db.String(100))
def __init__(self, info, url, create_time=False, comment=False):
self.info = info
self.url = url
self.created_time = create_time
self.comment = comment
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.id
def __repr__(self):
return "<Case('%s','%s','%s','%s','%s')>" % (
self.id, self.info, self.url, self.created_time, self.comment)
class Serata(db.Model):
__tablename__ = "serata"
__table_args__ = (db.UniqueConstraint("id",
"data",
name="contraint_serata"), )
id = db.Column(db.Integer(), primary_key=True)
nome = db.Column(db.String(255), nullable=False)
descrizione = db.Column(db.String(255), nullable=False)
data = db.Column(db.DateTime(), nullable=False)
link_partecipazione = db.Column(db.String(255), nullable=True)
link_registrazione = db.Column(db.String(255), nullable=True)
corso_id = db.Column(db.Integer(), db.ForeignKey("corso.id"))
def __init__(self,
nome,
descrizione,
data,
link_partecipazione='',
link_registrazione=''):
self.nome = nome
self.descrizione = descrizione
self.data = data
self.link_partecipazione = link_partecipazione
self.link_registrazione = link_registrazione
def __repr__(self):
return "<Descrizione '{}'. Link registrazione>".format(
self.descrizione, self.link_registrazione)
class History(db.Model):
__tablename__ = "history"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey(
'users.id'), nullable=False)
username = db.Column(db.String(128), nullable=True)
user_email = db.Column(db.String(128), nullable=True)
date = db.Column(
db.DateTime(), default=datetime.datetime.utcnow(), nullable=True)
task = db.Column(db.String(128), nullable=True)
def __init__(self, user_id, username, user_email, date, task):
self.user_id = user_id
self.username = username
self.user_email = user_email
self.date = date
self.task = task
def to_json(self):
return {
'id': self.id,
'user_id': self.user_id,
'username': self.username,
'user_email': self.user_email,
'date': self.date,
'task': self.task
}
class Appointment(db.Model):
__tablename__ = 'appointments'
id = db.Column(db.Integer, primary_key=True)
start = db.Column(db.DateTime(timezone=True), nullable=False)
end = db.Column(db.DateTime(timezone=True), nullable=False)
created = db.Column(db.DateTime(timezone=True), nullable=False)
status = db.Column(db.Boolean(), nullable=False) # True active False
# canceled
comments = db.Column(db.String(1024))
event_id = db.Column(db.Integer, db.ForeignKey('events.id'), nullable=False)
event = db.relationship('Event',
backref='appointments',
innerjoin=True,
cascade='all, delete-orphan',
single_parent=True,
uselist=False)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer)
body = db.Column(db.Text)
created_at = db.Column(db.DateTime(timezone=True),
server_default=db.func.now())
image_url = db.Column(db.Text)
view_count = db.Column(db.Integer, default=0)
class Record(db.Model, AbstractModel):
product_id = db.Column(db.String(40),
db.ForeignKey("product.id"),
primary_key=True)
date = db.Column(db.DateTime(),
default=datetime.datetime.utcnow,
primary_key=True)
price = db.Column(db.Float(), nullable=False)
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer)
post_id = db.Column(db.Integer)
body = db.Column(db.Text)
image_url = db.Column(db.Text)
created_at = db.Column(db.DateTime(timezone=True),
server_default=db.func.now())
class Media(db.Model):
__tablename__ = 'media'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
description = db.Column(db.String(150))
location = db.Column(db.String(150))
author = db.Column(db.ForeignKey('users.id'))
posted_date = db.Column(db.DateTime(), default=datetime.utcnow)
class GitHubContributions(db.Model, AddUpdateDelete):
__tablename__ = 'githubcontributions'
id = db.Column(db.Integer, primary_key=True)
swag_id = db.Column(db.Integer, db.ForeignKey('swag.id'))
time_logged = db.Column(db.DateTime(timezone=True), unique=False)
github_url = db.Column(db.Text, unique=False)
point_value = db.Column(db.Integer)
swag = db.relationship("Swag")
class ServiceStatus(db.Model):
__tablename__ = "service_status"
ip = db.Column(db.String(), primary_key=True)
last_seen_ts = db.Column(db.DateTime())
def __init__(self, ip, ts):
self.ip = ip
self.last_seen_ts = ts
class alumni(db.Model):
__tablename__ = 'tb_alumni'
id = db.Column(db.Integer, primary_key=True)
department = db.Column(db.String(64)) # 校友所属系
name = db.Column(db.String(64)) # 校友名字
company = db.Column(db.String(64)) # 校友公司
type = db.Column(db.String(64), default=0) # 捐赠类型
money = db.Column(db.Integer()) # 捐赠金额
time = db.Column(db.DateTime(), default=datetime.utcnow)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
admin = db.Column(db.Boolean(), default=False, nullable=False)
created_at = db.Column(db.DateTime(), default=func.now(), nullable=False)
def __init__(self, username, email, password):
self.username = username
self.email = email
self.password = bcrypt.generate_password_hash(
password, current_app.config.get('BCRYPT_LOG_ROUNDS')).decode()
def to_json(self):
return {
'id': self.id,
'username': self.username,
'email': self.email,
'active': self.active,
'admin': self.admin
}
def encode_auth_token(self):
try:
payload = {
'exp':
datetime.datetime.utcnow() + datetime.timedelta(
days=current_app.config.get('TOKEN_EXPIRATION_DAYS'),
seconds=current_app.config.get(
'TOKEN_EXPIRATION_SECONDS')),
'iat':
datetime.datetime.utcnow(),
'sub':
self.id
}
return jwt.encode(payload,
current_app.config.get('SECRET_KEY'),
algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
try:
payload = jwt.decode(auth_token,
current_app.config.get('SECRET_KEY'))
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
class Task(db.Model):
id = db.Column(db.Integer, primary_key=True)
taskname = db.Column(db.String(80), unique=True)
completedate = db.Column(db.DateTime())
category = db.Column(db.String(20))
def __init__(self, taskname, completedate, category):
self.taskname = taskname
self.completedate = completedate
self.category = category
class Lecture(db.Model):
__tablename__ = "lectures"
id = db.Column(db.Integer, primary_key=True, nullable=False)
room = db.Column(db.String(128), nullable=False)
subject = db.Column(db.String(128), nullable=False)
start_time = db.Column(db.DateTime(timezone=True), nullable=False)
end_time = db.Column(db.DateTime(timezone=True), nullable=False)
lecturer = db.Column(db.String(128))
students = db.relationship('AttendanceRecord',
backref='lecture',
lazy='dynamic')
def to_dict(self):
return {
'id': self.id,
'room': self.room,
'subject': self.subject,
'start_time': self.start_time,
'end_time': self.end_time,
'lecturer': self.lecturer,
'status': self.status()
}
def from_dict(self, data):
for field in ['room', 'subject', 'start_time', 'end_time', 'lecturer']:
if field in data:
setattr(self, field, data[field])
def status(self):
# start = datetime.datetime.strptime(self.start_time, '%a, %d %b %Y %H:%M:%S %Z')
# end = datetime.datetime.strptime(self.end_time, '%a, %d %b %Y %H:%M:%S %Z')
start = self.start_time
end = self.end_time
now = datetime.datetime.now(start.tzinfo)
if now < start:
return 'SCHEDULED'
elif start <= now < end:
return 'IN PROGRESS'
else:
return 'FINISHED'
class Schedule(db.Model):
__tablename__ = 'schedules'
id = db.Column(db.Integer, primary_key=True)
message = db.Column(db.String())
created = db.Column(db.DateTime(timezone=True))
def __init__(self, message=""):
self.message = message
self.created = datetime.datetime.utcnow()
def __repr__(self):
return '<name {}>'.format(self.message)
class Hacktoberfest(db.Model, AddUpdateDelete):
__tablename__ = 'hacktoberfest'
id = db.Column(db.Integer, primary_key=True)
swag_id = db.Column(db.Integer, db.ForeignKey('swag.id'))
time_logged = db.Column(db.DateTime(timezone=True), unique=False)
total_points = db.Column(db.Integer)
hacktoberfest_swag_sent = db.Column(db.Integer) # year
hacktoberfest_approved = db.Column(db.Boolean, unique=False, default=False)
email_address = db.Column(db.String(255), unique=False)
sendgrid_employee = db.Column(db.Boolean)
sendgrid_customer = db.Column(db.Boolean)
swag = db.relationship("Swag")
class Log(db.Model, AddUpdateDelete):
__tablename__ = 'log'
id = db.Column(db.Integer, primary_key=True)
time_logged = db.Column(db.DateTime(timezone=True), unique=True)
action = db.Column(db.String(255), unique=False)
delta = db.Column(db.Text, unique=False)
error = db.Column(db.Text, unique=False)
affected_systems = db.Column(db.String(255), unique=False)
def __init__(self,
time_logged=None,
action=None,
delta=None,
error=None,
affected_systems=None):
self.time_logged = time_logged
self.action = action
self.delta = delta
self.error = error
self.affected_systems = affected_systems
def add_log_entry(self, time_logged, action, delta, error,
affected_systems):
self.time_logged = time_logged
self.action = action
self.delta = delta
self.error = error
self.affected_systems = affected_systems
self.add(self)
def __repr__(self):
"""Return a machine-readable representation of this Log object.
Only trouble is, a log entry has an ID property which is determined
on creation. Reporting it here means this isn't executable to make a
new log entry.
"""
return ("{classname}("
"id={id!r}, "
"time_logged={time_logged!r}, "
"action={action!r}, "
"delta={delta!r}, "
"error={error!r}, "
"affected_systems={affected_systems!r})").format(
classname=self.__class__.__name__,
id=self.id,
time_logged=self.time_logged,
action=self.action,
delta=self.delta,
error=self.error,
affected_systems=self.affected_systems)
class Education(BaseMixin, ExperienceMixin, db.Model):
title = db.Column(db.String(50), nullable=False)
school = db.Column(db.String(50), default='')
extent = db.Column(db.String(50), default='')
description = db.Column(db.String(), default='')
type = db.Column(ChoiceType(EducationType, impl=db.String()),
default=EducationType.education.value)
startdate = db.Column(db.DateTime())
enddate = db.Column(db.DateTime())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User',
foreign_keys=[user_id],
backref='educations')
@property
def _descriptive(self):
return self.title + (', {}'.format(self.school)
if self.school != '' else '')
def add_activity(self, new, session):
if not new:
return
origin = self.user.name
target = self._descriptive
action = '{origin} added the work experience {target}'
activity = Activity(
**{
'action': action,
'user_id': self.user.id,
'education_id': self.id,
'origin': 'user',
'target': 'education'
})
session.add(activity)
class Album(db.Model):
__tablename__ = "albums"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(300), nullable=False)
description = db.Column(db.String(1000), nullable=False)
images = db.relationship('Image', backref=db.backref('albums', lazy=True))
created_at = db.Column(db.DateTime(timezone=True), nullable=False)
def __init__(self, title, description, created_at=None):
if not created_at:
created_at = datetime.datetime.now()
self.title = title
self.description = description
self.created_at = created_at
class Intent(db.Model):
__tablename__ = 'intents'
id = db.Column(db.Integer, primary_key=True)
bot_guid = db.Column(db.String(),
ForeignKey("bots.bot_guid", ondelete="CASCADE"))
name = db.Column(db.String())
utterances = db.Column(ARRAY(db.String()))
patterns = db.Column(ARRAY(db.String()))
has_entities = db.Column(Boolean, unique=False, default=False)
responses = db.Column(ARRAY(db.String()))
calls = db.Column(db.Integer, default=0)
is_folder = db.Column(Boolean, unique=False, default=False)
modified = db.Column(db.DateTime(timezone=False))
created = db.Column(db.DateTime(timezone=False))
def __init__(self,
bot_guid,
name,
has_entities,
is_folder=False,
utterances=[],
responses=[],
patterns=[]):
self.name = name
self.bot_guid = bot_guid
self.utterances = utterances
self.patterns = patterns
self.has_entities = has_entities
self.responses = responses
self.calls = 0
self.is_folder = is_folder
self.modified = datetime.datetime.utcnow()
self.created = datetime.datetime.utcnow()
def __repr__(self):
return '<name {}>'.format(self.name)
class AdminUser(db.Model, UserMixin):
__tablename__ = "admin_users"
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('admin_roles', lazy='dynamic'))
def __str__(self):
return self.email
