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 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 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 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 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 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 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 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 test_format_money(self):
adapter = IShoppingSite(self.portal)
money = self.money('12.40')
self.assertEqual(adapter.format_money(money), u'12.40 €')
def notify_ordered(context, event):
if event.action == 'ordered':
shopping_site = IShoppingSite(context)
adapter = IOrderAdapter(context)
portal = shopping_site.portal()
email_from_address = getUtility(IRegistry)['collective.cart.shopping.notification_cc_email'] or portal.getProperty('email_from_address')
billing = shopping_site.get_address('billing')
default_charset = getattr(getattr(getToolByName(context, 'portal_properties'), 'site_properties'), 'default_charset', 'utf-8')
email_charset = getUtility(ISiteRoot).getProperty('email_charset', 'utf-8')
subject = context.translate(_(u'order-number', u'Order Number: ${number}', mapping={'number': context.id}))
utility = getUtility(IUnicodeUtility)
mfrom = u'"{}" <{}>'.format(utility.safe_unicode(shopping_site.shop().title), email_from_address)
host = getToolByName(context, 'MailHost')
underline = '=' * 28
billing_address = utility.address(billing)
if shopping_site.billing_same_as_shipping():
shipping_address = billing_address
else:
shipping = shopping_site.get_address('shipping')
shipping_address = utility.address(shipping)
articles = shopping_site.cart_article_listing()
for article in articles:
subtotal = article['gross'] * article['quantity']
article.update({'subtotal': shopping_site.format_money(subtotal)})
shipping_method_title = hasattr(
adapter.shipping_method(), 'Title') and adapter.shipping_method().Title.decode(default_charset) or u''
items = shopping_site.cart().copy()
for key in ['articles', 'billing_same_as_shipping', 'shipping_method', 'billing', 'shipping']:
if key in items:
del items[key]
items.update({
'number': context.id,
'underline': underline,
'billing_address': billing_address,
'shipping_address': shipping_address,
'articles': articles,
'shipping_method_title': shipping_method_title,
'is_shipping_free': shopping_site.shipping_gross_money().amount == 0.0,
'shipping_gross': shopping_site.locale_shipping_gross(),
'total': shopping_site.locale_total(),
})
message_to_customer = context.unrestrictedTraverse('@@to-customer-order-mail-template')(**items)
mto_customer = u'"{}" <{}>'.format(utility.fullname(billing), billing['email'])
subject_to_customer = subject
message_to_shop = context.unrestrictedTraverse('@@to-shop-order-mail-template')(**items)
mto_shop = mfrom
subject_to_shop = subject
try:
host.send(message_to_customer, mto_customer, mfrom, subject=subject_to_customer, charset=email_charset)
host.send(message_to_shop, mto_shop, mfrom, subject=subject_to_shop, charset=email_charset)
except:
message = _(u'order-processed-but',
default=u'The order was processed but we could not send e-mail to you successfully. Please consult the shop owner.')
IStatusMessage(context.REQUEST).addStatusMessage(message, type='warn')
