def test_load_dialect_impl(self, dialect_module, impl):
"""
Should produce the same impl type as Alembic would expect after
inspecing a database
"""
password_type = PasswordType()
assert isinstance(
password_type.load_dialect_impl(dialect_module.dialect()), impl)
def test_load_dialect_impl(self, dialect_module, impl):
"""
Should produce the same impl type as Alembic would expect after
inspecing a database
"""
password_type = PasswordType()
assert isinstance(
password_type.load_dialect_impl(dialect_module.dialect()),
impl
)
class User(UserMixin, Base):
__tablename__ = 'user'
user_id = Column(Integer, primary_key=True, autoincrement=True)
username = Column(String(20), nullable=False)
password = Column(PasswordType(
schemes=['pbkdf2_sha512']
), nullable=False)
class Admin(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(
db.String(64),
unique=True,
nullable=False,
info={'label': "Username"}
)
password = db.Column(
PasswordType(
schemes=['pbkdf2_sha512']
),
nullable=False,
info={'label': "Password"}
)
def __init__(self, username, password):
self.username = username
self.password = password
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return unicode(self.id)
def __repr__(self):
return '<Admin \'%s\'>' % self.username
class User(Base):
__tablename__ = 'user'
id = Column(Integer, primary_key=True)
username = Column('username', String, unique=True)
password = Column(PasswordType(schemes=['pbkdf2_sha512']))
email = Column('email', String, nullable=True)
tokens = relationship("Token", backref="user")
def __init__(self, username, password, email=None):
self.username = username
self.password = password
self.email = email
@validates('username')
def validate_username(self, key, username):
if re.match(r"^[A-Za-z0-9_]+$", username) is None:
raise InvalidUsernameError
return username
@validates('email')
def validate_email(self, key, email):
if email and re.match(r"[^@]+@[^@]+\.[^@]+", email) is None:
raise InvalidEmailError
return email
class Users(Base):
__tablename__ = 'Users'
id = Column(Integer, primary_key=True)
first_name = Column(String)
last_name = Column(String)
username = Column(String, unique=True)
password = Column(PasswordType(schemes=['pbkdf2_sha512']))
class UserToken(IDMixin, CreatedTimestampMixin, Base):
__tablename__ = "user_tokens"
token = Column(PasswordType(schemes=["pbkdf2_sha512"]), nullable=False)
user_id = Column(Integer, ForeignKey("users.id"), index=True)
user = relationship("User", primaryjoin=user_id == User.id)
class User(Timestampable, UUIDable):
username = Column(String(length=255), unique=False)
password = Column(
PasswordType(
max_length=255,
onload=(
lambda **kwargs: {
**kwargs,
'schemes': current_app.config['PASSWORD_SCHEMES'],
}),
),
nullable=False,
unique=False,
)
is_active = Column(Boolean, default=True)
is_child = Column(Boolean, default=False)
parents = relationship(
'User',
secondary=ParentChildAssociation.__table__,
primaryjoin=f'User.id == ParentChildAssociation.child_id',
secondaryjoin=f'User.id == ParentChildAssociation.parent_id',
backref='children',
)
def __str__(self) -> str:
prefix = '[C] ' if self.is_child else '[P] '
return f'{prefix}{self.username}'
class user(Base):
__tablename__ = 'user'
id = Column(Integer, primary_key=True, nullable=False)
email = Column(Text, unique=True, nullable=False)
email_confirmed = Column(Boolean, nullable=False, default=False)
password = Column(PasswordType(schemes=['pbkdf2_sha512']), nullable=False)
vehicles = relationship("vehicle", passive_deletes=True)
class User(db.Model, CRUD):
""" User model """
_GENDERS = [(u'male', u'Male'), (u'female', u'Female')]
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(PasswordType(schemes=['pbkdf2_sha512']),
nullable=False)
gender = db.Column(ChoiceType(_GENDERS))
weights = db.relationship('UserWeight',
backref='users',
lazy=True,
cascade="all,delete")
date_created = db.Column(db.DateTime, default=db.func.current_timestamp())
date_modified = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
def __init__(self, email, name, password, gender):
self.email = email
self.name = name
self.password = password
self.gender = gender
def __str__(self):
return self.name
def __repr__(self):
return "<User: {}>".format(self.name)
def save(self):
if self.password and self.email:
db.session.add(self)
db.session.commit()
else:
abort(400, 'Email and Password are required.')
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
def encode_auth_token(self, user_id):
"""
Generates the Auth Token
:return: string
"""
try:
payload = {
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(days=0, seconds=5),
'iat':
datetime.datetime.utcnow(),
'sub':
user_id
}
return jwt.encode(payload, settings.SECRET_KEY, algorithm='HS256')
except Exception as e:
return e
class User(db.Model):
__tablename__ = 'users'
email = db.Column(db.String, primary_key=True)
password = db.Column(PasswordType(schemes=['pbkdf2_sha512']),
nullable=False)
authenticated = db.Column(db.Boolean, nullable=False, default=False)
def is_active(self):
return True
def get_id(self):
return self.email
def is_authenticated(self):
return self.authenticated
def is_anonymous(self):
return False
def authenticate(self, password):
# WARNING: this only secure because self.password is `PasswordType`
compare = self.password == password
if compare:
self.authenticated = True
return compare
class User(Base, HasUUID, HasCreatedBy, HasCreatedAtUpdatedAt):
""" Reddit User """
__tablename__ = 'user'
username = Column(
String,
nullable=False,
unique=True,
doc="Username, typically the email address of the user",
)
email = Column(String,
nullable=False,
unique=True,
doc="Email address of the user")
password = Column(
PasswordType(schemes=['bcrypt']),
nullable=False,
default=default_password,
doc="Bcrypt",
)
@validates('username')
def validate_username(self, key, username):
if not username:
raise ValueError("Username cannot be empty.")
return username
@validates('password')
def validate_password(self, key, password):
if isinstance(password, Password):
return password
class User(db.Model):
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(), unique=True)
password = db.Column(
PasswordType(schemes=['pbkdf2_sha512', 'md5_crypt'],
deprecated=['md5_crypt']))
def __init__(self, username, password):
self.username = username
self.password = password
def check_password(self, value):
return self.password == value
def is_active(self):
return True
def get_id(self):
return self.id
def insert_user(self):
try:
db.session.add(self)
db.session.commit()
except:
return False
return True
def __repr__(self):
return '<User %r>' % self.username
def test_context_is_lazy(self):
"""
Make sure the init doesn't evaluate the lazy context.
"""
onload = mock.Mock(return_value={})
PasswordType(onload=onload)
assert not onload.called
class User(UserMixin, db.Model, TimestampMixin):
"""
User model.
`account_type`: `basic` and `premium`, also `admin`, but not sure about that yet. It"s `basic` by default
`status`: by default inactive, becomes active after email confirmation
"""
__tablename__ = "users"
id = db.Column(UUID(as_uuid=True), primary_key=True, nullable=False, default=uuid4)
email = db.Column(db.String(255), nullable=False)
first_name = db.Column(db.String(255), nullable=False)
last_name = db.Column(db.String(255), nullable=False)
password = db.Column(PasswordType(schemes=["bcrypt"]), nullable=False)
is_active = db.Column(db.Boolean(), nullable=False, server_default="1")
confirmed = db.Column(db.Boolean(), nullable=False, server_default="0")
email_confirmed_at = db.Column(db.DateTime())
roles = db.relationship("Role", secondary="user_roles")
__table_args__ = (
UniqueConstraint("email", name="uq_users_email"),
)
def __init__(self, *args, **kwargs):
super(User, self).__init__(*args, **kwargs)
@staticmethod
def auth(email, password):
user = User.query.filter_by(email=email).first()
if user and user.password == password:
return user
return None
def __repr__(self):
return f"User(id={self.id}, email={self.email}, account_type={self.account_type}, status={self.status})"
class User(Base):
__tablename__ = "user"
id = Column(Integer, primary_key=True)
email = Column(String)
password = Column(
PasswordType(schemes=['pbkdf2_sha512', 'md5_crypt'],
deprecated=['md5_crypt']))
class User(db.Model):
"""User"""
__tablename__ = "users"
user_id = db.Column(db.Integer, autoincrement=True, primary_key=True)
username = db.Column(db.String(50), unique=True)
email = db.Column(db.String(50), unique=True)
zipcode = db.Column(db.String(20), unique=False)
password = db.Column(PasswordType(
# The returned dictionary is forwarded to the CryptContext
onload=lambda **kwargs: dict(
schemes=['pbkdf2_sha512', 'md5_crypt'],
**kwargs
),
),
unique=False,
nullable=False
)
def __repr__(self):
"""Provides more helpful output when printed"""
return "<User user_id: {} username: {} password:{}>".format(self.user_id, self.username, self.password)
class Users(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.VARCHAR, nullable=False)
email = db.Column(db.VARCHAR)
password = db.Column(PasswordType(schemes=['pbkdf2_sha512']),
nullable=False)
salt = db.Column(db.VARCHAR, nullable=False)
class User(Timestampable, UUIDable):
email = Column(EmailType, nullable=False, unique=True)
first_name = Column(String(length=MAX_LENGTH), nullable=False)
last_name = Column(String(length=MAX_LENGTH), nullable=False)
username = Column(String(length=MAX_LENGTH), nullable=False)
password = Column(
PasswordType(
max_length=MAX_LENGTH,
onload=(
lambda **kwargs: {
**kwargs,
'schemes': current_app.config['PASSWORD_SCHEMES'],
}),
),
nullable=False,
unique=False,
)
is_active = Column(Boolean, default=True)
accepted_help_requests = relationship(
'apps.help_requests.models.HelpRequest',
back_populates='accepted_by',
)
def __str__(self) -> str:
return f'{self.first_name} {self.last_name} ({self.email})'
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(150))
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(PasswordType(schemes=['pbkdf2_sha512']),
nullable=False)
def verify_password(self, password):
return password == self.password
def generate_auth_token(self, expiration=1000 * 60):
s = Serializer(Config.SECRET_KEY, expires_in=expiration)
return s.dumps({'id': self.id})
@staticmethod
def verify_auth_token(token):
s = Serializer(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 __init__(self, email, password, name=None):
self.name = name
self.email = email
self.password = password
def __repr__(self):
return '<id {}>'.format(self.id)
class User(Base):
__tablename__ = 'users'
uid = Column(Integer, primary_key=True)
account = Column(String, nullable=False)
password = Column(PasswordType(schemes=['sha1_crypt']), nullable=False)
@validates('account')
def validate_account(self, key, email):
assert '@' in email, "Account format isn't correct! (Correct sample: [email protected])"
return email
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return str(self.uid)
def __repr__(self):
return "<User(uid={}, account={})>".format(self.uid, self.account)
class Account(Base):
"""
Class that maps to the account table in the database and hold
data about user accounts
"""
__tablename__ = "account"
id = Column(Integer, primary_key=True)
email = Column(String(50), nullable=False, unique=True)
credit_card = Column(BigInteger, nullable=False)
# sqlalchemy_utils.PasswordType requires passlib
# pip install passlib
password = Column(PasswordType(schemes=['pbkdf2_sha512', 'md5_crypt'],
deprecated=['md5_crypt']),
unique=False,
nullable=False)
zip_code = Column(Integer, nullable=False)
first_name = Column(String(30), nullable=True)
last_name = Column(String(30), nullable=True)
theater_owner = Column(Boolean, nullable=True)
created = Column(DateTime, default=datetime.datetime.now)
updated = Column(DateTime, onupdate=datetime.datetime.now)
def __repr__(self):
return f"<{self.__class__.__name__}(id={self.id}, email={self.email})>"
class User(Base):
__tablename__ = 'user'
uid = synonym('login')
login = Column(String, primary_key=True, nullable=False)
name = Column(String, nullable=False)
email = Column(String, unique=True, nullable=False)
password = Column(
PasswordType(schemes=['pbkdf2_sha512']), nullable=False
)
profiles = Column(types.SetType, default=set())
permissions = Column(types.SetType, default=set())
active = Column(Boolean(name='bool'), default=True)
def __str__(self):
return self.name
likes = relationship(
'gallery.Photo',
secondary=Likes.__table__,
back_populates="likes",
collection_class=set
)
def as_dict(self):
return {
'login': self.login,
'name': self.name,
'email': self.email,
}
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), unique=True, nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(PasswordType(schemes=[
'sha256_crypt',
]))
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow)
password_changed_at = db.Column(db.DateTime)
identities = db.relationship('Identity', backref='user', lazy='dynamic')
sessions = db.relationship('Session', backref='user', lazy='dynamic')
@classmethod
def find_by_email_or_username(cls, username):
return (User.query.filter((User.email == username)
| (User.username == username)).first())
def change_password(self, password):
self.password = password
self.password_changed_at = datetime.utcnow()
class User(Base, UserMixin):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
# User authentication information (required for Flask-User)
username = Column(Unicode(30), nullable=False, unique=True)
email = Column(Unicode(255), nullable=False, unique=True)
confirmed_at = Column(DateTime())
password = Column(PasswordType(schemes=['pbkdf2_sha512', 'md5_crypt']),
nullable=False,
server_default='')
reset_password_token = Column(String(100), nullable=False, default='')
# User information
active = Column('is_active', Boolean(), nullable=False, server_default='0')
first_name = Column(Unicode(50), nullable=False, server_default=u'')
last_name = Column(Unicode(50), nullable=False, server_default=u'')
# Relationships
roles = relationship('Role',
secondary='users_roles',
backref=backref('users', lazy='dynamic'))
# Timestamps
created = Column(DateTime, default=datetime.datetime.utcnow)
last_updated = Column(DateTime, default=datetime.datetime.utcnow)
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), nullable=True)
email = db.Column(db.String(75), nullable=False, unique=True)
password = db.Column(
PasswordType(schemes=[
'pbkdf2_sha512',
]),
unique=False,
nullable=False,
)
created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def verify_password(self, password):
return self.password == password
def generate_auth_token(self, expiration=600):
s = Serializer(SECRET_KEY, expires_in=expiration)
return s.dumps({'id': self.id})
@staticmethod
def verify_auth_token(token):
s = Serializer(SECRET_KEY)
try:
data = s.loads(token)
except SignatureExpired:
return None
except BadSignature:
return None
user = User.query.get(data['id'])
return user
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
def upgrade():
op.create_table('user',
sa.Column('id',
sa.Integer,
primary_key=True,
nullable=False),
sa.Column('email',
sa.Unicode(128),
nullable=False,
unique=True),
sa.Column('password',
PasswordType(schemes=['pbkdf2_sha512']),
nullable=False),
sa.Column('role',
sa.Unicode(1024),
nullable=False,
server_default='user'),
sa.Column('last_login_at', sa.DateTime, nullable=True),
sa.Column('created_at', sa.DateTime, nullable=False),
sa.Column('updated_at', sa.DateTime, nullable=False),
mysql_engine='InnoDB')
op.create_table(
'user_project',
sa.Column('id', sa.Integer, primary_key=True, nullable=False),
sa.Column('user_id',
sa.Integer,
sa.ForeignKey('user.id', name='user_project_ibfk1'),
nullable=False),
sa.Column('project_id',
sa.Integer,
sa.ForeignKey('project.id', name='user_project_ibfk2'),
nullable=False))
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(length=32, collation=COL_ASCII_GENERAL_CI),
unique=True,
nullable=False)
email = db.Column(EmailType(length=255, collation=COL_ASCII_GENERAL_CI),
unique=True,
nullable=True)
password_hash = db.Column(PasswordType(max_length=255, schemes=['argon2']),
nullable=False)
status = db.Column(ChoiceType(UserStatusType, impl=db.Integer()),
nullable=False)
level = db.Column(ChoiceType(UserLevelType, impl=db.Integer()),
nullable=False)
created_time = db.Column(db.DateTime(timezone=False),
default=datetime.utcnow)
last_login_date = db.Column(db.DateTime(timezone=False),
default=None,
nullable=True)
last_login_ip = db.Column(db.Binary(length=16),
default=None,
nullable=True)
torrents = db.relationship('Torrent',
back_populates='user',
lazy="dynamic")
# session = db.relationship('Session', uselist=False, back_populates='user')
def __init__(self, username, email, password):
self.username = username
self.email = email
self.password_hash = password
self.status = UserStatusType.INACTIVE
self.level = UserLevelType.REGULAR
def __repr__(self):
return '<User %r>' % self.username
@classmethod
def by_id(cls, id):
return cls.query.get(id)
@classmethod
def by_username(cls, username):
user = cls.query.filter_by(username=username).first()
return user
@classmethod
def by_email(cls, email):
user = cls.query.filter_by(email=email).first()
return user
@property
def is_admin(self):
return self.level is UserLevelType.ADMIN or self.level is UserLevelType.SUPERADMIN
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('invite',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('key', sa.String(length=10), nullable=True),
sa.PrimaryKeyConstraint('id')
)
op.create_table('user',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('login', sa.String(length=80), nullable=True),
sa.Column('password',
PasswordType(schemes=['pbkdf2_sha512', 'md5_crypt'], deprecated=['md5_crypt']),
nullable=True),
sa.Column('gender', sa.String(length=80), nullable=True),
sa.Column('xp', sa.Integer(), nullable=True),
sa.Column('image_big', sa.String(length=120), nullable=True),
sa.Column('role', sa.String(length=80), nullable=True),
sa.PrimaryKeyConstraint('id'),
sa.UniqueConstraint('login')
)
op.create_table('event',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('author_id', sa.Integer(), nullable=True),
sa.Column('title', sa.String(length=80), nullable=True),
sa.Column('description_short', sa.String(length=80), nullable=True),
sa.Column('description', sa.String(length=120), nullable=True),
sa.Column('max_participants', sa.Integer(), nullable=True),
sa.Column('status', sa.String(length=80), nullable=True),
sa.Column('best_player_reward', sa.Integer(), nullable=True),
sa.Column('result_file', sa.String(length=120), nullable=True),
sa.Column('date_start', sa.DateTime(), nullable=True),
sa.Column('image_big', sa.String(length=120), nullable=True),
sa.Column('published', sa.Boolean(), nullable=True),
sa.ForeignKeyConstraint(['author_id'], ['user.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.create_table('event_participate',
sa.Column('user_id', sa.Integer(), nullable=True),
sa.Column('event_id', sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(['event_id'], ['event.id'], ),
sa.ForeignKeyConstraint(['user_id'], ['user.id'], )
)
op.create_table('event_result',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('user_id', sa.Integer(), nullable=True),
sa.Column('event_id', sa.Integer(), nullable=True),
sa.Column('place', sa.Integer(), nullable=True),
sa.Column('reward', sa.Integer(), nullable=True),
sa.Column('rewarded', sa.Boolean(), nullable=True),
sa.ForeignKeyConstraint(['event_id'], ['event.id'], ),
sa.ForeignKeyConstraint(['user_id'], ['user.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.create_table('event_wait',
sa.Column('user_id', sa.Integer(), nullable=True),
sa.Column('event_id', sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(['event_id'], ['event.id'], ),
sa.ForeignKeyConstraint(['user_id'], ['user.id'], )
)
class User(UserMixin, db.Model):
__tablename__ = "users"
user_id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80),
index=True,
unique=True,
nullable=False)
password = db.Column(
PasswordType(schemes=["pbkdf2_sha256"])) # password hash
first_name = db.Column(db.String(80), nullable=False)
last_name = db.Column(db.String(80), nullable=False)
birth_date = db.Column(db.Date)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, onupdate=datetime.utcnow)
email = db.Column(EmailType, unique=True)
messages = db.relationship("Message",
lazy="select",
cascade="delete",
foreign_keys="Message.user_id")
attachments = db.relationship("Attachment",
lazy="select",
foreign_keys="Attachment.user_id")
memberships = db.relationship("Member",
lazy="select",
cascade="delete",
foreign_keys="Member.user_id")
chats = db.relationship("Chat",
lazy="select",
cascade="delete",
foreign_keys="Chat.creator_id")
def __init__(self,
username=None,
first_name=None,
last_name=None,
email=None):
self.username = username
self.first_name = first_name
self.last_name = last_name
self.email = email
def __repr__(self):
# pylint: disable=line-too-long
return "<{}: user_id={}, username={}, first_name={}, last_name={}, created_at={}, updated_at={}>".format(
self.__class__.__name__,
self.user_id,
self.username,
self.first_name,
self.last_name,
self.created_at,
self.updated_at,
)
def get_id(self):
return self.user_id
class User(BaseMixin, db.Model):
__tablename__ = 'game_of_thrones_user'
name = db.Column(db.Unicode(255), nullable=False)
email = db.Column(EmailType, nullable=False)
password = db.Column(PasswordType(schemes=[
'pbkdf2_sha512',
], ))
