Running different query base on resource parent - pyramid

Question

I'm working on a pyramid traversal project and i want to run different query for retrieving the same resource base on its parent or so.
Say i have 3 resources: Customer, Store, Order. now both Customer and Store could have a list of Orders. So i define an OrderListResource as a resource and my view is like:
#view_config(context=resources.OrderListResource, renderer='json')
def view_order_list(context, request):
return {orders: context.retrieve_method()}
Now i wonder what is the best practice to retrieve data base on resource parent?
For example how OrderListResource should decide to retrieve orders by customer id or by store id. the logics should lie on the view or the resource itself?
Thanks.

Answer 1

Well, since you're using traversal, getting to the parent of your resource is very easy:
parent = context.__parent__
query = session.query(OrderList)
if isinstance(parent, CustomerResource):
query = query.filter(OrderList.customer_id == parent.id)
elif isinstance(parent, StoreResource):
query = query.filter(OrderList.store_id == parent.id)
If the parent you want to check may not be an immediate parent of your resource you can use pyramid.traversal.find_interface method.
Alternatively, if the logic differs a lot depending on whether the Order is contained within a Customer or Store, you may have two separate views using the containment view predicate.
#view_config(context=resources.OrderListResource, containment=CustomerResource, renderer='json')
def view_order_list_for_customer(context, request):
return ...
#view_config(context=resources.OrderListResource, containment=StoreResource, renderer='json')
def view_order_list_for_store(context, request):
return ...

Answer 2

Given that every resource in a resource tree has an identity then what is the purpose and the identity of a resource called OrderListResource?
To match a resource as a context during traversal it has to be created previously. Do you want to update these resources while doing CRUD operations on your real resources??? That is why I understand your idea behind OrderListResource as a collection of Order resources as a result of a dynamic query at application runtime.
You want to store customers, stores and orders. Every customer, store and order has an identity that enables you to find the item in a collection. You could create such a resource tree.
root (/) (Root Resource)
|- customers (Container supporting traversal)
|- stores (Container supporting traversal)
|- orders (Container supporting traversal)
URL patterns to traverse the resource tree
/customers/{uid}
/stores/{uid}
/orders/{uid}
Given that you save the relation to store and customer in an order resource, how to query the relationship between your resources with a natural URL pattern that fits well into the existing URL patterns?
/customers/{uid}/orders
/stores/{uid}/orders
Find orders from a single customer
#view_config(name='orders', context=resources.Customer, renderer='json')
def view_order_list_for_customer(context, request):
customer = context.__name__
orders = request.root['orders']
orders_by_customer = [order for order in orders if order.customer == customer]
return dict(orders = orders_by_customer)
Find orders from a single store
#view_config(name='orders', context=resources.Store, renderer='json')
def view_order_list_for_store(context, request):
store = context.__name__
orders = request.root['orders']
orders_by_store = [order for order in orders if order.store == store]
return dict(orders = orders_by_store)
These views are location-aware and enable you to create the query with information from the given context.
Please notice that the view name matches the name of the resource containing all Order resources.
To explore the relationship between two resources your URLs would look usually like
/resource/identifier/resource