Exemplo n.º 1
0
 def action(self, order):
     """"""
     url = '%s/' % (self.context.absolute_url())
     props = getToolByName(self.context, 'portal_properties').pcommerce_properties
     props_paypal = getToolByName(self.context, 'portal_properties').paypal_properties
     portal_state = getMultiAdapter((self.context, self.context.REQUEST), name=u'plone_portal_state')
     lang = self.context.REQUEST.get('LANGUAGE', portal_state.default_language())
     price = CurrencyAware(order.totalincl)
     interface = self.get_paypal_interface_obj()
     cart = IShoppingCart(self.context)
     cart_products = cart.getProducts()
     product_titles = []
     for product in cart_products:
         product_titles.append(product['title'] + ' ' )
     button_params = {
         'BUTTONCODE': 'ENCRYPTED',
         'BUTTONTYPE': 'BUYNOW',
         'BUTTONSUBTYPE': 'SERVICES',
         'BUYNOWTEXT': 'PAYNOW',
         'L_BUTTONVAR0': 'notify_url=%s' % props_paypal.ipn_notify_url,
         'L_BUTTONVAR1': 'amount=%.2f' % float(price.getRoundedValue()),
         'L_BUTTONVAR2': 'item_name=%s' % "".join(product_titles),
         'L_BUTTONVAR3': 'item_number=%s' % order.orderid,
         'L_BUTTONVAR4': 'return=%s' % url + 'payment.success',
         'L_BUTTONVAR5': 'cancel_return=%s' % url + 'payment.cancel',
         'L_BUTTONVAR6': 'no_shipping=1',
         'L_BUTTONVAR7': 'no_note=1',
         'L_BUTTONVAR8': 'rm=1',
         'L_BUTTONVAR11': 'currency_code=EUR'
     }
     response = interface.bm_create_button(**button_params)
     return response.EMAILLINK
Exemplo n.º 2
0
    def __call__(self):
        self.request.set('disable_border', 1)
        self.errors = {}

        self.cart = IShoppingCart(self.context)

        if not len(self.cart):
            statusmessage = IStatusMessage(self.request)
            statusmessage.addStatusMessage(
                _(u'You have not yet added any '
                  'products to your cart'), 'error')
            return self.request.RESPONSE.redirect('%s/@@cart' %
                                                  self.context.absolute_url())

        if self.request.form.get('checkout.cancel', None):
            return getMultiAdapter((self.context, self.request),
                                   name=u'checkout.cancel')()

        self.stepid = int(self.request.form.get('checkout.stepid', 0))

        temp_state = None
        registry = IOrderRegistry(self.context)
        self.order = registry.getOrder(
            self.request.SESSION.get(ORDER_SESSION_KEY, 0))
        if self.order is not None and self.order.state != INITIALIZED:
            temp_state = self.order.state
            self.order.state = INITIALIZED

        self.order = IOrder(self.context)

        self._stepid_validator()

        if self.request.form.get('checkout.next') and \
            self.stepid < len(self.steps) - 1:
            self.next()
        elif self.request.form.get('checkout.previous') and self.stepid > 0:
            self.previous()
        elif self.request.get('stepid'):
            self.gotostep(int(self.request.get('stepid', 0)))

        if self.redirect is not None:
            return self.request.RESPONSE.redirect(self.redirect)

        html = self.template()

        if temp_state is not None:
            self.order.state = temp_state

        if self.laststep:
            registry = IOrderRegistry(self.context)
            registry.send(self.order.orderid)
            self.cart.clear()
        return html
Exemplo n.º 3
0
 def update(self):
     self.statusmessages = IStatusMessage(self.request)
     try:
         amount = int(self.request.get('cartAmount', 1))
     except:
         self.statusmessages.addStatusMessage(_(u'Please specify an amount'), 'error')
         return
     
     self.added = self.removed = 0
     adapter = IShoppingCart(self.context)
     
     if self.request.get('cartAdd', None):
         self.added += adapter.add(self.request.get('cartAdd', None), amount)
     
     elif self.request.get('cartVariation', None):
         self.added += adapter.addVariation(self.request.get('cartVariation', None), amount)
         if not self.added:
             self.statusmessages.addStatusMessage(_(u'Please select a variation'), 'error')
     
     elif self.request.get('cartRemove', None):
         self.removed -= adapter.remove(self.request.get('cartRemove', None), self.request.get('cartRemoveAmount', None))
     
     elif self.request.get('cartEdit', None):
         a, r = adapter.edit(self.request.get('cartEdit', None))
         self.added += a
         self.removed += r
         
     self.addStatusMessages()
Exemplo n.º 4
0
    def __call__(self):
        self.request.set('disable_border', 1)
        self.errors = {}

        self.cart = IShoppingCart(self.context)

        if not len(self.cart):
            statusmessage = IStatusMessage(self.request)
            statusmessage.addStatusMessage(_(u'You have not yet added any '
                'products to your cart'), 'error')
            return self.request.RESPONSE.redirect('%s/@@cart' %
                    self.context.absolute_url())

        if self.request.form.get('checkout.cancel', None):
            return getMultiAdapter((self.context, self.request),
                    name=u'checkout.cancel')()

        self.stepid = int(self.request.form.get('checkout.stepid', 0))

        temp_state = None
        registry = IOrderRegistry(self.context)
        self.order = registry.getOrder(self.request.SESSION.get(
            ORDER_SESSION_KEY, 0))
        if self.order is not None and self.order.state != INITIALIZED:
            temp_state = self.order.state
            self.order.state = INITIALIZED

        self.order = IOrder(self.context)

        self._stepid_validator()

        if self.request.form.get('checkout.next') and \
            self.stepid < len(self.steps) - 1:
            self.next()
        elif self.request.form.get('checkout.previous') and self.stepid > 0:
            self.previous()
        elif self.request.get('stepid'):
            self.gotostep(int(self.request.get('stepid', 0)))

        if self.redirect is not None:
            return self.request.RESPONSE.redirect(self.redirect)

        html = self.template()

        if temp_state is not None:
            self.order.state = temp_state

        if self.laststep:
            registry = IOrderRegistry(self.context)
            registry.send(self.order.orderid)
            self.cart.clear()
        return html
Exemplo n.º 5
0
class Cart(BrowserView):
    """view of the shopping cart
    """

    template = ViewPageTemplateFile('cart.pt')

    def __call__(self):
        self.request.set('disable_border', 1)
        self.cart = IShoppingCart(self.context)
        return self.template()
    
    @property
    @memoize
    def size(self):
        return self.cart.amount()
    
    @property
    @memoize
    def products(self):
        return self.cart.getProducts()
    
    @property
    @memoize
    def checkout(self):
        return getToolByName(self.context, 'portal_membership').checkPermission(CheckOut, self.context)
    
    @property
    @memoize
    def price(self):
        return CurrencyAware(self.cart.getPrice())
    
    @property 
    @memoize
    def taxincl(self):
        taxes = ITaxes(self.context)
        return {'tax': taxes.taxincl[0],
                'taxname': taxes.taxincl[1]}
        
Exemplo n.º 6
0
class Cart(BrowserView):
    """view of the shopping cart
    """

    template = ViewPageTemplateFile('cart.pt')

    def __call__(self):
        self.request.set('disable_border', 1)
        self.cart = IShoppingCart(self.context)
        return self.template()

    @property
    @memoize
    def size(self):
        return self.cart.amount()

    @property
    @memoize
    def products(self):
        return self.cart.getProducts()

    @property
    @memoize
    def checkout(self):
        return getToolByName(self.context,
                             'portal_membership').checkPermission(
                                 CheckOut, self.context)

    @property
    @memoize
    def price(self):
        return CurrencyAware(self.cart.getPrice())

    @property
    @memoize
    def taxincl(self):
        taxes = ITaxes(self.context)
        return {'tax': taxes.taxincl[0], 'taxname': taxes.taxincl[1]}
Exemplo n.º 7
0
class Renderer(base.Renderer):

    def update(self):
        self.cart = IShoppingCart(self.context)

    @property
    def portal_url(self):
        portal_state = getMultiAdapter((self.context, self.request), name=u'plone_portal_state')
        return portal_state.portal_url()
    
    @property
    def size(self):
        return self.cart.amount()
    
    @property
    def price(self):
        return CurrencyAware(self.cart.getPrice())
    
    @property
    def checkout(self):
        return getToolByName(self.context, 'portal_membership').checkPermission(CheckOut, self.context)

    render = ViewPageTemplateFile('cart.pt')
Exemplo n.º 8
0
 def action(self, order):
     """"""
     url = '%s/' % (self.context.absolute_url())
     props = getToolByName(self.context,
                           'portal_properties').pcommerce_properties
     props_paypal = getToolByName(self.context,
                                  'portal_properties').paypal_properties
     portal_state = getMultiAdapter((self.context, self.context.REQUEST),
                                    name=u'plone_portal_state')
     lang = self.context.REQUEST.get('LANGUAGE',
                                     portal_state.default_language())
     price = CurrencyAware(order.totalincl)
     interface = self.get_paypal_interface_obj()
     cart = IShoppingCart(self.context)
     cart_products = cart.getProducts()
     product_titles = []
     for product in cart_products:
         product_titles.append(product['title'] + ' ')
     button_params = {
         'BUTTONCODE': 'ENCRYPTED',
         'BUTTONTYPE': 'BUYNOW',
         'BUTTONSUBTYPE': 'SERVICES',
         'BUYNOWTEXT': 'PAYNOW',
         'L_BUTTONVAR0': 'notify_url=%s' % props_paypal.ipn_notify_url,
         'L_BUTTONVAR1': 'amount=%.2f' % float(price.getRoundedValue()),
         'L_BUTTONVAR2': 'item_name=%s' % "".join(product_titles),
         'L_BUTTONVAR3': 'item_number=%s' % order.orderid,
         'L_BUTTONVAR4': 'return=%s' % url + 'payment.success',
         'L_BUTTONVAR5': 'cancel_return=%s' % url + 'payment.cancel',
         'L_BUTTONVAR6': 'no_shipping=1',
         'L_BUTTONVAR7': 'no_note=1',
         'L_BUTTONVAR8': 'rm=1',
         'L_BUTTONVAR11': 'currency_code=EUR'
     }
     response = interface.bm_create_button(**button_params)
     return response.EMAILLINK
Exemplo n.º 9
0
 def products(self):
     if not hasattr(self, 'cart'):
         self.cart = IShoppingCart(self.context)
     order = None
     if self.request.SESSION.get(ORDER_SESSION_KEY, None) is not None:
         registry = IOrderRegistry(self.context)
         order = registry.getOrder(self.request.SESSION.get(ORDER_SESSION_KEY, 0))
         if order is not None:
             increaseStockFromOrder(registry, order)
     products = self.cart.getProducts()
     uid_catalog = getToolByName(self.context, 'uid_catalog')
     for product in products:
         provider = IStock(uid_catalog(UID=product['uid'])[0].getObject())
         if not len(product['variations']):
             product['stock'] = provider.stock()
         else:
             product['stock'] = provider.variationStock([uid_catalog(UID=v['uid'])[0].getObject() for v in product['variations']])
         product['outofstock'] = product['amount'] > product['stock']
         product['checkout_allowed'] = not product['outofstock'] or provider.outOfStockCheckoutAllowed()
     if order is not None:
         decreaseStockFromOrder(registry, order)
     return products
Exemplo n.º 10
0
 def update(self):
     self.cart = IShoppingCart(self.context)
Exemplo n.º 11
0
class Checkout(BrowserView):
    """checkout view
    """
    implements(ICheckoutView)

    template = ViewPageTemplateFile('checkout.pt')

    errors = {}
    cart = None
    order = None
    stepid = 0
    components = []
    redirect = None

    def __call__(self):
        self.request.set('disable_border', 1)
        self.errors = {}

        self.cart = IShoppingCart(self.context)

        if not len(self.cart):
            statusmessage = IStatusMessage(self.request)
            statusmessage.addStatusMessage(
                _(u'You have not yet added any '
                  'products to your cart'), 'error')
            return self.request.RESPONSE.redirect('%s/@@cart' %
                                                  self.context.absolute_url())

        if self.request.form.get('checkout.cancel', None):
            return getMultiAdapter((self.context, self.request),
                                   name=u'checkout.cancel')()

        self.stepid = int(self.request.form.get('checkout.stepid', 0))

        temp_state = None
        registry = IOrderRegistry(self.context)
        self.order = registry.getOrder(
            self.request.SESSION.get(ORDER_SESSION_KEY, 0))
        if self.order is not None and self.order.state != INITIALIZED:
            temp_state = self.order.state
            self.order.state = INITIALIZED

        self.order = IOrder(self.context)

        self._stepid_validator()

        if self.request.form.get('checkout.next') and \
            self.stepid < len(self.steps) - 1:
            self.next()
        elif self.request.form.get('checkout.previous') and self.stepid > 0:
            self.previous()
        elif self.request.get('stepid'):
            self.gotostep(int(self.request.get('stepid', 0)))

        if self.redirect is not None:
            return self.request.RESPONSE.redirect(self.redirect)

        html = self.template()

        if temp_state is not None:
            self.order.state = temp_state

        if self.laststep:
            registry = IOrderRegistry(self.context)
            registry.send(self.order.orderid)
            self.cart.clear()
        return html

    @property
    def steps(self):
        return ISteps(self.context)

    def next(self):
        self._nextstep()
        while 1:
            for component in self.components:
                if component.renders():
                    return
            self._nextstep()

    def previous(self):
        self._previousstep()
        while 1:
            for component in self.components:
                if component.renders():
                    return
            self._previousstep()

    def gotostep(self, stepid):
        self._gotostep(stepid)
        renders = False
        for component in self.components:
            if component.renders():
                renders = True
        if not renders:
            self.gotostep(self.stepid + 1)

    def _nextstep(self):
        if self.validate():
            self.process()
            self.stepid += 1
            self._stepid_validator()

    def _previousstep(self):
        self.stepid -= 1
        self._stepid_validator()

    def _gotostep(self, stepid):
        self.stepid = stepid
        self._stepid_validator()

    def _stepid_validator(self):
        if self.stepid < 0:
            self.stepid = 0
            self._initialize_components()
            return
        elif self.stepid > len(self.steps) - 1:
            self.stepid = len(self.steps) - 1

        for stepid in range(0, self.stepid):
            if not stepid in self.order.processed_steps:
                self.stepid = stepid
                self._initialize_components()
                return

        self._initialize_components()

    def _initialize_components(self):
        self.components = []
        for name in self.steps[self.stepid]['components']:
            component = getMultiAdapter((self.context, self.request),
                                        interface=IComponent,
                                        name=name).__of__(self.context)
            self.components.append(component)
        return self.components

    def validate(self):
        valid = True
        for component in self.components:
            if not component.validate():
                valid = False
        return valid

    def process(self):
        self.redirect = None
        for component in self.components:
            component.process()
            if not (self.stepid in self.order.processed_steps):
                self.order.processed_steps = self.order.processed_steps + \
                (self.stepid,)
            for i in range(0, len(self.steps)):
                step = self.steps[i]
                for name in step['components']:
                    s_component = getMultiAdapter(
                        (self.context, self.request),
                        interface=IComponent,
                        name=name).__of__(self.context)
                    if component.__name__ in s_component.dependencies:
                        self.order.processed_steps = \
                        tuple([n for n in self.order.processed_steps
                            if not n == i])
            if hasattr(component, 'action'):
                action = component.action()
                if action:
                    self.redirect = action

    def renders(self, step):
        components = []
        for name in step['components']:
            component = getMultiAdapter((self.context, self.request),
                                        interface=IComponent,
                                        name=name).__of__(self.context)
            if component.renders():
                return True
        return False

    @property
    def stepnavigation(self):
        steps = []
        step = None

        for i in range(0, len(self.steps)):
            step = self.steps[i]
            if len(steps) and step['name'] == steps[-1]['name']:
                continue
            renders = False
            for name in step['components']:
                component = getMultiAdapter((self.context, self.request),
                                            interface=IComponent,
                                            name=name).__of__(self.context)
                if component.renders():
                    renders = True
            if not renders:
                continue

            selected = False
            if step['name'] == self.steps[self.stepid]['name']:
                selected = True

            _class = 'step'
            if i == 0:
                _class += ' first'
            elif i == (len(self.steps) - 1):
                _class += ' last'
            if selected:
                _class += ' select'
            if i < self.stepid:
                _class += ' passed'
            if i in self.order.processed_steps:
                _class += ' processed'
            href = None
            if (i in self.order.processed_steps or \
                    (i - 1) in self.order.processed_steps) and \
                    not selected and not self.laststep:
                href = '%s/@@checkout?stepid=%s' % (
                    self.context.absolute_url(), i)

            steps.append({
                'stepid': str(i),
                'name': step['name'],
                'selected': selected,
                'href': href,
                'class': _class,
            })
        return steps

    @property
    def previous_label(self):
        for component in self.components:
            if hasattr(component, 'previous_label'):
                return component.previous_label
        if self.laststep:
            return _(u'Print')
        return _(u'Previous step')

    @property
    def next_label(self):
        for component in self.components:
            if hasattr(component, 'next_label'):
                return component.next_label
        if self.laststep:
            return _(u'Continue shopping')
        if self.stepid == len(self.steps) - 2:
            return _(u'Send order')
        return _(u'Next step')

    @property
    def cancel_label(self):
        for component in self.components:
            if hasattr(component, 'cancel_label'):
                return component.cancel_label
        return _(u'Cancel checkout')

    @property
    def previous_onclick(self):
        for component in self.components:
            if hasattr(component, 'previous_onclick'):
                return component.previous_onclick
        if self.laststep:
            return "print()"
        return None

    @property
    def next_onclick(self):
        for component in self.components:
            if hasattr(component, 'next_onclick'):
                return component.next_onclick
        return None

    @property
    def cancel_onclick(self):
        for component in self.components:
            if hasattr(component, 'cancel_onclick'):
                return component.cancel_onclick
        return None

    @property
    def action(self):
        if self.laststep:
            props = getToolByName(self.context,
                                  'portal_properties').pcommerce_properties
            portal_state = getMultiAdapter((self.context, self.request),
                                           name=u'plone_portal_state')
            return '%s/%s' % (portal_state.portal_url(),
                              props.getProperty('post_checkout', ''))
        return self.context.absolute_url() + '/@@checkout'

    @property
    def laststep(self):
        return self.stepid == len(self.steps) - 1
Exemplo n.º 12
0
class Checkout(BrowserView):
    """checkout view
    """
    implements(ICheckoutView)

    template = ViewPageTemplateFile('checkout.pt')

    errors = {}
    cart = None
    order = None
    stepid = 0
    components = []
    redirect = None

    def __call__(self):
        self.request.set('disable_border', 1)
        self.errors = {}

        self.cart = IShoppingCart(self.context)

        if not len(self.cart):
            statusmessage = IStatusMessage(self.request)
            statusmessage.addStatusMessage(_(u'You have not yet added any '
                'products to your cart'), 'error')
            return self.request.RESPONSE.redirect('%s/@@cart' %
                    self.context.absolute_url())

        if self.request.form.get('checkout.cancel', None):
            return getMultiAdapter((self.context, self.request),
                    name=u'checkout.cancel')()

        self.stepid = int(self.request.form.get('checkout.stepid', 0))

        temp_state = None
        registry = IOrderRegistry(self.context)
        self.order = registry.getOrder(self.request.SESSION.get(
            ORDER_SESSION_KEY, 0))
        if self.order is not None and self.order.state != INITIALIZED:
            temp_state = self.order.state
            self.order.state = INITIALIZED

        self.order = IOrder(self.context)

        self._stepid_validator()

        if self.request.form.get('checkout.next') and \
            self.stepid < len(self.steps) - 1:
            self.next()
        elif self.request.form.get('checkout.previous') and self.stepid > 0:
            self.previous()
        elif self.request.get('stepid'):
            self.gotostep(int(self.request.get('stepid', 0)))

        if self.redirect is not None:
            return self.request.RESPONSE.redirect(self.redirect)

        html = self.template()

        if temp_state is not None:
            self.order.state = temp_state

        if self.laststep:
            registry = IOrderRegistry(self.context)
            registry.send(self.order.orderid)
            self.cart.clear()
        return html

    @property
    def steps(self):
        return ISteps(self.context)

    def next(self):
        self._nextstep()
        while 1:
            for component in self.components:
                if component.renders():
                    return
            self._nextstep()

    def previous(self):
        self._previousstep()
        while 1:
            for component in self.components:
                if component.renders():
                    return
            self._previousstep()

    def gotostep(self, stepid):
        self._gotostep(stepid)
        renders = False
        for component in self.components:
            if component.renders():
                renders = True
        if not renders:
            self.gotostep(self.stepid + 1)

    def _nextstep(self):
        if self.validate():
            self.process()
            self.stepid += 1
            self._stepid_validator()

    def _previousstep(self):
        self.stepid -= 1
        self._stepid_validator()

    def _gotostep(self, stepid):
        self.stepid = stepid
        self._stepid_validator()

    def _stepid_validator(self):
        if self.stepid < 0:
            self.stepid = 0
            self._initialize_components()
            return
        elif self.stepid > len(self.steps) - 1:
            self.stepid = len(self.steps) - 1

        for stepid in range(0, self.stepid):
            if not stepid in self.order.processed_steps:
                self.stepid = stepid
                self._initialize_components()
                return

        self._initialize_components()

    def _initialize_components(self):
        self.components = []
        for name in self.steps[self.stepid]['components']:
            component = getMultiAdapter((self.context, self.request),
                    interface=IComponent, name=name).__of__(self.context)
            self.components.append(component)
        return self.components

    def validate(self):
        valid = True
        for component in self.components:
            if not component.validate():
                valid = False
        return valid

    def process(self):
        self.redirect = None
        for component in self.components:
            component.process()
            if not (self.stepid in self.order.processed_steps):
                self.order.processed_steps = self.order.processed_steps + \
                (self.stepid,)
            for i in range(0, len(self.steps)):
                step = self.steps[i]
                for name in step['components']:
                    s_component = getMultiAdapter(
                            (self.context, self.request), interface=IComponent,
                            name=name).__of__(self.context)
                    if component.__name__ in s_component.dependencies:
                        self.order.processed_steps = \
                        tuple([n for n in self.order.processed_steps
                            if not n == i])
            if hasattr(component, 'action'):
                action = component.action()
                if action:
                    self.redirect = action

    def renders(self, step):
        components = []
        for name in step['components']:
            component = getMultiAdapter((self.context, self.request),
                    interface=IComponent, name=name).__of__(self.context)
            if component.renders():
                return True
        return False

    @property
    def stepnavigation(self):
        steps = []
        step = None

        for i in range(0, len(self.steps)):
            step = self.steps[i]
            if len(steps) and step['name'] == steps[-1]['name']:
                continue
            renders = False
            for name in step['components']:
                component = getMultiAdapter((self.context, self.request),
                        interface=IComponent, name=name).__of__(self.context)
                if component.renders():
                    renders = True
            if not renders:
                continue

            selected = False
            if step['name'] == self.steps[self.stepid]['name']:
                selected = True

            _class = 'step'
            if i == 0:
                _class += ' first'
            elif i == (len(self.steps) - 1):
                _class += ' last'
            if selected:
                _class += ' select'
            if i < self.stepid:
                _class += ' passed'
            if i in self.order.processed_steps:
                _class += ' processed'
            href = None
            if (i in self.order.processed_steps or \
                    (i - 1) in self.order.processed_steps) and \
                    not selected and not self.laststep:
                href = '%s/@@checkout?stepid=%s' % (
                        self.context.absolute_url(), i)

            steps.append({'stepid': str(i),
                          'name': step['name'],
                          'selected': selected,
                          'href': href,
                          'class': _class, })
        return steps

    @property
    def previous_label(self):
        for component in self.components:
            if hasattr(component, 'previous_label'):
                return component.previous_label
        if self.laststep:
            return _(u'Print')
        return _(u'Previous step')

    @property
    def next_label(self):
        for component in self.components:
            if hasattr(component, 'next_label'):
                return component.next_label
        if self.laststep:
            return _(u'Continue shopping')
        if self.stepid == len(self.steps) - 2:
            return _(u'Send order')
        return _(u'Next step')

    @property
    def cancel_label(self):
        for component in self.components:
            if hasattr(component, 'cancel_label'):
                return component.cancel_label
        return _(u'Cancel checkout')

    @property
    def previous_onclick(self):
        for component in self.components:
            if hasattr(component, 'previous_onclick'):
                return component.previous_onclick
        if self.laststep:
            return "print()"
        return None

    @property
    def next_onclick(self):
        for component in self.components:
            if hasattr(component, 'next_onclick'):
                return component.next_onclick
        return None

    @property
    def cancel_onclick(self):
        for component in self.components:
            if hasattr(component, 'cancel_onclick'):
                return component.cancel_onclick
        return None

    @property
    def action(self):
        if self.laststep:
            props = getToolByName(self.context,
                    'portal_properties').pcommerce_properties
            portal_state = getMultiAdapter((self.context, self.request),
                    name=u'plone_portal_state')
            return '%s/%s' % (portal_state.portal_url(),
                    props.getProperty('post_checkout', ''))
        return self.context.absolute_url() + '/@@checkout'

    @property
    def laststep(self):
        return self.stepid == len(self.steps) - 1
Exemplo n.º 13
0
 def __call__(self):
     self.request.set('disable_border', 1)
     self.cart = IShoppingCart(self.context)
     return self.template()
Exemplo n.º 14
0
 def __call__(self):
     self.request.set('disable_border', 1)
     self.cart = IShoppingCart(self.context)
     return self.template()