Intro

Crafting URLs with finesse and efficiency is a task that demands careful consideration. When faced with the challenge of filtering data and creating URLs based on specific criteria, developers often encounter different solutions. We explore two approaches to URL construction: “Mapping” and the logical “If/Else Statements.”

How did I get here? Well, in my quest for new challenges, I stumbled upon an exciting journey exploring the power of APIs in Nokia NSP (Nokia Network Services Platform). APIs are the magical gateways that unlock a treasure trove of possibilities. (For more information, check out https://network.developer.nokia.com/api-documentation/. Yes, you’ll need an account to access this beauty.)

In this exploration, I encountered a challenge: utilizing REST APIs to extract valuable information from Nokia NSP. Often, I needed to apply specific criteria to filter the data. To construct complex URLs with various filters directly in the URL, I had to devise an elegant solution that wouldn’t turn into an unruly mess.

URL Construction and Filtering

Picture this: a URL base like f”https://{server}/network-supervisor/net-elements”. Now, imagine adding filters to the URL to display precise information, like f”https://{server}/network-supervisor/net-elements?filter=type=epipe&operstate=enabled”.

As you can imagine, handling multiple filters with a series of if/then statements could become a labyrinth of complexity and hard to maintain. A cleaner, more enchanting approach was needed.

Mapping: The Suggested Function

construct_url function This function, relying on the power of a filter mapping dictionary, elegantly crafts URLs based on a set of filters.

def construct_url(url_base, filters):

    filter_mapping = {
        ('operState', 'type'): "?filter=operState='{operState}' AND type='{type}'",
        ('type', 'operState'): "?filter=operState='{operState}' AND type='{type}'",
        ('name',): "?filter=name='{name}'",
        ('fdn',): "?filter=fdn='{fdn}'",
        ('type',): "?filter=type='{type}'",
        ('operState',): "?filter=operState='{operState}'"
    }

    filter_keys = tuple(filters.keys())
    suffix = filter_mapping.get(filter_keys, "")

    url = url_base + suffix.format(**filters) if suffix else url_base
    return url
    

Pros of the Function Approach

1. Compact Code: The function makes use of a filter mapping dictionary, enabling a more concise representation of URL constructions with multiple filters.
2. Scalability: Adding or modifying filter combinations can be easily accomplished by updating the filter_mapping dictionary without having to modify the core logic of the function.
3. Readability: The function’s structure is straightforward and easy to understand, making it more maintainable for future code contributors.

The Alternative Approach: If/Else Statements

An alternative approach to construct URLs based on filters is by using if/else statements.

def construct_url(url_base, filters):
    url = url_base

    if 'name' in filters and 'fdn' in filters and 'type' in filters:
        url += "?filter=name='{name}' AND fdn='{fdn}' AND type='{type}'"

    elif 'name' in filters and 'fdn' in filters:
        url += "?filter=name='{name}' AND fdn='{fdn}'"

    elif 'name' in filters and 'type' in filters:
        url += "?filter=name='{name}' AND type='{type}'"

    elif 'fdn' in filters and 'type' in filters:
        url += "?filter=fdn='{fdn}' AND type='{type}'"

    elif 'operState' in filters and 'type' in filters:
        url += "?filter=operState='{operState}' AND type='{type}'"

    elif 'type' in filters and 'operState' in filters:
        url += "?filter=operState='{operState}' AND type='{type}'"

    elif 'name' in filters:
        url += "?filter=name='{name}'"

    elif 'fdn' in filters:
        url += "?filter=fdn='{fdn}'"

    elif 'type' in filters:
        url += "?filter=type='{type}'"

    elif 'operState' in filters:
        url += "?filter=operState='{operState}'"

    return url

Cons of the If/Else Approach

1. Code Duplication: This approach may lead to code duplication, as certain filter combinations may require the same URL suffix, leading to less maintainable code.
2. Scalability: As the number of filters increases, the if/else statements can become unwieldy and harder to manage.

Conclusion

In conclusion, both the provided function and the if/else approach have their merits and drawbacks. The choice between the two largely depends on the specific requirements of your project. The function approach is advantageous when you have a limited set of filters and want a more concise and scalable solution. On the other hand, the if/else approach is preferable for its simplicity and adaptability when dealing with a broader range of filter combinations.

When making your decision, consider factors such as the size and complexity of your codebase, the number of filters you expect to handle, and the familiarity of your development team with either approach. By carefully evaluating these factors, you can ensure that your code is not only efficient but also maintainable and easy to comprehend for all team members.

See ya!

The feature image used in this post it’s a color/light study of a random picture I looked up. Please, check out my art work in Instagram, thanks: