def create_order(self, order_id=None):
        """Create order into order container from cart in session

        :param order_id: Order ID
        :type order_id: str

        :rtype: collective.cart.core.Order
        """
        container = self.order_container()
        articles = self.cart_articles()
        if container and articles:
            if order_id is None:
                order_id = str(container.next_order_id)
            order = createContentInContainer(
                container, "collective.cart.core.Order", id=order_id, checkConstraints=False
            )
            modified(order)
            self.update_next_order_id()
            for uuid in articles:
                article = createContentInContainer(
                    order, "collective.cart.core.OrderArticle", checkConstraints=False, **articles[uuid]
                )
                modified(article)

            return order

 def clean_ac_record(self):
     context = aq_inner(self.context)
     data = getattr(context, 'report_ac')
     as_json = json.dumps(data)
     setattr(context, 'report_ac', as_json)
     modified(context)
     return as_json

    def handleOK(self, action):
        data, errors = self.extractData()
        if errors:
            self.status = self.formErrorsMessage
            return
        try:
            valid = is_valid_isbn(data['isbn'])
        except:
            print sys.exc_info()
            raise ActionExecutionError(Invalid(u"Objevila se nějaká chyby při volání Aleph služby! (%s)" % (str(sys.exc_info()),)))

        if not valid:
            raise ActionExecutionError(Invalid(u"ISBN není validní!"))

        try:
            appearedAtAleph = getISBNCount(data['isbn'])
        except:
            print sys.exc_info()
            raise ActionExecutionError(Invalid(u"Objevila se nějaká chyby při volání Aleph služby! (%s)" % (str(sys.exc_info()),)))

        if appearedAtAleph:
            raise ActionExecutionError(Invalid(u"ISBN už v Alephu existuje!"))

        wft = api.portal.get_tool('portal_workflow')
        self.context.isbn = data['isbn']
        modified(self.context)
        wft.doActionFor(self.context, 'submitISBNGeneration')
        self.status = u"Hotovo!"

 def __setitem__(self, key, value):
     if not isinstance(key, str):
         raise ValueError('Only plain ascii keys are accepted')
     if not isinstance(value, str):
         raise ValueError('Only plain ascii values are accepted')
     self._dict[key] = value
     modified(self, key)

 def update(self):
     context = aq_inner(self.context)
     self.errors = {}
     if 'form.button.Delete' in self.request:
         authenticator = getMultiAdapter((context, self.request),
                                         name=u"authenticator")
         if not authenticator.verify():
             raise Unauthorized
         form = self.request.form
         current_layout = context.layout_order
         try:
             headlines = json.loads(context.headlines)
         except TypeError:
             headlines = {}
         uuid = form.get('headline.uid', None)
         del headlines[uuid]
         new_headlines = json.dumps(headlines)
         setattr(context, 'headlines', new_headlines)
         current_layout.remove(uuid)
         setattr(context, 'layout_order', current_layout)
         modified(context)
         context.reindexObject(idxs='modified')
         api.portal.show_message(
             message=_(u"Headline successfully removed."),
             request=self.request)
         next_url = context.absolute_url() + '/@@edit-layout'
         return self.request.response.redirect(next_url)

def add_order_container(event):
    context = event.context
    if not IShoppingSite(context).order_container():
        container = createContentInContainer(
            context, 'collective.cart.core.OrderContainer',
            id="order-container", title="Order Container", checkConstraints=False)
        modified(container)

 def _update_panel_asignment(self, data):
     context = aq_inner(self.context)
     item = uuidToObject(self.uuid)
     current = getattr(item, 'panels', list())
     idx = int(self.slot)
     panel = data['panel']
     if not current:
         updated = list()
         updated.append(panel)
     else:
         list_idx = len(current) - 1
         updated = current
         if panel:
             if idx > list_idx:
                 updated.append(panel)
             else:
                 del updated[idx]
                 updated.insert(idx, panel)
     setattr(item, 'panels', updated)
     modified(context)
     context.reindexObject(idxs='modified')
     base_url = context.absolute_url()
     params = '/@@panel-asignment?uuid={0}'.format(self.uuid)
     next_url = base_url + params
     return self.request.response.redirect(next_url)

 def _create_panel(self):
     context = aq_inner(self.context)
     token = django_random.get_random_string(length=24)
     title = self.request.form.get('title')
     new_title = 'row'
     if title:
         new_title = title
     block = {
         'id': token,
         'title': new_title,
         'status': 'visible',
         'klass': 'pp-row-default',
         'panels': [
             {
                 'uuid': None,
                 'component': u"placeholder",
                 'grid-col': 12,
                 'klass': 'pp-column'
             }
         ]
     }
     items = getattr(context, 'panelPageLayout', None)
     if items is None:
         items = list()
     items.append(block)
     setattr(context, 'panelPageLayout', items)
     modified(context)
     context.reindexObject(idxs='modified')
     url = '{0}/@@panelpage-editor'.format(context.absolute_url())
     return url

 def importOrderableItems(self, data):
     context = aq_inner(self.context)
     logger = getLogger('ShopContentImport')
     io = StringIO.StringIO(data)
     reader = csv.reader(io, delimiter=';', dialect="excel", quotechar='"')
     header = reader.next()
     processed_records = 0
     transaction_threshold = 50
     for row in reader:
         code = self.getSpecificRecord(header, row, name=u'productCode')
         title = self.getSpecificRecord(header, row, name=u'title_de')
         title_en = self.getSpecificRecord(header, row, name=u'title_en')
         data = {
             'title': title,
             'title_de': title,
             'title_en': title_en,
             'productCode': code}
         if not code:
             logger.info('Product code missing for record %s' % title)
         else:
             logger.info('Processing file: %s' % title)
             item = createContentInContainer(
                 context,
                 'chromsystems.shopcontent.orderableitem',
                 checkConstraints=True, **data)
             modified(item)
         processed_records += 1
         if processed_records % transaction_threshold == 0:
             transaction.commit()
     return processed_records

 def _create_report(self):
     context = aq_inner(self.context)
     date = datetime.datetime.now()
     token = django_random.get_random_string(length=24)
     item = api.content.create(
         type='xpose.seodash.report',
         id=token,
         title='Report {0} {1}'.format(date.strftime("%B"),
                                       date.strftime("%Y")),
         container=context,
         safe_id=True
     )
     uuid = api.content.get_uuid(obj=item)
     template_file = os.path.join(os.path.dirname(__file__),
                                  'report.json')
     template = Template(open(template_file).read())
     template_vars = {
         'id': uuid_tool.uuid4(),
         'uid': uuid,
         'timestamp': int(time.time()),
         'created': datetime.datetime.now(),
         'dashboard': api.content.get_uuid(obj=context),
     }
     report = template.substitute(template_vars)
     setattr(item, 'report', report)
     modified(item)
     item.reindexObject(idxs='modified')
     return uuid

 def create_folder(self):
     from plone.dexterity.utils import createContentInContainer
     folder = createContentInContainer(
         self.portal, 'collective.behavior.sku.Folder', id='folder',
         checkConstraints=False, title='Földer', description='Description of Földer.')
     modified(folder)
     return folder

 def test_renaming_workspace_updates_group_titles(self):
     self.workspace.setTitle('new title')
     from zope.lifecycleevent import modified
     modified(self.workspace)
     group = self.portal.portal_groups.getGroupById(
         'Admins:' + self.workspace.UID())
     self.assertEqual(group.getProperty('title'), 'Admins: new title')

 def _refresh_configuration(self, data):
     context = aq_inner(self.context)
     xovi_tool = getUtility(IXoviTool)
     project_list = xovi_tool.get(
         service=u'project',
         method=u'getProjects',
         limit=50
     )
     projects = json.dumps(project_list)
     setattr(context, 'projects_xovi', projects)
     daily_domains = xovi_tool.get(
         service=u'seo',
         method=u'getDailyDomains',
         limit=50
     )
     domains = json.dumps(daily_domains)
     setattr(context, 'domains_xovi', domains)
     modified(context)
     context.reindexObject(idxs='modified')
     IStatusMessage(self.request).addStatusMessage(
         _(u"The Xovi configuration has sucessfully been refreshed"),
         type='info')
     portal_url = api.portal.get().absolute_url()
     param = '/adm/@@setup-xovi'
     url = portal_url + param
     return self.request.response.redirect(url)

 def setUp(self):
     self.portal = self.layer['portal']
     self.request = self.layer['request']
     self.portal_url = self.portal.absolute_url()
     setRoles(self.portal, TEST_USER_ID, ['Manager'])
     self.doc1 = api.content.create(
         container=self.portal,
         type='Document',
         title=u'Some Document',
     )
     self.doc1.text = RichTextValue(u'One two', 'text/plain', 'text/html')
     self.browser = Browser(self.layer['app'])
     self.browser.handleErrors = False
     modified(self.doc1)
     self.statscache = getUtility(IHistoryStatsCache)
     self.statscache.refresh()
     import transaction
     transaction.commit()
     # Set up browser
     self.browser = Browser(self.layer['app'])
     self.browser.handleErrors = False
     self.browser.addHeader(
         'Authorization',
         'Basic {}:{}'.format(SITE_OWNER_NAME, SITE_OWNER_PASSWORD,)  # noqa: P101
     )

 def render(self):
     folder = IResponseContainer(self.context)
     form = self.request.form
     context = aq_inner(self.context)
     if not self.can_edit_response:
         msg = _(u'You are not allowed to edit responses.')
         api.portal.show_message(message=msg, request=self.request, type='error')
     else:
         response_id = form.get('response_id', None)
         if response_id is None:
             msg = _(u'No response selected for saving.')
             api.portal.show_message(message=msg, request=self.request, type='error')
         elif folder[response_id] is None:
             msg = _(u'Response does not exist anymore; perhaps it was removed by another user.')
             api.portal.show_message(message=msg, request=self.request, type='error')
         else:
             response = folder[response_id]
             response_text = form.get('response', u'')
             response.text = response_text
             msg = _(
                 u'Changes saved to response id ${response_id}.',
                 mapping=dict(response_id=response_id)
             )
             api.portal.show_message(message=msg, request=self.request)
             modified(response, context)
     self.request.response.redirect(context.absolute_url())

 def postprocess_ac_record(self):
     context = aq_inner(self.context)
     report = self.report()
     ac_data = getattr(context, 'report_ac')
     ac_report = json.loads(ac_data)
     metric = report[1]
     table = metric['dataTable']
     rows = table['rows']
     for entry in ac_report[:50]:
         time_rec = entry['record_date']['mysql']
         time_comps = time_rec.split('-')
         entry_date = '{0}.{1}.{2}'.format(time_comps[2],
                                           time_comps[1],
                                           time_comps[0])
         new_row = {
             'xd:trackingDate': entry_date,
             'xd:trackingUserId': entry['user']['display_name'],
             'xd:trackingSummary': entry['summary'],
             'xd:trackingValue': entry['value']
         }
         rows.append(new_row)
     table['rows'] = rows
     metric['dataTable'] = table
     stored = getattr(context, 'report')
     data = json.loads(stored)
     items = data['items']
     items[1] = metric
     setattr(context, 'report', json.dumps(data))
     modified(context)
     context.reindexObject(idxs='modified')
     msg = _(u"Built links data table was successfully updated")
     api.portal.show_message(msg, self.request)
     return msg

def setUp(self):
    layer = self.globs['layer']
    browser = Browser(layer['app'])
    portal = layer['portal']
    self.globs.update({
        'TEST_USER_NAME': TEST_USER_NAME,
        'TEST_USER_PASSWORD': TEST_USER_PASSWORD,
        'browser': browser,
        'portal': portal,
    })
    browser.setBaseUrl(portal.absolute_url())
    browser.handleErrors = True
    portal.error_log._ignored_exceptions = ()

    setRoles(portal, TEST_USER_ID, ['Manager'])

    alsoProvides(portal, IShoppingSiteRoot)
    portal.reindexObject()

    container = createContentInContainer(
        portal, 'collective.cart.core.OrderContainer', checkConstraints=False, id='order-container', title='Örder Cöntäiner')
    modified(container)

    order1 = createContentInContainer(container, 'collective.cart.core.Order', checkConstraints=False, id='1')
    modified(order1)

    transaction.commit()

 def test_articles(self):
     from Products.CMFCore.utils import getToolByName
     from collective.cart.core.interfaces import IShoppingSiteRoot
     from plone.uuid.interfaces import IUUID
     from zope.interface import alsoProvides
     from zope.lifecycleevent import modified
     alsoProvides(self.portal, IShoppingSiteRoot)
     workflow = getToolByName(self.portal, 'portal_workflow')
     context = self.create_content('collective.cart.core.Article')
     article1 = self.create_content('collective.cart.core.Article', money=self.money('10.00'), title='Ärticle1')
     workflow.doActionFor(article1, 'publish')
     uuid1 = IUUID(article1)
     modified(article1)
     article2 = self.create_content('collective.cart.core.Article', money=self.money('20.00'), title='Ärticle2')
     workflow.doActionFor(article2, 'publish')
     uuid2 = IUUID(article2)
     modified(article2)
     context.related_articles = [uuid1, uuid2]
     instance = self.create_viewlet(RelatedArticlesViewlet, context)
     self.assertEqual(instance.articles(), [{
         'gross': self.money('10.00'),
         'image_url': 'http://nohost/plone/fallback.png',
         'title': 'Ärticle1',
         'url': 'http://nohost/plone/article1'
     }, {
         'gross': self.money('20.00'),
         'image_url': 'http://nohost/plone/fallback.png',
         'title': 'Ärticle2',
         'url': 'http://nohost/plone/article2'
     }])

 def __call__(self):
     form = self.request.form
     context = aq_inner(self.context)
     status = IStatusMessage(self.request)
     if not self.can_edit_response:
         msg = _(u"You are not allowed to edit responses.")
         msg = translate(msg, 'Poi', context=self.request)
         status.addStatusMessage(msg, type='error')
     else:
         response_id = form.get('response_id', None)
         if response_id is None:
             msg = _(u"No response selected for saving.")
             msg = translate(msg, 'Poi', context=self.request)
             status.addStatusMessage(msg, type='error')
         else:
             response = self.folder[response_id]
             response_text = form.get('response', u'')
             response.text = response_text
             # Remove cached rendered response.
             response.rendered_text = None
             msg = _(u"Changes saved to response id ${response_id}.",
                     mapping=dict(response_id=response_id))
             msg = translate(msg, 'Poi', context=self.request)
             status.addStatusMessage(msg, type='info')
             # Fire event.  We put the context in the descriptions
             # so event handlers can use this fully acquisition
             # wrapped object to do their thing.  Feels like
             # cheating, but it gets the job done.  Arguably we
             # could turn the two arguments around and signal that
             # the issue has changed, with the response in the
             # event descriptions.
             modified(response, context)
     self.request.response.redirect(context.absolute_url())

    def setUpContent(self):
        pat.login(self.portal, testing.SITE_ADMIN)

        self.challenge = helpers.create_challenge(
            self.challenges, "a-real-challenge")

        for i in range(0, 20):
            wsId = "workspace_" + str(i)
            wsName = u"Workspace " + str(i)
            ws = ws_helpers.create_workspace(self.workspaces,
                wsId, title=wsName,
                challenges=[relatify(self.challenge)])
            modified(ws)

        for i in range(0, 5):
            projectId = 'project_' + str(i)
            projectName = u"Prøjėçt " + str(i)
            project = helpers.create_project(
                self.workspaces, projectId,
                title=projectName,
                challenges=[relatify(self.challenge)],
                description=u"A lengthy but interesting description",
                goals=u"Lorem ipsum. Add goals here.")
            ws_helpers.do_action_for(project, 'publish')

            for j in range(0,3):
                wsId = "project_workspace_" + str(i) + "_" + str(j)
                wsName = u"Project-Workspace " + str(i) + " " + str(j)
                ws = ws_helpers.create_workspace(self.workspaces,
                    wsId, title=wsName)
                project.add_workspace(ws)

        pat.logout()