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

drfchelseru/services.py

@@ -0,0 +1,239 @@
+import requests, json
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+from zeep import Client
+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
+
+
+from .settings import sms_init_check
+
+
+class ParsianWebcoIr:
+    """
+        token
+        TemplateID
+        MessageVars
+        Receiver
+        delay
+    """
+    API_KEY = None
+    HEADERS = {"Content-Type": "application/x-www-form-urlencoded"}
+    def __init__(self, mobile, options, *args, **kwargs):
+        self.RECEIVER = mobile
+        if options and 'api_key' in options:
+            self.API_KEY = options['api_key']
+
+    def send_message(self, message, template_id):
+        try:
+            api_url = 'https://api.parsianwebco.ir/webservice-send-sms/send'
+            data = {
+                'token': self.API_KEY,
+                'TemplateID': template_id,
+                'MessageVars': message,
+                'Receiver': self.RECEIVER,
+                'delay': 1
+            }
+            return json.loads(requests.post(url=api_url, data=data, headers=self.HEADERS).content)
+            """
+                response:
+                    status:
+                        200 ok
+                        100 faild
+                        401 no authenticated
+            """
+        except:
+            return False
+
+
+class MeliPayamakCom:
+    '''
+    username
+    password
+    from
+    to
+    text
+    '''
+    USERNAME = None
+    PASSWORD = None
+    FROM = None
+
+    def __init__(self, mobile, options, *args, **kwargs):
+        self.RECEIVER = mobile
+        if options and 'username' in options and 'password' in options and 'from' in options:
+            self.USERNAME = options['username']
+            self.PASSWORD = options['password']
+            self.FROM = options['from']
+
+    def send_message(self, message):
+        try:
+            client = Client(wsdl='https://api.payamak-panel.com/post/Send.asmx?wsdl')
+            data = {
+                'username': self.USERNAME,
+                'password': self.PASSWORD,
+                'from': self.FROM,
+                'to': self.RECEIVER,
+                'text': message,
+                'isflash': False
+            }
+
+            response = client.service.SendSimpleSMS2(**data)
+            return response
+            """
+                response:
+                    status:
+                        recld (Unique value for each successful submission)
+                        0   The username or password is incorrect.
+                        2   Not enough credit.
+                        3   Limit on daily sending.
+                        4   Limit on sending volume.
+                        5   The sender's number is not valid.
+                        6   The system is being updated.
+                        7   The text contains the filtered word.
+                        9   Sending from public lines via web service is not possible.
+                        10  The desired user is not active.
+                        11  Not sent.
+                        12  The user's credentials are not complete.
+                        14  The text contains a link.
+                        15  Sending to more than 1 mobile number is not possible without inserting "لغو11".
+                        16  No recipient number found
+                        17  The text of the SMS is empty.
+                        35  In REST, it means that the number is on the blacklist of communications.
+            """
+        except:
+            return False
+
+
+class KavenegarCom:
+    '''
+    API_KEY
+    receptor
+    message
+    sender
+    '''
+    API_KEY = None
+    SENDER = None
+    
+    def __init__(self, mobile, options, *args, **kwargs):
+        self.RECEIVER = mobile
+        if options and 'api_key' in options and 'from' in options:
+            self.API_KEY = options['api_key']
+            self.SENDER = options['from']
+
+
+    def send_message(self, message):
+        try:
+            api_url = f'https://api.kavenegar.com/v1/{self.API_KEY}/sms/send.json'
+            data = {
+                'sender': self.SENDER,
+                'receptor': self.RECEIVER,
+                'message': message,
+            }
+            response = requests.post(url=api_url, data=data)
+            return response
+            """
+                response:
+                    messageid Unique identifier of this SMS (To know the status of the sent SMS, this value is the input to the Status method.)
+                    status:
+                        200   if status is 10 & 5 , message received.
+                        400   The parameters are incomplete.
+                        401   Account has been deactivated.
+                        403   The API-Key identification code is not valid.
+                        406   Empty mandatory parameters sent.
+                        411   The recipient is invalid.
+                        412   The sender is invalid.
+                        413   The message is empty or the message length exceeds the allowed limit. The maximum length of the entire SMS text is 900 characters.
+                        414   The request volume exceeds the allowed limit, sending SMS: maximum 200 records per call and status control: maximum 500 records per call
+                        416   The originating service IP does not match the settings.
+                        418   Your credit is not sufficient.
+                        451   Excessive calls within a specific time period are restricted to IP addresses.
+            """
+        except:
+            return False
+
+
+
+def send_message(mobile_number, message_text, data, template_id=None):
+    try:
+        icheck = sms_init_check()
+        if not (icheck and isinstance(icheck, dict) and 'SMS_SERVICE' in icheck and 'SETTINGS' in icheck):
+            raise 'SMS service settings are not configured correctly.'
+
+    except ImproperlyConfigured as e:
+            print(f"Configuration Error: {e}")
+            raise
+    
+    sms_service = icheck['SMS_SERVICE']
+    options = icheck['SETTINGS']
+    response_data = None
+    response_status_code = HTTP_500_INTERNAL_SERVER_ERROR
+    response_bool = False
+
+    if sms_service == 'PARSIAN_WEBCO_IR':
+        try:
+            if not template_id:
+                template_id = data.get('template_id')
+                if not template_id:
+                    raise ImproperlyConfigured('template_id is required for the PARSIAN_WEBCO_IR service.')
+
+            service = ParsianWebcoIr(mobile=mobile_number, options=options)
+            response = service.send_message(message=message_text, template_id=template_id)
+            if isinstance(response, dict) and 'status' in response:
+                obj_status = response['status']
+                if response['status'] == 200:
+                    response_data = {'receiver': mobile_number, 'message': message_text}
+                    response_status_code = HTTP_200_OK
+                    response_bool = True
+                elif response['status'] == 100:
+                    response_data = {'details': 'The SMS service provider was unable to process the request.'}
+                    response_status_code = HTTP_502_BAD_GATEWAY
+                    response_bool = False
+                elif response['status'] == 401:
+                    response_data = {'details': 'Authentication is not accepted, check your token...'}
+                    response_status_code = HTTP_401_UNAUTHORIZED
+                    response_bool = False
+        except ImproperlyConfigured as e:
+            print(f"Configuration Error: {e}")
+            raise
+        
+
+    elif sms_service == 'MELI_PAYAMAK_COM':
+        service = MeliPayamakCom(mobile=mobile_number, options=options)
+        response = service.send_message(message=message_text)
+        obj_status = response
+        if response in [0, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 14, 15, 16, 17, 35]:
+            response_data = {'details': 'The SMS service provider was unable to process the request.', 'errorcode': response}
+            response_status_code = HTTP_502_BAD_GATEWAY
+            response_bool = False
+        else:
+            response_data = {'receiver': mobile_number, 'message': message_text, 'messageid': response}
+            response_status_code = HTTP_200_OK
+            response_bool = True
+
+    elif sms_service == 'KAVENEGAR_COM':
+        service = KavenegarCom(mobile=mobile_number, options=options)
+        try:
+            response = service.send_message(message=message_text)
+            response_json = response.json()
+            entries = response_json.get('entries', [])
+            _return = response_json.get('return', {})
+
+            if entries:
+                response_data = entries[0]
+                obj_status = response_data.get('status')
+                if response.status_code == 200 and response_data.get('status') in [5, 10]:
+                    response_data = {'receiver': response_data.get('receptor'), 'message': response_data.get('message'), 'messageid': response_data.get('messageid')}
+                    response_status_code = HTTP_200_OK
+                    response_bool = True
+                else:
+                    response_data = {'details': 'The SMS service provider was unable to process the request.', 'errorcode': response_data.get('status'), 'errortext': response_data.get('statustext'), 'message': response_data.get('message')}
+                    response_status_code = HTTP_502_BAD_GATEWAY
+                    response_bool = False
+            elif _return:
+                response_data = {'details': 'The SMS service provider was unable to process the request.', 'message': _return.get('message')}
+                response_status_code = HTTP_502_BAD_GATEWAY
+                response_bool = False
+        except (ValueError, KeyError, IndexError) as e:
+            obj_status = 502
+            return False, {'details': 'Invalid response structure.', 'error': str(e)}
+
+    return response_bool, {'data': response_data, 'obj_status': obj_status, 'status': response_status_code}

drfchelseru/settings.py

@@ -0,0 +1,187 @@
+"""
+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
+            'OTP_SMS_TEMPLATE_ID'       : 1,    
+        }
+    },
+    'SMS': {
+        'SMS_SERVICE': 'PARSIAN_WEBCO_IR',  # PARSIAN_WEBCO_IR , MELI_PAYAMAK_COM , KAVENEGAR_COM
+        'SETTINGS': {
+            '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',
+        },
+        'TEMPLATES': {
+            'T1': 1,
+            'T2': 2,
+            'T3': 3,
+            'T4': 4,
+            'T5': 5,
+            'T6': 6,
+            'T7': 7,
+            'T8': 8,
+            'T9': 9,
+        }
+    }
+}
+"""
+
+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('OTP_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 = {}
+        templates = {}
+        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:
+                templates = getattr(settings, SERVICE_NAME).get('SMS').get('TEMPLATES', {})
+                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('SETTINGS'):
+                            raise ImproperlyConfigured(f'SETTINGS key must be defined in {SERVICE_NAME}: SMS .')
+                        
+                        else:
+                            if sms_service == 'PARSIAN_WEBCO_IR':
+                                api_key = getattr(settings, SERVICE_NAME).get('SMS').get('SETTINGS').get('PARSIAN_WEBCO_IR_API_KEY')
+                                if not api_key:
+                                    raise ImproperlyConfigured(f'PARSIAN_WEBCO_IR_API_KEY must be defined in {SERVICE_NAME}: SMS: SETTINGS, To access the SMS service API, you need to have API keys.')
+                                
+                                else:
+                                    options['api_key'] = api_key
+                            
+                            # -------------------------------------
+                            elif sms_service == 'MELI_PAYAMAK_COM':
+                                username = getattr(settings, SERVICE_NAME).get('SMS').get('SETTINGS').get('MELI_PAYAMAK_COM_USERNAME')
+                                if not username:
+                                    raise ImproperlyConfigured(f'MELI_PAYAMAK_COM_USERNAME must be defined in {SERVICE_NAME}: SMS: SETTINGS, To access the SMS service API, you need to have API keys.')
+                                
+                                else:
+                                    options['username'] = username
+
+                                password = getattr(settings, SERVICE_NAME).get('SMS').get('SETTINGS').get('MELI_PAYAMAK_COM_PASSWORD')
+                                if not password:
+                                    raise ImproperlyConfigured(f'MELI_PAYAMAK_COM_PASSWORD must be defined in {SERVICE_NAME}: SMS: SETTINGS, To access the SMS service API, you need to have API keys.')
+                                
+                                else:
+                                    options['password'] = password
+
+                                _from = getattr(settings, SERVICE_NAME).get('SMS').get('SETTINGS').get('MELI_PAYAMAK_COM_FROM')
+                                if not _from:
+                                    raise ImproperlyConfigured(f'MELI_PAYAMAK_COM_FROM must be defined in {SERVICE_NAME}: SMS: SETTINGS, To send an SMS, the sender`s number is required.')
+                                
+                                else:
+                                    options['from'] = _from
+                            
+                            # -------------------------------------
+                            elif sms_service == 'KAVENEGAR_COM':
+                                api_key = getattr(settings, SERVICE_NAME).get('SMS').get('SETTINGS').get('KAVENEGAR_COM_API_KEY')
+                                if not api_key:
+                                    raise ImproperlyConfigured(f'KAVENEGAR_COM_API_KEY must be defined in {SERVICE_NAME}: SMS: SETTINGS, To access the SMS service API, you need to have API keys.')
+                                
+                                else:
+                                    options['api_key'] = api_key
+
+                                _from = getattr(settings, SERVICE_NAME).get('SMS').get('SETTINGS').get('KAVENEGAR_COM_FROM')
+                                if not _from:
+                                    raise ImproperlyConfigured(f'KAVENEGAR_COM_FROM must be defined in {SERVICE_NAME}: SMS: SETTINGS, To send an SMS, the sender`s number is required.')
+                                
+                                else:
+                                    options['from'] = _from
+
+        return {'SMS_SERVICE': sms_service, 'SETTINGS': options, 'TEMPLATES': templates}
+    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
+