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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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)
class CharacterDTO(db.Model): __tablename__ = 'character' character_name = db.Column(db.String(80), nullable = False) actor_id = db.Column(db.Integer, db.ForeignKey('actor.actor_id'), primary_key = True) tribulation_id = db.Column(db.Integer, db.ForeignKey('tribulation.tribulation_id'), primary_key = True)
class User(UserMixin, db.Model): """ The User database object model. The Flask-Login extension expects that the class used to represent users implements the following properties and methods: a. is_authenticated - This property should return True if the user is authenticated, i.e. they have provided valid credentials. (Only authenticated users will fulfill the criteria of login_required.) b. is_active - This property should return True if this is an active user - in addition to being authenticated, they also have activated their account, not been suspended, or any condition your application has for rejecting an account. Inactive accounts may not log in (without being forced of course). c. is_anonymous - This property should return True if this is an anonymous user. (Actual users should return False instead.) d. get_id() - This method must return a unicode that uniquely identifies this user, and can be used to load the user from the user_loader callback. Note that this must be a unicode - if the ID is natively an int or some other type, you will need to convert it to unicode. e. These are inherited from the [`UserMixin`](https://flask-login.readthedocs.io/en/latest/#flask_login.UserMixin) class. f. [`db.Model`](https://flask-sqlalchemy.palletsprojects.com/en/2.x/api/#models) q 1. What does db.relationship() do? That function returns a new property that can do multiple things. In this case we told it to point to the Post class and load multiple of those. How does it know that this will return more than one post? Because SQLAlchemy guesses a useful default from your declaration. If you would want to have a one-to-one relationship you can pass uselist=False to relationship() (this would create a one-to-one relationship). """ 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) about_me = db.Column(db.String(140)) last_seen = db.Column(db.DateTime, default=datetime.utcnow) password_hash = db.Column(db.String(128)) poster = db.Column(db.Boolean, unique=False, default=False) posts = db.relationship("Post", backref="author", lazy="dynamic") followed = db.relationship( "User", secondary=followers, primaryjoin=(followers.c.follower_id == id), secondaryjoin=(followers.c.followed_id == id), backref=db.backref("followers", lazy="dynamic"), lazy="dynamic", ) def __repr__(self): return "<User {}>".format(self.username) def set_poster(self, status): self.poster = status def is_poster(self): return self.poster 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 avatar(self, size): digest = md5(self.email.lower().encode("utf-8")).hexdigest() return "https://www.gravatar.com/avatar/{}?d=identicon&s={}".format( digest, size) def follow(self, user): if not self.is_following(user): self.followed.append(user) def unfollow(self, user): if self.is_following(user): self.followed.remove(user) def is_following(self, user): return self.followed.filter( followers.c.followed_id == user.id).count() == 1 def followers(self): follower_posts = (Post.query.join( followers, (followers.c.follower_id == Post.user_id)).filter( followers.c.followed_id == self.id).all()) return set([ User.query.filter_by(id=post.user_id).first() for post in follower_posts ]) def followed_users(self): followed = (Post.query.join( followers, (followers.c.followed_id == Post.user_id)).filter( followers.c.follower_id == self.id).all()) return set([ User.query.filter_by(id=post.user_id).first() for post in followed ]) def followed_posts(self): followed = Post.query.join( followers, (followers.c.followed_id == Post.user_id)).filter( followers.c.follower_id == self.id) own = Post.query.filter_by(user_id=self.id) return followed.union(own).order_by(Post.timestamp.desc())
class User(UserMixin, db.Model): """ The User database object model. The Flask-Login extension expects that the class used to represent users implements the following properties and methods: a. is_authenticated - This property should return True if the user is authenticated, i.e. they have provided valid credentials. (Only authenticated users will fulfill the criteria of login_required.) b. is_active - This property should return True if this is an active user - in addition to being authenticated, they also have activated their account, not been suspended, or any condition your application has for rejecting an account. Inactive accounts may not log in (without being forced of course). c. is_anonymous - This property should return True if this is an anonymous user. (Actual users should return False instead.) d. get_id() - This method must return a unicode that uniquely identifies this user, and can be used to load the user from the user_loader callback. Note that this must be a unicode - if the ID is natively an int or some other type, you will need to convert it to unicode. e. These are inherited from the [`UserMixin`](https://flask-login.readthedocs.io/en/latest/#flask_login.UserMixin) class. f. [`db.Model`](https://flask-sqlalchemy.palletsprojects.com/en/2.x/api/#models) q 1. What does db.relationship() do? That function returns a new property that can do multiple things. In this case we told it to point to the Post class and load multiple of those. How does it know that this will return more than one post? Because SQLAlchemy guesses a useful default from your declaration. If you would want to have a one-to-one relationship you can pass uselist=False to relationship() (this would create a one-to-one relationship). """ 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) about_me = db.Column(db.String(140)) twitter = db.Column(db.String(140)) instagram = db.Column(db.String(140)) github = db.Column(db.String(140)) profile_picture_url = db.Column(db.String(140)) last_seen = db.Column(db.DateTime, default=datetime.utcnow) password_hash = db.Column(db.String(128)) poster = db.Column(db.Boolean, unique=False, default=False) admin = db.Column(db.Boolean, unique=False, default=False) receives_mail = db.Column(db.Boolean, unique=False, default=False) authenticated = db.Column(db.Boolean, unique=False, default=False) posts = db.relationship("Post", backref="author", lazy="dynamic") followed = db.relationship( "User", secondary=followers, primaryjoin=(followers.c.follower_id == id), secondaryjoin=(followers.c.followed_id == id), backref=db.backref("followers", lazy="dynamic"), lazy="dynamic", ) def forgot_password(email): user = User.query.filter_by(email=email).first() rand_string = "".join( random.choice(string.ascii_uppercase + string.digits) for _ in range(10)) user.set_password(rand_string) db.session.add(user) db.session.commit() msg = Message("Your Temporary Password", sender="*****@*****.**", recipients=[email]) msg.body = ( "Your temporary password is: " + rand_string + ".\n Make sure to reset your password when you log back in!") mail.send(msg) return def __repr__(self): return "<User {}>".format(self.username) def set_poster(self, status): self.poster = status return def is_poster(self): return self.poster def set_mail_status(self, status): self.receives_mail = status return def get_mail_status(self): return self.receives_mail def is_admin(self): return self.admin def set_admin(self, status): self.admin = status return 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 avatar(self, size): digest = md5(self.email.lower().encode("utf-8")).hexdigest() return "https://www.gravatar.com/avatar/{}?d=identicon&s={}".format( digest, size) def follow(self, user): if not self.is_following(user): self.followed.append(user) return def unfollow(self, user): if self.is_following(user): self.followed.remove(user) return def is_following(self, user): return self.followed.filter( followers.c.followed_id == user.id).count() == 1 def followers(self): follower_posts = (Post.query.join( followers, (followers.c.follower_id == Post.user_id)).filter( followers.c.followed_id == self.id).all()) return set([ User.query.filter_by(id=post.user_id).first() for post in follower_posts ]) def followed_users(self): followed = (Post.query.join( followers, (followers.c.followed_id == Post.user_id)).filter( followers.c.follower_id == self.id).all()) return set([ User.query.filter_by(id=post.user_id).first() for post in followed ]) def followed_posts(self): followed = Post.query.join( followers, (followers.c.followed_id == Post.user_id)).filter( followers.c.follower_id == self.id) own = Post.query.filter_by(user_id=self.id) return followed.union(own).order_by(Post.timestamp.desc()) def delete_all(): if not current_user.admin: return "There Was An Error!" users = User.get_users() for user in users: if not user.admin: db.session.delete(user) db.session.commit() return def delete(id): user = User.query.get_or_404(id) if not user.admin: db.session.delete(user) db.session.commit() return redirect(url_for("admin")) def get_user(id): return User.query.get_or_404(id) def get_users(): return User.query.order_by(User.username).all() def get_posts(self): return self.posts def get_post(id): return Post.get_post(id) def signed_in(self): return self.authenticated def send_weekly_newsletter(): recipients = User.get_users() recipients_emails = [] post_urls = [] for user in recipients: recipients_emails.append(user.email) if len(user.get_posts().all()) > 0: posts = user.get_posts().all() for post in posts: if (datetime.utcnow() - post.timestamp) > timedelta(days=1): post_urls.append(post) msg = Message( "Joe Damiba's Playlist This Week", sender="*****@*****.**", recipients=recipients_emails, ) msg.body = str(post_urls) mail.send(msg) return