Python utils.serialize_user函数代码示例

def _profile_view(profile, is_profile):
    # TODO: Fix circular import
    from website.addons.badges.util import get_sorted_user_badges

    if profile and profile.is_disabled:
        raise HTTPError(http.GONE)

    if 'badges' in settings.ADDONS_REQUESTED:
        badge_assertions = get_sorted_user_badges(profile),
        badges = _get_user_created_badges(profile)
    else:
        # NOTE: While badges, are unused, 'assertions' and 'badges' can be
        # empty lists.
        badge_assertions = []
        badges = []

    if profile:
        profile_user_data = profile_utils.serialize_user(profile, full=True)
        return {
            'profile': profile_user_data,
            'assertions': badge_assertions,
            'badges': badges,
            'user': {
                'is_profile': is_profile,
                'can_edit': None,  # necessary for rendering nodes
                'permissions': [],  # necessary for rendering nodes
            },
        }

    raise HTTPError(http.NOT_FOUND)

def serialize_draft_registration(draft, auth=None):
    
    import sys
    sys.path.insert(0, submodule_path('utils.py'))
    from website.profile.utils import serialize_user  # noqa

    node = draft.branched_from
    
    return {
        'pk': draft._id,
        'branched_from': serialize_node(draft.branched_from, auth),
        'initiator': serialize_user(draft.initiator, full=True),
        'registration_metadata': draft.registration_metadata,
        'registration_schema': serialize_meta_schema(draft.registration_schema),
        'initiated': str(draft.datetime_initiated),
        'updated': str(draft.datetime_updated),
        'flags': draft.flags,
        'requires_approval': draft.requires_approval,
        #'is_pending_approval': draft.is_pending_review,
        #'is_approved': draft.is_approved,
        'approval': serialize_draft_registration_approval(draft.approval)
        # 'urls': {
        #     'edit': node.web_url_for('edit_draft_registration_page', 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')
        # }
    }

def _profile_view(profile, is_profile=False, embed_nodes=False, include_node_counts=False):
    if profile and profile.is_disabled:
        raise HTTPError(http.GONE)
    # NOTE: While badges, are unused, 'assertions' and 'badges' can be
    # empty lists.
    badge_assertions = []
    badges = []

    if profile:
        profile_user_data = profile_utils.serialize_user(profile, full=True, is_profile=is_profile, include_node_counts=include_node_counts)
        ret = {
            'profile': profile_user_data,
            'assertions': badge_assertions,
            'badges': badges,
            'user': {
                '_id': profile._id,
                'is_profile': is_profile,
                'can_edit': None,  # necessary for rendering nodes
                'permissions': [],  # necessary for rendering nodes
            },
        }
        if embed_nodes:
            ret.update({
                'public_projects': get_public_projects(user=profile),
                'public_components': get_public_components(user=profile),
            })
        return ret
    raise HTTPError(http.NOT_FOUND)

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

    node = draft.branched_from

    return {
        'pk': draft._id,
        'branched_from': serialize_node(node, auth),
        'initiator': serialize_user(draft.initiator, full=True),
        '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 test_serialize_user_full(self):
     user = UserFactory()
     ProjectFactory(creator=user, is_public=False)
     NodeFactory(creator=user)
     ProjectFactory(creator=user, is_public=True)
     CollectionFactory(creator=user)
     d = utils.serialize_user(user, full=True, include_node_counts=True)
     profile_image_url = filters.profile_image_url(settings.PROFILE_IMAGE_PROVIDER,
                                               user,
                                               use_ssl=True,
                                               size=settings.PROFILE_IMAGE_LARGE)
     assert_equal(d['id'], user._primary_key)
     assert_equal(d['url'], user.url)
     assert_equal(d.get('username'), None)
     assert_equal(d['fullname'], user.fullname)
     assert_equal(d['registered'], user.is_registered)
     assert_equal(d['profile_image_url'], profile_image_url)
     assert_equal(d['absolute_url'], user.absolute_url)
     assert_equal(d['date_registered'], user.date_registered.strftime('%Y-%m-%d'))
     projects = [
         node
         for node in user.contributed
         if node.category == 'project'
         and not node.is_registration
         and not node.is_deleted
     ]
     public_projects = [p for p in projects if p.is_public]
     assert_equal(d['number_projects'], len(projects))
     assert_equal(d['number_public_projects'], len(public_projects))

def _profile_view(profile, is_profile=False):
    # TODO: Fix circular import
    from website.addons.badges.util import get_sorted_user_badges

    if profile and profile.is_disabled:
        raise HTTPError(http.GONE)

    if "badges" in settings.ADDONS_REQUESTED:
        badge_assertions = (get_sorted_user_badges(profile),)
        badges = _get_user_created_badges(profile)
    else:
        # NOTE: While badges, are unused, 'assertions' and 'badges' can be
        # empty lists.
        badge_assertions = []
        badges = []

    if profile:
        profile_user_data = profile_utils.serialize_user(profile, full=True, is_profile=is_profile)
        return {
            "profile": profile_user_data,
            "assertions": badge_assertions,
            "badges": badges,
            "user": {
                "is_profile": is_profile,
                "can_edit": None,  # necessary for rendering nodes
                "permissions": [],  # necessary for rendering nodes
            },
        }

    raise HTTPError(http.NOT_FOUND)

def serialize_draft_registration(draft, auth=None):
    
    import sys
    sys.path.insert(0, submodule_path('utils.py'))
    from website.profile.utils import serialize_user  # noqa
    #import ipdb; ipdb.set_trace()
    node = draft.branched_from
    
    return {
        'pk': draft._id,
        'branched_from': serialize_node(draft.branched_from, auth),
        'initiator': serialize_user(draft.initiator, full=True),
        'registration_metadata': draft.registration_metadata,
        'registration_schema': serialize_meta_schema(draft.registration_schema),
        'initiated': str(draft.datetime_initiated),
        'updated': str(draft.datetime_updated),
        'config': draft.config or {},
        'flags': draft.flags,
        # 'urls': {
        #     'edit': node.web_url_for('edit_draft_registration_page', 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')
        # }
    }

 def test_serialize_user_merged(self):
     master = UserFactory()
     user = UserFactory()
     master.merge_user(user)
     d = utils.serialize_user(user, full=True)
     assert_true(d['is_merged'])
     assert_equal(d['merged_by']['url'], user.merged_by.url)
     assert_equal(d['merged_by']['absolute_url'], user.merged_by.absolute_url)

 def test_serialize_user_full_includes_email_if_is_profile(self):
     serialized = utils.serialize_user(
         self.project.creator,
         self.project,
         full=True,
         is_profile=True
     )
     assert_in('emails', serialized)

def claim_user_registered(auth, node, **kwargs):
    """View that prompts user to enter their password in order to claim
    contributorship on a project.

    A user must be logged in.
    """
    current_user = auth.user

    sign_out_url = web_url_for('auth_login', logout=True, next=request.url)
    if not current_user:
        return redirect(sign_out_url)
    # Logged in user should not be a contributor the project
    if node.is_contributor(current_user):
        logout_url = web_url_for('auth_logout', redirect_url=request.url)
        data = {
            'message_short': 'Already a contributor',
            'message_long': ('The logged-in user is already a contributor to this '
                'project. Would you like to <a href="{}">log out</a>?').format(logout_url)
        }
        raise HTTPError(http.BAD_REQUEST, data=data)
    uid, pid, token = kwargs['uid'], kwargs['pid'], kwargs['token']
    unreg_user = User.load(uid)
    if not verify_claim_token(unreg_user, token, pid=node._primary_key):
        raise HTTPError(http.BAD_REQUEST)

    # Store the unreg_user data on the session in case the user registers
    # a new account
    session.data['unreg_user'] = {
        'uid': uid, 'pid': pid, 'token': token
    }

    form = PasswordForm(request.form)
    if request.method == 'POST':
        if form.validate():
            if current_user.check_password(form.password.data):
                node.replace_contributor(old=unreg_user, new=current_user)
                node.save()
                status.push_status_message(
                    'You are now a contributor to this project.',
                    kind='success',
                    trust=False
                )
                return redirect(node.url)
            else:
                status.push_status_message(language.LOGIN_FAILED, kind='warning', trust=False)
        else:
            forms.push_errors_to_status(form.errors)
    if is_json_request():
        form_ret = forms.utils.jsonify(form)
        user_ret = profile_utils.serialize_user(current_user, full=False)
    else:
        form_ret = form
        user_ret = current_user
    return {
        'form': form_ret,
        'user': user_ret,
        'signOutUrl': sign_out_url
    }

def claim_user_registered(auth, node, **kwargs):
    """
    View that prompts user to enter their password in order to claim being a contributor on a project.
    A user must be logged in.
    """

    current_user = auth.user

    sign_out_url = web_url_for("auth_register", logout=True, next=request.url)
    if not current_user:
        return redirect(sign_out_url)

    # Logged in user should not be a contributor the project
    if node.is_contributor(current_user):
        logout_url = web_url_for("auth_logout", redirect_url=request.url)
        data = {
            "message_short": "Already a contributor",
            "message_long": (
                "The logged-in user is already a contributor to this "
                'project. Would you like to <a href="{}">log out</a>?'
            ).format(logout_url),
        }
        raise HTTPError(http.BAD_REQUEST, data=data)

    uid, pid, token = kwargs["uid"], kwargs["pid"], kwargs["token"]
    unreg_user = User.load(uid)
    if not verify_claim_token(unreg_user, token, pid=node._primary_key):
        error_data = {
            "message_short": "Invalid url.",
            "message_long": "The token in the URL is invalid or has expired.",
        }
        raise HTTPError(http.BAD_REQUEST, data=error_data)

    # Store the unreg_user data on the session in case the user registers
    # a new account
    session.data["unreg_user"] = {"uid": uid, "pid": pid, "token": token}

    form = PasswordForm(request.form)
    if request.method == "POST":
        if form.validate():
            if current_user.check_password(form.password.data):
                node.replace_contributor(old=unreg_user, new=current_user)
                node.save()
                status.push_status_message("You are now a contributor to this project.", kind="success", trust=False)
                return redirect(node.url)
            else:
                status.push_status_message(language.LOGIN_FAILED, kind="warning", trust=False)
        else:
            forms.push_errors_to_status(form.errors)
    if is_json_request():
        form_ret = forms.utils.jsonify(form)
        user_ret = profile_utils.serialize_user(current_user, full=False)
    else:
        form_ret = form
        user_ret = current_user
    return {"form": form_ret, "user": user_ret, "signOutUrl": sign_out_url}

 def test_serialize_user(self):
     master = UserFactory()
     user = UserFactory()
     master.merge_user(user)
     d = utils.serialize_user(user)
     assert_equal(d['id'], user._primary_key)
     assert_equal(d['url'], user.url)
     assert_equal(d.get('username', None), None)
     assert_equal(d['fullname'], user.fullname)
     assert_equal(d['registered'], user.is_registered)
     assert_equal(d['absolute_url'], user.absolute_url)
     assert_equal(d['date_registered'], user.date_registered.strftime('%Y-%m-%d'))
     assert_equal(d['active'], user.is_active)

    def test_serialize_access_requests(self):
        new_user = AuthUserFactory()
        node_request = NodeRequestFactory(
            creator=new_user,
            target=self.project,
            request_type=workflows.RequestTypes.ACCESS.value,
            machine_state=workflows.DefaultStates.INITIAL.value
        )
        node_request.run_submit(new_user)
        res = utils.serialize_access_requests(self.project)

        assert len(res) == 1
        assert res[0]['comment'] == node_request.comment
        assert res[0]['id'] == node_request._id
        assert res[0]['user'] == utils.serialize_user(new_user)

def _profile_view(profile, is_profile=False, include_node_counts=False):
    if profile and profile.is_disabled:
        raise HTTPError(http.GONE)

    if profile:
        profile_quickfilesnode = QuickFilesNode.objects.get_for_user(profile)
        profile_user_data = profile_utils.serialize_user(profile, full=True, is_profile=is_profile, include_node_counts=include_node_counts)
        ret = {
            'profile': profile_user_data,
            'user': {
                '_id': profile._id,
                'is_profile': is_profile,
                'can_edit': None,  # necessary for rendering nodes
                'permissions': [],  # necessary for rendering nodes
                'has_quickfiles': profile_quickfilesnode.files.filter(type='osf.osfstoragefile').exists()
            },
        }
        return ret
    raise HTTPError(http.NOT_FOUND)

 def test_serialize_user_full_does_not_include_emails_by_default(self):
     serialized = utils.serialize_user(self.project.creator, self.project, full=True)
     assert_not_in('emails', serialized)