class Tag(db.Model):
__tablename__ = "tags"
tag_id = db.Column(db.Integer, autoincrement=True, primary_key=True)
gratitude_id = db.Column(db.Integer,
db.ForeignKey('gratitudes.gratitude_id'),
nullable=False)
user_id = db.Column(db.Integer,
db.ForeignKey('users.user_id'),
nullable=False)
gratitude = db.relationship('Gratitude', backref='tags')
user = db.relationship('User', backref="tags")
@classmethod
def add_new_tag(cls, gratitude_id, user_id):
"""Adds new tag to the db. """
tag = Tag(gratitude_id=gratitude_id, user_id=user_id)
db.session.add(tag)
db.session.commit()
return tag
class Transition(db.Model, TimestampMixin):
__tablename__ = 'transitions'
__table_args__ = {'sqlite_autoincrement': True}
id = db.Column(db.BigInteger, primary_key=True)
settlement_id = db.Column(db.BigInteger, db.ForeignKey('settlement.id'), nullable=False)
product_id = db.Column(db.BigInteger, db.ForeignKey('product.id'), nullable=False)
price = db.Column(db.Integer, nullable=False)
class Feedback(db.Model):
"""."""
__tablename__ = "feedback"
feedback_id = db.Column(db.Integer, autoincrement=True, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.user_id'),
nullable=False)
email = db.Column(db.String(255), nullable=False)
addressed = db.Column(db.Boolean, default=False, nullable=False)
category_id = db.Column(db.Integer,
db.ForeignKey('feedback_categories.category_id'),
nullable=False)
new_vendor_name = db.Column(db.String(32))
new_program_name = db.Column(db.String(32))
outgoing_name = db.Column(db.String(32))
receiving_name = db.Column(db.String(32))
new_numerator = db.Column(db.Integer)
new_denominator = db.Column(db.Integer)
feedback = db.Column(db.Text, nullable=False)
user = db.relationship('User', backref=db.backref('feedback'))
user = db.relationship('FeedbackCategory', backref=db.backref('feedback'))
def __repr__(self):
"""Provide helpful representation when printed."""
return "<from {}: {}>".format(
self.email,
self.feedback,
)
class Vote(Base):
account_id = db.Column(db.Integer,
db.ForeignKey('account.id'),
nullable=True)
issue_id = db.Column(db.Integer, db.ForeignKey('issue.id'), nullable=True)
cast = db.Column(db.Boolean)
class TransactionHistory(db.Model):
"""Transactions that impact program balance."""
__tablename__ = "transaction_history"
transaction_id = db.Column(db.Integer, autoincrement=True, primary_key=True)
action_id = db.Column(db.Integer, db.ForeignKey('actions.action_id'), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.user_id'), nullable=False)
program_id = db.Column(db.Integer, db.ForeignKey('programs.program_id'), nullable=False)
beginning_balance = db.Column(db.Integer, nullable=False)
ending_balance = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
user = db.relationship('User', backref=db.backref('transaction_history'))
program = db.relationship('Program', backref=db.backref('transaction_history'))
action = db.relationship('Action', backref=db.backref('transaction_history'))
def __repr__(self):
"""Provide helpful representation when printed."""
return "<{} |user: {} |program: {} | beg: {} end: {} | {}>".format(self.transaction_id,
self.user_id,
self.program_id,
self.beginning_balance,
self.ending_balance,
self.created_at,
)
class Comment(db.Model):
"""Class for user comments on gratitudes."""
__tablename__ = "comments"
comment_id = db.Column(db.Integer, autoincrement=True, primary_key=True)
text = db.Column(db.Text, nullable=False)
gratitude_id = db.Column(db.Integer,
db.ForeignKey('gratitudes.gratitude_id'),
nullable=False)
user_id = db.Column(db.Integer,
db.ForeignKey('users.user_id'),
nullable=False)
gratitude = db.relationship('Gratitude', backref='comments')
user = db.relationship('User', backref='users')
@classmethod
def add_new_comment(cls, text, gratitude_id, user_id):
"""Adds new comment to the db."""
comment = Comment(text=text,
gratitude_id=gratitude_id,
user_id=user_id)
db.session.add(comment)
db.session.commit()
return comment
class Question(Base):
text = db.Column(db.String(128), nullable=False)
issue_id = db.Column(db.Integer, db.ForeignKey('issue.id'), nullable=True)
answer_id = db.Column(db.Integer, db.ForeignKey('answer.id'), nullable=True)
options = db.relationship("Option")
responses = db.relationship("Response")
class Answer(Base):
text = db.Column(db.String(128), nullable=False)
# currently one-to-one with question, possibly should be many-to-many with question?
issue_id = db.Column(db.Integer, db.ForeignKey('issue.id'), nullable=True)
option_id = db.Column(db.Integer,
db.ForeignKey('option.id'),
nullable=True)
class GradoAsignatura(db.Model):
id = db.Column(db.Integer, primary_key=True)
grado_id = db.Column(db.Integer, db.ForeignKey("grado.id"), nullable=False)
asignatura_id = db.Column(db.Integer,
db.ForeignKey("asignatura.id"),
nullable=False)
def __init__(self, grado_id, asignatura_id):
self.grado_id = grado_id
self.asignatura_id = asignatura_id
class FoundQR(db.Model):
""" a qrcode found by a team """
team_id = db.Column(db.Integer, db.ForeignKey('team.id'), primary_key=True)
qr_id = db.Column(db.String, db.ForeignKey('qr_code.id'), primary_key=True)
qr = db.relationship('QRCode',
backref=db.backref('teams', cascade='all, delete'))
def __repr__(self):
return f'<FoundQR {self.team.name} found {self.qr}>'
class Response(Base):
question_id = db.Column(db.Integer,
db.ForeignKey('question.id'),
nullable=True)
option_id = db.Column(db.Integer,
db.ForeignKey('option.id'),
nullable=True)
account_id = db.Column(db.Integer,
db.ForeignKey('account.id'),
nullable=True)
class Collection(db.Model):
__tablename__ = 'collections'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
attraction_id = db.Column(db.Integer, db.ForeignKey('attractions.id'), nullable=False)
def __init__(self, user_id, attraction_id):
self.user_id = user_id
self.attraction_id = attraction_id
class Task(Base):
issue_id = db.Column(db.Integer, db.ForeignKey('issue.id'), nullable=True)
# account which has taken responsibility for the task.
account_id = db.Column(db.Integer,
db.ForeignKey('account.id'),
nullable=True)
# Front end should
text = db.Column(db.String(1000), nullable=False)
date_created = db.Column(db.DateTime, default=db.func.current_timestamp())
due_date = db.Column(db.DateTime, nullable=False)
class Curso(db.Model):
id = db.Column(db.Integer, primary_key=True)
jornada_id = db.Column(db.Integer,
db.ForeignKey("jornada.id"),
nullable=False)
grado_id = db.Column(db.Integer, db.ForeignKey("grado.id"), nullable=False)
letra = db.Column(db.String(1), nullable=False)
def __init__(self, jornada_id, grado_id, letra):
self.grado_id = grado_id
self.jornada_id = jornada_id
self.letra = letra
class Connection(db.Model):
"""Class for Connections; like an association table for Users to Users relationships?"""
__tablename__ = "connections"
connection_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
follower_user_id = db.Column(db.Integer, db.ForeignKey('users.user_id'))
following_user_id = db.Column(db.Integer, db.ForeignKey('users.user_id'))
def __repr__(self):
return "<Connection ID: {}, Follower: {}, Following: {}>".format(
self.connection_id,
self.follower_user_id,
self.following_user_id,
)
@classmethod
def add_connection_to_db(cls, follower_user_id, following_user_id):
"""Given the follower and following user ids, adds connection to db."""
try:
connection = Connection.query.filter_by(
follower_user_id=follower_user_id,
following_user_id=following_user_id,
).one()
flash("You're already following that user!")
except NoResultFound:
connection = Connection(
follower_user_id=follower_user_id,
following_user_id=following_user_id,
)
db.session.add(connection)
db.session.commit()
print "Added new connection object to the db."
following = User.query.get(following_user_id)
flash("You're now following {} {}".format(following.first_name,
following.last_name))
@classmethod
def delete_connection(cls, follower_user_id, following_user_id):
"""Delete a connection between users."""
try:
connection = Connection.query.filter_by(
follower_user_id=follower_user_id,
following_user_id=following_user_id,
).one()
db.session.delete(connection)
db.session.commit()
except NoResultFound:
print "That connection was not in the db."
class Profesor(db.Model):
id = db.Column(db.Integer, primary_key=True)
usuario_id = db.Column(db.Integer,
db.ForeignKey("usuario.id"),
nullable=True)
jornada_id = db.Column(db.Integer,
db.ForeignKey("jornada.id"),
nullable=False)
def __init__(self, usuario_id, jornada_id):
self.usuario_id = usuario_id
self.jornada_id = jornada_id
class AsignaturaProfesor(db.Model):
id = db.Column(db.Integer, primary_key=True)
grado_asignatura_id = db.Column(db.Integer,
db.ForeignKey("grado_asignatura.id"),
nullable=False)
profesor_id = db.Column(db.Integer,
db.ForeignKey("profesor.id"),
nullable=False)
def __init__(self, grado_asignatura_id, profesor_id):
self.grado_asignatura_id = grado_asignatura_id
self.profesor_id = profesor_id
class BloqueJornada(db.Model):
id = db.Column(db.Integer, primary_key=True)
bloque_id = db.Column(db.Integer,
db.ForeignKey("bloque.id"),
nullable=False)
jornada_id = db.Column(db.Integer,
db.ForeignKey("jornada.id"),
nullable=False)
def __init__(self, bloque_id, jornada_id):
self.bloque_id = bloque_id
self.jornada_id = jornada_id
class Comment(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
repliee_id = db.Column(db.Integer, index=True)
time = db.Column(db.DateTime)
content = db.Column(db.Text)
replier_id = db.Column(db.Integer, db.ForeignKey('users.id'))
video_id = db.Column(db.Integer, db.ForeignKey('videos.id'))
def __repr__(self):
return '<Comment %r>' % self.content
class ShadowDimension(Dimension):
id = db.Column(db.Integer, db.ForeignKey(Dimension.id), primary_key=True)
__tablename__ = 'shadow_dimension'
__mapper_args__ = {'polymorphic_identity': __tablename__}
_referenced_object_id = db.Column(db.Integer,
db.ForeignKey(ConcreteDimension.id))
_referenced_object = db.relationship(ConcreteDimension,
foreign_keys=[_referenced_object_id],
backref='copies')
shadow = True
def __init__(self, dimension, **kwargs):
self._referenced_object = dimension
super(ShadowDimension, self).__init__(**kwargs)
for question in dimension.questions:
if not isinstance(question, ConcreteQuestion):
question = question.concrete
s_question = ShadowQuestion(question)
self.questions.append(s_question)
@property
def concrete_id(self):
if self._referenced_object is None:
return None
return self._referenced_object.id
@property
def concrete(self):
if self._referenced_object is None:
return None
return self._referenced_object
@property
def reference_id(self):
return self._referenced_object.reference_id
@property
def original_language(self) -> BabelLanguage:
return self._referenced_object.original_language
@property
def name(self) -> str:
return self._referenced_object.name
@property
def name_translations(self) -> Dict[str, str]:
return self._referenced_object.name_translations
class Picture(db.Model):
team_id = db.Column(db.Integer, db.ForeignKey('team.id'), primary_key=True)
objective_id = db.Column(db.Integer,
db.ForeignKey('objective.id'),
primary_key=True)
filename = db.Column(db.String, nullable=False)
status = db.Column(db.Integer, nullable=False)
objective = db.relationship('Objective',
backref=db.backref('teams',
cascade='all, delete'))
def __repr__(self):
return f'<Picture for {self.objective} by {self.team.name}, status={self.status}>'
class PropertyUpdatedTrackerEntry(TrackerEntry):
"""
Stores the old and new values for a property of a certain
survey item. Also stores a href to that item as well as the name of the
item.
"""
id = db.Column(db.Integer,
db.ForeignKey(TrackerEntry.id, ondelete='CASCADE'),
primary_key=True)
# polymorphic config
__tablename__ = 'property_updated_tracker_entry'
__mapper_args__ = {'polymorphic_identity': __tablename__}
# columns
item_name = db.Column(db.String(50))
property_name = db.Column(db.String(50))
_values = db.Column(MUTABLE_HSTORE)
# foreign keys
item_id = db.Column(
db.Integer,
db.ForeignKey('survey_base.id', onupdate='CASCADE',
ondelete='CASCADE'))
# relationships
item = db.relationship('SurveyBase',
uselist=False,
foreign_keys=[item_id],
backref=backref('property_updated_tracker_entries',
cascade='all, delete'))
def __init__(self, dataclient: DataClient, item_name: str,
item: 'SurveyBase', property_name, previous_value, new_value,
**kwargs):
super(PropertyUpdatedTrackerEntry, self).__init__(dataclient, **kwargs)
self.item_name = ellipse(item_name, 50)
self.item = item
self.property_name = ellipse(property_name, 50)
self._values = {'previous': str(previous_value), 'new': str(new_value)}
@property
def previous_value(self):
return self._values['previous']
@property
def new_value(self):
return self._values['new']
class BookCopy(db.Model):
book_copy_id = db.Column(db.Integer, primary_key=True)
book_id = db.Column(db.Integer,
db.ForeignKey('book.book_id'),
nullable=False)
is_checked_out = db.Column(db.Boolean, nullable=False, default=False)
def __repr__(self):
return (
"<BookCopy(book_copy_id='%s',book_id='%s',is_checked_out='%s'>" %
(self.book_copy_id, self.book_id, self.is_checked_out))
def to_dict(self):
"""
Method to convert a book copy to a python dictionary data object
:return: dict
"""
print('Book Copy to_dict')
copy_dict = {
'book_copy_id': self.book_copy_id,
'book_id': self.book_id,
'is_checked_out': self.is_checked_out,
}
return copy_dict
def update(self, **kwargs):
"""
Method to update a book copy's attributes
:param kwargs: A dict of valid key-value pairs
:return: None
"""
print('BookCopy.update()')
for key, value in kwargs.items():
setattr(self, key, value)
class Gratitude(db.Model):
"""Creating class for gratitude entries."""
__tablename__ = "gratitudes"
gratitude_id = db.Column(db.Integer, autoincrement=True, primary_key=True)
text = db.Column(db.Text, nullable=False)
entry_id = db.Column(db.Integer,
db.ForeignKey('entries.entry_id'),
nullable=False)
entry = db.relationship('Entry', backref='gratitudes')
@classmethod
def add_new_gratitude(cls, text, entry_id):
"""Adds new gratitude to the db. """
gratitude = Gratitude(text=text, entry_id=entry_id)
db.session.add(gratitude)
db.session.commit()
return gratitude
@classmethod
def get_gratitudes_by_entry(cls, entry_id):
"""Returns all gratitudes associated with a given entry."""
return Gratitude.query.filter_by(entry_id=entry_id).all()
class Booking(db.Model):
__tablename__ = 'bookings'
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.String(50), nullable=False)
time = db.Column(db.String(50), nullable=False)
price = db.Column(db.Integer, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
attraction_id = db.Column(db.Integer, db.ForeignKey('attractions.id'), nullable=False)
def __init__(self, date, time, price, user_id, attraction_id):
self.date = date
self.time = time
self.price = price
self.user_id = user_id
self.attraction_id = attraction_id
class Note(db.Model):
note_title = db.Column(db.String, primary_key=True)
note = db.Column(db.String, nullable=False)
book_id = db.Column(db.Integer,
db.ForeignKey('book.book_id'),
nullable=False)
def __repr__(self):
return '<Note %r : %r %r>' % (self.note_title, self.note, self.book_id)
def to_dict(self):
"""
Method to convert a Note object to a dict object representation
:return: dict representation of a Note
"""
a_dict = {
'note_title': self.note_title,
'note': self.note,
'book_id': self.book_id
}
return a_dict
def update(self, **kwargs):
"""
Method to update a Note's attributes
:param kwargs: A dict of valid key-value pairs
:return: None
"""
for key, value in kwargs.items():
setattr(self, key, value)
class Note(db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(60), nullable=False)
notebook_id = db.Column(db.Integer,
db.ForeignKey("notebook.id"),
nullable=False)
notebook = db.relationship("Notebook", back_populates="notes")
class ConcreteDimension(Dimension):
id = db.Column(db.Integer, db.ForeignKey(Dimension.id), primary_key=True)
__tablename__ = 'concrete_dimension'
__mapper_args__ = {'polymorphic_identity': __tablename__}
# columns
name_translations = db.Column(MUTABLE_HSTORE)
name = translation_hybrid(name_translations)
original_language = db.Column(db.Enum(BabelLanguage), nullable=False)
shadow = False
def __init__(self, name: str, **kwargs):
self.original_language = g._language
super(ConcreteDimension, self).__init__(name=name, **kwargs)
self.reference_id = SurveyBase.generate_reference_id(self)
@staticmethod
def from_shadow(shadow):
d = ConcreteDimension("")
d.name_translations = shadow.name_translations
d.original_language = shadow.original_language
d.randomize_question_order = shadow.randomize_question_order
d.owners = shadow.owners
d.reference_id = shadow.reference_id
for s_question in shadow.questions:
c_question = ConcreteQuestion.from_shadow(s_question)
d.questions.append(c_question)
return d
class ItemAddedTrackerEntry(TrackerEntry):
"""
TrackerEntry that indicates that a new item has been added to a survey.
"""
id = db.Column(db.Integer,
db.ForeignKey(TrackerEntry.id, ondelete='CASCADE'),
primary_key=True)
# polymorphic config
__tablename__ = 'item_added_tracker_entry'
__mapper_args__ = {'polymorphic_identity': __tablename__}
# columns
parent_item_name = db.Column(db.String(50))
added_item_name = db.Column(db.String(50))
# foreign keys
parent_item_id = db.Column(
db.Integer,
db.ForeignKey('survey_base.id', onupdate='CASCADE',
ondelete='CASCADE'))
added_item_id = db.Column(
db.Integer,
db.ForeignKey('survey_base.id', onupdate='CASCADE',
ondelete='CASCADE'))
# relationships
parent_item = db.relationship('SurveyBase',
uselist=False,
foreign_keys=[parent_item_id],
backref=backref(
'item_added_parent_tracker_entries',
cascade='all, delete'))
added_item = db.relationship('SurveyBase',
uselist=False,
foreign_keys=[added_item_id],
backref=backref('item_added_tracker_entries',
cascade='all, delete'))
def __init__(self, dataclient, parent_item_name: str,
parent_item: 'SurveyBase', added_item_name: str,
added_item: 'SurveyBase', **kwargs):
super(ItemAddedTrackerEntry, self).__init__(dataclient, **kwargs)
self.parent_item_name = ellipse(parent_item_name, 50)
self.added_item_name = ellipse(added_item_name, 50)
self.parent_item = parent_item
self.added_item = added_item
class Settlement(db.Model, TimestampMixin):
__tablename__ = 'settlement'
__table_args__ = {'sqlite_autoincrement': True}
id = db.Column(db.BigInteger, primary_key=True)
gift_code_id = db.Column(db.BigInteger,
db.ForeignKey('gift_code.id'),
nullable=False)
transition = db.relationship('Transition')
