Python lifecycleevent.modified函数代码示例

    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())