Python utils.serialize_node函数代码示例

def addon_view_file(auth, node, file_node, version):
    # TODO: resolve circular import issue
    from website.addons.wiki import settings as wiki_settings

    if isinstance(version, tuple):
        version, error = version
        error = error.replace('\n', '').strip()
    else:
        error = None

    ret = serialize_node(node, auth, primary=True)

    if file_node._id + '-' + version._id not in node.file_guid_to_share_uuids:
        node.file_guid_to_share_uuids[file_node._id + '-' + version._id] = uuid.uuid4()
        node.save()

    if ret['user']['can_edit']:
        sharejs_uuid = str(node.file_guid_to_share_uuids[file_node._id + '-' + version._id])
    else:
        sharejs_uuid = None

    download_url = furl.furl(request.url.encode('utf-8')).set(args=dict(request.args, **{
        'direct': None,
        'mode': 'render',
        'action': 'download',
    }))

    render_url = furl.furl(settings.MFR_SERVER_URL).set(
        path=['render'],
        args={'url': download_url.url}
    )

    ret.update({
        'urls': {
            'render': render_url.url,
            'mfr': settings.MFR_SERVER_URL,
            'sharejs': wiki_settings.SHAREJS_URL,
            'gravatar': get_gravatar(auth.user, 25),
            'files': node.web_url_for('collect_file_trees'),
            'archived_from': get_archived_from_url(node, file_node) if node.is_registration else None,
        },
        'error': error,
        'file_name': file_node.name,
        'file_name_title': os.path.splitext(file_node.name)[0],
        'file_name_ext': os.path.splitext(file_node.name)[1],
        'file_path': file_node.path,
        'sharejs_uuid': sharejs_uuid,
        'provider': file_node.provider,
        'materialized_path': file_node.materialized_path,
        'extra': version.metadata.get('extra', {}),
        'size': version.size if version.size is not None else 9966699,
        'private': getattr(node.get_addon(file_node.provider), 'is_private', False),
        'file_tags': [tag._id for tag in file_node.tags],
        'file_guid': file_node.get_guid()._id,
        'file_id': file_node._id,
        'allow_comments': file_node.provider in settings.ADDONS_COMMENTABLE
    })

    ret.update(rubeus.collect_addon_assets(node))
    return ret

def addon_deleted_file(auth, node, **kwargs):
    """Shows a nice error message to users when they try to view
    a deleted file
    """
    # Allow file_node to be passed in so other views can delegate to this one
    trashed = kwargs.get('file_node') or TrashedFileNode.load(kwargs.get('trashed_id'))
    if not trashed:
        raise HTTPError(httplib.NOT_FOUND, {
            'message_short': 'Not Found',
            'message_long': 'This file does not exist'
        })

    ret = serialize_node(node, auth, primary=True)
    ret.update(rubeus.collect_addon_assets(node))
    ret.update({
        'urls': {
            'render': None,
            'sharejs': None,
            'mfr': settings.MFR_SERVER_URL,
            'gravatar': get_gravatar(auth.user, 25),
            'files': node.web_url_for('collect_file_trees'),
        },
        'extra': {},
        'size': 9966699,  # Prevent file from being editted, just in case
        'sharejs_uuid': None,
        'file_name': trashed.name,
        'file_path': trashed.path,
        'provider': trashed.provider,
        'materialized_path': trashed.materialized_path,
        'error': FILE_GONE_ERROR_MESSAGE.format(file_name=trashed.name),
        'private': getattr(node.get_addon(trashed.provider), 'is_private', False),
    })

    return ret, httplib.GONE

def addon_view_file(auth, node, node_addon, file_guid, extras):
    render_url = node.api_url_for(
        'addon_render_file',
        path=file_guid.waterbutler_path.lstrip('/'),
        provider=file_guid.provider,
        render=True,
        **extras
    )

    ret = serialize_node(node, auth, primary=True)

    # Disable OSF Storage file deletion in DISK_SAVING_MODE
    if settings.DISK_SAVING_MODE and node_addon.config.short_name == 'osfstorage':
        ret['user']['can_edit'] = False

    ret.update({
        'provider': file_guid.provider,
        'render_url': render_url,
        'file_path': file_guid.waterbutler_path,
        'files_url': node.web_url_for('collect_file_trees'),
        'rendered': get_or_start_render(file_guid),
        # Note: must be called after get_or_start_render. This is really only for github
        'extra': json.dumps(getattr(file_guid, 'extra', {})),
        #NOTE: get_or_start_render must be called first to populate name
        'file_name': getattr(file_guid, 'name', os.path.split(file_guid.waterbutler_path)[1]),
    })

    ret.update(rubeus.collect_addon_assets(node))
    return ret

def serialize_draft_registration(draft, auth=None):
    from website.project.utils import serialize_node  # noqa

    node = draft.branched_from

    return {
        'pk': draft._id,
        'branched_from': serialize_node(node, auth),
        'initiator': serialize_initiator(draft.initiator),
        'registration_metadata': draft.registration_metadata,
        'registration_schema': serialize_meta_schema(draft.registration_schema),
        'initiated': utils.iso8601format(draft.datetime_initiated),
        'updated': utils.iso8601format(draft.datetime_updated),
        'flags': draft.flags,
        'urls': {
            'edit': node.web_url_for('edit_draft_registration_page', draft_id=draft._id),
            'submit': node.api_url_for('submit_draft_for_review', draft_id=draft._id),
            'before_register': node.api_url_for('project_before_register'),
            'register': node.api_url_for('register_draft_registration', draft_id=draft._id),
            'register_page': node.web_url_for('draft_before_register_page', draft_id=draft._id),
            'registrations': node.web_url_for('node_registrations')
        },
        'requires_approval': draft.requires_approval,
        'is_pending_approval': draft.is_pending_review,
        'is_approved': draft.is_approved,
    }

def addon_deleted_file(auth, node, **kwargs):
    """Shows a nice error message to users when they try to view
    a deleted file
    """
    # Allow file_node to be passed in so other views can delegate to this one
    trashed = kwargs.get("file_node") or TrashedFileNode.load(kwargs.get("trashed_id"))
    if not trashed:
        raise HTTPError(httplib.NOT_FOUND, {"message_short": "Not Found", "message_long": "This file does not exist"})

    ret = serialize_node(node, auth, primary=True)
    ret.update(rubeus.collect_addon_assets(node))
    ret.update(
        {
            "urls": {
                "render": None,
                "sharejs": None,
                "mfr": settings.MFR_SERVER_URL,
                "gravatar": get_gravatar(auth.user, 25),
                "files": node.web_url_for("collect_file_trees"),
            },
            "extra": {},
            "size": 9966699,  # Prevent file from being editted, just in case
            "sharejs_uuid": None,
            "file_name": trashed.name,
            "file_path": trashed.path,
            "provider": trashed.provider,
            "materialized_path": trashed.materialized_path,
            "error": FILE_GONE_ERROR_MESSAGE.format(file_name=trashed.name),
            "private": getattr(node.get_addon(trashed.provider), "is_private", False),
        }
    )

    return ret, httplib.GONE

def dropbox_view_file(path, node_addon, auth, **kwargs):
    """Web view for the file detail page."""
    if not path:
        raise HTTPError(http.NOT_FOUND)
    # check that current user has access to the path
    if not is_authorizer(auth, node_addon):
        abort_if_not_subdir(path, node_addon.folder)
    node = node_addon.owner
    client = get_node_addon_client(node_addon)
    # Lazily create a file GUID record
    file_obj, created = DropboxFile.get_or_create(node=node, path=path)

    redirect_url = check_file_guid(file_obj)
    if redirect_url:
        return redirect(redirect_url)
    rev = request.args.get('rev') or ''
    rendered = render_dropbox_file(file_obj, client=client, rev=rev)
    cleaned_path = clean_path(path)
    response = {
        'revisions_url': node.api_url_for('dropbox_get_revisions',
            path=cleaned_path, rev=rev),  # Append current revision as a query param
        'file_name': get_file_name(path),
        'render_url': node.api_url_for('dropbox_render_file', path=cleaned_path),
        'download_url': file_obj.download_url(guid=True, rev=rev),
        'rendered': rendered,
    }
    response.update(serialize_node(node, auth, primary=True))
    return response, http.OK

def node_registration_retraction_get(auth, node, **kwargs):
    """Prepares node object for registration retraction page.

    :return: serialized Node to be retracted
    :raises: 400: BAD_REQUEST if registration already pending retraction
    """

    if not node.is_registration:
        raise HTTPError(
            http.BAD_REQUEST,
            data={
                "message_short": "Invalid Request",
                "message_long": "Retractions of non-registrations is not permitted.",
            },
        )
    if node.pending_retraction:
        raise HTTPError(
            http.BAD_REQUEST,
            data={
                "message_short": "Invalid Request",
                "message_long": "This registration is already pending a retraction.",
            },
        )

    return serialize_node(node, auth, primary=True)

def draft_before_register_page(auth, node, draft, *args, **kwargs):
    """Allow the user to select an embargo period and confirm registration

    :return: serialized Node + DraftRegistration
    :rtype: dict
    """
    ret = serialize_node(node, auth, primary=True)

    ret['draft'] = serialize_draft_registration(draft, auth)
    return ret

def edit_draft_registration_page(auth, node, draft, **kwargs):
    """Draft registration editor

    :return: serialized DraftRegistration
    :rtype: dict
    """
    check_draft_state(draft)
    ret = project_utils.serialize_node(node, auth, primary=True)
    ret['draft'] = serialize_draft_registration(draft, auth)
    return ret

def view_file(auth, path, node_addon, version_query):
    node = node_addon.owner
    idx, version, record = get_version(path, node_addon, version_query, throw=False)
    file_obj = model.OsfStorageGuidFile.get_or_create(node=node, path=path)
    redirect_url = check_file_guid(file_obj)
    if redirect_url:
        return redirect(redirect_url)
    ret = serialize_file(idx, version, record, path, node)
    ret.update(serialize_node(node, auth, primary=True))
    return ret

def addon_view_file(auth, node, node_addon, guid_file, extras):
    # TODO: resolve circular import issue
    from website.addons.wiki import settings as wiki_settings

    ret = serialize_node(node, auth, primary=True)

    # Disable OSF Storage file deletion in DISK_SAVING_MODE
    if settings.DISK_SAVING_MODE and node_addon.config.short_name == 'osfstorage':
        ret['user']['can_edit'] = False

    try:
        guid_file.enrich()
    except exceptions.AddonEnrichmentError as e:
        error = e.as_html()
    else:
        error = None

    if guid_file._id not in node.file_guid_to_share_uuids:
        node.file_guid_to_share_uuids[guid_file._id] = uuid.uuid4()
        node.save()

    if ret['user']['can_edit']:
        sharejs_uuid = str(node.file_guid_to_share_uuids[guid_file._id])
    else:
        sharejs_uuid = None

    size = getattr(guid_file, 'size', None)
    if size is None:  # Size could be 0 which is a falsey value
        size = 9966699  # if we dont know the size assume its to big to edit

    ret.update({
        'error': error.replace('\n', '') if error else None,
        'provider': guid_file.provider,
        'file_path': guid_file.waterbutler_path,
        'panels_used': ['edit', 'view'],
        'private': getattr(node_addon, 'is_private', False),
        'sharejs_uuid': sharejs_uuid,
        'urls': {
            'files': node.web_url_for('collect_file_trees'),
            'render': guid_file.mfr_render_url,
            'sharejs': wiki_settings.SHAREJS_URL,
            'mfr': settings.MFR_SERVER_URL,
            'gravatar': get_gravatar(auth.user, 25),
            'external': getattr(guid_file, 'external_url', None)
        },
        # Note: must be called after get_or_start_render. This is really only for github
        'size': size,
        'extra': getattr(guid_file, 'extra', {}),
        #NOTE: get_or_start_render must be called first to populate name
        'file_name': getattr(guid_file, 'name', os.path.split(guid_file.waterbutler_path)[1]),
        'materialized_path': getattr(guid_file, 'materialized', guid_file.waterbutler_path),
    })

    ret.update(rubeus.collect_addon_assets(node))
    return ret

 def get_mako_return(self):
     ret = serialize_node(self.project, Auth(self.user), primary=True)
     ret.update({
         'extra': '',
         'provider': '',
         'rendered': '',
         'file_path': '',
         'files_url': '',
         'file_name': '',
         'render_url': '',
     })
     return ret

def addon_view_file(auth, node, file_node, version):
    # TODO: resolve circular import issue
    from website.addons.wiki import settings as wiki_settings

    if isinstance(version, tuple):
        version, error = version
        error = error.replace("\n", "").strip()
    else:
        error = None

    ret = serialize_node(node, auth, primary=True)

    if file_node._id not in node.file_guid_to_share_uuids:
        node.file_guid_to_share_uuids[file_node._id] = uuid.uuid4()
        node.save()

    if ret["user"]["can_edit"]:
        sharejs_uuid = str(node.file_guid_to_share_uuids[file_node._id])
    else:
        sharejs_uuid = None

    download_url = furl.furl(request.url.encode("utf-8")).set(
        args=dict(request.args, **{"direct": None, "mode": "render", "action": "download"})
    )

    render_url = furl.furl(settings.MFR_SERVER_URL).set(path=["render"], args={"url": download_url.url})

    ret.update(
        {
            "urls": {
                "render": render_url.url,
                "mfr": settings.MFR_SERVER_URL,
                "sharejs": wiki_settings.SHAREJS_URL,
                "gravatar": get_gravatar(auth.user, 25),
                "files": node.web_url_for("collect_file_trees"),
            },
            "error": error,
            "file_name": file_node.name,
            "file_name_title": os.path.splitext(file_node.name)[0],
            "file_name_ext": os.path.splitext(file_node.name)[1],
            "file_path": file_node.path,
            "sharejs_uuid": sharejs_uuid,
            "provider": file_node.provider,
            "materialized_path": file_node.materialized_path,
            "extra": version.metadata.get("extra", {}),
            "size": version.size if version.size is not None else 9966699,
            "private": getattr(node.get_addon(file_node.provider), "is_private", False),
            "file_tags": [tag._id for tag in file_node.tags],
        }
    )

    ret.update(rubeus.collect_addon_assets(node))
    return ret

def node_register_page(auth, node, **kwargs):
    """Display the registration metadata for a registration.

    :return: serialized Node
    """

    if node.is_registration:
        return serialize_node(node, auth)
    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='draft'))

 def get_mako_return(self):
     ret = serialize_node(self.project, Auth(self.user), primary=True)
     ret.update({
         'extra': '',
         'provider': '',
         'rendered': '',
         'file_path': '',
         'files_url': '',
         'file_name': '',
         'render_url': '',
         'materialized_path': '',
     })
     ret.update(rubeus.collect_addon_assets(self.project))
     return ret