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 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 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 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 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 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 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 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_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 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 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 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 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 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_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 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 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 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 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
