def get_feedbacks(user, status, priority, type, search=None):
feedbacks = []
if type == ALL or type is None:
type_filter = get_list_from_set(FEEDBACK_TYPE)
else:
type_filter = [type]
if priority == ALL or priority is None:
priority_filter = get_list_from_set(DEMO_PRIORITY)
else:
priority_filter = [priority]
if status is None or status == 'active':
status_filter = ['Open', 'Pending', 'In Progress']
else:
if status == ALL:
status_filter = get_list_from_set(FEEDBACK_STATUS)
else:
status_filter = [status]
sa_id_list = []
if user.groups.filter(name=Roles.DEALERS).exists():
sa_list = get_model('ServiceAdvisor').objects.active_under_dealer(user)
if sa_list:
for sa in sa_list:
sa_id_list.append(sa.service_advisor_id)
sa_id_list.append(user)
feedbacks = get_model('Feedback').objects.filter(reporter__name__in=sa_id_list, status__in=status_filter,
priority__in=priority_filter, type__in=type_filter
).order_by('-created_date')
if user.groups.filter(name=Roles.DEALERADMIN).exists():
dealers = get_model('Dealer').objects.all()
for dealer in dealers:
sa_id_list.append(dealer.dealer_id)
sa_id_list.append(user)
feedbacks = get_model('Feedback').objects.filter(reporter__name__in=sa_id_list, status__in=status_filter,
priority__in=priority_filter, type__in=type_filter
).order_by('-created_date')
if user.groups.filter(name=Roles.ASCS).exists():
sa_list = get_model('ServiceAdvisor').objects.active_under_asc(user)
sa_id_list = []
if sa_list:
for sa in sa_list:
sa_id_list.append(sa.service_advisor_id)
sa_id_list.append(user)
feedbacks = get_model('Feedback').objects.filter(reporter__name__in=sa_id_list, status__in=status_filter,
priority__in=priority_filter, type__in=type_filter
).order_by('-created_date')
if user.groups.filter(name=Roles.SDMANAGERS).exists():
feedbacks = get_model('Feedback').objects.filter(status__in=status_filter, priority__in=priority_filter,
type__in=type_filter).order_by('-created_date')
if user.groups.filter(name=Roles.SDOWNERS).exists():
user_profile = get_model('UserProfile').objects.filter(user=user)
servicedesk_user = get_model('ServiceDeskUser').objects.filter(user_profile=user_profile[0])
feedbacks = get_model('Feedback').objects.filter(assignee=servicedesk_user[0], status__in=status_filter,
priority__in=priority_filter, type__in=type_filter).order_by('-created_date')
return feedbacks
def save_help_desk_data(request):
fields = ['description', 'advisorMobile', 'type', 'summary', 'priority', 'department', 'sub-department', 'sub-department-assignee']
sms_dict = {}
for field in fields:
sms_dict[field] = request.POST.get(field, None)
if request.FILES:
sms_dict['file_location'] = request.FILES['sd_file']
else:
sms_dict['file_location'] = None
user_profile = get_model('UserProfile').objects.get(user__username=str(sms_dict['advisorMobile']))
if request.user.groups.filter(name=Roles.DEALERS).exists():
dealer_asc_obj = get_model('Dealer').objects.get(dealer_id=request.user)
elif request.user.groups.filter(name=Roles.ASCS).exists():
dealer_asc_obj = get_model('AuthorizedServiceCenter').objects.get(asc_id=request.user)
else:
dealer_asc_obj = None
if dealer_asc_obj:
dealer_asc_email = dealer_asc_obj.user.user.email
else:
dealer_asc_email = None
phone_number = getattr(user_profile, 'phone_number') or None
email = getattr(user_profile.user, 'email') or None
return create_feedback(sms_dict, phone_number, email,
user_profile.user.username, dealer_asc_email,
request.user, with_detail=True)
def initiate_welcome_kit(self, mechanic_obj):
'''Saves the welcome kit request for processing'''
welcome_kit=get_model('WelcomeKit').objects.filter(member=mechanic_obj)
if not welcome_kit:
delivery_address = ', '.join(filter(None, (mechanic_obj.shop_number,
mechanic_obj.shop_name,
mechanic_obj.shop_address)))
partner=None
packed_by=None
partner_list = get_model('Partner').objects.using(settings.BRAND).all()
if len(partner_list)==1:
partner=partner_list[0]
packed_by=partner.user.user.username
date = self.set_date('Welcome Kit', 'Open')
welcome_kit=get_model('WelcomeKit')(member=mechanic_obj,
delivery_address=delivery_address,
partner=partner,
packed_by=packed_by,
due_date=date['due_date'],
expected_delivery_date=date['expected_delivery_date'])
welcome_kit.save(using=settings.BRAND)
self.send_welcome_kit_mail_to_partner(welcome_kit)
else:
welcome_kit=welcome_kit[0]
return welcome_kit
def send_reminders_for_servicedesk(*args, **kwargs):
manager_obj = User.objects.get(groups__name="sdm")
time = datetime.now()
"""
send mail when reminder_date is less than current date or when due date is less than current date
"""
brand = kwargs.get("brand", None)
feedback_obj = get_model("Feedback", brand).objects.filter(
reminder_date__lte=time, reminder_flag=False
) or get_model("Feedback", brand).objects.filter(due_date__lte=time, resolution_flag=False)
for feedback in feedback_obj:
if not feedback.reminder_flag:
context = utils.create_context("DUE_DATE_EXCEEDED_MAIL_TO_AGENT", feedback)
send_due_date_reminder(context, feedback.assignee.user_profile.user.email)
context = utils.create_context("DUE_DATE_REMINDER_MAIL_TO_MANAGER", feedback)
send_due_date_reminder(context, manager_obj.email)
feedback.reminder_flag = False
if not feedback.resolution_flag:
context = utils.create_context("DUE_DATE_EXCEEDED_MAIL_TO_MANAGER", feedback)
escalation_list = get_model("UserProfile", brand).objects.filter(user__groups__name=Roles.SDESCALATION)
escalation_list_detail = utils.get_escalation_mailing_list(escalation_list)
send_due_date_exceeded(context, escalation_list_detail["mail"])
for phone_number in escalation_list_detail["sms"]:
send_sms("DUE_DATE_EXCEEDED_ESCALATION", phone_number, feedback, brand)
feedback.resolution_flag = False
feedback.save()
def export_data(self, brand=None):
results = get_model('AccumulationRequest').objects.using(brand).filter(sent_to_sap=0)
items = []
total_failed = 0
item_batch = {
'T_STAMP': datetime.now().strftime("%Y-%m-%dT%H:%M:%S")}
for accumulation in results:
try:
item = {
"CRDAT": accumulation.created_date.date().strftime("%Y-%m-%d"),
"TANSSID": accumulation.transaction_id,
"MECHID": accumulation.member.permanent_id,
"MOBNO": str(accumulation.member.phone_number),
}
upcs = accumulation.upcs.all()
part_number_list=upcs.values_list('part_number', flat=True)
upcs_point=get_model('SparePartPoint').objects.using(brand).filter(part_number__in=part_number_list, territory=accumulation.member.state.state_code)
for upc in upcs:
temp = item.copy()
temp['UPCED'] = str(upc.unique_part_code)
upc_point = filter(lambda point: upc.part_number == point.part_number, upcs_point)
temp['POINTS'] = upc_point[0].points
items.append(temp)
except Exception as ex:
logger.error("[ExportAccumulationFeed]: error fetching from db {0}".format(ex))
total_failed = total_failed + 1
return items, item_batch, total_failed
def change_status(self, request, **kwargs):
'''
Change status to Either approved or rejected
'''
self.is_authenticated(request)
if request.method != 'POST':
return HttpResponse(json.dumps({"message" : "Method not allowed"}), content_type= "application/json",
status=400)
history_id = kwargs['history_id']
try:
load = json.loads(request.body)
except:
return HttpResponse(content_type="application/json", status=404)
comment = load.get('comment')
status = load.get('status')
user = request.user
approval_flag=False
status_values = ['Approved','Rejected']
try:
'''
Changing the status to approved/rejected in VisualisationUploadHistory
'''
if status in status_values:
sbom_details = get_model('VisualisationUploadHistory').objects.filter(id=history_id)
(sku_code,bom_number,plate_id,eco_number) = sbom_details.values_list('sku_code','bom_number','plate_id','eco_number')[0]
visualisation_data = sbom_details[0]
visualisation_data.status = status
try:
'''
changing the ECO-I status to approved/rejected
'''
eco_i = get_model('ECOImplementation').objects.get(eco_number=eco_number)
eco_i.status = status
eco_i.save(using=settings.BRAND)
validation_date = eco_i.change_date
except Exception as ex:
validation_date = datetime.today()
LOG.info('[reject_release]: {0}'.format(ex))
bom_queryset = get_model('BOMPlatePart').objects.filter(bom__sku_code=sku_code,
bom__bom_number=bom_number,
plate__plate_id=plate_id,valid_from__lte=validation_date,
valid_to__gt=validation_date)
bom_visualisation =get_model('BOMVisualization').objects.filter(bom__in=bom_queryset)
if status == 'Approved':
approval_flag = True
bom_visualisation.update(is_published=True)
bom_visualisation.update(is_approved=approval_flag)
if comment:
comments_data = get_model('EpcCommentThread')(user=user,comment=comment)
comments_data.save(using=settings.BRAND)
visualisation_data.comments.add(comments_data)
visualisation_data.save(using=settings.BRAND)
return HttpResponse(json.dumps({"message" : "Status of SBOM changed to {0} ".format(status),"status":visualisation_data.status}),content_type="application/json")
else:
error_message='Its mandatory to provide comment when status is changed to rejected '
return HttpResponse(json.dumps({"message" : error_message}),content_type="application/json", status=400)
except Exception as ex:
error_message='Error [reject_release]: {0}'.format(ex)
LOG.info(error_message)
return HttpResponse(json.dumps({"message" : error_message}),content_type="application/json", status=400)
def add_constants(self):
'''Upload data of the Constants'''
print "Loading constants.."
file_path = os.path.join(settings.PROJECT_DIR, 'template_data/constant.json')
constants = json.loads(open(file_path).read())
for app in ALL_APPS:
cons = get_model('Constant', app)
for constant in constants:
fields = constant['fields']
temp_obj = cons.objects.using(app).filter(constant_name=fields['constant_name'])
if not temp_obj:
temp_obj = cons(id=constant['pk'], created_date=TODAY, constant_name=fields['constant_name'],constant_value=fields['constant_value'])
temp_obj.save(using=app)
if 'country_name' in fields.keys() and app=='bajajib':
country_obj = get_model('Country', app).objects.filter(name=fields['country_name'])
if not country_obj:
country_obj = get_model('Country', app)(name=fields['country_name'],
area_code=fields['country_code'])
country_obj.save(using=app)
else:
country_obj = country_obj[0]
temp_obj.country = country_obj
temp_obj.save(using=app)
print "Loaded constants..."
def book_service(self, request, **kwargs):
self.is_authenticated(request)
if request.method != 'POST':
return HttpResponse(json.dumps({'message' : 'Method not allowed'}),
content_type='application/json')
try:
load = json.loads(request.body)
asc_id = load.get('asc_id')
service_date = load.get('service_date')
product_id = load.get('product_id')
service_center = get_model('ServiceCenterLocation', settings.BRAND).objects.get(id=asc_id)
consumer = get_model('Consumer', settings.BRAND).objects.get(user=request.user)
service_obj = get_model('ServiceHistory', settings.BRAND)(consumer=consumer,
service_center_location=service_center,
product_id=product_id,
service_date=service_date,
asc_id=asc_id
)
service_obj.save(using=settings.BRAND)
return HttpResponse(json.dumps({'status' : 1, 'message' : 'Service Requested'}),
content_type='application/json')
except Exception as ex:
logger.error("Exception while booking a service - {0}".format(ex))
return HttpBadRequest("Service couldnot be booked")
return
def import_data(self):
try:
eco_implementation_list=[]
eco_number_list=[]
plate_list=[]
added_part_list=[]
for eco_obj in self.data_source:
if eco_obj['change_date'] == "0000-00-00" or not eco_obj['change_date']:
change_date=None
else:
change_date=datetime.strptime(eco_obj['change_date'], "%Y-%m-%d")
eco_implementation_list.append(get_model('ECOImplementation')(change_no=eco_obj['change_no'],change_date=change_date,
change_time=eco_obj['change_time'],plant=eco_obj['plant'],
action=eco_obj['action'],parent_part=eco_obj['parent_part'],
added_part=eco_obj['added_part'],added_part_qty=eco_obj['added_part_qty'],
deleted_part=eco_obj['deleted_part'],deleted_part_qty=eco_obj['deleted_part_qty'],
chassis_number=eco_obj['chassis_number'],engine_number=eco_obj['engine_number'],
eco_number=eco_obj['eco_number'],reason_code=eco_obj['reason_code'],
remarks=eco_obj['remarks']
))
eco_number_list.append(eco_obj['eco_number'])
plate_list.append(eco_obj['parent_part'])
added_part_list.append(eco_obj['added_part'])
eco_implementation_obj = get_model('ECOImplementation').objects.bulk_create(eco_implementation_list)
feed_remark = self.modify_sbom_data(eco_implementation_obj, set(eco_number_list), set(plate_list), set(added_part_list), self.feed_remark)
mail.send_epc_feed_received_mail(brand=settings.BRAND, template_name='ECO_RELEASE_FEED')
self.feed_remark=feed_remark
except Exception as ex:
ex="[Exception: ]: ECOImplementationFeed {0}".format(ex)
logger.error(ex)
self.feed_remark.fail_remarks(ex)
return self.feed_remark
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 upload_sku_data(self):
'''Upload sku data'''
print ''' Started uploading SKU data'''
file_list = ['brand_product_range.csv']
vertical_list = [{'name':'Motorcycle', 'description':'Motorcycle'},
{'name':'Commercial Vehicle', 'description':'Commercial Vehicle'},
{'name':'Probiking', 'description':'Probiking'}]
for vertical in vertical_list:
try:
brand_vertical=get_model('BrandVertical', APP).objects.get(name=vertical['name'])
except Exception as ObjectDoesNotExist:
brand_vertical=get_model('BrandVertical', APP)(name=vertical['name'], description=vertical['description'])
brand_vertical.save(using=APP)
product_list=[]
for i in range(0, 1):
with open(settings.PROJECT_DIR + '/upload_data/' + file_list[i], 'r') as csvfile:
spamreader = csv.reader(csvfile, delimiter=',')
next(spamreader)
for row_list in spamreader:
temp ={}
temp['sku_code'] = row_list[0].strip()
temp['description'] = row_list[1].strip()
temp['vertical'] = row_list[2].strip()
product_list.append(temp)
for product in product_list:
try:
app = product['vertical']
brand_product_range = get_model('BrandProductRange', app)
brand_product_obj = brand_product_range.objects.using(app).get(sku_code=product['sku_code'])
except Exception as ObjectDoesNotExist:
brand_product_obj = brand_product_range(sku_code=product['sku_code'],
description=product['description'])
brand_product_obj.save(using=app)
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 get_feedback(feedback_id, user):
if user.groups.filter(name=Roles.SDOWNERS).exists():
user_profile = get_model('UserProfile').objects.filter(user=user)
servicedesk_user = get_model('ServiceDeskUser').objects.filter(user_profile=user_profile[0])
return get_model('Feedback').objects.get(id=feedback_id, assignee=servicedesk_user[0])
else:
return get_model('Feedback').objects.get(id=feedback_id)
def save_circular(self,request, **kwargs):
try:
data = request.POST.copy()
sku_list=data.getlist('model_sku_code')
if sku_list:
circular_obj = get_model('ServiceCircular')(product_type=data['product_type'],
type_of_circular = data['type_of_circular'],
change_no = data['change_no'],
new_circular = data['new_circular'],
buletin_no = data['buletin_no'],
circular_date = data['circular_date'],
from_circular = data['from_circular'],
to_circular = data['to_circular'],
cc_circular = data['cc_circular'],
circular_subject = data['circular_subject'],
part_added = data['part_added'],
circular_title = data['circular_title'],
part_deleted = data['part_deleted'],
part_changed = data['part_changed'],
model_name = data['model_name'],
sku_description = data['sku_description'])
circular_obj.save()
sku_code_list = get_model('BrandProductRange').objects.filter(sku_code__in=sku_list)
for sku_code in sku_code_list:
circular_obj.model_sku_code.add(sku_code)
data = {'status':1, 'message': 'Successfully saved'}
else:
data = {'status':0, 'message': 'sku_code is mandatary'}
except Exception as ex:
logger.error('[service_circular]:{0}:: {1}'.format(ex))
data = {'status': 0, 'message': 'could not save'}
return HttpResponse(json.dumps(data), content_type="application/json")
def get_status_count(self, request, **kwargs):
'''
Gives the count of all the indents
based on the user status wise.
'''
self.is_authenticated(request)
args = request.GET
from_date = args.get('from', datetime.now() - timedelta(days=180))
to_date = args.get('to', datetime.now())
query_args = [Q(created_date__range=[from_date, to_date])]
submitted_indents=[]
try:
if request.user.groups.filter(name=Roles.TRANSPORTER):
submitted_indents = get_model('ContainerLR').objects.filter(transporter__user__user_id=request.user.id
).values_list('zib_indent_num_id', flat=True)
elif request.user.groups.filter(name=Roles.SUPERVISOR):
supervisor = get_model('Supervisor').objects.get(user__user_id=request.user.id)
submitted_indents = get_model('ContainerLR').objects.filter(Q(submitted_by=supervisor.supervisor_id) | Q(submitted_by=None)
& Q(transporter=supervisor.transporter
)).values_list('zib_indent_num_id', flat=True)
if submitted_indents:
query_args.append(Q(id__in=submitted_indents))
data = get_model('ContainerIndent').objects.filter(reduce(operator.and_, query_args)
).values('status').annotate(total=Count('status')).order_by('-status')
except Exception as ex:
LOG.error('Exception while obtaining CTS count : {0}'.format(ex))
return HttpResponse(content=json.dumps(list(data), cls=DjangoJSONEncoder), content_type='application/json')
def get_accumulation_detail(self, request, choice, model_name):
kwargs={}
if request.user.groups.filter(name=Roles.AREASPARESMANAGERS).exists():
asm_state_list=get_model('AreaSparesManager').objects.get(user__user=request.user).state.all()
kwargs['member__state__in'] = asm_state_list
accumulation = get_model(model_name).objects.using(settings.BRAND).filter(**kwargs).select_related('member__state', 'upcs')
return accumulation
def get_feedback_response(request, feedback_id):
data = request.POST
if data['feedbackresponse']:
get_model('Feedback').objects.filter(
id=feedback_id).update(ratings=str(data['feedbackresponse']))
return render(request, 'service-desk/feedback_received.html')
else:
return HttpResponse()
def get_servicedesk_users(designation):
users = User.objects.filter(groups__name__in=designation)
if len(users) > 0:
user_list = get_model('UserProfile').objects.filter(user__in=users)
return get_model('ServiceDeskUser').objects.filter(user_profile__in=user_list)
else:
LOG.info("No user with designation SDO exists")
return None
def get_dealer_asc_email(feedback_obj):
user = feedback_obj.reporter.user_profile.user
if user.groups.filter(name=Roles.SERVICEADVISOR).exists():
dealer_asc_obj = get_model('ServiceAdvisor').objects.get_dealer_asc_obj(feedback_obj.reporter)
else:
dealer_asc_obj = get_model('UserProfile').objects.get(user=feedback_obj.reporter.user_profile.user)
return dealer_asc_obj
def preview_sbom_details(self, request, **kwargs):
'''
preview the BOM data submitted
params:
bom_number: the bom number associated with a sku_code code
plate_id: the plate_id of the bom
eco_number: the eco-release number
'''
self.is_authenticated(request)
if request.method != 'GET':
return HttpResponse(json.dumps({"message" : "Method not allowed"}), content_type= "application/json",
status=400)
history_id=kwargs['history_id']
try:
visualisation_data = get_model('VisualisationUploadHistory').objects.filter(id=history_id)
comments_data_from_visualisation_table = None
if not visualisation_data:
return HttpResponse(json.dumps({}),content_type="application/json")
comments_data_from_visualisation_table = visualisation_data[0]
(sku_code,bom_number,plate_id,eco_number) = visualisation_data.values_list('sku_code','bom_number','plate_id','eco_number')[0]
plate_data = get_model('BOMPlate').objects.get(plate_id=plate_id)
plate_image = str(plate_data.plate_image)
s3_baseurl = settings.S3_BASE_URL
plate_image_path = s3_baseurl+"/"+plate_image
try:
eco_i = get_model('ECOImplementation').objects.get(eco_number=eco_number)
validation_date = eco_i.change_date
except Exception as ex:
validation_date = datetime.today()
LOG.info('[preview_sbom_details]: {0}'.format(ex))
bom_queryset = get_model('BOMPlatePart').objects.filter(bom__sku_code=sku_code,
bom__bom_number=bom_number,
plate__plate_id=plate_id,valid_from__lte=validation_date,
valid_to__gt=validation_date)
bom_visualisation =get_model('BOMVisualization').objects.filter(bom__in=bom_queryset)
plate_part_details =[]
for data in bom_visualisation:
part_details = model_to_dict(data ,exclude=['id','bom'])
part_details["quantity"] = model_to_dict(data.bom ,fields=['quantity']).values()[0]
part_details["part_number"] = model_to_dict(data.bom.part ,fields=['part_number']).values()[0]
part_details["description"] = model_to_dict(data.bom.part ,fields=['description']).values()[0]
plate_part_details.append(part_details)
if not plate_image:
plate_image = "Image Not Available"
comment_list=[]
comments ={ comment_list.append((comments.comment,str(comments.created_date))) for comments in comments_data_from_visualisation_table.comments.all()}
output_data = {"plate_image":plate_image_path,'plate_part_details': plate_part_details,'comments':comment_list}
return HttpResponse(json.dumps(output_data), content_type="application/json",)
except Exception as ex:
LOG.info('[preview_sbom_details]: {0}'.format(ex))
return HttpResponse(json.dumps({"message" : 'Exception while fetching plate images : {0}'.format(ex)}),content_type="application/json", status=400)
def user_registration_email(self, request, **kwargs):
'''
Register the user with email
Args: phone number , email
Return : Access token if email id doesnt exist else otp is sent to user's email
'''
if request.method != 'POST':
return HttpResponse(json.dumps({'message':'Method not allowed'}),
content_type='application/json')
load = json.loads(request.body)
email = load.get('email', None)
phone_number = load.get('phone_number', None)
if not email or not phone_number:
return HttpBadRequest("Phone number and email is mandatory")
try:
consumer = get_model('Consumer', settings.BRAND).objects.get_active_consumers_with_email(email)
if consumer.phone_number == phone_number:
access_token = self.generate_access_token(request, consumer)
return HttpResponse(json.dumps(access_token),
content_type='application/json')
else:
consumer_obj = get_model('Consumer', settings.BRAND).objects.\
get_active_consumers_with_phone(phone_number)
if not consumer_obj.user.email:
self.update_consumer_email(consumer_obj, email, False)
self.send_otp_to_mail(phone_number, email)
return HttpResponse(json.dumps({'status':1, 'message' : 'OTP sent successfully'}),
content_type='application/json')
else:
self.create_user(False, phone_number, email)
self.send_otp_to_mail(phone_number, email)
return HttpResponse(json.dumps({'status':1, 'message' : 'OTP sent successfully'}),
content_type='application/json')
except Exception as ex:
logger.info("Exception while registering user whose email exists - {0}".format(ex))
try:
consumer_obj = get_model('Consumer', settings.BRAND).objects.\
get_active_consumers_with_phone(phone_number)
if not consumer_obj.user.email:
self.update_consumer_email(consumer_obj, email, True)
access_token = self.generate_access_token(request, consumer_obj)
return HttpResponse(json.dumps(access_token),
content_type='application/json')
else:
consumer_obj = get_model('Consumer', settings.BRAND).objects.get(Q(phone_number=phone_number) &
~Q(user__email=email) &
Q(user__is_active=True)
)
user_obj = self.create_user(False, phone_number, email)
self.send_otp_to_mail(phone_number, email)
return HttpResponse(json.dumps({'status':1, 'message' : 'OTP sent successfully'}),
content_type='application/json')
except Exception as ex:
logger.info("Exception while registering user whose email doesnot exist - {0}".format(ex))
return HttpBadRequest("Could not register the user with this email")
def upload_service_advisor_data(self):
'''Upload data of SA associated with the dealers'''
print "Started running SA function..."
file_list = ['sa_data_goa_dl_hr.csv']
file = open("sa_details.txt", "w")
sa_list = []
dealer_model = get_model('Dealer', APP)
sa_model = get_model('ServiceAdvisor', APP)
for i in range(0, 1):
with open(settings.PROJECT_DIR + '/upload_data/' + file_list[i], 'r') as csvfile:
spamreader = csv.reader(csvfile, delimiter=',')
next(spamreader)
for row_list in spamreader:
temp={}
temp['city'] = (row_list[3].strip())
temp['dealer_id'] = row_list[1].strip()
temp['name'] = row_list[4].strip()
temp['number'] = self.mobile_format(row_list[5].strip())
sa_list.append(temp)
for sa in sa_list:
if not sa['name']=='':
print "...Loading SA..", sa
dealer_object = dealer_model.objects.get(dealer_id = sa['dealer_id'])
try:
try:
sa_object = sa_model.objects.get(user__phone_number = sa['number'], status='Y')
except Exception as ex:
file.write("{0}: {1}".format(sa['number'], ex))
service_advisor_id = TEMP_SA_ID_PREFIX + str(random.randint(10**5, 10**6))
new_user=self.register_user(group=Roles.SERVICEADVISOR, username=service_advisor_id)
sa_object = sa_model(service_advisor_id = service_advisor_id,
user=new_user,
status='Y',
dealer_id=dealer_object.user_id)
sa_object.save()
if sa_object.dealer_id!=dealer_object.user_id:
raise ValueError('ACTIVE UNDER {0}'.format(sa_object.dealer_id.dealer_id))
user_obj = sa_object.user.user
user_pro_obj = sa_object.user
first_name = sa['name']
last_name = ''
if len(sa['name'])>30:
full_name = sa['name'].split(' ')
first_name = ' '.join(full_name[0:3])
last_name = ' '.join(full_name[3:])
user_obj.first_name = first_name
user_obj.last_name = last_name
user_obj.save(using=APP)
user_pro_obj.address = sa['city']
user_pro_obj.phone_number = sa['number']
user_pro_obj.save()
except Exception as ex:
file.write("{0}: {1}".format(sa['number'], ex))
file.close()
def get_preferences_list(self, filter_key=None):
"""Returns preferences depeding on brand filter
"""
data = []
if filter_key:
data = get_model(self._meta.model).objects.filter(**{self._meta.filter_key: filter_key})
else:
data = get_model(self._meta.model).objects.all()
return map(model_to_dict, data)
def get_indents_query(self, object_list, bundle):
query_set=[]
if bundle.request.user.groups.filter(name=Roles.TRANSPORTER):
query_set = get_model('ContainerLR').objects.filter(transporter__user__user_id=bundle.request.user.id)
elif bundle.request.user.groups.filter(name=Roles.SUPERVISOR):
supervisor = get_model('Supervisor').objects.get(user__user_id=bundle.request.user.id)
query_set = get_model('ContainerLR').objects.filter(Q(submitted_by=supervisor.supervisor_id) | Q(submitted_by=None)
& Q(transporter=supervisor.transporter))
return query_set
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 update_preference(self, data, preference_key, filter_key):
"""Used for updating the preferences depending on preferences key and brand
"""
data['key'] = preference_key
data[self._meta.filter_key] = filter_key
if get_model(self._meta.model).objects.filter(**{'key': preference_key,
self._meta.filter_key: filter_key}).exists():
get_model(self._meta.model).objects.filter(**{'key': preference_key,
self._meta.filter_key: filter_key}).update(**data)
else:
self.save_preference(data)
def set_wait_time(feedback_data):
start_date = feedback_data.pending_from
end_date = datetime.datetime.now()
start_date = convert_utc_to_local_time(start_date)
start_date = start_date.strftime(TIME_FORMAT)
end_date = end_date.strftime(TIME_FORMAT)
start_date = datetime.datetime.strptime(start_date, TIME_FORMAT)
end_date = datetime.datetime.strptime(end_date, TIME_FORMAT)
wait = end_date - start_date
wait_time = wait.total_seconds()
previous_wait = feedback_data.wait_time
get_model('Feedback').objects.filter(id = feedback_data.id).update(wait_time = wait_time+previous_wait)
def add_product(product, consumer_phone_number_mapping, phone_number, product_details, final_products):
consumer_obj = consumer_phone_number_mapping[phone_number]
product_brand = get_model('Brand', GmApps.AFTERBUY).objects.get(name=GmApps.BAJAJ)
try:
product_type = get_model('ProductType', GmApps.AFTERBUY).objects.get(product_type=product.sku_code)
except Exception as ObjectDoesNotExist:
product_type = afterbuy_models.ProductType(product_type=product.sku_code,
brand=product_brand)
product_type.save()
final_products.append(get_model('UserProduct', GmApps.AFTERBUY)(consumer=consumer_obj, product_type=product_type,
brand_product_id=product_details.brand_product_id))
return final_products
def get_admin_site_custom(brand):
brand_admin = MechaneedAdminSite(name=brand)
brand_admin.register(User, UserAdmin)
brand_admin.register(Group, GroupAdmin)
brand_admin.register(get_model("UserProfile", brand), UserProfileAdmin)
brand_admin.register(get_model("Agency", brand), AgencyAdmin)
brand_admin.register(get_model("QualityCheck", brand), QualityCheckAdmin)
brand_admin.register(get_model("FieldInterviewerSupervisor", brand), FieldInterviewerSupervisorAdmin)
brand_admin.register(get_model("FieldInterviewer", brand), FieldInterviewerAdmin)
return brand_admin
def get_mechanics_detail(self, request, choice, model_name):
'''Fetches the details of the mechanics based on args'''
kwargs={}
if choice=='new':
kwargs['download_detail'] = False
if choice!='all':
kwargs['form_status'] = 'Complete'
if request.user.groups.filter(name=Roles.AREASPARESMANAGERS).exists():
asm_state_list=get_model('AreaSparesManager').objects.get(user__user=request.user).state.all()
kwargs['state__in'] = asm_state_list
mechanics = get_model(model_name).objects.using(settings.BRAND).filter(**kwargs).select_related('state', 'registered_by_distributor')
return mechanics
