Restaurant Review Glitch: Customer App Discovery Screen

by Admin 56 views
Restaurant Review Glitch: Customer App Discovery Screen

Hey everyone, let's dive into a frustrating bug report regarding a customer app's restaurant review feature. Specifically, we're looking at a food delivery app, potentially built with React Native (based on the provided context). The issue revolves around how restaurant reviews are displayed on the discovery screen, and how the system handles multiple review attempts per order. Let's break it down, guys!

The Bug: Delayed Review Updates and Multiple Reviews

The core problem: When a customer submits a review for a restaurant after a past order, the updated review doesn't immediately reflect on the restaurant's discovery screen. Users have to jump through hoops (like navigating into the restaurant's details) to see their review reflected. Another issue is that the customer should only be allowed to review an order once, but there seems to be a glitch where they might be able to submit multiple reviews for the same order. This is a big no-no, and needs to be addressed.

Imagine you're craving some delicious tacos. You find a restaurant, place an order, and enjoy your meal. After the meal, you decide to leave a review, giving the restaurant five stars. You head back to the discovery screen, eager to see your review reflected, right? Wrong! The review doesn't update, leaving you (and other potential customers) in the dark. This is a poor user experience, because the discovery screen is the first point of contact and needs to convey accurate information immediately.

Also, consider the fact that reviews influence a customer's decision making when choosing a restaurant. If reviews are not updated in a timely manner, or if there is the possibility of multiple reviews from the same person on a single order, then this can cause distrust of the reviews. This could result in fewer orders from the app, which would affect both the business as well as the customers.

Let's get into the specifics of the bug report.

Steps to Reproduce the Issue

To really understand the issue, we need to replicate the problem. Here’s how you can do it, step-by-step:

  1. Open the Customer Application: Start the food delivery app on your device.
  2. Navigate to Profile: Tap on the profile menu button (this is usually represented by a user icon). This action takes you to your profile settings.
  3. Access Order History: Select 'Order History' under the 'My Orders' section, this is how you can find the past orders you have placed.
  4. View Past Orders: Within Order History, choose 'Past' to see your previous orders. This allows you to select any of your previous orders to review.
  5. Submit a Review: Select an order, and provide a rating. Give the restaurant a star rating. Write a review, and submit it.
  6. Return to Discovery Screen: After submitting the review, go back to the restaurant discovery screen (the main screen). This is where you see the lists of restaurants and all the information related to them.
  7. Observe the Restaurant: Find the restaurant you just reviewed. At this point, you'll see the reviews are not updated as expected.

Following these steps should let you experience the bug firsthand.

Expected Behavior

What should happen is very clear, we need to fix it. Here's what the application should ideally do.

  1. Instant Review Updates: When a customer submits a review for a restaurant, it should be immediately displayed on the restaurant's discovery page. No need to tap into the restaurant details; the updated rating and review should be visible instantly.
  2. Single Review per Order: Customers should only be allowed to review an order once. After submitting a review, they shouldn't be able to review the same order again.

Think about this from a customer's perspective. They provide a review, and expect that review to be visible immediately, it increases the user's trust to the platform, and creates a more streamlined user experience.

Technical Considerations and Potential Solutions

Let's discuss how this can be resolved. This issue is likely rooted in how the app handles data synchronization and user input validation.

Data Synchronization Issues

The delayed review updates suggest a problem with data synchronization. Here are possible causes:

  • Caching Problems: The app might be caching restaurant data, preventing the updated review from immediately appearing on the discovery screen. The solution might involve clearing the cache or refreshing the data more frequently.
  • Backend Delays: The backend server that stores reviews might not be immediately pushing the new review data to the customer application. A solution might involve implementing real-time updates using techniques like WebSockets or server-sent events (SSE).
  • Asynchronous Updates: The app might be using asynchronous tasks to update the reviews, and these tasks are not completing instantly. The solution might involve optimizing the tasks to complete faster or displaying a loading indicator while the review is being updated.

User Input Validation

The ability to submit multiple reviews per order indicates a problem with user input validation. This can be resolved by implementing checks.

  • Database Checks: When the user attempts to submit a review, the app should check the database to see if the user has already reviewed the order. If a review already exists, the app should not allow the user to submit a new one.
  • Frontend Validation: The app can also validate the review attempts on the frontend. After the user has submitted a review, the review button should be disabled, or the app should display a message to prevent the user from attempting to resubmit the review.

Code Snippets (Illustrative - React Native)

Here are some simplified code snippets (in React Native) to illustrate potential fixes, keep in mind that the exact implementation will vary based on your app's structure.

// Example: Refreshing Restaurant Data After Review
async function submitReview(orderId, rating, comment) {
  // API call to submit the review to the backend
  const response = await api.submitReview(orderId, rating, comment);

  if (response.success) {
    // Refresh restaurant data immediately
    fetchRestaurantData(); // Replace with your data fetching function
    Alert.alert('Success', 'Review submitted successfully!');
  } else {
    Alert.alert('Error', 'Failed to submit review.');
  }
}

// Example: Preventing Multiple Reviews
const [hasReviewed, setHasReviewed] = useState(false);

useEffect(() => {
  // Check if the user has already reviewed the order on component mount
  checkIfReviewed(orderId).then(reviewed => {
    setHasReviewed(reviewed);
  });
}, [orderId]);

function renderReviewButton() {
  if (hasReviewed) {
    return <Text>Thank you for your review!</Text>;
  }
  return <Button title="Leave a Review" onPress={leaveReview} />;
}

Addressing the Issue

The fix would involve modifying the backend server to ensure that reviews are saved correctly, and that the frontend updates the review information immediately. Make sure that the backend also validates the review and does not allow for multiple reviews from the same user for the same order.

Conclusion: Improving the User Experience

This bug report highlights a crucial user experience issue. By fixing the delayed review updates and preventing multiple reviews, the application can enhance user trust, and improve its reliability. The implementation of real-time updates and input validation, as well as addressing caching issues, should ensure that restaurant reviews are displayed accurately and promptly on the discovery screen. Remember to test all the fixes thoroughly, and to continue to collect user feedback to ensure the best possible experience.