def is_valid_data(customer_id=None, coupon=None, sa_phone=None):
'''
Error During wrong entry of Customer ID or UCN (message to the service advisor)
- "Wrong Customer ID or UCN"
'''
coupon_obj = customer_obj = []
message = ''
if coupon:
coupon_obj = models.CouponData.objects.filter(unique_service_coupon=coupon)
if customer_id:
customer_id = models.CustomerTempRegistration.objects.get_updated_customer_id(customer_id)
customer_obj = models.ProductData.objects.filter(customer_id=customer_id)
if ((customer_obj and coupon_obj and coupon_obj[0].product.product_id != customer_obj[0].product_id) or\
(not customer_obj and not coupon_obj)):
message = templates.get_template('SEND_SA_WRONG_CUSTOMER_UCN')
elif customer_id and not customer_obj:
message = templates.get_template('SEND_SA_WRONG_CUSTOMER_UCN')
elif coupon and not coupon_obj:
message = templates.get_template('SEND_SA_WRONG_CUSTOMER_UCN')
if message:
sa_phone = utils.get_phone_number_format(sa_phone)
sms_log(settings.BRAND, receiver=sa_phone, action=AUDIT_ACTION, message=message)
send_job_to_queue(send_invalid_keyword_message, {"phone_number":sa_phone, "message": message, "sms_client":settings.SMS_CLIENT})
LOG.info("Message sent to SA : " + message)
return False
return True
def register_customer(sms_dict, phone_number):
customer_name = sms_dict['name']
email_id = sms_dict['email_id']
try:
object = models.UserProfile.objects.get(phone_number=phone_number)
gladmind_customer_id = object.gladmind_customer_id
customer_name = object.customer_name
except ObjectDoesNotExist as odne:
gladmind_customer_id = utils.generate_unique_customer_id()
registration_date = datetime.now()
user_feed = BaseFeed()
user = user_feed.register_user('customer', username=gladmind_customer_id)
# FIXME: Check this code is getting used or not
# customer = models.UserProfile(
# user=user, gladmind_customer_id=gladmind_customer_id, phone_number=phone_number,
# customer_name=customer_name, email_id=email_id,
# registration_date=registration_date)
# customer.save()
# Please update the template variable before updating the keyword-argument
message = sms_parser.render_sms_template(status='send', keyword=sms_dict['keyword'], customer_id=gladmind_customer_id)
phone_number = utils.get_phone_number_format(phone_number)
LOG.info("customer is registered with message %s" % message)
sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message)
send_job_to_queue(send_registration_detail, {"phone_number":phone_number, "message":message, "sms_client":settings.SMS_CLIENT})
return True
def sent_otp_user_phone_number(self, request, **kwargs):
'''
Send OTP to user's phone on successfull registration
Args : phone number
Returns : OTP is sent to user's phone number
'''
if request.method != 'POST':
return HttpResponse(json.dumps({"message":"method not allowed"}), content_type="application/json",status=401)
try:
load = json.loads(request.body)
except:
return HttpResponse(content_type="application/json", status=404)
phone_number = load.get('phone_number')
if not phone_number:
return HttpBadRequest("phone_number is required.")
try:
otp = otp_handler.get_otp(phone_number=phone_number)
message = afterbuy_utils.get_template('SEND_OTP').format(otp)
send_job_to_queue(send_otp, {'phone_number':phone_number, 'message':message, 'sms_client':settings.SMS_CLIENT})
logger.info('OTP sent to mobile {0}'.format(phone_number))
data = {'status': 1, 'message': "OTP sent_successfully"}
except Exception as ex:
logger.error('Invalid details, mobile {0} and exception {1}'.format(request.POST.get('phone_number', ''),ex))
data = {'status': 0, 'message': ex}
return HttpResponse(json.dumps(data), content_type="application/json")
def customer_service_detail(sms_dict, phone_number):
customer_id = sms_dict.get('sap_customer_id', None)
message = None
try:
customer_product_data = models.CouponData.objects.select_related('product').\
filter(product__customer_phone_number=phone_number, \
product__customer_id=customer_id).\
order_by('product', 'valid_days') if customer_id else \
models.CouponData.objects.select_related('product').\
filter(product__customer_phone_number=phone_number).\
order_by('product', 'valid_days')
LOG.info(customer_product_data)
valid_product_data = []
for data in customer_product_data:
if data.status == 1 or data.status == 4:
valid_product_data.append(data)
valdata = [valid_product_data[0]]
service_list = map(lambda object: {'vin': object.product.product_id, 'usc': object.unique_service_coupon, 'valid_days': object.valid_days, 'valid_kms':object.valid_kms}, valdata)
template = templates.get_template('SEND_CUSTOMER_SERVICE_DETAIL')
msg_list = [template.format(**key_args) for key_args in service_list]
if not msg_list:
raise Exception()
message = ', '.join(msg_list)
except Exception as ex:
message = sms_parser.render_sms_template(status='invalid', keyword=sms_dict['keyword'], sap_customer_id=customer_id)
LOG.info("Send Service detail %s" % message)
phone_number = utils.get_phone_number_format(phone_number)
sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message)
send_job_to_queue(send_service_detail, {"phone_number":phone_number, "message":message, "sms_client":settings.SMS_CLIENT})
return {'status': True, 'message': message}
def generate_otp(request):
if request.method == 'POST':
try:
username = request.POST['username']
user = User.objects.get(username=username)
phone_number = ''
user_profile_obj = models.UserProfile.objects.filter(user=user)
if user_profile_obj:
phone_number = user_profile_obj[0].phone_number
logger.info('OTP request received . username: {0}'.format(username))
token = otp_handler.get_otp(user=user)
message = get_template('SEND_OTP').format(token)
send_job_to_queue(send_otp, {'phone_number': phone_number, 'message': message,
'sms_client': settings.SMS_CLIENT})
logger.info('OTP sent to mobile {0}'.format(phone_number))
# #Send email if email address exist
if user.email:
sent_otp_email(data=token, receiver=user.email, subject='Forgot Password')
return HttpResponseRedirect('/aftersell/users/otp/validate?username='******'Invalid details, mobile {0}'.format(ex))
return HttpResponseRedirect('/aftersell/users/otp/generate?details=invalid')
elif request.method == 'GET':
return render(request, 'portal/get_otp.html')
def send_customer_detail(sms_dict, phone_number):
keyword = sms_dict['params']
keyword = keyword.lower()
value = sms_dict['message']
kwargs = {}
kwargs['customer_phone_number__endswith'] = utils.get_phone_number_format(phone_number)
if value and len(value)>5 and keyword in ['vin', 'id']:
if keyword == 'id':
kwargs['customer_id'] = value
model_key = 'vin'
search_key = 'product_id'
else:
kwargs['product_id__endswith'] = value
model_key = 'id'
search_key = 'customer_id'
try:
product_object = models.ProductData.objects.get(**kwargs)
if product_object.customer_id:
message = templates.get_template('SEND_CUSTOMER_DETAILS').format(model_key, getattr(product_object, search_key))
else:
message = templates.get_template('INVALID_RECOVERY_MESSAGE').format(keyword)
except Exception as ex:
LOG.info('Details not found with message %s' % ex)
message = templates.get_template('INVALID_RECOVERY_MESSAGE').format(keyword)
else:
message = templates.get_template('SEND_INVALID_MESSAGE')
sms_log(settings.BRAND,receiver=phone_number, action=AUDIT_ACTION, message=message)
send_job_to_queue(customer_detail_recovery, {"phone_number":phone_number, "message":message, "sms_client":settings.SMS_CLIENT})
return {'status': True, 'message': message}
def redemption_request_due_date_escalation(*args, **kwargs):
time = datetime.now()
"""
send mail when due date is less than current date for redemption request
"""
brand = kwargs.get("brand", None)
args = [Q(due_date__lte=time), Q(resolution_flag=False), ~Q(status="Delivered")]
redemption_request_obj = get_model("RedemptionRequest", brand).objects.filter(reduce(operator.and_, args))
for redemption_request in redemption_request_obj:
data = get_email_template("REDEMPTION_REQUEST_DUE_DATE_EXCEED_MAIL_TO_MANAGER", brand)
data["newsubject"] = data["subject"].format(id=redemption_request.transaction_id)
data["content"] = data["body"].format(
transaction_id=redemption_request.transaction_id, status=redemption_request.status
)
escalation_list = get_model("UserProfile", brand).objects.filter(user__groups__name=Roles.REDEEMESCALATION)
escalation_list_detail = utils.get_escalation_mailing_list(escalation_list)
send_email_to_redeem_escaltion_group(data, escalation_list_detail)
message = templates.get_template("LOYALTY_DUE_DATE_EXCEED_ESCALATION", brand).format(
transaction_id=redemption_request.transaction_id, status=redemption_request.status
)
for phone_number in escalation_list_detail["sms"]:
phone_number = utils.get_phone_number_format(phone_number)
sms_log(brand, receiver=phone_number, action=AUDIT_ACTION, message=message)
send_job_to_queue(
send_loyalty_escalation_message,
{"phone_number": phone_number, "message": message, "sms_client": settings.SMS_CLIENT},
)
redemption_request.resolution_flag = True
redemption_request.save()
def update_coupon_data(sender, **kwargs):
from gladminds.sqs_tasks import send_on_product_purchase
instance = kwargs['instance']
logger.info("triggered update_coupon_data")
if instance.customer_phone_number:
product_purchase_date = instance.purchase_date
vin = instance.product_id
coupon_data = models.CouponData.objects.filter(product=instance)
for coupon in coupon_data:
mark_expired_on = product_purchase_date + \
timedelta(days=int(coupon.valid_days))
coupon_object = models.CouponData.objects.get(
product=instance, unique_service_coupon=coupon.unique_service_coupon)
coupon_object.mark_expired_on = mark_expired_on
coupon_object.extended_date = mark_expired_on
coupon_object.save()
try:
customer_name=instance.customer_name
customer_phone_number = utils.get_phone_number_format(instance.customer_phone_number)
customer_id=instance.customer_id
temp_customer_data = models.CustomerTempRegistration.objects.filter(product_data__product_id=vin)
customer_id_replaced = False
if temp_customer_data and not temp_customer_data[0].temp_customer_id == customer_id:
customer_id_replaced = True
message = templates.get_template('SEND_REPLACED_CUSTOMER_ID').format(
customer_name=customer_name, sap_customer_id=customer_id)
elif instance.customer_id.find('T') == 0:
message = templates.get_template('SEND_TEMPORARY_CUSTOMER_ID').format(
customer_name=customer_name, sap_customer_id=customer_id)
else:
if compare_purchase_date(product_purchase_date):
message = templates.get_template('SEND_CUSTOMER_ON_PRODUCT_PURCHASE').format(
customer_name=customer_name, sap_customer_id=customer_id)
else:
message = templates.get_template('SEND_REPLACED_CUSTOMER_ID').format(
customer_name=customer_name, sap_customer_id=customer_id)
sms_log(
settings.BRAND, receiver=customer_phone_number, action='SEND TO QUEUE', message=message)
send_job_to_queue(send_on_product_purchase, {"phone_number":customer_phone_number, "message":message, "sms_client":settings.SMS_CLIENT})
if not customer_id_replaced:
if str(vin).upper().startswith('VBK', 0, 3):
if str(vin).upper()[4] in ['U','G']:
message = templates.get_template('SEND_CUSTOMER_REGISTER_KTM_DUKE'
).format(customer_name=instance.customer_name,
duke_android_url="http://tinyurl.com/com-ktm-ab",
duke_web_url="http://ktmdukeweb.gladminds.co")
elif str(vin).upper()[4]=='Y':
message = templates.get_template('SEND_CUSTOMER_REGISTER_KTM_RC'
).format(customer_name=instance.customer_name,
rc_android_url="http://tinyurl.com/COM-KTM-RC",
rc_web_url="http://ktmrcweb.gladminds.co")
sms_log(settings.BRAND, receiver=instance.customer_phone_number, action='SEND TO QUEUE', message=message)
send_job_to_queue(send_on_product_purchase, {"phone_number":instance.customer_phone_number, "message":message, "sms_client":settings.SMS_CLIENT})
except Exception as ex:
logger.info("[Exception]: Signal-In Update Coupon Data %s" % ex)
def is_sa_initiator(coupon_id, service_advisor, phone_number):
coupon_data = models.CouponData.objects.filter(unique_service_coupon = coupon_id)
coupon_sa_obj = models.ServiceAdvisorCouponRelationship.objects.filter(unique_service_coupon=coupon_data\
,service_advisor=service_advisor)
if len(coupon_sa_obj)>0:
return True
else:
sa_phone = utils.get_phone_number_format(phone_number)
message = "SA is not the coupon initiator."
sms_log(settings.BRAND, receiver=sa_phone, action=AUDIT_ACTION, message=message)
send_job_to_queue(send_invalid_keyword_message, {"phone_number":sa_phone, "message": message, "sms_client":settings.SMS_CLIENT})
return False
def customer_support_helper(obj_list, data, message):
for obj in obj_list:
try:
phone = obj.user.phone_number
send_email_to_asc_customer_support(data, obj.user.user.email)
sms_log(receiver=phone, action=AUDIT_ACTION, message=message)
send_job_to_queue(
send_dfsc_customer_support,
{"phone_number": phone, "message": message, "sms_client": settings.SMS_CLIENT},
)
except Exception as ex:
logger.info("[Exception fail to send SMS to ASCs/Dealers on Customer Support] {0}".format(ex))
def close_coupon(sms_dict, phone_number):
'''
A function that handles coupon close
'''
service_advisor = validate_service_advisor(phone_number, close_action=True)
unique_service_coupon = sms_dict['usc']
customer_id = sms_dict.get('sap_customer_id', None)
message = None
if settings.LOGAN_ACTIVE:
LOGGER.post_event("close_coupon", {'sender':phone_number,
'brand':settings.BRAND})
if not service_advisor:
return {'status': False, 'message': templates.get_template('UNAUTHORISED_SA')}
sa_uinitiator_result, msg = is_sa_initiator(unique_service_coupon, service_advisor, phone_number)
if not sa_uinitiator_result:
return {'status': False, 'message': msg}
try:
product = get_product(sms_dict)
if not product:
return {'status': False, 'message': templates.get_template('INVALID_CUSTOMER_ID')}
coupon_object = models.CouponData.objects.filter(product=product.id,
unique_service_coupon=unique_service_coupon).select_related ('product')
if not coupon_object:
return {'status': False, 'message': templates.get_template('INVALID_UCN')}
coupon_object = coupon_object[0]
if coupon_object.status == 2 or coupon_object.status == 6:
message = templates.get_template('COUPON_ALREADY_CLOSED')
elif coupon_object.status == 4:
customer_phone_number = coupon_object.product.customer_phone_number
coupon_object.status = 2
coupon_object.service_advisor = service_advisor
coupon_object.closed_date = datetime.now()
coupon_object.save()
message = templates.get_template('SEND_SA_CLOSE_COUPON').format(customer_id=customer_id, usc=unique_service_coupon)
else:
message = templates.get_template('SEND_SA_WRONG_CUSTOMER_UCN')
except Exception as ex:
LOG.error("[Exception_coupon_close] {0}".format(ex))
message = templates.get_template('SEND_INVALID_MESSAGE')
finally:
LOG.info("Close coupon with message %s" % message)
phone_number = utils.get_phone_number_format(phone_number)
sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message)
send_job_to_queue(send_coupon, {"phone_number":phone_number, "message": message, "sms_client":settings.SMS_CLIENT})
return {'status': True, 'message': message}
def create_feedback(sms_dict, phone_number, email, name, dealer_email, with_detail=False):
''' Save the feedback or complain from SA and sends SMS for successfully receive '''
manager_obj = User.objects.get(groups__name=Roles.SDMANAGERS)
try:
servicedesk_user = create_servicedesk_user(name, phone_number, email)
if with_detail:
gladminds_feedback_object = models.Feedback(reporter=servicedesk_user,
type=sms_dict['type'],
summary=sms_dict['summary'], description=sms_dict['description'],
status="Open", created_date=datetime.datetime.now()
)
else:
gladminds_feedback_object = models.Feedback(reporter=servicedesk_user,
message=sms_dict['message'], status="Open",
created_date=datetime.datetime.now()
)
gladminds_feedback_object.save()
if sms_dict['file_location']:
file_obj = sms_dict['file_location']
filename_prefix = gladminds_feedback_object.id
filename_suffix = str(uuid.uuid4())
ext = file_obj.name.split('.')[-1]
file_obj.name = 'GM'+str(filename_prefix)+'_'+'_'+filename_suffix+'.'+ext
destination = settings.SDFILE_DIR.format(settings.ENV)
bucket = settings.SDFILE_BUCKET
path = utils.upload_file(destination, bucket, file_obj, logger_msg="SDFile")
gladminds_feedback_object.file_location = path
gladminds_feedback_object.save()
message = templates.get_template('SEND_RCV_FEEDBACK').format(type=gladminds_feedback_object.type)
except Exception as ex:
LOG.error(ex)
message = templates.get_template('SEND_INVALID_MESSAGE')
finally:
LOG.info("Send complain message received successfully with %s" % message)
if phone_number:
phone_number = utils.get_phone_number_format(phone_number)
sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message)
send_job_to_queue(send_servicedesk_feedback_detail, {"phone_number":phone_number, "message":message, "sms_client":settings.SMS_CLIENT})
if dealer_email:
context = utils.create_context('FEEDBACK_DETAIL_TO_DEALER', gladminds_feedback_object)
send_dealer_feedback(context, dealer_email)
context = utils.create_context('FEEDBACK_DETAIL_TO_ADIM', gladminds_feedback_object)
send_feedback_received(context, manager_obj.email)
context = utils.create_context('FEEDBACK_CONFIRMATION', gladminds_feedback_object)
send_servicedesk_feedback(context, get_reporter_details(gladminds_feedback_object.reporter, "email"))
return {'status': True, 'message': message}
def get_brand_data(sms_dict, phone_number):
product_type = sms_dict['brand_id']
try:
product_data = models.ProductData.objects.select_related('product_type').filter(customer_phone_number=phone_number, product_type__product_type=product_type)
if product_data:
product_list = map(lambda object: {'sap_customer_id':object.customer_id, 'vin': object.product_id}, product_data)
template = templates.get_template('SEND_BRAND_DATA')
msg_list = [template.format(**key_args) for key_args in product_list]
message = ', '.join(msg_list)
else:
raise Exception
except Exception as ex:
message = templates.get_template('SEND_INVALID_MESSAGE')
sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message)
send_job_to_queue(send_brand_sms_customer, {"phone_number": phone_number,
"message": message})
return {'status': True, 'message': message}
def register_rider(sms_dict, phone_number):
'''
A function that handles rider registration
'''
dealer = models.Dealer.objects.active_dealer(phone_number)
service_advisor = validate_sa_for_registration(phone_number)
if not dealer and service_advisor is None:
message = templates.get_template('UNAUTHORISED_DEALER')
return {'message' : message}
registration_number = sms_dict['registration_number']
rider_phone_number = sms_dict['phone_number']
try:
customer_support = models.Constant.objects.get(constant_name='customer_support_number_uganda').constant_value
product = models.ProductData.objects.get(veh_reg_no=registration_number)
if product:
riders = models.FleetRider.objects.filter(product=product, phone_number=rider_phone_number)
if not riders:
rider = models.FleetRider(product=product, is_active=True, phone_number=rider_phone_number)
rider.save()
else:
riders.update(is_active=True)
riders = models.FleetRider.objects.filter(Q(product=product),~Q(phone_number=rider_phone_number))
riders.update(is_active=False)
rider_message = templates.get_template('SEND_RIDER_REGISTER').format(phone_number=rider_phone_number)
sms_log(settings.BRAND, receiver=rider_phone_number, action=AUDIT_ACTION, message=rider_message)
send_job_to_queue(send_coupon, {"phone_number":rider_phone_number, "message": rider_message,
"sms_client":settings.SMS_CLIENT})
owner_message = templates.get_template('SEND_RIDER_REGISTER_TO_OWNER').format(customer_name=product.customer_name,
registration_number=product.registration_number,
phone_number=customer_support)
sms_log(settings.BRAND, receiver=product.customer_phone_number, action=AUDIT_ACTION, message=owner_message)
send_job_to_queue(send_coupon, {"phone_number":product.customer_phone_number, "message": owner_message,
"sms_client":settings.SMS_CLIENT})
message = templates.get_template('RIDER_SUCCESSFULLY_REGISTERED')
data = {'message' : message, 'status': True}
except Exception as ex:
LOG.info('[register_rider]:Exception : '.format(ex))
message = templates.get_template('INVALID_REGISTRATION_NUMBER').format(phone_number=customer_support)
data = {'message' : message, 'status': False}
return data
def send_feedback_sms(template_name, phone_number, feedback_obj, comment_obj=None):
created_date = convert_utc_to_local_time(feedback_obj.created_date)
try:
message = templates.get_template(template_name).format(
type=feedback_obj.type,
reporter=feedback_obj.reporter,
message=feedback_obj.message,
created_date=created_date,
assign_to=feedback_obj.assign_to,
priority=feedback_obj.priority)
if comment_obj and template_name == 'SEND_MSG_TO_ASSIGNEE':
message = message + 'Note :' + comment_obj.comments
except Exception as ex:
message = templates.get_template('SEND_INVALID_MESSAGE')
finally:
LOG.info("Send complain message received successfully with {0}".format(message))
phone_number = utils.get_phone_number_format(phone_number)
sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message)
send_job_to_queue(send_servicedesk_feedback_detail, {"phone_number":phone_number, "message":message, "sms_client":settings.SMS_CLIENT})
return {'status': True, 'message': message}
def user_registration_phone(self, request, **kwargs):
'''
Register user with valid phone number
Args : phone number
Returns : OTP is sent to user's phone on successful registration
'''
if request.method != 'POST':
return HttpResponse(json.dumps({"message":"method not allowed"}), content_type="application/json",status=401)
try:
load = json.loads(request.body)
except:
return HttpResponse(content_type="application/json", status=404)
phone_number = load.get('phone_number')
if not phone_number:
return HttpBadRequest("Enter phone number")
try:
consumer_obj = get_model('Consumer', settings.BRAND).objects.get(phone_number=phone_number,
user__is_active=True)
data = {'status': 1, 'message': 'phone number already registered'}
except Exception as ObjectDoesNotExist:
logger.info('Exception while registering user - {0}'.format(phone_number))
try:
user_obj = self.create_user(True, phone_number=phone_number)
consumer_obj = user_obj['consumer_obj']
data = {'status':1, 'message': 'Phone number registered successfully'}
except Exception as ex:
logger.info("Exception while registering user with phone number - {0}".format(ex))
return HttpBadRequest("Phone number could not be registered")
try:
otp = otp_handler.get_otp(phone_number=phone_number)
message = afterbuy_utils.get_template('SEND_OTP').format(otp)
send_job_to_queue(send_otp, {'phone_number': phone_number,
'message': message,'sms_client': settings.SMS_CLIENT})
consumer_obj.is_phone_verified = False
consumer_obj.save()
logger.info('OTP sent to mobile {0}'.format(phone_number))
return HttpResponse(json.dumps(data), content_type="application/json")
except Exception as ex:
logger.info('Exception while generating OTP - {0}'.format(ex))
return HttpBadRequest("OTP could not be generated")
def send_sms(template_name, phone_number, feedback_obj, comment_obj=None, brand=None):
created_date = convert_utc_to_local_time(feedback_obj.created_date, True)
try:
assignee = feedback_obj.assignee.user_profile.user.username
except:
assignee = ""
try:
due_date = feedback_obj.due_date.strftime(DATE_FORMAT)
except:
due_date = ""
reporter = None
try:
if feedback_obj.reporter:
reporter = feedback_obj.reporter.user_profile
message = templates.get_template(template_name, brand).format(
type=feedback_obj.type,
reporter=reporter,
message=feedback_obj.description,
created_date=created_date,
assign_to=assignee,
priority=feedback_obj.priority,
due_date=due_date,
id=feedback_obj.id,
)
if comment_obj and template_name == "SEND_MSG_TO_ASSIGNEE":
message = message + "Note :" + comment_obj.comment
except Exception as ex:
logger.info("send_sms: {0}".format(ex))
message = templates.get_template("SEND_INVALID_MESSAGE", brand)
finally:
logger.info("Send complain message received successfully with %s" % message)
phone_number = utils.get_phone_number_format(phone_number)
sms_log(brand, receiver=phone_number, action=AUDIT_ACTION, message=message)
send_job_to_queue(
send_servicedesk_feedback_detail,
{"phone_number": phone_number, "message": message, "sms_client": settings.SMS_CLIENT},
)
return {"status": True, "message": message}
def authenticate_user_send_otp(self, request, **kwargs):
if request.method != 'POST':
return HttpResponse(json.dumps({"message":"method not allowed"}), content_type="application/json",status=401)
try:
load = json.loads(request.body)
except:
return HttpResponse(content_type="application/json", status=404)
email = load.get('email_id')
phone_number = load.get('phone_number')
if not phone_number and not email:
return HttpBadRequest("phone_number or email is required")
try:
if phone_number:
phone_number = format_phone_number(phone_number)
logger.info('OTP request received. Mobile: {0}'.format(phone_number))
user_obj = afterbuy_model.Consumer.objects.get(phone_number=phone_number).user
otp = otp_handler.get_otp(user=user_obj)
message = afterbuy_utils.get_template('SEND_OTP').format(otp)
send_job_to_queue('send_otp', {'phone_number': phone_number,
'message': message, "sms_client": settings.SMS_CLIENT})
logger.info('OTP sent to mobile {0}'.format(phone_number))
data = {'status': 1, 'message': "OTP sent_successfully"}
#Send email if email address exist
if email:
try:
consumer_obj = afterbuy_model.Consumer.objects.get(user__email=email, is_email_verified=True)
site = RequestSite(request)
afterbuy_model.EmailToken.objects.create_email_token(consumer_obj, email, site, trigger_mail='forgot-password')
data = {'status': 1, 'message': "Password reset link sent successfully"}
return HttpResponse(json.dumps(data), content_type="application/json")
except Exception as ex:
log_message = "new user :{0}".format(ex)
logger.info(log_message)
data = {'status': 0, 'message': "Either your email is not verified or its not exist"}
except Exception as ex:
logger.error('Invalid details, mobile {0} and exception {1}'.format(request.POST.get('phone_number', ''),ex))
data = {'status': 0, 'message': "inavlid phone_number/email_id"}
return HttpResponse(json.dumps(data), content_type="application/json")
def render_sms(self, request, **kwargs):
phone_number = ""
message = ""
if request.POST.get('text'):
message = request.POST.get('text')
phone_number = request.POST.get('phoneNumber')
elif request.GET.get('cli'):
message = request.GET.get('msg')
phone_number = request.GET.get('cli')
elif request.POST.get("advisorMobile"):
phone_number = request.POST.get('advisorMobile')
customer_id = request.POST.get('customerId')
if request.POST.get('action') == 'validate':
LOGGER.info('Validating the service coupon for customer {0}'.format(customer_id))
odo_read = request.POST.get('odoRead')
service_type = request.POST.get('serviceType')
message = '{3} {0} {1} {2}'.format(customer_id, odo_read,
service_type, settings.ALLOWED_KEYWORDS['check'].upper())
LOGGER.info('Message to send: ' + message)
else:
ucn = request.POST.get('ucn')
LOGGER.info('Terminating the service coupon {0}'.format(ucn))
message = '{2} {0} {1}'.format(customer_id,
ucn, settings.ALLOWED_KEYWORDS['close'].upper())
LOGGER.info('Message to send: ' + message)
try:
to_be_serialized=sms_processing(phone_number, message, settings.BRAND)
except InvalidKeyWord as ink:
LOGGER.info("The database failed to perform {0}:{1}".format(
request.POST.get('action'), ink))
send_job_to_queue(send_invalid_keyword_message, {"phone_number":phone_number, "message":ink.template, "sms_client":settings.SMS_CLIENT})
return HttpBadRequest(json.dumps({'status':False, 'message':ink.template}))
except Exception as ex:
LOGGER.info("The database failed to perform {0}:{1}".format(
request.POST.get('action'), ex))
return HttpBadRequest(json.dumps({'status':False, 'message':ex}))
return self.create_response(request, data=to_be_serialized)
def validate_service_advisor(phone_number, close_action=False):
message = None
all_sa_dealer_obj = models.ServiceAdvisor.objects.active(phone_number)
if not len(all_sa_dealer_obj):
message = templates.get_template('UNAUTHORISED_SA')
elif close_action and all_sa_dealer_obj[0].dealer and all_sa_dealer_obj[0].dealer.use_cdms:
message = templates.get_template('DEALER_UNAUTHORISED')
if message:
sa_phone = utils.get_phone_number_format(phone_number)
sms_log(settings.BRAND, receiver=sa_phone, action=AUDIT_ACTION, message=message)
send_job_to_queue(send_service_detail, {"phone_number":sa_phone, "message": message, "sms_client":settings.SMS_CLIENT})
return None
service_advisor_obj = all_sa_dealer_obj[0]
if service_advisor_obj.dealer:
dealer_asc_obj = service_advisor_obj.dealer
dealer_asc_obj.last_transaction_date = datetime.now()
else:
dealer_asc_obj = service_advisor_obj.asc
dealer_asc_obj.last_transaction_date = datetime.now()
dealer_asc_obj.save(using=settings.BRAND)
return service_advisor_obj
def create_feedback(sms_dict, phone_number, email, name, dealer_email, user, with_detail=False):
''' Save the feedback or complain from SA and sends SMS for successfully receive '''
manager_obj = User.objects.get(groups__name=Roles.SDMANAGERS)
try:
servicedesk_user = create_servicedesk_user(name, phone_number, email)
sub_category = get_model('DepartmentSubCategories').objects.get(id=sms_dict['sub-department'])
if json.loads(sms_dict['sub-department-assignee']):
sub_department_assignee = get_model('ServiceDeskUser').objects.filter(id=sms_dict['sub-department-assignee'])
else:
sub_department_assignee = ''
if len(sub_department_assignee)>0:
gladminds_feedback_object = get_model('Feedback')(reporter=servicedesk_user,
type=sms_dict['type'],
summary=sms_dict['summary'], description=sms_dict['description'],
status="Open", created_date=datetime.datetime.now(), priority=sms_dict['priority'],
sub_department = sub_category, assignee=sub_department_assignee[0]
)
else:
gladminds_feedback_object = get_model('Feedback')(reporter=servicedesk_user,
type=sms_dict['type'],
summary=sms_dict['summary'], description=sms_dict['description'],
status="Open", created_date=datetime.datetime.now(), priority=sms_dict['priority'],
sub_department = sub_category
)
gladminds_feedback_object.save(using=settings.BRAND)
update_feedback_activities(gladminds_feedback_object, SDActions.STATUS, None,
gladminds_feedback_object.status, user)
if gladminds_feedback_object.assignee:
date = set_due_date(sms_dict['priority'], gladminds_feedback_object)
gladminds_feedback_object.due_date = date['due_date']
gladminds_feedback_object.reminder_date = date['reminder_date']
gladminds_feedback_object.save(using=settings.BRAND)
if sms_dict['file_location']:
file_obj = sms_dict['file_location']
filename_prefix = gladminds_feedback_object.id
filename_suffix = str(uuid.uuid4())
ext = file_obj.name.split('.')[-1]
file_obj.name = 'GM'+str(filename_prefix)+'_'+'_'+filename_suffix+'.'+ext
destination = settings.SDFILE_DIR.format(settings.ENV)
bucket = settings.SDFILE_BUCKET
path = utils.upload_file(destination, bucket, file_obj, logger_msg="SDFile")
gladminds_feedback_object.file_location = path
gladminds_feedback_object.save(using=settings.BRAND)
message = templates.get_template('SEND_RCV_FEEDBACK').format(type="feedback")
except Exception as ex:
LOG.error(ex)
message = templates.get_template('SEND_INVALID_MESSAGE')
finally:
LOG.info("Send complain message received successfully with %s" % message)
if phone_number:
phone_number = utils.get_phone_number_format(phone_number)
sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message)
LOG.info("[create_feedback]: {0}".format(settings.SMS_CLIENT))
send_job_to_queue(send_servicedesk_feedback_detail, {"phone_number":phone_number, "message":message, "sms_client":settings.SMS_CLIENT})
if dealer_email:
context = utils.create_context('FEEDBACK_DETAIL_TO_DEALER', gladminds_feedback_object)
send_dealer_feedback(context, dealer_email)
context = utils.create_context('FEEDBACK_DETAIL_TO_ADIM', gladminds_feedback_object)
send_feedback_received(context, manager_obj.email)
context = utils.create_context('FEEDBACK_CONFIRMATION', gladminds_feedback_object)
send_servicedesk_feedback(context, get_reporter_details(gladminds_feedback_object.reporter, "email"))
return {'status': True, 'message': message}
def validate_coupon(sms_dict, phone_number):
actual_kms = int(sms_dict['kms'])
service_type = sms_dict['service_type']
dealer_message = None
customer_message = None
customer_phone_number = None
customer_message_countdown = settings.DELAY_IN_CUSTOMER_UCN_MESSAGE
sap_customer_id = sms_dict.get('sap_customer_id', None)
service_advisor = validate_service_advisor(phone_number)
if settings.LOGAN_ACTIVE:
LOGGER.post_event("check_coupon", {'sender':phone_number,
'brand':settings.BRAND})
if not service_advisor:
return {'status': False, 'message': templates.get_template('UNAUTHORISED_SA')}
if not is_valid_data(customer_id=sap_customer_id, sa_phone=phone_number):
return {'status': False, 'message': templates.get_template('SEND_SA_WRONG_CUSTOMER_UCN')}
try:
product = get_product(sap_customer_id)
LOG.info("Associated product %s" % product)
update_exceed_limit_coupon(actual_kms, product, service_advisor)
valid_coupon = models.CouponData.objects.filter(Q(status=1) | Q(status=4) | Q(status=5), product=product,
valid_kms__gte=actual_kms, service_type=service_type) \
.select_related('vin', 'customer_phone_number__phone_number').order_by('service_type')
LOG.info("List of available valid coupons %s" % valid_coupon)
if len(valid_coupon) > 0:
update_higher_range_coupon(valid_coupon[0].valid_kms, product)
valid_coupon = valid_coupon[0]
LOG.info("valid coupon %s" % valid_coupon)
coupon_sa_obj = models.ServiceAdvisorCouponRelationship.objects.filter(unique_service_coupon=valid_coupon\
,service_advisor=service_advisor)
LOG.info('Coupon_sa_obj exists: %s' % coupon_sa_obj)
if not len(coupon_sa_obj):
coupon_sa_obj = models.ServiceAdvisorCouponRelationship(unique_service_coupon=valid_coupon\
,service_advisor=service_advisor)
coupon_sa_obj.save()
LOG.info('Coupon obj created: %s' % coupon_sa_obj)
in_progress_coupon = models.CouponData.objects.filter(product=product, valid_kms__gte=actual_kms, status=4) \
.select_related ('product').order_by('service_type')
try:
customer_phone_number = product.customer_phone_number
except Exception as ax:
LOG.error('Customer Phone Number is not stored in DB %s' % ax)
if len(in_progress_coupon) > 0:
update_inprogress_coupon(in_progress_coupon[0], actual_kms, service_advisor)
LOG.info("Validate_coupon: Already in progress coupon")
dealer_message = templates.get_template('COUPON_ALREADY_INPROGRESS').format(
service_type=in_progress_coupon[0].service_type,
customer_id=sap_customer_id)
customer_message = templates.get_template('SEND_CUSTOMER_VALID_COUPON').format(
coupon=in_progress_coupon[0].unique_service_coupon,
service_type=in_progress_coupon[0].service_type)
elif valid_coupon:
LOG.info("Validate_coupon: valid coupon")
update_coupon(valid_coupon, actual_kms, service_advisor, 4, datetime.now())
dealer_message = templates.get_template('SEND_SA_VALID_COUPON').format(
service_type=valid_coupon.service_type,
customer_id=sap_customer_id, customer_phone=product.customer_phone_number)
customer_message = templates.get_template('SEND_CUSTOMER_VALID_COUPON').format(
coupon=valid_coupon.unique_service_coupon,
service_type=valid_coupon.service_type)
else:
LOG.info("Validate_coupon: No valid or in-progress coupon")
requested_coupon_status = get_requested_coupon_status(product, service_type)
dealer_message = templates.get_template('SEND_SA_OTHER_VALID_COUPON').format(
req_service_type=service_type,
req_status=requested_coupon_status,
customer_id=sap_customer_id)
customer_message=dealer_message
sms_log(settings.BRAND, receiver=customer_phone_number, action=AUDIT_ACTION, message=customer_message)
send_job_to_queue(send_coupon_detail_customer, {"phone_number":utils.get_phone_number_format(customer_phone_number), "message":customer_message, "sms_client":settings.SMS_CLIENT},
delay_seconds=customer_message_countdown)
except Exception as ex:
LOG.info('[validate_coupon]:Exception : '.format(ex))
dealer_message = templates.get_template('SEND_INVALID_MESSAGE')
finally:
LOG.info("validate message send to SA %s" % dealer_message)
phone_number = utils.get_phone_number_format(phone_number)
sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=dealer_message)
send_job_to_queue(send_service_detail, {"phone_number": phone_number,
"message": dealer_message,
"sms_client": settings.SMS_CLIENT})
return {'status': True, 'message': dealer_message}
def register_customer(request, group=None):
post_data = request.POST
data_source = []
existing_customer = False
product_obj = models.ProductData.objects.filter(product_id=post_data['customer-vin'])
if not post_data['customer-id']:
temp_customer_id = utils.generate_temp_id(TEMP_ID_PREFIX)
else:
temp_customer_id = post_data['customer-id']
existing_customer = True
data_source.append(utils.create_purchase_feed_data(post_data, product_obj[0], temp_customer_id))
check_with_invoice_date = utils.subtract_dates(data_source[0]['product_purchase_date'], product_obj[0].invoice_date)
check_with_today_date = utils.subtract_dates(data_source[0]['product_purchase_date'], datetime.datetime.now())
if not existing_customer and check_with_invoice_date.days < 0 or check_with_today_date.days > 0:
message = "Product purchase date should be between {0} and {1}".\
format((product_obj[0].invoice_date).strftime("%d-%m-%Y"),(datetime.datetime.now()).strftime("%d-%m-%Y"))
logger.info('[Temporary_cust_registration]:: {0} Entered date is: {1}'.format(message, str(data_source[0]['product_purchase_date'])))
return json.dumps({"message": message})
try:
with transaction.atomic():
customer_obj = models.CustomerTempRegistration.objects.filter(temp_customer_id = temp_customer_id)
if customer_obj:
customer_obj = customer_obj[0]
if customer_obj.new_number != data_source[0]['customer_phone_number']:
update_count = models.Constant.objects.get(constant_name='mobile_number_update_count').constant_value
if customer_obj.mobile_number_update_count >= int(update_count) and group[0] != Roles.SDMANAGERS:
customer_update = models.CustomerUpdateFailure(product_id = product_obj[0],
customer_name = data_source[0]['customer_name'],
customer_id = customer_obj.temp_customer_id,
updated_by = "dealer-"+ str(request.user),
old_number = customer_obj.new_number,
new_number = data_source[0]['customer_phone_number'])
customer_update.save()
message = get_template('PHONE_NUMBER_UPDATE_COUNT_EXCEEDED')
return json.dumps({'message' : message})
if models.UserProfile.objects.filter(phone_number=data_source[0]['customer_phone_number']):
message = get_template('FAILED_UPDATE_PHONE_NUMBER').format(phone_number=data_source[0]['customer_phone_number'])
return json.dumps({'message': message})
old_number = customer_obj.new_number
customer_obj.new_number = data_source[0]['customer_phone_number']
customer_obj.product_data = product_obj[0]
customer_obj.sent_to_sap = False
customer_obj.dealer_asc_id = str(request.user)
customer_obj.mobile_number_update_count+=1
update_history = models.CustomerUpdateHistory(temp_customer=customer_obj,
updated_field='Phone Number',
old_value=old_number,
new_value=customer_obj.new_number,
email_flag=False)
update_history.save()
message = get_template('CUSTOMER_MOBILE_NUMBER_UPDATE').format(customer_name=customer_obj.new_customer_name, new_number=customer_obj.new_number)
for phone_number in [customer_obj.new_number, old_number]:
phone_number = utils.get_phone_number_format(phone_number)
sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message)
send_job_to_queue(send_customer_phone_number_update_message, {"phone_number":phone_number, "message":message, "sms_client":settings.SMS_CLIENT})
if models.UserProfile.objects.filter(user__groups__name=Roles.BRANDMANAGERS).exists():
groups = utils.stringify_groups(request.user)
if Roles.ASCS in groups:
dealer_asc_id = "asc : " + customer_obj.dealer_asc_id
elif Roles.DEALERS in groups:
dealer_asc_id = "dealer : " + customer_obj.dealer_asc_id
else :
dealer_asc_id = "manager : " + customer_obj.dealer_asc_id
message = get_template('CUSTOMER_PHONE_NUMBER_UPDATE').format(customer_id=customer_obj.temp_customer_id, old_number=old_number,
new_number=customer_obj.new_number, dealer_asc_id=dealer_asc_id)
managers = models.UserProfile.objects.filter(user__groups__name=Roles.BRANDMANAGERS)
for manager in managers:
phone_number = utils.get_phone_number_format(manager.phone_number)
sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message)
send_job_to_queue(send_customer_phone_number_update_message, {"phone_number":phone_number, "message":message, "sms_client":settings.SMS_CLIENT})
else:
if models.UserProfile.objects.filter(phone_number=data_source[0]['customer_phone_number']):
message = get_template('FAILED_UPDATE_PHONE_NUMBER').format(phone_number=data_source[0]['customer_phone_number'])
return json.dumps({'message': message})
customer_obj = models.CustomerTempRegistration(product_data=product_obj[0],
new_customer_name = data_source[0]['customer_name'],
new_number = data_source[0]['customer_phone_number'],
product_purchase_date = data_source[0]['product_purchase_date'],
temp_customer_id = temp_customer_id,
dealer_asc_id = str(request.user))
customer_obj.save()
logger.info('[Temporary_cust_registration]:: Initiating purchase feed')
feed_remark = FeedLogWithRemark(len(data_source),
feed_type='Purchase Feed',
action='Received', status=True)
sap_obj = SAPFeed()
feed_response = sap_obj.import_to_db(feed_type='purchase', data_source=data_source, feed_remark=feed_remark)
if feed_response.failed_feeds > 0:
logger.info('[Temporary_cust_registration]:: ' + json.dumps(feed_response.remarks))
raise ValueError('purchase feed failed!')
logger.info('[Temporary_cust_registration]:: purchase feed completed')
except Exception as ex:
logger.info(ex)
return HttpResponseBadRequest()
if existing_customer:
return json.dumps({'message': CUST_UPDATE_SUCCESS})
return json.dumps({'message': CUST_REGISTER_SUCCESS + temp_customer_id})
def validate_coupon(sms_dict, phone_number):
'''
A function that handles coupon check
'''
#vehicle_registration_no = sms_dict['veh_reg_no']
service_type = sms_dict['service_type']
dealer_message = None
customer_message = None
customer_phone_number = None
customer_message_countdown = settings.DELAY_IN_CUSTOMER_UCN_MESSAGE
vehicle_registration_no = sms_dict.get('veh_reg_no', None)
service_advisor = validate_service_advisor(phone_number)
if settings.LOGAN_ACTIVE:
LOGGER.post_event("check_coupon", {'sender':phone_number,
'brand':settings.BRAND})
if not service_advisor:
return {'status': False, 'message': templates.get_template('UNAUTHORISED_SA')}
# if not is_valid_data(customer_registration=customer_registration, sa_phone=phone_number):
# return {'status': False, 'message': templates.get_template('SEND_SA_WRONG_CUSTOMER_UCN'
if service_type not in ['1','2','3']:
return {'status': False, 'message': templates.get_template('INVALID_ST')}
try:
product_data_list = get_product(sms_dict)
customer_support = models.Constant.objects.get(constant_name='customer_support_number_uganda').constant_value
if not product_data_list:
# This new line is added
message = templates.get_template('INVALID_VEH_REG_NO').format(
support_number=customer_support)
return {'status': False, 'message': message}
# return {'status': False, 'message': templates.get_template('INVALID_VEH_REG_NO')}
LOG.info("Associated product %s" % product_data_list.product_id)
# update_exceed_limit_coupon(actual_kms, product, service_advisor)
valid_coupon = models.CouponData.objects.filter( (Q(status=1) | Q(status=4) | Q(status=5)) & Q(product=product_data_list.id)
& Q(service_type=service_type ))
try :
closed_coupon_latest = models.CouponData.objects.filter( Q(status=2) & Q(product=product_data_list.id) ).latest('closed_date')
except:
closed_coupon_latest = []
if not valid_coupon:
return {'status': False, 'message': templates.get_template('COUPON_ALREADY_CLOSED')}
LOG.info("List of available valid coupons %s" % valid_coupon)
if len(valid_coupon) > 0:
valid_coupon = valid_coupon[0]
LOG.info("valid coupon %s" % valid_coupon)
coupon_sa_obj = models.ServiceAdvisorCouponRelationship.objects.filter(unique_service_coupon=valid_coupon\
,service_advisor=service_advisor)
LOG.info('Coupon_sa_obj exists: %s' % coupon_sa_obj)
if not len(coupon_sa_obj):
coupon_sa_obj = models.ServiceAdvisorCouponRelationship(unique_service_coupon=valid_coupon\
,service_advisor=service_advisor)
coupon_sa_obj.save()
LOG.info('Coupon obj created: %s' % coupon_sa_obj)
in_progress_coupon = models.CouponData.objects.filter(product=product_data_list.id, status=4) \
.select_related ('product').order_by('service_type')
try:
customer_phone_number = product_data_list.customer_phone_number
except Exception as ax:
LOG.error('Customer Phone Number is not stored in DB %s' % ax)
rider = models.FleetRider.objects.filter(product=product_data_list, is_active=True)
rider_message={'message':None}
if rider:
rider_phone_number = rider[0].phone_number
else:
rider = None
if len(in_progress_coupon) > 0:
update_inprogress_coupon(in_progress_coupon[0], service_advisor)
LOG.info("Validate_coupon: Already in progress coupon")
if (in_progress_coupon[0] == valid_coupon):
dealer_message = templates.get_template('COUPON_ALREADY_INPROGRESS').format(
service_type=service_type,
customer_id=product_data_list.customer_id)
customer_message = templates.get_template('SEND_CUSTOMER_VALID_COUPON').format(customer_name=product_data_list.customer_name,
coupon=in_progress_coupon[0].unique_service_coupon,
service_type=in_progress_coupon[0].service_type)
rider_message = customer_message
else:
#in_progress_coupon_name = in_progress_coupon[0].unique_service_coupon
dealer_message = templates.get_template('PLEASE_CLOSE_INPROGRESS_COUPON').format(
coupon=in_progress_coupon[0].unique_service_coupon)
#dealer_message = templates.get_template('PLEASE_CLOSE_INPROGRESS_COUPON')
elif valid_coupon:
if closed_coupon_latest:
closed_coupon_date = closed_coupon_latest.closed_date
today = datetime.now(pytz.utc)
free_service_coupon_diffrence = (today-closed_coupon_date).days
if free_service_coupon_diffrence < 15:
return {'status': False, 'message': templates.get_template('INVALID_SERVICE_DIFFERENCE')}
LOG.info("Validate_coupon: valid coupon")
update_coupon(valid_coupon, service_advisor, 4, datetime.now())
dealer_message = templates.get_template('SEND_SA_VALID_COUPON').format(
service_type=service_type,
customer_id=product_data_list.customer_id, customer_phone=product_data_list.customer_phone_number)
customer_message = templates.get_template('SEND_CUSTOMER_VALID_COUPON').format(
customer_name=product_data_list.customer_name,coupon=valid_coupon.unique_service_coupon,
service_type=valid_coupon.service_type)
rider_message = customer_message
else:
LOG.info("Validate_coupon: No valid or in-progress coupon")
requested_coupon_status = get_requested_coupon_status(product_data_list.id, service_type)
dealer_message = templates.get_template('SEND_SA_OTHER_VALID_COUPON').format(
req_service_type=service_type,
req_status=requested_coupon_status,
customer_id=product_data_list.customer_id)
customer_message = dealer_message
rider_message = dealer_message
try:
val =unicodedata.normalize('NFKD', rider_message).encode('ascii','ignore')
if rider and val != None:
sms_log(settings.BRAND, receiver=rider_phone_number, action=AUDIT_ACTION, message=rider_message)
send_job_to_queue(send_coupon, {"phone_number":rider_phone_number, "message": rider_message,
"sms_client":settings.SMS_CLIENT})
except Exception as ex:
LOG.info('[Rider_message]:Exception : '.format(ex))
sms_log(settings.BRAND, receiver=customer_phone_number, action=AUDIT_ACTION, message=customer_message)
send_job_to_queue(send_coupon_detail_customer, {"phone_number":utils.get_phone_number_format(customer_phone_number), "message":customer_message, "sms_client":settings.SMS_CLIENT},
delay_seconds=customer_message_countdown)
sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=dealer_message)
send_job_to_queue(send_service_detail, {"phone_number": phone_number,
"message": dealer_message,
"sms_client": settings.SMS_CLIENT})
except Exception as ex:
LOG.info('[validate_coupon]:Exception : '.format(ex))
dealer_message = templates.get_template('SEND_INVALID_MESSAGE')
finally:
LOG.info("validate message send to SA %s" % dealer_message)
phone_number = utils.get_phone_number_format(phone_number)
sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=dealer_message)
send_job_to_queue(send_service_detail, {"phone_number": phone_number,
"message": dealer_message,
"sms_client": settings.SMS_CLIENT})
return {'status': True, 'message': dealer_message}
def register_owner(sms_dict, phone_number):
'''
A function that handles owner registration
'''
dealer = models.Dealer.objects.active_dealer(phone_number)
service_advisor = validate_sa_for_registration(phone_number)
if not dealer and (service_advisor is None) :
message = templates.get_template('UNAUTHORISED_DEALER')
return {'message' : message, 'status': False}
registration_number = sms_dict['registration_number']
owner_phone_number = sms_dict['phone_number']
customer_name = sms_dict['customer_name']
customer_district = sms_dict['district']
customer_support = models.Constant.objects.get(constant_name='customer_support_number_uganda').constant_value
try:
purchase_date_format = models.Constant.objects.get(constant_name='purchase_date_format',
country__name='UG').constant_value
purchase_date = datetime.strptime(sms_dict['purchase_date'], purchase_date_format)
if purchase_date > datetime.now():
message = templates.get_template('INVALID_REGISTRATION_NUMBER_OR_PURCHASE_DATE').format(phone_number=customer_support)
return {'message' : message, 'status': False}
product = models.ProductData.objects.get(veh_reg_no=registration_number)
all_products = models.ProductData.objects.all().aggregate(Max('customer_id'))
if all_products['customer_id__max']:
customer_id = int(all_products['customer_id__max']) + 1
else:
customer_id = models.Constant.objects.get(constant_name='customer_id').constant_value
if not product.purchase_date:
product.customer_name = customer_name
product.customer_phone_number = owner_phone_number
product.purchase_date = purchase_date
product.customer_id = customer_id
product.customer_district = customer_district
update_coupon_expiry(product, purchase_date)
product.save()
owner_message = templates.get_template('SEND_OWNER_REGISTER').format(customer_name=product.customer_name,
customer_id=product.customer_id)
sms_log(settings.BRAND, receiver=product.customer_phone_number, action=AUDIT_ACTION, message=owner_message)
send_job_to_queue(send_coupon, {"phone_number":product.customer_phone_number, "message": owner_message,
"sms_client":settings.SMS_CLIENT})
elif(product.customer_phone_number != owner_phone_number):
update_history = models.CustomerUpdateHistory(updated_field='phone_number',
old_value=product.customer_phone_number,
new_value=owner_phone_number,
product=product)
update_history.save()
old_number = product.customer_phone_number
product.customer_phone_number = owner_phone_number
product.save()
owner_message = templates.get_template('OWNER_MOBILE_NUMBER_UPDATE').format(customer_name=product.customer_name,
new_number=owner_phone_number, phone_number=customer_support)
for phone_number in [old_number, owner_phone_number]:
sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=owner_message)
send_job_to_queue(send_coupon, {"phone_number":phone_number, "message": owner_message,
"sms_client":settings.SMS_CLIENT})
else:
if product.customer_phone_number == owner_phone_number:
sa_message_for_owner = templates.get_template('OWNER_MOBILE_NUMBER_EXIST')
send_job_to_queue(send_service_detail, {"phone_number": phone_number,
"message": sa_message_for_owner,
"sms_client": settings.SMS_CLIENT})
return {'message' : sa_message_for_owner, 'status': False}
data = {'message' : owner_message, 'status': True}
except Exception as ex:
LOG.info('[register_owner]:Exception : '.format(ex))
message = templates.get_template('INVALID_REGISTRATION_NUMBER_OR_PURCHASE_DATE').format(phone_number=customer_support)
sms_log(settings.BRAND, receiver=owner_phone_number, action=AUDIT_ACTION, message=message)
# send_job_to_queue(send_coupon, {"phone_number":owner_phone_number, "message": message,
# "sms_client":settings.SMS_CLIENT})
data = {'message' : message, 'status': False}
return data
