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