Examples with AccAccountDto eu.bcvsolutions.idm.acc.dto.AccAccountDto used on opensource projects

Example 36 with AccAccountDto

use of eu.bcvsolutions.idm.acc.dto.AccAccountDto in project CzechIdMng by bcvsolutions.

the class AbstractProvisioningExecutor method doProvisioning.

@Override
public void doProvisioning(AccAccountDto account) {
    Assert.notNull(account);
    EntityAccountFilter filter = createEntityAccountFilter();
    filter.setAccountId(account.getId());
    List<? extends EntityAccountDto> entityAccoutnList = getEntityAccountService().find(filter, null).getContent();
    if (entityAccoutnList == null) {
        return;
    }
    entityAccoutnList.stream().filter(entityAccount -> {
        return entityAccount.isOwnership();
    }).forEach((entityAccount) -> {
        doProvisioning(account, getService().get(entityAccount.getEntity()));
    });
}

Example 37 with AccAccountDto

use of eu.bcvsolutions.idm.acc.dto.AccAccountDto in project CzechIdMng by bcvsolutions.

the class AbstractProvisioningExecutor method getAccountSystemEntity.

protected AccAccountDto getAccountSystemEntity(UUID systemEntity) {
    AccAccountFilter filter = new AccAccountFilter();
    filter.setSystemEntityId(systemEntity);
    List<AccAccountDto> accounts = this.accountService.find(filter, null).getContent();
    if (accounts.isEmpty()) {
        return null;
    } else {
        // We assume that system entity has only one account!
        return accounts.get(0);
    }
}

Example 38 with AccAccountDto

use of eu.bcvsolutions.idm.acc.dto.AccAccountDto in project CzechIdMng by bcvsolutions.

the class AbstractSynchronizationExecutor method updateAccountUid.

/**
 * Update account UID from system. UID mapped attribute must exist and returned
 * value must be not null and must be String
 *
 * @param logItem
 * @param account
 * @param mappedAttributes
 * @param icAttributes
 * @param system
 */
private void updateAccountUid(SynchronizationContext context) {
    Assert.notNull(context, "Context is required!");
    SysSyncItemLogDto logItem = context.getLogItem();
    AccAccountDto account = context.getAccount();
    // Generate UID value from mapped attribute marked as UID (Unique ID).
    // UID mapped attribute must exist and returned value must be not null
    // and must be String
    String attributeUid = this.generateUID(context);
    if (!account.getUid().equals(attributeUid)) {
        addToItemLog(logItem, MessageFormat.format("IdM Account UID ({0}) is different ({1}). We will update him.", account.getUid(), attributeUid));
        account.setUid(attributeUid);
        account = accountService.save(account);
    }
}

Example 39 with AccAccountDto

use of eu.bcvsolutions.idm.acc.dto.AccAccountDto in project CzechIdMng by bcvsolutions.

the class AbstractSynchronizationExecutor method doItemSynchronization.

@Override
public boolean doItemSynchronization(SynchronizationContext context) {
    Assert.notNull(context);
    String uid = context.getUid();
    IcConnectorObject icObject = context.getIcObject();
    IcSyncDeltaTypeEnum type = context.getType();
    AbstractSysSyncConfigDto config = context.getConfig();
    SysSystemDto system = context.getSystem();
    SystemEntityType entityType = context.getEntityType();
    AccAccountDto account = context.getAccount();
    SysSyncLogDto log = context.getLog();
    SysSyncItemLogDto logItem = context.getLogItem();
    List<SysSyncActionLogDto> actionLogs = context.getActionLogs();
    // Set default unknown action type
    context.addActionType(SynchronizationActionType.UNKNOWN);
    try {
        // Find system entity for uid
        SysSystemEntityDto systemEntity = findSystemEntity(uid, system, entityType);
        context.addSystemEntity(systemEntity);
        // Find acc account for uid or system entity
        if (account == null) {
            account = findAccount(context);
            if (systemEntity == null) {
                addToItemLog(logItem, "SystemEntity for this uid doesn't exist. We will create it.");
                systemEntity = createSystemEntity(uid, entityType, system);
            }
        }
        context.addSystemEntity(systemEntity).addAccount(account);
        if (IcSyncDeltaTypeEnum.CREATE == type || IcSyncDeltaTypeEnum.UPDATE == type || IcSyncDeltaTypeEnum.CREATE_OR_UPDATE == type) {
            // Update or create
            Assert.notNull(icObject);
            List<IcAttribute> icAttributes = icObject.getAttributes();
            if (account == null) {
                // Account doesn't exist in IDM
                resolveAccountNotExistSituation(context, systemEntity, icAttributes);
            } else {
                // Account exist in IdM (LINKED)
                context.addActionType(config.getLinkedAction().getAction());
                SynchronizationSituationType situation = SynchronizationSituationType.LINKED;
                if (StringUtils.hasLength(config.getLinkedActionWfKey())) {
                    SynchronizationLinkedActionType linkedAction = config.getLinkedAction();
                    SynchronizationActionType action = linkedAction.getAction();
                    // We will start specific workflow
                    startWorkflow(config.getLinkedActionWfKey(), situation, action, null, context);
                } else {
                    resolveLinkedSituation(config.getLinkedAction(), context);
                }
                addToItemLog(logItem, "Account exist in IdM (LINKED) - ended");
            }
        } else if (IcSyncDeltaTypeEnum.DELETE == type) {
            // Missing account situation, can be call from connector
            // (support delete account event) and from reconciliation
            context.addActionType(config.getMissingAccountAction().getAction());
            SynchronizationSituationType situation = SynchronizationSituationType.MISSING_ACCOUNT;
            if (StringUtils.hasLength(config.getMissingAccountActionWfKey())) {
                ReconciliationMissingAccountActionType missingAccountActionType = config.getMissingAccountAction();
                SynchronizationActionType action = missingAccountActionType.getAction();
                // We will start specific workflow
                startWorkflow(config.getMissingAccountActionWfKey(), situation, action, null, context);
            } else {
                // Resolve missing account situation for one item
                this.resolveMissingAccountSituation(config.getMissingAccountAction(), context);
            }
        } else if (context.isExportAction()) {
            // Export situation - create account to system
            this.resolveUnlinkedSituation(SynchronizationUnlinkedActionType.LINK_AND_UPDATE_ACCOUNT, context);
        }
        // Call hard hibernate session flush and clear
        if (getHibernateSession().isOpen()) {
            getHibernateSession().flush();
            getHibernateSession().clear();
        }
        return true;
    } catch (Exception e) {
        loggingException(context.getActionType(), log, logItem, actionLogs, uid, e);
        throw e;
    }
}

Example 40 with AccAccountDto

use of eu.bcvsolutions.idm.acc.dto.AccAccountDto in project CzechIdMng by bcvsolutions.

the class AbstractSynchronizationExecutor method resolveLinkedSituation.

/**
 * Method for resolve linked situation for one item.
 */
@Override
public void resolveLinkedSituation(SynchronizationLinkedActionType action, SynchronizationContext context) {
    SystemEntityType entityType = context.getEntityType();
    SysSyncLogDto log = context.getLog();
    SysSyncItemLogDto logItem = context.getLogItem();
    List<SysSyncActionLogDto> actionLogs = context.getActionLogs();
    AccAccountDto account = context.getAccount();
    addToItemLog(logItem, MessageFormat.format("IdM Account ({0}) exists in IDM (LINKED)", account.getUid()));
    addToItemLog(logItem, MessageFormat.format("Linked action is {0}", action));
    switch(action) {
        case IGNORE:
            // Linked action is IGNORE. We will do nothing
            initSyncActionLog(SynchronizationActionType.LINKED, OperationResultType.IGNORE, logItem, log, actionLogs);
            return;
        case UNLINK:
            // Linked action is UNLINK
            updateAccountUid(context);
            doUnlink(account, false, log, logItem, actionLogs);
            initSyncActionLog(SynchronizationActionType.UNLINK, OperationResultType.SUCCESS, logItem, log, actionLogs);
            return;
        case UNLINK_AND_REMOVE_ROLE:
            // Linked action is UNLINK_AND_REMOVE_ROLE
            updateAccountUid(context);
            doUnlink(account, true, log, logItem, actionLogs);
            initSyncActionLog(SynchronizationActionType.UNLINK, OperationResultType.SUCCESS, logItem, log, actionLogs);
            return;
        case UPDATE_ENTITY:
            // Linked action is UPDATE_ENTITY
            updateAccountUid(context);
            doUpdateEntity(context);
            initSyncActionLog(SynchronizationActionType.UPDATE_ENTITY, OperationResultType.SUCCESS, logItem, log, actionLogs);
            return;
        case UPDATE_ACCOUNT:
            // Linked action is UPDATE_ACCOUNT
            updateAccountUid(context);
            doUpdateAccount(account, entityType, log, logItem, actionLogs);
            initSyncActionLog(SynchronizationActionType.UPDATE_ACCOUNT, OperationResultType.SUCCESS, logItem, log, actionLogs);
            return;
        default:
            break;
    }
}