def update(self, instance, auto_update=True): """Update a model instance. An InvalidRequestException will be raised if the instance has not been marked as existing. :param instance: The model instance being updated. :param auto_update: Auto-update the instance with the values from Shopify. When set to False, the raw JSON object will be returned. example usage:: from shopify_trois.engines.http import Json as Shopify from shopify_trois import Credentials from shopify_trois.models import Blog credentials = Credentials(...) shopify = Shopify(store_name="test", credentials=credentials) blog = shopify.fetch(Blog, 4) blog.commentable = False shopify.update(blog) """ self._can_request("update", instance) if not instance._meta__.exists: msg = "The supplied instance does not yet exists." raise InvalidRequestException(msg) enclosure = instance.enclosure or instance.to_underscore_name() if self.ignore_model_properties: data = instance.to_dict() else: data = dict([ (k, v) for k, v in instance.to_dict().items() if k in instance.properties ]) req = Request(instance) req.data = json.dumps({enclosure: data}) res = self._put(req) if res.status_code == requests.codes.ok: if auto_update: instance.update( res.json(), ignore_properties=self.ignore_model_properties ) return else: return res.json() raise ShopifyException(res)
def update(self, instance, auto_update=True): """Update a model instance. An InvalidRequestException will be raised if the instance has not been marked as existing. :param instance: The model instance being updated. :param auto_update: Auto-update the instance with the values from Shopify. When set to False, the raw JSON object will be returned. example usage:: from shopify_trois.engines.http import Json as Shopify from shopify_trois import Credentials from shopify_trois.models import Blog credentials = Credentials(...) shopify = Shopify(store_name="test", credentials=credentials) blog = shopify.fetch(Blog, 4) blog.commentable = False shopify.update(blog) """ self._can_request("update", instance) if not instance._meta__.exists: msg = "The supplied instance does not yet exists." raise InvalidRequestException(msg) enclosure = instance.enclosure or instance.to_underscore_name() if self.ignore_model_properties: data = instance.to_dict() else: data = dict([(k, v) for k, v in instance.to_dict().items() if k in instance.properties]) req = Request(instance) req.data = json.dumps({enclosure: data}) res = self._put(req) if res.status_code == requests.codes.ok: if auto_update: instance.update(res.json(), ignore_properties=self.ignore_model_properties) return else: return res.json() raise ShopifyException(res)
def add(self, instance, auto_update=True): """Add the model instance to the store. :param instance: The model instance being added. :param auto_update: Auto-update the instance with the values from Shopify. When set to false, the raw JSON object will be returned. example usage:: from shopify_trois.engines.http import Json as Shopify from shopify_trois import Credentials from shopify_trois.models import Blog credentials = Credentials(...) shopify = Shopify(store_name="test", credentials=credentials) blog = Blog(title="Awesome") shopify.add(blog) """ self._can_request("create", instance) req = Request(instance) enclosure = instance.enclosure or instance.to_underscore_name() if self.ignore_model_properties: data = instance.to_dict() else: data = dict([ (k, v) for k, v in instance.to_dict().items() if k in instance.properties ]) req.data = json.dumps({enclosure: data}) res = self._post(req) if res.status_code == requests.codes.created: if auto_update: instance.update( res.json(), ignore_properties=self.ignore_model_properties ) return else: return res.json() raise ShopifyException(res)
def count(self, model, **params): """Return the count of a model, filtered by parameters example usage:: from shopify_trois.engines.http import Json as Shopify from shopify_trois import Credentials from shopify_trois.models import Blog credentials = Credentials(...) shopify = Shopify(store_name="test", credentials=credentials) blogs = shopify.count(Blog) """ self._can_request("count", model) req = Request(model, **params) req.resource += "/count" res = self._get(req) if res.status_code == requests.codes.ok: data = res.json() return data["count"] raise ShopifyException(res)
def add(self, instance, auto_update=True): """Add the model instance to the store. :param instance: The model instance being added. :param auto_update: Auto-update the instance with the values from Shopify. When set to false, the raw JSON object will be returned. example usage:: from shopify_trois.engines.http import Json as Shopify from shopify_trois import Credentials from shopify_trois.models import Blog credentials = Credentials(...) shopify = Shopify(store_name="test", credentials=credentials) blog = Blog(title="Awesome") shopify.add(blog) """ self._can_request("create", instance) req = Request(instance) enclosure = instance.enclosure or instance.to_underscore_name() if self.ignore_model_properties: data = instance.to_dict() else: data = dict([(k, v) for k, v in instance.to_dict().items() if k in instance.properties]) req.data = json.dumps({enclosure: data}) res = self._post(req) if res.status_code == requests.codes.created: if auto_update: instance.update(res.json(), ignore_properties=self.ignore_model_properties) return else: return res.json() raise ShopifyException(res)
def test_url_for_request(self): credentials = Credentials() shopify = Shopify(shop_name='test', credentials=credentials) request = Request() request.resource = "/test" url = shopify.url_for_request(request) # Note: the base request class does not have an extension. expected = "https://test.myshopify.com/admin/test.json" self.assertEquals(url, expected) request.resource = "/test/mmmm food" url = shopify.url_for_request(request) # Note: The url generated by url_for_request are not escaped. The # actual request.{method} will escape the url for us. expected = "https://test.myshopify.com/admin/test/mmmm food.json" self.assertEquals(url, expected)
def test_url_for_request(self): credentials = Credentials() shopify = OAuthEngine(shop_name='test', credentials=credentials) request = Request() request.resource = "/test" url = shopify.url_for_request(request) # Note: the base request class does not have an extension. expected = "https://test.myshopify.com/admin/test." self.assertEquals(url, expected) request.resource = "/test/mmmm food" url = shopify.url_for_request(request) # Note: The url generated by url_for_request are not escaped. The # actual request.{method} will escape the url for us. expected = "https://test.myshopify.com/admin/test/mmmm food." self.assertEquals(url, expected)
def test_generate_subresource_for_model(self): # This should fail due to not having a parent_id value # set on the class try: r = Request(TestSubModel) result = r.generate_resource_for_model() self.fail("A resource location should not have been generated." " `%s` " % result) except ShopifyException: pass # This should fail due to not having a parent_id value # set on the instance m = TestSubModel() try: r = Request(m) result = r.generate_resource_for_model() self.fail() except ShopifyException: pass r = Request(TestSubModel, parent_id=2) self.assertEquals(r.resource, '/test/2/test') m.testmodel_id = 1 r = Request(m) self.assertEquals(r.resource, '/test/1/test') m.id = 3 r = Request(m) self.assertEquals(r.resource, '/test/1/test/3')
def test_generate_resource_for_model(self): r = Request() result = r.generate_resource_for_model(TestModel) self.assertEquals(result, '/test') r = Request() model = TestModel() model.id = '1' result = r.generate_resource_for_model(model) self.assertEquals(result, '/test/1') instance = TestModel(id=1) r = Request(instance) self.assertEquals(r.resource, '/test/1') r = Request(TestModel) self.assertEquals(r.resource, '/test')
def custom_post(self, instance, action, data=None): """Executes a custom post method on an instance. :param instance: The model instance being modified. :param action: The action to be executed. """ self._can_request(action, instance) req = Request(instance) req.resource += action req.data = data res = self._post(req) if res.status_code == requests.codes.ok: return res.json() raise ShopifyException(res)
def delete(self, instance, **params): """Delete a model instance. An InvalidRequestException will be raised if the instance does not yet exists. :param instance: The model instance to remove. :param params: Query parameters. example usage:: from shopify_trois.engines.http import Json as Shopify from shopify_trois import Credentials from shopify_trois.models import Blog credentials = Credentials(...) shopify = Shopify(store_name="test", credentials=credentials) blog = Blog(id=3) shopify.delete(blog) """ self._can_request("delete", instance) if not instance._meta__.exists: msg = "The supplied instance does not yet exists." raise InvalidRequestException(msg) req = Request(instance) req.params = params res = self._delete(req) if res.status_code == requests.codes.ok: return True raise ShopifyException(res)
def fetch(self, model, primary_key=None, auto_instance=True, **params): """Get a specific model instance by primary key. :param Model: The class being queried. :param primary_key: The primary key value of the instance. :param auto_instance: Automatically create an instance instead of returning a json object. :param params: Query parameters. example usage:: from shopify_trois.engines.http import Json as Shopify from shopify_trois import Credentials from shopify_trois.models import Blog credentials = Credentials(...) shopify = Shopify(store_name="test", credentials=credentials) blog = shopify.fetch(Blog, 2) """ self._can_request("view", model) req = Request(model, **params) # Shop is the sole resource not following the same naming # convention for its resource url. if not model.__name__.lower() == "shop": req.resource += "/{primary_key}".format(primary_key=primary_key) res = self._get(req) if res.status_code == requests.codes.ok: data = res.json() if auto_instance: enclosure = model.enclosure or model.to_underscore_name() return model(**data[enclosure]) else: return data raise ShopifyException(res)
def index(self, model, auto_instance=True, **params): """Fetch the index for a given model and supplied parameters. :param model: The model being queried. :param auto_instance: Automatically create a Collection instance instead of returning a json object. :param params: Query parameters (see shopify documentation) example usage:: from shopify_trois.engines.http import Json as Shopify from shopify_trois import Credentials from shopify_trois.models import Blog credentials = Credentials(...) shopify = Shopify(store_name="test", credentials=credentials) blogs = shopify.index(Blog) for blog in blogs: print(blog.to_dict()) """ self._can_request("index", model) req = Request(model, **params) res = self._get(req) if res.status_code == requests.codes.ok: if auto_instance: return Collection(model, res.json()) else: return res.json() raise ShopifyException(res)
def test_init(self): r = Request() self.assertEquals(r.params, None) self.assertEquals(r.resource, None) self.assertEquals(r.data, None)
def test_headers(self): r = Request() self.assertEquals(r.headers(), {}) r.headers('test', 'value') self.assertEquals(r.headers(), {'test': 'value'}) r.headers('test', None) self.assertEquals(r.headers(), {'test': None}) r.headers('test2', None) self.assertEquals(r.headers(), {'test': None, 'test2': None})