diff --git a/erpnext/templates/pages/customer_reviews.html b/erpnext/templates/pages/customer_reviews.html
index 3621fcf..121bec3 100644
--- a/erpnext/templates/pages/customer_reviews.html
+++ b/erpnext/templates/pages/customer_reviews.html
@@ -5,45 +5,54 @@
 
 {% block page_content %}
 <div class="product-container reviews-full-page col-md-12">
-	<!-- Title and Action -->
-	<div class="w-100 mb-6 d-flex">
-		<div class="reviews-header col-9">
-			{{ _("Customer Reviews") }}
+	{% if enable_reviews %}
+		<!-- Title and Action -->
+		<div class="w-100 mb-6 d-flex">
+			<div class="reviews-header col-9">
+				{{ _("Customer Reviews") }}
+			</div>
+
+			<div class="write-a-review-btn col-3">
+				<!-- Write a Review for legitimate users -->
+				{% if frappe.session.user != "Guest" and user_is_customer %}
+					<button class="btn btn-write-review"
+						data-web-item="{{ web_item }}">
+						{{ _("Write a Review") }}
+					</button>
+				{% endif %}
+			</div>
 		</div>
 
-		<div class="write-a-review-btn col-3">
-			<!-- Write a Review for legitimate users -->
-			{% if frappe.session.user != "Guest" and user_is_customer %}
-				<button class="btn btn-write-review"
-					data-web-item="{{ web_item }}">
-					{{ _("Write a Review") }}
-				</button>
+		<!-- Summary -->
+		{{ ratings_summary(reviews, reviews_per_rating, average_rating, average_whole_rating, for_summary=True, total_reviews=total_reviews) }}
+
+
+		<!-- Reviews and Comments -->
+		<div class="mt-8">
+			{% if reviews %}
+				{{ user_review(reviews) }}
+
+				{% if not reviews | len >= total_reviews %}
+					<button class="btn btn-light btn-view-more mr-2 mt-4 mb-4 w-30"
+						data-web-item="{{ web_item }}">
+						{{ _("View More") }}
+					</button>
+				{% endif %}
+
+			{% else %}
+				<h6 class="text-muted mt-6">
+					{{ _("No Reviews") }}
+				</h6>
 			{% endif %}
 		</div>
-	</div>
-
-	<!-- Summary -->
-	{{ ratings_summary(reviews, reviews_per_rating, average_rating, average_whole_rating, for_summary=True, total_reviews=total_reviews) }}
-
-
-	<!-- Reviews and Comments -->
-	<div class="mt-8">
-		{% if reviews %}
-			{{ user_review(reviews) }}
-
-			{% if not reviews | len >= total_reviews %}
-				<button class="btn btn-light btn-view-more mr-2 mt-4 mb-4 w-30"
-					data-web-item="{{ web_item }}">
-					{{ _("View More") }}
-				</button>
-			{% endif %}
-
-		{% else %}
-			<h6 class="text-muted mt-6">
+	{% else %}
+		<!-- If reviews are disabled -->
+		<div class="text-center">
+			<h3 class="text-muted mt-8">
 				{{ _("No Reviews") }}
-			</h6>
-		{% endif %}
-	</div>
+			</h3>
+		</div>
+	{% endif %}
 </div>
 
 {% endblock %}
diff --git a/erpnext/templates/pages/customer_reviews.py b/erpnext/templates/pages/customer_reviews.py
index 2b8ebff..696ecea 100644
--- a/erpnext/templates/pages/customer_reviews.py
+++ b/erpnext/templates/pages/customer_reviews.py
@@ -3,6 +3,7 @@
 import frappe
 from erpnext.e_commerce.doctype.item_review.item_review import get_item_reviews
 from erpnext.e_commerce.doctype.website_item.website_item import check_if_user_is_customer
+from erpnext.e_commerce.doctype.e_commerce_settings.e_commerce_settings import get_shopping_cart_settings
 
 def get_context(context):
 	context.no_cache = 1
@@ -13,4 +14,6 @@
 		context.item_code = frappe.form_dict.get("item_code")
 		context.web_item = frappe.db.get_value("Website Item", {"item_code": context.item_code}, "name")
 		context.user_is_customer = check_if_user_is_customer()
-		get_item_reviews(context.web_item, 0, 10, context)
+		context.enable_reviews = get_shopping_cart_settings().enable_reviews
+		if context.enable_reviews:
+			get_item_reviews(context.web_item, 0, 10, context)
diff --git a/erpnext/templates/pages/wishlist.py b/erpnext/templates/pages/wishlist.py
index dfd60f5..9fa83a9 100644
--- a/erpnext/templates/pages/wishlist.py
+++ b/erpnext/templates/pages/wishlist.py
@@ -3,29 +3,16 @@
 import frappe
 from erpnext.utilities.product import get_price
 from erpnext.e_commerce.shopping_cart.cart import _set_price_list
+from erpnext.e_commerce.doctype.e_commerce_settings.e_commerce_settings import get_shopping_cart_settings
 
 def get_context(context):
-	settings = frappe.get_doc("E Commerce Settings")
-	items = get_wishlist_items()
-	selling_price_list = _set_price_list(settings)
+	is_guest = frappe.session.user == "Guest"
 
-	for item in items:
-		if settings.show_stock_availability:
-			item.available = get_stock_availability(item.item_code, item.get("warehouse"))
+	settings = get_shopping_cart_settings()
+	items = get_wishlist_items() if not is_guest else []
+	selling_price_list = _set_price_list(settings) if not is_guest else None
 
-		price_details = get_price(
-			item.item_code,
-			selling_price_list,
-			settings.default_customer_group,
-			settings.company
-		)
-
-		if price_details:
-			item.formatted_price = price_details.get('formatted_price')
-			item.formatted_mrp = price_details.get('formatted_mrp')
-			if item.formatted_mrp:
-				item.discount = price_details.get('formatted_discount_percent') or \
-					price_details.get('formatted_discount_rate')
+	items = set_stock_price_details(items, settings, selling_price_list)
 
 	context.items = items
 	context.settings = settings
@@ -53,6 +40,27 @@
 		},
 		fields=[
 			"web_item_name", "item_code", "item_name",
-			"website_item", "price", "warehouse",
+			"website_item", "warehouse",
 			"image", "item_group", "route"
 		])
+
+def set_stock_price_details(items, settings, selling_price_list):
+	for item in items:
+		if settings.show_stock_availability:
+			item.available = get_stock_availability(item.item_code, item.get("warehouse"))
+
+		price_details = get_price(
+			item.item_code,
+			selling_price_list,
+			settings.default_customer_group,
+			settings.company
+		)
+
+		if price_details:
+			item.formatted_price = price_details.get('formatted_price')
+			item.formatted_mrp = price_details.get('formatted_mrp')
+			if item.formatted_mrp:
+				item.discount = price_details.get('formatted_discount_percent') or \
+					price_details.get('formatted_discount_rate')
+
+	return items
\ No newline at end of file
