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