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 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 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 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 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_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_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})
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})
