class AuthService(object):
def __init__(self):
self.task_service = TaskService()
self.user_manager = UserManager()
self.auth_user_login_serializer = AuthUserLoginSerializer()
self.auth_user_confirm_reset_password = AuthUserConfirmResetPasswordSerializer(
)
def login_user(self, **kwargs) -> str:
data = filter_by_keys(kwargs, auth_login_sw_model.keys())
user = self.auth_user_login_serializer.load(data)
token = generate_login_token(user)
# TODO: Pending to testing whats happen if add a new field in user model when a user is logged
flask_security.login_user(user)
return token
@staticmethod
def logout_user():
# TODO: check if the user is logged
flask_security.logout_user()
def request_reset_password(self, **kwargs):
data = filter_by_keys(kwargs, auth_user_reset_password_sw_model.keys())
user = self.auth_user_login_serializer.load(data, partial=True)
token = user.get_reset_token()
reset_password_url = url_for('auth_reset_password_resource',
token=token,
_external=True)
email_data = {
'email': user.email,
'reset_password_url': reset_password_url,
}
self.task_service.reset_password_email(**email_data)
def check_token_status(self, token):
data = filter_by_keys(data={'token': token}, keys=['token'])
self.auth_user_confirm_reset_password.load(data, partial=True)
def confirm_request_reset_password(self, token: str, password: str) -> str:
data = filter_by_keys(data={
'token': token,
'password': password
},
keys=['token', 'password'])
user = self.auth_user_confirm_reset_password.load(data)
self.user_manager.save(user.id, **{'password': password})
return generate_login_token(user.reload())
class User(Date, AbstractBaseUser, SoftDeletionModel):
class Meta:
db_table = 'users'
objects = UserManager()
REGULAR_USER_LEVEL = 'regular_user'
SUPER_USER_LEVEL = 'super_user'
USERNAME_FIELD = 'email'
USER_LEVELS = [
(REGULAR_USER_LEVEL, 'Regular User'),
(SUPER_USER_LEVEL, 'Super User'),
]
first_name = models.CharField(max_length=128)
last_name = models.CharField(max_length=128)
email = models.EmailField(unique=True)
password = models.CharField(max_length=256)
level = models.CharField(max_length=32,
default=REGULAR_USER_LEVEL,
choices=USER_LEVELS)
def get_str_representation(self):
return {
'email': self.email,
'level': self.level,
}
def get_full_name(self):
return self.first_name + self.last_name
class User(AbstractBaseUser, PermissionsMixin):
email = models.EmailField(max_length=255, unique=True)
is_staff = models.BooleanField(default=False)
is_active = models.BooleanField(default=True)
objects = UserManager()
USERNAME_FIELD = 'email'
def __repr__(self):
return self.email
def __str__(self):
return self.__repr__()
class User(AbstractBaseUser, PermissionsMixin):
username_validator = UnicodeUsernameValidator()
username = models.CharField(
_('username'),
max_length=150,
unique=True,
help_text=_('Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.'),
validators=[username_validator],
error_messages={
'unique': _("A user with that username already exists."),
},
)
is_staff = models.BooleanField(
_('staff status'),
default=False,
help_text=_('Designates whether the user can log into this admin site.'),
)
is_active = models.BooleanField(
_('active'),
default=True,
help_text=_(
'Designates whether this user should be treated as active. '
'Unselect this instead of deleting accounts.'
),
)
date_joined = models.DateTimeField(_('date joined'), default=timezone.now)
objects = UserManager()
USERNAME_FIELD = 'username'
def get_full_name(self):
"""
Return the first_name plus the last_name, with a space in between.
"""
return self.username
def get_short_name(self):
"""Return the short name for the user."""
return self.username
class UserService(BaseService):
def __init__(self, *args, **kwargs):
super(UserService, self).__init__(*args, **kwargs)
self.manager = UserManager()
self.role_manager = RoleManager()
self.user_serializer = UserSerializer()
def create(self, user_data):
deserialized_data = self.user_serializer.load(user_data)
with db_wrapper.database.atomic():
role = self.role_manager.find(deserialized_data['role_id'])
user = self.manager.get_last_record()
fs_uniquifier = 1 if user is None else user.id + 1
deserialized_data.update({
'created_by': current_user.id,
'roles': [role],
'fs_uniquifier': fs_uniquifier
})
user = user_datastore.create_user(**deserialized_data)
return user
def find(self, user_id: int, *args):
self.user_serializer.load({'id': user_id}, partial=True)
return self.manager.find(user_id, *args)
def save(self, user_id: int, **kwargs):
kwargs['id'] = user_id
data = self.user_serializer.load(kwargs, unknown=EXCLUDE)
user = self.manager.find(user_id)
with db_wrapper.database.atomic():
self.manager.save(user_id, **data)
if 'role_id' in data:
user_datastore.remove_role_from_user(user, user.roles[0])
role = self.role_manager.find(data['role_id'])
user_datastore.add_role_to_user(user, role)
return user.reload()
def delete(self, user_id: int):
self.user_serializer.load({'id': user_id}, partial=True)
return self.manager.delete(user_id)
import logging
from flask_security import verify_password
from marshmallow import validate, fields, validates, post_load
from werkzeug.exceptions import Unauthorized, Forbidden
from app.extensions import ma
from app.managers import UserManager
from config import Config
logger = logging.getLogger(__name__)
user_manager = UserManager()
class AuthUserLoginSerializer(ma.Schema):
email = fields.Str(load_only=True, required=True)
password = fields.Str(
load_only=True,
required=True,
validate=validate.Length(min=Config.SECURITY_PASSWORD_LENGTH_MIN,
max=50),
)
__user = None
@validates('email')
def validate_email(self, email):
args = (user_manager.model.active == True,
user_manager.model.deleted_at.is_null(),)
self.__user = user_manager.find_by_email(email, *args)
if self.__user is None:
def __init__(self, *args, **kwargs):
super(UserService, self).__init__(*args, **kwargs)
self.manager = UserManager()
self.role_manager = RoleManager()
self.user_serializer = UserSerializer()
def __init__(self):
self.task_service = TaskService()
self.user_manager = UserManager()
self.auth_user_login_serializer = AuthUserLoginSerializer()
self.auth_user_confirm_reset_password = AuthUserConfirmResetPasswordSerializer(
)