authease 1.0.1__tar.gz

authease-1.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Oluwatemmy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

authease-1.0.1/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: authease
+Version: 1.0.1
+Summary: An authentication package
+Home-page: https://github.com/Oluwatemmy/authease
+Author: Oluwaseyi Ajayi
+Author-email: oluwaseyitemitope456@gmail.com
+Project-URL: Documentation, https://github.com/Oluwatemmy/authease#readme
+Project-URL: Source, https://github.com/Oluwatemmy/authease
+Project-URL: Issues, https://github.com/Oluwatemmy/authease/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Framework :: Django
+Classifier: Development Status :: 3 - Alpha
+Requires-Python: >=3.6
+License-File: LICENSE
+Requires-Dist: Django>=5.0.6
+Requires-Dist: djangorestframework>=3.15.1
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: django-environ>=0.11.2
+Requires-Dist: djangorestframework-simplejwt>=5.3.1
+Requires-Dist: google-api-python-client>=2.136.0
+Requires-Dist: environs>=11.0.0
+Requires-Dist: marshmallow>=3.21.3

authease-1.0.1/README.md

@@ -0,0 +1,2 @@
+# django oauth system
+ A django authentication system with google oauth

authease-1.0.1/auth_core/admin.py

@@ -0,0 +1,6 @@
+from django.contrib import admin
+from .models import User
+
+# Register your models here.
+
+admin.site.register(User)

authease-1.0.1/auth_core/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class AuthCoreConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'auth_core'

authease-1.0.1/auth_core/manager.py

@@ -0,0 +1,46 @@
+from django.contrib.auth.models import BaseUserManager
+from django.core.exceptions import ValidationError
+from django.core.validators import validate_email
+from django.utils.translation import gettext_lazy as _
+
+
+class UserManager(BaseUserManager):
+    def email_validator(self, email):
+        try:
+            validate_email(email)
+        except ValidationError:
+            raise ValueError(_("Please enter a valid email address"))
+        
+
+    def create_user(self, email, first_name, last_name, password, **extra_fields):
+        if email:
+            email=self.normalize_email(email)
+            self.email_validator(email)
+        else:
+            raise ValueError(_("An Email Address is required"))
+        if not first_name:
+            raise ValueError(_("First Name is required"))
+        if not last_name:
+            raise ValueError(_("Last Name is required"))
+        
+        user = self.model(email=email, first_name=first_name, last_name=last_name, **extra_fields)
+        user.set_password(password)
+        user.save(using=self._db)
+
+        return user
+    
+    def create_superuser(self, email, first_name, last_name, password, **extra_fields):
+        extra_fields.setdefault("is_staff", True)
+        extra_fields.setdefault("is_superuser", True)
+        extra_fields.setdefault("is_verified", True)
+
+        if extra_fields.get("is_staff") is not True:
+            raise ValueError (_("is staff must be true for admin user"))
+        
+        if extra_fields.get("is_superuser") is not True:
+            raise ValueError (_("is superuser must be true for admin user"))
+
+        user = self.create_user(
+            email, first_name, last_name, password, **extra_fields
+        )
+        return user

authease-1.0.1/auth_core/migrations/0001_initial.py

@@ -0,0 +1,47 @@
+# Generated by Django 5.0.6 on 2024-10-12 18:17
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('auth', '0012_alter_user_first_name_max_length'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='User',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('password', models.CharField(max_length=128, verbose_name='password')),
+                ('email', models.EmailField(max_length=255, unique=True, verbose_name='Email Address')),
+                ('first_name', models.CharField(max_length=150, verbose_name='First name')),
+                ('last_name', models.CharField(max_length=150, verbose_name='Last name')),
+                ('is_staff', models.BooleanField(default=False)),
+                ('is_active', models.BooleanField(default=True)),
+                ('is_superuser', models.BooleanField(default=False)),
+                ('is_verified', models.BooleanField(default=False)),
+                ('date_joined', models.DateTimeField(auto_now_add=True)),
+                ('last_login', models.DateTimeField(auto_now=True)),
+                ('auth_provider', models.CharField(default='email', max_length=50)),
+                ('groups', models.ManyToManyField(blank=True, help_text='The groups this user belongs to. A user will get all permissions granted to each of their groups.', related_name='user_set', related_query_name='user', to='auth.group', verbose_name='groups')),
+                ('user_permissions', models.ManyToManyField(blank=True, help_text='Specific permissions for this user.', related_name='user_set', related_query_name='user', to='auth.permission', verbose_name='user permissions')),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='OneTimePassword',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('code', models.CharField(max_length=6, unique=True)),
+                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+            ],
+        ),
+    ]

authease-1.0.1/auth_core/models.py

@@ -0,0 +1,80 @@
+from django.db import models
+from django.contrib.auth.models import (
+    AbstractBaseUser,
+    PermissionsMixin,
+)
+from django.utils.translation import gettext_lazy as _
+from .manager import UserManager
+from rest_framework_simplejwt.tokens import RefreshToken
+from django.core.validators import RegexValidator
+
+# Create your models here.
+
+AUTH_PROVIDERS = {
+    'email': 'email',
+    'google': 'google',
+    'github': 'github',
+    'facebook': 'facebook'
+}
+
+class User(AbstractBaseUser, PermissionsMixin):
+    # Abstractbaseuser has password, last_login, is_active by default
+
+    email = models.EmailField(unique=True, max_length=255, verbose_name= _("Email Address"), help_text=_("Required. Enter a valid email address."))
+    first_name = models.CharField(max_length=150, verbose_name=_("First name"))
+    last_name = models.CharField(max_length=150, verbose_name=_("Last name"))
+
+    is_staff = models.BooleanField(
+        default=False
+    )  # must needed, otherwise you won't be able to loginto django-admin.
+    is_active = models.BooleanField(
+        default=True
+    )  # must needed, otherwise you won't be able to loginto django-admin.
+    is_superuser = models.BooleanField(
+        default=False
+    )  # this field inherit from PermissionsMixin.
+    is_verified = models.BooleanField(
+        default=False
+    )
+    date_joined = models.DateTimeField(
+        auto_now_add=True
+    )
+    last_login = models.DateTimeField(
+        auto_now=True
+    )
+    auth_provider = models.CharField(max_length=50, default=AUTH_PROVIDERS.get("email"))
+
+    USERNAME_FIELD = "email"
+
+    REQUIRED_FIELDS = ["first_name", "last_name"]
+
+    objects = UserManager()
+
+    def __str__(self):
+        return self.email
+    
+    def get_full_name(self):
+        return f"{self.first_name} {self.last_name}"
+    
+    def tokens(self):
+        refresh = RefreshToken.for_user(self)
+
+        return {
+            'refresh': str(refresh),
+            'access': str(refresh.access_token)
+        }
+    
+    class Meta:
+        verbose_name = "User"
+        verbose_name_plural = "Users"
+
+
+class OneTimePassword(models.Model):
+    code_validator = RegexValidator(regex=r'^\d{6}$', message="Code must be 6 digits.")
+
+
+    user = models.OneToOneField(User, on_delete=models.CASCADE)
+    code = models.CharField(max_length=6, unique=True, validators=[code_validator])
+
+    def __str__(self):
+        return f"{self.user.first_name} passcode"

authease-1.0.1/auth_core/serializers.py

@@ -0,0 +1,171 @@
+import os
+from .models import User
+from dotenv import load_dotenv
+from django.urls import reverse
+from .utils import send_normal_email
+from rest_framework import serializers
+from django.contrib.auth import authenticate
+from django.utils.http import urlsafe_base64_encode, urlsafe_base64_decode
+from django.utils.encoding import smart_str, smart_bytes, force_str
+from rest_framework.exceptions import AuthenticationFailed
+from django.contrib.sites.shortcuts import get_current_site
+from django.contrib.auth.tokens import PasswordResetTokenGenerator
+from rest_framework_simplejwt.tokens import RefreshToken, TokenError
+
+load_dotenv()
+
+
+class UserRegisterSerializer(serializers.ModelSerializer):
+    password=serializers.CharField(min_length=8, max_length=70, write_only=True)
+    confirm_password=serializers.CharField(min_length=8, max_length=70, write_only=True)
+
+    class Meta:
+        model=User
+        fields=["email", "first_name", "last_name", "password", "confirm_password"]
+
+    def validate(self, attrs):
+        password = attrs.get("password", "")
+        confirm_password = attrs.get("confirm_password", "")
+
+        if password != confirm_password:
+            raise serializers.ValidationError("Passwords do not match")
+        
+        return attrs
+    
+    def create(self, validated_data):
+        user = User.objects.create_user(
+            email=validated_data["email"],
+            first_name=validated_data["first_name"],
+            last_name=validated_data["last_name"],
+            password=validated_data["password"],
+        )
+
+        return user
+
+
+class LoginSerializer(serializers.ModelSerializer):
+    email = serializers.EmailField(min_length=8, max_length=255)
+    password = serializers.CharField(min_length=8, max_length=70, write_only=True)
+    full_name = serializers.CharField(max_length=255, read_only=True)
+    access_token = serializers.CharField(max_length=255, read_only=True)
+    refresh_token = serializers.CharField(max_length=255, read_only=True)
+
+    class Meta:
+        model = User
+        fields = ["email", "password", "full_name", "access_token", "refresh_token"]
+
+    def validate(self, attrs):
+        email = attrs.get("email", "")
+        password = attrs.get("password", "")
+        request = self.context.get('request')
+        user = authenticate(request=request, email=email, password=password)
+
+        if not user:
+            raise AuthenticationFailed("Invalid email or password. Please try again")
+        
+        if not user.is_verified:
+            raise AuthenticationFailed("Your account is not verified. Please verify your email address")
+        token = user.tokens()
+
+        return {
+            'email': user.email,
+            'full_name': user.get_full_name(),
+            'access_token': token['access'],
+            'refresh_token': token['refresh']
+        }
+
+
+class PasswordResetRequestSerializer(serializers.ModelSerializer):
+    email = serializers.EmailField(max_length=255)
+
+    class Meta:
+        model=User
+        fields = ["email"]
+
+    def validate(self, attrs):
+        email = attrs.get('email')
+
+        if User.objects.filter(email=email).exists():
+            user = User.objects.get(email=email)
+            
+            # Check if the user is verified
+            if not user.is_verified:
+                raise serializers.ValidationError("Email is not verified. Please verify your email before resetting the password.")
+        
+            uidb64 = urlsafe_base64_encode(smart_bytes(user.id))
+            token = PasswordResetTokenGenerator().make_token(user)
+            request = self.context.get('request')
+            relative_link = reverse('password-reset-confirm', kwargs={'uidb64': uidb64, 'token': token})
+            absink = f"http://{os.environ.get('DOMAIN')}{relative_link}"
+
+            email_body = f"Hi, Use the link below to reset your password \n {absink}"
+            data= {
+                'email_body': email_body,
+                'email_subject': "Reset your Password",
+                'to_email': user.email
+            }
+            send_normal_email(data)
+        else:
+            raise serializers.ValidationError("User with this email does not exist")
+
+        return super().validate(attrs)
+
+
+class SetNewPasswordSerializer(serializers.Serializer):
+    password = serializers.CharField(min_length=6, max_length=100, write_only=True)
+    confirm_password = serializers.CharField(min_length=6, max_length=100, write_only=True)
+    token = serializers.CharField(write_only=True)
+    uidb64 = serializers.CharField(write_only=True)
+
+    class Meta:
+        fields = [
+            "password",
+            "confirm_password",
+            "token",
+            "uidb64"
+        ]
+
+    def validate(self, attrs):
+        password = attrs.get("password")
+        confirm_password = attrs.get("confirm_password")
+
+        if password != confirm_password:
+            raise AuthenticationFailed("Password and Confirm Password doesn't match", 401)
+        
+        try:
+            token = attrs.get("token")
+            uidb64 = attrs.get("uidb64")
+            user_id = force_str(urlsafe_base64_decode(uidb64))
+            user = User.objects.get(id=user_id)
+            if not PasswordResetTokenGenerator().check_token(user, token):
+                raise AuthenticationFailed("The reset link is invalid", 401)
+            
+            if password != confirm_password:
+                raise AuthenticationFailed("Password and Confirm Password doesn't match", 401)
+            
+            user.set_password(password)
+            user.save()
+            return user
+        except Exception as e:
+            raise AuthenticationFailed("The reset link is invalid", 401)
+
+
+class LogoutSerializer(serializers.Serializer):
+    refresh_token = serializers.CharField()
+
+    default_error_messages = {
+        "bad_token": "Token is invalid or expired",
+    }
+
+    def validate(self, attrs):
+        self.token = attrs.get('refresh_token')
+        return attrs
+    
+    def save(self, **kwargs):
+        try:
+            token = RefreshToken(self.token)
+            token.blacklist()
+
+        except TokenError:
+            self.fail("bad_token")
+

authease-1.0.1/auth_core/tests/test_login_views.py

@@ -0,0 +1,243 @@
+from django.core import mail
+from django.urls import reverse
+from django.test import TestCase
+from rest_framework import status
+from rest_framework.test import APIClient
+from auth_core.models import User, OneTimePassword
+from django.core import mail
+from rest_framework_simplejwt.tokens import RefreshToken
+from rest_framework_simplejwt.exceptions import TokenError, TokenBackendError
+
+class LoginUserViewTests(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+
+        self.login_url = reverse('login')  # the login url has been saved as 'login'
+        self.user_data = {
+            "email": 'testuser@example.com',
+            "password": 'testpassword123',
+            "first_name": 'Test',
+            "last_name": 'User'
+        }
+        self.user = User.objects.create_user(**self.user_data)
+
+
+    def test_login_success(self):
+        """
+        Test successful login with valid credentials.
+        """
+        # Get the user and set them as active
+        self.user = User.objects.get(email=self.user_data["email"])
+        self.user.is_verified = True    # a user cannot login without verifying their account
+        self.user.save()
+
+        # Attempt to log in with correct credentials
+        data = {
+            'email': 'testuser@example.com',
+            'password': 'testpassword123'
+        }
+        response = self.client.post(self.login_url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertIn('access_token', response.data)
+        self.assertIn('email', response.data)
+        self.assertEqual(response.data['email'], data['email'])
+        self.assertIn('full_name', response.data)
+
+    def test_login_invalid_email(self):
+        """
+        Test login with an invalid email.
+        """
+        data = {
+            'email': 'invalid@example.com',
+            'password': 'testpassword123'
+        }
+        response = self.client.post(self.login_url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+        self.assertEqual(str(response.data['detail']), 'Invalid email or password. Please try again')
+
+    def test_login_invalid_password(self):
+        """
+        Test login with an invalid password.
+        """
+        data = {
+            'email': 'testuser@example.com',
+            'password': 'wrongpassword'
+        }
+        response = self.client.post(self.login_url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+        self.assertEqual(str(response.data['detail']), 'Invalid email or password. Please try again')
+
+    def test_login_missing_fields(self):
+        """
+        Test login with missing fields.
+        """
+        data = {
+            'email': '',
+            'password': ''
+        }
+        response = self.client.post(self.login_url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertIn('email', response.data)
+        self.assertIn('password', response.data)
+
+    def test_login_with_unverified_email(self):
+        """
+            Test login with an unverified email.
+        """
+        data = {
+            'email': 'testuser@example.com',
+            'password': 'testpassword123'
+        }
+
+        # Attempt to log in with correct credentials
+        response = self.client.post(self.login_url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+        self.assertEqual(str(response.data['detail']), 'Your account is not verified. Please verify your email address')
+
+
+class LogoutViewTests(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+
+        self.logout_url = reverse('logout')  # Ensure you use the correct URL name
+        self.user_data = {
+            "email": 'testuser@example.com',
+            "password": 'testpassword123',
+            "first_name": 'Test',
+            "last_name": 'User'
+        }
+        self.user = User.objects.create_user(**self.user_data)
+
+    def test_logout_success(self):
+        """
+        Test successful logout.
+        """
+        # Get the user and set them as active
+        self.user = User.objects.get(email=self.user_data["email"])
+        self.user.is_verified = True    # a user cannot login without verifying their account
+        self.user.save()
+
+        # Authenticate the user first by logging in (you can use the login endpoint)
+        user_data = {
+            "email": "testuser@example.com",
+            "password": "testpassword123",
+        }
+
+        login_response = self.client.post(reverse("login"), user_data, format='json')
+
+        # Check response status code for successful login (expecting 200 OK)
+        self.assertEqual(login_response.status_code, status.HTTP_200_OK)
+
+        # Extract the tokens from the login response
+        access_token = login_response.data['access_token']
+        refresh_token = login_response.data['refresh_token']
+
+        # Add the access token to the Authorization header for logout request
+        self.client.credentials(HTTP_AUTHORIZATION=f'Bearer {access_token}')
+
+        # Make the logout request with the refresh token
+        response = self.client.post(self.logout_url, {"refresh_token": refresh_token}, format='json')
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        # Test that the refresh token is blacklisted
+        with self.assertRaises(TokenError):
+            # Try to use the blacklisted refresh token to get a new access token
+            blacklisted_token = RefreshToken(refresh_token)
+            blacklisted_token.check_blacklist()  # Should raise an error if the token is blacklisted
+
+    def test_logout_without_authentication(self):
+        """
+        Test logout without authentication.
+        """
+        # Get the user and set them as active
+        self.user = User.objects.get(email=self.user_data["email"])
+        self.user.is_verified = True    # a user cannot login without verifying their account
+        self.user.save()
+
+        response = self.client.post(self.logout_url, format='json')
+        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+        self.assertEqual(response.data['detail'], 'Authentication credentials were not provided.')
+
+    def test_logout_invalid_token(self):
+        """
+        Test logout with an invalid token.
+        """
+        # Get the user and set them as active
+        self.user = User.objects.get(email=self.user_data["email"])
+        self.user.is_verified = True  # Ensure the user is verified to allow login
+        self.user.save()
+
+        # Add the access token to the Authorization header for logout request
+        self.client.credentials(HTTP_AUTHORIZATION=f'Bearer {'access_token'}')
+
+        # Make a logout request with an invalid refresh token
+        response = self.client.post(self.logout_url, {'refresh_token': 'invalid_token'}, format='json')
+
+        with self.assertRaises(TokenError) as context:
+            # Try to use the blacklisted refresh token to get a new access token
+            blacklisted_token = RefreshToken('invalid_token')
+            blacklisted_token.check_blacklist()  # Should raise an error if the token is blacklisted
+
+        # Check the error message
+        self.assertEqual(str(context.exception), "Token is invalid or expired")
+
+        # Check that the response has a 401 status code
+        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+
+        # Check that the error message matches the one in the LogoutSerializer's default error message
+        self.assertEqual(response.data['messages'][0]['message'], "Token is invalid or expired")
+
+
+class TestAuthenticationViewTests(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+
+        self.test_auth_url = reverse('test-auth')  # Ensure you use the correct URL name
+        self.user_data = {
+            "email": 'testuser@example.com',
+            "password": 'testpassword123',
+            "first_name": 'Test',
+            "last_name": 'User'
+        }
+        self.user = User.objects.create_user(**self.user_data)
+
+        # Get the user and set them as active
+        self.user = User.objects.get(email=self.user_data["email"])
+        self.user.is_verified = True    # a user cannot login without verifying their account
+        self.user.save()
+
+        self.client.login(email='testuser@example.com', password='testpassword123')  # Log in to get a token
+        
+    def test_authentication_success(self):
+        """
+        Test access to an authenticated view.
+        """
+        # Authenticate the user first by logging in (you can use the login endpoint)
+        user_data = {
+            "email": "testuser@example.com",
+            "password": "testpassword123",
+        }
+
+        login_response = self.client.post(reverse("login"), user_data, format='json')
+
+        # Extract the tokens from the login response
+        access_token = login_response.data['access_token']
+
+        # Add the access token to the Authorization header for logout request
+        self.client.credentials(HTTP_AUTHORIZATION=f'Bearer {access_token}')
+
+        response = self.client.get(self.test_auth_url, format='json')
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data['message'], "Hello, authenticated user!")
+
+    def test_authentication_failure(self):
+        """
+        Test access to an authenticated view without authentication.
+        """
+        self.client.logout()  # Log out the user
+        
+        response = self.client.get(self.test_auth_url, format='json')
+        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+        self.assertEqual(response.data['detail'], 'Authentication credentials were not provided.')
+