Restaurant Review Bug: Customer App Not Updating Reviews

Hey guys, we've got a situation with the customer app and restaurant reviews! It seems like there's a bug where the reviews aren't updating correctly on the discovery screen, and customers are potentially able to leave multiple reviews for the same order. Let's dive into the details and see what's going on.

The Issue: Reviews Not Updating and Multiple Reviews Allowed

The main problem we're facing is that when a customer leaves a review for a restaurant through their order history, the updated review isn't immediately reflected on the restaurant's listing on the discovery screen. This can be super confusing for other users who are browsing restaurants and relying on those reviews to make their decisions. Imagine seeing outdated reviews – not a great experience, right?

Another critical issue is that customers are currently able to review the same order multiple times. Ideally, a customer should only be able to leave one review per order to keep things fair and accurate. Allowing multiple reviews could lead to skewed ratings and an unreliable review system. So, to address the primary challenge, let's delve into the core issue: customer reviews not updating on the restaurant discovery screen. This issue significantly impacts user experience as it presents outdated information, potentially misleading customers. When a user takes the time to provide feedback, they expect their input to be reflected promptly, aiding others in making informed decisions. The current delay in updating reviews undermines this expectation and can erode trust in the app's reliability. To fully grasp the magnitude of this problem, we need to consider the user's journey. A customer places an order, receives their meal, and then navigates to their order history to leave a review. They rate the restaurant and perhaps add a detailed comment about their experience. Logically, they would anticipate that their feedback is immediately visible to other users browsing the app. However, when this update fails to occur, it creates a disconnect between the user's action and the app's response. This lag can be particularly frustrating if the customer had a strong opinion, positive or negative, and wants to share it with the community. Furthermore, the issue of allowing multiple reviews per order complicates the integrity of the feedback system. Imagine a scenario where a customer has a particularly good or bad experience and decides to leave several reviews to amplify their voice. This not only skews the overall rating but also makes it difficult for other users to get an accurate picture of the restaurant's performance. A fair and reliable review system is crucial for fostering trust among users. It ensures that restaurants are evaluated based on consistent criteria and that customers can make decisions with confidence. By allowing only one review per order, we can minimize the potential for manipulation and maintain a more balanced representation of customer opinions. In addition to the immediate user experience impact, these issues can also have long-term consequences for the platform. A reputation for unreliable reviews can deter new users from joining and cause existing users to question the app's value. Restaurants, too, may become disillusioned if they feel the review system is not accurately reflecting their service quality. Therefore, addressing these bugs is not just about fixing a technical glitch; it's about safeguarding the integrity of the entire platform and ensuring its continued success. We need a robust system that both promptly updates reviews and prevents multiple submissions, creating a trustworthy environment for both customers and restaurants.

Steps to Reproduce the Bug

Okay, so how can we actually see this bug in action? Follow these steps:

1. Go to the Customer Application and tap on the Profile menu button. Think of this as your starting point, your mission control for all things customer-related in the app.
2. Click on Order History under the My Orders section, and then select Past. This is where you'll find all your completed orders, the history of your culinary adventures!
3. Now, give a review to any of your previous orders. Rate it, write a comment – the whole shebang! This is where you're providing valuable feedback, or at least you think you are...
4. Here's the key part: Go back to the discovery page and look at the restaurant you just reviewed. You'll probably notice that the reviews aren't updated until you actually open the restaurant's details. Bummer!

To give a more detailed breakdown, let's dissect these steps further. When you first navigate to the Profile section, you're entering your personal space within the app. This is where you manage your account details, view past orders, and of course, leave reviews. The Order History section is like a time capsule of your previous meals, a record of your dining experiences. By selecting Past, you're focusing on orders that have already been delivered and consumed, the perfect candidates for your insightful reviews. The act of giving a review is where you, as a customer, become a critic. You're sharing your thoughts, your ratings, and your overall impression of the restaurant. This feedback is crucial for other users, as it helps them make informed decisions about where to dine. But here's where the bug rears its ugly head. After you've poured your heart and soul into your review, you expect it to be immediately visible to the world. You anticipate that other users will see your feedback and benefit from your experience. However, when you go back to the discovery page, you're met with a disappointing reality. The restaurant's listing doesn't reflect your recent review. The star rating remains unchanged, and your witty comment is nowhere to be seen. This discrepancy creates a sense of disconnect and undermines the value of your contribution. The only way to see the updated review is to open the restaurant's details, which is an extra step that shouldn't be necessary. This behavior suggests that the app is not properly refreshing the data on the discovery page, leading to a frustrating user experience. The system should ideally push updates in real-time, ensuring that the discovery page always displays the most current information. By understanding these steps in detail, we can better appreciate the impact of the bug and the importance of fixing it promptly. The customer journey should be seamless and intuitive, and this review update issue disrupts that flow.

Expected Behavior

Ideally, when a customer leaves a review for a restaurant, it should be displayed immediately on the restaurant's discovery page. No tapping, no waiting, just instant feedback gratification! Plus, we need to make sure that customers can only review an order once. It's a one-review-per-order policy for maximum fairness and accuracy.

To elaborate on the expected behavior, consider the ideal scenario from the user's perspective. After placing an order and receiving their meal, a customer decides to share their experience by leaving a review. They navigate to their order history, select the relevant order, and provide their feedback, whether it's a glowing five-star rating or a constructive critique. The expectation is that this feedback will be promptly reflected in the app, allowing other users to benefit from their insights. On the restaurant discovery page, each listing should display the most up-to-date information, including the average star rating and the number of reviews. When a new review is submitted, the app should automatically update these metrics, ensuring that users always see the latest feedback. This real-time update is crucial for maintaining transparency and building trust in the platform. Imagine a user browsing the discovery page, looking for a highly-rated restaurant. They see a listing with a four-star average and a certain number of reviews. If a new five-star review has just been submitted, the average rating should ideally increase, and the review count should increment. This immediate feedback loop encourages users to contribute reviews, knowing that their input will have a direct impact on the information displayed. In addition to the immediate update, the system should also prevent customers from reviewing the same order multiple times. This is essential for maintaining the integrity of the review system and preventing skewed ratings. Allowing multiple reviews could lead to situations where a single user dominates the feedback, potentially manipulating the overall score. A one-review-per-order policy ensures that the average rating is based on a wider range of opinions, providing a more balanced and reliable representation of the restaurant's performance. This policy also simplifies the review management process for restaurants. They can be confident that the feedback they receive is genuine and that the overall rating reflects a diverse set of experiences. By implementing these two key features – immediate review updates and one-review-per-order policy – we can create a more user-friendly and trustworthy platform for both customers and restaurants. The goal is to foster a transparent environment where feedback is valued and used to improve the overall dining experience.

Visual Evidence: Screen Recording

We even have a screen recording (WhatsApp.Video.2025-01-15.at.11.49.12.AM.1.mp4) that shows this bug in action. Seeing is believing, right?

Device Information

Here's the tech setup where this bug was spotted:

• Device: Infinix Hot 50 (Specific device details help us understand if it's device-specific.)
• OS: Windows (Operating system information is crucial for compatibility testing.)
• Browser: Application (Specifying "Application" suggests this is happening within the native app.)
• Version: 14 (The app version helps pinpoint if the bug is in a specific release.)

To elaborate on the significance of this device information, let's consider each component individually. The Device, in this case, the Infinix Hot 50, is a specific hardware model. Knowing the device is important because bugs can sometimes be device-specific, meaning they only occur on certain hardware configurations. This could be due to factors such as screen resolution, processing power, or memory limitations. For example, a bug might manifest on a device with lower processing power due to performance bottlenecks. The Operating System (OS), identified as Windows, is the software that manages the device's hardware and software resources. Different operating systems have different architectures and APIs, which can lead to variations in how an application behaves. While Windows is primarily known for desktop and laptop computers, the fact that it's listed here might indicate the use of an Android emulator on Windows, or potentially a misunderstanding in the information provided. Clarifying this aspect is crucial for accurate debugging. The Browser, specified as "Application," is a key piece of information. This suggests that the bug is occurring within the native mobile application, rather than a web browser. Native applications interact directly with the device's hardware and operating system, which means that bugs in this environment can have different root causes compared to web-based applications. The Version, listed as 14, is the specific release number of the application. Software versions are essential for tracking bug fixes and feature updates. If a bug is present in version 14 but not in earlier versions, it indicates that the issue was introduced in that specific release. This information helps developers narrow down the scope of the bug and identify the code changes that might have caused it. In combination, these device details provide a comprehensive snapshot of the environment where the bug was observed. This information is invaluable for developers as they work to reproduce the bug, diagnose its root cause, and implement a fix. By understanding the specific hardware, operating system, and application version involved, developers can efficiently target their debugging efforts and ensure that the fix addresses the issue effectively.

Next Steps

So, what's the plan of attack? We need to:

1. Investigate the code to find out why the reviews aren't updating on the discovery screen.
2. Implement a fix to ensure reviews are displayed in real-time.
3. Enforce the one-review-per-order rule to maintain review integrity.

Let's get this fixed, guys, so our customers can trust the reviews they see and make the best dining decisions!

To elaborate on these next steps, let's break down each action and its significance. Investigating the code is the first and most crucial step in resolving any bug. This involves a deep dive into the application's codebase to understand how the review system is implemented and where the potential issues might lie. Developers will need to examine the code responsible for fetching reviews, updating the display on the discovery screen, and handling review submissions. This might involve reviewing database queries, API calls, caching mechanisms, and UI rendering logic. The goal is to identify the specific lines of code that are causing the reviews to not update in real-time. This investigation often involves using debugging tools, logging statements, and code analysis techniques to trace the flow of data and pinpoint the source of the problem. It's like a detective solving a mystery, following clues and piecing together the puzzle to uncover the truth. Once the root cause of the issue is identified, the next step is to implement a fix. This involves modifying the code to correct the faulty behavior and ensure that reviews are displayed on the discovery screen as soon as they are submitted. The specific fix will depend on the nature of the bug. It might involve correcting an error in the database query, updating the caching mechanism, or modifying the UI rendering logic. The fix should be carefully tested to ensure that it resolves the issue without introducing any new problems. This often involves writing unit tests and integration tests to verify the correctness of the code changes. The goal is to create a robust and reliable solution that addresses the bug effectively and prevents it from recurring in the future. In addition to fixing the review update issue, it's also important to enforce the one-review-per-order rule. This involves implementing logic in the application to prevent customers from submitting multiple reviews for the same order. This could involve adding a check in the code that verifies whether a user has already reviewed a particular order before allowing them to submit a new review. The database might also need to be updated to enforce this rule at the data level. This is crucial for maintaining the integrity of the review system and ensuring that the feedback is accurate and unbiased. By implementing these next steps, we can address the current bugs in the customer app and create a more user-friendly and trustworthy platform for both customers and restaurants. It's about building a system that values feedback and provides a seamless experience for everyone involved.