Пример #1
0
def get_contributors(auth, node, **kwargs):

    # Can set limit to only receive a specified number of contributors in a call to this route
    if request.args.get('limit'):
        try:
            limit = int(request.args['limit'])
        except ValueError:
            raise HTTPError(http.BAD_REQUEST, data=dict(
                message_long='Invalid value for "limit": {}'.format(request.args['limit'])
            ))
    else:
        limit = None

    anonymous = has_anonymous_link(node, auth)

    if anonymous or not node.can_view(auth):
        raise HTTPError(http.FORBIDDEN)

    # Limit is either an int or None:
    # if int, contribs list is sliced to specified length
    # if None, contribs list is not sliced
    contribs = profile_utils.serialize_contributors(
        node.visible_contributors[0:limit],
        node=node,
    )

    # Will either return just contributor list or contributor list + 'more' element
    if limit:
        return {
            'contributors': contribs,
            'more': max(0, len(node.visible_contributors) - limit)
        }
    else:
        return {'contributors': contribs}
Пример #2
0
def _get_logs(node, count, auth, link=None, page=0):
    """

    :param Node node:
    :param int count:
    :param auth:
    :return list: List of serialized logs,
            boolean: if there are more logs

    """
    logs = []
    total = 0
    for log in reversed(node.logs):
        # A number of errors due to database inconsistency can arise here. The
        # log can be None; its `node__logged` back-ref can be empty, and the
        # 0th logged node can be None. Need to make sure that log is not None
        if log:
            log_node = log.resolve_node(node)
            if log.can_view(node, auth):
                total += 1
                anonymous = has_anonymous_link(log_node, auth)
                logs.append(serialize_log(log, anonymous))
        else:
            logger.warn('Log on node {} is None'.format(node._id))

    paginated_logs, pages = paginate(logs, total, page, count)

    return list(paginated_logs), total, pages
Пример #3
0
def _get_summary(node, auth, rescale_ratio, primary=True, link_id=None, show_path=False):
    # TODO(sloria): Refactor this or remove (lots of duplication with _view_project)
    summary = {
        'id': link_id if link_id else node._id,
        'primary': primary,
        'is_registration': node.is_registration,
        'is_fork': node.is_fork,
        'is_pending_registration': node.is_pending_registration,
        'is_retracted': node.is_retracted,
        'is_pending_retraction': node.is_pending_retraction,
        'embargo_end_date': node.embargo_end_date.strftime("%A, %b. %d, %Y") if node.embargo_end_date else False,
        'is_pending_embargo': node.is_pending_embargo,
        'archiving': node.archiving,
    }

    if node.can_view(auth):
        summary.update({
            'can_view': True,
            'can_edit': node.can_edit(auth),
            'primary_id': node._id,
            'url': node.url,
            'primary': primary,
            'api_url': node.api_url,
            'title': node.title,
            'category': node.category,
            'node_type': node.project_or_component,
            'is_fork': node.is_fork,
            'is_registration': node.is_registration,
            'anonymous': has_anonymous_link(node, auth),
            'registered_date': node.registered_date.strftime('%Y-%m-%d %H:%M UTC')
            if node.is_registration
            else None,
            'forked_date': node.forked_date.strftime('%Y-%m-%d %H:%M UTC')
            if node.is_fork
            else None,
            'nlogs': None,
            'ua_count': None,
            'ua': None,
            'non_ua': None,
            'addons_enabled': node.get_addon_names(),
            'is_public': node.is_public,
            'parent_title': node.parent_node.title if node.parent_node else None,
            'parent_is_public': node.parent_node.is_public if node.parent_node else False,
            'show_path': show_path
        })
        if rescale_ratio:
            ua_count, ua, non_ua = _get_user_activity(node, auth, rescale_ratio)
            summary.update({
                'nlogs': len(node.logs),
                'ua_count': ua_count,
                'ua': ua,
                'non_ua': non_ua,
            })
    else:
        summary['can_view'] = False

    # TODO: Make output format consistent with _view_project
    return {
        'summary': summary,
    }
Пример #4
0
def node_register_template_page(auth, node, metaschema_id, **kwargs):
    if node.is_registration and bool(node.registered_schema):
        try:
            meta_schema = RegistrationSchema.objects.get(_id=metaschema_id)
        except RegistrationSchema.DoesNotExist:
            # backwards compatability for old urls, lookup by name
            meta_schema = RegistrationSchema.objects.filter(name=_id_to_name(metaschema_id)).order_by('-schema_version').first()
            if not meta_schema:
                raise HTTPError(http.NOT_FOUND, data={
                    'message_short': 'Invalid schema name',
                    'message_long': 'No registration schema with that name could be found.'
                })
        if not node.registered_schema.filter(id=meta_schema.id).exists():
            raise HTTPError(http.BAD_REQUEST, data={
                'message_short': 'Invalid schema',
                'message_long': 'This registration has no registration supplment with that name.'
            })

        ret = _view_project(node, auth, primary=True)
        my_meta = serialize_meta_schema(meta_schema)
        if has_anonymous_link(node, auth):
            for indx, schema_page in enumerate(my_meta['schema']['pages']):
                for idx, schema_question in enumerate(schema_page['questions']):
                    if schema_question['title'] in settings.ANONYMIZED_TITLES:
                        del my_meta['schema']['pages'][indx]['questions'][idx]
        ret['node']['registered_schema'] = serialize_meta_schema(meta_schema)
        return ret
    else:
        status.push_status_message(
            'You have been redirected to the project\'s registrations page. From here you can initiate a new Draft Registration to complete the registration process',
            trust=False,
            id='redirected_to_registrations',
        )
        return redirect(node.web_url_for('node_registrations', view=kwargs.get('template'), _guid=True))
Пример #5
0
def comment_discussion(auth, node, **kwargs):

    users = collect_discussion(node)
    anonymous = has_anonymous_link(node, auth)
    # Sort users by comment frequency
    # TODO: Allow sorting by recency, combination of frequency and recency
    sorted_users = sorted(
        users.keys(),
        key=lambda item: len(users[item]),
        reverse=True,
    )

    return {
        'discussion': [
            {
                'id': privacy_info_handle(user._id, anonymous),
                'url': privacy_info_handle(user.url, anonymous),
                'fullname': privacy_info_handle(user.fullname, anonymous, name=True),
                'isContributor': node.is_contributor(user),
                'gravatarUrl': privacy_info_handle(
                    gravatar(
                        user, use_ssl=True, size=settings.GRAVATAR_SIZE_DISCUSSION,
                    ),
                    anonymous
                ),

            }
            for user in sorted_users
        ]
    }
Пример #6
0
def get_node_contributors_abbrev(auth, node, **kwargs):
    anonymous = has_anonymous_link(node, auth)
    formatter = "surname"
    max_count = kwargs.get("max_count", 3)
    if "user_ids" in kwargs:
        users = [User.load(user_id) for user_id in kwargs["user_ids"] if user_id in node.visible_contributor_ids]
    else:
        users = node.visible_contributors

    if anonymous or not node.can_view(auth):
        raise HTTPError(http.FORBIDDEN)

    contributors = []

    n_contributors = len(users)
    others_count = ""

    for index, user in enumerate(users[:max_count]):

        if index == max_count - 1 and len(users) > max_count:
            separator = " &"
            others_count = str(n_contributors - 3)
        elif index == len(users) - 1:
            separator = ""
        elif index == len(users) - 2:
            separator = " &"
        else:
            separator = ","
        contributor = user.get_summary(formatter)
        contributor["user_id"] = user._primary_key
        contributor["separator"] = separator

        contributors.append(contributor)

    return {"contributors": contributors, "others_count": others_count}
Пример #7
0
def _get_logs(node, count, auth, link=None, offset=0):
    """

    :param Node node:
    :param int count:
    :param auth:
    :return list: List of serialized logs,
            boolean: if there are more logs

    """
    logs = []
    has_more_logs = False
    for log in (x for idx, x in enumerate(reversed(node.logs)) if idx >= offset):
        # A number of errors due to database inconsistency can arise here. The
        # log can be None; its `node__logged` back-ref can be empty, and the
        # 0th logged node can be None. Catch and log these errors and ignore
        # the offending logs.
        log_node = log.resolve_node(node)
        if log.can_view(node, auth):
            anonymous = has_anonymous_link(log_node, auth)
            if len(logs) < count:
                logs.append(serialize_log(log, anonymous))
            else:
                has_more_logs = True
                break
    return logs, has_more_logs
Пример #8
0
def osf_storage_get_revisions(payload, node_addon, **kwargs):
    node = node_addon.owner
    page = payload.get('page') or 0
    path = payload.get('path')
    is_anon = has_anonymous_link(node, Auth(private_key=payload.get('view_only')))

    if not path:
        raise HTTPError(httplib.BAD_REQUEST)

    try:
        page = int(page)
    except (TypeError, ValueError):
        raise HTTPError(httplib.BAD_REQUEST)

    record = model.OsfStorageFileRecord.find_by_path(path, node_addon)

    if record is None:
        raise HTTPError(httplib.NOT_FOUND)

    indices, versions, more = record.get_versions(
        page,
        size=osf_storage_settings.REVISIONS_PAGE_SIZE,
    )

    return {
        'revisions': [
            utils.serialize_revision(node, record, versions[idx], indices[idx], anon=is_anon)
            for idx in range(len(versions))
        ],
        'more': more,
    }
Пример #9
0
def dataverse_get_file_info(node_addon, auth, **kwargs):
    """API view that gets info for a file."""
    node = node_addon.owner
    file_id = kwargs.get('path')

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

    anonymous = has_anonymous_link(node, auth)

    download_url = node.web_url_for('dataverse_download_file', path=file_id)
    dataverse_url = 'http://{0}/dvn/dv/'.format(HOST) + node_addon.dataverse_alias
    study_url = 'http://dx.doi.org/' + node_addon.study_hdl
    delete_url = node.api_url_for('dataverse_delete_file', path=file_id)

    data = {
        'node': {
            'id': node._id,
            'title': node.title
        },
        'filename': scrape_dataverse(file_id, name_only=True)[0],
        'dataverse': privacy_info_handle(node_addon.dataverse, anonymous),
        'study': privacy_info_handle(node_addon.study, anonymous),
        'urls': {
            'dataverse': privacy_info_handle(dataverse_url, anonymous),
            'study': privacy_info_handle(study_url, anonymous),
            'download': privacy_info_handle(download_url, anonymous),
            'delete': privacy_info_handle(delete_url, anonymous),
            'files': node.web_url_for('collect_file_trees'),
        }
    }

    return {'data': data}, httplib.OK
Пример #10
0
def serialize_node_summary(node, auth, primary=True, show_path=False):
    summary = {
        'id': node._id,
        'primary': primary,
        'is_registration': node.is_registration,
        'is_fork': node.is_fork,
        'is_pending_registration': node.is_pending_registration,
        'is_retracted': node.is_retracted,
        'is_pending_retraction': node.is_pending_retraction,
        'embargo_end_date': node.embargo_end_date.strftime('%A, %b. %d, %Y') if node.embargo_end_date else False,
        'is_pending_embargo': node.is_pending_embargo,
        'is_embargoed': node.is_embargoed,
        'archiving': node.archiving,
    }
    contributor_data = serialize_contributors_for_summary(node)

    parent_node = node.parent_node
    user = auth.user
    if node.can_view(auth):
        summary.update({
            'can_view': True,
            'can_edit': node.can_edit(auth),
            'primary_id': node._id,
            'url': node.url,
            'primary': primary,
            'api_url': node.api_url,
            'title': node.title,
            'category': node.category,
            'isPreprint': bool(node.preprint_file_id),
            'childExists': bool(node.nodes_active),
            'is_admin': node.has_permission(user, permissions.ADMIN),
            'is_contributor': node.is_contributor(user),
            'logged_in': auth.logged_in,
            'node_type': node.project_or_component,
            'is_fork': node.is_fork,
            'is_registration': node.is_registration,
            'anonymous': has_anonymous_link(node, auth),
            'registered_date': node.registered_date.strftime('%Y-%m-%d %H:%M UTC')
            if node.is_registration
            else None,
            'forked_date': node.forked_date.strftime('%Y-%m-%d %H:%M UTC')
            if node.is_fork
            else None,
            'ua_count': None,
            'ua': None,
            'non_ua': None,
            'is_public': node.is_public,
            'parent_title': parent_node.title if parent_node else None,
            'parent_is_public': parent_node.is_public if parent_node else False,
            'show_path': show_path,
            # Read nlogs annotation if possible
            'nlogs': node.nlogs if hasattr(node, 'nlogs') else node.logs.count(),
            'contributors': contributor_data['contributors'],
            'others_count': contributor_data['others_count'],
        })
    else:
        summary['can_view'] = False

    return summary
Пример #11
0
def osfstorage_get_revisions(file_node, node_addon, payload, **kwargs):
    is_anon = has_anonymous_link(node_addon.owner, Auth(private_key=request.args.get('view_only')))

    # Return revisions in descending order
    return {
        'revisions': [
            utils.serialize_revision(node_addon.owner, file_node, version, index=len(file_node.versions) - idx - 1, anon=is_anon)
            for idx, version in enumerate(reversed(file_node.versions))
        ]
    }
Пример #12
0
def file_info(auth, fid, **kwargs):
    versions = []
    node = kwargs['node'] or kwargs['project']
    file_name = fid
    file_name_clean = urlsafe_filename(file_name)
    files_page_url = node.web_url_for('collect_file_trees')
    latest_download_url = None
    api_url = None
    anonymous = has_anonymous_link(node, auth)

    try:
        files_versions = node.files_versions[file_name_clean]
    except KeyError:
        raise HTTPError(http.NOT_FOUND)
    latest_version_number = get_latest_version_number(file_name_clean, node) + 1

    for idx, version in enumerate(list(reversed(files_versions))):
        node_file = NodeFile.load(version)
        number = len(files_versions) - idx
        unique, total = get_basic_counters('download:{}:{}:{}'.format(
            node._primary_key,
            file_name_clean,
            number,
        ))
        download_url = node_file.download_url(node)
        api_url = node_file.api_url(node)
        versions.append({
            'file_name': file_name,
            'download_url': download_url,
            'version_number': number,
            'display_number': number if idx > 0 else 'current',
            'modified_date': node_file.date_uploaded.strftime('%Y/%m/%d %I:%M %p'),
            'downloads': total if total else 0,
            'committer_name': privacy_info_handle(
                node_file.uploader.fullname, anonymous, name=True
            ),
            'committer_url': privacy_info_handle(node_file.uploader.url, anonymous),
        })
        if number == latest_version_number:
            latest_download_url = download_url
    return {
        'node_title': node.title,
        'file_name': file_name,
        'versions': versions,
        'registered': node.is_registration,
        'urls': {
            'api': api_url,
            'files': files_page_url,
            'latest': {
                'download': latest_download_url,
            },
        }
    }
Пример #13
0
def _get_summary(node, auth, rescale_ratio, primary=True, link_id=None, show_path=False):
    # TODO(sloria): Refactor this or remove (lots of duplication with _view_project)
    summary = {
        "id": link_id if link_id else node._id,
        "primary": primary,
        "is_registration": node.is_registration,
        "is_fork": node.is_fork,
        "is_pending_registration": node.is_pending_registration,
        "is_retracted": node.is_retracted,
        "is_pending_retraction": node.is_pending_retraction,
        "embargo_end_date": node.embargo_end_date.strftime("%A, %b. %d, %Y") if node.embargo_end_date else False,
        "is_pending_embargo": node.is_pending_embargo,
        "archiving": node.archiving,
    }

    if node.can_view(auth):
        summary.update(
            {
                "can_view": True,
                "can_edit": node.can_edit(auth),
                "primary_id": node._id,
                "url": node.url,
                "primary": primary,
                "api_url": node.api_url,
                "title": node.title,
                "category": node.category,
                "node_type": node.project_or_component,
                "is_fork": node.is_fork,
                "is_registration": node.is_registration,
                "anonymous": has_anonymous_link(node, auth),
                "registered_date": node.registered_date.strftime("%Y-%m-%d %H:%M UTC")
                if node.is_registration
                else None,
                "forked_date": node.forked_date.strftime("%Y-%m-%d %H:%M UTC") if node.is_fork else None,
                "nlogs": None,
                "ua_count": None,
                "ua": None,
                "non_ua": None,
                "addons_enabled": node.get_addon_names(),
                "is_public": node.is_public,
                "parent_title": node.parent_node.title if node.parent_node else None,
                "parent_is_public": node.parent_node.is_public if node.parent_node else False,
                "show_path": show_path,
            }
        )
        if rescale_ratio:
            ua_count, ua, non_ua = _get_user_activity(node, auth, rescale_ratio)
            summary.update({"nlogs": len(node.logs), "ua_count": ua_count, "ua": ua, "non_ua": non_ua})
    else:
        summary["can_view"] = False

    # TODO: Make output format consistent with _view_project
    return {"summary": summary}
Пример #14
0
def list_comments(auth, node, **kwargs):
    anonymous = has_anonymous_link(node, auth)
    guid = request.args.get('target')
    target = resolve_target(node, guid)
    serialized_comments = serialize_comments(target, auth, anonymous)
    n_unread = 0

    if node.is_contributor(auth.user):
        if auth.user.comments_viewed_timestamp is None:
            auth.user.comments_viewed_timestamp = {}
            auth.user.save()
        n_unread = n_unread_comments(target, auth.user)
    return {
        'comments': serialized_comments,
        'nUnread': n_unread
    }
Пример #15
0
def osf_storage_get_revisions(payload, node_addon, **kwargs):
    node = node_addon.owner
    path = payload.get('path')
    is_anon = has_anonymous_link(node, Auth(private_key=payload.get('view_only')))

    if not path:
        raise HTTPError(httplib.BAD_REQUEST)

    record = model.OsfStorageFileNode.get(path.strip('/'), node_addon)

    # Return revisions in descending order
    return {
        'revisions': [
            utils.serialize_revision(node, record, version, index=len(record.versions) - idx - 1, anon=is_anon)
            for idx, version in enumerate(reversed(record.versions))
        ]
    }
Пример #16
0
def get_node_contributors_abbrev(auth, **kwargs):
    node = kwargs['node'] or kwargs['project']

    anonymous = has_anonymous_link(node, auth)

    max_count = kwargs.get('max_count', 3)
    if 'user_ids' in kwargs:
        users = [
            User.load(user_id) for user_id in kwargs['user_ids']
            if user_id in node.visible_contributor_ids
        ]
    else:
        users = node.visible_contributors

    if anonymous or not node.can_view(auth):
        raise HTTPError(http.FORBIDDEN)

    contributors = []

    n_contributors = len(users)
    others_count = ''

    for index, user in enumerate(users[:max_count]):

        if index == max_count - 1 and len(users) > max_count:
            separator = '&nbsp;&'
            others_count = str(n_contributors - 3)
        elif index == len(users) - 1:
            separator = ''
        elif index == len(users) - 2:
            separator = '&nbsp&'
        else:
            separator = ','

        contributors.append({
            'user_id': user._primary_key,
            'separator': separator,
        })

    return {
        'contributors': contributors,
        'others_count': others_count,
    }
Пример #17
0
def _get_logs(node, count, auth, link=None, page=0):
    """

    :param Node node:
    :param int count:
    :param auth:
    :return list: List of serialized logs,
            boolean: if there are more logs

    """
    logs_set = node.get_aggregate_logs_queryset(auth)
    total = len(logs_set)
    start = page * count
    stop = start + count
    logs = [
        serialize_log(log, auth=auth, anonymous=has_anonymous_link(node, auth))
        for log in logs_set[start:stop]
    ]
    pages = math.ceil(total / float(count))
    return logs, total, pages
Пример #18
0
def get_node_contributors_abbrev(auth, node, **kwargs):
    anonymous = has_anonymous_link(node, auth)
    formatter = 'surname'
    max_count = kwargs.get('max_count', 3)
    if 'user_ids' in kwargs:
        users = [
            User.load(user_id) for user_id in kwargs['user_ids']
            if user_id in node.visible_contributor_ids
        ]
    else:
        users = node.visible_contributors

    if anonymous or not node.can_view(auth):
        raise HTTPError(http.FORBIDDEN)

    contributors = []

    n_contributors = len(users)
    others_count = ''

    for index, user in enumerate(users[:max_count]):

        if index == max_count - 1 and len(users) > max_count:
            separator = ' &'
            others_count = str(n_contributors - 3)
        elif index == len(users) - 1:
            separator = ''
        elif index == len(users) - 2:
            separator = ' &'
        else:
            separator = ','
        contributor = user.get_summary(formatter)
        contributor['user_id'] = user._primary_key
        contributor['separator'] = separator

        contributors.append(contributor)

    return {
        'contributors': contributors,
        'others_count': others_count,
    }
Пример #19
0
def osfstorage_get_revisions(file_node, node_addon, payload, **kwargs):
    from osf.models import PageCounter, FileVersion  # TODO Fix me onces django works
    is_anon = has_anonymous_link(node_addon.owner, Auth(private_key=request.args.get('view_only')))

    counter_prefix = 'download:{}:{}:'.format(file_node.node._id, file_node._id)

    version_count = file_node.versions.count()
    # Don't worry. The only % at the end of the LIKE clause, the index is still used
    counts = dict(PageCounter.objects.filter(_id__startswith=counter_prefix).values_list('_id', 'total'))
    qs = FileVersion.includable_objects.filter(basefilenode__id=file_node.id).include('creator__guids').order_by('-created')

    for i, version in enumerate(qs):
        version._download_count = counts.get('{}{}'.format(counter_prefix, version_count - i - 1), 0)

    # Return revisions in descending order
    return {
        'revisions': [
            utils.serialize_revision(node_addon.owner, file_node, version, index=version_count - idx - 1, anon=is_anon)
            for idx, version in enumerate(qs)
        ]
    }
Пример #20
0
def node_register_template_page(auth, node, metaschema_id, **kwargs):
    if node.is_registration and bool(node.registered_schema):
        try:
            meta_schema = MetaSchema.find_one(
                Q('_id', 'eq', metaschema_id)
            )
        except NoResultsFound:
            # backwards compatability for old urls, lookup by name
            try:
                meta_schema = MetaSchema.find(
                    Q('name', 'eq', _id_to_name(metaschema_id))
                ).sort('-schema_version')[0]
            except IndexError:
                raise HTTPError(http.NOT_FOUND, data={
                    'message_short': 'Invalid schema name',
                    'message_long': 'No registration schema with that name could be found.'
                })
        if meta_schema not in node.registered_schema:
            raise HTTPError(http.BAD_REQUEST, data={
                'message_short': 'Invalid schema',
                'message_long': 'This registration has no registration supplment with that name.'
            })

        ret = _view_project(node, auth, primary=True)
        my_meta = serialize_meta_schema(meta_schema)
        if has_anonymous_link(node, auth):
            for indx, schema_page in enumerate(my_meta['schema']['pages']):
                for idx, schema_question in enumerate(schema_page['questions']):
                    if schema_question['title'] in settings.ANONYMIZED_TITLES:
                        del my_meta['schema']['pages'][indx]['questions'][idx]
        ret['node']['registered_schema'] = serialize_meta_schema(meta_schema)
        return ret
    else:
        status.push_status_message(
            'You have been redirected to the project\'s registrations page. From here you can initiate a new Draft Registration to complete the registration process',
            trust=False
        )
        return redirect(node.web_url_for('node_registrations', view=kwargs.get('template')))
Пример #21
0
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
Пример #22
0
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)
Пример #23
0
def _view_project(node, auth, primary=False):
    """Build a JSON object containing everything needed to render
    project.view.mako.
    """
    user = auth.user

    parent = node.parent_node
    if user:
        dashboard = find_dashboard(user)
        dashboard_id = dashboard._id
        in_dashboard = dashboard.pointing_at(node._primary_key) is not None
    else:
        in_dashboard = False
        dashboard_id = ""
    view_only_link = auth.private_key or request.args.get("view_only", "").strip("/")
    anonymous = has_anonymous_link(node, auth)
    widgets, configs, js, css = _render_addon(node)
    redirect_url = node.url + "?view_only=None"

    # Before page load callback; skip if not primary call
    if primary:
        for addon in node.get_addons():
            messages = addon.before_page_load(node, user) or []
            for message in messages:
                status.push_status_message(message, kind="info", dismissible=False, trust=True)
    data = {
        "node": {
            "id": node._primary_key,
            "title": node.title,
            "category": node.category_display,
            "category_short": node.category,
            "node_type": node.project_or_component,
            "description": node.description or "",
            "license": serialize_node_license_record(node.license),
            "url": node.url,
            "api_url": node.api_url,
            "absolute_url": node.absolute_url,
            "redirect_url": redirect_url,
            "display_absolute_url": node.display_absolute_url,
            "update_url": node.api_url_for("update_node"),
            "in_dashboard": in_dashboard,
            "is_public": node.is_public,
            "is_archiving": node.archiving,
            "date_created": iso8601format(node.date_created),
            "date_modified": iso8601format(node.logs[-1].date) if node.logs else "",
            "tags": [tag._primary_key for tag in node.tags],
            "children": bool(node.nodes_active),
            "is_registration": node.is_registration,
            "is_pending_registration": node.is_pending_registration,
            "is_retracted": node.is_retracted,
            "is_pending_retraction": node.is_pending_retraction,
            "retracted_justification": getattr(node.retraction, "justification", None),
            "embargo_end_date": node.embargo_end_date.strftime("%A, %b. %d, %Y") if node.embargo_end_date else False,
            "is_pending_embargo": node.is_pending_embargo,
            "registered_from_url": node.registered_from.url if node.is_registration else "",
            "registered_date": iso8601format(node.registered_date) if node.is_registration else "",
            "root_id": node.root._id,
            "registered_meta": node.registered_meta,
            "registered_schemas": serialize_meta_schemas(node.registered_schema),
            "registration_count": len(node.node__registrations),
            "is_fork": node.is_fork,
            "forked_from_id": node.forked_from._primary_key if node.is_fork else "",
            "forked_from_display_absolute_url": node.forked_from.display_absolute_url if node.is_fork else "",
            "forked_date": iso8601format(node.forked_date) if node.is_fork else "",
            "fork_count": len(node.forks),
            "templated_count": len(node.templated_list),
            "watched_count": len(node.watchconfig__watched),
            "private_links": [x.to_json() for x in node.private_links_active],
            "link": view_only_link,
            "anonymous": anonymous,
            "points": len(node.get_points(deleted=False, folders=False)),
            "piwik_site_id": node.piwik_site_id,
            "comment_level": node.comment_level,
            "has_comments": bool(getattr(node, "commented", [])),
            "has_children": bool(getattr(node, "commented", False)),
            "identifiers": {"doi": node.get_identifier_value("doi"), "ark": node.get_identifier_value("ark")},
            "has_draft_registrations": bool(node.draft_registrations_active),
        },
        "parent_node": {
            "exists": parent is not None,
            "id": parent._primary_key if parent else "",
            "title": parent.title if parent else "",
            "category": parent.category_display if parent else "",
            "url": parent.url if parent else "",
            "api_url": parent.api_url if parent else "",
            "absolute_url": parent.absolute_url if parent else "",
            "registrations_url": parent.web_url_for("node_registrations") if parent else "",
            "is_public": parent.is_public if parent else "",
            "is_contributor": parent.is_contributor(user) if parent else "",
            "can_view": parent.can_view(auth) if parent else False,
        },
        "user": {
            "is_contributor": node.is_contributor(user),
            "is_admin": node.has_permission(user, ADMIN),
            "is_admin_parent": parent.is_admin_parent(user) if parent else False,
            "can_edit": (node.can_edit(auth) and not node.is_registration),
            "has_read_permissions": node.has_permission(user, READ),
            "permissions": node.get_permissions(user) if user else [],
            "is_watching": user.is_watching(node) if user else False,
            "piwik_token": user.piwik_token if user else "",
            "id": user._id if user else None,
            "username": user.username if user else None,
            "fullname": user.fullname if user else "",
            "can_comment": node.can_comment(auth),
            "show_wiki_widget": _should_show_wiki_widget(node, user),
            "dashboard_id": dashboard_id,
        },
        "badges": _get_badge(user),
        # TODO: Namespace with nested dicts
        "addons_enabled": node.get_addon_names(),
        "addons": configs,
        "addon_widgets": widgets,
        "addon_widget_js": js,
        "addon_widget_css": css,
        "node_categories": Node.CATEGORY_MAP,
    }
    return data
Пример #24
0
def _view_project(node, auth, primary=False):
    """Build a JSON object containing everything needed to render
    project.view.mako.
    """
    user = auth.user

    parent = node.parent_node
    if user:
        dashboard = find_dashboard(user)
        dashboard_id = dashboard._id
        in_dashboard = dashboard.pointing_at(node._primary_key) is not None
    else:
        in_dashboard = False
        dashboard_id = ''
    view_only_link = auth.private_key or request.args.get('view_only',
                                                          '').strip('/')
    anonymous = has_anonymous_link(node, auth)
    widgets, configs, js, css = _render_addon(node)
    redirect_url = node.url + '?view_only=None'

    # Before page load callback; skip if not primary call
    if primary:
        for addon in node.get_addons():
            messages = addon.before_page_load(node, user) or []
            for message in messages:
                status.push_status_message(message,
                                           kind='info',
                                           dismissible=False,
                                           trust=True)
    data = {
        'node': {
            'id':
            node._primary_key,
            'title':
            node.title,
            'category':
            node.category_display,
            'category_short':
            node.category,
            'node_type':
            node.project_or_component,
            'description':
            node.description or '',
            'url':
            node.url,
            'api_url':
            node.api_url,
            'absolute_url':
            node.absolute_url,
            'redirect_url':
            redirect_url,
            'display_absolute_url':
            node.display_absolute_url,
            'update_url':
            node.api_url_for('update_node'),
            'in_dashboard':
            in_dashboard,
            'is_public':
            node.is_public,
            'is_archiving':
            node.archiving,
            'date_created':
            iso8601format(node.date_created),
            'date_modified':
            iso8601format(node.logs[-1].date) if node.logs else '',
            'tags': [tag._primary_key for tag in node.tags],
            'children':
            bool(node.nodes),
            'is_registration':
            node.is_registration,
            'is_retracted':
            node.is_retracted,
            'pending_retraction':
            node.pending_retraction,
            'retracted_justification':
            getattr(node.retraction, 'justification', None),
            'embargo_end_date':
            node.embargo_end_date.strftime("%A, %b. %d, %Y")
            if node.embargo_end_date else False,
            'pending_embargo':
            node.pending_embargo,
            'registered_from_url':
            node.registered_from.url if node.is_registration else '',
            'registered_date':
            iso8601format(node.registered_date)
            if node.is_registration else '',
            'root_id':
            node.root._id,
            'registered_meta': [{
                'name_no_ext': from_mongo(meta),
                'name_clean': clean_template_name(meta),
            } for meta in node.registered_meta or []],
            'registration_count':
            len(node.node__registrations),
            'is_fork':
            node.is_fork,
            'forked_from_id':
            node.forked_from._primary_key if node.is_fork else '',
            'forked_from_display_absolute_url':
            node.forked_from.display_absolute_url if node.is_fork else '',
            'forked_date':
            iso8601format(node.forked_date) if node.is_fork else '',
            'fork_count':
            len(node.forks),
            'templated_count':
            len(node.templated_list),
            'watched_count':
            len(node.watchconfig__watched),
            'private_links': [x.to_json() for x in node.private_links_active],
            'link':
            view_only_link,
            'anonymous':
            anonymous,
            'points':
            len(node.get_points(deleted=False, folders=False)),
            'piwik_site_id':
            node.piwik_site_id,
            'comment_level':
            node.comment_level,
            'has_comments':
            bool(getattr(node, 'commented', [])),
            'has_children':
            bool(getattr(node, 'commented', False)),
            'identifiers': {
                'doi': node.get_identifier_value('doi'),
                'ark': node.get_identifier_value('ark'),
            },
        },
        'parent_node': {
            'exists':
            parent is not None,
            'id':
            parent._primary_key if parent else '',
            'title':
            parent.title if parent else '',
            'category':
            parent.category_display if parent else '',
            'url':
            parent.url if parent else '',
            'api_url':
            parent.api_url if parent else '',
            'absolute_url':
            parent.absolute_url if parent else '',
            'registrations_url':
            parent.web_url_for('node_registrations') if parent else '',
            'is_public':
            parent.is_public if parent else '',
            'is_contributor':
            parent.is_contributor(user) if parent else '',
            'can_view':
            parent.can_view(auth) if parent else False
        },
        'user': {
            'is_contributor': node.is_contributor(user),
            'is_admin_parent':
            parent.is_admin_parent(user) if parent else False,
            'can_edit': (node.can_edit(auth) and not node.is_registration),
            'has_read_permissions': node.has_permission(user, 'read'),
            'permissions': node.get_permissions(user) if user else [],
            'is_watching': user.is_watching(node) if user else False,
            'piwik_token': user.piwik_token if user else '',
            'id': user._id if user else None,
            'username': user.username if user else None,
            'fullname': user.fullname if user else '',
            'can_comment': node.can_comment(auth),
            'show_wiki_widget': _should_show_wiki_widget(node, user),
            'dashboard_id': dashboard_id,
        },
        'badges': _get_badge(user),
        # TODO: Namespace with nested dicts
        'addons_enabled': node.get_addon_names(),
        'addons': configs,
        'addon_widgets': widgets,
        'addon_widget_js': js,
        'addon_widget_css': css,
        'node_categories': Node.CATEGORY_MAP,
    }
    return data
Пример #25
0
def _view_project(node, auth, primary=False):
    """Build a JSON object containing everything needed to render
    project.view.mako.
    """
    user = auth.user

    parent = node.parent_node
    view_only_link = auth.private_key or request.args.get('view_only', '').strip('/')
    anonymous = has_anonymous_link(node, auth)
    widgets, configs, js, css = _render_addon(node)
    redirect_url = node.url + '?view_only=None'

    # Before page load callback; skip if not primary call
    if primary:
        for addon in node.get_addons():
            messages = addon.before_page_load(node, user) or []
            for message in messages:
                status.push_status_message(message, dismissible=False)
    data = {
        'node': {
            'id': node._primary_key,
            'title': node.title,
            'category': node.category_display,
            'node_type': node.project_or_component,
            'description': node.description or '',
            'url': node.url,
            'api_url': node.api_url,
            'absolute_url': node.absolute_url,
            'redirect_url': redirect_url,
            'display_absolute_url': node.display_absolute_url,
            'citations': {
                'apa': node.citation_apa,
                'mla': node.citation_mla,
                'chicago': node.citation_chicago,
            } if not anonymous else '',
            'is_public': node.is_public,
            'date_created': iso8601format(node.date_created),
            'date_modified': iso8601format(node.logs[-1].date) if node.logs else '',

            'tags': [tag._primary_key for tag in node.tags],
            'children': bool(node.nodes),
            'is_registration': node.is_registration,
            'registered_from_url': node.registered_from.url if node.is_registration else '',
            'registered_date': iso8601format(node.registered_date) if node.is_registration else '',
            'registered_meta': [
                {
                    'name_no_ext': from_mongo(meta),
                    'name_clean': clean_template_name(meta),
                }
                for meta in node.registered_meta or []
            ],
            'registration_count': len(node.node__registrations),

            'is_fork': node.is_fork,
            'forked_from_id': node.forked_from._primary_key if node.is_fork else '',
            'forked_from_display_absolute_url': node.forked_from.display_absolute_url if node.is_fork else '',
            'forked_date': iso8601format(node.forked_date) if node.is_fork else '',
            'fork_count': len(node.node__forked.find(Q('is_deleted', 'eq', False))),
            'templated_count': len(node.templated_list),
            'watched_count': len(node.watchconfig__watched),
            'private_links': [x.to_json() for x in node.private_links_active],
            'link': view_only_link,
            'anonymous': anonymous,
            'points': len(node.get_points(deleted=False, folders=False)),
            'piwik_site_id': node.piwik_site_id,

            'comment_level': node.comment_level,
            'has_comments': bool(getattr(node, 'commented', [])),
            'has_children': bool(getattr(node, 'commented', False)),

        },
        'parent_node': {
            'id': parent._primary_key if parent else '',
            'title': parent.title if parent else '',
            'url': parent.url if parent else '',
            'api_url': parent.api_url if parent else '',
            'absolute_url': parent.absolute_url if parent else '',
            'is_public': parent.is_public if parent else '',
            'is_contributor': parent.is_contributor(user) if parent else '',
            'can_view': (auth.private_key in parent.private_link_keys_active) if parent else False
        },
        'user': {
            'is_contributor': node.is_contributor(user),
            'can_edit': (node.can_edit(auth)
                         and not node.is_registration),
            'permissions': node.get_permissions(user) if user else [],
            'is_watching': user.is_watching(node) if user else False,
            'piwik_token': user.piwik_token if user else '',
            'id': user._id if user else None,
            'username': user.username if user else None,
            'fullname': user.fullname if user else '',
            'can_comment': node.can_comment(auth),
            'show_wiki_widget': _should_show_wiki_widget(node, user),
        },
        'badges': _get_badge(user),
        # TODO: Namespace with nested dicts
        'addons_enabled': node.get_addon_names(),
        'addons': configs,
        'addon_widgets': widgets,
        'addon_widget_js': js,
        'addon_widget_css': css,

    }
    return data
Пример #26
0
def _view_project(node, auth, primary=False):
    """Build a JSON object containing everything needed to render
    project.view.mako.
    """
    user = auth.user

    parent = node.find_readable_antecedent(auth)
    if user:
        bookmark_collection = find_bookmark_collection(user)
        bookmark_collection_id = bookmark_collection._id
        in_bookmark_collection = bookmark_collection.pointing_at(node._primary_key) is not None
    else:
        in_bookmark_collection = False
        bookmark_collection_id = ''
    view_only_link = auth.private_key or request.args.get('view_only', '').strip('/')
    anonymous = has_anonymous_link(node, auth)
    widgets, configs, js, css = _render_addon(node)
    redirect_url = node.url + '?view_only=None'

    disapproval_link = ''
    if (node.is_pending_registration and node.has_permission(user, ADMIN)):
        disapproval_link = node.root.registration_approval.stashed_urls.get(user._id, {}).get('reject', '')

    if (node.is_pending_embargo and node.has_permission(user, ADMIN)):
        disapproval_link = node.root.embargo.stashed_urls.get(user._id, {}).get('reject', '')

    # Before page load callback; skip if not primary call
    if primary:
        for addon in node.get_addons():
            messages = addon.before_page_load(node, user) or []
            for message in messages:
                status.push_status_message(message, kind='info', dismissible=False, trust=True)
    data = {
        'node': {
            'disapproval_link': disapproval_link,
            'id': node._primary_key,
            'title': node.title,
            'category': node.category_display,
            'category_short': node.category,
            'node_type': node.project_or_component,
            'description': node.description or '',
            'license': serialize_node_license_record(node.license),
            'url': node.url,
            'api_url': node.api_url,
            'absolute_url': node.absolute_url,
            'redirect_url': redirect_url,
            'display_absolute_url': node.display_absolute_url,
            'update_url': node.api_url_for('update_node'),
            'in_dashboard': in_bookmark_collection,
            'is_public': node.is_public,
            'is_archiving': node.archiving,
            'date_created': iso8601format(node.date_created),
            'date_modified': iso8601format(node.logs[-1].date) if node.logs else '',
            'tags': [tag._primary_key for tag in node.tags],
            'children': bool(node.nodes_active),
            'is_registration': node.is_registration,
            'is_pending_registration': node.is_pending_registration,
            'is_retracted': node.is_retracted,
            'is_pending_retraction': node.is_pending_retraction,
            'retracted_justification': getattr(node.retraction, 'justification', None),
            'embargo_end_date': node.embargo_end_date.strftime('%A, %b. %d, %Y') if node.embargo_end_date else False,
            'is_pending_embargo': node.is_pending_embargo,
            'is_embargoed': node.is_embargoed,
            'is_pending_embargo_termination': node.is_embargoed and (
                node.embargo_termination_approval and
                node.embargo_termination_approval.is_pending_approval
            ),
            'registered_from_url': node.registered_from.url if node.is_registration else '',
            'registered_date': iso8601format(node.registered_date) if node.is_registration else '',
            'root_id': node.root._id if node.root else None,
            'registered_meta': node.registered_meta,
            'registered_schemas': serialize_meta_schemas(node.registered_schema),
            'registration_count': node.registrations_all.count(),
            'is_fork': node.is_fork,
            'forked_from_id': node.forked_from._primary_key if node.is_fork else '',
            'forked_from_display_absolute_url': node.forked_from.display_absolute_url if node.is_fork else '',
            'forked_date': iso8601format(node.forked_date) if node.is_fork else '',
            'fork_count': node.forks.count(),
            'templated_count': node.templated_list.count(),
            'watched_count': node.watches.count(),
            'private_links': [x.to_json() for x in node.private_links_active],
            'link': view_only_link,
            'anonymous': anonymous,
            'points': len(node.get_points(deleted=False, folders=False)),
            'comment_level': node.comment_level,
            'has_comments': bool(Comment.find(Q('node', 'eq', node))),
            'has_children': bool(Comment.find(Q('node', 'eq', node))),
            'identifiers': {
                'doi': node.get_identifier_value('doi'),
                'ark': node.get_identifier_value('ark'),
            },
            'institutions': get_affiliated_institutions(node) if node else [],
            'alternative_citations': [citation.to_json() for citation in node.alternative_citations],
            'has_draft_registrations': node.has_active_draft_registrations,
            'contributors': [contributor._id for contributor in node.contributors],
            'is_preprint': node.is_preprint,
            'is_preprint_orphan': node.is_preprint_orphan,
            'preprint_file_id': node.preprint_file._id if node.preprint_file else None
        },
        'parent_node': {
            'exists': parent is not None,
            'id': parent._primary_key if parent else '',
            'title': parent.title if parent else '',
            'category': parent.category_display if parent else '',
            'url': parent.url if parent else '',
            'api_url': parent.api_url if parent else '',
            'absolute_url': parent.absolute_url if parent else '',
            'registrations_url': parent.web_url_for('node_registrations') if parent else '',
            'is_public': parent.is_public if parent else '',
            'is_contributor': parent.is_contributor(user) if parent else '',
            'can_view': parent.can_view(auth) if parent else False
        },
        'user': {
            'is_contributor': node.is_contributor(user),
            'is_admin': node.has_permission(user, ADMIN),
            'is_admin_parent': parent.is_admin_parent(user) if parent else False,
            'can_edit': (node.can_edit(auth)
                         and not node.is_registration),
            'has_read_permissions': node.has_permission(user, READ),
            'permissions': node.get_permissions(user) if user else [],
            'is_watching': user.is_watching(node) if user else False,
            'id': user._id if user else None,
            'username': user.username if user else None,
            'fullname': user.fullname if user else '',
            'can_comment': node.can_comment(auth),
            'show_wiki_widget': _should_show_wiki_widget(node, user),
            'dashboard_id': bookmark_collection_id,
            'institutions': get_affiliated_institutions(user) if user else [],
        },
        'badges': _get_badge(user),
        # TODO: Namespace with nested dicts
        'addons_enabled': node.get_addon_names(),
        'addons': configs,
        'addon_widgets': widgets,
        'addon_widget_js': js,
        'addon_widget_css': css,
        'node_categories': [
            {'value': key, 'display_name': value}
            for key, value in settings.NODE_CATEGORY_MAP.iteritems()
        ]
    }
    return data
Пример #27
0
def _get_summary(node,
                 auth,
                 rescale_ratio,
                 primary=True,
                 link_id=None,
                 show_path=False):
    # TODO(sloria): Refactor this or remove (lots of duplication with _view_project)
    summary = {
        'id':
        link_id if link_id else node._id,
        'primary':
        primary,
        'is_registration':
        node.is_registration,
        'is_fork':
        node.is_fork,
        'is_retracted':
        node.is_retracted,
        'pending_retraction':
        node.pending_retraction,
        'embargo_end_date':
        node.embargo_end_date.strftime("%A, %b. %d, %Y")
        if node.embargo_end_date else False,
        'pending_embargo':
        node.pending_embargo,
        'archiving':
        node.archiving,
    }

    if node.can_view(auth):
        summary.update({
            'can_view':
            True,
            'can_edit':
            node.can_edit(auth),
            'primary_id':
            node._id,
            'url':
            node.url,
            'primary':
            primary,
            'api_url':
            node.api_url,
            'title':
            node.title,
            'category':
            node.category,
            'node_type':
            node.project_or_component,
            'is_fork':
            node.is_fork,
            'is_registration':
            node.is_registration,
            'anonymous':
            has_anonymous_link(node, auth),
            'registered_date':
            node.registered_date.strftime('%Y-%m-%d %H:%M UTC')
            if node.is_registration else None,
            'forked_date':
            node.forked_date.strftime('%Y-%m-%d %H:%M UTC')
            if node.is_fork else None,
            'nlogs':
            None,
            'ua_count':
            None,
            'ua':
            None,
            'non_ua':
            None,
            'addons_enabled':
            node.get_addon_names(),
            'is_public':
            node.is_public,
            'parent_title':
            node.parent_node.title if node.parent_node else None,
            'parent_is_public':
            node.parent_node.is_public if node.parent_node else False,
            'show_path':
            show_path
        })
        if rescale_ratio:
            ua_count, ua, non_ua = _get_user_activity(node, auth,
                                                      rescale_ratio)
            summary.update({
                'nlogs': len(node.logs),
                'ua_count': ua_count,
                'ua': ua,
                'non_ua': non_ua,
            })
    else:
        summary['can_view'] = False

    # TODO: Make output format consistent with _view_project
    return {
        'summary': summary,
    }
Пример #28
0
def serialize_node_summary(node, auth, primary=True, show_path=False):
    is_registration = node.is_registration
    summary = {
        'id': node._id,
        'primary': primary,
        'is_registration': node.is_registration,
        'is_fork': node.is_fork,
        'is_pending_registration': node.is_pending_registration if is_registration else False,
        'is_retracted': node.is_retracted if is_registration else False,
        'is_pending_retraction': node.is_pending_retraction if is_registration else False,
        'embargo_end_date': node.embargo_end_date.strftime('%A, %b. %d, %Y') if is_registration and node.embargo_end_date else False,
        'is_pending_embargo': node.is_pending_embargo if is_registration else False,
        'is_embargoed': node.is_embargoed if is_registration else False,
        'archiving': node.archiving if is_registration else False,
    }

    parent_node = node.parent_node
    user = auth.user
    if node.can_view(auth):
        # Re-query node with contributor guids included to prevent N contributor queries
        node = AbstractNode.objects.filter(pk=node.pk).include('contributor__user__guids').get()
        contributor_data = serialize_contributors_for_summary(node)
        summary.update({
            'can_view': True,
            'can_edit': node.can_edit(auth),
            'primary_id': node._id,
            'url': node.url,
            'primary': primary,
            'api_url': node.api_url,
            'title': node.title,
            'category': node.category,
            'isPreprint': bool(node.preprint_file_id),
            'childExists': Node.objects.get_children(node, active=True).exists(),
            'is_admin': node.has_permission(user, permissions.ADMIN),
            'is_contributor': node.is_contributor(user),
            'logged_in': auth.logged_in,
            'node_type': node.project_or_component,
            'is_fork': node.is_fork,
            'is_registration': is_registration,
            'anonymous': has_anonymous_link(node, auth),
            'registered_date': node.registered_date.strftime('%Y-%m-%d %H:%M UTC')
            if node.is_registration
            else None,
            'forked_date': node.forked_date.strftime('%Y-%m-%d %H:%M UTC')
            if node.is_fork
            else None,
            'ua_count': None,
            'ua': None,
            'non_ua': None,
            'is_public': node.is_public,
            'parent_title': parent_node.title if parent_node else None,
            'parent_is_public': parent_node.is_public if parent_node else False,
            'show_path': show_path,
            'contributors': contributor_data['contributors'],
            'others_count': contributor_data['others_count'],
            'description': node.description if len(node.description) <= 150 else node.description[0:150] + '...',
        })
    else:
        summary['can_view'] = False

    return summary
Пример #29
0
def project_wiki_view(auth, wname, path=None, **kwargs):
    node = kwargs['node'] or kwargs['project']
    anonymous = has_anonymous_link(node, auth)
    wiki_name = (wname or '').strip()
    wiki_key = to_mongo_key(wiki_name)
    wiki_page = WikiPage.objects.get_for_node(node, wiki_name)
    wiki_version = WikiVersion.objects.get_for_node(node, wiki_name)
    wiki_settings = node.get_addon('wiki')
    can_edit = (auth.logged_in and not node.is_registration
                and (node.has_permission(auth.user, WRITE)
                     or wiki_settings.is_publicly_editable))
    versions = _get_wiki_versions(node, wiki_name, anonymous=anonymous)

    # Determine panels used in view
    panels = {'view', 'edit', 'compare', 'menu'}
    if request.args and set(request.args).intersection(panels):
        panels_used = [panel for panel in request.args if panel in panels]
        num_columns = len(
            set(panels_used).intersection({'view', 'edit', 'compare'}))
        if num_columns == 0:
            panels_used.append('view')
            num_columns = 1
    else:
        panels_used = ['view', 'menu']
        num_columns = 1

    try:
        view = wiki_utils.format_wiki_version(
            version=request.args.get('view'),
            num_versions=len(versions),
            allow_preview=True,
        )
        compare = wiki_utils.format_wiki_version(
            version=request.args.get('compare'),
            num_versions=len(versions),
            allow_preview=False,
        )
    except InvalidVersionError:
        raise WIKI_INVALID_VERSION_ERROR

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

    if wiki_version:
        version = wiki_version.identifier
        is_current = wiki_version.is_current
        content = wiki_version.html(node)
        rendered_before_update = wiki_version.rendered_before_update
    else:
        version = 'NA'
        is_current = False
        content = ''
        rendered_before_update = False

    if can_edit:
        if wiki_key not in node.wiki_private_uuids:
            wiki_utils.generate_private_uuid(node, wiki_name)
        sharejs_uuid = wiki_utils.get_sharejs_uuid(node, wiki_name)
    else:
        if not wiki_page and wiki_key != 'home':
            raise WIKI_PAGE_NOT_FOUND_ERROR
        if 'edit' in request.args:
            if wiki_settings.is_publicly_editable:
                raise HTTPError(http_status.HTTP_401_UNAUTHORIZED)
            if node.can_view(auth):
                return redirect(
                    node.web_url_for('project_wiki_view',
                                     wname=wname,
                                     _guid=True))
            raise HTTPError(http_status.HTTP_403_FORBIDDEN)
        sharejs_uuid = None

    # Opens 'edit' panel when home wiki is empty
    if not content and can_edit and wiki_name == 'home':
        panels_used.append('edit')

    # Default versions for view and compare
    version_settings = {
        'view': view or ('preview' if 'edit' in panels_used else 'current'),
        'compare': compare or 'previous',
    }

    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,
        'rendered_before_update': rendered_before_update,
        'page': wiki_page,
        'version': version,
        'versions': versions,
        'sharejs_uuid': sharejs_uuid or '',
        'sharejs_url': settings.SHAREJS_URL,
        'is_current': is_current,
        'version_settings': version_settings,
        'pages_current': _get_wiki_pages_latest(node),
        'category': node.category,
        'panels_used': panels_used,
        'num_columns': num_columns,
        'urls': {
            'api':
            _get_wiki_api_urls(
                node, wiki_name, {
                    'content':
                    node.api_url_for('wiki_page_content', wname=wiki_name),
                    'draft':
                    node.api_url_for('wiki_page_draft', wname=wiki_name),
                }),
            'web':
            _get_wiki_web_urls(node, wiki_name),
            'profile_image':
            get_profile_image_url(auth.user, 25),
        },
    }
    ret.update(_view_project(node, auth, primary=True))
    ret['user']['can_edit_wiki_body'] = can_edit
    return ret
Пример #30
0
def project_wiki_view(auth, wname, path=None, **kwargs):
    node = kwargs["node"] or kwargs["project"]
    anonymous = has_anonymous_link(node, auth)
    wiki_name = (wname or "").strip()
    wiki_key = to_mongo_key(wiki_name)
    wiki_page = node.get_wiki_page(wiki_name)
    wiki_settings = node.get_addon("wiki")
    can_edit = (
        auth.logged_in
        and not node.is_registration
        and (node.has_permission(auth.user, "write") or wiki_settings.is_publicly_editable)
    )
    versions = _get_wiki_versions(node, wiki_name, anonymous=anonymous)

    # Determine panels used in view
    panels = {"view", "edit", "compare", "menu"}
    if request.args and set(request.args).intersection(panels):
        panels_used = [panel for panel in request.args if panel in panels]
        num_columns = len(set(panels_used).intersection({"view", "edit", "compare"}))
        if num_columns == 0:
            panels_used.append("view")
            num_columns = 1
    else:
        panels_used = ["view", "menu"]
        num_columns = 1

    try:
        view = wiki_utils.format_wiki_version(
            version=request.args.get("view"), num_versions=len(versions), allow_preview=True
        )
        compare = wiki_utils.format_wiki_version(
            version=request.args.get("compare"), num_versions=len(versions), allow_preview=False
        )
    except InvalidVersionError:
        raise WIKI_INVALID_VERSION_ERROR

    # Default versions for view and compare
    version_settings = {
        "view": view or ("preview" if "edit" in panels_used else "current"),
        "compare": compare or "previous",
    }

    # 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.html(node)
        use_python_render = wiki_page.rendered_before_update
    else:
        version = "NA"
        is_current = False
        content = ""
        use_python_render = False

    if can_edit:
        if wiki_key not in node.wiki_private_uuids:
            wiki_utils.generate_private_uuid(node, wiki_name)
        sharejs_uuid = wiki_utils.get_sharejs_uuid(node, wiki_name)
    else:
        if wiki_key not in node.wiki_pages_current and wiki_key != "home":
            raise WIKI_PAGE_NOT_FOUND_ERROR
        if "edit" in request.args:
            if wiki_settings.is_publicly_editable:
                raise HTTPError(http.UNAUTHORIZED)
            raise HTTPError(http.FORBIDDEN)
        sharejs_uuid = None

    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,
        "use_python_render": use_python_render,
        "page": wiki_page,
        "version": version,
        "versions": versions,
        "sharejs_uuid": sharejs_uuid or "",
        "sharejs_url": settings.SHAREJS_URL,
        "is_current": is_current,
        "version_settings": version_settings,
        "pages_current": _get_wiki_pages_current(node),
        "category": node.category,
        "panels_used": panels_used,
        "num_columns": num_columns,
        "urls": {
            "api": _get_wiki_api_urls(
                node,
                wiki_name,
                {
                    "content": node.api_url_for("wiki_page_content", wname=wiki_name),
                    "draft": node.api_url_for("wiki_page_draft", wname=wiki_name),
                },
            ),
            "web": _get_wiki_web_urls(node, wiki_name),
            "gravatar": get_gravatar(auth.user, 25),
        },
    }
    ret.update(_view_project(node, auth, primary=True))
    ret["user"]["can_edit_wiki_body"] = can_edit
    return ret
Пример #31
0
def _view_project(node, auth, primary=False,
                  embed_contributors=False, embed_descendants=False,
                  embed_registrations=False, embed_forks=False):
    """Build a JSON object containing everything needed to render
    project.view.mako.
    """
    node = Node.objects.filter(pk=node.pk).include('contributor__user__guids').get()
    user = auth.user

    parent = node.find_readable_antecedent(auth)
    if user:
        bookmark_collection = find_bookmark_collection(user)
        bookmark_collection_id = bookmark_collection._id
        in_bookmark_collection = bookmark_collection.linked_nodes.filter(pk=node.pk).exists()
    else:
        in_bookmark_collection = False
        bookmark_collection_id = ''
    view_only_link = auth.private_key or request.args.get('view_only', '').strip('/')
    anonymous = has_anonymous_link(node, auth)
    widgets, configs, js, css = _render_addon(node)
    redirect_url = node.url + '?view_only=None'

    disapproval_link = ''
    if (node.is_pending_registration and node.has_permission(user, ADMIN)):
        disapproval_link = node.root.registration_approval.stashed_urls.get(user._id, {}).get('reject', '')

    if (node.is_pending_embargo and node.has_permission(user, ADMIN)):
        disapproval_link = node.root.embargo.stashed_urls.get(user._id, {}).get('reject', '')

    # Before page load callback; skip if not primary call
    if primary:
        for addon in node.get_addons():
            messages = addon.before_page_load(node, user) or []
            for message in messages:
                status.push_status_message(message, kind='info', dismissible=False, trust=True)
    data = {
        'node': {
            'disapproval_link': disapproval_link,
            'id': node._primary_key,
            'title': node.title,
            'category': node.category_display,
            'category_short': node.category,
            'node_type': node.project_or_component,
            'description': node.description or '',
            'license': serialize_node_license_record(node.license),
            'url': node.url,
            'api_url': node.api_url,
            'absolute_url': node.absolute_url,
            'redirect_url': redirect_url,
            'display_absolute_url': node.display_absolute_url,
            'update_url': node.api_url_for('update_node'),
            'in_dashboard': in_bookmark_collection,
            'is_public': node.is_public,
            'is_archiving': node.archiving,
            'date_created': iso8601format(node.date_created),
            'date_modified': iso8601format(node.logs.latest().date) if node.logs.exists() else '',
            'tags': list(node.tags.filter(system=False).values_list('name', flat=True)),
            'children': bool(node.nodes_active),
            'is_registration': node.is_registration,
            'is_pending_registration': node.is_pending_registration,
            'is_retracted': node.is_retracted,
            'is_pending_retraction': node.is_pending_retraction,
            'retracted_justification': getattr(node.retraction, 'justification', None),
            'date_retracted': iso8601format(getattr(node.retraction, 'date_retracted', None)),
            'embargo_end_date': node.embargo_end_date.strftime('%A, %b. %d, %Y') if node.embargo_end_date else False,
            'is_pending_embargo': node.is_pending_embargo,
            'is_embargoed': node.is_embargoed,
            'is_pending_embargo_termination': node.is_embargoed and (
                node.embargo_termination_approval and
                node.embargo_termination_approval.is_pending_approval
            ),
            'registered_from_url': node.registered_from.url if node.is_registration else '',
            'registered_date': iso8601format(node.registered_date) if node.is_registration else '',
            'root_id': node.root._id if node.root else None,
            'registered_meta': node.registered_meta,
            'registered_schemas': serialize_meta_schemas(list(node.registered_schema.all())),
            'registration_count': node.registrations_all.count(),
            'is_fork': node.is_fork,
            'forked_from_id': node.forked_from._primary_key if node.is_fork else '',
            'forked_from_display_absolute_url': node.forked_from.display_absolute_url if node.is_fork else '',
            'forked_date': iso8601format(node.forked_date) if node.is_fork else '',
            'fork_count': node.forks.filter(is_deleted=False).count(),
            'templated_count': node.templated_list.count(),
            'private_links': [x.to_json() for x in node.private_links_active],
            'link': view_only_link,
            'anonymous': anonymous,
            'points': len(node.get_points(deleted=False, folders=False)),
            'comment_level': node.comment_level,
            'has_comments': bool(Comment.find(Q('node', 'eq', node))),
            'has_children': bool(Comment.find(Q('node', 'eq', node))),
            'identifiers': {
                'doi': node.get_identifier_value('doi'),
                'ark': node.get_identifier_value('ark'),
            },
            'institutions': get_affiliated_institutions(node) if node else [],
            'alternative_citations': [citation.to_json() for citation in node.alternative_citations.all()],
            'has_draft_registrations': node.has_active_draft_registrations,
            'contributors': list(node.contributors.values_list('guids___id', flat=True)),
            'is_preprint': node.is_preprint,
            'is_preprint_orphan': node.is_preprint_orphan,
            'has_published_preprint': node.preprints.filter(is_published=True).exists() if node else False,
            'preprint_file_id': node.preprint_file._id if node.preprint_file else None,
            'preprint_url': node.preprint_url
        },
        'parent_node': {
            'exists': parent is not None,
            'id': parent._primary_key if parent else '',
            'title': parent.title if parent else '',
            'category': parent.category_display if parent else '',
            'url': parent.url if parent else '',
            'api_url': parent.api_url if parent else '',
            'absolute_url': parent.absolute_url if parent else '',
            'registrations_url': parent.web_url_for('node_registrations') if parent else '',
            'is_public': parent.is_public if parent else '',
            'is_contributor': parent.is_contributor(user) if parent else '',
            'can_view': parent.can_view(auth) if parent else False
        },
        'user': {
            'is_contributor': node.is_contributor(user),
            'is_admin': node.has_permission(user, ADMIN),
            'is_admin_parent': parent.is_admin_parent(user) if parent else False,
            'can_edit': (node.can_edit(auth)
                         and not node.is_registration),
            'has_read_permissions': node.has_permission(user, READ),
            'permissions': node.get_permissions(user) if user else [],
            'id': user._id if user else None,
            'username': user.username if user else None,
            'fullname': user.fullname if user else '',
            'can_comment': node.can_comment(auth),
            'show_wiki_widget': _should_show_wiki_widget(node, user),
            'dashboard_id': bookmark_collection_id,
            'institutions': get_affiliated_institutions(user) if user else [],
        },
        'badges': _get_badge(user),
        # TODO: Namespace with nested dicts
        'addons_enabled': node.get_addon_names(),
        'addons': configs,
        'addon_widgets': widgets,
        'addon_widget_js': js,
        'addon_widget_css': css,
        'node_categories': [
            {'value': key, 'display_name': value}
            for key, value in settings.NODE_CATEGORY_MAP.iteritems()
        ]
    }
    if embed_contributors and not anonymous:
        data['node']['contributors'] = utils.serialize_visible_contributors(node)
    if embed_descendants:
        descendants, all_readable = _get_readable_descendants(auth=auth, node=node)
        data['user']['can_sort'] = all_readable
        data['node']['descendants'] = [
            serialize_node_summary(node=each, auth=auth, primary=not node.has_node_link_to(each), show_path=False)
            for each in descendants
        ]
    if embed_registrations:
        data['node']['registrations'] = [
            serialize_node_summary(node=each, auth=auth, show_path=False)
            for each in node.registrations_all.order_by('-registered_date').exclude(is_deleted=True).annotate(nlogs=Count('logs'))
        ]
    if embed_forks:
        data['node']['forks'] = [
            serialize_node_summary(node=each, auth=auth, show_path=False)
            for each in node.forks.exclude(type='osf.registration').exclude(is_deleted=True).order_by('-forked_date').annotate(nlogs=Count('logs'))
        ]
    return data
Пример #32
0
def github_view_file(auth, **kwargs):

    node = kwargs['node'] or kwargs['project']
    node_settings = kwargs['node_addon']

    path = get_path(kwargs)
    file_name = os.path.split(path)[1]

    # Get branch / commit
    branch = request.args.get('branch')
    sha = request.args.get('sha', branch)
    ref = sha or branch

    connection = GitHub.from_settings(node_settings.user_settings)

    # Get current file for delete url
    current_file = connection.contents(user=node_settings.user,
                                       repo=node_settings.repo,
                                       path=path,
                                       ref=sha or branch)

    anonymous = has_anonymous_link(node, auth)
    try:
        # If GUID has already been created, we won't redirect, and can check
        # whether the file exists below
        guid = GithubGuidFile.find_one(
            Q('node', 'eq', node) & Q('path', 'eq', path))

    except ModularOdmException:
        # If GUID doesn't exist, check whether file exists before creating
        commits = connection.history(
            node_settings.user,
            node_settings.repo,
            path,
            ref,
        )
        if not commits:
            raise HTTPError(http.NOT_FOUND)
        guid = GithubGuidFile(
            node=node,
            path=path,
        )
        guid.save()

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

    # Get default branch if neither SHA nor branch is provided
    if ref is None:
        repo = connection.repo(node_settings.user, node_settings.repo)
        ref = branch = repo.default_branch

    # Get file history; use SHA or branch if registered, else branch
    start_sha = ref if node.is_registration else branch
    commits = connection.history(node_settings.user,
                                 node_settings.repo,
                                 path,
                                 sha=start_sha)

    # Get current commit
    shas = [commit['sha'] for commit in commits]
    if not shas:
        raise HTTPError(http.NOT_FOUND)
    current_sha = sha if sha in shas else shas[0]

    # Get file URL
    download_url = '/' + guid._id + '/download/' + ref_to_params(
        branch, current_sha)
    render_url = os.path.join(node.api_url, 'github', 'file', path,
                              'render') + '/' + ref_to_params(
                                  branch, current_sha)

    delete_url = None
    if current_file:
        delete_url = node.api_url_for('github_delete_file',
                                      path=path) + ref_to_params(
                                          branch, current_file.sha)

    for commit in commits:
        commit['download'] = ('/' + guid._id + '/download/' +
                              ref_to_params(sha=commit['sha']))
        commit['view'] = ('/' + guid._id + '/' +
                          ref_to_params(branch, sha=commit['sha']))
        if anonymous:
            commit['name'] = 'A user'
            commit['email'] = ''

    # Get or create rendered file
    cache_file_name = get_cache_file(
        path,
        current_sha,
    )
    rendered = get_cache_content(node_settings, cache_file_name)
    if rendered is None:
        try:
            _, data, size = connection.file(
                node_settings.user,
                node_settings.repo,
                path,
                ref=sha,
            )
        except TooBigError:
            rendered = 'File too large to download.'
        if rendered is None:
            # Skip if too large to be rendered.
            if github_settings.MAX_RENDER_SIZE is not None and size > github_settings.MAX_RENDER_SIZE:
                rendered = 'File too large to render; download file to view it.'
            else:
                rendered = get_cache_content(
                    node_settings,
                    cache_file_name,
                    start_render=True,
                    remote_path=guid.path,
                    file_content=data,
                    download_url=download_url,
                )

    rv = {
        'node': {
            'id': node._id,
            'title': node.title
        },
        'file_name': file_name,
        'files_page_url': node.web_url_for('collect_file_trees'),
        'current_sha': current_sha,
        'render_url': render_url,
        'rendered': rendered,
        'download_url': download_url,
        'delete_url': delete_url,
        'commits': commits,
    }
    rv.update(_view_project(node, auth, primary=True))
    return rv
Пример #33
0
def serialize_node_summary(node, auth, primary=True, show_path=False):
    is_registration = node.is_registration
    summary = {
        'id':
        node._id,
        'primary':
        primary,
        'is_registration':
        node.is_registration,
        'is_fork':
        node.is_fork,
        'is_pending_registration':
        node.is_pending_registration if is_registration else False,
        'is_retracted':
        node.is_retracted if is_registration else False,
        'is_pending_retraction':
        node.is_pending_retraction if is_registration else False,
        'embargo_end_date':
        node.embargo_end_date.strftime('%A, %b. %d, %Y')
        if is_registration and node.embargo_end_date else False,
        'is_pending_embargo':
        node.is_pending_embargo if is_registration else False,
        'is_embargoed':
        node.is_embargoed if is_registration else False,
        'archiving':
        node.archiving if is_registration else False,
    }

    parent_node = node.parent_node
    user = auth.user
    if node.can_view(auth):
        # Re-query node with contributor guids included to prevent N contributor queries
        node = AbstractNode.objects.filter(
            pk=node.pk).include('contributor__user__guids').get()
        contributor_data = serialize_contributors_for_summary(node)
        summary.update({
            'can_view':
            True,
            'can_edit':
            node.can_edit(auth),
            'primary_id':
            node._id,
            'url':
            node.url,
            'primary':
            primary,
            'api_url':
            node.api_url,
            'title':
            node.title,
            'category':
            node.category,
            'isPreprint':
            bool(node.preprint_file_id),
            'childExists':
            Node.objects.get_children(node, active=True).exists(),
            'is_admin':
            node.has_permission(user, permissions.ADMIN),
            'is_contributor':
            node.is_contributor(user),
            'logged_in':
            auth.logged_in,
            'node_type':
            node.project_or_component,
            'is_fork':
            node.is_fork,
            'is_registration':
            is_registration,
            'anonymous':
            has_anonymous_link(node, auth),
            'registered_date':
            node.registered_date.strftime('%Y-%m-%d %H:%M UTC')
            if node.is_registration else None,
            'forked_date':
            node.forked_date.strftime('%Y-%m-%d %H:%M UTC')
            if node.is_fork else None,
            'ua_count':
            None,
            'ua':
            None,
            'non_ua':
            None,
            'is_public':
            node.is_public,
            'parent_title':
            parent_node.title if parent_node else None,
            'parent_is_public':
            parent_node.is_public if parent_node else False,
            'show_path':
            show_path,
            'contributors':
            contributor_data['contributors'],
            'others_count':
            contributor_data['others_count'],
            'description':
            node.description if len(node.description) <= 150 else
            node.description[0:150] + '...',
        })
    else:
        summary['can_view'] = False

    return summary
Пример #34
0
def _view_project(node, auth, primary=False):
    """Build a JSON object containing everything needed to render
    project.view.mako.
    """
    user = auth.user

    parent = node.parent_node
    if user:
        bookmark_collection = find_bookmark_collection(user)
        bookmark_collection_id = bookmark_collection._id
        in_bookmark_collection = bookmark_collection.pointing_at(node._primary_key) is not None
    else:
        in_bookmark_collection = False
        bookmark_collection_id = ''
    view_only_link = auth.private_key or request.args.get('view_only', '').strip('/')
    anonymous = has_anonymous_link(node, auth)
    widgets, configs, js, css = _render_addon(node)
    redirect_url = node.url + '?view_only=None'

    disapproval_link = ''
    if (node.is_pending_registration and node.has_permission(user, ADMIN)):
        disapproval_link = node.root.registration_approval.stashed_urls.get(user._id, {}).get('reject', '')

    # Before page load callback; skip if not primary call
    if primary:
        for addon in node.get_addons():
            messages = addon.before_page_load(node, user) or []
            for message in messages:
                status.push_status_message(message, kind='info', dismissible=False, trust=True)
    data = {
        'node': {
            'disapproval_link': disapproval_link,
            'id': node._primary_key,
            'title': node.title,
            'category': node.category_display,
            'category_short': node.category,
            'node_type': node.project_or_component,
            'description': node.description or '',
            'license': serialize_node_license_record(node.license),
            'url': node.url,
            'api_url': node.api_url,
            'absolute_url': node.absolute_url,
            'redirect_url': redirect_url,
            'display_absolute_url': node.display_absolute_url,
            'update_url': node.api_url_for('update_node'),
            'in_dashboard': in_bookmark_collection,
            'is_public': node.is_public,
            'is_archiving': node.archiving,
            'date_created': iso8601format(node.date_created),
            'date_modified': iso8601format(node.logs[-1].date) if node.logs else '',
            'tags': [tag._primary_key for tag in node.tags],
            'children': bool(node.nodes_active),
            'is_registration': node.is_registration,
            'is_pending_registration': node.is_pending_registration,
            'is_retracted': node.is_retracted,
            'is_pending_retraction': node.is_pending_retraction,
            'retracted_justification': getattr(node.retraction, 'justification', None),
            'embargo_end_date': node.embargo_end_date.strftime("%A, %b. %d, %Y") if node.embargo_end_date else False,
            'is_pending_embargo': node.is_pending_embargo,
            'is_embargoed': node.is_embargoed,
            'is_pending_embargo_termination': node.is_embargoed and (
                node.embargo_termination_approval and
                node.embargo_termination_approval.is_pending_approval
            ),
            'registered_from_url': node.registered_from.url if node.is_registration else '',
            'registered_date': iso8601format(node.registered_date) if node.is_registration else '',
            'root_id': node.root._id if node.root else None,
            'registered_meta': node.registered_meta,
            'registered_schemas': serialize_meta_schemas(node.registered_schema),
            'registration_count': node.registrations_all.count(),
            'is_fork': node.is_fork,
            'forked_from_id': node.forked_from._primary_key if node.is_fork else '',
            'forked_from_display_absolute_url': node.forked_from.display_absolute_url if node.is_fork else '',
            'forked_date': iso8601format(node.forked_date) if node.is_fork else '',
            'fork_count': node.forks.count(),
            'templated_count': node.templated_list.count(),
            'watched_count': node.watches.count(),
            'private_links': [x.to_json() for x in node.private_links_active],
            'link': view_only_link,
            'anonymous': anonymous,
            'points': len(node.get_points(deleted=False, folders=False)),
            'piwik_site_id': node.piwik_site_id,
            'comment_level': node.comment_level,
            'has_comments': bool(Comment.find(Q('node', 'eq', node))),
            'has_children': bool(Comment.find(Q('node', 'eq', node))),
            'identifiers': {
                'doi': node.get_identifier_value('doi'),
                'ark': node.get_identifier_value('ark'),
            },
            'institution': {
                'name': node.primary_institution.name if node.primary_institution else None,
                'logo_path': node.primary_institution.logo_path if node.primary_institution else None,
                'id': node.primary_institution._id if node.primary_institution else None
            },
            'alternative_citations': [citation.to_json() for citation in node.alternative_citations],
            'has_draft_registrations': node.has_active_draft_registrations,
            'contributors': [contributor._id for contributor in node.contributors]
        },
        'parent_node': {
            'exists': parent is not None,
            'id': parent._primary_key if parent else '',
            'title': parent.title if parent else '',
            'category': parent.category_display if parent else '',
            'url': parent.url if parent else '',
            'api_url': parent.api_url if parent else '',
            'absolute_url': parent.absolute_url if parent else '',
            'registrations_url': parent.web_url_for('node_registrations') if parent else '',
            'is_public': parent.is_public if parent else '',
            'is_contributor': parent.is_contributor(user) if parent else '',
            'can_view': parent.can_view(auth) if parent else False
        },
        'user': {
            'is_contributor': node.is_contributor(user),
            'is_admin': node.has_permission(user, ADMIN),
            'is_admin_parent': parent.is_admin_parent(user) if parent else False,
            'can_edit': (node.can_edit(auth)
                         and not node.is_registration),
            'has_read_permissions': node.has_permission(user, READ),
            'permissions': node.get_permissions(user) if user else [],
            'is_watching': user.is_watching(node) if user else False,
            'piwik_token': user.piwik_token if user else '',
            'id': user._id if user else None,
            'username': user.username if user else None,
            'fullname': user.fullname if user else '',
            'can_comment': node.can_comment(auth),
            'show_wiki_widget': _should_show_wiki_widget(node, user),
            'dashboard_id': bookmark_collection_id,
            'institutions': get_affiliated_institutions(user) if user else [],
        },
        'badges': _get_badge(user),
        # TODO: Namespace with nested dicts
        'addons_enabled': node.get_addon_names(),
        'addons': configs,
        'addon_widgets': widgets,
        'addon_widget_js': js,
        'addon_widget_css': css,
        'node_categories': Node.CATEGORY_MAP
    }
    return data
Пример #35
0
def _view_project(node, auth, primary=False):
    """Build a JSON object containing everything needed to render
    project.view.mako.
    """
    user = auth.user

    parent = node.parent_node
    if user:
        dashboard = find_dashboard(user)
        dashboard_id = dashboard._id
        in_dashboard = dashboard.pointing_at(node._primary_key) is not None
    else:
        in_dashboard = False
        dashboard_id = ''
    view_only_link = auth.private_key or request.args.get('view_only', '').strip('/')
    anonymous = has_anonymous_link(node, auth)
    widgets, configs, js, css = _render_addon(node)
    redirect_url = node.url + '?view_only=None'

    # Before page load callback; skip if not primary call
    if primary:
        for addon in node.get_addons():
            messages = addon.before_page_load(node, user) or []
            for message in messages:
                status.push_status_message(message, dismissible=False)
    data = {
        'node': {
            'id': node._primary_key,
            'title': node.title,
            'category': node.category_display,
            'category_short': node.category,
            'node_type': node.project_or_component,
            'description': node.description or '',
            'url': node.url,
            'api_url': node.api_url,
            'absolute_url': node.absolute_url,
            'redirect_url': redirect_url,
            'display_absolute_url': node.display_absolute_url,
            'update_url': node.api_url_for('update_node'),
            'in_dashboard': in_dashboard,
            'is_public': node.is_public,
            'date_created': iso8601format(node.date_created),
            'date_modified': iso8601format(node.logs[-1].date) if node.logs else '',
            'tags': [tag._primary_key for tag in node.tags],
            'children': bool(node.nodes),
            'is_registration': node.is_registration,
            'registered_from_url': node.registered_from.url if node.is_registration else '',
            'registered_date': iso8601format(node.registered_date) if node.is_registration else '',
            'registered_meta': [
                {
                    'name_no_ext': from_mongo(meta),
                    'name_clean': clean_template_name(meta),
                }
                for meta in node.registered_meta or []
            ],
            'registration_count': len(node.node__registrations),
            'is_fork': node.is_fork,
            'forked_from_id': node.forked_from._primary_key if node.is_fork else '',
            'forked_from_display_absolute_url': node.forked_from.display_absolute_url if node.is_fork else '',
            'forked_date': iso8601format(node.forked_date) if node.is_fork else '',
            'fork_count': len(node.forks),
            'templated_count': len(node.templated_list),
            'watched_count': len(node.watchconfig__watched),
            'private_links': [x.to_json() for x in node.private_links_active],
            'link': view_only_link,
            'anonymous': anonymous,
            'points': len(node.get_points(deleted=False, folders=False)),
            'piwik_site_id': node.piwik_site_id,
            'comment_level': node.comment_level,
            'has_comments': bool(getattr(node, 'commented', [])),
            'has_children': bool(getattr(node, 'commented', False)),
            'identifiers': {
                'doi': node.get_identifier_value('doi'),
                'ark': node.get_identifier_value('ark'),
            },
        },
        'parent_node': {
            'exists': parent is not None,
            'id': parent._primary_key if parent else '',
            'title': parent.title if parent else '',
            'category': parent.category_display if parent else '',
            'url': parent.url if parent else '',
            'api_url': parent.api_url if parent else '',
            'absolute_url': parent.absolute_url if parent else '',
            'registrations_url': parent.web_url_for('node_registrations') if parent else '',
            'is_public': parent.is_public if parent else '',
            'is_contributor': parent.is_contributor(user) if parent else '',
            'can_view': parent.can_view(auth) if parent else False
        },
        'user': {
            'is_contributor': node.is_contributor(user),
            'is_admin_parent': parent.is_admin_parent(user) if parent else False,
            'can_edit': (node.can_edit(auth)
                         and not node.is_registration),
            'has_read_permissions': node.has_permission(user, 'read'),
            'permissions': node.get_permissions(user) if user else [],
            'is_watching': user.is_watching(node) if user else False,
            'piwik_token': user.piwik_token if user else '',
            'id': user._id if user else None,
            'username': user.username if user else None,
            'fullname': user.fullname if user else '',
            'can_comment': node.can_comment(auth),
            'show_wiki_widget': _should_show_wiki_widget(node, user),
            'dashboard_id': dashboard_id,
        },
        'badges': _get_badge(user),
        # TODO: Namespace with nested dicts
        'addons_enabled': node.get_addon_names(),
        'addons': configs,
        'addon_widgets': widgets,
        'addon_widget_js': js,
        'addon_widget_css': css,
        'node_categories': Node.CATEGORY_MAP,
    }
    return data
Пример #36
0
def _view_project(node, auth, primary=False,
                  embed_contributors=False, embed_descendants=False,
                  embed_registrations=False, embed_forks=False):
    """Build a JSON object containing everything needed to render
    project.view.mako.
    """
    node = AbstractNode.objects.filter(pk=node.pk).include('contributor__user__guids').get()
    user = auth.user

    try:
        contributor = node.contributor_set.get(user=user)
    except Contributor.DoesNotExist:
        contributor = None

    parent = node.find_readable_antecedent(auth)
    if user:
        bookmark_collection = find_bookmark_collection(user)
        bookmark_collection_id = bookmark_collection._id
        in_bookmark_collection = bookmark_collection.guid_links.filter(_id=node._id).exists()
    else:
        in_bookmark_collection = False
        bookmark_collection_id = ''

    view_only_link = auth.private_key or request.args.get('view_only', '').strip('/')
    anonymous = has_anonymous_link(node, auth)
    addons = list(node.get_addons())
    widgets, configs, js, css = _render_addons(addons)
    redirect_url = node.url + '?view_only=None'

    disapproval_link = ''
    if (node.is_pending_registration and node.has_permission(user, ADMIN)):
        disapproval_link = node.root.registration_approval.stashed_urls.get(user._id, {}).get('reject', '')

    if (node.is_pending_embargo and node.has_permission(user, ADMIN)):
        disapproval_link = node.root.embargo.stashed_urls.get(user._id, {}).get('reject', '')

    # Before page load callback; skip if not primary call
    if primary:
        for addon in addons:
            messages = addon.before_page_load(node, user) or []
            for message in messages:
                status.push_status_message(message, kind='info', dismissible=False, trust=True)
    NodeRelation = apps.get_model('osf.NodeRelation')

    is_registration = node.is_registration
    data = {
        'node': {
            'disapproval_link': disapproval_link,
            'id': node._primary_key,
            'title': node.title,
            'category': node.category_display,
            'category_short': node.category,
            'node_type': node.project_or_component,
            'description': node.description or '',
            'license': serialize_node_license_record(node.license),
            'url': node.url,
            'api_url': node.api_url,
            'absolute_url': node.absolute_url,
            'redirect_url': redirect_url,
            'display_absolute_url': node.display_absolute_url,
            'update_url': node.api_url_for('update_node'),
            'in_dashboard': in_bookmark_collection,
            'is_public': node.is_public,
            'is_archiving': node.archiving,
            'date_created': iso8601format(node.created),
            'date_modified': iso8601format(node.last_logged) if node.last_logged else '',
            'tags': list(node.tags.filter(system=False).values_list('name', flat=True)),
            'children': node.nodes_active.exists(),
            'child_exists': Node.objects.get_children(node, active=True).exists(),
            'is_supplemental_project': node.has_linked_published_preprints,
            'is_registration': is_registration,
            'is_pending_registration': node.is_pending_registration if is_registration else False,
            'is_retracted': node.is_retracted if is_registration else False,
            'is_pending_retraction': node.is_pending_retraction if is_registration else False,
            'retracted_justification': getattr(node.retraction, 'justification', None) if is_registration else None,
            'date_retracted': iso8601format(getattr(node.retraction, 'date_retracted', None)) if is_registration else '',
            'embargo_end_date': node.embargo_end_date.strftime('%A, %b %d, %Y') if is_registration and node.embargo_end_date else '',
            'is_pending_embargo': node.is_pending_embargo if is_registration else False,
            'is_embargoed': node.is_embargoed if is_registration else False,
            'is_pending_embargo_termination': is_registration and node.is_embargoed and (
                node.embargo_termination_approval and
                node.embargo_termination_approval.is_pending_approval
            ),
            'registered_from_url': node.registered_from.url if is_registration else '',
            'registered_date': iso8601format(node.registered_date) if is_registration else '',
            'root_id': node.root._id if node.root else None,
            'registered_meta': node.registered_meta,
            'registered_schemas': serialize_meta_schemas(list(node.registered_schema.all())) if is_registration else False,
            'is_fork': node.is_fork,
            'is_collected': node.is_collected,
            'collections': serialize_collections(node.collecting_metadata_list, auth),
            'forked_from_id': node.forked_from._primary_key if node.is_fork else '',
            'forked_from_display_absolute_url': node.forked_from.display_absolute_url if node.is_fork else '',
            'forked_date': iso8601format(node.forked_date) if node.is_fork else '',
            'fork_count': node.forks.exclude(type='osf.registration').filter(is_deleted=False).count(),
            'private_links': [x.to_json() for x in node.private_links_active],
            'link': view_only_link,
            'templated_count': node.templated_list.count(),
            'linked_nodes_count': NodeRelation.objects.filter(child=node, is_node_link=True).exclude(parent__type='osf.collection').count(),
            'anonymous': anonymous,
            'comment_level': node.comment_level,
            'has_comments': node.comment_set.exists(),
            'identifiers': {
                'doi': node.get_identifier_value('doi'),
                'ark': node.get_identifier_value('ark'),
            },
            'visible_preprints': serialize_preprints(node, user),
            'institutions': get_affiliated_institutions(node) if node else [],
            'has_draft_registrations': node.has_active_draft_registrations,
            'access_requests_enabled': node.access_requests_enabled,
            'storage_location': node.osfstorage_region.name,
            'waterbutler_url': node.osfstorage_region.waterbutler_url,
            'mfr_url': node.osfstorage_region.mfr_url
        },
        'parent_node': {
            'exists': parent is not None,
            'id': parent._primary_key if parent else '',
            'title': parent.title if parent else '',
            'category': parent.category_display if parent else '',
            'url': parent.url if parent else '',
            'api_url': parent.api_url if parent else '',
            'absolute_url': parent.absolute_url if parent else '',
            'registrations_url': parent.web_url_for('node_registrations', _guid=True) if parent else '',
            'is_public': parent.is_public if parent else '',
            'is_contributor': parent.is_contributor(user) if parent else '',
            'can_view': parent.can_view(auth) if parent else False,
        },
        'user': {
            'is_contributor': bool(contributor),
            'is_admin': bool(contributor) and contributor.admin,
            'is_admin_parent': parent.is_admin_parent(user) if parent else False,
            'can_edit': bool(contributor) and contributor.write and not node.is_registration,
            'can_edit_tags': bool(contributor) and contributor.write,
            'has_read_permissions': node.has_permission(user, READ),
            'permissions': get_contributor_permissions(contributor, as_list=True) if contributor else [],
            'id': user._id if user else None,
            'username': user.username if user else None,
            'fullname': user.fullname if user else '',
            'can_comment': bool(contributor) or node.can_comment(auth),
            'show_wiki_widget': _should_show_wiki_widget(node, contributor),
            'dashboard_id': bookmark_collection_id,
            'institutions': get_affiliated_institutions(user) if user else [],
        },
        # TODO: Namespace with nested dicts
        'addons_enabled': [each.short_name for each in addons],
        'addons': configs,
        'addon_widgets': widgets,
        'addon_widget_js': js,
        'addon_widget_css': css,
        'node_categories': [
            {'value': key, 'display_name': value}
            for key, value in settings.NODE_CATEGORY_MAP.items()
        ]
    }

    # Default should be at top of list for UI and for the project overview page the default region
    # for a component is that of the it's parent node.
    region_list = get_storage_region_list(user, node=node)

    data.update({'storage_regions': region_list})
    data.update({'storage_flag_is_active': storage_i18n_flag_active()})

    if embed_contributors and not anonymous:
        data['node']['contributors'] = utils.serialize_visible_contributors(node)
    else:
        data['node']['contributors'] = list(node.contributors.values_list('guids___id', flat=True))
    if embed_descendants:
        descendants, all_readable = _get_readable_descendants(auth=auth, node=node)
        data['user']['can_sort'] = all_readable
        data['node']['descendants'] = [
            serialize_node_summary(node=each, auth=auth, primary=not node.has_node_link_to(each), show_path=False)
            for each in descendants
        ]
    if embed_registrations:
        data['node']['registrations'] = [
            serialize_node_summary(node=each, auth=auth, show_path=False)
            for each in node.registrations_all.order_by('-registered_date').exclude(is_deleted=True)
        ]
    if embed_forks:
        data['node']['forks'] = [
            serialize_node_summary(node=each, auth=auth, show_path=False)
            for each in node.forks.exclude(type='osf.registration').exclude(is_deleted=True).order_by('-forked_date')
        ]
    return data
Пример #37
0
def figshare_view_file(*args, **kwargs):
    auth = kwargs['auth']
    node = kwargs['node'] or kwargs['project']
    node_settings = kwargs['node_addon']

    article_id = kwargs.get('aid') or None
    file_id = kwargs.get('fid') or None

    anonymous = has_anonymous_link(node, auth)

    if not article_id or not file_id:
        raise HTTPError(http.NOT_FOUND)

    connect = Figshare.from_settings(node_settings.user_settings)
    if node_settings.figshare_type == 'project':
        item = connect.project(node_settings, node_settings.figshare_id)
    else:
        item = connect.article(node_settings, node_settings.figshare_id)

    if article_id not in str(item):
        raise HTTPError(http.NOT_FOUND)
    article = connect.article(node_settings, article_id)

    found = False
    for f in article['items'][0]['files']:
        if f['id'] == int(file_id):
            found = f
            break
    if not found:
        raise HTTPError(http.NOT_FOUND)

    try:
        # If GUID has already been created, we won't redirect, and can check
        # whether the file exists below
        guid = FigShareGuidFile.find_one(
            Q('node', 'eq', node) &
            Q('article_id', 'eq', article_id) &
            Q('file_id', 'eq', file_id)
        )
    except:
        guid = FigShareGuidFile(node=node, article_id=article_id, file_id=file_id)
        guid.save()

    redirect_url = check_file_guid(guid)

    if redirect_url:
        return redirect(redirect_url)

    private = not(article['items'][0]['status'] == 'Public')

    figshare_url = 'http://figshare.com/'
    if private:
        figshare_url += 'preview/_preview/{0}'.format(article['items'][0]['article_id'])
    else:
        figshare_url += 'articles/{0}/{1}'.format(article['items'][0]['title'].replace(' ', '_'), article['items'][0]['article_id'])

    version_url = "http://figshare.com/articles/{filename}/{file_id}".format(
        filename=article['items'][0]['title'], file_id=article['items'][0]['article_id'])

    download_url = node.api_url + 'figshare/download/article/{aid}/file/{fid}'.format(aid=article_id, fid=file_id)

    render_url = node.api_url + \
        'figshare/render/article/{aid}/file/{fid}'.format(aid=article_id, fid=file_id)

    delete_url = node.api_url + 'figshare/article/{aid}/file/{fid}/'.format(aid=article_id, fid=file_id)

    filename = found['name']
    cache_file_name = get_cache_file(
        article_id, file_id
    )
    rendered = get_cache_content(node_settings, cache_file_name)
    if private:
        rendered = messages.FIGSHARE_VIEW_FILE_PRIVATE.format(url='http://figshare.com/')
    elif rendered is None:

        filename, size, filedata = connect.get_file(node_settings, found)

        if figshare_settings.MAX_RENDER_SIZE is not None and size > figshare_settings.MAX_RENDER_SIZE:
            rendered = messages.FIGSHARE_VIEW_FILE_OVERSIZED.format(
                url=found.get('download_url'))
        else:
            rendered = get_cache_content(
                node_settings,
                cache_file_name,
                start_render=True,
                remote_path=filename,
                file_content=filedata,
                download_url=download_url,
            )

    categories = connect.categories()['items']  # TODO Cache this
    categories = ''.join(
        ["<option value='{val}'>{label}</option>".format(val=i['id'], label=i['name']) for i in categories])

    rv = {
        'node': {
            'id': node._id,
            'title': node.title
        },
        'file_name': filename,
        'rendered': rendered,
        'file_status': article['items'][0]['status'],
        'file_version': article['items'][0]['version'],
        'doi': 'http://dx.doi.org/10.6084/m9.figshare.{0}'.format(article['items'][0]['article_id']),
        'parent_type': 'fileset' if article['items'][0]['defined_type'] == 'fileset' else 'singlefile',
        'parent_id': article['items'][0]['article_id'],
        'figshare_categories': categories,
        'figshare_title': article['items'][0]['title'],
        'figshare_desc': article['items'][0]['description'],
        'urls': {
            'render': render_url,
            'download': found.get('download_url'),
            'version': version_url,
            'figshare': privacy_info_handle(figshare_url, anonymous),
            'delete': delete_url,
            'files': node.web_url_for('collect_file_trees')
        }
    }
    rv.update(_view_project(node, auth, primary=True))
    return rv
Пример #38
0
def figshare_view_file(*args, **kwargs):
    auth = kwargs['auth']
    node = kwargs['node'] or kwargs['project']
    node_settings = kwargs['node_addon']

    article_id = kwargs.get('aid') or None
    file_id = kwargs.get('fid') or None

    anonymous = has_anonymous_link(node, auth)

    if not article_id or not file_id:
        raise HTTPError(http.NOT_FOUND)

    connect = Figshare.from_settings(node_settings.user_settings)
    if node_settings.figshare_type == 'project':
        item = connect.project(node_settings, node_settings.figshare_id)
    else:
        item = connect.article(node_settings, node_settings.figshare_id)

    if article_id not in str(item):
        raise HTTPError(http.NOT_FOUND)
    article = connect.article(node_settings, article_id)

    found = False
    for f in article['items'][0]['files']:
        if f['id'] == int(file_id):
            found = f
            break
    if not found:
        raise HTTPError(http.NOT_FOUND)

    try:
        # If GUID has already been created, we won't redirect, and can check
        # whether the file exists below
        guid = FigShareGuidFile.find_one(
            Q('node', 'eq', node) & Q('article_id', 'eq', article_id)
            & Q('file_id', 'eq', file_id))
    except:
        guid = FigShareGuidFile(node=node,
                                article_id=article_id,
                                file_id=file_id)
        guid.save()

    redirect_url = check_file_guid(guid)

    if redirect_url:
        return redirect(redirect_url)

    private = not (article['items'][0]['status'] == 'Public')

    figshare_url = 'http://figshare.com/'
    if private:
        figshare_url += 'preview/_preview/{0}'.format(
            article['items'][0]['article_id'])
    else:
        figshare_url += 'articles/{0}/{1}'.format(
            article['items'][0]['title'].replace(' ', '_'),
            article['items'][0]['article_id'])

    version_url = "http://figshare.com/articles/{filename}/{file_id}".format(
        filename=article['items'][0]['title'],
        file_id=article['items'][0]['article_id'])

    download_url = node.api_url + 'figshare/download/article/{aid}/file/{fid}'.format(
        aid=article_id, fid=file_id)

    render_url = node.api_url + \
        'figshare/render/article/{aid}/file/{fid}'.format(aid=article_id, fid=file_id)

    delete_url = node.api_url + 'figshare/article/{aid}/file/{fid}/'.format(
        aid=article_id, fid=file_id)

    filename = found['name']
    cache_file_name = get_cache_file(article_id, file_id)
    rendered = get_cache_content(node_settings, cache_file_name)
    if private:
        rendered = messages.FIGSHARE_VIEW_FILE_PRIVATE.format(
            url='http://figshare.com/')
    elif rendered is None:

        filename, size, filedata = connect.get_file(node_settings, found)

        if figshare_settings.MAX_RENDER_SIZE is not None and size > figshare_settings.MAX_RENDER_SIZE:
            rendered = messages.FIGSHARE_VIEW_FILE_OVERSIZED.format(
                url=found.get('download_url'))
        else:
            rendered = get_cache_content(
                node_settings,
                cache_file_name,
                start_render=True,
                remote_path=filename,
                file_content=filedata,
                download_url=download_url,
            )

    categories = connect.categories()['items']  # TODO Cache this
    categories = ''.join([
        "<option value='{val}'>{label}</option>".format(val=i['id'],
                                                        label=i['name'])
        for i in categories
    ])

    rv = {
        'node': {
            'id': node._id,
            'title': node.title
        },
        'file_name':
        filename,
        'rendered':
        rendered,
        'file_status':
        article['items'][0]['status'],
        'file_version':
        article['items'][0]['version'],
        'doi':
        'http://dx.doi.org/10.6084/m9.figshare.{0}'.format(
            article['items'][0]['article_id']),
        'parent_type':
        'fileset'
        if article['items'][0]['defined_type'] == 'fileset' else 'singlefile',
        'parent_id':
        article['items'][0]['article_id'],
        'figshare_categories':
        categories,
        'figshare_title':
        article['items'][0]['title'],
        'figshare_desc':
        article['items'][0]['description'],
        'urls': {
            'render': render_url,
            'download': found.get('download_url'),
            'version': version_url,
            'figshare': privacy_info_handle(figshare_url, anonymous),
            'delete': delete_url,
            'files': node.web_url_for('collect_file_trees')
        }
    }
    rv.update(_view_project(node, auth, primary=True))
    return rv
Пример #39
0
def project_wiki_view(auth, wname, path=None, **kwargs):
    node = kwargs['node'] or kwargs['project']
    anonymous = has_anonymous_link(node, auth)
    wiki_name = (wname or '').strip()
    wiki_key = to_mongo_key(wiki_name)
    wiki_page = node.get_wiki_page(wiki_name)
    wiki_settings = node.get_addon('wiki')
    can_edit = (
        auth.logged_in
        and not node.is_registration
        and (
            node.has_permission(auth.user, 'write')
            or wiki_settings.is_publicly_editable
        )
    )
    versions = _get_wiki_versions(node, wiki_name, anonymous=anonymous)

    # Determine panels used in view
    panels = {'view', 'edit', 'compare', 'menu'}
    if request.args and set(request.args).intersection(panels):
        panels_used = [panel for panel in request.args if panel in panels]
        num_columns = len(set(panels_used).intersection({'view', 'edit', 'compare'}))
        if num_columns == 0:
            panels_used.append('view')
            num_columns = 1
    else:
        panels_used = ['view', 'menu']
        num_columns = 1

    try:
        view = wiki_utils.format_wiki_version(
            version=request.args.get('view'),
            num_versions=len(versions),
            allow_preview=True,
        )
        compare = wiki_utils.format_wiki_version(
            version=request.args.get('compare'),
            num_versions=len(versions),
            allow_preview=False,
        )
    except InvalidVersionError:
        raise WIKI_INVALID_VERSION_ERROR

    # Default versions for view and compare
    version_settings = {
        'view': view or ('preview' if 'edit' in panels_used else 'current'),
        'compare': compare or 'previous',
    }

    # 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.html(node)
        use_python_render = wiki_page.rendered_before_update
    else:
        version = 'NA'
        is_current = False
        content = ''
        use_python_render = False

    if can_edit:
        if wiki_key not in node.wiki_private_uuids:
            wiki_utils.generate_private_uuid(node, wiki_name)
        sharejs_uuid = wiki_utils.get_sharejs_uuid(node, wiki_name)
    else:
        if wiki_key not in node.wiki_pages_current and wiki_key != 'home':
            raise WIKI_PAGE_NOT_FOUND_ERROR
        if 'edit' in request.args:
            if wiki_settings.is_publicly_editable:
                raise HTTPError(http.UNAUTHORIZED)
            raise HTTPError(http.FORBIDDEN)
        sharejs_uuid = None

    # Opens 'edit' panel when home wiki is empty
    if not content and can_edit and wiki_name == 'home':
        panels_used.append('edit')

    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,
        'use_python_render': use_python_render,
        'page': wiki_page,
        'version': version,
        'versions': versions,
        'sharejs_uuid': sharejs_uuid or '',
        'sharejs_url': settings.SHAREJS_URL,
        'is_current': is_current,
        'version_settings': version_settings,
        'pages_current': _get_wiki_pages_current(node),
        'category': node.category,
        'panels_used': panels_used,
        'num_columns': num_columns,
        'urls': {
            'api': _get_wiki_api_urls(node, wiki_name, {
                'content': node.api_url_for('wiki_page_content', wname=wiki_name),
                'draft': node.api_url_for('wiki_page_draft', wname=wiki_name),
            }),
            'web': _get_wiki_web_urls(node, wiki_name),
            'gravatar': get_gravatar(auth.user, 25),
        },
    }
    ret.update(_view_project(node, auth, primary=True))
    ret['user']['can_edit_wiki_body'] = can_edit
    return ret
Пример #40
0
def project_wiki_view(auth, wname, path=None, **kwargs):
    node = kwargs['node'] or kwargs['project']
    anonymous = has_anonymous_link(node, auth)
    wiki_name = (wname or '').strip()
    wiki_key = to_mongo_key(wiki_name)
    wiki_page = node.get_wiki_page(wiki_name)
    toc = _serialize_wiki_toc(node, auth=auth)
    can_edit = node.has_permission(auth.user, 'write') and not node.is_registration
    versions = _get_wiki_versions(node, wiki_name, anonymous=anonymous)

    # Determine panels used in view
    panels = {'view', 'edit', 'compare', 'menu'}
    if request.args and set(request.args).intersection(panels):
        panels_used = [panel for panel in request.args if panel in panels]
        num_columns = len(set(panels_used).intersection({'view', 'edit', 'compare'}))
        if num_columns == 0:
            panels_used.append('view')
            num_columns = 1
    else:
        panels_used = ['view', 'menu']
        num_columns = 1

    try:
        view = wiki_utils.format_wiki_version(
            version=request.args.get('view'),
            num_versions=len(versions),
            allow_preview=True,
        )
        compare = wiki_utils.format_wiki_version(
            version=request.args.get('compare'),
            num_versions=len(versions),
            allow_preview=False,
        )
    except InvalidVersionError:
        raise WIKI_INVALID_VERSION_ERROR

    # Default versions for view and compare
    version_settings = {
        'view': view or ('preview' if 'edit' in panels_used else 'current'),
        'compare': compare or 'previous',
    }

    # 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.html(node)
        use_python_render = wiki_page.rendered_before_update
    else:
        version = 'NA'
        is_current = False
        content = ''
        use_python_render = False

    if can_edit:
        if wiki_key not in node.wiki_private_uuids:
            wiki_utils.generate_private_uuid(node, wiki_name)
        sharejs_uuid = wiki_utils.get_sharejs_uuid(node, wiki_name)
    else:
        if wiki_key not in node.wiki_pages_current and wiki_key != 'home':
            raise WIKI_PAGE_NOT_FOUND_ERROR
        if 'edit' in request.args:
            raise HTTPError(http.FORBIDDEN)
        sharejs_uuid = None

    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,
        'use_python_render': use_python_render,
        'page': wiki_page,
        'version': version,
        'versions': versions,
        'sharejs_uuid': sharejs_uuid or '',
        'sharejs_url': settings.SHAREJS_URL,
        'is_current': is_current,
        'version_settings': version_settings,
        'pages_current': _get_wiki_pages_current(node),
        'toc': toc,
        'category': node.category,
        'panels_used': panels_used,
        'num_columns': num_columns,
        'urls': {
            'api': _get_wiki_api_urls(node, wiki_name, {
                'content': node.api_url_for('wiki_page_content', wname=wiki_name),
                'draft': node.api_url_for('wiki_page_draft', wname=wiki_name),
            }),
            'web': _get_wiki_web_urls(node, wiki_name),
            'gravatar': get_gravatar(auth.user, 25),
        },
    }
    ret.update(_view_project(node, auth, primary=True))
    return ret