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

    if (attributes.contains("entitlements")) {
        userEntity.removeAllEntitlements();
    }

    if (entitlements != null) {
        for (Entitlement scimEntitlements : entitlements) {
            EntitlementEntity entitlementsEntity = entitlementConverter.fromScim(scimEntitlements);
            userEntity.removeEntitlement(entitlementsEntity); // we always have to remove the entitlement's in case
            // the primary attribute has changed
            if (Strings.isNullOrEmpty(scimEntitlements.getOperation())
                    || !scimEntitlements.getOperation().equalsIgnoreCase("delete")) {

                ensureOnlyOnePrimaryEntitlementExists(entitlementsEntity, userEntity.getEntitlements());
                userEntity.addEntitlement(entitlementsEntity);
            }
        }
    }
}
 

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

	Set<Entitlement> entitlements = builderCommand.showAllEntitlements();
	for(Entitlement current : entitlements){
		if(match(current, key, valueExp)){
			final Entitlement entitlement = builderCommand.builderShellFactory.enterEntitlementShell(current);
			if(entitlement != null){
				builderCommand.builder.updateEntitlement(current, entitlement);
			}
		}
	}
}
 

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

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

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

	subShell.commandLoop();

	return entitlementBuilder.build();
}
 

import org.osiam.resources.scim.Entitlement; //导入依赖的package包/类
private void updateEntitlement(UpdateUser.Builder updateBuilder, List<Entitlement> entitlements, String value) {
    Entitlement newEntitlement = new Entitlement.Builder().setValue(value)
            .setType(new Entitlement.Type(LdapAuthentication.LDAP_PROVIDER)).build();
    for (Entitlement entitlement : entitlements) {
        if (entitlement.getType() != null
                && entitlement.getType().toString().equals(LdapAuthentication.LDAP_PROVIDER)) {
            updateBuilder.deleteEntitlement(entitlement);
        }
    }
    updateBuilder.addEntitlement(newEntitlement);
}
 

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

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

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

    return attribute.getValue();
}
 

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

    return new Entitlement.Type(dbData);
}
 

import org.osiam.resources.scim.Entitlement; //导入依赖的package包/类
@Override
public EntitlementEntity fromScim(Entitlement scim) {
    EntitlementEntity entitlementsEntity = new EntitlementEntity();
    entitlementsEntity.setValue(String.valueOf(scim.getValue()));
    entitlementsEntity.setType(scim.getType());
    entitlementsEntity.setPrimary(scim.isPrimary());

    return entitlementsEntity;
}
 

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

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

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

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

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

import org.osiam.resources.scim.Entitlement; //导入依赖的package包/类
@Command(description = "Add an entitlement for this user.", startsSubshell = true)
public void addEntitlement() throws IOException {
	final Entitlement entitlement = builderCommand.builderShellFactory.enterEntitlementShell();
	if(entitlement != null){
		builderCommand.builder.addEntitlement(entitlement);
	}
}
 

import org.osiam.resources.scim.Entitlement; //导入依赖的package包/类
@Command(description = "Show all entitlements (persited and non persisted) for the user.")
public Set<Entitlement> showAllEntitlements(){
	Set<Entitlement> all = new HashSet<>(user.getEntitlements());
	all.addAll(_build().getScimConformUpdateUser().getEntitlements());
	
	return all;
}
 

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

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

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

        Entitlement entitlement = new Entitlement.Builder()
                .setPrimary(true)
                .setType(new Entitlement.Type(IRRELEVANT))
                .setValue("entitlement" + countCurrentUser)
                .build();

        ArrayList<Entitlement> entitlements = new ArrayList<Entitlement>();
        entitlements.add(entitlement);

        return entitlements;
    }
 

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

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

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