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 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 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 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_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_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 customer_support_helper(obj_list, data, message):
for obj in obj_list:
try:
phone = obj.user.phone_number
send_email_to_asc_customer_support(data, obj.user.user.email)
sms_log(receiver=phone, action=AUDIT_ACTION, message=message)
send_job_to_queue(
send_dfsc_customer_support,
{"phone_number": phone, "message": message, "sms_client": settings.SMS_CLIENT},
)
except Exception as ex:
logger.info("[Exception fail to send SMS to ASCs/Dealers on Customer Support] {0}".format(ex))
def send_brand_sms_customer(*args, **kwargs):
status = "success"
brand = kwargs.get("brand", None)
try:
phone_number = kwargs.get("phone_number", None)
message = kwargs.get("message", None)
set_gateway(**kwargs)
except (Exception, MessageSentFailed) as ex:
status = "failed"
send_brand_sms_customer.retry(exc=ex, countdown=10, kwargs=kwargs, max_retries=5)
finally:
sms_log(brand, status=status, receiver=phone_number, message=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_dfsc_customer_support(*args, **kwargs):
"""
sends customer support phone number
"""
status = "success"
try:
phone_number = kwargs.get("phone_number", None)
message = kwargs.get("message", None)
set_gateway(**kwargs)
except (Exception, MessageSentFailed) as ex:
status = "failed"
send_reminder_message.retry(exc=ex, countdown=10, kwargs=kwargs, max_retries=5)
finally:
sms_log(status=status, receiver=phone_number, message=message)
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 send_coupon_validity_detail(*args, **kwargs):
"""
send sms to service advisor, whether the coupon is valid or not
"""
status = "success"
brand = kwargs.get("brand", None)
try:
phone_number = kwargs.get("phone_number", None)
message = kwargs.get("message", None)
set_gateway(**kwargs)
except (Exception, MessageSentFailed) as ex:
status = "failed"
send_coupon_validity_detail.retry(exc=ex, countdown=10, kwargs=kwargs, max_retries=5)
finally:
sms_log(brand, status=status, receiver=phone_number, message=message)
def send_servicedesk_feedback_detail(*args, **kwargs):
"""
send sms in service desk
"""
status = "success"
brand = kwargs.get("brand", None)
try:
phone_number = kwargs.get("phone_number", None)
message = kwargs.get("message", None)
set_gateway(**kwargs)
except (Exception, MessageSentFailed) as ex:
status = "failed"
send_servicedesk_feedback_detail.retry(exc=ex, countdown=10, kwargs=kwargs, max_retries=5)
finally:
sms_log(brand, status=status, receiver=phone_number, message=message)
def send_loyalty_escalation_message(*args, **kwargs):
"""
sends escalation message related to loyalty
"""
status = "success"
brand = kwargs.get("brand", None)
try:
phone_number = kwargs.get("phone_number", None)
message = kwargs.get("message", None)
set_gateway(**kwargs)
except (Exception, MessageSentFailed) as ex:
status = "failed"
send_reminder_message.retry(exc=ex, countdown=10, kwargs=kwargs, max_retries=5)
finally:
sms_log(brand, status=status, receiver=phone_number, message=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 send_registration_detail(*args, **kwargs):
"""
send sms to customer on customer registration
"""
status = "success"
brand = kwargs.get("brand", None)
logger.info("message addded")
try:
phone_number = kwargs.get("phone_number", None)
message = kwargs.get("message", None)
set_gateway(**kwargs)
except (Exception, MessageSentFailed) as ex:
status = "failed"
send_registration_detail.retry(exc=ex, countdown=10, kwargs=kwargs, max_retries=5)
finally:
sms_log(brand, status=status, receiver=phone_number, message=message)
def create_feedback(sms_dict, phone_number, email, name, dealer_email, with_detail=False):
''' Save the feedback or complain from SA and sends SMS for successfully receive '''
manager_obj = User.objects.get(groups__name=Roles.SDMANAGERS)
try:
servicedesk_user = create_servicedesk_user(name, phone_number, email)
if with_detail:
gladminds_feedback_object = models.Feedback(reporter=servicedesk_user,
type=sms_dict['type'],
summary=sms_dict['summary'], description=sms_dict['description'],
status="Open", created_date=datetime.datetime.now()
)
else:
gladminds_feedback_object = models.Feedback(reporter=servicedesk_user,
message=sms_dict['message'], status="Open",
created_date=datetime.datetime.now()
)
gladminds_feedback_object.save()
if sms_dict['file_location']:
file_obj = sms_dict['file_location']
filename_prefix = gladminds_feedback_object.id
filename_suffix = str(uuid.uuid4())
ext = file_obj.name.split('.')[-1]
file_obj.name = 'GM'+str(filename_prefix)+'_'+'_'+filename_suffix+'.'+ext
destination = settings.SDFILE_DIR.format(settings.ENV)
bucket = settings.SDFILE_BUCKET
path = utils.upload_file(destination, bucket, file_obj, logger_msg="SDFile")
gladminds_feedback_object.file_location = path
gladminds_feedback_object.save()
message = templates.get_template('SEND_RCV_FEEDBACK').format(type=gladminds_feedback_object.type)
except Exception as ex:
LOG.error(ex)
message = templates.get_template('SEND_INVALID_MESSAGE')
finally:
LOG.info("Send complain message received successfully with %s" % message)
if phone_number:
phone_number = utils.get_phone_number_format(phone_number)
sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message)
send_job_to_queue(send_servicedesk_feedback_detail, {"phone_number":phone_number, "message":message, "sms_client":settings.SMS_CLIENT})
if dealer_email:
context = utils.create_context('FEEDBACK_DETAIL_TO_DEALER', gladminds_feedback_object)
send_dealer_feedback(context, dealer_email)
context = utils.create_context('FEEDBACK_DETAIL_TO_ADIM', gladminds_feedback_object)
send_feedback_received(context, manager_obj.email)
context = utils.create_context('FEEDBACK_CONFIRMATION', gladminds_feedback_object)
send_servicedesk_feedback(context, get_reporter_details(gladminds_feedback_object.reporter, "email"))
return {'status': True, 'message': message}
def get_brand_data(sms_dict, phone_number):
product_type = sms_dict['brand_id']
try:
product_data = models.ProductData.objects.select_related('product_type').filter(customer_phone_number=phone_number, product_type__product_type=product_type)
if product_data:
product_list = map(lambda object: {'sap_customer_id':object.customer_id, 'vin': object.product_id}, product_data)
template = templates.get_template('SEND_BRAND_DATA')
msg_list = [template.format(**key_args) for key_args in product_list]
message = ', '.join(msg_list)
else:
raise Exception
except Exception as ex:
message = templates.get_template('SEND_INVALID_MESSAGE')
sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message)
send_job_to_queue(send_brand_sms_customer, {"phone_number": phone_number,
"message": message})
return {'status': True, 'message': message}
def register_rider(sms_dict, phone_number):
'''
A function that handles rider registration
'''
dealer = models.Dealer.objects.active_dealer(phone_number)
service_advisor = validate_sa_for_registration(phone_number)
if not dealer and service_advisor is None:
message = templates.get_template('UNAUTHORISED_DEALER')
return {'message' : message}
registration_number = sms_dict['registration_number']
rider_phone_number = sms_dict['phone_number']
try:
customer_support = models.Constant.objects.get(constant_name='customer_support_number_uganda').constant_value
product = models.ProductData.objects.get(veh_reg_no=registration_number)
if product:
riders = models.FleetRider.objects.filter(product=product, phone_number=rider_phone_number)
if not riders:
rider = models.FleetRider(product=product, is_active=True, phone_number=rider_phone_number)
rider.save()
else:
riders.update(is_active=True)
riders = models.FleetRider.objects.filter(Q(product=product),~Q(phone_number=rider_phone_number))
riders.update(is_active=False)
rider_message = templates.get_template('SEND_RIDER_REGISTER').format(phone_number=rider_phone_number)
sms_log(settings.BRAND, receiver=rider_phone_number, action=AUDIT_ACTION, message=rider_message)
send_job_to_queue(send_coupon, {"phone_number":rider_phone_number, "message": rider_message,
"sms_client":settings.SMS_CLIENT})
owner_message = templates.get_template('SEND_RIDER_REGISTER_TO_OWNER').format(customer_name=product.customer_name,
registration_number=product.registration_number,
phone_number=customer_support)
sms_log(settings.BRAND, receiver=product.customer_phone_number, action=AUDIT_ACTION, message=owner_message)
send_job_to_queue(send_coupon, {"phone_number":product.customer_phone_number, "message": owner_message,
"sms_client":settings.SMS_CLIENT})
message = templates.get_template('RIDER_SUCCESSFULLY_REGISTERED')
data = {'message' : message, 'status': True}
except Exception as ex:
LOG.info('[register_rider]:Exception : '.format(ex))
message = templates.get_template('INVALID_REGISTRATION_NUMBER').format(phone_number=customer_support)
data = {'message' : message, 'status': False}
return data
def 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 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})
