Ejemplo n.º 1
0
class UserRoles(DB.Model):
    """Связующая сущность между пользователями и их ролями"""
    __tablename__ = 'user_roles'

    id = DB.Column(DB.Integer, primary_key=True)
    user_id = DB.Column(DB.Integer, DB.ForeignKey('user.id', ondelete='CASCADE'))
    role_id = DB.Column(DB.Integer, DB.ForeignKey('role.id', ondelete='CASCADE'))

    def __repr__(self):
        return "UserRoles(id={id}, name={name}, user_id={user_id})". \
            format(id=self.id, name=self.name, user_id=self.user_id)
Ejemplo n.º 2
0
class FluModelGoogleTerm(DB.Model):  # pylint: disable=too-few-public-methods
    """
    ORM Model representing a link table between FluModel and GoogleTerm
    """

    flu_model_id = DB.Column(DB.Integer, DB.ForeignKey('model.id'), primary_key=True)
    google_term_id = DB.Column(DB.Integer, DB.ForeignKey('google_term.id'), primary_key=True)

    def save(self):
        """ Convenience method to save current instance """
        DB.session.add(self)
        DB.session.commit()
Ejemplo n.º 3
0
class Message(DB.Model):
    __tablename__ = "messages"

    id = DB.Column(DB.Integer, primary_key=True)
    dt = DB.Column(DB.DateTime, nullable=False)
    text = DB.Column(DB.String(500), nullable=False)
    sender_id = DB.Column(DB.Integer,
                          DB.ForeignKey("users.id"),
                          nullable=False)
    sender_username = DB.Column(DB.String(32),
                                DB.ForeignKey("users.username"),
                                nullable=False)
    receiver_id = DB.Column(DB.Integer,
                            DB.ForeignKey("users.id"),
                            nullable=False)
    receiver_username = DB.Column(DB.String(32),
                                  DB.ForeignKey("users.username"),
                                  nullable=False)
    chat_id = DB.Column(DB.Integer, DB.ForeignKey("chats.id"), nullable=False)
    chat = DB.relationship(
        "Chat",
        backref=DB.backref("messages", cascade="all, delete-orphan"),
        lazy="joined",
    )

    def __init__(self, text, sender_id, sender_username, receiver_id,
                 receiver_username, chat_id):
        self.dt = datetime.utcnow()
        self.text = text
        self.sender_id = sender_id
        self.sender_username = sender_username
        self.receiver_id = receiver_id
        self.receiver_username = receiver_username
        self.chat_id = chat_id

    def __repr__(self):
        return "<Message %r>" % self.message

    def to_dict(self):
        return {
            "id": self.id,
            "dt": self.dt.strftime('%Y-%m-%d %H:%M:%S'),
            "text": self.text,
            "sender_id": self.sender_id,
            "sender_username": self.sender_username,
            "receiver_id": self.receiver_id,
            "receiver_username": self.receiver_username,
            "chat_id": self.chat_id,
        }
Ejemplo n.º 4
0
class Message(DB.Model):
    __tablename__ = 'messages'

    id = DB.Column(DB.Integer, primary_key=True)
    dt = DB.Column(DB.DateTime, nullable=False)
    text = DB.Column(DB.String(500), nullable=False)
    sender_id = DB.Column(DB.Integer,
                          DB.ForeignKey('users.id'),
                          nullable=False)
    sender_username = DB.Column(DB.String(32),
                                DB.ForeignKey('users.username'),
                                nullable=False)
    receiver_id = DB.Column(DB.Integer,
                            DB.ForeignKey('users.id'),
                            nullable=False)
    receiver_username = DB.Column(DB.String(32),
                                  DB.ForeignKey('users.username'),
                                  nullable=False)
    chat_id = DB.Column(DB.Integer, DB.ForeignKey('chats.id'), nullable=False)
    chat = DB.relationship('Chat',
                           backref=DB.backref('messages',
                                              cascade="all, delete-orphan"),
                           lazy='joined')

    def __init__(self, text, sender_id, sender_username, receiver_id,
                 receiver_username, chat_id):
        self.dt = datetime.utcnow()
        self.text = text
        self.sender_id = sender_id
        self.sender_username = sender_username
        self.receiver_id = receiver_id
        self.receiver_username = receiver_username
        self.chat_id = chat_id

    def __repr__(self):
        return '<Message %r>' % self.message

    def to_dict(self):
        return {
            'id': self.id,
            'dt': self.dt.isoformat(),
            'text': self.text,
            'sender_id': self.sender_id,
            'sender_username': self.sender_username,
            'receiver_id': self.receiver_id,
            'receiver_username': self.receiver_username,
            'chat_id': self.chat_id
        }
Ejemplo n.º 5
0
class TeachingLessonAndCurriculumUnit(DB.Model):
    """Класс для связующей сущности между единицами учебного плана и учебного занятия"""
    __tablename__ = 'teaching_lesson_and_curriculum_unit'

    teaching_lesson_id = DB.Column(
        DB.Integer, DB.ForeignKey('curriculum_unit.curriculum_unit_id'), primary_key=True
    )
    curriculum_unit_id = DB.Column(
        DB.Integer, DB.ForeignKey('teaching_lesson.teaching_lesson_id'), primary_key=True
    )

    def __repr__(self):
        return "TeachingLessonAndCurriculumUnit(teaching_lesson_id={teaching_lesson_id}," \
               " curriculum_unit_id={curriculum_unit_id})" \
            .format(teaching_lesson_id=self.teaching_lesson_id,
                    curriculum_unit_id=self.curriculum_unit_id)
Ejemplo n.º 6
0
class Student(DB.Model, _ObjectWithFullName):
    """Класс для сущности 'Студент'"""
    __tablename__ = 'student'

    id = DB.Column('student_id', DB.BIGINT, primary_key=True)
    surname = DB.Column('student_surname', DB.String(45), nullable=False)
    firstname = DB.Column('student_firstname', DB.String(45), nullable=False)
    middlename = DB.Column('student_middlename', DB.String(45))
    stud_group_id = DB.Column(DB.ForeignKey(
        'stud_group.stud_group_id', ondelete='SET NULL', onupdate='SET NULL'
    ), index=True)
    semester = DB.Column('student_semestr', DB.SMALLINT)
    alumnus_year = DB.Column('student_alumnus_year', DB.SMALLINT)
    expelled_year = DB.Column('student_expelled_year', DB.SMALLINT)

    def __repr__(self):
        return "Student(id={id}," \
               " surname={surname}," \
               " firstname={firstname}," \
               " middlename={middlename}," \
               " stud_group_id={stud_group_id}," \
               " semester={semester}," \
               " alumnus_year={alumnus_year}," \
               " expelled_year={expelled_year})". \
            format(id=self.id,
                   surname=self.surname,
                   firstname=self.firstname,
                   middlename=self.middlename,
                   stud_group_id=self.stud_group_id,
                   semester=self.semester,
                   alumnus_year=self.alumnus_year,
                   expelled_year=self.expelled_year)
Ejemplo n.º 7
0
class RunToSamples(db.Model):
    """
    Model for database table that maps SequencingRuns to Sample IDs
    and Project IDs. For now, the Project IDs and Sample IDs are stored
    as strings (VARCHAR), in case the Project associated with the Run
    does not exist in the database yet.
    """
    id = db.Column(db.Integer, primary_key=True)
    sequencing_run_id = db.Column(db.Integer, db.ForeignKey('sequencing_run.id'))
    sample_id = db.Column(db.VARCHAR(512), default=None)
    project_id = db.Column(db.VARCHAR(50), default=None)

    def to_dict(self):
        return {
            'id': self.id,
            'sequencing_run_id': self.sequencing_run_id,
            'sample_id': self.sample_id,
            'project_id': self.project_id
        }

    def from_dict(self, data):
        for field in data:
            setattr(self, field, data[field])

    def __repr__(self):
        return ('<RunToSamples mapping with SequencingRun {}, Sample ID {},'
                ' and Project ID {}>'.format(self.sequencing_run_id, self.sample_id,
                                             self.project_id))
Ejemplo n.º 8
0
class JokeReaction(DB.Model):
    """jokes reactions model"""
    __tablename__ = 'joke_reaction'
    id = DB.Column(DB.Integer, primary_key=True)
    joke_id = DB.Column(DB.Integer, DB.ForeignKey('joke.id'))
    reaction_type = DB.Column(Enum(ReactionsType))
    created_at = DB.Column(TIMESTAMP, default=datetime.utcnow, nullable=False)
Ejemplo n.º 9
0
class ShoppingList(DB.Model):
    """Create a shopping list table"""

    __tablename__ = "shoppinglists"

    list_id = DB.Column(DB.Integer, primary_key=True)
    listname = DB.Column(DB.String(50))
    shoppingitems = DB.relationship('ShoppingItems',
                                    backref='ShoppingItems.item_id',
                                    cascade="all, delete-orphan")
    created_by = DB.Column(DB.Integer, DB.ForeignKey(User.user_id))

    def __init__(self, listname, created_by):
        """ initilization """
        self.listname = listname
        self.created_by = created_by

    def save(self):
        """ stores list to database """
        DB.session.add(self)
        DB.session.commit()

    @staticmethod
    def get_all():
        """ get all shopping lists """
        return ShoppingList.query.all()

    def delete(self):
        """ deletes shopping list """
        DB.session.delete(self)
        DB.session.commit()

    def __repr__(self):
        return "<ShoppingList: {}>".format(self.listname)
Ejemplo n.º 10
0
Archivo: models.py Proyecto: Teahaf/ZI
class Server(DB.Model):
    """Server model."""
    __tablename__ = 'server'

    id = DB.Column(DB.Integer, primary_key=True)
    name = DB.Column(DB.String)
    path = DB.Column(DB.String)
    hash = DB.Column(DB.String)
    user_id = DB.Column(DB.Integer, DB.ForeignKey("users.id"))
    data_size = DB.Column(DB.Integer)

    def __init__(self, name, path, hash, data_size, user_id):
        self.name = name
        self.path = path
        self.hash = hash
        self.data_size = data_size
        self.user_id = user_id

    def create(cls, name, path, hash, data_size, user_id):
        server = Server(name, path, hash, data_size, user_id)
        DB.session.add(server)
        DB.session.commit()
        DB.session.refresh(server)
        return server

    def to_dict(self):
        my_dict = {}
        my_dict["id"] = self.id
        my_dict["name"] = self.name
        my_dict["path"] = self.path
        my_dict["hash"] = self.hash
        my_dict["data_size"] = self.data_size
        my_dict["user_id"] = self.user_id
        return my_dict
Ejemplo n.º 11
0
class Attendance(DB.Model):
    """Класс для сущности 'Посещаемость'"""
    __tablename__ = 'attendance'
    __table_args__ = (
        DB.ForeignKeyConstraint(['attendance_teaching_lesson_id', 'attendance_curriculum_unit_id'],
                                ['teaching_lesson_and_curriculum_unit.teaching_lesson_id',
                                 'teaching_lesson_and_curriculum_unit.curriculum_unit_id']),
    )

    attendance_teaching_lesson_id = DB.Column(DB.Integer, primary_key=True, autoincrement=True)
    attendance_curriculum_unit_id = DB.Column(DB.Integer, primary_key=True, autoincrement=True)

    lesson_attendance = DB.Column(DB.Boolean, nullable=False)
    lesson_date = DB.Column(DB.Date, nullable=False)
    student_id = DB.Column(DB.BigInteger, DB.ForeignKey('student.student_id'), nullable=False)

    def __repr__(self):
        return "Attendance(attendance_teaching_lesson_id={attendance_teaching_lesson_id}," \
               " attendance_curriculum_unit_id={attendance_curriculum_unit_id}," \
               " lesson_attendance={lesson_attendance}," \
               " lesson_date={lesson_date}, student_id={student_id})". \
            format(attendance_teaching_lesson_id=self.attendance_teaching_lesson_id,
                   attendance_curriculum_unit_id=self.attendance_curriculum_unit_id,
                   lesson_attendance=self.lesson_attendance,
                   lesson_date=self.lesson_date,
                   student_id=self.student_id)
Ejemplo n.º 12
0
class GoogleDate(DB.Model):
    """
    ORM Model representing the date for which a complete set of Google terms for a particular model
    ID was retrieved. The date here stored assumes the scores for a set of Google terms as a
    transaction and should always be added to the session together with the set of GoogleScores.
    """

    id = DB.Column(DB.Integer, primary_key=True)
    flu_model_id = DB.Column(DB.Integer, DB.ForeignKey('model.id'))
    transaction_timestamp = DB.Column(DB.DateTime, default=DB.func.current_timestamp())
    score_date = DB.Column(DB.Date)

    def __init__(self, model_id: int, score_date: date):
        self.flu_model_id = model_id
        self.score_date = score_date

    def save(self):
        """ Convenience method to save current instance """
        DB.session.add(self)
        DB.session.commit()

    def __repr__(self):
        return '<GoogleDate model_id=%d %s>' % (
            self.flu_model_id, self.score_date.strftime('%Y-%m-%d')
        )
Ejemplo n.º 13
0
class Todo(DB.Model):
    ''' Initialize Todo Table with person_Id/Todo/StartDate/DueDate Columns '''
    id = DB.Column(DB.Integer, primary_key=True)
    person_id = DB.Column(DB.Integer, DB.ForeignKey('person.id'))
    todo = DB.Column(DB.String(255), nullable=False)
    start_todo = DB.Column(DB.DateTime, default=start_date_new)
    due_date = DB.Column(DB.DateTime, default=end_date_new)
Ejemplo n.º 14
0
class Account(DB.Model):
    id = DB.Column(DB.Integer, primary_key=True, autoincrement=True)
    org_id = DB.Column(DB.Integer, DB.ForeignKey("org.id"), nullable=False)
    name = DB.Column(DB.String(128))
    code = DB.Column(DB.String(128))

    def __repr__(self):
        return "%s - %s" % (self.code, self.name)
Ejemplo n.º 15
0
class NoteModel(DB.Model):
    __tablename__ = "notes"
    id = DB.Column(DB.String(), primary_key=True)
    lifegroup = DB.Column(DB.String(20), DB.ForeignKey('lifegroups.name', ondelete='CASCADE'), nullable=False)
    text = DB.Column(DB.String(), nullable=False)

    def __repr__(self):
        return '<Note %r>' % self.id
Ejemplo n.º 16
0
class Chat(DB.Model):
    __tablename__ = "chats"

    id = DB.Column(DB.Integer, primary_key=True)
    dt = DB.Column(DB.DateTime, nullable=False)
    user1_id = DB.Column(DB.Integer, DB.ForeignKey("users.id"), nullable=False)
    user1_name = DB.Column(
        DB.String(32), DB.ForeignKey("users.username"), nullable=False
    )
    user1_sk_sym = DB.Column(DB.String(500), nullable=False)
    user2_id = DB.Column(DB.Integer, DB.ForeignKey("users.id"), nullable=False)
    user2_name = DB.Column(
        DB.String(32), DB.ForeignKey("users.username"), nullable=False
    )
    user2_sk_sym = DB.Column(DB.String(500), nullable=False)
    last_message_dt = DB.Column(DB.DateTime, nullable=False)

    def __init__(
        self, user1_id, user1_name, user1_sk_sym, user2_id, user2_name, user2_sk_sym
    ):
        self.dt = datetime.utcnow()
        self.user1_id = user1_id
        self.user1_name = user1_name
        self.user1_sk_sym = user1_sk_sym
        self.user2_id = user2_id
        self.user2_name = user2_name
        self.user2_sk_sym = user2_sk_sym
        self.last_message_dt = datetime.utcnow()

    def __repr__(self):
        return "<Chat %r>" % self.id

    def to_dict(self):
        return {
            "id": self.id,
            "dt": self.dt.strftime('%Y-%m-%d %H:%M:%S'),
            "user1_id": self.user1_id,
            "user1_name": self.user1_name,
            "user1_sk_sym": self.user1_sk_sym,
            "user2_id": self.user2_id,
            "user2_name": self.user2_name,
            "user2_sk_sym": self.user2_sk_sym,
            "last_message_dt": self.last_message_dt.strftime('%Y-%m-%d %H:%M:%S'),
        }
Ejemplo n.º 17
0
class DefaultFluModel(DB.Model):  # pylint: disable=too-few-public-methods
    """
    ORM Model to define the default public model to be returned by the API
    """

    id = DB.Column(DB.Integer, primary_key=True)
    flu_model_id = DB.Column(DB.Integer, DB.ForeignKey('model.id'))

    def __repr__(self):
        return '<DefaultFluModel %d>' % self.flu_model_id
Ejemplo n.º 18
0
class Dataset(DB.Model):# pylint: disable=R0903
    """
    Subsets model for SQL database
    """
    __tablename__ = 'dataset'

    id = DB.Column(DB.Integer, primary_key=True, autoincrement=True)
    included_rows = DB.Column(DB.ARRAY(DB.String), nullable=True)
    date = DB.Column(DB.DateTime, nullable=False, default=datetime.utcnow)
    file_id = DB.Column(DB.Integer, DB.ForeignKey('file.id', ondelete="CASCADE"))
    user_id = DB.Column(DB.Integer, DB.ForeignKey('users.id'))
    filter_id = DB.Column(DB.Integer, DB.ForeignKey('filter.id'), nullable=True)

    def __init__(self, file_id, user_id, included_rows=None, filter_id=None):
        self.date = datetime.utcnow()
        self.included_rows = included_rows
        self.file_id = file_id
        self.filter_id = filter_id
        self.user_id = user_id
Ejemplo n.º 19
0
class MemberModel(DB.Model):
    __tablename__ = "members"
    id = DB.Column(DB.String(), primary_key=True)
    lifegroup = DB.Column(DB.String(),
                          DB.ForeignKey('lifegroups.name', ondelete='CASCADE'))
    name = DB.Column(DB.String(), nullable=False)
    seats = DB.Column(DB.Integer(), default=0)
    suburb = DB.Column(DB.String(), nullable=False)

    def __repr__(self):
        return '<Member %r>' % self.name
Ejemplo n.º 20
0
class Group(Base):

    __tablename__ = 'auth_group'

    name = DB.Column(DB.String(128), nullable=False, unique=True)
    initials = DB.Column(DB.String(10), nullable=False, unique=True)
    parent_id = DB.Column(DB.Integer,
                          DB.ForeignKey('auth_group.id'),
                          nullable=True)
    children = DB.relationship('Group', lazy="joined", join_depth=2)
    roles = DB.relationship('Role',
                            secondary=ROLES,
                            backref=DB.backref('groups'))
Ejemplo n.º 21
0
class Chat(DB.Model):
    __tablename__ = 'chats'

    id = DB.Column(DB.Integer, primary_key=True)
    dt = DB.Column(DB.DateTime, nullable=False)
    user1_id = DB.Column(DB.Integer, DB.ForeignKey('users.id'), nullable=False)
    user1_name = DB.Column(DB.String(32), DB.ForeignKey('users.username'), nullable=False)
    user1_sk_sym = DB.Column(DB.String(500), nullable=False)
    user2_id = DB.Column(DB.Integer, DB.ForeignKey('users.id'), nullable=False)
    user2_name = DB.Column(DB.String(32), DB.ForeignKey('users.username'), nullable=False)
    user2_sk_sym = DB.Column(DB.String(500), nullable=False)
    last_message_dt = DB.Column(DB.DateTime, nullable=False)

    def __init__(self, user1_id, user1_name, user1_sk_sym, user2_id, user2_name, user2_sk_sym):
        self.dt = datetime.utcnow()
        self.user1_id = user1_id
        self.user1_name = user1_name
        self.user1_sk_sym = user1_sk_sym
        self.user2_id = user2_id
        self.user2_name = user2_name
        self.user2_sk_sym = user2_sk_sym
        self.last_message_dt = datetime.utcnow()


    def __repr__(self):
        return '<Chat %r>' % self.id

    def to_dict(self):
        return {
            'id': self.id,
            'dt': self.dt.isoformat(),
            'user1_id': self.user1_id,
            'user1_name': self.user1_name,
            'user1_sk_sym': self.user1_sk_sym,
            'user2_id': self.user2_id,
            'user2_name': self.user2_name,
            'user2_sk_sym': self.user2_sk_sym,
            'last_message_dt': self.last_message_dt.isoformat()
        }
Ejemplo n.º 22
0
class CurriculumUnit(DB.Model):
    """Класс для сущности 'Единица учебного плана'"""
    __tablename__ = 'curriculum_unit'
    __table_args__ = (
        DB.UniqueConstraint('subject_id', 'stud_group_id'),
    )

    id = DB.Column('curriculum_unit_id', DB.INTEGER, primary_key=True, autoincrement=True)
    subject_id = DB.Column(DB.ForeignKey('subject.subject_id'), nullable=False, index=True)
    stud_group_id = DB.Column(DB.ForeignKey('stud_group.stud_group_id'), nullable=False, index=True)
    teacher_id = DB.Column(DB.ForeignKey('teacher.teacher_id'), nullable=False, index=True)
    mark_type = DB.Column('mark_type', DB.Enum(MarkType), nullable=False)
    hours_att_1 = DB.Column('hours_att_1', DB.SMALLINT, nullable=False)
    hours_att_2 = DB.Column('hours_att_2', DB.SMALLINT, nullable=False)
    hours_att_3 = DB.Column('hours_att_3', DB.SMALLINT, nullable=False)

    subject = DB.relationship('Subject')
    teacher = DB.relationship('Teacher')
    att_marks = DB.relationship('AttMark', lazy=True, backref='curriculum_unit')
    teaching_lessons = DB.relationship(
        'TeachingLesson', secondary='teaching_lesson_and_curriculum_unit'
    )

    def __repr__(self):
        return "CurriculumUnit(id={id}, subject_id={subject_id}, stud_group_id={stud_group_id}," \
               " teacher_id={teacher_id}," \
               " mark_type={mark_type}, hours_att_1={hours_att_1}," \
               " hours_att_2={hours_att_2}," \
               " hours_att_3={hours_att_3})" \
            .format(id=self.id,
                    subject_id=self.subject_id,
                    stud_group_id=self.stud_group_id,
                    teacher_id=self.teacher_id,
                    mark_type=self.mark_type,
                    hours_att_1=self.hours_att_1,
                    hours_att_2=self.hours_att_2,
                    hours_att_3=self.hours_att_3)
Ejemplo n.º 23
0
class User(Base):

    __tablename__ = 'auth_user'

    # User Name
    name = DB.Column(DB.String(200), nullable=False)

    # Identification Data: email & password
    email = DB.Column(EmailType, nullable=False, unique=True)
    password = DB.Column(PasswordType(
        # The returned dictionary is forwarded to the CryptContext
        onload=lambda **kwargs: dict(schemes=PS, **kwargs)
    ), nullable=False)
    group_id = DB.Column(DB.Integer, DB.ForeignKey('auth_group.id'))
    group = DB.relationship(Group)
Ejemplo n.º 24
0
class AttMark(DB.Model):
    """Класс для сущности 'Аттестационная оценка'"""
    __tablename__ = 'att_mark'
    __table_args__ = (
        DB.UniqueConstraint('curriculum_unit_id', 'student_id'),
    )

    att_mark_id = DB.Column(DB.INTEGER, primary_key=True, autoincrement=True)
    curriculum_unit_id = DB.Column(
        DB.ForeignKey('curriculum_unit.curriculum_unit_id'), nullable=False
    )
    student_id = DB.Column(DB.ForeignKey('student.student_id'), nullable=False, index=True)
    att_mark_1 = DB.Column(DB.SMALLINT)
    att_mark_2 = DB.Column(DB.SMALLINT)
    att_mark_3 = DB.Column(DB.SMALLINT)
    att_mark_exam = DB.Column(DB.SMALLINT)
    att_mark_append_ball = DB.Column(DB.SMALLINT)
    student = DB.relationship('Student')

    def __repr__(self):
        return "AttMark(att_mark_id={att_mark_id}," \
               " curriculum_unit_id={curriculum_unit_id}," \
               " student_id={student_id}," \
               " att_mark_1={att_mark_1}," \
               " att_mark_2={att_mark_2}," \
               " att_mark_3={att_mark_3}," \
               " att_mark_exam={att_mark_exam}," \
               " att_mark_append_ball={att_mark_append_ball})". \
            format(att_mark_id=self.att_mark_id,
                   curriculum_unit_id=self.curriculum_unit_id,
                   student_id=self.student_id,
                   att_mark_1=self.att_mark_1,
                   att_mark_2=self.att_mark_2,
                   att_mark_3=self.att_mark_3,
                   att_mark_exam=self.att_mark_exam,
                   att_mark_append_ball=self.att_mark_append_ball)
Ejemplo n.º 25
0
class Logs(DB.Model):
    id = DB.Column(DB.Integer, primary_key=True)
    msg = DB.Column(DB.String(128))
    timestamp = DB.Column(DB.DateTime, default=datetime.utcnow)
    channel_id = DB.Column(DB.Integer, DB.ForeignKey(Channel.id, ondelete="CASCADE"))

    def __repr__(self):
        return '<Log Message: {}>'.format(self.msg)

    def to_json(self):
        return {
            "Id": self.id,
            "Channel id": self.channel_id,
            "Message": self.msg,
            "Timestamp": self.timestamp.strftime("%H:%M:%S"),
        }
Ejemplo n.º 26
0
class ModelFunction(DB.Model):  # pylint: disable=too-few-public-methods
    """
    ORM Model to define the function used to calculate the model scores
    """

    id = DB.Column(DB.Integer, primary_key=True)
    function_name = DB.Column(DB.String, nullable=False)
    average_window_size = DB.Column(DB.Integer, nullable=False)
    has_confidence_interval = DB.Column(DB.Boolean)

    flu_model_id = DB.Column(DB.Integer, DB.ForeignKey('model.id'))

    def save(self):
        """ Convenience method to save current instance """
        DB.session.add(self)
        DB.session.commit()
Ejemplo n.º 27
0
class Blocks(db.Model):
    classID = db.Column(db.Integer, primary_key=True)
    className = db.Column(db.String(80), unique=False, nullable=False)
    classSection = db.Column(db.String(80), unique=False, nullable=False)
    timeStart = db.Column(db.Time, nullable = False)
    timeEnd = db.Column(db.Time, nullable = False)
    day_of_week = db.Column(db.Integer, nullable=False)
    studentID = db.Column(db.Integer, db.ForeignKey('person.id'))
    def __init__(self, className, classSection,timeStart, timeEnd, day_of_week,studentID):
        self.className = className
        self.classSection = classSection
        self.studentID = studentID
        self.timeStart = timeStart
        self.timeEnd = timeEnd
        self.day_of_week = day_of_week
    def __repr__(self):
        return "<Blocks(className='%s',classSection='%s',timeStart='%s',timeEnd='%s',day_of_week = '%s', studentID='%s')>" % (self.className, self.classSection, self.timeStart, self.timeEnd, self.day_of_week, self.studentID)
Ejemplo n.º 28
0
class TaskList(DB.Model):
    """Creating DB table to store task lists from the past"""
    __tablename__ = 'tasklist'
    id = DB.Column(DB.Integer, primary_key=True, unique=True,
                   nullable=False)  ## primary key
    email = DB.Column(DB.String(80),
                      DB.ForeignKey('person.email'),
                      unique=False,
                      nullable=False)  ## foreign key
    date = DB.Column(
        DB.String(80), unique=False,
        nullable=False)  ## convert date to string in python and store it here
    task = DB.Column(DB.String(400), unique=False, nullable=False)
    completed = DB.Column(DB.Integer, unique=False,
                          nullable=False)  ## 0 = false, 1 = true

    def __repr__(self):
        return '<TaskList %r>' % self.email
Ejemplo n.º 29
0
class Joke(DB.Model):
    """Joke model"""
    id = DB.Column(DB.Integer, primary_key=True)
    joke = DB.Column(DB.Text, index=True)
    joke_length = DB.Column(DB.Integer)
    rank = DB.Column(DB.Float, index=True)
    category_id = DB.Column(DB.Integer, DB.ForeignKey('category.id'))
    reactions = DB.relationship('JokeReaction', backref='joke_reaction', lazy='dynamic')

    def __repr__(self):
        """info about joke"""
        return '<Joke %r>' % (self.id)

    def html_joke(self):
        """from (string) joke --> to (array) joke divided by enters"""
        return self.joke.split('\n')

    def reactions_num(self, reaction_type):
        """number of specific reaction"""
        return self.reactions.filter(JokeReaction.reaction_type == reaction_type).count()

    def all_reactions(self):
        """number of all reactions for specifi joke"""
        return self.reactions.count()

    def order_reactions(self):
        """order reactions"""
        reactions_data = [
            ("unamused", self.reactions_num(ReactionsType.unamused)),
            ("neutral", self.reactions_num(ReactionsType.neutral)),
            ("smile", self.reactions_num(ReactionsType.smile)),
            ("funny", self.reactions_num(ReactionsType.funny))]
        reactions_data = [item for item in reactions_data if item[1] > 0]
        reactions_data = sorted(reactions_data, key=itemgetter(1), reverse=True)
        return reactions_data

    def add_reaction(self, reaction_type):
        """method called after a user made reaction"""
        new_reaction = JokeReaction(joke_id=self.id, reaction_type=reaction_type)
        DB.session.add(new_reaction)
        DB.session.commit()
Ejemplo n.º 30
0
class User(UserMixin, db.Model):
    '''User class definition'''
    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)
    password_hash = db.Column(db.String(128))
    full_name = db.Column(db.String(140))
    last_seen = db.Column(db.DateTime, default=datetime.utcnow)
    level_id = db.Column(db.Integer, db.ForeignKey('user_level.id'))

    def __repr__(self):
        return '<User {}>'.format(self.username)

    def set_password(self, password):
        '''Set user password'''
        self.password_hash = generate_password_hash(password)

    def check_password(self, password):
        '''Check user password'''
        return check_password_hash(self.password_hash, password)

    def get_reset_password_token(self, expires_in=600):
        '''Generate JWT token'''
        return jwt.encode(
            {'reset_password': self.id, 'exp': time() + expires_in},
            current_app.config['SECRET_KEY'], algorithm='HS256').decode('utf-8')

    @staticmethod
    def verify_reset_password_token(token):
        '''Verify JWT token'''
        try:
            jwtresult = jwt.decode(token, current_app.config['SECRET_KEY'], algorithms=['HS256'])['reset_password']
        except jwt.DecodeError:
            return
        return User.query.get(jwtresult)

    def avatar(self, size):
        '''Generate Gravatar link'''
        digest = md5(self.email.lower().encode('utf-8')).hexdigest()
        return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(digest, size)