Fix: Restaurants Showing Outside Delivery Area

Hey guys, let's dive into this bug report about a frustrating issue in the Enatega app – restaurants with high delivery charges showing up even when they're way outside the delivery area. This can be super annoying for users, so let's break down the problem, how to reproduce it, what's expected, and what's actually happening.

Describe the Bug

The core issue is that some restaurants, like "Farm Fresh - Wadi Halfa" as mentioned in the report, are popping up in the Enatega app even when they're located far away from the user's specified delivery address. This leads to incredibly high delivery charges that make ordering from these places impractical. Basically, if a restaurant is outside the serviceable area or the delivery fees are sky-high due to distance, it shouldn't be displayed to the user in the first place. Imagine craving some food and then getting hit with a crazy delivery fee – not a great experience, right?

We need to ensure that the app intelligently filters out these distant restaurants to avoid misleading users and creating frustration. This involves a combination of factors, such as accurate distance calculation, defined service areas for each restaurant, and a mechanism to hide restaurants that don't meet the criteria. The current behavior undermines the user experience and potentially damages the app's reputation. We want users to trust that the app is showing them relevant options within a reasonable delivery range and price.

Think about it from a user perspective: you open the app, enter your address, and expect to see restaurants that can actually deliver to you without breaking the bank. When restaurants far outside the delivery zone appear, it creates clutter and makes it harder to find what you're actually looking for. It also raises questions about the app's reliability and accuracy. Therefore, fixing this bug is essential for improving the overall user experience and ensuring that the app functions as intended. We want to help users find delicious food quickly and easily, without any surprises or disappointments.

Steps to Reproduce

Okay, so how can we actually see this bug in action? The report outlines a pretty straightforward way to reproduce it. Here’s a step-by-step guide:

1. Open the Enatega app: Pretty self-explanatory, guys. Fire up the app on your device.
2. Set a delivery address that's far from certain restaurants: This is the key step. Choose an address that you know is a bit of a distance from some of the restaurants in the app. For example, the report mentions "Delish Bites Co." as a potential example.
3. Browse through the list of available restaurants: Start scrolling through the list of restaurants that the app displays as being available to you.
4. Observe that some restaurants with high delivery charges are still displayed in the search results: This is where you'll see the bug. Restaurants that should be too far away are still showing up, likely with those crazy delivery fees attached.

By following these steps, you should be able to consistently reproduce the issue and see those out-of-range restaurants popping up. This will help in verifying the bug and confirming that the fix is working properly once implemented. It's important to have a clear and repeatable process for reproducing bugs so that developers can accurately diagnose the problem and test the solution. The more specific we are in our reproduction steps, the easier it will be to ensure a robust fix.

Expected Behavior

So, what should happen? Ideally, the app should be smart enough to only show restaurants that can actually deliver to the user without charging an arm and a leg. Restaurants that are outside the delivery service area or have prohibitively high delivery fees due to distance should simply not be displayed in the list of available restaurants. This creates a cleaner, more relevant experience for the user. It prevents the user from wasting time browsing restaurants that are effectively inaccessible due to location.

Think of it like this: you wouldn't want to see a pizza place 50 miles away if you're trying to order dinner, right? The app should have a similar understanding of distance and service areas. The expected behavior also ties into the overall usability of the app. A user-friendly app presents information that is relevant and actionable. Displaying restaurants that are too far away clutters the interface and detracts from the user's ability to quickly find a suitable option. It also sets a false expectation, leading users to believe that these restaurants are actually within reach when they are not.

Ultimately, the expected behavior aligns with the core functionality of a food delivery app: to connect users with restaurants that can actually deliver to them. By filtering out distant restaurants, the app can provide a more streamlined and efficient experience, increasing user satisfaction and the likelihood of repeat orders. This is not just about aesthetics; it's about the fundamental purpose of the app and ensuring that it delivers on its promise.

Actual Behavior

Unfortunately, what's actually happening is that restaurants located far from the delivery address are still being displayed, despite the high delivery fee. This is the core of the bug. The app isn't properly filtering out these distant options, leading to a confusing and potentially frustrating experience for the user. The high delivery fees associated with these restaurants are a clear indicator that they shouldn't be displayed in the first place.

This behavior not only impacts the user experience but also suggests potential issues with the app's underlying logic. The app may not be accurately calculating distances, or it may not have a robust mechanism for defining and enforcing service areas for each restaurant. Whatever the cause, the result is the same: users are seeing irrelevant options that should be filtered out. This can lead to users abandoning their orders, leaving negative reviews, or even switching to a competing app.

The discrepancy between the expected and actual behavior highlights the importance of thorough testing and quality assurance. It's crucial to identify and address these kinds of bugs before they impact a large number of users. The fact that this issue has been reported suggests that it's not an isolated incident, and that a fix is necessary to prevent further frustration and potential damage to the app's reputation. The actual behavior is a direct contradiction of the app's intended function and needs to be rectified promptly.

Screenshots

The report mentions an attached screenshot, "IMG_0482," which likely visually demonstrates the issue. Screenshots are super helpful in bug reports because they give a clear picture of what the user is seeing. In this case, the screenshot probably shows a restaurant listed with an unusually high delivery fee due to its distance from the user's address. Visual evidence like this can be invaluable for developers when they're trying to understand and fix a bug.

By seeing the actual screen that the user is seeing, developers can more easily identify the problem and verify the fix. Screenshots also help to eliminate any ambiguity in the bug report. They provide concrete evidence of the issue and allow developers to quickly grasp the situation. In addition to the high delivery fee, the screenshot might also show the restaurant's distance from the delivery address, further illustrating the discrepancy between the expected and actual behavior. The inclusion of screenshots in bug reports is a best practice that significantly improves the efficiency of the bug-fixing process.

Smartphone Details

• Device: iPhone 15 Pro
• OS: iOS 17.6.1

This information is also crucial! Knowing the device and operating system helps developers narrow down the potential causes of the bug. Sometimes, bugs are specific to certain devices or operating systems due to variations in hardware or software configurations. By providing this information, the reporter has made it easier for the developers to reproduce the issue and test the fix on the same device and OS version.

For example, a bug that occurs on an iPhone 15 Pro running iOS 17.6.1 might not occur on an older iPhone or on an Android device. By knowing this, developers can focus their efforts on the specific environment where the bug is occurring. This saves time and resources and ensures that the fix is targeted and effective. The more details that are included in a bug report, the better the chances of a quick and accurate resolution. Device and OS information are key pieces of the puzzle, and their inclusion demonstrates a thorough and helpful bug report.

Hopefully, this breakdown clarifies the issue. Let's get this fixed so users can enjoy a seamless ordering experience! 🚀