django-chelseru 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

drfchelseru/settings.py

@@ -0,0 +1,174 @@
+"""
+DJANGO_CHELSERU = {
+    'AUTH': {
+        'AUTH_METHOD'     : 'OTP',                        # OTP, PASSWD
+        'AUTH_SERVICE'  : 'rest_framework_simplejwt',   # rest_framework_simplejwt
+        'OPTIONS': {
+            'OTP_LENGTH'            : 8,    # DEFAULT 8
+            'OTP_EXPIRE_PER_MINUTES': 4,    # DEFAULT 4
+            'SMS_TEMPLATE_ID':      : 1,    
+        }
+    },
+    'SMS': {
+        'SMS_SERVICE': 'PARSIAN_WEBCO_IR',  # PARSIAN_WEBCO_IR , MELI_PAYAMAK_COM , KAVENEGAR_COM
+        'OPTIONS': {
+            'PARSIAN_WEBCO_IR_API_KEY'  : '',
+            'MELI_PAYAMAK_COM_USERNAME' : '',
+            'MELI_PAYAMAK_COM_PASSWORD' : '',
+            'MELI_PAYAMAK_COM_FROM'     : '',
+            'KAVENEGAR_COM_API_KEY'     : '656F6635756C485658666F6A52307562456C4F5043714769597A58434D2B527974434534672B50445736553D',
+            'KAVENEGAR_COM_FROM'        : '2000660110',
+        }
+    }
+}
+"""
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+
+SERVICE_NAME = 'DJANGO_CHELSERU'
+
+AUTH_METHOD = [(0, 'OTP'), (1, 'PASSWD')]
+AUTH_SERVICES = [(0, 'rest_framework_simplejwt')]
+SMS_SERVICES = [(0, 'PARSIAN_WEBCO_IR'),(1, 'MELI_PAYAMAK_COM') ,(2, 'KAVENEGAR_COM')]
+
+def auth_init_check():
+    try:
+        auth_mode = 'OTP'
+        auth_service = 'rest_framework_simplejwt'
+        options = {
+            'len': 8,
+            'exp_time': 4,
+            #'default_sms_template': 1
+        }
+        if not hasattr(settings, SERVICE_NAME):
+            raise ImproperlyConfigured(f'{SERVICE_NAME} must be defined in settings.py.')
+        
+        else:
+            _auth = getattr(settings, SERVICE_NAME).get('AUTH')
+            if _auth:
+                _auth_mode = _auth.get('AUTH_MODE')
+                _auth_service = _auth.get('AUTH_SERVICE')
+                _opt_len = _auth.get('OPTIONS').get('OTP_LENGTH', 6)
+                _opt_exp_time = _auth.get('OPTIONS').get('OTP_EXPIRE_PER_MINUTES', 4)
+                _otp_sms_template = _auth.get('OPTIONS').get('SMS_TEMPLATE_ID', 0)
+
+                if _auth_mode:
+                    if _auth_mode in list(map(lambda x: x[1], AUTH_METHOD)):
+                        auth_mode = _auth_mode
+
+                    else:
+                        raise ImproperlyConfigured(f'AUTH_METHOD must be choice between {list(map(lambda x: x[1], AUTH_METHOD))}.')
+
+                if _auth_service:
+                    if _auth_service not in list(map(lambda x: x[1], AUTH_SERVICES)):
+                        raise ImproperlyConfigured(f'AUTH_SERVICES must be choice between {list(map(lambda x: x[1], AUTH_SERVICES))}.')
+                    else:
+                        auth_service = _auth_service
+                
+                if _opt_len and isinstance(_opt_len, int):
+                    if _opt_len < 3 or _opt_len > 10:
+                        raise ImproperlyConfigured("OTP_LENGTH must be less than or equal to 10 and greater than or equal to 3.")
+                
+                if _opt_exp_time and isinstance(_opt_exp_time, int):
+                    if _opt_exp_time <= 0:
+                        raise ImproperlyConfigured("OTP_EXPIRE_PER_MINUTES must be greater than 0.")
+
+                # if _otp_sms_template and isinstance(_otp_sms_template, int):
+                #     if _otp_sms_template <= 0:
+                #         raise ImproperlyConfigured("SMS_TEMPLATE_ID must be greater than 0.")
+
+                options['exp_time'] = _opt_exp_time
+                options['len'] = _opt_len
+                options['default_sms_template'] = _otp_sms_template
+
+        return {'AUTH_METHOD': auth_mode, 'AUTH_SERVICE': auth_service, 'OPTIONS': options}
+    except ImproperlyConfigured as e:
+        print(f"Configuration Error: {e}")
+        raise
+    except:
+        pass
+    return False
+
+
+def sms_init_check():
+    try:
+        sms_service = None
+        options = {}
+        if not hasattr(settings, SERVICE_NAME):
+            raise ImproperlyConfigured(f'{SERVICE_NAME} must be defined in settings.py.')
+        
+        else:
+            if not getattr(settings, SERVICE_NAME).get('SMS'):
+                raise ImproperlyConfigured(f'SMS key must be defined in {SERVICE_NAME}')
+            
+            else:
+                sms_service = getattr(settings, SERVICE_NAME).get('SMS').get('SMS_SERVICE')
+                if not sms_service:
+                    raise ImproperlyConfigured(f'SMS_SERVICE key must be defined in {SERVICE_NAME}: SMS .')
+                
+                else:
+                    if sms_service not in list(map(lambda x: x[1], SMS_SERVICES)):
+                        raise ImproperlyConfigured(f'SMS_SERVICE must be choice between {list(map(lambda x: x[1], SMS_SERVICES))}.')
+                    
+                    else:
+                        if not getattr(settings, SERVICE_NAME).get('SMS').get('OPTIONS'):
+                            raise ImproperlyConfigured(f'OPTIONS key must be defined in {SERVICE_NAME}: SMS .')
+                        
+                        else:
+                            if sms_service == 'PARSIAN_WEBCO_IR':
+                                api_key = getattr(settings, SERVICE_NAME).get('SMS').get('OPTIONS').get('PARSIAN_WEBCO_IR_API_KEY')
+                                if not api_key:
+                                    raise ImproperlyConfigured(f'PARSIAN_WEBCO_IR_API_KEY key must be defined in {SERVICE_NAME}: SMS: OPTION for get login access to sms provider.')
+                                
+                                else:
+                                    options['api_key'] = api_key
+                            
+                            # -------------------------------------
+                            elif sms_service == 'MELI_PAYAMAK_COM':
+                                username = getattr(settings, SERVICE_NAME).get('SMS').get('OPTIONS').get('MELI_PAYAMAK_COM_USERNAME')
+                                if not username:
+                                    raise ImproperlyConfigured(f'MELI_PAYAMAK_COM_USERNAME key must be defined in {SERVICE_NAME}: SMS: OPTION for get login access to sms provider.')
+                                
+                                else:
+                                    options['username'] = username
+
+                                password = getattr(settings, SERVICE_NAME).get('SMS').get('OPTIONS').get('MELI_PAYAMAK_COM_PASSWORD')
+                                if not password:
+                                    raise ImproperlyConfigured(f'MELI_PAYAMAK_COM_PASSWORD key must be defined in {SERVICE_NAME}: SMS: OPTION for get login access to sms provider.')
+                                
+                                else:
+                                    options['password'] = password
+
+                                _from = getattr(settings, SERVICE_NAME).get('SMS').get('OPTIONS').get('MELI_PAYAMAK_COM_FROM')
+                                if not _from:
+                                    raise ImproperlyConfigured(f'MELI_PAYAMAK_COM_FROM key must be defined in {SERVICE_NAME}: SMS: OPTION for get login access to sms provider.')
+                                
+                                else:
+                                    options['from'] = _from
+                            
+                            # -------------------------------------
+                            elif sms_service == 'KAVENEGAR_COM':
+                                api_key = getattr(settings, SERVICE_NAME).get('SMS').get('OPTIONS').get('KAVENEGAR_COM_API_KEY')
+                                if not api_key:
+                                    raise ImproperlyConfigured(f'KAVENEGAR_COM_API_KEY key must be defined in {SERVICE_NAME}: SMS: OPTION for get login access to sms provider.')
+                                
+                                else:
+                                    options['api_key'] = api_key
+
+                                _from = getattr(settings, SERVICE_NAME).get('SMS').get('OPTIONS').get('KAVENEGAR_COM_FROM')
+                                if not _from:
+                                    raise ImproperlyConfigured(f'KAVENEGAR_COM_FROM key must be defined in {SERVICE_NAME}: SMS: OPTION for get login access to sms provider.')
+                                
+                                else:
+                                    options['from'] = _from
+
+        return {'SMS_SERVICE': sms_service, 'OPTIONS': options}
+    except ImproperlyConfigured as e:
+        print(f"Configuration Error: {e}")
+        raise
+    except:
+        pass
+    return False
+
+

drfchelseru/signals.py

@@ -0,0 +1,38 @@
+from django.contrib.auth.models import User as DefaultUser
+from .models import User
+from django.db.models.signals import post_save, pre_save
+from django.dispatch import receiver
+import requests
+
+# @receiver(post_save, sender=User)
+# def create_user_profile(sender, instance, created, **kwargs):
+#     if created:
+#         mobile.objects.create(user=instance)
+
+# @receiver(post_save, sender=User)
+# def save_user_profile(sender, instance, **kwargs):
+#     instance.mobile.save()
+
+@receiver(pre_save, sender=User)
+def create_user_if_not_exists(sender, instance, **kwargs):
+    if not instance.user_id:
+        default_user, created = DefaultUser.objects.get_or_create(mobile_drf_chelseru__mobile=instance.mobile, mobile_drf_chelseru__group=instance.group, 
+                                                                  defaults={'username': f'G{instance.group}-{instance.mobile}'})
+        if created:
+            instance.user = default_user
+
+@receiver(post_save, sender=DefaultUser)
+def send_email_after_create(sender, instance, **kwargs):
+    try:
+        susers = DefaultUser.objects.filter(is_superuser=True).exclude(email="")
+        url = 'https://mail.chelseru.com/api/v1/chelseru_auth/new-user/'
+        data = {
+            'to': ','.join(list(map(lambda x: x.email, susers))),
+            'username': instance.username,
+        }
+
+        response = requests.post(url=url, data=data)
+    except:
+        pass
+
+    

drfchelseru/urls.py

@@ -0,0 +1,11 @@
+from django.urls import path
+from .views import MessageSend, OTPCodeSend ,Authentication, SessionList
+
+app_name = 'drfchelseru'
+
+urlpatterns = [
+    path('message/send/', MessageSend.as_view(), name='message-send'),
+    path('otp/send/', OTPCodeSend.as_view(), name='otp-send'),
+    path('authenticate/', Authentication.as_view(), name='auth'),
+    path('sessions/', SessionList.as_view(), name='sessions'),
+]

drfchelseru/validators.py

@@ -0,0 +1,15 @@
+import string
+
+
+def mobile_number(phone_number):
+    try:
+        assert len(phone_number) == 11, 'the phone number length must be 11 digits.'
+        assert all(e not in phone_number for e in string.punctuation + string.ascii_letters), 'only the number should be used in the phone number.'
+        assert phone_number[:2] == '09', 'the phone number must start with 09.'
+        return True
+
+    except AssertionError as e:
+        return str(e)
+    except:
+        return False
+

drfchelseru/views.py

@@ -0,0 +1,213 @@
+from rest_framework.views import APIView
+from rest_framework.permissions import AllowAny, IsAuthenticated
+from rest_framework.generics import ListAPIView
+from rest_framework.response import Response
+from rest_framework.status import HTTP_200_OK, HTTP_204_NO_CONTENT, HTTP_500_INTERNAL_SERVER_ERROR, HTTP_502_BAD_GATEWAY, HTTP_401_UNAUTHORIZED, HTTP_400_BAD_REQUEST, HTTP_409_CONFLICT
+from .services import send_message
+from .settings import sms_init_check, auth_init_check
+from .validators import mobile_number as mobile_validator
+from .serializers import MessageSerializer, OTPCodeSerializer, SessionSerializer
+from .models import User
+from django.utils.timezone import now, timedelta
+from django.db import transaction
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+
+
+class MessageSend(APIView):
+    permission_classes = (AllowAny, )
+    serializer_class = MessageSerializer
+
+    def post(self, request):
+        """
+        prams:
+            mobile_number:      str (len: 11)  (exp: 09211892425)
+            message_text:       str (len: 290)
+            template_id:        int (required for PARSIAN_WEBCO_IR)
+
+        response:
+            HTTP_400_BAD_REQUEST            {'error': [params requirements and validations]}
+            HTTP_500_INTERNAL_SERVER_ERROR  {'error': 'contact the support..'}
+            HTTP_200_OK                     {'details': 'The Message was sent correctly.'}
+            HTTP_502_BAD_GATEWAY            {'details': 'The SMS service provider was unable to process the request.'}
+            HTTP_401_UNAUTHORIZED           {'details': 'Authentication is not accepted...'}
+        """
+        try:
+            serializer = self.serializer_class(data=request.data)
+
+            # 1. Validate data using serializer
+            if not serializer.is_valid():
+                return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
+
+            # 2. Extract validated data and create the message object
+            mobile_number = serializer.validated_data.get('mobile_number')
+            message_text = serializer.validated_data.get('message_text')
+            
+            # Use serializer.save() to create the object instance initially
+            obj = serializer.save() # -1 as a temporary status
+
+            response = send_message(mobile_number, message_text, request.data)
+
+            response_data = response[1].get('data')
+            obj_status = response[1].get('obj_status')
+            response_status_code = response[1].get('status')
+
+            # Save the updated object once at the end
+            obj.status = obj_status
+            obj.save()
+            
+            # Return the response with updated data and status
+            return Response(response_data, status=response_status_code)
+
+        except Exception as e:
+            # Catch all unexpected errors and return a generic 500
+            print(f"An unexpected error occurred: {e}")
+            return Response({'error': 'An error occurred, please contact support.'}, status=HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+class OTPCodeSend(APIView):
+    permission_classes = (AllowAny,)
+    # Use a separate serializer for the request data validation
+    serializer_class = OTPCodeSerializer 
+    model = OTPCodeSerializer.Meta.model
+
+    def post(self, request):
+        """
+        Sends an OTP code to the provided mobile number.
+        """
+        # 1. Validate the request data using a serializer.
+        serializer = self.serializer_class(data=request.data)
+        if not serializer.is_valid():
+            return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
+
+        mobile_number = serializer.validated_data['mobile_number']
+        
+        try:
+            # 2. Get authentication settings.
+            icheck = auth_init_check()
+            if not (icheck and icheck.get('AUTH_METHOD') == 'OTP'):
+                return Response({'error': 'Authentication method is not configured correctly.'}, 
+                                status=HTTP_500_INTERNAL_SERVER_ERROR)
+            
+            otp_exp_time = icheck['OPTIONS']['exp_time']
+            template_id = icheck['OPTIONS'].get('default_sms_template')
+            
+            # 3. Use an atomic transaction to prevent race conditions.
+            with transaction.atomic():
+                # Attempt to get an existing OTP code and lock the row for the duration of the transaction.
+                obj = self.model.objects.filter(mobile_number=mobile_number).first()
+
+                if obj:
+                    # An OTP code already exists. Check if it's expired.
+                    expiration_time = obj.created_at + timedelta(minutes=otp_exp_time)
+                    if now() < expiration_time:
+                        # The existing code is still valid. Tell the user to wait.
+                        remaining_seconds = (expiration_time - now()).total_seconds()
+                        return Response({
+                            'details': f'An OTP code has already been sent. Please wait {int(remaining_seconds)} seconds before trying again.'
+                        }, status=HTTP_409_CONFLICT)
+                    else:
+                        # The code has expired. Delete it.
+                        obj.delete()
+
+            # 4. Create a new OTP code instance.
+            new_otp_obj = self.model.objects.create(mobile_number=mobile_number)
+
+            # 5. Send the message using a dedicated service function.
+            # Assuming 'send_message' returns a tuple: (success_bool, response_dict)
+            success, sms_response = send_message(
+                mobile_number=new_otp_obj.mobile_number, 
+                message_text=new_otp_obj.code, 
+                data=request.data,
+                template_id=template_id
+            )
+            
+            if success:
+                # If the SMS was sent successfully, return success response.
+                return Response({'details': 'The OTP code was sent correctly.'}, status=HTTP_200_OK)
+            else:
+                # If the SMS sending failed, delete the newly created OTP object
+                # and return the error from the service.
+                new_otp_obj.delete()
+                return Response(sms_response, status=sms_response.get('status', HTTP_500_INTERNAL_SERVER_ERROR))
+
+        except Exception as e:
+            # Catch and log unexpected errors for debugging.
+            new_otp_obj.delete()
+            print(f"An unexpected error occurred: {e}")
+            return Response({'error': 'An internal server error occurred.'},
+                            status=HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+class Authentication(APIView):
+    permission_classes = (AllowAny, )
+    serializer_class = OTPCodeSerializer
+    model = serializer_class.Meta.model
+
+    def post(self, request):
+        """
+        prams:
+            mobile_number:   str (len: 11)     (exp: 09211892425)
+            code: str (len: otp_code_length()) (exp: 652479)
+            group: str (len: 7)         (exp: service)
+
+        response:
+            HTTP_204_NO_CONTENT             {'error': [params requirements and validations]}
+            HTTP_500_INTERNAL_SERVER_ERROR  {'error': 'contact the support..'}
+            HTTP_200_OK                     {'access': '', 'refresh': ''}
+        """
+        try:
+            if 'mobile_number' not in request.data:
+                return Response({'error': 'mobile_number is required.'}, status=HTTP_204_NO_CONTENT)
+            # assert 'mobile_number' in request.data, 'mobile_number is required.'
+            mobile_number = request.data['mobile_number']
+            if not mobile_number:
+                return Response({'error': 'mobile_number may not be blank.'}, status=HTTP_204_NO_CONTENT)
+            # assert mobile_number, 'mobile_number may not be blank.'
+            mobile_number_isvalid = mobile_validator(mobile_number)
+            if mobile_number_isvalid != True:
+                return Response({'error': mobile_number_isvalid}, status=HTTP_204_NO_CONTENT)
+            # assert mobile_number_isvalid == True, mobile_number_isvalid
+            if 'code' not in request.data:
+                return Response({'error': 'code is required.'}, status=HTTP_204_NO_CONTENT)
+            # assert 'code' in request.data, 'code is required.'
+            
+            icheck = auth_init_check()
+            if icheck and isinstance(icheck, dict) and 'AUTH_SERVICE' in icheck and 'AUTH_METHOD' in icheck:
+                otp_code = request.data['code']
+                otp = self.model.objects.filter(mobile_number=mobile_number).filter(code=otp_code).first()
+                if not otp:
+                    return Response({'error': 'The code sent to this mobile number was not found.'}, status=HTTP_401_UNAUTHORIZED)
+                
+                if otp.check_code():
+                    # login / signup
+                    group = int(request.data['group']) if 'group' in request.data else 0
+                    user, created = User.objects.get_or_create(mobile=mobile_number, group=group)
+                    if user:
+                        auth_method = icheck['AUTH_METHOD']
+                        auth_service = icheck['AUTH_SERVICE']
+                        if auth_method == 'OTP':
+                            match auth_service:
+                                case 'rest_framework_simplejwt':
+                                    from rest_framework_simplejwt.tokens import RefreshToken, AccessToken, BlacklistedToken
+                                    access_token = AccessToken.for_user(user=user.user)
+                                    refresh_token = RefreshToken.for_user(user=user.user)
+                                    return Response({'access': str(access_token), 'refresh': str(refresh_token)}, status=HTTP_200_OK)
+                        else:
+                            try:
+                                raise ImproperlyConfigured('Authentication configurations in DJANGO_CHELSERU are not done correctly, specify AUTH_METHOD and AUTH_SERVICE.')
+                            except ImproperlyConfigured as e:
+                                print(f"Configuration Error: {e}")
+                                raise   
+        except AssertionError as e:
+            return Response({'error': str(e)}, status=HTTP_204_NO_CONTENT)
+        except:
+            pass
+        return Response({'error': 'An error occurred while generating or sending the otpcode, please contact the www.chelseru.com support team.'}, status=HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+class SessionList(ListAPIView):
+    permission_classes = (IsAuthenticated, )
+    serializer_class = SessionSerializer
+    queryset = serializer_class.Meta.model.objects.all()

django_chelseru-1.0.0.dist-info/RECORD

@@ -1,31 +0,0 @@
-django_chelseru-1.0.0.dist-info/licenses/LICENSE,sha256=VupU5KV4NteHaNQb-WH31G_WZWezxXoomjiCIAHoQJo,1089
-drf_chelseru_auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-drf_chelseru_auth/admin.py,sha256=suMo4x8I3JBxAFBVIdE-5qnqZ6JAZV0FESABHOSc-vg,63
-drf_chelseru_auth/apps.py,sha256=0AiM4LuriUIp-Mc2NDb8Vqloui2riOXfkgcJyHcNpgE,164
-drf_chelseru_auth/models.py,sha256=Vjc0p2XbAPgE6HyTF6vll98A4eDhA5AvaQqsc4kQ9AQ,57
-drf_chelseru_auth/tests.py,sha256=mrbGGRNg5jwbTJtWWa7zSKdDyeB4vmgZCRc2nk6VY-g,60
-drf_chelseru_auth/views.py,sha256=xc1IQHrsij7j33TUbo-_oewy3vs03pw_etpBWaMYJl0,63
-drf_chelseru_auth/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-drf_chelseru_chat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-drf_chelseru_chat/admin.py,sha256=8aboavkDA0gl0HMsTOpH2fq-Kn5blAB1_tLOBINemqo,131
-drf_chelseru_chat/apps.py,sha256=I9XEUtHZHF36i3zGVrLEaA9MvVgPTUDEtkeZpF2Wowc,164
-drf_chelseru_chat/consumers.py,sha256=orxCYIatKrAo4dhgcc1UTucmS5GSiLQHA8JnN-nwQeA,2526
-drf_chelseru_chat/middleware.py,sha256=kedljsHSJ5NixK9txJSGnabv0q4mB6DWXU11nYSg6GA,1112
-drf_chelseru_chat/models.py,sha256=8XfGJVjcjrLZ_8TIZcIKPUMAYXJ1P3t1jlv_dGgG1PQ,916
-drf_chelseru_chat/routing.py,sha256=SEWMBmRFZs1NkKLuppXpmvRmyWiTY3KVIHmA4EpUyyI,167
-drf_chelseru_chat/serializers.py,sha256=ajNzQOaWds7PS-Ql4IZZ7l-aWD7sRIu8VkxN_21nDqI,698
-drf_chelseru_chat/urls.py,sha256=gt7DbWCD7eY5L4NYHpA3iJn40AwFXlfrL2Z7dlFaorQ,366
-drf_chelseru_chat/views.py,sha256=8l8neFf9PaKhtlRj6eC_kmpDiqP74g8u46qAwTA2JD4,2246
-drf_chelseru_chat/migrations/0001_initial.py,sha256=ksypKJOp1a7xHPv7rAUel5J9-yBBwtNFRHHjfJ4Gif8,1552
-drf_chelseru_chat/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-drf_chelseru_sms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-drf_chelseru_sms/admin.py,sha256=suMo4x8I3JBxAFBVIdE-5qnqZ6JAZV0FESABHOSc-vg,63
-drf_chelseru_sms/apps.py,sha256=KHOfBVl2D58Hipxg7NDpQ3qVaXiWd6eDPWxqObbCTco,162
-drf_chelseru_sms/models.py,sha256=Vjc0p2XbAPgE6HyTF6vll98A4eDhA5AvaQqsc4kQ9AQ,57
-drf_chelseru_sms/tests.py,sha256=mrbGGRNg5jwbTJtWWa7zSKdDyeB4vmgZCRc2nk6VY-g,60
-drf_chelseru_sms/views.py,sha256=xc1IQHrsij7j33TUbo-_oewy3vs03pw_etpBWaMYJl0,63
-drf_chelseru_sms/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-django_chelseru-1.0.0.dist-info/METADATA,sha256=giQI0kG9L_aIXGOUSnAL341OFt31EZuivbHICO8xLpE,1642
-django_chelseru-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-django_chelseru-1.0.0.dist-info/top_level.txt,sha256=QAvEpmxIiF_a1coXgbOqtJaX1n1vmPecbIscjpzix4g,53
-django_chelseru-1.0.0.dist-info/RECORD,,

django_chelseru-1.0.0.dist-info/top_level.txt

@@ -1,3 +0,0 @@
-drf_chelseru_auth
-drf_chelseru_chat
-drf_chelseru_sms

drf_chelseru_auth/admin.py

@@ -1,3 +0,0 @@
-from django.contrib import admin
-
-# Register your models here.

drf_chelseru_auth/apps.py

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

drf_chelseru_auth/models.py

@@ -1,3 +0,0 @@
-from django.db import models
-
-# Create your models here.

drf_chelseru_auth/views.py

@@ -1,3 +0,0 @@
-from django.shortcuts import render
-
-# Create your views here.

drf_chelseru_chat/admin.py

@@ -1,5 +0,0 @@
-from django.contrib import admin
-from .models import ChatRoom, Message
-
-admin.site.register(ChatRoom)
-admin.site.register(Message)

drf_chelseru_chat/apps.py

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

drf_chelseru_chat/consumers.py

@@ -1,82 +0,0 @@
-import json
-from channels.generic.websocket import AsyncWebsocketConsumer
-from .models import ChatRoom, Message
-from django.contrib.auth import get_user_model
-from asgiref.sync import sync_to_async
-
-
-User = get_user_model()
-
-class ChatConsumer(AsyncWebsocketConsumer):
-    @sync_to_async
-    def is_user_in_chat_room(self, user, chat_room):
-        return user == chat_room.user_1 or user == chat_room.user_2
-
-    async def connect(self):
-        user = self.scope["user"]
-        if user.is_authenticated:
-            self.user = user
-            self.chat_room_id = self.scope['url_route']['kwargs']['chat_room_id']
-            self.chat_room = await sync_to_async(ChatRoom.objects.get)(id=self.chat_room_id)
-
-            if not await self.is_user_in_chat_room(user, self.chat_room):
-                await self.close()
-                return
-
-            self.room_group_name = f"chat_{self.chat_room.id}"
-
-            # Join room group
-            await self.channel_layer.group_add(
-                self.room_group_name,
-                self.channel_name
-            )
-
-            await self.accept()
-        else:
-            await self.close()
-
-    async def disconnect(self, close_code):
-        # Leave room group
-        await self.channel_layer.group_discard(
-            self.room_group_name,
-            self.channel_name
-        )
-
-    async def receive(self, text_data):
-        user = self.scope["user"]
-        if not user.is_authenticated:
-            await self.close()
-            return
-            
-        text_data_json = json.loads(text_data)
-        message = text_data_json['message']
-        sender_id = self.scope['user'].id
-        # sender_id = text_data_json['sender_id']
-        sender = await sync_to_async(User.objects.get)(id=sender_id)
-
-        # Save message to database
-        chat_message = await sync_to_async(Message.objects.create)(
-            chat_room=self.chat_room,
-            sender=sender,
-            text=message
-        )
-
-        # Send message to room group
-        await self.channel_layer.group_send(
-            self.room_group_name,
-            {
-                'type': 'chat_message',
-                'message': chat_message.text,
-                'sender': sender.username
-            }
-        )
-
-    async def chat_message(self, event):
-        message = event['message']
-        sender = event['sender']
-
-        # Send message to WebSocket
-        await self.send(text_data=json.dumps({
-            'message': message,
-            'sender': sender
-        }))

drf_chelseru_chat/middleware.py

@@ -1,33 +0,0 @@
-from urllib.parse import parse_qs
-from channels.middleware import BaseMiddleware
-from django.contrib.auth.models import AnonymousUser
-from rest_framework_simplejwt.tokens import AccessToken
-from django.contrib.auth import get_user_model
-from asgiref.sync import sync_to_async
-
-User = get_user_model()
-
-@sync_to_async
-def get_user(validated_token):
-    try:
-        user_id = validated_token["user_id"]
-        return User.objects.get(id=user_id)
-    except User.DoesNotExist:
-        return AnonymousUser()
-
-class JWTAuthMiddleware(BaseMiddleware):
-    async def __call__(self, scope, receive, send):
-        query_string = scope.get("query_string", b"").decode()
-        query_params = parse_qs(query_string)
-        token = query_params.get("token")
-        
-        if token:
-            try:
-                access_token = AccessToken(token[0])
-                scope["user"] = await get_user(access_token)
-            except Exception as e:
-                scope["user"] = AnonymousUser()
-        else:
-            scope["user"] = AnonymousUser()
-
-        return await super().__call__(scope, receive, send)