Fixes #339 and add support for object specific filtering

src/xero/basemanager.py

@@ -1,8 +1,9 @@
 import io
 import json
 import requests
-from datetime import datetime
+from datetime import date, datetime
 from urllib.parse import parse_qs
+from uuid import UUID
 from xml.etree.ElementTree import Element, SubElement, tostring
 from xml.parsers.expat import ExpatError
 
@@ -40,6 +41,35 @@ class BaseManager:
         "Invoices": ["email", "online_invoice"],
         "Organisations": ["actions"],
     }
+    OBJECT_FILTER_FIELDS = {
+        "Invoices": {
+            "createdByMyApp": bool,
+            "summaryOnly": bool,
+            "IDs": list,
+            "InvoiceNumbers": list,
+            "ContactIDs": list,
+            "Statuses": list,
+        },
+        "PurchaseOrders": {"DateFrom": date, "DateTo": date, "Status": str},
+        "Quotes": {
+            "ContactID": UUID,
+            "ExpiryDateFrom": date,
+            "ExpiryDateTo": date,
+            "DateFrom": date,
+            "DateTo": date,
+            "Status": str,
+            "QuoteNumber": str,
+        },
+        "Journals": {"paymentsOnly": bool},
+        "Budgets": {"DateFrom": date, "DateTo": date},
+        "Contacts": {
+            "IDs": list,
+            "includeArchived": bool,
+            "summaryOnly": bool,
+            "searchTerm": str,
+        },
+        "TrackingCategories": {"includeArchived": bool},
+    }
     DATETIME_FIELDS = (
         "UpdatedDateUTC",
         "Updated",
@@ -397,10 +427,19 @@ def _filter(self, **kwargs):
                 headers = self.prepare_filtering_date(val)
                 del kwargs["since"]
 
-            # Accept IDs parameter for Invoices and Contacts endpoints
-            if "IDs" in kwargs:
-                params["IDs"] = ",".join(kwargs["IDs"])
-                del kwargs["IDs"]
+            def get_filter_value(key, value, value_type=None):
+                if key in self.BOOLEAN_FIELDS or value_type == bool:
+                    return "true" if value else "false"
+                elif key in self.DATE_FIELDS or value_type == date:
+                    return f"{value.year}-{value.month}-{value.day}"
+                elif key in self.DATETIME_FIELDS or value_type == datetime:
+                    return value.isoformat()
+                elif key.endswith("ID") or value_type == UUID:
+                    return "%s" % (
+                        value.hex if type(value) == UUID else UUID(value).hex
+                    )
+                else:
+                    return value
 
             def get_filter_params(key, value):
                 last_key = key.split("_")[-1]
@@ -440,11 +479,30 @@ def generate_param(key, value):
                     field = field.replace("_", ".")
                 return fmt % (field, get_filter_params(key, value))
 
+            KNOWN_PARAMETERS = ["order", "offset", "page"]
+            object_params = self.OBJECT_FILTER_FIELDS.get(self.name, {})
+            LIST_PARAMETERS = list(
+                filter(lambda x: object_params[x] == list, object_params)
+            )
+            EXTRA_PARAMETERS = list(
+                filter(lambda x: object_params[x] != list, object_params)
+            )
+
             # Move any known parameter names to the query string
-            KNOWN_PARAMETERS = ["order", "offset", "page", "includeArchived"]
-            for param in KNOWN_PARAMETERS:
+            for param in KNOWN_PARAMETERS + EXTRA_PARAMETERS:
+                if param in kwargs:
+                    params[param] = get_filter_value(
+                        param, kwargs.pop(param), object_params.get(param, None)
+                    )
+            # Support xero optimised list filtering; validate IDs we send but may need other validation
+            for param in LIST_PARAMETERS:
                 if param in kwargs:
-                    params[param] = kwargs.pop(param)
+                    if param.endswith("IDs"):
+                        params[param] = ",".join(
+                            map(lambda x: UUID(x).hex, kwargs.pop(param))
+                        )
+                    else:
+                        params[param] = ",".join(kwargs.pop(param))
 
             filter_params = []
 

src/xero/exceptions.py

@@ -50,10 +50,16 @@ def __init__(self, response):
 
         elif response.headers["content-type"].startswith("text/html"):
             payload = parse_qs(response.text)
-            self.errors = [payload["oauth_problem"][0]]
-            self.problem = self.errors[0]
-            super().__init__(response, payload["oauth_problem_advice"][0])
-
+            if payload:
+                self.errors = [payload["oauth_problem"][0]]
+                self.problem = self.errors[0]
+                super().__init__(response, payload["oauth_problem_advice"][0])
+            else:
+                # Sometimes xero returns the error message as pure text
+                # Not sure how to validate this is always the case
+                self.errors = [response.text]
+                self.problem = self.errors[0]
+                super().__init__(response, response.text)
         else:
             # Extract the messages from the text.
             # parseString takes byte content, not unicode.

src/xero/manager.py

@@ -8,7 +8,7 @@ def __init__(self, name, credentials, unit_price_4dps=False, user_agent=None):
         from xero import __version__ as VERSION  # noqa
 
         self.credentials = credentials
-        self.name = name
+        self.name = name.capitalize() if name.islower() else name
         self.base_url = credentials.base_url + XERO_API_URL
         self.extra_params = {"unitdp": 4} if unit_price_4dps else {}
         self.singular = singular(name)

tests/test_manager.py

@@ -226,13 +226,18 @@ def test_filter_ids(self):
         manager = Manager("contacts", credentials)
 
         uri, params, method, body, headers, singleobject = manager._filter(
-            IDs=["1", "2", "3", "4", "5"]
+            IDs=[
+                "3e776c4b-ea9e-4bb1-96be-6b0c7a71a37f",
+                "12345678901234567890123456789012",
+            ]
         )
 
         self.assertEqual(method, "get")
         self.assertFalse(singleobject)
 
-        expected_params = {"IDs": "1,2,3,4,5"}
+        expected_params = {
+            "IDs": "3e776c4bea9e4bb196be6b0c7a71a37f,12345678901234567890123456789012"
+        }
         self.assertEqual(params, expected_params)
 
     def test_rawfilter(self):