def publish_post(post):
    """ Publish the post if it is not already published.

    Files and links uploaded to a post are moved to its workspace,
    related to the post they were added to and published."""
    pw = getToolByName(post, 'portal_workflow')
    reviewState = pw.getInfoFor(post, 'review_state')
    ws = post.aq_parent
    if reviewState == 'private':
        post = utilities.rename(post)
        pw.doActionFor(post, 'publish')

    for itemId, item in post.items():
        if not IRichMetaData.providedBy(item):
            continue
        # before moving we check if an object with this id already exists in
        # the workspace:
        if itemId in ws:
            newId = utilities.find_possible_id(itemId, ws)
            post.manage_renameObjects([itemId], [newId])
            itemId = newId
        # move:
        clip = post.manage_cutObjects([itemId])
        ws.manage_pasteObjects(clip)
        item = ws[itemId]
        # relate:
        intids = getUtility(IIntIds)
        relation = RelationValue(intids.getId(item))
        post.aq_base.relatedFiles = getattr(post.aq_base, 'relatedFiles', [])
        if not relation.to_id in (x.to_id for x in post.aq_base.relatedFiles):
            post.aq_base.relatedFiles.append(relation)
    def postUpdate(self):
        # publish if it isn't already:
        pw = getToolByName(self.context, 'portal_workflow')
        reviewState = pw.getInfoFor(self.context, 'review_state')
        if reviewState == 'draft':
            utilities.rename(self.context)
            pw.doActionFor(self.context, 'publish-for-site-members')

        # process invited externs:
        if getattr(self.context, 'invitedExterns', None):
            invitedExterns = self.context.invitedExterns.split(',')
            emailAddresses = set()
            for email in invitedExterns:
                email = email.strip()
                if covalent.validators.email(email):
                    emailAddresses.add(email)

            urltool = getToolByName(self.context, 'portal_url')
            portal = urltool.getPortalObject()
            member_folder = portal['people']

            for email in emailAddresses:
                member = get_member_by_email(email, member_folder)
                if member:
                    # the member already exists
                    self.context.inviteMember(member.id)
                    continue

                # make member-objects (without invitation-mail)

                # become the owner of member_folder temporarily
                original_sm = getSecurityManager()
                member_folder_owner = member_folder.getOwner().getId()
                become_portal_user(portal, member_folder_owner)

                # add member
                uid = utilities.find_possible_id(email, member_folder)
                member = covalent.utilities.add_member_object(
                    member_folder, uid, uid, email, sendInvitation=False)
                member.role = 'extern'
                member.activation_code = ''.join(random.sample(
                    string.ascii_lowercase + string.digits, 8))

                # become the normal user again
                setSecurityManager(original_sm)

                # put the new uid on the workspaces invited-list
                self.context.inviteMember(uid)

                # avoid the usual invitation mail
                self.alreadyInvited.add(uid)

                # send special invitation mail
                self.messenger.sendInvitationForExtern(uid)

        super(Edit, self).postUpdate()
Example #3
0
 def create_link(self, parent, title, **kwargs):
     link_id = find_possible_id(title, parent)
     parent.invokeFactory(
         'RichLink',
         link_id,
         title=title,
         url="www.ixds.com",
         rmAuthor="IXDS",
         **kwargs)
     return parent[link_id]
Example #4
0
def add_pending_cnrd_member(people_folder, name, role, uid=None, email=None):

    if uid is None:
        uid = utilities.find_possible_id(name)
    if email is None:
        email = uid + "@testing.meelogic.com"
    member = covalent_utils.add_member_object(people_folder, uid, name, email)
    member.role = role
    modified(member)
    covalent_utils.auto_approve_member_object(member)
    return member
Example #5
0
def add_activated_cnrd_member(people_folder, name, role, uid=None, email=None,
                              password='******'):
    if uid is None:
        uid = utilities.find_possible_id(name)
    if email is None:
        email = uid + "@testing.ixds.com"
    member = covalent_utils.add_member_object(people_folder, uid, name, email)
    member.role = role
    modified(member)
    covalent_utils.add_plone_member(member, password)
    covalent_utils.activate_member_object(member)
    return member
    def update(self):
        fti = getUtility(IDexterityFTI, name=self.portal_type)
        data = {}

        obj = self.create(data)

        if obj is not None:
            obj.title = u"%s Draft" % fti.Title()
            obj.id = utilities.find_possible_id(obj.title, self.context)
            zope.event.notify(zope.lifecycleevent.ObjectCreatedEvent(obj))
            self.add(obj)
            self._finishedAdd = True
            self.immediate_view = "%s/%s/edit" % (self.context.absolute_url(), obj.id)

        super(AddForm, self).update()
Example #7
0
def add_content(parent, portal_type=None, id=None, title=None,
        publish=True, as_user=None, **kwargs):
    if id:
        id = utilities.find_possible_id(id, parent)
    elif title:
        id = utilities.find_possible_id(title, parent)
    else:
        print '  skipped creation of %s because no id or title was given.' % (
            portal_type)
        return

    original_sm = None
    if as_user:
        mtool = getToolByName(parent, 'portal_membership')
        authenticated_user = mtool.getAuthenticatedMember().getUserName()
        if as_user != authenticated_user:
            original_sm = getSecurityManager()
            become_portal_user(parent, as_user)

    try:
        parent.invokeFactory(id=id, type_name=portal_type, **kwargs)
    except Unauthorized, e:
        print '  skipped creation of "%s": %s.' % (id, e)
        return
def create_test_content(site):
    catalog = getToolByName(site, 'portal_catalog')
    portal_workflow = getToolByName(site, 'portal_workflow')

    print '### Creating test content on "%s" ###' % site

    print "creating challenges..."

    challenges = [
        {
            'portal_type': 'cnrd.Challenge',
            'title': u'Challenge 1',
            'description': u'Interesting description.',
            'icon': named_image(150, 150),
            'publish': False,
            'finalize': [challenge_finalizer],
        },
        {
            'portal_type': 'cnrd.Challenge',
            'title': u'Challenge 2',
            'description': u'Another interesting description.',
            'icon': named_image(150, 150),
            'publish': False,
            'finalize': [challenge_finalizer],
        },
    ]

    stats = build(challenges, site['challenges'])
    print '  %i created, %i modified, %i skipped, %i recursions.' % stats

    print "creating universities..."

    universities = [
        {
            'portal_type': 'cnrd.University',
            'title': u'University of Roma',
            'text': richtextify(u'<p>Some nice words.</p>'),
            'picture': named_image(150, 150),
            'location': 'Roma',
            'publish': True,
            'finalize': [university_finalizer],
        },
        {
            'portal_type': 'cnrd.University',
            'title': u'University of Helsinki',
            'text': richtextify(u'<p>Some nice words.</p>'),
            'picture': named_image(150, 150),
            'location': 'Helsinki',
            'publish': True,
            'finalize': [university_finalizer],
        },
    ]

    stats = build(universities, site['universities'])
    print '  %i created, %i modified, %i skipped, %i recursions.' % stats

    print "creating members..."

    members = [
        {
            'portal_type': 'cnrd.Member',
            'id': 'test_user_1',
            'title': u'Test User',
            'emailAddress': '*****@*****.**',
            'description': u'What are you lookin\' at?',
            'portrait': named_blob_image(150, 300, filename=u"member_img.png"),
            'university': relatify(site['universities'][utilities.find_possible_id(
                'University of Helsinki')]),
            'role': 'student',
            'publish': False,
            'finalize': [
                (covalent_utilities.add_plone_member, {'password': '******'}),
                covalent_utilities.activate_member_object],
        },
        {
            'portal_type': 'cnrd.Member',
            'id': 'test_user_2',
            'title': u'Karl Heinz',
            'emailAddress': '*****@*****.**',
            'description': u'What are you lookin\' at?',
            'portrait': named_blob_image(300, 150, filename=u"member_img.png"),
            'university': relatify(site['universities'][utilities.find_possible_id(
                'University of Helsinki')]),
            'role': 'student',
            'publish': False,
            'finalize': [
                (covalent_utilities.add_plone_member, {'password': '******'}),
                covalent_utilities.activate_member_object],
        },
        {
            'portal_type': 'cnrd.Member',
            'id': 'new-student',
            'title': u'New Student',
            'emailAddress': '*****@*****.**',
            'description': u'What are you lookin\' at?',
            'portrait': named_blob_image(300, 150, filename=u"member_img.png"),
            'university': relatify(site['universities'][utilities.find_possible_id(
                'University of Helsinki')]),
            'role': 'student',
            'as_user': '******',
            'publish': False,
        },
        {
            'portal_type': 'cnrd.Member',
            'id': 'rejected-student',
            'title': u'Rejected Student',
            'emailAddress': '*****@*****.**',
            'description': u'What are you lookin\' at?',
            'portrait': named_blob_image(300, 150, filename=u"member_img.png"),
            'university': relatify(site['universities'][utilities.find_possible_id(
                'University of Helsinki')]),
            'role': 'student',
            'as_user': '******',
            'publish': False,
            'finalize': [
                setToRejected],
        },
        {
            'portal_type': 'cnrd.Member',
            'id': 'pending-student',
            'title': u'Pending Student',
            'emailAddress': '*****@*****.**',
            'description': u'What are you lookin\' at?',
            'portrait': named_blob_image(300, 150, filename=u"member_img.png"),
            'university': relatify(site['universities'][utilities.find_possible_id(
                'University of Helsinki')]),
            'role': 'student',
            'publish': False,
        },
        {
            'portal_type': 'cnrd.Member',
            'id': 'expired-student',
            'title': u'Expired Student',
            'emailAddress': '*****@*****.**',
            'description': u'What are you lookin\' at?',
            'portrait': named_blob_image(300, 150, filename=u"member_img.png"),
            'university': relatify(site['universities'][utilities.find_possible_id(
                'University of Helsinki')]),
            'role': 'student',
            'publish': False,
            'finalize': [
                setToExpired],
        },
        {
            'portal_type': 'cnrd.Member',
            'id': 'active-student',
            'title': u'Active Student',
            'emailAddress': '*****@*****.**',
            'description': u'What are you lookin\' at?',
            'portrait': named_blob_image(300, 150, filename=u"member_img.png"),
            'university': relatify(site['universities'][utilities.find_possible_id(
                'University of Helsinki')]),
            'role': 'student',
            'publish': False,
            'finalize': [
                (covalent_utilities.add_plone_member, {'password': '******'}),
                covalent_utilities.activate_member_object],
        },
        {
            'portal_type': 'cnrd.Member',
            'id': 'inactive-student',
            'title': u'Inactive Student',
            'emailAddress': '*****@*****.**',
            'description': u'What are you lookin\' at?',
            'portrait': named_blob_image(300, 150, filename=u"member_img.png"),
            'university': relatify(site['universities'][utilities.find_possible_id(
                'University of Helsinki')]),
            'role': 'student',
            'publish': False,
            'finalize': [
                (covalent_utilities.add_plone_member, {'password': '******'}),
                covalent_utilities.activate_member_object,
                (portal_workflow.doActionFor, {'action': 'deactivate'})],
        },
        {
            'portal_type': 'cnrd.Member',
            'id': 'new_test_student_1',
            'title': u'New Test Student 1',
            'emailAddress': '*****@*****.**',
            'description': u'What are you lookin\' at?',
            'portrait': named_blob_image(300, 150, filename=u"member_img.png"),
            'university': relatify(site['universities'][utilities.find_possible_id(
                'University of Helsinki')]),
            'role': 'student',
            'as_user': '******',
            'publish': False,
            'finalize': [],
        },
        {
            'portal_type': 'cnrd.Member',
            'id': 'new_test_student_2',
            'title': u'New Test Student 2',
            'emailAddress': '*****@*****.**',
            'description': u'What are you lookin\' at?',
            'portrait': named_blob_image(300, 150, filename=u"member_img.png"),
            'university': relatify(site['universities'][utilities.find_possible_id(
                'University of Helsinki')]),
            'role': 'student',
            'as_user': '******',
            'publish': False,
            'finalize': [],
        },
        {
            'portal_type': 'cnrd.Member',
            'id': 'new_test_teacher',
            'title': u'New Test Teacher',
            'emailAddress': '*****@*****.**',
            'description': u'What are you lookin\' at?',
            'portrait': named_blob_image(300, 150, filename=u"member_img.png"),
            'university': relatify(site['universities'][utilities.find_possible_id(
                'University of Helsinki')]),
            'role': 'teacher',
            'as_user': '******',
            'publish': False,
            'finalize': [],
        },
    ]
    stats = build(members, site['people'])
    print '  %i created, %i modified, %i skipped, %i recursions.' % stats

    addSiteAdminsToAdminGroup(site)

    print "creating workspaces..."
    workspaces = [
        {
            'portal_type': 'ixds.Workspace',
            'title': u'My Workspace Draft',
            'description': u'Interesting description.',
            'challenges': [
                relatify(site['challenges']['challenge-1']),
            ],
            'members': set(),
            'previouslyEdited': True,
            'publish': False,
            'finalize': [
                (set_dates, {'date': DateTime() - 1})],
        },
        {
            'portal_type': 'ixds.Workspace',
            'title': u'Workspace 1',
            'description': u'Interesting description.',
            'challenges': [
                relatify(site['challenges']['challenge-1']),
            ],
            'members': set(['test_user_1', 'test_user_2', ]),
            'images': [named_image(150, 150), ],
            'previouslyEdited': True,
            'finalize': [
                update_workspace_image_fields,
                (set_dates, {'date': DateTime() - 80})],
        },
        {
            'portal_type': 'ixds.Workspace',
            'title': u'Workspace 2',
            'description': u'Another interesting description.',
            'challenges': [
                relatify(site['challenges']['challenge-2']),
            ],
            'members': set(['test_user_1', ]),
            'images': [named_image(150, 150), ],
            'previouslyEdited': True,
            'finalize': [
                update_workspace_image_fields,
                (set_dates, {'date': DateTime() - 70})],
        },
        {
            'portal_type': 'ixds.Workspace',
            'title': u'Empty workspace',
            'description': u'There is nothing in here, trust me.',
            'challenges': [
                relatify(site['challenges']['challenge-2']),
            ],
            'members': set(['test_user_1', ]),
            'images': [named_image(150, 150), ],
            'previouslyEdited': True,
            'finalize': [
                update_workspace_image_fields,
                (set_dates, {'date': DateTime() - 70})],
        },
        {
            'portal_type': 'ixds.Workspace',
            'title': u'Workspace with many posts',
            'description': u'This workspace certainly has a lot of posts.',
            'challenges': [
                relatify(site['challenges']['challenge-2']),
            ],
            'members': set(['test_user_1', ]),
            'images': [named_image(150, 150), ],
            'previouslyEdited': True,
            'finalize': [
                update_workspace_image_fields,
                (set_dates, {'date': DateTime() - 14})],
        },
        {
            'portal_type': 'ixds.Workspace',
            'title': u'Workspace with tasks',
            'description': u'',
            'challenges': [
                relatify(site['challenges']['challenge-2']),
            ],
            'members': set(['test_user_1', ]),
            'images': [named_image(150, 150), ],
            'previouslyEdited': True,
            'finalize': [
                update_workspace_image_fields,
                (set_dates, {'date': DateTime() - 14})],
        },
        {
            'portal_type': 'ixds.Workspace',
            'title': u'Workspace with polls',
            'description': u'',
            'challenges': [
                relatify(site['challenges']['challenge-2']),
            ],
            'members': set(['test_user_1', ]),
            'images': [named_image(150, 150), ],
            'previouslyEdited': True,
            'finalize': [
                update_workspace_image_fields,
                (set_dates, {'date': DateTime() - 14})],
        },
        {
            'portal_type': 'ixds.Workspace',
            'title': u'Workspace with files',
            'description': u'',
            'challenges': [
                relatify(site['challenges']['challenge-2']),
            ],
            'members': set(['test_user_2', ]),
            'images': [named_image(150, 150), ],
            'previouslyEdited': True,
            'finalize': [
                update_workspace_image_fields,
                (set_dates, {'date': DateTime() - 14})],
        },
    ]

    stats = build(workspaces, site['workspaces'])
    print '  %i created, %i modified, %i skipped, %i recursions.' % stats

    print "creating posts and files..."
    posts = [
        {
            'portal_type': 'ixds.Post',
            'title': u'Post 1',
            'text': richtextify(u'<p>This is text.</p>'),
            'parent': site['workspaces']['workspace-1'],
            'as_user': '******',
        },
        {
            'portal_type': 'ixds.Post',
            'title': u'Post 2',
            'text': richtextify(u'<p>This is more text.</p>'
                u'<p>More text, again.</p>'),
            'parent': site['workspaces']['workspace-1'],
            'as_user': '******',
            'items': [
                {
                    'portal_type': 'ixds.Reply',
                    'title': u'Reply 1',
                    'text': richtextify(u'<p>That\'s obvious.</p>'),
                    'as_user': '******',
                    'publish': False,
                    'finalize': [notify_form_completed],
                },
                {
                    'portal_type': 'ixds.Reply',
                    'title': u'Reply 2',
                    'text': richtextify(u'<p>Indeed.</p>'),
                    'as_user': '******',
                    'publish': False,
                    'finalize': [notify_form_completed],
                },
            ],
        },
        # tasks:
        {
            'portal_type': 'ixds.Task',
            'title': u'Task in the future',
            'text': richtextify(u'<p>This is fresh text.</p>'),
            'parent': site['workspaces']['workspace-with-tasks'],
            'date': DateTime() + 7,
            'finalize': [(covalent_utilities.set_owner_and_creator, {'userid': 'test_user_2'})],
        },
        {
            'portal_type': 'ixds.Task',
            'title': u'Task in the past',
            'text': richtextify(u'<p>This is text from long ago.</p>'),
            'parent': site['workspaces']['workspace-with-tasks'],
            'date': DateTime() - 7,
            'finalize': [(covalent_utilities.set_owner_and_creator, {'userid': 'test_user_2'})],
        },
        # polls and ratings:
        {
            'portal_type': 'ixds.Poll',
            'pollOrRating': 'poll',
            'options': set(['the one', 'the other']),
            'title': u'The poll from the past',
            'text': richtextify(u'<p>This is text from long ago.</p>'),
            'parent': site['workspaces']['workspace-with-polls'],
            'date': DateTime() - 7,
            'deadline': datetime.now() - timedelta(days=3),
            'finalize': [(covalent_utilities.set_owner_and_creator, {'userid': 'test_user_2'}),
                poll.initialize],
        },
        {
            'portal_type': 'ixds.Poll',
            'pollOrRating': 'rating',
            'options': set(range(1, 6)),
            'title': u'The rating from the past',
            'text': richtextify(u'<p>This is text from long ago.</p>'),
            'parent': site['workspaces']['workspace-with-polls'],
            'date': DateTime() - 6,
            'deadline': datetime.now() - timedelta(days=4),
            'finalize': [(covalent_utilities.set_owner_and_creator, {'userid': 'test_user_2'}),
                poll.initialize],
        },
        {
            'portal_type': 'ixds.Poll',
            'pollOrRating': 'poll',
            'options': set(['the one', 'the other']),
            'title': u'The poll',
            'text': richtextify(u'<p>This is text.</p>'),
            'parent': site['workspaces']['workspace-with-polls'],
            'date': DateTime() - 1,
            'deadline': datetime.now() + timedelta(days=7),
            'finalize': [(covalent_utilities.set_owner_and_creator, {'userid': 'test_user_2'}),
                poll.initialize],
        },
        {
            'portal_type': 'ixds.Poll',
            'pollOrRating': 'rating',
            'options': set(range(1, 6)),
            'title': u'The rating',
            'text': richtextify(u'<p>This is text.</p>'),
            'parent': site['workspaces']['workspace-with-polls'],
            'date': DateTime() - 2,
            'deadline': datetime.now() + timedelta(days=6),
            'finalize': [(covalent_utilities.set_owner_and_creator, {'userid': 'test_user_2'}),
                poll.initialize],
        },
        # (posts with) files:
        {
            'portal_type': 'ixds.Post',
            'title': u'Post with attached files',
            'text': richtextify(u'<p>This is text.</p>'),
            'parent': site['workspaces']['workspace-with-files'],
            'publish': False,
            'as_user': '******',
            'items': [
                {
                    'portal_type': 'RichFile',
                    'title': u'File with meta-data',
                    'rmMediaType': 'images',
                    'rmAuthor': u'Peter Müller',
                    'rmTags': ['scientific', 'handout'],
                    'public': True,
                    'fileData': namedfile.NamedBlobFile(dummy_image(50, 50),
                        filename=u"some_image.png"),
                    'publish': False,
                    'as_user': '******',
                    'finalize': [
                        notify_form_completed],
                },
                {
                    'portal_type': 'RichFile',
                    'title': u'Another File with meta-data',
                    'rmMediaType': 'images',
                    'rmAuthor': u'Peter Müller',
                    'rmTags': ['bachelor'],
                    'public': True,
                    'fileData': namedfile.NamedBlobFile(dummy_image(50, 50),
                        filename=u"some_other_image.png"),
                    'publish': False,
                    'as_user': '******',
                    'finalize': [
                        notify_form_completed],
                },
            ],
            'finalize_branch': [fileuploadcapable.publish_post],
        },
        {
            'portal_type': 'ixds.Post',
            'title': u'Post with attached file that has no meta-data',
            'text': richtextify(u'<p>This is text.</p>'),
            'parent': site['workspaces']['workspace-with-files'],
            'publish': False,
            'finalize': [(covalent_utilities.set_owner_and_creator, {'userid': 'test_user_2'})],
            'items': [
                {
                    'portal_type': 'RichFile',
                    'id': 'file_without_meta_data',
                    'fileData': namedfile.NamedBlobFile(dummy_image(50, 50),
                        filename=u"file_without_meta_data.png"),
                    'publish': False,
                    'finalize': [
                        (covalent_utilities.set_owner_and_creator, {'userid': 'test_user_2'})],
                },
                {
                    'portal_type': 'RichFile',
                    'id': 'another_file_without_meta_data',
                    'fileData': namedfile.NamedBlobFile(dummy_image(50, 50),
                        filename=u"another_file_without_meta_data.png"),
                    'publish': False,
                    'finalize': [
                        (covalent_utilities.set_owner_and_creator, {'userid': 'test_user_2'})],
                },
            ],
            'finalize_branch': [fileuploadcapable.publish_post],
        },
    ]

    for i in range(1, 25):
        posts.append({
            'portal_type': 'ixds.Post',
            'title': u'Post %d of many' % i,
            'text': richtextify(u'<p>This is text.</p>'),
            'parent': site['workspaces']['workspace-with-many-posts'],
            'finalize': [
                (covalent_utilities.set_owner_and_creator, {'userid': 'test_user_2'}),
                (set_dates, {'date': DateTime() - 25 + i}),
            ],
        })

    stats = build(posts)
    print '  %i created, %i modified, %i skipped, %i recursions.' % stats
    print
    print "reindexing... ",

    catalog.manage_catalogRebuild()

    print "done."
Example #9
0
def build(plan, context=None):
    d = {
        'portal_type': None,
        'id': None,
        'title': None,
        'publish': True,
        'parent': context,
        'as_user': None,
    }

    created = 0
    modified = 0
    skipped = 0
    recursions = 0

    for i in plan:
        args = d.copy()

        for attr, value in i.items():
            if attr not in ['items', 'finalize', 'finalize_branch']:
                args[attr] = value

        oid = args['id'] or utilities.find_possible_id(args['title'])
        parent = args['parent']
        obj = parent.get(oid, None)

        as_user = args.pop('as_user')
        original_sm = None
        if as_user:
            mtool = getToolByName(parent, 'portal_membership')
            authenticated_user = mtool.getAuthenticatedMember().getUserName()
            if as_user != authenticated_user:
                original_sm = getSecurityManager()
                become_portal_user(parent, as_user)

        if obj is None:
            new_obj = None
            if args['portal_type']:
                new_obj = add_content(**args)
            if new_obj:
                obj = new_obj
                created += 1
                modified -= 1
            else:
                skipped += 1
                continue

        finalize(obj, i.get('finalize', None))

        items = i.get('items', None)
        if items and obj is not None:
            c, m, s, r = build(items, obj)
            created += c
            modified += m
            skipped += s
            recursions += r + 1

        finalize(obj, i.get('finalize_branch', None))

        if original_sm:
            setSecurityManager(original_sm)

        modified += 1

    return created, modified, skipped, recursions