Quote:
Originally Posted by daveT
Thanks for the answer. I'm guessing that if it is bad in C++, then it is bad no matter what language I am using. I know that was pretty awful but when you are drinking...
I reconsidered the design a bit. Basically, I need to be able to construct maps like this: https://github.com/timotheus/ebaysdk...ng.py#L151-186
Which are nested and chained together. I found this from SO: http://programmers.stackexchange.com...a-class-method
And now I'm considering methods that look like this:
Code:
class GetFinalValue ():
def __init__ (self, final_value = True):
self.query = {}
self.query['IncludeFinalValueFee'] = final_value
def v (self):
return self.query
class GetOrdersByDay ():
def __init__ (self, days):
self.query = {}
self.query['NumberOfDays'] = days
def v (self):
return self.query
class GetOrdersByDate ():
def __init__ (self, from_date, to_date):
self.query = {}
self.query['CreateTimeFrom'] = from_date
self.query['CreateTimeTo'] = to_date
def v (self):
return self.query
class GetModifiedOrders ():
def __init__ (self, from_date, to_date):
self.query = {}
self.query['ModTimeFrom'] = from_date
self.query['ModTimeTo'] = to_date
def v (self):
return self.query
Which I guess would allow me to create said trees, but I end up with somthing like this:
If I want to call the API, I end up with something like this:
Code:
myCall = api.execute ('GetOrders', days.v().update(fv.v()))
I guess you can see how long that part I linked to would get. Obviously I can iterate, but still feels pretty gross.
It might not be bad in Python. In the Django ORM you can do Model(field1='foo').save() and it seems to work well and is definitely convenient. Though, the idea that I'd have a class creating a concrete database/api class which accesses a class variable to modify some global object does make me cringe. I think that could get messy quick.
What you have now is certainly far easier to understand, but you can factor all of the query code into a common subclass, and instead of having a new class for every query, you can make it a function:
Code:
class Query(object):
def __init__(self, **kwargs):
self.query = {}
for key, value in kwargs.iteritems():
if key in self.KEYS:
self.query[self.KEYS[key]] = value
else:
raise ValueError('Invalid key')
class OrderQuery(Query):
KEYS = {'day': 'NumberOfDays',
'final_value': 'IncludeFinalValueFee',
}
def include_final_value(self):
self.query['IncludeFinalValueFee'] = True
return self
def by_day(self, days):
self.query['NumberOfDays'] = days
return self
def created_between_dates(self, from_date, to_date):
self.query['CreateTimeFrom'] = from_date
self.query['CreateTimeTo'] = to_date
return self
def modified_between_dates(self, from_date, to_date):
self.query['ModTimeFrom'] = from_date
self.query['ModTimeTo'] = to_date
return self
I also threw in the ability to init your query with a set of keywords defined in the specific query subclass. You can use it like:
Code:
order_query = OrderQuery(final_value=True).by_day(6).created_between_dates(from_date, to_date)
api.execute('GetOrders', order_query.query)
You should probably add your own API endpoint so you have api.get_order(order_query) throughout your code instead of api.execute('GetOrders', order_query.query) and then if the api changes, or you need to add an api key or something you have one place to change it. You could also consider adding a QUERY_NAME class variable to your query subclasses and then you can call api.execute_query(order_query) where execute_query is:
Code:
def execute_query(query):
api.execute_query(query.QUERY_NAME, query.query)
