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
