def test_shipping_vat_money(self):
adapter = IShoppingSite(self.portal)
self.assertIsNone(adapter.shipping_vat_money())
adapter.shipping_gross_money = mock.Mock(return_value=self.money('10.00'))
adapter.shipping_method = mock.Mock(return_value={'vat_rate': 24.0})
self.assertEqual(adapter.shipping_vat_money(), self.money('2.40'))
def subarticles(self):
"""Returns subarticles for form select option
:rtype: list
"""
res = []
if self.context.use_subarticle:
subarticles = []
shopping_site = IShoppingSite(self.context)
for brain in self.articles(salable=True, use_subarticle=False):
obj = brain.getObject()
if not IArticleAdapter(obj).soldout():
subarticles.append(obj)
wftool = getToolByName(self.context, 'portal_workflow')
wf = wftool.getChainFor(self.context)[0]
for obj in subarticles:
state = wftool.getStatusOf(wf, obj)['review_state']
if state != 'private':
state = ''
res.append({
'title': safe_unicode(obj.Title()),
'gross': shopping_site.format_money(IArticleAdapter(obj).gross()),
'uuid': IUUID(obj),
'state': PMF(state),
})
return res
def articles(self):
"""Returns list of dictionary of articles
:rtype: list
"""
res = []
context = aq_inner(self.context)
if not getattr(context, 'related_articles', None):
context = aq_parent(context)
if not getattr(context, 'related_articles', None):
context = aq_parent(context)
if getattr(context, 'related_articles', None):
shopping_site = IShoppingSite(self.context)
path = shopping_site.shop_path()
for uuid in context.related_articles:
obj = shopping_site.get_object(IArticle, UID=uuid, path=path, review_state='published')
if obj is not None:
art = IArticleAdapter(obj)
res.append({
'gross': art.gross(),
'image_url': art.image_url(size='preview'),
'title': art.title(),
'url': obj.absolute_url(),
})
return res[:4]
def test_total(self):
adapter = IShoppingSite(self.portal)
adapter.articles_total = mock.Mock(return_value=self.money('2.00'))
self.assertEqual(adapter.total(), self.money('2.00'))
adapter.shipping_gross_money = mock.Mock(return_value=self.money('10.00'))
self.assertEqual(adapter.total(), self.money('12.00'))
def articles(self):
"""Returns list of dictionary of order articles
:rtype: list
"""
res = []
utility = getUtility(IUnicodeUtility)
shopping_site = IShoppingSite(self.context)
vat_adapter = IVATAdapter(self.context)
for item in self.get_content_listing(IOrderArticle):
obj = item.getObject()
order_article_adapter = IOrderArticleAdapter(obj)
gross_subtotal = order_article_adapter.gross_subtotal()
items = {
'description': utility.safe_unicode(item.Description()),
'gross': item.gross,
'gross_subtotal': gross_subtotal,
'locale_gross_subtotal': shopping_site.format_money(gross_subtotal),
'image_url': None,
'obj': obj,
'quantity': item.quantity,
'sku': item.sku,
'title': utility.safe_unicode(item.Title()),
'url': None,
'vat_rate': vat_adapter.percent(item.vat_rate),
'id': item.getId(),
}
orig_article = shopping_site.get_object(IArticle, path=shopping_site.portal_path(), UID=item.getId())
if orig_article:
items['url'] = orig_article.absolute_url()
items['image_url'] = IArticleAdapter(orig_article).image_url(size='mini')
res.append(items)
return res
def test_shipping_net_money(self):
adapter = IShoppingSite(self.portal)
self.assertIsNone(adapter.shipping_net_money())
adapter.shipping_gross_money = mock.Mock(return_value=self.money('10.00'))
adapter.shipping_vat_money = mock.Mock(return_value=self.money('2.40'))
self.assertEqual(adapter.shipping_net_money(), self.money('7.60'))
def test_articles_total(self):
adapter = IShoppingSite(self.portal)
adapter.cart_article_listing = mock.MagicMock()
self.assertEqual(adapter.articles_total(), self.money('0.00'))
adapter.cart_article_listing.return_value = [
{'gross': self.money('10.00'), 'quantity': 2}, {'gross': self.money('5.00'), 'quantity': 4}]
self.assertEqual(adapter.articles_total(), self.money('40.00'))
def test_shipping_methods(self):
adapter = IShoppingSite(self.portal)
self.assertEqual(len(adapter.shipping_methods()), 0)
alsoProvides(self.portal, IShoppingSiteRoot)
container = self.create_content('collective.cart.shipping.ShippingMethodContainer')
self.create_atcontent('ShippingMethod', container, id='shippingmethod1')
self.assertEqual(len(adapter.shipping_methods()), 1)
def test_reduce_stocks(self, IStock):
adapter = IShoppingSite(self.portal)
article1 = self.create_content('collective.cart.core.Article')
uuid1 = IUUID(article1)
article2 = self.create_content('collective.cart.core.Article')
uuid2 = IUUID(article2)
adapter.cart_article_listing = mock.Mock(return_value=[{'id': uuid1, 'quantity': 1}, {'id': uuid2, 'quantity': 2}])
adapter.reduce_stocks()
self.assertEqual(IStock().sub_stock.call_args_list, [((1,),), ((2,),)])
def test_get_shipping_gross_money(self):
alsoProvides(self.portal, IShoppingSiteRoot)
adapter = IShoppingSite(self.portal)
self.assertIsNone(adapter.get_shipping_gross_money('UUID'))
container = self.create_content('collective.cart.shipping.ShippingMethodContainer')
shippingmethod1 = self.create_atcontent('ShippingMethod', container, id='shippingmethod1')
uuid1 = IUUID(shippingmethod1)
self.assertEqual(adapter.get_shipping_gross_money(uuid1), self.money('0.00'))
def test_get_brain_for_text(self):
alsoProvides(self.portal, IShoppingSiteRoot)
adapter = IShoppingSite(self.portal)
self.assertIsNone(adapter.get_brain_for_text('name'))
folder = self.create_atcontent('Folder', id='name')
self.assertIsNone(adapter.get_brain_for_text('name'))
doc = self.create_atcontent('Document', folder, id='doc')
self.assertEqual(adapter.get_brain_for_text('name').getObject(), doc)
def shipping_method(self):
shopping_site = IShoppingSite(self.context)
items = shopping_site.shipping_method().copy()
if items['gross'].amount == 0.0:
items['is_free'] = True
else:
items['is_free'] = False
items['vat_rate'] = IVATAdapter(self.context).percent(items['vat_rate'])
items['gross'] = shopping_site.format_money(items['gross'])
return items
def test_clean_articles_in_cart(self, clean_articles_in_cart, IStock):
article1 = self.create_content('collective.cart.core.Article')
uuid1 = IUUID(article1)
article2 = self.create_content('collective.cart.core.Article')
uuid2 = IUUID(article2)
clean_articles_in_cart.return_value = {uuid1: {}, uuid2: {}}
IStock().stock = 0
instance = IShoppingSite(self.portal)
instance.update_cart = mock.Mock()
self.assertEqual(instance.clean_articles_in_cart(), {})
instance.update_cart.assert_called_with('articles', {})
def add_shipping_info_to_address_book_for_the_first_time(event):
member = IMember(event.context)
if member.area and not member.default_shipping_info:
data = IShoppingSite(event.context).get_address('shipping')
oid = u'{}1'.format('shipping')
info = createContentInContainer(
member.area, 'collective.cart.shopping.CustomerInfo', id=oid, checkConstraints=False, **data)
if not IShoppingSite(event.context).billing_same_as_shipping:
info.info_type = u'shipping'
modified(info)
class ArticleContentListingObject(RealContentListingObject):
adapts(IArticle)
def __init__(self, obj):
super(ArticleContentListingObject, self).__init__(obj)
self.adapter = IArticleAdapter(self._realobject)
self.shopping_site = IShoppingSite(self._realobject)
def __repr__(self):
return "<collective.cart.shopping.adapter.content_listing_object.ArticleContentListingObject instance at {}>".format(self.getPath())
def discount_available(self):
"""Return True if discount is available else False
:rtype boolean
"""
return self.adapter.discount_available()
def klass(self):
"""Return discount if discount is available esle normal
:rtype: str
"""
if self.discount_available():
return 'discount'
else:
return 'normal'
def gross(self):
"""Reterun localized gross
:rtype: unicode
"""
return self.shopping_site.format_money(self.adapter.gross())
def money(self):
"""Return localize money
:rtype: unicode
"""
return self.shopping_site.format_money(self._realobject.money)
# IContentListingObject
def CroppedDescription(self):
"""A cropped description"""
raise NotImplementedError
def getSize(self):
"""size in bytes"""
raise NotImplementedError
def test_update_address(self, update_address):
from zope.interface import alsoProvides
alsoProvides(self.portal, IShoppingSiteRoot)
adapter = IShoppingSite(self.portal)
data = {}
self.assertIsNone(adapter.update_address('billing', data))
update_address.return_value = None
self.assertEqual(adapter.update_address('billing', data),
u'birth_date_warning')
data = {'birth_date': 'BDATE'}
self.assertEqual(adapter.update_address('billing', data),
u'birth_date_warning')
data = {'birth_date': '1990-01-31'}
self.assertEqual(adapter.update_address('billing', data),
u'birth_date_warning')
data = {'birth_date': '31.01.1990'}
self.assertIsNone(adapter.update_address('billing', data))
data = {'birth_date': '31.01.1890'}
self.assertEqual(adapter.update_address('billing', data),
u'birth_date_warning_too_old')
def __call__(self, context):
terms = []
res = []
adapter = IShoppingSite(context)
path = adapter.shop_path()
for item in adapter.get_content_listing(IArticle, path=path):
obj = item.getObject()
uuid = IUUID(obj)
if not IPloneSiteRoot.providedBy(context) and uuid != IUUID(context):
res.append((IArticleAdapter(obj).title(), uuid))
res.sort()
terms = [SimpleTerm(item[1], item[1], item[0]) for item in res]
return SimpleVocabulary(terms)
def _orders(self):
shopping_site = IShoppingSite(self.context)
creator = self.context.restrictedTraverse('@@plone_portal_state').member().id
query = {
'Creator': creator,
'path': shopping_site.shop_path(),
'sort_on': 'modified',
'sort_order': 'descending',
}
order_number = self.request.form.get('order_number')
if order_number:
query['id'] = order_number
return shopping_site.get_content_listing(IOrder, **query)
def message(self, name=None):
if getattr(self, 'view', None):
name = name or getattr(self.view, '__name__', None)
else:
name = name or getattr(self, '__name__', None)
if name is not None:
name = '{}-message'.format(name)
brain = IShoppingSite(self.context).get_brain_for_text(name)
if brain:
return {
'title': brain.Title,
'description': brain.Description,
'text': brain.getObject().CookedBody(),
}
def articles(self):
"""Returns list of articles to show in cart."""
res = []
shopping_site = IShoppingSite(self.context)
for article in shopping_site.cart_article_listing():
adapter = getMultiAdapter((self.context, article), ICartArticleMultiAdapter)
article.update({
'image_url': adapter.image_url(size='mini'),
'gross': shopping_site.format_money(article['gross']),
'locale_gross_subtotal': shopping_site.format_money(adapter.gross_subtotal()),
'quantity_max': adapter.quantity_max(),
'quantity_size': adapter.quantity_size(),
})
res.append(article)
return res
def test_create_cart(self, create_order):
adapter = IShoppingSite(self.portal)
create_order.return_value = None
self.assertIsNone(adapter.create_order())
order1 = self.create_content('collective.cart.core.Order', id='1')
create_order.return_value = order1
self.assertEqual(adapter.create_order(), order1)
with self.assertRaises(KeyError):
order1['shipping_method']
with self.assertRaises(KeyError):
order1['billing']
with self.assertRaises(KeyError):
order1['shipping']
adapter.shipping_method = mock.Mock(return_value={'gross': self.money('10.00')})
order2 = self.create_content('collective.cart.core.Order', id='2')
create_order.return_value = order2
self.assertEqual(adapter.create_order(), order2)
self.assertIsNotNone(order2['shipping_method'])
with self.assertRaises(KeyError):
order2['billing']
with self.assertRaises(KeyError):
order2['shipping']
names = ['city', 'last_name', 'first_name', 'email', 'phone', 'post', 'street']
address = {}
for name in names:
address[name] = name.upper()
adapter.get_address = mock.Mock(return_value=address)
adapter.billing_same_as_shipping = mock.Mock(return_value=True)
order3 = self.create_content('collective.cart.core.Order', id='3')
create_order.return_value = order3
self.assertEqual(adapter.create_order(), order3)
self.assertIsNotNone(order3['shipping_method'])
self.assertIsNotNone(order3['billing'])
with self.assertRaises(KeyError):
order3['shipping']
adapter.billing_same_as_shipping = mock.Mock(return_value=False)
order4 = self.create_content('collective.cart.core.Order', id='4')
create_order.return_value = order4
self.assertEqual(adapter.create_order(), order4)
self.assertIsNotNone(order4['shipping_method'])
self.assertIsNotNone(order4['billing'])
self.assertIsNotNone(order4['shipping'])
def test_create_order(self, cart):
from zope.interface import alsoProvides
alsoProvides(self.portal, IShoppingSiteRoot)
with self.assertRaises(AttributeError):
IShoppingSite(
self.portal).create_order(order_id='2').registration_number
self.create_content('collective.cart.core.OrderContainer')
cart.return_value = {
'articles': {
'UUID1': mock.MagicMock()
},
'registration_number': '3'
}
self.assertEqual(
IShoppingSite(
self.portal).create_order(order_id='3').registration_number,
'3')
def test_shipping_gross_money(self):
adapter = IShoppingSite(self.portal)
adapter.shipping_method = mock.Mock(return_value=None)
self.assertIsNone(adapter.shipping_gross_money())
adapter.get_shipping_gross_money = mock.Mock()
adapter.shipping_method = mock.Mock(return_value={'uuid': 'UUID'})
adapter.shipping_gross_money()
adapter.get_shipping_gross_money.assert_called_with('UUID')
def subarticles(self):
"""Returns subarticles for form select option
:rtype: list
"""
res = []
if self.context.use_subarticle:
subarticles = []
shopping_site = IShoppingSite(self.context)
for brain in self.articles(salable=True, use_subarticle=False):
obj = brain.getObject()
if not IArticleAdapter(obj).soldout():
subarticles.append(obj)
for obj in subarticles:
res.append({
'title': safe_unicode(obj.Title()),
'gross': shopping_site.format_money(IArticleAdapter(obj).gross()),
'uuid': IUUID(obj),
})
return res
def shipping_methods(self):
"""Returns list of dictionary of shipping methods
:rtype: list
"""
shopping_site = IShoppingSite(self.context)
default_charset = getattr(getattr(getToolByName(
self.context, 'portal_properties'), 'site_properties'), 'default_charset', 'utf-8')
res = []
for brain in shopping_site.shipping_methods():
uuid = brain.UID
orig_uuid = shopping_site.shipping_method()['uuid']
if uuid == orig_uuid:
shipping_gross_money = shopping_site.shipping_gross_money()
else:
shipping_gross_money = shopping_site.get_shipping_gross_money(uuid)
if shipping_gross_money.amount == 0.0:
title = brain.Title
else:
title = '{} {}'.format(brain.Title, shopping_site.format_money(shipping_gross_money).encode(default_charset))
res.append({
'description': brain.Description,
'checked': uuid == orig_uuid,
'title': title,
'uuid': uuid,
})
return res
def _objs(self):
"""Returns list of article objects
:rtype: list
"""
query = {
'sort_on': 'feed_order',
'sort_order': 'descending',
}
limit = getUtility(IRegistry)['slt.theme.articles_feed_on_top_page']
if limit:
query['sort_limit'] = limit
return IShoppingSite(self.context).get_objects(IFeedToShopTop, **query)
def articles(self):
"""Returns list of dictionary of articles
:rtype: list
"""
res = []
shopping_site = IShoppingSite(self.context)
articles = super(ArticlesInArticleViewlet, self).articles()
if articles:
for item in IContentListing(articles):
obj = item.getObject()
adapter = IArticleAdapter(obj)
soldout = adapter.soldout()
quantity_max = adapter.quantity_max()
numbers = xrange(1, quantity_max + 1)
quantity_size = len(str(quantity_max))
subarticles = []
if obj.use_subarticle:
subarticles = adapter.subarticles()
res.append({
'description': item.Description(),
'discount_end': adapter.discount_end(),
'gross': shopping_site.format_money(adapter.gross()),
'id': item.getId(),
'image_url': adapter.image_url(size='mini'),
'klass': 'add-to-cart {}'.format(item.getId()),
'money': shopping_site.format_money(item.money),
'numbers': numbers,
'quantity_max': quantity_max,
'quantity_size': quantity_size,
'soldout': soldout,
'subarticles': subarticles,
'title': adapter.title(),
'url': item.getURL(),
'uuid': item.uuid(),
'vat_rate': IVATAdapter(self.context).percent(item.vat_rate)
})
return res
def test_billing_same_as_shipping(self):
adapter = IShoppingSite(self.portal)
self.assertIsNone(adapter.billing_same_as_shipping())
adapter.cart = mock.Mock(return_value={'billing_same_as_shipping': False})
self.assertFalse(adapter.billing_same_as_shipping())
adapter.cart = mock.Mock(return_value={'billing_same_as_shipping': True})
self.assertTrue(adapter.billing_same_as_shipping())
def test_is_addresses_filled(self):
adapter = IShoppingSite(self.portal)
self.assertIsNone(adapter.is_addresses_filled())
adapter.is_address_filled = mock.Mock(return_value=True)
self.assertTrue(adapter.is_addresses_filled())
self.assertEqual(adapter.is_address_filled.call_args_list, [(('billing',),), (('shipping',),)])
adapter.billing_same_as_shipping = mock.Mock(return_value=True)
self.assertTrue(adapter.is_addresses_filled())
self.assertEqual(adapter.is_address_filled.call_args_list, [(('billing',),), (('shipping',),), (('billing',),)])
def test_is_address_filled(self):
adapter = IShoppingSite(self.portal)
self.assertFalse(adapter.is_address_filled('billing'))
adapter.get_address = mock.Mock(return_value={})
self.assertFalse(adapter.is_address_filled('billing'))
names = ['city', 'last_name', 'first_name', 'email', 'phone', 'post', 'street']
address = {}
for name in names:
address[name] = name.upper()
adapter.get_address = mock.Mock(return_value=address)
self.assertTrue(adapter.is_address_filled('billing'))
del address['email']
self.assertFalse(adapter.is_address_filled('billing'))
def test_update_address(self, update_address):
from zope.interface import alsoProvides
alsoProvides(self.portal, IShoppingSiteRoot)
adapter = IShoppingSite(self.portal)
data = {}
self.assertIsNone(adapter.update_address('billing', data))
update_address.return_value = None
self.assertEqual(adapter.update_address('billing', data), u'birth_date_warning')
data = {'birth_date': 'BDATE'}
self.assertEqual(adapter.update_address('billing', data), u'birth_date_warning')
data = {'birth_date': '1990-01-31'}
self.assertEqual(adapter.update_address('billing', data), u'birth_date_warning')
data = {'birth_date': '31.01.1990'}
self.assertIsNone(adapter.update_address('billing', data))
data = {'birth_date': '31.01.1890'}
self.assertEqual(adapter.update_address('billing', data), u'birth_date_warning_too_old')
def test_verifyObject(self):
from zope.interface.verify import verifyObject
context = self.create_content('collective.cart.core.Order')
self.assertTrue(verifyObject(IShoppingSite, IShoppingSite(context)))
def test_verifyObject(self):
from zope.interface.verify import verifyObject
self.assertTrue(verifyObject(IShoppingSite,
IShoppingSite(self.portal)))
def test_link_to_order(self, getToolByName):
context = self.create_content('collective.cart.core.Order', id='2')
getToolByName().getHomeUrl.return_value = 'home_url'
self.assertEqual(
IShoppingSite(context).link_to_order(2), 'home_url?order_number=2')
def test_locale_articles_total(self):
adapter = IShoppingSite(self.portal)
articles_total = mock.Mock()
adapter.articles_total = articles_total
adapter.articles_total = mock.Mock(return_value=self.money('40.00'))
self.assertEqual(adapter.locale_articles_total(), u'40.00 €')
def test_shipping_method(self):
adapter = IShoppingSite(self.portal)
self.assertIsNone(adapter.shipping_method())
adapter.cart = mock.MagicMock(return_value={'shipping_method': 'SHIPPINIG_METHOD'})
self.assertEqual(adapter.shipping_method(), 'SHIPPINIG_METHOD')
def test__calculated_weight(self):
adapter = IShoppingSite(self.portal)
self.assertEqual(adapter._calculated_weight(), 0.0)
adapter.shipping_method = mock.Mock()
self.assertEqual(adapter._calculated_weight(), 0.0)
self.assertEqual(adapter._calculated_weight('RATE'), 0.0)
self.assertEqual(adapter._calculated_weight(10.0), 0.0)
adapter.cart_article_listing = mock.MagicMock(return_value=[{'weight': 100.0, 'depth': 10.0, 'height': 20.0, 'width': 30.0, 'quantity': 1}])
self.assertEqual(adapter._calculated_weight(10.0), 0.1)
adapter.cart_article_listing = mock.MagicMock(return_value=[
{'weight': 100.0, 'depth': 10.0, 'height': 20.0, 'width': 30.0, 'quantity': 1},
{'weight': 10.0, 'depth': 10.0, 'height': 20.0, 'width': 30.0, 'quantity': 1}])
self.assertEqual(adapter._calculated_weight(10.0), 0.16)
adapter.cart_article_listing = mock.MagicMock(return_value=[
{'weight': 100.0, 'depth': 10.0, 'height': 20.0, 'width': 30.0, 'quantity': 2, 'vat_rate': 24.0}])
self.assertEqual(adapter._calculated_weight(10.0), 0.2)
