Python node._view_project函数代码示例

 def test_view_project_child_exists(self):
     linked_node = ProjectFactory(creator=self.user)
     result = _view_project(self.node, Auth(self.user))
     assert_equal(result['node']['child_exists'], False)
     self.node.add_node_link(linked_node, Auth(self.user), save=True)
     result = _view_project(self.node, Auth(self.user))
     assert_equal(result['node']['child_exists'], False)
     child_component = NodeFactory(creator=self.user, parent=self.node)
     result = _view_project(self.node, Auth(self.user))
     assert_equal(result['node']['child_exists'], True)

 def test_serialize_node_summary_child_exists(self):
     user = UserFactory()
     parent_node = ProjectFactory(creator=user)
     linked_node = ProjectFactory(creator=user)
     result = _view_project(parent_node, Auth(user))
     assert_equal(result['node']['child_exists'], False)
     parent_node.add_node_link(linked_node, Auth(user), save=True)
     result = _view_project(parent_node, Auth(user))
     assert_equal(result['node']['child_exists'], False)
     child_component = NodeFactory(creator=user, parent=parent_node)
     result = _view_project(parent_node, Auth(user))
     assert_equal(result['node']['child_exists'], True)

def collect_file_trees(auth, node, **kwargs):
    """Collect file trees for all add-ons implementing HGrid views, then
    format data as appropriate.
    """
    serialized = _view_project(node, auth, primary=True)
    # Add addon static assets
    serialized.update(rubeus.collect_addon_assets(node))
    return serialized

    def test_view_project_pending_registration_for_admin_contributor_does_contain_cancel_link(self):
        pending_reg = RegistrationFactory(project=self.node, archive=True)
        assert_true(pending_reg.is_pending_registration)
        result = _view_project(pending_reg, Auth(self.user))

        assert_not_equal(result['node']['disapproval_link'], '')
        assert_in('/?token=', result['node']['disapproval_link'])
        pending_reg.delete()

    def test_view_project_pending_registration_for_admin_contributor_does_contain_cancel_link(self):
        pending_reg = RegistrationFactory(project=self.node, archive=True)
        assert_true(pending_reg.is_pending_registration)
        result = _view_project(pending_reg, Auth(self.user))

        assert_not_equal(result["node"]["disapproval_link"], "")
        assert_in("/?token=", result["node"]["disapproval_link"])
        pending_reg.remove()

    def test_view_project_pending_registration_for_write_contributor_does_not_contain_cancel_link(self):
        write_user = UserFactory()
        self.node.add_contributor(write_user, permissions=permissions.WRITE, auth=Auth(self.user), save=True)
        pending_reg = RegistrationFactory(project=self.node, archive=True)
        assert_true(pending_reg.is_pending_registration)
        result = _view_project(pending_reg, Auth(write_user))

        assert_equal(result["node"]["disapproval_link"], "")
        pending_reg.remove()

def dataverse_view_file(node_addon, auth, **kwargs):

    node = node_addon.owner

    file_id = kwargs.get('path')

    fail_if_unauthorized(node_addon, auth, file_id)
    fail_if_private(file_id)

    # lazily create a file GUID record
    file_obj, created = DataverseFile.get_or_create(node=node, path=file_id)

    redirect_url = check_file_guid(file_obj)
    if redirect_url:
        return redirect(redirect_url)

    # Get or create rendered file
    cache_file_name = '{0}.html'.format(file_id)
    rendered = get_cache_content(node_addon, cache_file_name)

    if rendered is None:
        filename, content = scrape_dataverse(file_id)
        _, ext = os.path.splitext(filename)
        download_url = node.api_url_for(
            'dataverse_download_file_proxy', path=file_id
        )
        rendered = get_cache_content(
            node_addon,
            cache_file_name,
            start_render=True,
            remote_path=file_obj.file_id + ext,  # Include extension for MFR
            file_content=content,
            download_url=download_url,
        )
    else:
        filename, _ = scrape_dataverse(file_id, name_only=True)

    render_url = node.api_url_for(
        'dataverse_get_rendered_file',
        path=file_id,
        render=True
    )
    ret = {
        'file_name': filename,
        'rendered': rendered,
        'render_url': render_url,
        'urls': {
            'render': render_url,
            'download': node.web_url_for('dataverse_download_file',
                                         path=file_id),
            'info': node.api_url_for('dataverse_get_file_info',
                                     path=file_id),
        }

    }
    ret.update(_view_project(node, auth))
    return ret

def collect_file_trees(**kwargs):
    """Collect file trees for all add-ons implementing HGrid views, then
    format data as appropriate.
    """
    node = kwargs['node'] or kwargs['project']
    auth = kwargs['auth']

    serialized = _view_project(node, auth)
    # Add addon static assets
    serialized.update(rubeus.collect_addon_assets(node))
    return serialized

def badges_page(*args, **kwargs):
    node = kwargs["node"] or kwargs["project"]
    auth = kwargs["auth"]
    ret = {"complete": True, "assertions": get_sorted_node_badges(node)}
    if auth.user:
        badger = auth.user.get_addon("badges")
        if badger:
            ret.update(badger.to_json(auth.user))
            ret["uid"] = auth.user._id
    ret.update(_view_project(node, auth))
    return ret

    def test_view_project_embed_forks_excludes_registrations(self):
        project = ProjectFactory()
        fork = project.fork_node(Auth(project.creator))
        reg = RegistrationFactory(project=fork)

        res = _view_project(project, auth=Auth(project.creator), embed_forks=True)

        assert_in('forks', res['node'])
        assert_equal(len(res['node']['forks']), 1)

        assert_equal(res['node']['forks'][0]['id'], fork._id)

    def test_view_project_pointer_count_excludes_folders(self):
        pointer_project = ProjectFactory(is_public=True)  # project that points to another project
        pointed_project = self.node  # project that other project points to
        pointer_project.add_pointer(pointed_project, Auth(pointer_project.creator), save=True)

        # Project is in a organizer collection
        folder = CollectionFactory(creator=pointed_project.creator)
        folder.add_pointer(pointed_project, Auth(pointed_project.creator), save=True)

        result = _view_project(pointed_project, Auth(pointed_project.creator))
        # pointer_project is included in count, but not folder
        assert_equal(result['node']['points'], 1)

    def test_view_project_pointer_count_excludes_folders(self):
        user = UserFactory()
        pointer_project = ProjectFactory(is_public=True)  # project that points to another project
        pointed_project = ProjectFactory(creator=user)  # project that other project points to
        pointer_project.add_pointer(pointed_project, Auth(pointer_project.creator), save=True)

        # Project is in a dashboard folder
        folder = FolderFactory(creator=pointed_project.creator)
        folder.add_pointer(pointed_project, Auth(pointed_project.creator), save=True)

        result = _view_project(pointed_project, Auth(pointed_project.creator))
        # pointer_project is included in count, but not folder
        assert_equal(result['node']['points'], 1)

    def test_view_project_embed_registrations_sorted_by_registered_date_descending(self):
        # register a project several times, with various registered_dates
        registrations = []
        for days_ago in (21, 3, 2, 8, 13, 5, 1):
            registration = RegistrationFactory(project=self.project)
            reg_date = registration.registered_date - dt.timedelta(days_ago)
            registration.registered_date = reg_date
            registration.save()
            registrations.append(registration)

        registrations.sort(key=lambda r: r.registered_date, reverse=True)
        expected = [r._id for r in registrations]

        data = _view_project(node=self.project, auth=Auth(self.project.creator), embed_registrations=True)
        actual = [n['id'] for n in data['node']['registrations']]
        assert_equal(actual, expected)

def bitbucket_page(*args, **kwargs):

    user = kwargs['auth'].user
    node = kwargs['node'] or kwargs['project']
    bitbucket = kwargs['node_addon']

    data = _view_project(node, user)

    content = _page_content(node, bitbucket, data)

    rv = {
        'addon_title': 'Bitbucket',
        'addon_page': content,
        'addon_page_js': bitbucket.config.include_js['page'],
        'addon_page_css': bitbucket.config.include_css['page'],
    }
    rv.update(data)
    return rv

def zotero_page(**kwargs):

    auth = kwargs['auth']
    node = kwargs['node'] or kwargs['project']
    zotero = node.get_addon('zotero')

    data = _view_project(node, auth)

    xml = zotero._fetch_references()

    rv = {
        'complete': True,
        'xml': xml,
        'addon_page_js': zotero.config.include_js['page'],
        'addon_page_css': zotero.config.include_css['page'],
    }
    rv.update(data)
    return rv