class LanguagesKnown(db.Model): __tablename__ = 'languages_known' id = db.Column(db.Integer, primary_key=True, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) language_id = db.Column(db.Integer, db.ForeignKey('languages.id'), nullable=False) # Relationships user = db.relationship('Users', backref='languages_known') language = db.relationship('Languages', backref='languages_known') def __init__(self, **kwargs): self.id = kwargs.get('id') self.user_id = kwargs.get('user_id') self.language_id = kwargs.get('language_id') def __repr__(self): return '<LanguagesKnown -> id: {}, user_id: {}, language_id: {}'.format( self.id, self.user_id, self.language_id) def to_dict(self): return dict(id=self.id, user_id=self.user_id, language_id=self.language_id)
class GroupMemberModel(db.Model): __modelname__ = "Group Member" __tablename__ = "group_members" group_id = db.Column(db.Integer, db.ForeignKey("groups.id"), primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey("users.id"), primary_key=True) is_lead = db.Column(db.Boolean, default=False, nullable=False) permission = db.Column(db.Integer, default=Permission.READ, nullable=False) group = db.relationship("GroupModel", backref=db.backref( "members", cascade="delete, delete-orphan")) user = db.relationship("UserModel", backref=db.backref("groups_membership", cascade="delete, delete-orphan")) @db.validates('is_lead') def validate_leader(self, key, is_lead): # We can only have one leader in a group if self.team.leader(): raise ValueError(f"{self.group.name} group already have a leader") return is_lead @property def user_role(self): return f"{self.group.name}:{'leader' if self.is_lead else 'member'}"
class Participants(db.Model): __tablename__ = "participants" id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.ForeignKey(User.id)) schedule_id = db.Column(db.ForeignKey(Schedule.schedule_id)) schedule = db.relationship('Schedule', foreign_keys='Participants.schedule_id') participant = db.relationship('User', foreign_keys='Participants.user_id') def __init__(self, schedule_id, user_id): self.schedule_id = schedule_id self.user_id = user_id def commit(self): db.session.add(self) db.session.commit() @staticmethod def clash(startTime, endTime, givenStartTime, givenEndTime): if startTime <= givenStartTime: return endTime >= givenStartTime else: return startTime <= givenEndTime @staticmethod def is_available(email, start_time, end_time, curr_schedule_id=None): """""" user_id = db.session.query( User.id).filter(User.email == email).scalar() print("User ID:", user_id) schedules = db.session.query(Participants.schedule_id).filter( Participants.user_id == user_id).all() print("Schedules:", list(schedules)) clashing = False if schedules is not None: for schedule_id in schedules: if curr_schedule_id is not None and schedule_id[ 0] != curr_schedule_id: schedule = db.session.query(Schedule).filter( Schedule.schedule_id == schedule_id[0]).scalar() if schedule is not None: print('if schedule not none', schedule.start_time, schedule.end_time) clashing = clashing or Participants.clash(schedule.start_time, schedule.end_time,\ start_time, end_time) print(clashing) return (not clashing), user_id @staticmethod def delete_schedule_participants(schedule_id): db.session.query(Participants).filter( Participants.schedule_id == schedule_id).delete() db.session.commit()
class Attendee(db.Model): __tablename__ = 'attendees' id = db.Column(db.Integer, primary_key=True, autoincrement=True) checkin_status = db.Column(db.Integer, default=0) updated_at = db.Column(db.DateTime, default=datetime.datetime.now, onupdate=datetime.datetime.now) scan_value = db.Column(db.String(60), nullable=True) scan_value_others = db.Column(db.Text, nullable=True) name = db.Column(db.String(40)) email = db.Column(db.String(60)) school = db.Column(db.String(100)) # Tags are separated by `;` tags = db.Column(db.Text, default=";") notes = db.Column(db.Text, default="") # 0 for participant, 10 for mentor, 11 for sponsor type = db.Column(db.Integer, default=0) event_id = db.Column(db.Integer, db.ForeignKey('events.id')) event = db.relationship("Event", back_populates="attendees") logs = db.relationship("Log", back_populates="attendee") def __init__(self, event, name, scan_value, email, school, tags=";", checkin_status=0, notes="", type=0, scan_value_others=";"): self.name = name self.scan_value = scan_value self.email = email self.school = school self.type = type self.event = event self.tags = tags self.checkin_status = checkin_status self.notes = notes self.scan_value_others = scan_value_others def as_dict(self): return { c.name: str(getattr(self, c.name)) if getattr(self, c.name) is not None else None for c in self.__table__.columns }
class User(Base, UserMixin): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(120), unique=True, nullable=False, info={'validators': Email()}) password = db.Column( db.String(225), nullable=False, info={ 'validators': Regexp(regex=r'((?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{6,20})', message='Invalid Password Format') }) active = db.Column(db.Boolean()) last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(20)) current_login_ip = db.Column(db.String(20)) login_count = db.Column(db.Integer) roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic')) def __init__(self, *mixed, **kwargs): super(User, self).__init__(*mixed, **kwargs) with app.app_context(): self.password = hash_password(kwargs['password']) def __repr__(self): return '<User %r>' % self.email
class RoleModel(db.Model): __tablename__ = "roles" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(50)) permission = db.Column(db.Integer, default=Permission.GENERAL) users = db.relationship("UserModel", backref="role", lazy=True) def __repr__(self): return '<Role \'%s\'>' % self.name @classmethod def get_default(cls): return cls.query.filter_by(permission=Permission.GENERAL).first() @staticmethod def insert(): roles = { "User": [Permission.GENERAL], "Administrator": [Permission.ADMINISTRATOR] } for r in roles: role = RoleModel.query.filter_by(name=r).first() if not role: role = RoleModel(name=r) role.permission = roles[r][0] db.session.add(role) db.session.commit()
class Ticket(db.Model): __tablename__ = 'tickets' id = db.Column(db.Integer, primary_key=True, unique=True, autoincrement=True) email = db.Column(db.String(), primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey("users.id")) user = db.relationship("User") submitted_at = db.Column(db.DateTime, default=datetime.datetime.now) code = db.Column(db.Text, unique=True) notes = db.Column(db.Text, default="") def __init__(self, email, notes, user, ticketNumber=""): self.email = email self.notes = notes self.user = user self.generateCode() def generateCode(self): self.code = secrets.token_hex(16) def json(self): return { "email": self.email, "code": self.code, "id": self.id, "user": self.user.description, "notes": self.notes }
class Availabilities(db.Model): __tablename__ = 'availabilities' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) day_of_week = db.Column(db.Integer, nullable=False) from_time = db.Column(db.Integer, nullable=False) to_time = db.Column(db.Integer, nullable=False) # Relationships user = db.relationship('Users', backref='availabilities') def __init__(self, user_id, day_of_week, from_time, to_time): self.user_id = user_id self.day_of_week = day_of_week self.from_time = from_time self.to_time = to_time def __repr__(self): return '<Availabilities -> id: {}, user_id: {}, day_of_week: {}, from_time: {}, to_time: {}'.format( self.id, self.user_id, self.day_of_week, self.from_time, self.to_time) def to_dict(self): return dict(id=self.id, user_id=self.user_id, day_of_week=self.day_of_week, from_time=self.from_time, to_time=self.to_time)
class Log(db.Model): __tablename__ = 'logs' id = db.Column(db.Integer, primary_key=True, autoincrement=True) action = db.Column(db.String()) value = db.Column(db.String()) attendee_id = db.Column(db.Integer, db.ForeignKey("attendees.id")) attendee = db.relationship("Attendee") created_at = db.Column(db.DateTime, default=datetime.datetime.now)
class Genre(db.Model): __tablename__ = 'genres' id = db.Column(db.Integer, primary_key=True) genre = db.Column(db.String(255), nullable=False) books = db.relationship('Book', backref='genre') def __repr__(self): return self.genre
class JobGroup(db.Model, CRUDMixin): """ Группа задач """ __tablename__ = 'job_groups' id = db.Column(db.Integer, primary_key=True) jobs = db.relationship('Job', backref='group', lazy='dynamic') def __repr__(self) -> str: return f'JobGroup {self.id}'
class Genre(db.Model): __tablename__ = 'genres' id = db.Column(db.Integer, primary_key=True) genre = db.Column(db.String(255), nullable=False, unique=True) books = db.relationship('Book', backref='genre') creator_id = db.Column(db.Integer, db.ForeignKey('users.id')) def __repr__(self): return self.genre
class Author(db.Model): __tablename__ = 'authors' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255), nullable=False) direction = db.Column(db.String(255)) date_of_birth = db.Column(db.String(255)) books = db.relationship('Book', backref='author') def __repr__(self): return self.name
class Movie(BaseModel, db.Model): """Model for movies table""" __tablename__ = "movies" id = db.Column(db.Integer, primary_key=True, autoincrement=True) uuid = db.Column(db.String(128), nullable=True) name = db.Column(db.String(128), nullable=False) source = db.Column(db.String(128), nullable=False) uri = db.Column(db.String(128), nullable=False) width = db.Column(db.Integer, nullable=True) height = db.Column(db.Integer, nullable=True) numberOfFrames = db.Column(db.Integer, nullable=True) fps = db.Column(db.Float(), default=0.0, nullable=True) stripeStatus = db.Column(db.Float(), default=0.0, nullable=True) cutStatus = db.Column(db.Float(), default=0.0, nullable=True) docStatus = db.Column(db.Float(), default=0.0, nullable=True) hasStripeImage = db.Column(db.Boolean(), default=False, nullable=False) numberOfStripes = db.Column(db.Integer(), default=0, nullable=False) active = db.Column(db.Boolean(), default=True, nullable=False) tags = db.relationship('Tag', backref='movies', lazy=True) def __init__(self, uuid, name, source, uri, active, width, height, numberOfFrames, fps, stripeStatus=0.0, cutStatus=0.0, docStatus=0.0, numberOfStripes=0, tags=[]): super().__init__() self.uuid = uuid self.name = name self.source = source self.uri = uri self.active = active self.width = width self.height = height self.numberOfFrames = numberOfFrames self.fps = fps self.stripeStatus = stripeStatus self.cutStatus = cutStatus self.docStatus = docStatus self.numberOfStripes = numberOfStripes self.tags = tags
class PublishHouse(db.Model): __tablename__ = 'publish_houses' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255), nullable=False) address = db.Column(db.String(255)) phone_num = db.Column(db.String(20)) website = db.Column(db.String(255)) books = db.relationship('Book', backref='publish_house') def __repr__(self): return self.name
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255), nullable=False, unique=True) password_hash = db.Column(db.String(255), nullable=True) created_on = db.Column(db.DateTime(), default=datetime.utcnow) books = db.relationship('Book', backref='creator') authors = db.relationship('Author', backref='creator') genres = db.relationship('Genre', backref='creator') publishers = db.relationship('PublishHouse', backref='creator') def __init__(self, email, password=None): self.email = email if password is not None: self.set_password(password) else: self.password_hash = None 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) @classmethod def authenticate(cls, **kwargs): email = kwargs.get('email') password = kwargs.get('password') if not email or not password: return None user = cls.query.filter_by(email=email).first() if not user or not check_password_hash(user.password_hash, password): return None return user
class Shop(db.Model): id = db.Column(db.Integer, primary_key=True) Type = db.Column(db.String(140)) Name = db.Column(db.String(140), unique=True) malls = db.relationship('Mall', secondary=shops_malls, backref=db.backref( 'shops', lazy='dynamic', )) def __repr__(self): return f'< {self.Name} >'
class Client(db.Model): __tablename__ = 'clients' id = db.Column(db.Integer, primary_key=True, autoincrement=True) user_id = db.Column(db.Integer, db.ForeignKey("users.id")) user = db.relationship("User") token = db.Column(db.String(), primary_key=True, unique=True) token_expired_at = db.Column( db.DateTime, default=lambda _: (datetime.datetime.now() + datetime.timedelta(days=5))) token_created_at = db.Column(db.DateTime, default=datetime.datetime.now) def __init__(self, user, token): self.user = user self.token = token
class RecordTypeModel(db.Model): __modelname__ = "DNS Record Type" __tablename__ = "dns_record_types" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(100), nullable=False, unique=True) value = db.Column(db.Integer) records = db.relationship("RecordModel", backref="rtype", lazy="dynamic") def __repr__(self): return (f"<{self.__class__.__name__}" f"(id={self.id})>" f"(name={self.name})>" f"(value={self.value})" f">") @db.validates("name") def validate_name(self, key, name): name = name.upper() return name @staticmethod def seeding(): RTYPE_AVAILABLES = { "A": dns.rdatatype.A, "CNAME": dns.rdatatype.CNAME, "PTR": dns.rdatatype.PTR, "MX": dns.rdatatype.MX, "TXT": dns.rdatatype.TXT, "SRV": dns.rdatatype.SRV } for rtype in RTYPE_AVAILABLES: record_type = RecordTypeModel.query.filter_by(name=rtype).first() if not record_type: record_type = RecordTypeModel(name=rtype) record_type.value = RTYPE_AVAILABLES[rtype] db.session.add(record_type) db.session.commit() @classmethod def get(cls, rtype): return cls.query.filter_by(name=rtype).first()
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True, autoincrement=True) username = db.Column(db.String(20), unique=True, nullable=False) password = db.Column(db.String(), nullable=False) name = db.Column(db.String(40)) is_admin = db.Column(db.Boolean(), default=False) events = db.relationship("Event", secondary=eventUsers, lazy='dynamic') def __init__(self, username, password, name, is_admin): self.username = username self.password = hash_password(password) self.name = name self.is_admin = is_admin def as_dict(self): return { 'name': self.name, 'id': self.id, 'is_admin': self.is_admin, 'events': [event.id for event in self.events] }
class Event(db.Model): __tablename__ = 'events' # many-to-many relationship with User id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(140), nullable=False) time = db.Column(db.DateTime, nullable=False) # TODO updated_at = db.Column(db.DateTime, default=datetime.datetime.now, onupdate=datetime.datetime.now) attendees = db.relationship("Attendee", back_populates='event') def __init__(self, name, datestring): self.name = name self.time = parser.parse(datestring) def as_dict(self): return { c.name: str(getattr(self, c.name)) if getattr(self, c.name) is not None else None for c in self.__table__.columns }