コード例 #1
0
def logRoleGrant(context, receiver, role):
    # adapted from subscribers.sharing.SharingHandler
    # this function should be replaced by a factored out variant from patches.py:sharing_handle_form
    # to have an actual context-diff.

    from zopyx.plone.persistentlogger.logger import IPersistentLogger

    logger = IPersistentLogger(context)

    user = plone.api.user.get_current()
    username = user.getUserName()
    info_url = '/@@user-information?userid={}'.format(username)
    email = user.getProperty('email')
    fullname = user.getProperty('fullname')
    if fullname and email:
        username = '******'.format(username, fullname, email)

    diff_context = {
        'role_changes': {
            receiver.getId(): {
                'fullname': receiver.getProperty('fullname'),
                'email': receiver.getProperty('email'),
                'added': {role,},
                'removed': set(),
            }
        }
    }

    logger.log('Sharing updated (via Role Request)',
               level='info',
               username=username,
               info_url=info_url,
               details=diff_context)
コード例 #2
0
 def log_clear(self):
     """ Clear persistent log """
     alsoProvides(self.request, IDisableCSRFProtection)
     logger = IPersistentLogger(self.context)
     logger.clear()
     msg = u'Log entries cleared'
     logger.log(msg, 'info')
     self.context.plone_utils.addPortalMessage(msg)
     return self.request.response.redirect(
         '{}/persistent-log'.format(self.context.absolute_url()))
コード例 #3
0
def create_accounting_account(obj, event):
    """ Create an IAccount for a registered resource during object creation """

    logger = IPersistentLogger(obj)

    try:
        obj.addAccount()
        logger.log('Account created on accounting server', level='info')
    except ConflictError:
        raise
    except Exception as e:
        pass
コード例 #4
0
 def test_logging(self):
     c = self.portal
     logger = IPersistentLogger(c)
     self.assertEqual(len(logger), 0)
     logger.log(u'error', 'error')
     logger.log(u'info', 'info')
     self.assertEqual(len(logger), 2)
     logger.clear()
     self.assertEqual(len(logger), 0)
     self.assertEqual(logger.get_last_user(), 'test-user')
コード例 #5
0
 def demo(self):
     """ Create demo logger entries """
     import time
     import random
     alsoProvides(self.request, IDisableCSRFProtection)
     logger = IPersistentLogger(self.context)
     for i in range(20):  
         text = u'some text üöä {}'.format(i)
         level = random.choice(['debug', 'info', 'warn', 'error', 'fatal'])
         details = dict(a=random.random(), b=random.random(), c=random.random())
         logger.log(text, level, details)
         time.sleep(0.3)
     self.context.plone_utils.addPortalMessage(u'Demo logger entries created')
     self.request.response.redirect(self.context.absolute_url() + '/@@persistent-log')
コード例 #6
0
    def _render(self):

        IPersistentLogger(self.context).log('store')

        if 'zipfile' not in self.request.form:
            raise ValueError('No parameter "zipfile" found')

        # cleanup source folder
        get_handle = self.context.get_handle(create_if_not_existing=True)
        target_dir = SRC_PREFIX
        if get_handle.exists(target_dir):
            get_handle.removedir(target_dir, force=True)
        get_handle.makedir(target_dir)

        # Write payload/data to ZIP file
        zip_out = temp_zip(suffix='.zip')
        with open(zip_out, 'wb') as fp:
            fp.write(self.request.form['zipfile'].read())

        # and unpack it
        result = dict(mapping=dict())
        with delete_after(zip_out):
            with fs.zipfs.ZipFS(zip_out, 'r') as zip_handle:
                for name in zip_handle.walkfiles():
                    name = name.lstrip('/')
                    dest_name = '{}/{}'.format(target_dir, name)
                    get_handle.ensuredir(dest_name)
                    data = zip_handle.open(name, 'rb').read()
                    with get_handle.open(dest_name, 'wb') as fp:
                        fp.write(data)
                    with get_handle.open(dest_name + '.sha256', 'wb') as fp:
                        fp.write(hashlib.sha256(data).hexdigest())
                    result['mapping'][name] = dest_name

        return result
コード例 #7
0
    def _render(self):
        """ Create a new content object in Plone """

        payload = decode_json_payload(self.request)

        id = str(uuid.uuid4())
        title = payload.get('title')
        description = payload.get('description')
        custom = payload.get('custom')

        connector = plone.api.content.create(
            type='xmldirector.plonecore.connector',
            container=self.context,
            id=id,
            title=title,
            description=description)

        connector.connector_subpath = 'plone.api-{}/{}'.format(
            plone.api.portal.get().getId(), id)
        connector.api_enabled = True
        connector.get_handle(create_if_not_existing=True)
        connector.reindexObject()

        if custom:
            annotations = IAnnotations(connector)
            annotations[ANNOTATION_KEY] = custom

        IPersistentLogger(connector).log('created', details=payload)
        self.request.response.setStatus(201)
        return dict(
            id=id,
            url=connector.absolute_url(),
        )
コード例 #8
0
 def demo(self):
     """ Create demo logger entries """
     import time
     import random
     alsoProvides(self.request, IDisableCSRFProtection)
     logger = IPersistentLogger(self.context)
     for i in range(20):
         text = u'some text üöä {}'.format(i)
         level = random.choice(['debug', 'info', 'warn', 'error', 'fatal'])
         details = dict(a=random.random(),
                        b=random.random(),
                        c=random.random())
         logger.log(comment=text, level=level, details=details)
         time.sleep(0.3)
     self.context.plone_utils.addPortalMessage(
         u'Demo logger entries created')
     self.request.response.redirect(self.context.absolute_url() +
                                    '/@@persistent-log')
コード例 #9
0
def SharingHandler(event):
    """ Log/intercept @@sharing changes """

    context = event.object
    logger = IPersistentLogger(context)

    user = plone.api.user.get_current()
    username = user.getUserName()
    info_url = '/@@user-information?userid={}'.format(username)
    email = user.getProperty('email')
    fullname = user.getProperty('fullname')
    if fullname and email:
        username = '******'.format(username, fullname, email)

    logger.log('Sharing updated',
               level='info',
               username=username,
               info_url=info_url,
               details=event.diff_context)
コード例 #10
0
 def test_entries(self):
     c = self.portal
     logger = IPersistentLogger(c)
     logger.log(u'error', 'error')
     logger.log(u'info', 'info')
     self.assertEqual(len(logger), 2)
     entries = logger.entries
     self.assertEqual(len(entries), 2)
     for entry in entries:
         self.assertEqual(entry, logger.entry_by_uuid(entry['uuid']))
コード例 #11
0
 def log_clear(self):
     """ Clear persistent log """
     alsoProvides(self.request, IDisableCSRFProtection)
     logger = IPersistentLogger(self.context)
     logger.clear()
     msg = u'Log entries cleared'
     logger.log(msg, 'info')
     self.context.plone_utils.addPortalMessage(msg)
     return self.request.response.redirect('{}/persistent-log'.format(
         self.context.absolute_url()))
コード例 #12
0
def modified(event):
    """ get new/updated metadata"""

    obj = event.object
    if not IDexterityContent.providedBy(obj):
        return

    fields = get_all_fields(obj)
    data = dict()
    for f in fields:
        v = getattr(obj, f, None)
        if callable(v):
            v = v()
        if isinstance(v, RichTextValue):
            v = v.raw
        data[f] = v
    IPersistentLogger(obj).log("Metadata changed", details=data)
コード例 #13
0
    def _render(self):

        payload = decode_json_payload(self.request)
        IPersistentLogger(self.context).log('set_metadata', details=payload)

        title = payload.get('title', _marker)
        if title is not _marker:
            self.context.setTitle(title)

        description = payload.get('description', _marker)
        if description is not _marker:
            self.context.setDescription(description)

        subject = payload.get('subject', _marker)
        if subject is not _marker:
            self.context.setSubject(subject)

        custom = payload.get('custom', _marker)
        if custom is not _marker:
            annotations = IAnnotations(self.context)
            annotations[ANNOTATION_KEY] = custom

        return dict()
コード例 #14
0
 def entries(self):
     alsoProvides(self.request, IDisableCSRFProtection)
     result = list(IPersistentLogger(self.context).entries)
     result = sorted(result, key=operator.itemgetter('date'))
     return result
コード例 #15
0
    def test_rolerequest(self, send_mail):
        def assertMailsSent(subject):
            self.assertEquals(1, send_mail.call_count)
            self.assertEquals(
                {'*****@*****.**', '*****@*****.**'},
                send_mail.call_args[1]['recipients'])
            for args in send_mail.call_args_list:
                self.assertEquals(2, len(args[1]['recipients']))
                self.assertIsNone(args[1]['sender'])
                self.assertEquals(subject, args[1]['subject'])
                self.assertEquals('role-request.txt', args[1]['template'])

            send_mail.reset_mock()

        username_requester = 'mfn-admin-2'
        username_receiver = 'mfn-admin-1'
        email_requester = '*****@*****.**'
        email_receiver = '*****@*****.**'
        location = self.folder['B2SAFE']
        role = 'Enabler'

        # Create users
        plone.api.user.create(email_receiver, username_receiver)
        plone.api.user.create(email_requester,
                              username_requester,
                              roles=('Manager', ))

        # Use requester to create rolerequest
        logout()
        login(self.portal, username_requester)

        self.portal.invokeFactory('RoleRequest', 'rolerequest')
        rolerequest = self.portal.rolerequest

        rolerequest.update(Title='Role Request for Peter Lustig',
                           userid=username_receiver,
                           role=role,
                           context=location,
                           motivation='Motivation')

        # Switch back to TEST_USER
        logout()
        login(self.portal, TEST_USER_NAME)

        # Take a tour through the transition graph checking mails being sent, permissions set and logged

        logger = IPersistentLogger(location)

        self.assertEquals('submitted',
                          plone.api.content.get_state(rolerequest))
        self.assertEquals(0, send_mail.call_count)
        self.assertFalse(role in plone.api.user.get_roles(
            username=username_receiver, obj=location, inherit=False))
        self.assertEquals(0, len(logger.entries))

        plone.api.content.transition(obj=rolerequest, transition='reject')

        self.assertEquals('rejected', plone.api.content.get_state(rolerequest))
        assertMailsSent('[DPMT] Role request rejected')
        self.assertFalse(role in plone.api.user.get_roles(
            username=username_receiver, obj=location, inherit=False))
        self.assertEquals(0, len(logger.entries))

        plone.api.content.transition(obj=rolerequest, transition='submit')

        self.assertEquals('submitted',
                          plone.api.content.get_state(rolerequest))
        self.assertEquals(0, send_mail.call_count)
        self.assertFalse(role in plone.api.user.get_roles(
            username=username_receiver, obj=location, inherit=False))
        self.assertEquals(0, len(logger.entries))

        plone.api.content.transition(obj=rolerequest, transition='accept')

        self.assertEquals('accepted', plone.api.content.get_state(rolerequest))
        assertMailsSent('[DPMT] Role request accepted')
        self.assertTrue(role in plone.api.user.get_roles(
            username=username_receiver, obj=location, inherit=False))
        self.assertEquals(1, len(logger.entries))