How to use

UserFederationProviderModel

in

org.keycloak.models

public static UserFederationProviderRepresentation toRepresentation(UserFederationProviderModel model) {
  UserFederationProviderRepresentation rep = new UserFederationProviderRepresentation();
  rep.setId(model.getId());
  rep.setConfig(model.getConfig());
  rep.setProviderName(model.getProviderName());
  rep.setPriority(model.getPriority());
  rep.setDisplayName(model.getDisplayName());
  rep.setFullSyncPeriod(model.getFullSyncPeriod());
  rep.setChangedSyncPeriod(model.getChangedSyncPeriod());
  rep.setLastSync(model.getLastSync());
  return rep;
}

public PartitionManager getPartitionManager(UserFederationProviderModel model) {
  PartitionManagerContext context = partitionManagers.get(model.getId());
  // Ldap config might have changed for the realm. In this case, we must re-initialize
  Map<String, String> config = model.getConfig();
  if (context == null || !config.equals(context.config)) {
    logLDAPConfig(model.getId(), config);
    PartitionManager manager = createPartitionManager(config);
    context = new PartitionManagerContext(config, manager);
    partitionManagers.put(model.getId(), context);
  }
  return context.partitionManager;
}

/**
 * Ensure that displayName of myProvider (if not null) is unique and there is no other provider with same displayName in the list.
 *
 * @param displayName         to check for duplications
 * @param myProvider          provider, which is excluded from the list (if present)
 * @param federationProviders
 * @throws ModelDuplicateException if there is other provider with same displayName
 */
public static void ensureUniqueDisplayName(String displayName, UserFederationProviderModel myProvider, List<UserFederationProviderModel> federationProviders) throws ModelDuplicateException {
  if (displayName != null) {
    for (UserFederationProviderModel federationProvider : federationProviders) {
      if (myProvider != null && (myProvider.equals(federationProvider) || (myProvider.getId() != null && myProvider.getId().equals(federationProvider.getId())))) {
        continue;
      }
      if (displayName.equals(federationProvider.getDisplayName())) {
        throw new ModelDuplicateException("There is already existing federation provider with display name: " + displayName);
      }
    }
  }
}

public void migrate(KeycloakSession session) {
  List<RealmModel> realms = session.realms().getRealms();
  for (RealmModel realm : realms) {
    List<UserFederationProviderModel> federationProviders = realm.getUserFederationProviders();
    for (UserFederationProviderModel fedProvider : federationProviders) {
      if (fedProvider.getProviderName().equals(LDAPConstants.LDAP_PROVIDER)) {
        Map<String, String> config = fedProvider.getConfig();
        if (isActiveDirectory(config)) {
          // Create mapper for MSAD account controls
          if (realm.getUserFederationMapperByName(fedProvider.getId(), "MSAD account controls") == null) {
            UserFederationMapperModel mapperModel = KeycloakModelUtils.createUserFederationMapperModel("MSAD account controls", fedProvider.getId(), LDAPConstants.MSAD_USER_ACCOUNT_CONTROL_MAPPER);
            realm.addUserFederationMapper(mapperModel);
          }
        }
      }
    }
  }
}

public static UserFederationProviderModel findUserFederationProviderById(String fedProviderId, RealmModel realm) {
  for (UserFederationProviderModel fedProvider : realm.getUserFederationProviders()) {
    if (fedProviderId.equals(fedProvider.getId())) {
      return fedProvider;
    }
  }
  return null;
}

public static UserFederationProviderModel findUserFederationProviderByDisplayName(String displayName, RealmModel realm) {
  if (displayName == null) {
    return null;
  }
  for (UserFederationProviderModel fedProvider : realm.getUserFederationProviders()) {
    if (displayName.equals(fedProvider.getDisplayName())) {
      return fedProvider;
    }
  }
  return null;
}

@Override
public void onEvent(ProviderEvent event) {
  if (event instanceof RealmModel.UserFederationProviderCreationEvent) {
    RealmModel.UserFederationProviderCreationEvent fedCreationEvent = (RealmModel.UserFederationProviderCreationEvent)event;
    UserFederationProviderModel providerModel = fedCreationEvent.getCreatedFederationProvider();
    if (providerModel.getProviderName().equals(getId())) {
      onProviderModelCreated(fedCreationEvent.getRealm(), providerModel);
    }
  }
}

private static List<UserFederationProviderModel> convertFederationProviders(List<UserFederationProviderRepresentation> providers) {
  List<UserFederationProviderModel> result = new ArrayList<UserFederationProviderModel>();
  for (UserFederationProviderRepresentation representation : providers) {
    UserFederationProviderModel model = new UserFederationProviderModel(representation.getId(), representation.getProviderName(),
        representation.getConfig(), representation.getPriority(), representation.getDisplayName(),
        representation.getFullSyncPeriod(), representation.getChangedSyncPeriod(), representation.getLastSync());
    result.add(model);
  }
  return result;
}

for (UserFederationProviderModel fedProvider : federationProviders) {
  if (fedProvider.getProviderName().equals(LDAPConstants.LDAP_PROVIDER)) {
    Map<String, String> config = fedProvider.getConfig();
    Set<UserFederationMapperModel> mappers = realm.getUserFederationMappersByFederationProvider(fedProvider.getId());
    if (mappers.isEmpty()) {
      UserFederationProviderFactory ldapFactory = (UserFederationProviderFactory) session.getKeycloakSessionFactory().getProviderFactory(UserFederationProvider.class, LDAPConstants.LDAP_PROVIDER);

if (providerName.equals(providerModel.getDisplayName())) {
  Set<UserFederationMapperModel> toDelete = newRealm.getUserFederationMappersByFederationProvider(providerModel.getId());
  for (UserFederationMapperModel mapperModel : toDelete) {
    newRealm.removeUserFederationMapper(mapperModel);

protected UserFederationProvider getFederationLink(RealmModel realm, UserModel user) {
  if (user.getFederationLink() == null) return null;
  for (UserFederationProviderModel fed : realm.getUserFederationProviders()) {
    if (fed.getId().equals(user.getFederationLink())) {
      return getFederationProvider(fed);
    }
  }
  return null;
}

public static UserFederationMapperRepresentation toRepresentation(RealmModel realm, UserFederationMapperModel model) {
  UserFederationMapperRepresentation rep = new UserFederationMapperRepresentation();
  rep.setId(model.getId());
  rep.setName(model.getName());
  rep.setFederationMapperType(model.getFederationMapperType());
  Map<String, String> config = new HashMap<String, String>();
  config.putAll(model.getConfig());
  rep.setConfig(config);
  UserFederationProviderModel fedProvider = KeycloakModelUtils.findUserFederationProviderById(model.getFederationProviderId(), realm);
  if (fedProvider == null) {
    throw new ModelException("Couldn't find federation provider with ID " + model.getId());
  }
  rep.setFederationProviderDisplayName(fedProvider.getDisplayName());
  return rep;
}

protected UserFederationProvider getFederationProvider(UserFederationProviderModel model) {
  UserFederationProviderFactory factory = (UserFederationProviderFactory)session.getKeycloakSessionFactory().getProviderFactory(UserFederationProvider.class, model.getProviderName());
  return factory.getInstance(session, model);
}

protected UserModel registerWithFederation(RealmModel realm, UserModel user) {
  for (UserFederationProviderModel federation : realm.getUserFederationProviders()) {
    UserFederationProvider fed = getFederationProvider(federation);
    if (fed.synchronizeRegistrations()) {
      user.setFederationLink(federation.getId());
      UserModel registered = fed.register(realm, user);
      managedUsers.put(registered.getId(), registered);
      return registered;
    }
  }
  return user;
}

public static UserFederationMapperModel toModel(RealmModel realm, UserFederationMapperRepresentation rep) {
  UserFederationMapperModel model = new UserFederationMapperModel();
  model.setId(rep.getId());
  model.setName(rep.getName());
  model.setFederationMapperType(rep.getFederationMapperType());
  model.setConfig(rep.getConfig());
  UserFederationProviderModel fedProvider = KeycloakModelUtils.findUserFederationProviderByDisplayName(rep.getFederationProviderDisplayName(), realm);
  if (fedProvider == null) {
    throw new ModelException("Couldn't find federation provider with display name [" + rep.getFederationProviderDisplayName() + "] referenced from mapper ["
        + rep.getName());
  }
  model.setFederationProviderId(fedProvider.getId());
  return model;
}