def validate_user_phone_number(self,phone_number, otp):
if not otp and not phone_number :
return HttpBadRequest("otp and phone_number required")
try:
otp_handler.validate_otp(otp, phone_number=phone_number)
except Exception as ex:
data = {'status': 0, 'message': "invalid OTP"}
logger.info("[Exception OTP]:{0}".
format(ex))
return HttpResponse(json.dumps(data), content_type="application/json")
def validate_otp(request):
if request.method == 'GET':
return render(request, 'portal/validate_otp.html')
elif request.method == 'POST':
try:
otp = request.POST['otp']
username = request.POST['username']
logger.info('OTP {0} recieved for validation. username {1}'.format(otp, username))
user = User.objects.get(username=username)
user_profile = models.UserProfile.objects.get(user=user)
otp_handler.validate_otp(otp, user=user_profile)
logger.info('OTP validated for name {0}'.format(username))
return render(request, 'portal/reset_pass.html', {'otp': otp})
except Exception as ex:
logger.error('OTP validation failed for name {0} : {1}'.format(username, ex))
return HttpResponseRedirect('/aftersell/users/otp/generate?token=invalid')
def change_user_password(self, request, **kwargs):
if request.method != 'POST':
return HttpResponse(json.dumps({"message":"method not allowed"}), content_type="application/json",status=401)
try:
load = json.loads(request.body)
except:
return HttpResponse(content_type="application/json", status=404)
type = kwargs['type']
otp_token = load.get('otp_token')
password = load.get('password1')
repassword = load.get('password2')
invalid_password = check_password(repassword)
if (invalid_password):
return HttpBadRequest("password is not meant according to the rules")
auth_key = load.get('auth_key')
user_details = {}
if not type:
return HttpBadRequest("type not defined use email/phone")
if password != repassword:
return HttpBadRequest("password1 and password2 not matched")
try:
if type=='phone':
try:
if not (settings.ENV in settings.IGNORE_ENV and otp_token in settings.HARCODED_OTPS):
consumer = afterbuy_model.OTPToken.objects.get(token=otp_token).user
otp_handler.validate_otp(otp_token, user=consumer)
except Exception:
raise ImmediateHttpResponse(
response=http.HttpBadRequest('Wrong OTP!'))
user_details['id'] = consumer.user.id
elif type=='email':
try:
user_obj = afterbuy_model.EmailToken.objects.get(activation_key=auth_key).user
except Exception:
raise ImmediateHttpResponse(
response=http.HttpBadRequest('invalid authentication key!'))
user_details['email'] = user_obj.user.email
user = User.objects.filter(**user_details)[0]
user.set_password(password)
user.save()
data = {'status': 1, 'message': "password updated successfully"}
except Exception as ex:
logger.error('Invalid details, mobile {0} and exception {1}'.format(request.POST.get('phone_number', ''),ex))
data = {'status': 0, 'message': "password not updated"}
return HttpResponse(json.dumps(data), content_type="application/json")
def validate_otp_phone(self, request, **kwargs):
'''
Validate otp sent to phone
args : phone number and otp
return : status 1 on successfull validation
'''
if request.method != 'POST':
return HttpResponse(json.dumps({"message":"method not allowed"}),
content_type="application/json",status=401)
try:
load = json.loads(request.body)
otp_token = load.get('otp_token')
phone_number = load.get('phone_number')
if not otp_token or not phone_number:
return HttpBadRequest("OTP and phone number is mandatory")
try:
consumer_user = get_model('Consumer', settings.BRAND).objects.get(phone_number=phone_number,
is_email_verified=True)
otp_handler.validate_otp(otp_token, phone_number=phone_number)
access_token = self.generate_access_token(request, consumer_user)
return HttpResponse(json.dumps({'status': 1,'access_token':access_token, 'message':'OTP validated'}),
content_type='application/json')
except Exception as ex:
user = get_model('Consumer', settings.BRAND).objects.get(phone_number=phone_number, user__is_active=True)
otp_handler.validate_otp(otp_token, phone_number=phone_number)
user.is_phone_verified = True
user.save(using=settings.BRAND)
logger.info("Exception checking exisiting user {0}".format(ex))
return HttpResponse(json.dumps({'status': 1, 'message':'OTP validated'}),
content_type='application/json')
except Exception as ex:
logger.info("Exception while validating OTP {0}".format(ex))
return HttpBadRequest("OTP couldnot be validated")
def validate_otp_email(self, request, **kwargs):
'''
Validate the otp sent to email and map user products
Args : email , phone number , otp
Returns : map the products and returns access token
'''
if request.method != 'POST':
return HttpResponse(json.dumps({'message':"Method not allowed"}),
content_type='application/json')
try:
load = json.loads(request.body)
phone_number = load.get('phone_number')
otp_token = load.get('otp_token')
email = load.get('email')
if not otp_token or not phone_number or not email:
return HttpBadRequest("OTP , phone number , email is mandatory")
otp_handler.validate_otp(otp_token, email=email)
consumer = get_model('Consumer', settings.BRAND).objects.select_related('user').get(user__email=email,
phone_number=phone_number)
user = consumer.user
user.is_active = True
user.save(using=settings.BRAND)
consumer.is_email_verified = True
consumer.save(using=settings.BRAND)
user_products = get_model('UserProduct', settings.BRAND).objects.\
select_related('consumer').filter(~Q(consumer__phone_number=phone_number) &
Q(consumer__user__email=email) &
Q(consumer__user__is_active=True))
if len(user_products) >0:
for product in user_products:
user = product.consumer.user
user.is_active = False
user.save(using=settings.BRAND)
product.save(using=settings.BRAND)
products = []
for product in user_products:
products.append(get_model('UserProduct', settings.BRAND)(consumer=consumer,
nick_name=product.nick_name,
product_type=product.product_type,
purchase_date=product.purchase_date,
brand_product_id=product.brand_product_id,
image_url=product.image_url,
color=product.color,
is_deleted=product.is_deleted,
description=product.description,
is_accepted=product.is_accepted,
service_reminder=product.service_reminder,
details_completed=product.details_completed,
manual_link=product.manual_link,
warranty_year=product.warranty_year,
insurance_year=product.insurance_year))
new_products = get_model('UserProduct', settings.BRAND).objects.bulk_create(products)
new_products = get_model('UserProduct', settings.BRAND).objects.\
select_related('consumer').filter(Q(consumer__phone_number=phone_number) &
Q(consumer__user__email=email))
product_dict = {}
for user_product in user_products:
product_mapping = filter(lambda product : product.brand_product_id == user_product.brand_product_id,
new_products)
product_dict[user_product.brand_product_id] = product_mapping[0]
insurance_details = get_model('ProductInsuranceInfo', settings.BRAND).objects.filter(product__in=user_products)
self.update_product_insurance_warranty(product_dict, insurance_details)
warranty_details = get_model('ProductWarrantyInfo', settings.BRAND).objects.filter(product__in=user_products)
self.update_product_insurance_warranty(product_dict, warranty_details)
else:
consumers = get_model('Consumer', settings.BRAND).objects.select_related('user').filter(Q(user__email=email)&
~Q(phone_number=phone_number),
Q(user__is_active=True))
for consumer_obj in consumers:
user = consumer_obj.user
user.is_active = False
user.save(using=settings.BRAND)
consumer_obj.save(using=settings.BRAND)
all_consumers = get_model('Consumer', settings.BRAND).objects.select_related('user')\
.filter(Q(phone_number=phone_number) &
~Q(user__email=email) &
Q(user__is_active=True))
if len(all_consumers) >0:
all_consumers[0].has_discrepancy = True
user_obj = all_consumers[0].user
user_obj.is_active = False
user_obj.save(using=settings.BRAND)
all_consumers[0].save(using=settings.BRAND)
access_token = self.generate_access_token(request, consumer)
return HttpResponse(json.dumps(access_token),
content_type='application/json')
except Exception as ex:
logger.info("Exception while validating email otp - {0}".format(ex))
return HttpBadRequest("OTP could not be validated")