class Product(db.Model): __tablename__ = 'products' id = db.Column(db.Integer, primary_key=True) image_url = db.Column(db.String(255)) price = db.Column(db.DECIMAL) title = db.Column(db.String(255)) description = db.Column(db.Text, default='') ingredients = db.relationship('Flower', secondary=product_flower, lazy='subquery', backref=db.backref('product', lazy=True)) categories = db.relationship('Category', secondary=product_category, lazy='subquery', backref=db.backref('products', lazy=True))
class TrackOut(db.Model): ''' Database Generated Fields ''' id = db.Column(db.Integer, primary_key=True) track_id = db.Column(db.Integer, db.ForeignKey('track.uuid', ondelete='CASCADE')) created_at = db.Column(db.DateTime, default=datetime.utcnow) uuid = db.Column(db.String, default=generate_uuid) ''' Configurable Fields ''' user_id = db.Column(db.Integer) name = db.Column(db.String(1000)) type = db.Column(db.String(50)) settings = db.Column(db.String(1000)) eq = db.relationship("Equalizer", backref=db.backref("eq", passive_deletes=True), lazy='subquery', uselist=False) de = db.relationship("Deesser", backref=db.backref("de", passive_deletes=True), lazy='subquery', uselist=False) co = db.relationship("Compressor", backref=db.backref("co", passive_deletes=True), lazy='subquery', uselist=False) re = db.relationship("Reverb", backref=db.backref("re", passive_deletes=True), lazy='subquery', uselist=False) ''' Wav File Representation ''' path = db.Column(db.String(1000)) file_hash = db.Column(db.LargeBinary, unique=True) def to_dict(self): trackout = { "id": self.id, "uuid": self.uuid, "user_id": self.user_id, "track_id": self.track_id, "created_at": self.created_at, "name": self.name, "type": self.type, "path": self.path, "settings": self.settings } return trackout
class Movie(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(100), unique=True, nullable=False) genre_id = db.Column(db.Integer, db.ForeignKey('genre.id'), nullable=False) genre = db.relationship('Genre', backref=db.backref('movie', lazy=True)) cast = db.relationship('Actor', secondary=movies_actors_association, lazy=True, backref=db.backref('movies', lazy=True)) def __repr__(self): return self.title
class User(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(32), index=True, unique=True) email = db.Column(db.String(120), index=True, unique=True) password_hash = db.Column(db.String(128)) gardens = db.relationship('Garden', secondary=ownership, lazy='dynamic', backref=db.backref('owners', lazy='dynamic')) sensors = db.relationship('Sensor', backref='owner', lazy='dynamic') 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 generate_auth_token(self, expiration=600): s = Serializer(app.config['SECRET_KEY'], expires_in=expiration) return s.dumps({'id': self.id}) @staticmethod def verify_auth_token(token): s = Serializer(app.config['SECRET_KEY']) try: data = s.loads(token) except SignatureExpired: return None # Valid token but expired except BadSignature: return None # Invalid token user = User.query.get(data['id']) return user def __repr__(self): return '<User {}>'.format(self.username)
class DeckSelectedCard(db.AlchemyBase): """Tracks cards selected for use in First Five `is_first_five` means cards that are explicitly included in the First Five. `is_paid_effect` means that the player plans to pay the effect cost for that card in the first round. `tutor_card_id` means that the card in `tutor_card_id` was used to fetch this card, which means that it can functionally be either the First Sixth card and/or a paid effect cost. """ __tablename__ = "deck_selected_card" deck_id = db.Column(db.Integer, db.ForeignKey(Deck.id), nullable=False, primary_key=True) card_id = db.Column(db.Integer, db.ForeignKey(Card.id), nullable=False, primary_key=True) tutor_card_id = db.Column(db.Integer, nullable=False, default=0, primary_key=True) is_first_five = db.Column(db.Boolean, nullable=False, default=False) is_paid_effect = db.Column(db.Boolean, nullable=False, default=False) deck = db.relationship(Deck, backref=db.backref("selected_cards", cascade="all, delete-orphan"))
class Client(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(20), unique=True) id_phone = db.Column(db.Integer, db.ForeignKey('phone.id'), nullable=True) email = db.Column(db.String(50), unique=True) created = db.Column(db.DateTime) # cria uma propriedade # (não faz parte do banco de dados) records = db.relationship( 'Record', # backref='client': um jeito simples de declarar também uma nova propriedade na classe Record # haverá a propriedade record.client para Record backref='client', # Indica quando os dados serão carregados do banco de dados # o lazy='dynamic' retorna um objeto query que pode ser refinado antes de carregar items. lazy='dynamic') # cria uma propriedade que expressa um relacionamento um-para-um (uselist=False) phone = db.relationship('Phone', backref='client', uselist=False) groups = db.relationship('Group', secondary=clients_groups, backref=db.backref('members', lazy='dynamic')) def __init__(self, username, email): self.username = username self.email = email self.created = datetime.now()
class Speaker(db.Model): id = db.Column(db.Integer, primary_key=True) first_name = db.Column(db.String(150), nullable=False) last_name = db.Column(db.String(150), nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) phone = db.Column(db.String(80), unique=True, nullable=True) description = db.Column(db.String(255), nullable=True) company_name = db.Column(db.String(140), nullable=True) job_title = db.Column(db.String(120), nullable=True) speaker_photo = db.Column(db.String(100), default="default.png") website = db.Column(db.String(200)) workshop = db.relationship('Workshop', backref=db.backref('workshop', lazy=True)) def __repr__(self): return f"Speaker {self.firstName} {self.lastName}" def save(self): db.session.add(self) db.session.commit() def delete(self): db.session.delete(self) db.session.commit() def update(self): db.session.commit()
class CapitalCall(db.Model): __tablename__ = 'capitalcall' id = db.Column(db.Integer, primary_key=True, autoincrement=True) date = db.Column(db.DateTime, default=datetime.now(), nullable=False) name = db.Column(db.String(255), nullable=False, unique=True) capital = db.Column(db.Float, nullable=False) # Establish Many-to-Many relationship investments = db.relationship( 'Investment', secondary=FundInvestments, backref=db.backref('capitalcall', lazy='dynamic') ) def __init__(self, name, capital, date=None): self.name = name self.capital = capital if date is not None: self.date = date def to_json(self): return { 'id': self.id, 'name': self.name, 'capital': self.capital, 'date': self.date.strftime('%Y-%m-%d T%H:%M:%S.%f'), 'investments': [i.to_json() for i in self.investments] }
class Fund(db.Model): __tablename__ = 'fund' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(128), nullable=False, unique=True) date = db.Column(db.DateTime, default=datetime.now(), nullable=False) # Establish One-to-Many relationship committments = db.relationship( 'Committment', backref='fund', lazy='dynamic' ) # Establish Many-to-Many relationship investments = db.relationship( 'Investment', secondary=FundInvestments, backref=db.backref('fund', lazy='dynamic') ) def __init__(self, name): self.name = name def to_json(self): return { 'id': self.id, 'name': self.name, 'date': self.date.strftime('%Y-%m-%d T%H:%M:%S.%f'), 'committments': [c.to_json() for c in self.committments], }
class User(db.Model, UserMixin): 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('users', lazy='dynamic')) def __str__(self): return self.email # Create customized model view class class MyModelView(sqla.ModelView): def is_accessible(self): return (current_user.is_active and current_user.is_authenticated and current_user.has_role('superuser')) def _handle_view(self, name, **kwargs): """ Override builtin _handle_view in order to redirect users when a view is not accessible. """ if not self.is_accessible(): if current_user.is_authenticated: # permission denied abort(403) else: # login return redirect(url_for('security.login', next=request.url))
class Lecturer(db.Model): __tablename__ = 'lecturers' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(100)) email = db.Column(db.String(128), index=True) department_id = db.Column(db.Integer, db.ForeignKey('departments.id')) password_hash = db.Column(db.String(128)) assigned_courses = db.relationship('Course', secondary=assigned_courses, backref=db.backref('lecturers_assigned', lazy='dynamic'), lazy='dynamic') created_at = db.Column(db.DateTime, default=datetime.utcnow) def __init__(self, name, email, department_code, password): self.name = name.title() self.email = email self.department = Department.query.filter_by( code=department_code).first() self.password = password @property def to_dict(self): json_lecturer = { 'name': self.name, 'email': self.email, 'department': self.department.code, 'school': self.department.school.code, 'registered_on': arrow.get(self.created_at).for_json(), 'registered_since': arrow.get(self.created_at).humanize(), } return json_lecturer def assign_course(self, course): if not self.is_assigned(course): self.assigned_courses.append(course) def is_assigned(self, course): return self.assigned_courses.filter( assigned_courses.c.course_id == course.id).count() > 0 @property def password(self): raise AttributeError('Sorry mate :|. Read only field') @password.setter def password(self, password): self.password_hash = generate_password_hash(password) def verify_password(self, password): return check_password_hash(self.password_hash, password) def __repr__(self): return f'Lecturer(name={self.name}, email={self.email})' def save(self): db.session.add(self) db.session.commit()
class Tarefa(db.Model): __tablename__ = "tarefa" id = db.Column(db.Integer, primary_key=True, autoincrement=True, nullable=False) titulo = db.Column(db.String(50), nullable=False) descricao = db.Column(db.String(100), nullable=False) data_expiracao = db.Column(db.Date, nullable=False) projeto_id = db.Column(db.Integer, db.ForeignKey(projeto_model.Projeto.id)) projeto = db.relationship(projeto_model.Projeto, backref=db.backref("tarefas", lazy="dynamic"));
class Token(db.Model): id = db.Column(db.Integer, primary_key=True) auth_token = db.Column(db.String(255), nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) user = db.relationship(User, backref=db.backref('token', lazy=True, uselist=False, cascade="all, delete"))
class ApplicantValue(db.Model): __tablename__ = 'applicant_values' id = db.Column(db.Integer, primary_key=True) applicant_id = db.Column(db.Integer, db.ForeignKey('applicants.id')) value_id = db.Column(db.Integer, db.ForeignKey('values.id')) created_at = Column(DateTime(timezone=True), nullable=False, default=datetime.now()) # relationships applicant = db.relationship('Applicant', backref=db.backref( "applicant_values", cascade="all, delete-orphan")) value = db.relationship('Value', backref=db.backref("applicant_values", cascade="all, delete-orphan"))
class Media(db.Model): __tablename__ = 'media' __table_args__ = {'schema': 'multiquestions'} id = db.Column(db.Integer, primary_key=True, nullable=False, unique=True) filetype = db.Column(db.String(32)) data = db.Column(db.LargeBinary) question = db.relationship('Questions', secondary='multiquestions.relationmedia', backref=db.backref('medias', lazy='dynamic'))
class Types(db.Model): __tablename__ = 'types' __table_args__ = {'schema': 'multiquestions'} id = db.Column(db.Integer, primary_key=True, nullable=False, unique=True) type = db.Column(db.String(80), nullable=False) typename = db.Column(db.String(80), nullable=False) question = db.relationship('Questions', secondary='multiquestions.relationtypes', backref=db.backref('types', lazy='dynamic'))
class Show(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(255)) url = db.Column(db.String(255)) start_date = db.Column(db.DateTime) venue_id = db.Column(db.Integer, db.ForeignKey('venue.id')) venue = db.relationship('Venue', db.backref('show', lazy='dynamic')) source_id = db.Column(db.Integer, db.ForeignKey('source.id')) source = db.relationship('Source', db.backref('source', lazy='dynamic')) def __init__(self, title, url, start_date): self.title = title self.url = url self.start_date = start_date def save(self): db.session.add(self) db.session.commit()
class Business(db.Model): """""" __tablename__ = 'businesses' id = db.Column(db.Integer, primary_key=True, index=True) name = db.Column(db.String(100), nullable=False, unique=True) description = db.Column(db.Text, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) location_id = db.Column(db.Integer, db.ForeignKey('locations.id')) categories = db.relationship('Category', secondary=business_category, lazy='subquery', backref=db.backref('businesses', lazy=True)) reviews = db.relationship('Review', backref='business', lazy=True) photo = db.Column(db.String(200)) created_at = db.Column(db.DateTime, default=datetime.utcnow()) updated_at = db.Column(db.DateTime, default=datetime.utcnow()) def create(self): db.session.add(self) db.session.commit() def update(self): db.session.commit() business = Business.query.get(self.id) result = { 'message': 'Business updated successfully.', 'code': 200, 'business': Business.get_business_details(business) } return result def delete(self): db.session.delete(self) db.session.commit() @staticmethod def get_business(id): business = Business.query.get(int(id)) return business @staticmethod def get_business_details(business): categories = [ Category.get_categories_details(c) for c in business.categories ] return {'id': business.id, 'name':business.name, 'description': business.description, 'userId':business.user_id, \ 'locationId':business.location_id, 'categories':categories, 'photo':business.photo} @staticmethod def get_businesses(): businesses = Business.query.all() return businesses def __repr__(self): """""" return '<Business : {0} >'.format(self.name)
class Recipe(db.Model): '''Class to represent recipe table''' __tablename__ = 'recipe' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(120), unique=False, nullable=False) ingredients = db.Column(db.String(250)) description = db.Column(db.Text) cat_id = db.Column(db.Integer, db.ForeignKey('recipe_category.id'), nullable=False) user_id = db.Column(db.Integer, nullable=False) category = db.relationship("RecipeCategory", backref=db.backref( "recipe", cascade="all, delete-orphan")) def __init__(self, name, cat_id, user_id, ingredients=None, description=None): self.name = name self.ingredients = ingredients self.description = description self.cat_id = cat_id self.user_id = user_id def save(self): db.session.add(self) db.session.commit() @staticmethod def update(): db.session.commit() @staticmethod def get_all(): return Recipe.query.all() @staticmethod def get_all_limit_offset(catid, userid, lim): return Recipe.query.filter_by(cat_id=catid, user_id=\ userid).limit(lim).all() @staticmethod def get_all_limit(userid, lim): return Recipe.query.filter_by(user_id=userid).limit(lim).all() def delete(self): db.session.delete(self) db.session.commit() def __repr__(self): return "<Recipe: {}>".format(self.name)
class Transacao(db.Model): __tablename__ = "transacao" id = db.Column(db.Integer, primary_key=True, autoincrement=True, nullable=False) titulo = db.Column(db.String(50), nullable=False) descricao = db.Column(db.String(100), nullable=False) valor = db.Column(db.Float, nullable=False) tipo = db.Column(db.Enum(TipoEnum), nullable=False) data = db.Column(db.Date, nullable=False) conta_id = db.Column(db.Integer, db.ForeignKey("conta.id")) conta = db.relationship("Conta", backref=db.backref("transacoes", lazy="dynamic"))
class User(db.Model): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(180), unique=True, nullable=False) username = db.Column(db.String(80), unique=True, nullable=False) password = db.Column(db.String(120), nullable=False) role_id = db.Column(db.Integer, db.ForeignKey('role.id'), nullable=False) role = db.relationship('Role', backref=db.backref('users', lazy=True)) created_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) def save(self): db.session.add(self) db.session.commit() def delete(self): db.session.delete(self) db.session.commit() #! Delete All @classmethod def delete_all(cls): try: num_rows_deleted = db.session.query(cls).delete() db.session.commit() return {'message': f'{num_rows_deleted} row(s) deleted'} except: return {'message': 'Something went wrong'} def update(self): db.session.commit() @classmethod def find_by_email(cls, email): return cls.query.filter_by(email=email).first() @classmethod def find_by_username(cls, username): return cls.query.filter_by(username=username).first() @staticmethod def generate_hash(password): return generate_password_hash(password) @staticmethod def verify_hash(hashed, password): return check_password_hash(hashed, password) def __repr__(self): return(f"{__class__.__name__} {self.username}")
class DeckDie(db.AlchemyBase): __tablename__ = "deck_die" deck_id = db.Column(db.Integer, db.ForeignKey(Deck.id), nullable=False, primary_key=True) die_flag = db.Column(db.Integer, nullable=False, primary_key=True) count = db.Column(db.SmallInteger, nullable=False) deck = db.relationship(Deck, backref=db.backref("dice", cascade="all, delete-orphan"))
class Task(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255), nullable=False) completed = db.Column(db.Boolean, nullable=False, default=False) created_at = db.Column(db.DateTime, default=datetime.utcnow) updated_at = db.Column(db.DateTime, onupdate=datetime.utcnow) planned_complete_date = db.Column(db.DateTime) completed_at = db.Column(db.DateTime) project_id = db.Column(db.Integer, db.ForeignKey('project.id'), nullable=False) comments = db.relationship('Comment', backref='task', lazy='dynamic') assignees = db.relationship('User', secondary=assignees_for_tasks, backref=db.backref('tasks', lazy='dynamic'), lazy='dynamic' ) def save(self): db.session.add(self) def delete(self): db.session.delete(self) @staticmethod def get_all(): return Task.query.all() def add_assignee(self, assignee): self.assignees.append(assignee) db.session.add(self) def remove_assignee(self, assignee): self.assignees.remove(assignee) db.session.add(self) def update_completed_state(self, old_task_completed): print("Self completed") print(self.completed) print("OG task completed") print(old_task_completed) if self.completed != old_task_completed: print("Got to first if") if self.completed: print("Got to second if") self.completed_at = datetime.utcnow() else: self.completed_at = None return self def __repr__(self): return f'<Task {self.name} | Created at {self.created_at} | {self.completed} | Completed at {self.completed_at}>'
class Tarefa(db.Model): __tablename__ = 'tarefa' id = db.Column(db.Integer, primary_key=True, autoincrement=True) titulo = db.Column(db.String(50), nullable=False) descricao = db.Column(db.String(100), nullable=False) data_expiracao = db.Column(db.Date, nullable=False) #Relacionamento de 1 para n projeto_id = db.Column(db.Integer, db.ForeignKey('projeto.id')) projeto = db.relationship( 'Projeto', backref=db.backref('tarefas', lazy='dynamic')) #projeto_model.Projeto
class Camera(db.Model): id = db.Column(db.Integer, primary_key=True) model = db.Column(db.String(80), nullable=False) iso_min = db.Column(db.Integer, nullable=False) iso_max = db.Column(db.Integer, nullable=False) resolution = db.Column(db.Float, nullable=False) autofocus = db.Column(db.Integer, nullable=False) ois = db.Column(db.Boolean, nullable=False) wr = db.Column(db.Boolean, nullable=False) wifi = db.Column(db.Boolean, nullable=False) weight = db.Column(db.Float, nullable=False) producer_id = db.Column(db.Integer, db.ForeignKey('producer.id'), nullable=False) producer = db.relationship('Producer', backref=db.backref('cameras', lazy=True)) sensor_format_id = db.Column(db.Integer, db.ForeignKey('sensor_format.id'), nullable=False) sensor_format = db.relationship('SensorFormat', backref=db.backref('cameras', lazy=True)) mount_id = db.Column(db.Integer, db.ForeignKey('mount.id'), nullable=False) mount = db.relationship('Mount', backref=db.backref('cameras', lazy=True)) def __init__(self, model, iso_min, iso_max, resolution, autofocus, ois, wr, wifi, weight, producer, sensor_format, mount): self.model = model self.iso_min = iso_min self.iso_max = iso_max self.resolution = resolution self.autofocus = autofocus self.ois = ois self.wr = wr self.wifi = wifi self.weight = weight self.producer = producer self.sensor_format = sensor_format self.mount = mount
class UserRelease(db.AlchemyBase): __tablename__ = "user_release" user_id = db.Column(db.Integer, db.ForeignKey(User.id), nullable=False, primary_key=True, index=True) release_id = db.Column(db.Integer, db.ForeignKey(Release.id), nullable=False, primary_key=True) user = db.relationship(User, backref=db.backref("collection", cascade="all, delete-orphan"))
class Comment(db.Model): __tablename__ = 'comments' id = db.Column(db.Integer, primary_key=True) comment = db.Column(db.String(250), nullable=False) creation_date = db.Column(db.TIMESTAMP, server_default=db.func.current_timestamp(), nullable=False) category_id = db.Column(db.Integer, db.ForeignKey('categories.id', ondelete='CASCADE'), nullable=False) category = db.relationship('Category', backref=db.backref('comments', lazy='dynamic')) def __init__(self, comment, category_id): self.comment = comment self.category_id = category_id
class DeckCard(db.AlchemyBase): __tablename__ = "deck_card" deck_id = db.Column(db.Integer, db.ForeignKey(Deck.id), nullable=False, primary_key=True) card_id = db.Column(db.Integer, db.ForeignKey(Card.id), nullable=False, primary_key=True) count = db.Column(db.SmallInteger, nullable=False) card = db.relationship(Card) deck = db.relationship(Deck, backref=db.backref("cards", cascade="all, delete-orphan"))
class Tags(db.Model): __tablename__ = 'tags' __table_args__ = {'schema': 'multiquestions'} id = db.Column(db.Integer, primary_key=True, nullable=False, unique=True) tagname = db.Column(db.String(80), unique=True, nullable=False) question = db.relationship('Questions', secondary='multiquestions.relationtags', backref=db.backref('tags', lazy='dynamic')) def serialize(self): output = [] for q in self.question: mq = {} mq['uid'] = q.uid output.append(mq) return {'tagname': self.tagname, 'question': output}
class NoteModel(db.Model): id = db.Column(db.Integer, primary_key=True) note = db.Column(db.String(300), unique=False, nullable=False) date = db.Column(db.DateTime, default=datetime.now) author_id = db.Column(db.Integer, db.ForeignKey(UserModel.id)) private = db.Column(db.Boolean(), default=True, server_default="true", nullable=False) archive = db.Column(db.Boolean(), default=False, server_default="false", nullable=False) tags = db.relationship(TagModel, secondary=tags, lazy='subquery', backref=db.backref('notes', lazy=True)) @classmethod def get_all_notes(cls, author, archive): if archive == "all": return NoteModel.query.filter_by(author_id=author.id).all() if archive == "no_archive": return NoteModel.query.filter_by(author_id=author.id, archive=False).all() if archive == "archive": return NoteModel.query.filter_by(author_id=author.id, archive=True).all() @classmethod def get_all_public_notes(cls): return NoteModel.query.filter_by(private=False, archive=False).all() @classmethod def get_notes_filtered_by_tags(cls, tag_name): return NoteModel.query.filter(NoteModel.tags.any(name=tag_name), NoteModel.archive == False).all() def save(self): db.session.add(self) db.session.commit() def delete(self): db.session.delete(self) db.session.commit()