def check_point_balance(self, sms_dict, phone_number): '''send balance point of the user''' try: mechanic = get_model('Member').objects.using(settings.BRAND).filter(phone_number=utils.mobile_format(phone_number)) if not mechanic: message=get_template('UNREGISTERED_USER') raise ValueError('Unregistered user') elif mechanic and mechanic[0].form_status=='Incomplete': message=get_template('INCOMPLETE_FORM') raise ValueError('Incomplete user details') total_points=mechanic[0].total_points today = datetime.now().strftime('%d/%m/%Y') message=get_template('SEND_BALANCE_POINT').format( mechanic_name=mechanic[0].first_name, total_points=total_points, today=today) except Exception as ex: LOG.error('[check_point_balance]:{0}:: {1}'.format( phone_number, ex)) finally: phone_number = utils.get_phone_number_format(phone_number) sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message) self.queue_service(send_point, {'phone_number': phone_number, 'message': message, "sms_client": settings.SMS_CLIENT}) return {'status': True, 'message': message}
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 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 get_customers_to_send_reminder(*args, **kwargs): from gladminds.sqs_tasks import send_reminder_message day = kwargs.get('reminder_day', None) brand= kwargs.get('brand', None) today_date = datetime.now().date() reminder_date = datetime.now().date()+timedelta(days=day) results = get_model("CouponData", brand).objects.select_for_update().filter(mark_expired_on__range=(today_date, reminder_date), last_reminder_date__isnull=True, status=1).select_related('vin', 'customer_phone_number__phone_number') for reminder in results: product = reminder.vin phone_number = product.customer_phone_number.phone_number usc = reminder.unique_service_coupon vin = product.vin expired_date = reminder.mark_expired_on.strftime('%d/%m/%Y') valid_kms = reminder.valid_kms message = templates.get_template('SEND_CUSTOMER_COUPON_REMINDER').format(usc=usc, vin=vin, expired_date=expired_date, valid_kms=valid_kms) send_reminder_message.delay(phone_number=phone_number, message=message) sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message) reminder.last_reminder_date = datetime.now() reminder.save() user = get_model("UserProfile", brand).objects.filter(phone_number=phone_number) notification = afterbuy_models.UserNotification(user=user[0],message=message, notification_date=datetime.now(), notification_read=0) notification.save() transaction.commit()
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 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 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 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 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 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_welcome_sms(self, mech): '''Send welcome sms to mechanics when registered''' phone_number=utils.get_phone_number_format(mech.phone_number) message=get_template('COMPLETE_FORM').format( mechanic_name=mech.first_name, member_id=mech.permanent_id) sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message) self.queue_service(send_loyalty_sms, {'phone_number': phone_number, 'message': message, "sms_client": settings.SMS_CLIENT}) LOG.error('[send_welcome_sms]:{0}:: {1}'.format( phone_number, message))
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 send_welcome_kit_delivery_retailer(self, redemption_request): '''Send redemption request sms to retailer''' retailer = redemption_request.retailer phone_number=utils.get_phone_number_format(retailer.mobile) message=get_template('WELCOME_KIT_DELIVERY_RETAILER').format( retailer_name=retailer.retailer_name) sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message) self.queue_service(send_loyalty_sms, {'phone_number': phone_number, 'message': message, "sms_client": settings.SMS_CLIENT}) LOG.error('[send_request_status_sms]:{0}:: {1}'.format( phone_number, message))
def redeem_point(self, sms_dict, phone_number): '''redeem points with given upc for Member''' product_codes = sms_dict['product_id'].upper().split() try: retailer = get_model('Retailer').objects.using(settings.BRAND).filter(mobile=utils.mobile_format(phone_number)) if retailer: message = self.redeem_point_retailer(product_codes, phone_number, sms_dict,retailer) return {'status': True, 'message': message} mechanic = get_model('Member').objects.using(settings.BRAND).filter(phone_number=utils.mobile_format(phone_number)) if not mechanic: message=get_template('UNREGISTERED_USER') raise ValueError('Unregistered user') elif mechanic and mechanic[0].form_status=='Incomplete': message=get_template('INCOMPLETE_FORM') raise ValueError('Incomplete user details') elif mechanic and (mechanic[0].mechanic_id!=sms_dict['member_id'] and mechanic[0].permanent_id!=sms_dict['member_id']): message=get_template('INVALID_MEMBER_ID').format(mechanic_name=mechanic[0].first_name) raise ValueError('Invalid user-ID') products=get_model('ProductCatalog').objects.using(settings.BRAND).filter(product_id__in=product_codes) redeem_points=0 if len(products)==len(product_codes): for product in products: redeem_points=redeem_points+product.points left_points=mechanic[0].total_points-redeem_points if left_points>=0: total_points=self.update_points(mechanic[0], redeem=redeem_points) transaction_ids = self.register_redemption_request(mechanic, products) message=get_template('SEND_REDEEM_POINT').format( mechanic_name=mechanic[0].first_name, transaction_id=transaction_ids, total_points=total_points) else: if len(products)==1: message=get_template('SEND_INSUFFICIENT_POINT_SINGLE').format( mechanic_name=mechanic[0].first_name, total_points=mechanic[0].total_points, shortage_points=abs(left_points)) else: message=get_template('SEND_INSUFFICIENT_POINT_MULTIPLE').format( mechanic_name=mechanic[0].first_name, shortage_points=abs(left_points)) else: message=get_template('INVALID_PRODUCT_ID') except Exception as ex: LOG.error('[redeem_point]:{0}:: {1}'.format(phone_number, ex)) finally: phone_number = utils.get_phone_number_format(phone_number) sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message) self.queue_service(send_point, {'phone_number': phone_number, 'message': message, "sms_client": settings.SMS_CLIENT}) return {'status': True, 'message': message}
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 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 send_request_status_sms_retailer(self, redemption_request): '''Send redemption request sms to retailer''' retailer = redemption_request.retailer phone_number=utils.get_phone_number_format(retailer.mobile) message=get_template('REDEMPTION_PRODUCT_STATUS_RETAILER').format( retailer_name=retailer.retailer_name, transaction_id=redemption_request.transaction_id, product_name=redemption_request.product.description, status=redemption_request.status.lower()) sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message) self.queue_service(send_loyalty_sms, {'phone_number': phone_number, 'message': message, "sms_client": settings.SMS_CLIENT}) LOG.error('[send_request_status_sms]:{0}:: {1}'.format( phone_number, message))
def dfsc_customer_support(*args, **kwargs): brand = kwargs.get("brand", None) asc_obj = ( get_model("AuthorizedServiceCenter", brand).objects.filter(user__state="MAH").select_related("user, user__user") ) dealer_obj = get_model("Dealer", brand).objects.filter(user__state="MAH").select_related("user, user__user") data = get_email_template("CUSTOMER_SUPPORT_FOR_DFSC", brand) data["newsubject"] = data["subject"] data["content"] = data["body"] message = templates.get_template("CUSTOMER_SUPPORT_FOR_DFSC", brand) customer_support_helper(asc_obj, data, message) customer_support_helper(dealer_obj, data, message)
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 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 get_customers_to_send_reminder_by_admin(*args, **kwargs): from gladminds.sqs_tasks import send_reminder_message today = datetime.now().date() brand= kwargs.get('brand', None) results = get_model("CouponData", brand).objects.filter(schedule_reminder_date__day=today.day, schedule_reminder_date__month=today.month, schedule_reminder_date__year=today.year, status=1).select_related('product_id', 'customer_phone_number') for reminder in results: product_obj = reminder.product phone_number = product_obj.customer_phone_number usc = reminder.unique_service_coupon vin = product_obj.product_id expired_date = reminder.mark_expired_on.strftime('%d/%m/%Y') valid_kms = reminder.valid_kms message = templates.get_template('SEND_CUSTOMER_COUPON_REMINDER').format(usc=usc, vin=vin, expired_date=expired_date, valid_kms=valid_kms) send_reminder_message.delay(phone_number=phone_number, message=message) sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message) reminder.last_reminder_date = datetime.now() reminder.schedule_reminder_date = None reminder.save() transaction.commit()
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 accumulate_point_retailer(self, retailer, phone_number, unique_product_codes): '''accumulate points with given upc for retailer''' unique_product_codes = unique_product_codes valid_upc=[] valid_product_number=[] invalid_upcs_message='' try: if len(unique_product_codes)>constants.MAX_UPC_ALLOWED: message=get_template('MAX_ALLOWED_UPC').format( max_limit=constants.MAX_UPC_ALLOWED) raise ValueError('Maximum allowed upc exceeded') if not retailer: message=get_template('UNREGISTERED_USER') raise ValueError('Unregistered user') elif retailer and retailer[0].form_status=='Incomplete': message=get_template('INCOMPLETE_FORM') raise ValueError('Incomplete user details') state_code = retailer[0].state.state_code spares = get_model('SparePartUPC').objects.filter(unique_part_code__in=unique_product_codes,is_used_by_retailer=False) if not spares: message=get_template('SEND_UPC_IS_USED') raise ValueError('Requested UPC is already used.') added_points=0 spare_upc_part_map={} total_points=retailer[0].total_points if spares: for spare in spares: valid_product_number.append(spare.part_number) if not spare_upc_part_map.has_key(spare.part_number): spare_upc_part_map[spare.part_number]=[] spare_upc_part_map[spare.part_number].append(spare.unique_part_code.upper()) spare_points = get_model('SparePartPoint').objects.get_part_number(valid_product_number, state_code) if spare_points: retailer_accumulation_log=get_model('AccumulationRequestRetailer')(retailer=retailer[0], points=0,total_points=0) retailer_accumulation_log.save(using=settings.BRAND) for spare_point in spare_points: if spare_point.valid_from and spare_point.valid_till: if self.check_date_validity(spare_point.valid_from,spare_point.valid_till): added_points=added_points+(len(spare_upc_part_map[spare_point.part_number]) * spare_point.points) valid_upc.extend(spare_upc_part_map[spare_point.part_number]) else: added_points=added_points+(len(spare_upc_part_map[spare_point.part_number]) * spare_point.points) valid_upc.extend(spare_upc_part_map[spare_point.part_number]) total_points=self.update_points_retailer(retailer[0], accumulate=added_points) valid_spares = get_model('SparePartUPC').objects.filter(unique_part_code__in=valid_upc,is_used_by_retailer=False) for spare in valid_spares: retailer_accumulation_log.upcs.add(spare) retailer_accumulation_log.points=added_points retailer_accumulation_log.total_points=total_points retailer_accumulation_log.save(using=settings.BRAND) valid_spares.using(settings.BRAND).update(is_used_by_retailer=True) invalid_upcs = list(set(unique_product_codes).difference(valid_upc)) if invalid_upcs: invalid_upcs_message=' Invalid Entry... {0} does not exist in our records.'.format( (', '.join(invalid_upcs))) used_upcs = get_model('SparePartUPC').objects.filter(unique_part_code__in=valid_upc,is_used_by_retailer=True) # if used_upcs: # accumulation_requests = get_model('AccumulationRequest').objects.using(settings.BRAND).filter(upcs__in=used_upcs).prefetch_related('upcs').select_related('upcs') # accumulation_dict = {} # try: # for accumulation_request in accumulation_requests: # for upcs in accumulation_request.upcs.values(): # accumulation_dict[upcs['unique_part_code']] = accumulation_request # for used_upc in used_upcs: # discrepant_accumulation_log = get_model('DiscrepantAccumulation')(new_member=mechanic[0], upc = used_upc, # accumulation_request=accumulation_dict[used_upc]) # discrepant_accumulation_log.save(using=settings.BRAND) # except Exception as ex: # LOG.error('[accumulate_point]:{0}:: {1}'.format(phone_number, ex)) if len(unique_product_codes)==1 and invalid_upcs: message=get_template('SEND_INVALID_UPC') else: message=get_template('SEND_ACCUMULATED_POINT_RETAILER').format( retailer_name=retailer[0].retailer_name, added_points=added_points, total_points=total_points, invalid_upcs=invalid_upcs_message) except Exception as ex: LOG.error('[accumulate_point]:{0}:: {1}'.format(phone_number, ex)) finally: phone_number = utils.get_phone_number_format(phone_number) sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message) self.queue_service(send_point, {'phone_number': phone_number, 'message': message, "sms_client": settings.SMS_CLIENT}) return 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
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 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}