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'))