def post(self, request, user_type: PlatformUserType, format=None): """ Add a new FcmToken for user """ log_info(__name__, "post", ">>") fcm_token = request.data.get('fcm_token', None) token_type = request.data.get('token_type', None) if fcm_token and token_type: try: token_type = FcmTokentype.tokentype_from_string(token_type) # TODO: Add check that user and user_type combination exist if not MobileFcm.objects.filter( platform_user=request.user, platform_user_type=user_type, registration_id=fcm_token).exists(): fcm_token = MobileFcm.create_token(request.user, user_type, fcm_token, token_type) return Response(status=status.HTTP_201_CREATED) # TODO: Policy check. Are we sending meaningful status messages? return Response(status=status.HTTP_208_ALREADY_REPORTED) except KeyError as e: log_exception(e) content = {'message': 'invalid request'} return Response(content, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None): # Exchange phone and OTP for JWT """ Post Exchage JwtToken for otp and phone """ log_info(__name__, "post", ">>") token = request.data.get("token", None) phone = request.data.get("phone", None) user = None if phone: is_valid_number, parsed_e164, _, _ = phonenumber.validate_and_return_param( phone) if not is_valid_number: content = {'message': 'Phone number invalid', 'phone': phone} return Response(content, status=status.HTTP_400_BAD_REQUEST) try: user = PlatformUser.objects.get(phone=parsed_e164) except PlatformUser.DoesNotExist: content = { 'message': 'Account does not exist. Signup instead.', 'phone': phone} return Response(content, status=status.HTTP_400_BAD_REQUEST) if token and user: if not user.is_active: content = {'message': 'Account is deactived.', 'phone': phone} return Response(content, status=status.HTTP_400_BAD_REQUEST) if not AuthTempCode.verify_for_token_user(token, user): content = {'message': 'Verification Failed'} return Response(content, status=status.HTTP_400_BAD_REQUEST) content = get_login_info_for_user(user) return Response(content, status=status.HTTP_200_OK) content = {'message': 'Paramters missing'} return Response(content, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format=None): # Get OTP """ Get OTP in exchange for phone """ log_info(__name__, "get", ">>") phone = request.query_params.get("phone", None) if phone: is_valid_number, parsed_e164, _, _ = phonenumber.validate_and_return_param( phone) if not is_valid_number: content = {'message': 'Phone number invalid', 'phone': phone} return Response(content, status=status.HTTP_400_BAD_REQUEST) try: user = PlatformUser.objects.get(phone=parsed_e164) except PlatformUser.DoesNotExist: content = { 'message': 'Account does not exist. Signup instead.', 'phone': phone} return Response(content, status=status.HTTP_400_BAD_REQUEST) if not user.is_active: content = {'message': 'Account is deactived.', 'phone': phone} return Response(content, status=status.HTTP_400_BAD_REQUEST) token = AuthTempCode.create_for_user(user=user) if token: content = {'phone': phone} if DEBUG: content["token"] = token return Response(content, status=status.HTTP_200_OK) content = { 'message': 'Something went wrong. Try again later', 'phone': phone} # pragma: no cover return Response(content, status=status.HTTP_400_BAD_REQUEST) # pragma: no cover content = {'message': 'Phone missing'} return Response(content, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None): # Signup log_info(__name__, "post", ">>") self.permission_classes = (AllowAny,) phone = request.data.get("phone", None) user, content = _create_new_user(phone) response_status = status.HTTP_201_CREATED if user else status.HTTP_400_BAD_REQUEST return Response(content, status=response_status)
def dispatch_otp(user_external_id: str, phone: str, otp: str): ''' Send OTP sms ''' log_info(__name__, "dispatch_otp", ">>") sms_text = f"Your OTP is {otp}" dispatch_sms(user_external_id, phone, sms_text, True, True)
def task_handle_sms_delivery_cb_for_msg91(request): """ Pushes the cb data to queue and returned 200 """ if request.method == 'POST': log_info(__name__, "task_handle_sms_delivery_cb", ">>") dispatch_sms_delivery_cb_for_msg91(request.data) return Response(status=status.HTTP_200_OK)
def dispatch_data_notification_to_deliveryagent(platform_users: List, data_message: dict): ''' Send Data notification to delivery agent. eg. App resync request ''' log_info(__name__, "dispatch_display_notification_to_deliveryagent", ">>") dispatch_data_notification(platform_users, data_message, PlatformUserType.AGENT)
def dispatch_data_notification_to_customer(platform_users: List, data_message: dict): ''' Send Data notification to customer app. eg. App resync request ''' log_info(__name__, "dispatch_data_notification_to_customer", ">>") dispatch_data_notification(platform_users, data_message, PlatformUserType.CUSTOMER)
def dispatch_data_notification_to_merchant(platform_users: List, data_message: dict): ''' Send Data notification to merchat app. eg. App resync request ''' log_info(__name__, "dispatch_data_notification_to_merchant", ">>") dispatch_data_notification(platform_users, data_message, PlatformUserType.MERCHANT)
def patch(self, request, format=None): # Update User Info log_info(__name__, "patch", ">>") self.permission_classes = (IsAuthenticated, ActivePermission,) self.perform_authentication(request) self.check_permissions(request) user = request.user if 'name' in request.data: user.set_name(request.data.get('name')) user.save() return Response(PlatformUserSerializer(user, many=False).data, status=status.HTTP_200_OK)
def dispatch_display_notification_to_deliveryagent(platform_users: List, message_title: str, message_body: str): ''' Send Promotional/Platform handled notification eg. New Offer ''' log_info(__name__, "dispatch_display_notification_to_deliveryagent", ">>") dispatch_display_notification(platform_users, message_title, message_body, PlatformUserType.AGENT)
def dispatch_display_notification_to_customer(platform_users: List, message_title: str, message_body: str): ''' Send Promotional/Platform handled notification eg. New Offer ''' log_info(__name__, "dispatch_display_notification_to_customer", ">>") dispatch_display_notification(platform_users, message_title, message_body, PlatformUserType.CUSTOMER)
def check_place_initfile(source_initfile, user_initfile): """if user initfile not exist try to creat it from the system initfile""" if not os.path.isfile(user_initfile): logger.log_warning(LOG3.format(user_initfile)) try: directory = os.path.dirname(user_initfile) os.makedirs(directory, exist_ok=True) shutil.copyfile(source_initfile, user_initfile) logger.log_info(LOG4.format(source_initfile)) except: # IOError in Python 3 is now an alias for OSerror logger.log_error(LOG5.format(source_initfile))
def dispatch_sms(user_external_id: str, phone: str, sms_text: str, transactional=True, retry_required=True): ''' Send Generic SMS ''' log_info(__name__, "dispatch_sms", ">>") if not user_external_id: raise ValueError('user_external_id') task_send_sms.delay(user_external_id, phone, sms_text, None, True, True)
def send_data_message(self, data_message: dict, api_key=None): log_info(__name__, "send_data_message", ">>") result = fcm_send_data_message(self.registration_id, data_message=data_message, api_key=api_key) # TODO: Remove below behaviour if we are periodically asking for working IDs using fcm wrapper if 'error' in result['results'][0]: # pragma : no cover if settings.NOTIF_MOBILE_DELETE_INACTIVE_DEVICES: self.delete() else: self.update(active=False) log_info(__name__, "send_data_message", "<<") return result
def dispatch_simple_email_to_customer(platform_customer, sender_email: str, sender_name: str, subject: str, plain_text_content: str, html_content: str, retry_required=True): ''' Send Simple Email to platform Customer. TODO: Test after platform_customer is implemented ''' log_info(__name__, "dispatch_simple_email_to_customer", ">>") if not platform_customer: raise ValueError('platform_user') if not (plain_text_content or html_content): raise ValueError('html_content, plain_text_content') dispatch_simple_email(platform_customer.get_user_external_id(), sender_email, sender_name, platform_customer.get_email(), subject, plain_text_content, html_content)
def dispatch_simple_email(user_external_id: str, sender_email: str, sender_name: str, to_email: str, subject: str, plain_text_content: str, html_content: str, retry_required=True): ''' Send Simple Email ''' log_info(__name__, "dispatch_simple_email", ">>") if not user_external_id: raise ValueError('user_external_id') if not to_email: raise ValueError('to_email') if not (plain_text_content or html_content): raise ValueError('html_content, plain_text_content') task_send_simple_email.delay(user_external_id, sender_email, sender_name, to_email, subject, plain_text_content, html_content, True)
def dispatch_template_email(user_external_id: str, sender_email: str, sender_name: str, to_email: str, template_id: str, dynamic_template_data: dict, retry_required=True): ''' Send Teplate based Email ''' log_info(__name__, "dispatch_simple_email", ">>") if not user_external_id: raise ValueError('user_external_id') if not to_email: raise ValueError('to_email') if not template_id: raise ValueError('template_id') if not dynamic_template_data: raise ValueError('dynamic_template_data') task_send_template_email.delay(user_external_id, sender_email, sender_name, to_email, template_id, dynamic_template_data, True)
def load_dot_env_file(dot_env_path): """ load .env file. Args: dot_env_path (str): .env file path Returns: dict: environment variables mapping { "UserName": "******", "Password": "******", "PROJECT_KEY": "ABCDEFGH" } Raises: exceptions.FileFormatError: If .env file format is invalid. """ if not os.path.isfile(dot_env_path): raise exceptions.FileNotFound(".env file path is not exist.") logger.log_info("Loading environment variables from {}".format(dot_env_path)) env_variables_mapping = {} with io.open(dot_env_path, 'r', encoding='utf-8') as fp: for line in fp: # maxsplit=1 if "=" in line: variable, value = line.split("=", 1) elif ":" in line: variable, value = line.split(":", 1) else: raise exceptions.FileFormatError(".env format error") env_variables_mapping[variable.strip()] = value.strip() utils.set_os_environ(env_variables_mapping) return env_variables_mapping
def send_template_email( self, user_external_id: str, sender_email: str, sender_name: str, to_email: str, template_id: str, dynamic_template_data: dict) -> Tuple[EmailResult, str]: ''' Doesn't send. Just prints and create BaseEmail entity in DB ''' log_info(__name__, "send_template_email", ">>") log_info( __name__, "send_template_email", f"sender_email-{sender_email}\nsender_name-{sender_name}\nto_email-{to_email} \\\ \ntemplate_id-{template_id} \\\ dynamic_template_data-{dynamic_template_data}") external_id = str(uuid.uuid4()) BaseEmail.create( { 'sender_email': sender_email, 'sender_name': sender_name, 'template_id': template_id, 'dynamic_template_data': dynamic_template_data }, to_email, self.get_type(), EmailResult.SENT, external_id, user_external_id) return EmailResult.SENT, external_id
def send_sms(self, user_external_id: str, mob_num, sms_mess, sender_id, is_transactional) -> Tuple[SmsResult, str]: log_info(__name__, "send_sms", ">>") is_valid_indian, _, indian_national_number = phonenumber.is_valid_indian_number( mob_num) if is_valid_indian: mob_num = str(indian_national_number) else: raise Exception("Invalid number " + str(mob_num)) log_info( __name__, "send_sms", f"mob_num-{mob_num}\nsms_mess-{sms_mess}\nsender_id-{sender_id}\nis_transactional{is_transactional}" ) external_id = str(uuid.uuid4()) time.sleep(2) sms = BaseSMS.create(user_external_id=user_external_id, phone=mob_num, sms_text=sms_mess, client_type=self.get_type(), status=SmsResult.SENT, external_id=str(external_id)) return SmsResult.SENT, external_id
def proceed(self, pathname): """operate on one pathname""" if not checks.pathname(pathname): logger.log_error(LOG1.format(pathname)) else: path = pathnames.get_path(pathname) tip = checks.get_type(pathname) full_name = pathnames.get_name(pathname) #print(full_name) exts_names = [ ext for ext in pathnames.get_name_ext(pathname) if ext ] #print(exts_names) base_name = pathnames.get_base_name(pathname) #print(base_name) logger.log_info(LOG2.format(tip, full_name)) cfg_tip = self.cfg[tip] renamer = main.Main() new_names = renamer.get_correct_name(base_name, exts_names, cfg_tip, self.sp_conv) new_name = pathnames.join_base_name_ext(new_names[0], new_names[1:]) logger.log_info(LOG3.format(new_name)) logger.log_info(LOG4.format(self.mode)) if self.mode == MODE_CHECK: if not new_name == full_name: tty.print_info(pathname) #return os.EX_DATAERR # Exit code that means the input data was incorrect. elif self.mode == MODE_RETURN: tty.print_info(new_name) elif self.mode == MODE_WRITE: ### faut debuter par le changement de nom des files, sinon problem avec les nouvo nom de rep actions.rename(path, full_name, new_name) else: pass return os.EX_OK
def clean_registration_ids(cls, registration_ids): log_info(__name__, "clean_registration_ids", ">>") log_info(__name__, "clean_registration_ids", registration_ids) return registration_ids
def get(self, request, format=None): # Get User info log_info(__name__, "get", ">>") self.permission_classes = (IsAuthenticated, ActivePermission,) self.perform_authentication(request) self.check_permissions(request) return Response(PlatformUserSerializer(request.user, many=False).data, status=status.HTTP_200_OK)
def update_report(self, cb_data): # pragma: no cover log_info(__name__, "update_report", ">>")
def get_type(self) -> SmsClientType: log_info(__name__, "get_type", ">>") return SmsClientType.DEBUG
def update_report(self, cb_data: dict): """ { 'data': '[ { "senderId":"SENDRID", "requestId":"386273757a69363337323739", "report":[ { "date":"2018-02-19 21:26:11", "number":"917829862689", "status":"1", "desc":"DELIVERED" }], "userId":"168816", "campaignName":"API" } ]' } ({ 'data': '[ { "senderId":"SENDRID", "requestId":"3863686a5a70303035363635", "report":[ { "date":"2018-03-08 10:53:49","number":"919900260756","status":"1","desc":"DELIVERED" }], "userId":"168816","campaignName":"API" }, { "senderId":"SENDRID", "requestId":"3863686a5a6d333036373738", "report":[ { "date":"2018-03-08 10:53:47","number":"919845672578","status":"1","desc":"DELIVERED" }], "userId":"168816", "campaignName":"API" }, { "senderId":"SENDRID", "requestId":"3863686a5a6e393736393032", "report":[ { "date":"2018-03-08 10:53:47","number":"919945511755","status":"1","desc":"DELIVERED" }], "userId":"168816","campaignName":"API" }]'}, 'MSG91') """ log_level_info(1, __name__, "_update_report_for_msg91", ">>") data = cb_data.get('data', None) cb_data_json = json.loads(data) if cb_data_json: for data_content in cb_data_json: request_id = str(data_content['requestId']) report_status = int(((data_content['report'])[0])['status']) report_status = self._convert_from_msg91(report_status) # TBD: # Do we need this to throw exception? # Then we need to get instead of filter log_level_info( 1, __name__, "_update_report_for_msg91", "{0}--{1}".format(str(request_id), str(report_status))) filter_result = BaseSMS.objects.filter( external_id=request_id).update(status=report_status) log_info(__name__, "_update_report_for_msg91", "Filter result - {0}".format(str(filter_result))) log_level_info(1, __name__, "_update_report_for_msg91", "<<")
def __init__(self, api_key: str): log_info(__name__, "__init__", ">>") log_info(__name__, "__init__", api_key) pass
def single_device_data_message(cls, **kwargs): log_info(__name__, "single_device_data_message", ">>") log_info(__name__, "single_device_data_message", kwargs) return {"results": [{"sucess": True}]}
def subscribe_registration_ids_to_topic(cls, **kwargs): log_info(__name__, "subscribe_registration_ids_to_topic", ">>") log_info(__name__, "subscribe_registration_ids_to_topic", kwargs) return True