def post(self, request):
login_id = request.data["login_id"]
password = request.data["password"]
serializer = LoginSerializer(data=request.data)
if serializer.is_valid():
try:
cursor = conn.cursor()
phone_no = LoginManager.get_user(login_id, password)
if phone_no:
check_if_otp_generated_for_more_than_limit_for_user(
phone_no)
check_if_user_is_blocked(phone_no)
random_otp = gen_otp()
send_otp_to_user_while_login.delay(phone_no, random_otp)
LoginManager.store_onto_OTP_table(phone_no, random_otp)
response = get_response_code("otp_sent")
response["Phone No."] = phone_no
return Response(response)
else:
return Response(get_response_code("login_failed"))
except TypeError:
return Response(get_response_code("login_failed"))
except Exception:
return Response(get_response_code("generic_response"))
finally:
cursor.close()
return Response(serializer.errors)
def post(self, request):
phone_no = request.headers.get("x_phoneno")
otp = request.data["otp"]
redis_instance = get_redis_instance()
if not phone_no:
raise BookStoreError(get_response_code("no_headers"))
try:
cursor = conn.cursor()
original_otps = LoginManager.get_otp_for_phone_no(phone_no)
if original_otps:
latest_otp = original_otps[len(original_otps) - 1][0]
latest_otp_send_time = original_otps[len(original_otps) - 1][1]
elasped_time = (timezone.now() -
latest_otp_send_time).total_seconds()
if otp == latest_otp and int(elasped_time) < int(
settings.OTP_EXPIRY_TIME):
user_id = LoginManager.get_user_id_from_phone_no(phone_no)
token = jwt_encode(user_id)
redis_instance.set(user_id, token)
LoginManager.delete_otp_for_authenticated_user(phone_no)
response = get_response_code("verify_response")
response["token"] = token
return Response(response)
else:
return Response(get_response_code("otp_invalid"))
else:
return Response(get_response_code("otp_not_generated"))
finally:
cursor.close()
def validate(self, validated_data):
for data in validated_data.values():
if data <= 0:
raise BookStoreError(get_response_code('invalid_data'))
product_quantity = db.execute_sql(
'select title from product where id = %s',
(validated_data['product_id'], ))
if not product_quantity:
raise BookStoreError(get_response_code('invalid_data'))
return validated_data
def logout(request):
user_id = get_current_user(request)
redis_instance = get_redis_instance()
try:
redis_instance.delete(user_id)
except DataError:
raise BookStoreError(get_response_code("login_required"))
except Exception:
return Response(get_response_code("generic_response"))
return Response(get_response_code("logout"))
def jwt_decode(token):
if not token:
raise BookStoreError(get_response_code('login_required'))
try:
payload = jwt.decode(token, settings.JWT_SECRET_KEY)
user_email = payload.get('user_id')
return user_email
except jwt.DecodeError as identifier:
raise BookStoreError(get_response_code('jwt_auth_error'))
except jwt.ExpiredSignatureError as indentifier:
raise BookStoreError(get_response_code('jwt_signature_expired'))
def insert(obj):
total_quantity = db.execute_sql('select quantity from product where id = %s', (obj.product_id,), False)
if not total_quantity:
raise BookStoreError(get_response_code('invalid_product_id'))
if total_quantity >= int(obj.quantity):
count = db.execute_sql('select quantity from cart where product_id = %s and user_id = %s', (obj.product_id, obj.user_id), False)
if count:
result = db.execute_sql('update cart set quantity = %s where product_id = %s and user_id = %s', (int(obj.quantity), obj.product_id, obj.user_id))
return get_response_code('updated_quantity')
query = 'insert into cart(user_id, product_id, quantity) values(%s, %s, %s)'
db.execute_sql(query, (obj.user_id, obj.product_id, obj.quantity))
return get_response_code('added_to_cart')
else:
raise BookStoreError(get_response_code("out_of_stock"))
def insert(obj, total=None, address=None, id=None):
id = get_latest_order_id()
order_status = {'products_cancelled': {}}
mail_response = []
for orders in obj:
product = db.execute_sql(
'select quantity, price, image, title, author from product where id = %s',
(orders.product_id, ), True)
if not product:
raise BookStoreError(get_response_code('invalid_product_id'))
product = product[0]
available_quantity = product[0]
price = product[1]
image = product[2]
title = product[3]
author = product[4]
if available_quantity == 0:
order_status = generate_cancelled_products(
order_status, get_response_code('not_available'), title)
continue
if type(orders.quantity
) == str or orders.quantity > available_quantity:
order_status = generate_cancelled_products(
order_status,
f'out_of_stock for quantity {orders.quantity}', title)
continue
if not address:
address = orders.address
total = orders.quantity * price
query = 'insert into orders(user_id, product_id, quantity, address, order_id) values(%s, %s, %s, %s, %s)'
result = db.execute_sql(query, (orders.user_id, orders.product_id,
orders.quantity, address, id))
product_info = {
'title': title,
'image': image,
'price': price,
'author': author,
'quantity': orders.quantity,
}
mail_response.append(product_info)
if len(mail_response) > 0:
order_placed_mail_to_user.delay(mail_response, total,
obj[0].user_id, id, address)
order_status['Order Placed'] = mail_response
order_status['status'] = 200
return get_response_code('order_placed') if len(
order_status['products_cancelled']) == 0 else order_status
def add_to_wishlist(request):
serializer = WishListSerializer(data=request.data)
if serializer.is_valid():
user_id = get_current_user(request)
serializer.save(user_id= user_id)
return Response(get_response_code('added_to_wishlist'))
return Response(serializer.errors)
def get(self, request, pk=None):
if pk:
pk = pk.lower()
products = Product.objects.get(pk)
else:
redis_instance = get_redis_instance()
products = get_cache_item()
if not products:
products = Product.objects.all()
set_cache(products)
try:
sort_by = 'id' if not request.GET.get(
'sortby') else request.GET.get('sortby').lower()
sort_type = True if request.GET.get('des') == 'true' else False
products.sort(key=lambda obj: getattr(obj, sort_by),
reverse=sort_type)
except AttributeError:
sort_by = 'author'
paginator_object = Paginator(products, PAGINATOR_PAGE_LIMIT)
page_no = 1 if request.GET.get('pageno') == None else request.GET.get(
'pageno')
try:
product_obj = paginator_object.page(page_no)
except EmptyPage:
product_obj = paginator_object.page(1)
serializer = prod_serializer(product_obj, many=True)
response = serializer.data
return Response(response) if response else Response(
get_response_code('invalid_product_id'))
def post(self, request):
user_id = get_current_user(request)
serializer = OrderSerializer(data=request.data)
if serializer.is_valid():
serializer.save(user_id=user_id)
return Response(get_response_code('order_placed'))
return Response(serializer.errors)
def add_to_cart(request):
serializer = CartAddSerializer(data=request.data)
if serializer.is_valid():
user_id = get_current_user(request)
serializer.save(user_id=user_id)
return Response(get_response_code("added_to_cart"))
return Response(serializer.data)
def get(self, request, id=None):
user_id = get_current_user(request)
if id:
try:
items = CartModel.objects.get(id, user_id)
except IndexError:
return Response(get_response_code("invalid_product_id"))
except Exception:
return Response(get_response_code("generic_response"))
total = sum(
[
0 if type(item.quantity) == str else item.price * item.quantity
for item in items
]
)
serializer = CartSerializer(items, many=True)
return Response({"cart": serializer.data, "total": total})
def get_current_user(request):
redis_instance = get_redis_instance()
token = request.headers.get("x_token")
user_id = jwt_decode(token)
for key in redis_instance.scan_iter():
if key.decode("utf-8") == str(user_id):
return user_id
raise BookStoreError(get_response_code("login_required"))
def create(self, validated_data):
count = db.execute_sql(
'select count(*) from wishlists where product_id = %s and user_id = %s',
(validated_data['product_id'], validated_data['user_id']), False)
if count > 0:
raise BookStoreError(
get_response_code('product_already_in_wishlist'))
wishlist_item = WishListModel(**validated_data)
wishlist_item.save()
return wishlist_item
def check_if_otp_generated_for_more_than_limit_for_user(phone_no):
count = db.execute_sql("select count(*) from otp_history", None, True)
count = count[0][0]
if count and count > OTP_GENERATION_LIMIT:
blocked_time = timezone.now() + timedelta(days=1)
db.execute_sql("delete from otp_history where phone_no = %s", (phone_no,))
db.execute_sql(
"insert into otp_history(phone_no, otp, datetime) values(%s,%s,%s)",
(phone_no, "blockd", blocked_time),
)
raise BookStoreError(get_response_code("too_many_otp"))
def execute_sql(query=None, params=None, many=None):
try:
cursor = connection.cursor()
res = cursor.execute(query, params)
if many == True:
result = cursor.fetchall()
return result if result else None
if many == False:
result = cursor.fetchone()
return result[0] if result else None
return res
except ProgrammingError:
raise BookStoreError(get_response_code("programming_error"))
except IntegrityError:
raise BookStoreError(get_response_code("invalid_product_id"))
except DatabaseError:
raise BookStoreError(get_response_code("database_error"))
except Exception:
raise BookStoreError("somethong went wrong")
finally:
cursor.close()
def get(self, request, id=None):
user_id = get_current_user(request)
if id:
try:
wishlist = WishListModel.objects.get(id, user_id)
products = Product.objects.get(str(wishlist.product_id))
except IndexError:
raise BookStoreError(get_response_code('invalid_product_id'))
else:
wishlist = WishListModel.objects.all(params=user_id)
products = Product.objects.filter(wishlist)
serializer = ProductSerializer(products, many = True)
return Response(serializer.data)
def order(request):
user_id = get_current_user(request)
address = request.data["address"]
items = CartModel.objects.all(user_id)
if len(items) == 0:
raise BookStoreError(get_response_code("item_not_in_cart"))
total = sum(
[
0 if type(item.quantity) == str else item.price * item.quantity
for item in items
]
)
id = get_latest_order_id()
response = OrderManager.insert(items, total, address, id)
return Response(response)
def delete(self, request, id):
user_id = get_current_user(request)
result = WishListModel.objects.delete(id, user_id)
if result == 0:
return Response(get_response_code('wishlist_delete_does_exists'))
return Response(get_response_code('deleted_wishlist_item'))
def validate(self, validated_data):
for values in validated_data.values():
if values <= 0:
raise BookStoreError(get_response_code("invalid_data"))
return validated_data
def delete(self, request, id=None):
user_id = get_current_user(request)
result = CartModel.objects.delete(id, user_id)
if result == 0:
return Response(get_response_code("item_not_in_cart"))
return Response(get_response_code("removed_cart_item"))
def insert(obj):
query = 'insert into wishlists(user_id, product_id) values(%s,%s)'
params = (obj.user_id, obj.product_id)
db.execute_sql(query, params)
return get_response_code('added_to_wishlist')
def validate_login_id(self, value):
if re.match(
"^[a-zA-Z0-9]+[\\.\\-\\+\\_]?[a-zA-Z0-9]+@[a-zA-Z0-9]+[.]?[a-zA-Z]{2,4}[\\.]?([a-z]{2,4})?$",
value) or re.match("[0-9]{10}", value):
return value
raise BookStoreError(get_response_code('invalid_login'))
