Java Attribute类代码示例

import org.opensaml.saml.saml2.core.Attribute; //导入依赖的package包/类
/**
 * New attribute statement.
 *
 * @param attributes            the attributes
 * @param setFriendlyName       the set friendly name
 * @param configuredNameFormats the configured name formats
 * @return the attribute statement
 */
public AttributeStatement newAttributeStatement(final Map<String, Object> attributes,
                                                final boolean setFriendlyName,
                                                final Map<String, String> configuredNameFormats) {
    final AttributeStatement attrStatement = newSamlObject(AttributeStatement.class);
    for (final Map.Entry<String, Object> e : attributes.entrySet()) {
        if (e.getValue() instanceof Collection<?> && ((Collection<?>) e.getValue()).isEmpty()) {
            LOGGER.info("Skipping attribute [{}] because it does not have any values.", e.getKey());
            continue;
        }
        final Attribute attribute = newAttribute(setFriendlyName, e, configuredNameFormats);
        attrStatement.getAttributes().add(attribute);
    }

    return attrStatement;
}
 

import org.opensaml.saml.saml2.core.Attribute; //导入依赖的package包/类
@Test
public void shouldReturnRequiredCycle3AttributesWhenValuesExistInCycle3Assertion(){
    List<Attribute> accountCreationAttributes = Arrays.asList(CYCLE_3).stream()
            .map(attributeQueryAttributeFactory::createAttribute)
            .collect(toList());

    ImmutableMap<String, String> build = ImmutableMap.<String, String>builder().put("cycle3Key", "cycle3Value").build();
    Cycle3Dataset cycle3Dataset = Cycle3Dataset.createFromData(build);
    HubAssertion hubAssertion =new HubAssertion("1", "issuerId", DateTime.now(), new PersistentId("1"), null, Optional.of(cycle3Dataset));

    List<Attribute> userAttributesForAccountCreation = userAccountCreationAttributeExtractor.getUserAccountCreationAttributes(accountCreationAttributes, null, Optional.of(hubAssertion));

    List<Attribute> cycle_3 = userAttributesForAccountCreation.stream().filter(a -> a.getName().equals("cycle_3")).collect(toList());
    StringBasedMdsAttributeValue personName = (StringBasedMdsAttributeValue) cycle_3.get(0).getAttributeValues().get(0);

    assertThat(cycle_3.size()).isEqualTo(1);
    assertThat(personName.getValue().equals("cycle3Value"));
}
 

import org.opensaml.saml.saml2.core.Attribute; //导入依赖的package包/类
private static Optional<String> getStringAttributeValue(List<Attribute> attributes, String attributeName) {
    final Optional<Attribute> attribute = getAttribute(attributes, attributeName);
    return attribute.map(attr -> {
        StringValueSamlObject attributeValue = ((StringValueSamlObject) attr.getAttributeValues().get(0));
        return Optional.ofNullable(attributeValue.getValue()).orElse("");
    });
}
 

import org.opensaml.saml.saml2.core.Attribute; //导入依赖的package包/类
@Test
public void shouldReturnFullAddressHistoryIncludingWhetherTheyAreVerified() throws Exception {
    List<Attribute> accountCreationAttributes = Arrays.asList(ADDRESS_HISTORY).stream()
            .map(attributeQueryAttributeFactory::createAttribute)
            .collect(toList());

    Address currentAddress = new Address(Arrays.asList("line1", "line2", "line3"), "postCode", "internationalPostCode", "uprn", null, null, true);
    Address oldAddress = new Address(Arrays.asList("old_line1", "old_line2", "old_line3"), "old_postCode", "old_internationalPostCode", "old_uprn", new DateTime(1990, 1, 30, 0, 0), new DateTime(2000, 1, 29, 0, 0), false);
    Address oldAddress2 = new Address(Arrays.asList("old_line1", "old_line2", "old_line3"), "old_postCode_2", "old_internationalPostCode_2", "old_uprn", new DateTime(2000, 1, 30, 0, 0), new DateTime(2010, 1, 29, 0, 0), true);

    MatchingDataset matchingDataset = MatchingDatasetBuilder.aMatchingDataset().withCurrentAddresses(singletonList(currentAddress)).withPreviousAddresses(Arrays.asList(oldAddress, oldAddress2)).build();
    List<Attribute> userAttributesForAccountCreation = userAccountCreationAttributeExtractor.getUserAccountCreationAttributes(accountCreationAttributes, Optional.of(matchingDataset), absent());

    Attribute addressHistoryAttribute = userAttributesForAccountCreation.stream().filter(a -> a.getName().equals("addresshistory")).collect(toList()).get(0);
    List<AddressImpl> addresses = addressHistoryAttribute.getAttributeValues().stream().map(v -> (AddressImpl) v).collect(toList());

    AddressImpl firstAddress = addresses.stream().filter(a -> a.getPostCode().getValue().equals("postCode")).findFirst().get();
    AddressImpl secondAddress = addresses.stream().filter(a -> a.getPostCode().getValue().equals("old_postCode")).findFirst().get();
    AddressImpl thirdAddress = addresses.stream().filter(a -> a.getPostCode().getValue().equals("old_postCode_2")).findFirst().get();

    assertThat(addresses.size()).isEqualTo(3);
    assertThat(firstAddress.getVerified()).isTrue();
    assertThat(secondAddress.getVerified()).isFalse();
    assertThat(thirdAddress.getVerified()).isTrue();
}
 

import org.opensaml.saml.saml2.core.Attribute; //导入依赖的package包/类
public OutboundResponseFromUnknownUserCreationService handle(InboundMatchingServiceRequest attributeQuery) {
    IdentityProviderAssertion matchingDatasetAssertion = attributeQuery.getMatchingDatasetAssertion();
    IdentityProviderAssertion authnStatementAssertion = attributeQuery.getAuthnStatementAssertion();
    final String hashedPid = userIdHashFactory.hashId(matchingDatasetAssertion.getIssuerId(),
        matchingDatasetAssertion.getPersistentId().getNameId(),
        authnStatementAssertion.getAuthnStatement().transform(IdentityProviderAuthnStatement::getAuthnContext));

    LevelOfAssuranceDto levelOfAssurance = AuthnContextToLevelOfAssuranceDtoMapper.map(attributeQuery.getAuthnStatementAssertion().getAuthnStatement().get().getAuthnContext());
    UnknownUserCreationResponseDto unknownUserCreationResponseDto = matchingServiceProxy.makeUnknownUserCreationRequest(new UnknownUserCreationRequestDto(hashedPid, levelOfAssurance));
    if (unknownUserCreationResponseDto.getResult().equalsIgnoreCase(UnknownUserCreationResponseDto.FAILURE)) {
        return OutboundResponseFromUnknownUserCreationService.createFailure(attributeQuery.getId(), matchingServiceAdapterConfiguration.getEntityId());
    }

    Optional<MatchingDataset> matchingDataset = attributeQuery.getMatchingDatasetAssertion().getMatchingDataset();
    List<Attribute> extractedUserAccountCreationAttributes = userAccountCreationAttributeExtractor.getUserAccountCreationAttributes(
            attributeQuery.getUserCreationAttributes(),
            matchingDataset,
            attributeQuery.getCycle3AttributeAssertion());

    final OutboundResponseFromUnknownUserCreationService matchingServiceResponse = getMatchingServiceResponse(attributeQuery, hashedPid, extractedUserAccountCreationAttributes);
    LOG.info(MessageFormat.format("Result from unknown attribute query request for id {0} is {1}", attributeQuery.getId(), matchingServiceResponse.getStatus()));

    return matchingServiceResponse;
}
 

import org.opensaml.saml.saml2.core.Attribute; //导入依赖的package包/类
private OutboundResponseFromUnknownUserCreationService getMatchingServiceResponse(
    final String hashPid,
    final InboundMatchingServiceRequest attributeQuery,
    final List<Attribute> userAttributesForAccountCreation) {
    AssertionRestrictions assertionRestrictions = new AssertionRestrictions(
        DateTime.now().plus(assertionLifetimeConfiguration.getAssertionLifetime().toMilliseconds()),
        attributeQuery.getId(),
        attributeQuery.getAssertionConsumerServiceUrl());

    MatchingServiceAssertion assertion = matchingServiceAssertionFactory.createAssertionFromMatchingService(
        new PersistentId(hashPid),
        matchingServiceAdapterConfiguration.getEntityId(),
        assertionRestrictions,
        attributeQuery.getAuthnStatementAssertion().getAuthnStatement().get().getAuthnContext(),
        attributeQuery.getAuthnRequestIssuerId(),
        userAttributesForAccountCreation);
    return OutboundResponseFromUnknownUserCreationService.createSuccess(
        assertion,
        attributeQuery.getId(),
        matchingServiceAdapterConfiguration.getEntityId()
    );
}
 

import org.opensaml.saml.saml2.core.Attribute; //导入依赖的package包/类
public InboundMatchingServiceRequest(
        String id,
        String issuer,
        IdentityProviderAssertion matchingDatasetAssertion,
        IdentityProviderAssertion authnStatementAssertion,
        Optional<HubAssertion> cycle3AttributeAssertion,
        DateTime issueInstant,
        String authnRequestIssuerId,
        String assertionConsumerServiceUrl,
        List<Attribute> userCreationAttributes) {


    super(id, issuer, issueInstant, null);

    this.matchingDatasetAssertion = matchingDatasetAssertion;
    this.authnStatementAssertion = authnStatementAssertion;
    this.cycle3AttributeAssertion = cycle3AttributeAssertion;
    this.authnRequestIssuerId = authnRequestIssuerId;
    this.assertionConsumerServiceUrl = assertionConsumerServiceUrl;
    this.userCreationAttributes = userCreationAttributes;
}
 

import org.opensaml.saml.saml2.core.Attribute; //导入依赖的package包/类
private EidasMatchingDatasetDto extractEidasMatchingDataset(List<Attribute> attributes) {
    LocalDate dob = getAttributeValue(attributes, Eidas_Attributes.DateOfBirth.NAME, DateOfBirth::getDateOfBirth);
    String givenName = getAttributeValue(attributes, Eidas_Attributes.FirstName.NAME, CurrentGivenName::getFirstName);
    String familyName = getAttributeValue(attributes, Eidas_Attributes.FamilyName.NAME, CurrentFamilyName::getFamilyName);
    String birthName = getAttributeValue(attributes, Eidas_Attributes.BirthName.NAME, BirthName::getBirthName);
    String placeOfBirth = getAttributeValue(attributes, Eidas_Attributes.PlaceOfBirth.NAME, PlaceOfBirth::getPlaceOfBirth);
    String gender = getAttributeValue(attributes, Eidas_Attributes.Gender.NAME, Gender::getValue);

    return new EidasMatchingDatasetDto(null,
        dob,
        givenName,
        familyName,
        birthName,
        gender,
        placeOfBirth
    );
}
 

import org.opensaml.saml.saml2.core.Attribute; //导入依赖的package包/类
@Test
public void shouldReturnCurrentAddressWhetherItIsVerifiedOrNot() {
    List<Attribute> accountCreationAttributes = singletonList(UserAccountCreationAttribute.CURRENT_ADDRESS).stream()
            .map(attributeQueryAttributeFactory::createAttribute)
            .collect(toList());


    Address currentAddress = new Address(Arrays.asList("line1", "line2", "line3"), "postCode", "internationalPostCode", "uprn", null, null, false);

    MatchingDataset matchingDataset = MatchingDatasetBuilder.aMatchingDataset().withCurrentAddresses(singletonList(currentAddress)).build();
    List<Attribute> userAttributesForAccountCreation = userAccountCreationAttributeExtractor.getUserAccountCreationAttributes(accountCreationAttributes, Optional.of(matchingDataset), absent());

    List<Attribute> addresses = userAttributesForAccountCreation.stream().filter(a -> a.getName().equals("currentaddress")).collect(toList());
    AddressImpl addressName = (AddressImpl) addresses.get(0).getAttributeValues().get(0);

    assertThat(addresses.size()).isEqualTo(1);
    assertThat(addressName.getPostCode().equals("postCode"));
}
 

import org.opensaml.saml.saml2.core.Attribute; //导入依赖的package包/类
@Test
public void shouldReturnFailureResponseWhenAttributesRequestedDoNotExist(){
    List<Attribute> requiredAttributes = asList(FIRST_NAME, MIDDLE_NAME).stream()
            .map(userAccountCreationAttribute -> new AttributeQueryAttributeFactory(new OpenSamlXmlObjectFactory()).createAttribute(userAccountCreationAttribute))
            .collect(toList());

    AttributeQuery attributeQuery = anAttributeQuery()
            .withId(REQUEST_ID)
            .withAttributes(requiredAttributes)
            .withIssuer(anIssuer().withIssuerId(applicationRule.getConfiguration().getHubEntityId()).build())
            .withSubject(aSubjectWithAssertions(asList(
                    anAuthnStatementAssertion(),
                    assertionWithOnlyFirstName()), REQUEST_ID, HUB_ENTITY_ID))
            .build();

    Response response = makeAttributeQueryRequest(UNKNOWN_USER_URI, attributeQuery, signatureAlgorithmForHub, digestAlgorithmForHub, HUB_ENTITY_ID);
    List<Assertion> decryptedAssertions = assertionDecrypter.decryptAssertions(response::getEncryptedAssertions);

    assertThat(response.getStatus().getStatusCode().getValue()).isEqualTo(RESPONDER);
    Assertions.assertThat(decryptedAssertions).hasSize(0);
    Assertions.assertThat(response.getInResponseTo()).isEqualTo(REQUEST_ID);
    Assertions.assertThat(response.getIssuer().getValue()).isEqualTo(TEST_RP_MS);
    assertThat(response).is(signedBy(TEST_RP_MS_PUBLIC_SIGNING_CERT, TEST_RP_MS_PRIVATE_SIGNING_KEY));
}
 

import org.opensaml.saml.saml2.core.Attribute; //导入依赖的package包/类
@Test
public void shouldReturnVerifiedIfAllCurrentAttributeValuesAreVerified() throws Exception {
    List<Attribute> accountCreationAttributes = Arrays.asList(SURNAME, SURNAME_VERIFIED).stream()
            .map(attributeQueryAttributeFactory::createAttribute)
            .collect(toList());


    SimpleMdsValue<String> currentSurname = new SimpleMdsValue<>("CurrentSurname", null, null, true);
    SimpleMdsValue<String> oldSurname1 = new SimpleMdsValue<>("OldSurname1", new DateTime(2000, 1, 30, 0, 0), new DateTime(2010, 1, 30, 0, 0), true);
    SimpleMdsValue<String> oldSurname2 = new SimpleMdsValue<>("OldSurname2", new DateTime(1990, 1, 30, 0, 0), new DateTime(2000, 1, 29, 0, 0), true);

    MatchingDataset matchingDataset = MatchingDatasetBuilder.aMatchingDataset().withSurnameHistory(Arrays.asList(oldSurname1, oldSurname2, currentSurname)).build();
    List<Attribute> userAttributesForAccountCreation = userAccountCreationAttributeExtractor.getUserAccountCreationAttributes(accountCreationAttributes, Optional.of(matchingDataset), absent());

    List<Attribute> surnames = userAttributesForAccountCreation.stream().filter(a -> a.getName().equals("surname")).collect(toList());
    List<Attribute>  verified = userAttributesForAccountCreation.stream().filter(a -> a.getName().equals("surname_verified")).collect(toList());
    PersonNameImpl personName = (PersonNameImpl) surnames.get(0).getAttributeValues().get(0);

    assertThat(surnames.size()).isEqualTo(1);
    assertThat(personName.getValue().equals("CurrentSurname"));
    assertThat(verified.size()).isEqualTo(1);
    assertThat(verified.get(0).getName().equals("surname_verified"));
}
 

import org.opensaml.saml.saml2.core.Attribute; //导入依赖的package包/类
private void assertThatResponseContainsExpectedUserCreationAttributes(List<AttributeStatement>  attributeStatements, final List<Attribute> expectedUserCreationAttributes) {
    assertThat(attributeStatements).hasSize(1);
    AttributeStatement attributeStatement = attributeStatements.get(0);
    assertThat(attributeStatement.getAttributes()).hasSameSizeAs(expectedUserCreationAttributes);

    for (final Attribute expectedUserCreationAttribute : expectedUserCreationAttributes) {
        Attribute actualAttribute = attributeStatement.getAttributes().stream()
                .filter(attribute -> expectedUserCreationAttribute.getName().equals(attribute.getName()))
                .findFirst()
                .get();

        assertThat(actualAttribute.getAttributeValues()).hasSameSizeAs(expectedUserCreationAttribute.getAttributeValues());
        if (!actualAttribute.getAttributeValues().isEmpty()) {
            assertThatAttributeValuesAreEqual(actualAttribute.getAttributeValues().get(0), expectedUserCreationAttribute.getAttributeValues().get(0));
        }
    }
}
 

import org.opensaml.saml.saml2.core.Attribute; //导入依赖的package包/类
private AttributeQuery givenAValidAttributeQuery() {
    AttributeQuery query = openSamlXmlObjectFactory.createAttributeQuery();

    query.setIssueInstant(DateTime.now());
    Subject originalSubject = openSamlXmlObjectFactory.createSubject();
    NameID originalSubjectNameId = openSamlXmlObjectFactory.createNameId("name_id");
    Issuer originalIssuer = openSamlXmlObjectFactory.createIssuer("issuer_id");
    originalSubject.setNameID(originalSubjectNameId);

    SubjectConfirmation subjectConfirmation = openSamlXmlObjectFactory.createSubjectConfirmation();
    originalSubject.getSubjectConfirmations().add(subjectConfirmation);
    query.setSubject(originalSubject);
    query.setIssuer(originalIssuer);

    originalIssuer.setValue("original issuer");
    query.setID("original id");
    originalSubjectNameId.setValue("original subject id");
    originalSubjectNameId.setSPNameQualifier("http://foo.com");

    List<Attribute> attributes = query.getAttributes();
    AttributeFactory_1_1 attributeFactory = new AttributeFactory_1_1(openSamlXmlObjectFactory);
    attributes.add(attributeFactory.createFirstnameAttribute(ImmutableList.of(new SimpleMdsValue<>(FIRST_NAME, null, null, false))));

    return query;
}
 

import org.opensaml.saml.saml2.core.Attribute; //导入依赖的package包/类
@Test
public void shouldNotReturnAttributesWhenNoCurrentValueExistsInMatchingDataSet() {
    List<Attribute> accountCreationAttributes = singletonList(SURNAME).stream()
            .map(attributeQueryAttributeFactory::createAttribute)
            .collect(toList());

    SimpleMdsValue<String> oldSurname1 = new SimpleMdsValue<>("OldSurname1", new DateTime(2000, 1, 30, 0, 0), new DateTime(2010, 1, 30, 0, 0), true);
    SimpleMdsValue<String> oldSurname2 = new SimpleMdsValue<>("OldSurname2", new DateTime(1990, 1, 30, 0, 0), new DateTime(2000, 1, 29, 0, 0), true);

    MatchingDataset matchingDataset = MatchingDatasetBuilder.aMatchingDataset().withSurnameHistory(Arrays.asList(oldSurname1, oldSurname2)).build();
    List<Attribute> userAttributesForAccountCreation = userAccountCreationAttributeExtractor.getUserAccountCreationAttributes(accountCreationAttributes, Optional.of(matchingDataset), absent());

    List<Attribute> surnames = userAttributesForAccountCreation.stream().filter(a -> a.getName().equals("surname")).collect(toList());

    assertThat(surnames.size()).isEqualTo(0);
}
 

import org.opensaml.saml.saml2.core.Attribute; //导入依赖的package包/类
@Test
public void createAssertionFromMatchingService() {
    IdGenerator idGenerator = mock(IdGenerator.class);
    AssertionRestrictions assertionRestrictions = mock(AssertionRestrictions.class);
    MatchingServiceAssertionFactory factory = new MatchingServiceAssertionFactory(idGenerator);
    AuthnContext authnContext = AuthnContext.LEVEL_4;
    List<Attribute> userAccountCreationAttributes = Arrays.asList(mock(Attribute.class));

    PersistentId thePersistentId = new PersistentId("thePersistentId");
    MatchingServiceAssertion assertionFromMatchingService = factory.createAssertionFromMatchingService(
        thePersistentId,
        "theIssuerId",
        assertionRestrictions,
        authnContext,
        "theAudience",
        userAccountCreationAttributes
    );

    assertThat(assertionFromMatchingService.getPersistentId(), sameInstance(thePersistentId));
    assertThat(assertionFromMatchingService.getIssuerId(), equalTo("theIssuerId"));
    assertThat(assertionFromMatchingService.getAssertionRestrictions(), sameInstance(assertionRestrictions));
    assertThat(assertionFromMatchingService.getAuthnStatement().getAuthnContext(), sameInstance(authnContext));
    assertThat(assertionFromMatchingService.getAudience(), equalTo("theAudience"));
    assertThat(assertionFromMatchingService.getUserAttributesForAccountCreation(), sameInstance(userAccountCreationAttributes));
}