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 User(db.Model): id = db.Column('uid', db.Integer, primary_key=True) name = db.Column('name', db.String(100)) # TODO unique email = db.Column('email', db.String(100), unique=True) # TODO add passwords def __init__(self, name, email): self.name = name self.email = email @staticmethod def is_valid_email(email): # TODO can be improved by making it a single sql query done = db.session.query(User.email).filter(User.email==email).scalar() print(email, done) exists = done is not None return exists @staticmethod def check_valid_emails(emails): valid = [] for email in emails: valid.append(User.is_valid_email(email)) return valid @staticmethod def get_similar_users(search): results = User.query.filter(User.email.like(search) | User.name.like(search)).all() return results
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(32), index=True) password_hash = db.Column(db.String(64)) def hash_password(self, password): self.password_hash = pwd_context.encrypt(password) def verify_password(self, password): return pwd_context.verify(password, self.password_hash) 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
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 Mall(db.Model): id = db.Column(db.Integer, primary_key=True) Name = db.Column(db.String(100), unique=True) City = db.Column(db.String(100)) District = db.Column(db.String(100)) def __repr__(self): return f'< {self.Name} >'
class Album(db.Model): __tablename__ = "album" album_id = db.Column(db.Integer, primary_key=True) artist = db.Column(db.String(64)) title = db.Column(db.String(128)) image_url = db.Column(db.String(255)) last_edited_at = db.Column(db.DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow)
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 Role(Base, RoleMixin): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80), nullable=False, unique=True) description = db.Column(db.String(255)) def __init__(self, name, desc): self.name = name self.description = desc def __repr__(self): return '<Role %r -- %r>' % (self.name, self.description)
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 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 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 Book(db.Model): __tablename__ = 'books' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(255), nullable=False) author_id = db.Column(db.Integer, db.ForeignKey('authors.id'), nullable=False) genre_id = db.Column(db.Integer, db.ForeignKey('genres.id')) year_of_writing = db.Column(db.String(255)) pages = db.Column(db.String(255)) publish_house_id = db.Column(db.Integer, db.ForeignKey('publish_houses.id')) def __repr__(self): return self.title
class ContactForm(db.Model): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(120), unique=False) name = db.Column(db.String(120)) message = db.column(db.String(5000)) def __init__(self, email, name, message): self.email = email self.name = name self.message = message def __repr__(self): return f'{self.name}\n{self.email}\n{self.message}'
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 UserModel(BaseModel): __modelname__ = "User" __tablename__ = "users" first_name = db.Column(db.String(255), nullable=False) last_name = db.Column(db.String(255)) username = db.Column(db.String(100), nullable=False, unique=True) password_hash = db.Column(db.String(150), nullable=False) role_id = db.Column(db.Integer, db.ForeignKey("roles.id")) @classmethod def get_username(cls, username): return cls.query.filter_by(username=username).first() @property def fullname(self): return f"{self.first_name} {self.last_name}" def can(self, permission): return self.role is not None and \ (self.role.permission and permission) == True def is_admin(self): return self.can(Permission.ADMINISTRATOR) @property def password(self): raise AttributeError('`password` is not a readable attribute') @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) # { # "sub": 1 #userid, # "role": "User", # "groups": ["corecommerce:lead", "travel:member"], # "iat": "23/12/1995", # "exp": "29/30/1998" # } # @jwt_required # @jwt_role("Administrator") # @jwt_any_roles(["User", "Administrator"])
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 BlacklistedTokenModel(db.Model): __tablename__ = "blacklisted_tokens" id = db.Column(db.Integer, primary_key=True, autoincrement=True) token = db.Column(db.String(255), unique=True, nullable=False) blackisted_at = db.Column(db.DateTime, nullable=False) def __repr__(self): return (f"<{self.__class__.__name__}(token={self.token})>") @classmethod def get(cls, token): return cls.query.filter_by(token=token).first() def save(self): self.blackisted_at = current_datetime() db.session.add(self) db.session.commit() @staticmethod def check(token): result = BlacklistedTokenModel.get(token) if result: return True return False
class User(db.Model): """ This will be the User class and will hold information regarding user accounts. """ id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(120), unique=True) # will not allow the same username twice user_email = db.Column( db.String(120), unique=True ) # will not allow a user to register twice with the same email address pwd_hash = db.Column(db.String(300)) def __init__(self, username, user_email, password): self.username = username self.user_email = user_email self.pwd_hash = make_pw_hash(password) def __repr__(self): return f'{self.username}'
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 User(BaseModel, db.Model): """Model for users table""" __tablename__ = "users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) username = db.Column(db.String(128), nullable=False) email = db.Column(db.String(128), nullable=False) password = db.Column(db.String(128), nullable=False) active = db.Column(db.Boolean(), default=True, nullable=False) # using func.now(), so time is calculated by the DB server and not by server server. # https://stackoverflow.com/questions/13370317/sqlalchemy-default-datetime?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa created_date = db.Column(db.DateTime, nullable=False, default=func.now()) def __init__(self, username, email, password): super().__init__() self.username = username self.email = email self.password = password
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 GroupModel(db.Model): __modelname__ = "Group" __tablename__ = "groups" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(50)) @property def leader(self): return GroupModel.query.filter( GroupModel.members.has(is_lead=True)).first()
class ContentElement(BaseModel, db.Model): """Model for content elements table""" __tablename__ = "contentelement" id = db.Column(db.Integer, primary_key=True, autoincrement=True, nullable=False) uuid = db.Column(db.String(128), nullable=True) documentID = db.Column(db.Integer, db.ForeignKey('document.id'), nullable=True) contentType = db.Column(db.String(16), nullable=True) content = db.Column(db.String(), nullable=True) def __init__(self, uuid, documentID, contentType, content): super().__init__() self.uuid = uuid self.documentID = documentID self.contentType = contentType self.content = content
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 RevokedTokenModel(db.Model): __tablename__ = 'revoked_tokens' id = db.Column(db.Integer, primary_key=True) jTokenId = db.Column(db.String(120)) def add(self): db.session.add(self) db.session.commit() @classmethod def is_jti_blacklisted(cls, jTokenId): query = cls.query.filter_by(jTokenId=jTokenId).first() return bool(query)
class Tag (BaseModel, db.Model): """Model for movies table""" __tablename__ = "frametag" id = db.Column(db.Integer, primary_key=True, autoincrement=True, nullable=False) movieID = db.Column(db.Integer, db.ForeignKey('movies.id'), nullable=True) fn = db.Column(db.Integer, nullable=True) tag = db.Column(db.String(16), nullable=True) def __init__(self, movieID, fn, tag): super().__init__() self.movieID = movieID self.fn = fn self.tag = tag
class Timezones(db.Model): id = db.Column(db.Integer, primary_key=True, nullable=False) name = db.Column(db.String(64), nullable=False) t_offset = db.Column(db.Integer, nullable=False) def __init__(self, id, name, offset): self.id = id self.name = name self.t_offset = offset def to_dict(self): return dict(id=self.id, timezone_name=self.name, timezone_offset=self.t_offset)
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 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