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

def nds_home(auth, **kwargs):
    node = kwargs['node'] or kwargs['project']

#    print "hello world"
    ret = {
        'files': {
            "My dataset" : "My Dataset",
            "Dataset 2" : "Dataset 2",
        },
        'member': {
            "first_nane" : "Ian",
            "last_name" : "Taylor",
        },
         'nds_me' : "Ian"
    }

    ret.update(_view_project(node, auth, primary=True))

    return ret

def project_wiki_edit(auth, wname, **kwargs):
    node = kwargs['node'] or kwargs['project']
    wiki_name = wname.strip()
    wiki_page = node.get_wiki_page(wiki_name)

    # ensure home is always lower case since it cannot be renamed
    if wiki_name.lower() == 'home':
        wiki_name = 'home'

    if wiki_page:
        version = wiki_page.version
        is_current = wiki_page.is_current
        content = wiki_page.content
        wiki_page_api_url = node.api_url_for('project_wiki_page', wname=wiki_name)
    else:
        version = 'NA'
        is_current = False
        content = ''
        wiki_page_api_url = None

    # TODO: Remove duplication with project_wiki_page
    toc = _serialize_wiki_toc(node, auth=auth)
    ret = {
        'wiki_id': wiki_page._primary_key if wiki_page else None,
        'wiki_name': wiki_page.page_name if wiki_page else wiki_name,
        'wiki_content': content,
        'version': version,
        'versions': _get_wiki_versions(node, wiki_name),
        'is_current': is_current,
        'is_edit': True,
        'pages_current': _get_wiki_pages_current(node),
        'toc': toc,
        'category': node.category,
        'urls': {
            'api': _get_wiki_api_urls(node, wiki_name, {
                'content': node.api_url_for('wiki_page_content', wname=wiki_name),
                'page': wiki_page_api_url
            }),
            'web': _get_wiki_web_urls(node, wiki_name),
        },
    }
    ret.update(_view_project(node, auth, primary=True))
    return ret

def project_wiki_page(auth, wname, **kwargs):
    node = kwargs['node'] or kwargs['project']
    anonymous = has_anonymous_link(node, auth)
    wiki_name = (wname or '').strip()
    wiki_page = node.get_wiki_page(name=wiki_name)

    status_code = 200
    version = 'NA'
    is_current = False
    content = ''

    if wiki_page:
        version = wiki_page.version
        is_current = wiki_page.is_current
        content = wiki_page.html(node)
    elif not wiki_page and wiki_name.lower() != 'home':
        status_code = 404

    ret = {
        'wiki_id': wiki_page._primary_key if wiki_page else None,
        'wiki_name': wiki_page.page_name if wiki_page else wiki_name,
        'wiki_content': content,
        'page': wiki_page,
        'version': version,
        'versions': _get_wiki_versions(node, wiki_name, anonymous=anonymous),
        'is_current': is_current,
        'is_edit': False,
        'pages_current': _get_wiki_pages_current(node),
        'toc': _serialize_wiki_toc(node, auth=auth),
        'category': node.category,
        'urls': {
            'api': _get_wiki_api_urls(node, wiki_name),
            'web': _get_wiki_web_urls(node, wiki_name),
        },
    }

    ret.update(_view_project(node, auth, primary=True))
    return ret, status_code

def project_wiki_compare(auth, wname, wver, **kwargs):
    node = kwargs['node'] or kwargs['project']
    anonymous = has_anonymous_link(node, auth)
    wiki_name = wname.strip()
    wiki_page = node.get_wiki_page(wiki_name)
    toc = _serialize_wiki_toc(node, auth=auth)

    if not wiki_page:
        raise HTTPError(http.NOT_FOUND)

    comparison_page = node.get_wiki_page(wiki_name, wver)
    if comparison_page:
        current = wiki_page.content
        comparison = comparison_page.content
        sm = difflib.SequenceMatcher(None, comparison, current)
        content = show_diff(sm)
        content = content.replace('\n', '<br />')
        ret = {
            'wiki_id': wiki_page._primary_key,
            'wiki_name': wiki_page.page_name,
            'wiki_content': content,
            'versions': _get_wiki_versions(node, wiki_name, anonymous),
            'is_current': True,
            'is_edit': False,
            'version': wiki_page.version,
            'compare_version': wver,
            'pages_current': _get_wiki_pages_current(node),
            'toc': toc,
            'category': node.category,
            'urls': {
                'api': _get_wiki_api_urls(node, wiki_name),
                'web': _get_wiki_web_urls(node, wiki_name, wver),
            },
        }
        ret.update(_view_project(node, auth, primary=True))
        return ret
    raise HTTPError(http.NOT_FOUND)

 def test_view_project_embed_descendants(self):
     child = NodeFactory(parent=self.project, creator=self.user)
     res = _view_project(self.project, auth=Auth(self.project.creator), embed_descendants=True)
     assert_in('descendants', res['node'])
     assert_equal(len(res['node']['descendants']), 1)
     assert_equal(res['node']['descendants'][0]['id'], child._id)