class Emails(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String, nullable=False)
def __repr__(self):
return f"Email: {self.email}"
class President(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
email = db.Column(db.String, nullable=False)
def __repr__(self):
return f"President is {self.name}: {self.email}"
class ToolForTribulationDTO(db.Model):
__tablename__ = 'tool_for_tribulation'
tribulation_id = db.Column(db.Integer,
db.ForeignKey('tribulation.tribulation_id'),
primary_key=True)
tool_id = db.Column(db.Integer,
db.ForeignKey('tool.tool_id'),
primary_key=True)
time_start = db.Column(db.DateTime, default=datetime.utcnow)
time_end = db.Column(db.DateTime, default=datetime.utcnow)
quantity = db.Column(db.Integer, default=0)
def serialize(self):
return {
"tribulation_id": self.tribulation_id,
"tool_id": self.tool_id,
"time_start": self.time_start,
"time_end": self.time_end,
"quantity": self.quantity
}
def merge(self, newdata):
for key, value in newdata.items():
if value:
setattr(self, key, value)
class User(UserMixin, db.Model):
__tablename__ = "users"
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(100), unique=True, nullable=False)
name = db.Column(db.String(100), nullable=False)
password = db.Column(db.String(100), nullable=False)
job = db.Column(db.String(150), nullable=True)
class Todo(db.Model):
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.String(200), nullable=False)
completed = db.Column(db.Integer, default=0)
date_create = db.Column(db.DateTime, default=datetime.utcnow)
def __repr__(self):
return '<Task %r>' % self.id
class Song(db.Model):
__tablename__ = 'songs'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100), unique=True, nullable=False)
artist = db.Column(db.String(100), unique=False, nullable=False)
description = db.Column(db.String(400), unique=False, nullable=True)
path = db.Column(db.String(100), unique=True, nullable=False)
class Formula(db.Model):
__tablename__ = 'formula'
name = db.Column(db.String(80), nullable = False)
id = db.Column(db.Integer, primary_key = True)
description = db.Column(db.String(250))
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
firstname = db.Column(db.String(64), index=True, unique=False)
lastname = db.Column(db.String(64), index=True, unique=False)
password_hash = db.Column(db.String(128))
recordings = db.relationship('Recording', backref='author', lazy='dynamic')
#auditionee = db.relationship('Audition', backref='auditionee', lazy='dynamic')
def get_info(self):
recordings = self.recordings.all()
scores = []
for r in recordings:
scores.append(r.get_score())
if (len(scores) == 0):
avg = 0
high = 0
else:
avg = np.mean(scores)
high = np.amax(scores)
return {
"firstname": self.firstname,
"lastname": self.lastname,
"top_score": str(round(high, 2)),
"average_score": str(round(avg, 2))
}
def get_recording(self):
recordings = self.recordings.all()
data = []
for r in recordings:
data.append(r.info())
return data
def change_username(self, name):
self.username = name
db.session.commit()
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)
def get_ID(self):
return self.id
def get_username(self):
return self.username
class Material(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
owner_id = db.Column(db.Integer,
db.ForeignKey('experiment.id'),
nullable=False)
def __repr__(self):
return f"Material('{self.name}','{self.owner_id}')"
class Course(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True, nullable=False)
experiments = db.relationship('Experiment',
backref='owner',
lazy='dynamic')
def __repr__(self):
return f"Course('{self.name}')"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String(140))
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
def __repr__(self):
return "<Post {}>".format(self.url)
class ActorDTO(db.Model):
__tablename__ = 'actor'
actor_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), nullable=False)
image = db.Column(db.String(500), nullable=True)
description = db.Column(db.String(500), nullable=True)
phone = db.Column(db.String(20), nullable=False)
email = db.Column(db.String(50), nullable=False)
password = db.Column(db.String(20), nullable=False, default='123')
role = db.Column(db.String(5), nullable=False, default='actor')
is_deleted = db.Column(db.Boolean(), default=False)
def serialize(self):
return {
"actor_id": self.actor_id,
"name": self.name,
"image": self.image,
"description": self.description,
"phone": self.phone,
"email": self.email,
"role": self.role,
}
def merge(self, newdata):
for key, value in newdata.items():
if value:
setattr(self, key, value)
class Experiment(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
owner_id = db.Column(db.Integer,
db.ForeignKey('course.id'),
nullable=False)
setups = db.relationship('Setup', backref='owner', lazy='dynamic')
materials = db.relationship('Material', backref='owner', lazy='dynamic')
def __repr__(self):
return f"Experiment('{self.name}','{self.owner_id}')"
class Formula(db.Model):
__tablename__ = 'formula'
__table_args__ = {'extend_existing': True}
name = db.Column(db.String(80), nullable=False)
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(250))
instructions = db.Column(db.String(1000))
class User(db.Model, UserMixin):
# usermixin is for user classes only and lets it inherit certain properties
# inheriting will allow us to use different login extensions
# each of these columns represents a data input from user registration
id = db.Column(db.Integer, primary_key=True)
# each user gets a unique ID to identify them
username = db.Column(db.String(), unique=True, nullable=False)
# everyone must have a username, and no one can have the same username as another (same with email)
password = db.Column(db.String(), nullable=False)
class Event(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
event_date = db.Column(db.DateTime, nullable=False)
event_end = db.Column(db.DateTime)
content = db.Column(db.Text, nullable=False)
def __repr__(self):
return self.event_date.strftime('%m')
class User(db.Model):
__tablename__ = 'user'
name = db.Column(db.String(80), nullable = False)
id = db.Column(db.Integer, primary_key = True)
title = db.Column(db.String(80))
user_creator = db.Column(db.Boolean, default = True)
def get_id(self):
return self.id
class LogDTO(db.Model):
__tablename__ = 'log'
user_id = db.Column(db.Integer, db.ForeignKey('actor.actor_id'), primary_key = True)
date_create = db.Column(db.DateTime,default = datetime.utcnow, primary_key = True)
action = db.Column(db.String(100), nullable = True)
user = db.relationship(ActorDTO)
def serialize(self):
return {
"user_id": self.user_id,
"user_name": self.user.name,
"date_create": self.date_create,
"action": self.action,
}
class News(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
news_date = db.Column(
db.DateTime,
nullable=False,
default=pytz.timezone('America/Los_Angeles').localize(
datetime.datetime.now()))
image_file = db.Column(db.String(20))
content = db.Column(db.Text, nullable=False)
def __repr__(self):
return f"News('{self.title}', '{self.news_date}')"
class Measurement(db.Model):
__tablename__ = 'Sensor_data'
sensor_id = db.Column('sensor_ID',
db.Integer,
primary_key=True,
nullable=False)
data = db.Column('data', db.ARRAY(db.Integer), nullable=False)
sequence_id = db.Column('sequence_ID', db.Integer)
timestamp = db.Column('timestamp',
db.DateTime,
nullable=False,
default=datetime.utcnow,
primary_key=True)
data_type = db.Column('data_type', db.SmallInteger)
def __repr__(self):
return f'<Measurement :: sensor_id={self.sensor_id}, sequence_id={self.sequence_id}>'
class ToolDTO(db.Model):
__tablename__ = 'tool'
tool_id = db.Column("tool_id",
db.Integer,
primary_key=True,
autoincrement=True)
name = db.Column(db.String(50), nullable=False)
image = db.Column(db.String(500), nullable=True)
description = db.Column(db.String(500), nullable=True)
quantity = db.Column(db.Integer, default=0)
status = db.Column(db.String(20), nullable=True)
is_deleted = db.Column(db.Boolean(), default=0)
def serialize(self):
return {
"tool_id": self.tool_id,
"name": self.name,
"image": self.image,
"description": self.description,
"quantity": self.quantity,
"status": self.status,
}
def merge(self, newdata):
for key, value in newdata.items():
if value:
setattr(self, key, value)
class Users(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column('id',
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
firstName = db.Column('first_name', db.String(50), nullable=False)
lastName = db.Column('last_name', db.String(50), nullable=False)
email = db.Column('email', db.String(50), nullable=False)
passHash = db.Column('pass_hash', db.String(60), nullable=False)
accountConfirmed = db.Column('account_confirmed',
db.String(1),
nullable=False,
default='F')
dateAdded = db.Column('date_added',
db.String(10),
default=datetime.now().strftime("%m_%d_%Y"))
def __init__(self, firstName, lastName, email, passHash):
self.firstName = firstName
self.lastName = lastName
self.email = email
self.passHash = passHash
def __repr__(self):
return f"User('{self.id}', '{self.firstName}', '{self.lastName}',"\
f"'{self.email}', '{self.dateAdded}')"
class Reservation(db.Model):
id = db.Column(db.Integer, primary_key=True)
res_date = db.Column(db.DateTime, nullable=False)
res_moment = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
is_started = db.Column(db.Boolean(), nullable=False, default=False)
owner_id = db.Column(db.Integer, db.ForeignKey('setup.id'), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def se(self): # se:Student Enviroment Starter
start_time = self.res_date
duration = Setup.query.filter_by(
id=self.owner_id).first().period_of_res
token = User.query.filter_by(id=self.user_id).first().password_sha1
setup = Setup.query.filter_by(id=self.owner_id).first()
port = self.owner_id + 8800
self.bash_file(token, setup.id, port)
duration = int(duration)
end_time = start_time + timedelta(minutes=duration)
left = end_time - datetime.now()
proc = subprocess.Popen([
'gnome-terminal', '--disable-factory', '--', 'bash',
'setup{}.sh'.format(setup.id)
],
preexec_fn=os.setpgrp)
o_e_id = Setup.query.filter_by(id=self.owner_id).first().owner_id
self.cp_materials(o_e_id, setup.id)
print(f'New student enviroment ready for {setup.name}!')
time.sleep(int(left.seconds) - 10)
print(f'{setup.name} is closing')
os.killpg(proc.pid, signal.SIGINT)
os.remove(f'setup{setup.id}.sh')
print(f'{setup.name} has closed')
@staticmethod
def bash_file(token, setup_id, port):
ip_adress = ip_find()
text = []
text.append('#!/bin/bash\n')
text.append('\n')
text.append('sudo su - setup{} <<EOF\n'.format(setup_id))
text.append('rm -rf *\n')
text.append(
"jupyter notebook --no-browser --NotebookApp.token='' --NotebookApp.password={0} --ip {1} --port {2} --NotebookApp.terminals_enabled=False\n"
.format(token, ip_adress, port))
text.append('EOF\n')
with open('setup{}.sh'.format(setup_id), 'w') as f:
f.writelines(text)
@staticmethod
def cp_materials(o_e_id, setup_id):
time.sleep(3) #If no delay put, materials delete in the subprocess
mtrls = Experiment.query.filter_by(id=o_e_id).first().materials.all()
for m in mtrls:
os.system(f'sudo cp uploads/{m.name} /home/setup{setup_id}/')
return
def __repr__(self):
return f"Reservation('{self.res_date}','{self.owner_id}','{self.user_id}')"
class TribulationDTO(db.Model):
__tablename__ = 'tribulation'
tribulation_id = db.Column(db.Integer,
primary_key=True,
autoincrement=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(500), nullable=True)
address = db.Column(db.String(200), nullable=True)
time_start = db.Column(db.DateTime, default=datetime.utcnow)
time_end = db.Column(db.DateTime, default=datetime.utcnow)
times = db.Column(db.Integer, default=1)
url_file = db.Column(db.String(200), nullable=True)
actor = db.relationship(ActorDTO,
secondary='character',
backref="tribulation")
tool = db.relationship(ToolDTO,
secondary='tool_for_tribulation',
backref="tribulation")
is_deleted = db.Column(db.Boolean(), default=0)
def serialize(self):
actor = [a.serialize() for a in self.actor]
tool = [t.serialize() for t in self.tool]
time_start = self.time_start.strftime("%Y-%m-%d")
time_end = self.time_end.strftime("%Y-%m-%d")
return {
"tribulation_id": self.tribulation_id,
"name": self.name,
"description": self.description,
"address": self.address,
"time_start": time_start,
"time_end": time_end,
"times": self.times,
"url_file": self.url_file,
"actor": actor,
"tool": tool
}
def merge(self, newdata):
for key, value in newdata.items():
if key != "_sa_instance_state":
print('va: ', value)
setattr(self, key, value)
class Setup(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
period_of_res = db.Column(db.Integer, nullable=False)
max_res_for_week = db.Column(db.Integer,
nullable=False) #Currently not in use
is_virtual = db.Column(db.Boolean(), nullable=False, default=False)
product_id = db.Column(db.String(150), nullable=False)
product_serial = db.Column(db.String(150), unique=True, nullable=False)
owner_id = db.Column(db.Integer,
db.ForeignKey('experiment.id'),
nullable=False)
reservations = db.relationship('Reservation',
backref='owner',
lazy='dynamic')
def setup_user_creator(self):
os.system(
f'sudo useradd -m -d /home/setup{self.id} -s /bin/bash setup{self.id}'
)
os.system(f'sudo chown -R setup{self.id} /home/setup{self.id}')
os.system(f'sudo chmod -R 750 /home/setup{self.id}')
if self.is_virtual:
os.system(f'sudo usermod -a -G dialout setup{self.id}')
return
self.rule_file(self.product_id, self.product_serial, self.id)
os.system(f'sudo cp 99-setup{self.id}.rules /etc/udev/rules.d/')
os.system(f'sudo udevadm control --reload-rules && udevadm trigger')
os.remove(f'99-setup{self.id}.rules')
def setup_user_delete(self):
if not self.is_virtual:
os.system(f'sudo rm /etc/udev/rules.d/99-setup{self.id}.rules')
os.system(f'sudo userdel -r setup{self.id}')
@staticmethod
def rule_file(product_id, product_serial, setup_id):
text = []
text.append(
f'SUBSYSTEM=="tty", ATTRS{{idProduct}}=="{product_id}", ATTRS{{serial}}=="{product_serial}", ACTION=="add", RUN+="/bin/setfacl -m u:setup{setup_id}:rw- /dev/$name"'
)
with open(f'99-setup{setup_id}.rules', 'w') as f:
f.writelines(text)
def __repr__(self):
return f"Setup('{self.name}','{self.period_of_res}','{self.max_res_for_week}','{self.owner_id}')"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
plays = db.Column(db.Integer, default=0)
url = db.Column(db.String(140))
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
def __repr__(self):
return "\n{} - https://www.youtube.com/watch?v={}\n".format(
self.body, self.url)
def get_plays(self):
return self.plays
def increment_play_count(self):
self.plays += 1
return
def delete_all():
posts = Post.get_posts()
for post in posts:
db.session.delete(post)
db.session.commit()
return redirect(url_for("index"))
def delete(id):
post = Post.get_post(id)
db.session.delete(post)
db.session.commit()
return
def create(url, body):
post = Post(user_id=current_user.id, url=url, body=body)
db.session.add(post)
db.session.commit()
return
def update(id, url, body):
post = Post.get_post(id)
post.url = url
post.body = body
db.session.add(post)
db.session.commit()
return
def get_post(id):
return Post.query.get_or_404(id)
def get_posts():
return Post.query.order_by(Post.id).all()
class User(db.Model):
__tablename__ = 'user'
__table_args__ = {'extend_existing': True}
name = db.Column(db.String(80), nullable=False)
id = db.Column(db.Integer, primary_key=True)
password = db.Column(db.String(80), nullable=True, default=id)
user_name = db.Column(db.String(80), nullable=True, default=name)
title = db.Column(db.String(80))
user_creator = db.Column(db.Boolean, default=True)
def get_password(self):
return self.password
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
password_sha1 = db.Column(db.String(120), nullable=False)
is_admin = db.Column(db.Boolean(), nullable=False, default=False)
reservations = db.relationship('Reservation',
backref='owner_student',
lazy='dynamic')
classes = db.relationship(
'Course',
secondary=subs,
backref=db.backref('students_of_class',
lazy='dynamic')) #Currently not in use
def __repr__(self):
return f"User('{self.username}','{self.email}')"
class Audition(db.Model):
id = db.Column(db.Integer, primary_key=True)
score = db.Column(db.Float)
scale = db.Column(db.String(64), index=False, unique=False)
key = db.Column(db.String(64), index=False, unique=False)
is_completed = db.Column(db.Boolean, default=False)
auditioner = db.Column(db.String(64), index=False, unique=False)
auditionee = db.Column(db.String(64), index=False, unique=False)
def complete(self):
self.is_completed = True
db.session.commit()
def set_score(self, score):
self.score = score
db.session.commit()
def get_score(self):
return self.score
def get_scale(self):
return self.scale
def get_key(self):
return self.key
def get_auditioner(self):
return self.auditioner
def get_ID(self):
return self.id
def get_auditionee(self):
return self.auditionee
def get_complete(self):
return self.is_completed
class Recording(db.Model):
id = db.Column(db.Integer, primary_key=True)
score = db.Column(db.Float)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
scale = db.Column(db.String(64), index=False, unique=False)
key = db.Column(db.String(64), index=False, unique=False)
def get_score(self):
return self.score
def __repr__(self):
return '<recording {}>'.format(self.score)
def info(self):
return (str(self.timestamp), str(self.score))
def get_scale(self):
return str(scale)
def get_key(self):
return str(key)
