import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
/**
 * updates (adds new, delete, updates) the {@link X509CertificateEntity}'s of the given {@link UserEntity} based on
 * the given List of X509Certificate's
 *
 * @param x509Certificates list of X509Certificate's to be deleted, updated or added
 * @param userEntity       user who needs to be updated
 * @param attributes       all {@link X509CertificateEntity}'s will be deleted if this Set contains 'x509Certificates'
 */
void update(List<X509Certificate> x509Certificates, UserEntity userEntity, Set<String> attributes) {

    if (attributes.contains("x509Certificates")) {
        userEntity.removeAllX509Certificates();
    }

    if (x509Certificates != null) {
        for (X509Certificate scimX509Certificate : x509Certificates) {
            X509CertificateEntity x509CertificateEntity = x509CertificateConverter.fromScim(scimX509Certificate);
            userEntity.removeX509Certificate(x509CertificateEntity); // we always have to remove the x509Certificate
            // the primary attribute has changed
            if (Strings.isNullOrEmpty(scimX509Certificate.getOperation())
                    || !scimX509Certificate.getOperation().equalsIgnoreCase("delete")) {

                ensureOnlyOnePrimaryX509CertificateExists(x509CertificateEntity, userEntity.getX509Certificates());
                userEntity.addX509Certificate(x509CertificateEntity);
            }
        }
    }
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
@Command(description = "Update a certificate from the user.", startsSubshell = true)
public void updateCertificate(
		@Param(value = "searchKey", description = "Which key should be used to identify the certificate.")
		String key,
		@Param(value = "expr", description = "If the value matches this regular expression, the certificate will updated.")
		String valueExp) throws IOException{

	Set<X509Certificate> certificates = builderCommand.showAllX509Certificates();
	for(X509Certificate current : certificates){
		if(match(current, key, valueExp)){
			final X509Certificate certificate = builderCommand.builderShellFactory.enterX509CertificateShell(current);
			if(certificate != null){
				builderCommand.builder.updateX509Certificate(current, certificate);
			}
		}
	}
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
/**
 * Enter a new subshell for creating a {@link X509Certificate}.
 *
 * @param current The current persisted {@link X509Certificate}.
 * @return The {@link X509Certificate}. Or null if the user interrupt the process.
 * @throws IOException
 */
public X509Certificate enterX509CertificateShell(X509Certificate current) throws IOException {
	final X509CertificateBuilder x509CertificateBuilder = new X509CertificateBuilder(current);

	final Shell subShell = ShellBuilder.subshell((current == null ? "create" : "replace") + "-certificate", shell)
		.behavior()
			.disableExitCommand()
			.addHandler(x509CertificateBuilder)
		.build();

	output.out()
		.normal("In this subshell you can create a certificate. Leave this sub shell via \"commit\" to persist the changes.")
	.println();

	subShell.commandLoop();

	return x509CertificateBuilder.build();
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
private static ArrayList<X509Certificate> getX509Certificates() {

        X509Certificate x509Certificate = new X509Certificate.Builder()
                .setPrimary(true)
                .setValue("MIIBrTCCARagAwIBAgIFHL6O8kAwDQYJKoZIhvcNAQEFBQAwGDEWMBQGA1UEAxMNRXhhbXBsZUlz"
                        + "c3VlcjAiGA8yMDAwMDEwMTAwMDAwMFoYDzIwNTAwMTAxMDAwMDAwWjAZMRcwFQYDVQQDEw5FeGFt"
                        + "cGxlU3ViamVjdDCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEApbwnNhV4Mgn1VrQctOaSkoTg"
                        + "S6VqDulOAgGvDxwGMaAILWn0lNU50P7mkyFemGLCAWT+JGxgk7XLmaJtTGdA+9z7GnxRtxRpsnEL"
                        + "yAleVvAVNvZxecMIYyuUM2ZRBZWAnyDig4HomVAXz3rA0B32L37qmf+e3Z/Yie2ft4l41FcCAwEA"
                        + "ATANBgkqhkiG9w0BAQUFAAOBgQBE9aUWNuXhRGK225tGPzMKOa3WkltBiZOv8RNCavvKkp6/WIle"
                        + "KWtoNwSwUGjq+VhVcGqBfPEqDN8eC5DeCIxmQqkvxVQLe8hAZ4o5upSvfxvttj1NbSJMBf6NtDrB"
                        + "aVjjgqxSubteb6th+cqTsPdUsn5WfDbDjeuSa5d0fOEBzw==")
                .build();

        ArrayList<X509Certificate> x509Certificates = new ArrayList<X509Certificate>();
        x509Certificates.add(x509Certificate);

        return x509Certificates;
    }
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
private void updateX509Certificate(UpdateUser.Builder updateBuilder, List<X509Certificate> x509Certificates,
        String value) {
    X509Certificate newX509Certificate = new X509Certificate.Builder().setValue(value)
            .setType(new X509Certificate.Type(LdapAuthentication.LDAP_PROVIDER)).build();
    for (X509Certificate x509Certificate : x509Certificates) {
        if (x509Certificate.getType() != null
                && x509Certificate.getType().toString().equals(LdapAuthentication.LDAP_PROVIDER)) {
            updateBuilder.deleteX509Certificate(x509Certificate);
        }
    }
    updateBuilder.addX509Certificate(newX509Certificate);
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
@Override
public X509CertificateEntity fromScim(X509Certificate scim) {
    X509CertificateEntity x509CertificateEntity = new X509CertificateEntity();
    x509CertificateEntity.setValue(scim.getValue());
    x509CertificateEntity.setType(scim.getType());
    x509CertificateEntity.setPrimary(scim.isPrimary());
    x509CertificateEntity.setDisplay(scim.getDisplay());
    return x509CertificateEntity;
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
@Override
public X509Certificate toScim(X509CertificateEntity entity) {
    return new X509Certificate.Builder()
            .setValue(entity.getValue())
            .setPrimary(entity.isPrimary())
            .setType(entity.getType())
            .setDisplay(entity.getDisplay())
            .build();
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
@Override
public String convertToDatabaseColumn(X509Certificate.Type attribute) {
    if (attribute == null || Strings.isNullOrEmpty(attribute.getValue())) {
        return null;
    }

    return attribute.getValue();
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
@Override
public X509Certificate.Type convertToEntityAttribute(String dbData) {
    if (Strings.isNullOrEmpty(dbData)) {
        return null;
    }

    return new X509Certificate.Type(dbData);
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
@Override
public X509CertificateEntity fromScim(X509Certificate scim) {
    X509CertificateEntity x509CertificateEntity = new X509CertificateEntity();
    x509CertificateEntity.setValue(scim.getValue());
    x509CertificateEntity.setType(scim.getType());
    x509CertificateEntity.setPrimary(scim.isPrimary());

    return x509CertificateEntity;
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
@Override
public X509Certificate toScim(X509CertificateEntity entity) {
    return new X509Certificate.Builder()
            .setValue(entity.getValue())
            .setPrimary(entity.isPrimary())
            .setType(entity.getType())
            .build();
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
public X509CertificateCommand(X509Certificate x509Certificate) {
    setDisplay(x509Certificate.getDisplay());
    setPrimary(x509Certificate.isPrimary());
    setValue(x509Certificate.getValue());

    if (x509Certificate.getType() != null) {
        setType(x509Certificate.getType().getValue());
    }
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
public X509Certificate getAsCertificate() {
    return new X509Certificate.Builder()
            .setDisplay(getDisplay())
            .setPrimary(getPrimary())
            .setValue(getValue())
            .setType(new Type(getType()))
            .build();
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
@Command(description = "Delete a certificate from the user.")
public void deleteCertificate(
		@Param(value = "searchKey", description = "Which key should be used to identify the certificate.")
		String key,
		@Param(value = "expr", description = "If the value matches this regular expression, the certificate will deleted.")
		String valueExp){
	
	Set<X509Certificate> certificates = builderCommand.showAllX509Certificates();
	for(X509Certificate current : certificates){
		if(match(current, key, valueExp)){
			builderCommand.builder.deleteX509Certificate(current);
		}
	}
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
@Command(name = "add-certificate", description = "Add a (X509)certificate for this user.", startsSubshell = true)
public void addX509Certificate() throws IOException {
	final X509Certificate x509Certificate = builderCommand.builderShellFactory.enterX509CertificateShell();
	if(x509Certificate != null){
		builderCommand.builder.addX509Certificate(x509Certificate);
	}
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
@Command(name = "show-all-certificate", description = "Show all certificates (persited and non persisted) for the user.")
public Set<X509Certificate> showAllX509Certificates(){
	Set<X509Certificate> all = new HashSet<>(user.getX509Certificates());
	all.addAll(_build().getScimConformUpdateUser().getX509Certificates());
	
	return all;
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
@Command(description = "Delete a certificate from the user.")
public void deleteCertificate(
		@Param(value = "searchKey", description = "Which key should be used to identify the certificate.")
		String key,
		@Param(value = "expr", description = "If the value matches this regular expression, the certificate will deleted.")
		String valueExp){
	
	List<X509Certificate> certificates = builderCommand.showAllX509Certificates();
	for(X509Certificate current : certificates){
		if(match(current, key, valueExp)){
			builderCommand.builder.removeX509Certificate(current);
		}
	}
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
@Override
public Object convertOutput(Object toBeFormatted) {
	if(!(toBeFormatted instanceof X509Certificate)) return null;
	
	final X509Certificate certificate = (X509Certificate)toBeFormatted;
	
	try {
		return toString(certificate);
	} catch (JsonProcessingException e) {
		return e;
	}
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
private void assertThatX509CertificatesAreEqual(List<X509Certificate> expected, List<X509Certificate> actual) {
    assertEquals(expected.size(), actual.size());
    ensureListSizeIsOne(expected);
    X509Certificate expectedValue = expected.get(0);
    X509Certificate actualValue = actual.get(0);

    assertEquals(expectedValue.getValue(), actualValue.getValue());
    assertEquals(expectedValue.isPrimary(), actualValue.isPrimary());
    assertEquals(expectedValue.getDisplay(), actualValue.getDisplay());
}
 

import org.osiam.resources.scim.X509Certificate; //导入依赖的package包/类
public X509Certificate.Type getType() {
    return type;
}