Python OpenIDServiceEndpoint.claimed_id方法代码示例

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import claimed_id [as 别名]
 def begin(self, url):
     endpoint = OpenIDServiceEndpoint()
     endpoint.claimed_id = 'oid'
     endpoint.server_url = 'http://localhost/'
     endpoint.type_uris = [OPENID_2_0_TYPE]
     auth_request = consumer.AuthRequest(endpoint, None)
     return auth_request

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import claimed_id [as 别名]
 def v1endpoint(self, port):
     """Return an OpenID 1.1 OpenIDServiceEndpoint for the server."""
     base = "http://%s:%s" % (socket.getfqdn('127.0.0.1'), port)
     ep = OpenIDServiceEndpoint()
     ep.claimed_id = base + "/id/bob"
     ep.server_url = base + "/openidserver"
     ep.type_uris = [OPENID_1_1_TYPE]
     return ep

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import claimed_id [as 别名]
def _verifyDiscoveryResultsOpenID2(self, resp_msg, endpoint):
    to_match = OpenIDServiceEndpoint()
    to_match.type_uris = [OPENID_2_0_TYPE]
    to_match.claimed_id = resp_msg.getArg(OPENID2_NS, 'claimed_id')
    to_match.local_id = resp_msg.getArg(OPENID2_NS, 'identity')

    # Raises a KeyError when the op_endpoint is not present
    to_match.server_url = resp_msg.getArg(
        OPENID2_NS, 'op_endpoint', no_default)

    # claimed_id and identifier must both be present or both
    # be absent
    if (to_match.claimed_id is None and
        to_match.local_id is not None):
        raise consumer.ProtocolError(
            'openid.identity is present without openid.claimed_id')

    elif (to_match.claimed_id is not None and
          to_match.local_id is None):
        raise consumer.ProtocolError(
            'openid.claimed_id is present without openid.identity')

    # This is a response without identifiers, so there's really no
    # checking that we can do, so return an endpoint that's for
    # the specified `openid.op_endpoint'
    elif to_match.claimed_id is None:
        return OpenIDServiceEndpoint.fromOPEndpointURL(to_match.server_url)

    # The claimed ID doesn't match, so we have to do discovery
    # again. This covers not using sessions, OP identifier
    # endpoints and responses that didn't match the original
    # request.
    if to_match.server_url.startswith(u'https://www.google.com/a/'):
        import urllib
        claimed_id = u'https://www.google.com/accounts/o8/user-xrds?uri=%s' % urllib.quote_plus(to_match.claimed_id)
    else:
        claimed_id = to_match.claimed_id

    if not endpoint:
        oidutil.log('No pre-discovered information supplied.')
        endpoint = self._discoverAndVerify(claimed_id, [to_match])
    else:
        # The claimed ID matches, so we use the endpoint that we
        # discovered in initiation. This should be the most common
        # case.
        try:
            self._verifyDiscoverySingle(endpoint, to_match)
        except consumer.ProtocolError, e:
            oidutil.log(
                "Error attempting to use stored discovery information: " +
                str(e))
            oidutil.log("Attempting discovery to verify endpoint")
            endpoint = self._discoverAndVerify(
                claimed_id, [to_match])

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import claimed_id [as 别名]
    def make_openid_response(self, sreg_args=None, teams_args=None):
        endpoint = OpenIDServiceEndpoint()
        endpoint.claimed_id = 'some-id'

        message = Message(OPENID2_NS)
        if sreg_args is not None:
            for key, value in sreg_args.items():
                message.setArg(SREG_NS, key, value)
        if teams_args is not None:
            for key, value in teams_args.items():
                message.setArg(TEAMS_NS, key, value)
        response = SuccessResponse(
            endpoint, message, signed_fields=message.toPostArgs().keys())
        return response

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import claimed_id [as 别名]
    def make_endpoint(self, protocol_uri, claimed_id, local_id=None):
        """Create an endpoint for use with `Consumer.beginWithoutDiscovery`.

        :arg protocol_uri: The URI for the OpenID protocol version.  This
            should be one of the OPENID_X_Y_TYPE constants.
        :arg claimed_id: The claimed identity URL for the endpoint.
        :arg local_id: The OP local identifier for the endpoint.  If this
            argument is not provided, it defaults to claimed_id.
        """
        msg = "Unexpected protocol URI: %s" % protocol_uri
        assert protocol_uri in OPENID_TYPES, msg

        endpoint = OpenIDServiceEndpoint()
        endpoint.type_uris = [protocol_uri]
        endpoint.server_url = self.base_openid_url
        endpoint.claimed_id = claimed_id
        endpoint.local_id = local_id or claimed_id
        return endpoint

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import claimed_id [as 别名]
def make_endpoint(protocol_uri, claimed_id, local_id=None):
    """Create an endpoint for use with `Consumer.beginWithoutDiscovery`.

    :arg protocol_uri: The URI for the OpenID protocol version.  This
        should be one of the OPENID_X_Y_TYPE constants.
    :arg claimed_id: The claimed identity URL for the endpoint.
    :arg local_id: The OP local identifier for the endpoint.  If this
        argument is not provided, it defaults to claimed_id.
    """
    assert protocol_uri in [
        OPENID_1_0_TYPE, OPENID_1_1_TYPE, OPENID_2_0_TYPE], (
        "Unexpected protocol URI: %s" % protocol_uri)

    endpoint = OpenIDServiceEndpoint()
    endpoint.type_uris = [protocol_uri]
    endpoint.server_url = get_requested_server_url(claimed_id)
    endpoint.claimed_id = claimed_id
    endpoint.local_id = local_id or claimed_id
    return endpoint

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import claimed_id [as 别名]
    def make_identifier_select_endpoint(self, protocol_uri):
        """Create an endpoint for use in OpenID identifier select mode.

        :arg protocol_uri: The URI for the OpenID protocol version.  This
            should be one of the OPENID_X_Y_TYPE constants.

        If the OpenID 1.x protocol is selected, the endpoint will be
        suitable for use with Launchpad's non-standard identifier select
        workflow.
        """
        msg = "Unexpected protocol URI: %s" % protocol_uri
        assert protocol_uri in OPENID_TYPES, msg

        endpoint = OpenIDServiceEndpoint()
        endpoint.server_url = self.base_openid_url
        if protocol_uri == OPENID_2_0_TYPE:
            endpoint.type_uris = [OPENID_IDP_2_0_TYPE]
        else:
            endpoint.type_uris = [protocol_uri]
            endpoint.claimed_id = IDENTIFIER_SELECT
            endpoint.local_id = IDENTIFIER_SELECT
        return endpoint

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import claimed_id [as 别名]
 def __init__(self, openid_namespace=OPENID2_NS):
     super(TestMessage, self).__init__(openid_namespace=openid_namespace)
     endpoint = OpenIDServiceEndpoint()
     endpoint.claimed_id = make_claimed_id('some-id')
     endpoint.server_url = SERVER_URL
     self.endpoint = endpoint

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import claimed_id [as 别名]
def makeSuccessResponse(claimed_id, query):
    """Returns an OpenID success response with given arguments, all signed."""
    endpoint = OpenIDServiceEndpoint()
    endpoint.claimed_id = claimed_id
    signed_list = ['openid.' + k for k in query]
    return SuccessResponse(endpoint, Message.fromOpenIDArgs(query), signed_list)

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import claimed_id [as 别名]
 def make_fake_openid_endpoint(self, claimed_id=None):
     endpoint = OpenIDServiceEndpoint()
     endpoint.claimed_id = claimed_id
     return endpoint