Examples with IdmFormAttributeDto eu.bcvsolutions.idm.core.eav.api.dto.IdmFormAttributeDto used on opensource projects

Example 1 with IdmFormAttributeDto

use of eu.bcvsolutions.idm.core.eav.api.dto.IdmFormAttributeDto in project CzechIdMng by bcvsolutions.

the class DefaultIdmAutomaticRoleAttributeRuleService method save.

@Override
public IdmAutomaticRoleAttributeRuleDto save(IdmAutomaticRoleAttributeRuleDto dto, BasePermission... permission) {
    // now isn't possible do equals with string_value (clob), so it is necessary to use only short text
    if ((AutomaticRoleAttributeRuleType.CONTRACT_EAV == dto.getType() || AutomaticRoleAttributeRuleType.IDENTITY_EAV == dto.getType()) && dto.getFormAttribute() != null) {
        initFormAttributeService();
        IdmFormAttributeDto formAttribute = formAttributeService.get(dto.getFormAttribute());
        if (formAttribute == null) {
            throw new ResultCodeException(CoreResultCode.NOT_FOUND, ImmutableMap.of("attribute", dto.getFormAttribute()));
        }
        if (formAttribute.getPersistentType() == PersistentType.TEXT) {
            throw new ResultCodeException(CoreResultCode.AUTOMATIC_ROLE_RULE_PERSISTENT_TYPE_TEXT);
        }
    }
    // check if is filled all necessary attribute
    if ((dto.getType() == AutomaticRoleAttributeRuleType.CONTRACT || dto.getType() == AutomaticRoleAttributeRuleType.IDENTITY) && StringUtils.isEmpty(dto.getAttributeName())) {
        throw new ResultCodeException(CoreResultCode.AUTOMATIC_ROLE_RULE_ATTRIBUTE_EMPTY, ImmutableMap.of("automaticRoleId", dto.getId(), "attribute", IdmAutomaticRoleAttributeRule_.attributeName.getName()));
    }
    if ((dto.getType() == AutomaticRoleAttributeRuleType.IDENTITY_EAV || dto.getType() == AutomaticRoleAttributeRuleType.CONTRACT_EAV) && dto.getAutomaticRoleAttribute() == null) {
        throw new ResultCodeException(CoreResultCode.AUTOMATIC_ROLE_RULE_ATTRIBUTE_EMPTY, ImmutableMap.of("automaticRoleId", dto.getId(), "attribute", IdmAutomaticRoleAttributeRule_.automaticRoleAttribute.getName()));
    }
    if (dto.getComparison() == AutomaticRoleAttributeRuleComparison.EQUALS && dto.getValue() == null) {
        throw new ResultCodeException(CoreResultCode.AUTOMATIC_ROLE_RULE_ATTRIBUTE_EMPTY, ImmutableMap.of("attribute", IdmAutomaticRoleAttributeRule_.value.getName()));
    }
    // throw new event
    if (isNew(dto)) {
        return entityEventManager.process(new AutomaticRoleAttributeRuleEvent(AutomaticRoleAttributeRuleEventType.CREATE, dto)).getContent();
    }
    return entityEventManager.process(new AutomaticRoleAttributeRuleEvent(AutomaticRoleAttributeRuleEventType.UPDATE, dto)).getContent();
}

Example 2 with IdmFormAttributeDto

use of eu.bcvsolutions.idm.core.eav.api.dto.IdmFormAttributeDto in project CzechIdMng by bcvsolutions.

the class DefaultFormService method saveFormInstance.

/**
 * {@inheritDoc}
 *
 * TODO: validations by given form definition? I don't think, it will not be
 * useful in synchronization etc. - only FE validations will be enough ...
 */
@Override
@Transactional
public IdmFormInstanceDto saveFormInstance(Identifiable owner, IdmFormDefinitionDto formDefinition, List<IdmFormValueDto> values) {
    FormableEntity ownerEntity = getOwnerEntity(owner);
    Assert.notNull(values, "Form values are required!");
    Assert.notNull(ownerEntity, "Form values owner is required!");
    formDefinition = checkDefaultDefinition(ownerEntity.getClass(), formDefinition);
    // 
    FormValueService<FormableEntity> formValueService = getFormValueService(ownerEntity);
    // 
    Map<UUID, IdmFormValueDto> previousValues = new HashMap<>();
    formValueService.getValues(ownerEntity, formDefinition).forEach(formValue -> {
        previousValues.put(formValue.getId(), formValue);
    });
    // 
    List<IdmFormValueDto> results = new ArrayList<>();
    for (IdmFormValueDto value : values) {
        // value could contant attribute id only
        UUID attributeId = value.getFormAttribute();
        Assert.notNull(attributeId, "Form attribute is required");
        IdmFormAttributeDto attribute = formDefinition.getMappedAttribute(attributeId);
        Assert.notNull(attribute, "Form attribute is required");
        // 
        value.setOwnerAndAttribute(ownerEntity, attribute);
        // 
        IdmFormValueDto previousValue = value.getId() == null ? null : previousValues.get(value.getId());
        if (previousValue != null) {
            // saved values will not be removed
            previousValues.remove(value.getId());
            // confidential value is always updated - only new values are sent from client
            if (value.isConfidential() || !value.isEquals(previousValue)) {
                // update value
                results.add(formValueService.save(value));
                LOG.trace("FormValue [{}:{}] for owner [{}] was updated", attribute.getCode(), value.getId(), ownerEntity);
            }
        } else {
            // create new value
            results.add(formValueService.save(value));
            LOG.trace("FormValue [{}:{}] for owner [{}] was created", attribute.getCode(), value.getId(), ownerEntity);
        }
    }
    // 
    // remove unsaved values by attribute definition (patch method is not
    // implemented now)
    previousValues.values().stream().filter(formValue -> {
        // they could not be sent with form (only changed values)
        return !formValue.isConfidential();
    }).forEach(value -> {
        formValueService.delete(value);
        LOG.trace("FormValue [{}:{}] for owner [{}] was deleted", value.getFormAttribute(), value.getId(), ownerEntity);
    });
    // publish event - eav was saved
    if (lookupService.getDtoLookup(ownerEntity.getClass()) == null) {
        // TODO: remove this branch after all agends will be rewritten to dto usage
        entityEventManager.process(new CoreEvent<>(CoreEventType.EAV_SAVE, ownerEntity));
    } else {
        entityEventManager.process(new CoreEvent<>(CoreEventType.EAV_SAVE, lookupService.lookupDto(ownerEntity.getClass(), ownerEntity.getId())));
    }
    // 
    return new IdmFormInstanceDto(ownerEntity, formDefinition, results);
}

Example 3 with IdmFormAttributeDto

use of eu.bcvsolutions.idm.core.eav.api.dto.IdmFormAttributeDto in project CzechIdMng by bcvsolutions.

the class DefaultIdmFormDefinitionService method updateDefinition.

@Override
@Transactional
public IdmFormDefinitionDto updateDefinition(String definitionType, String definitionCode, List<IdmFormAttributeDto> attributes) {
    Assert.notNull(definitionType);
    // 
    IdmFormDefinitionDto formDefinition = findOneByTypeAndCode(definitionType, definitionCode);
    if (formDefinition == null) {
        formDefinition = new IdmFormDefinitionDto();
        formDefinition.setType(definitionType);
        formDefinition.setCode(definitionCode);
        // TODO: we don't set definition to unmodifiable - some changes can be done through ui?
        formDefinition = save(formDefinition);
    }
    // 
    if (attributes == null || attributes.isEmpty()) {
        // change script has to be provided
        return formDefinition;
    }
    // upgrade definition
    boolean changed = false;
    Short seq = 0;
    for (IdmFormAttributeDto attribute : attributes) {
        // update seq - attributes can be simply given in different order
        if (attribute.getSeq() == null) {
            attribute.setSeq(seq);
        }
        IdmFormAttributeDto savedAttribute = formAttributeService.findAttribute(formDefinition.getType(), formDefinition.getCode(), attribute.getCode());
        if (savedAttribute == null) {
            savedAttribute = attribute;
            savedAttribute.setFormDefinition(formDefinition.getId());
            if (savedAttribute.getSeq() == null) {
                savedAttribute.setSeq(seq);
            }
            // 
            formAttributeService.save(savedAttribute);
            changed = true;
        } else {
            // throw exception, if incompatible change was found
            checkIncompatibleChanges(formDefinition, savedAttribute, attribute);
            // save compatible changes
            if (compareCompatibleChanges(savedAttribute, attribute) != 0) {
                // update attribute - compatible changes
                savedAttribute.setSeq(attribute.getSeq());
                savedAttribute.setName(attribute.getName());
                savedAttribute.setFaceType(attribute.getFaceType());
                savedAttribute.setReadonly(attribute.isReadonly());
                savedAttribute.setRequired(attribute.isRequired());
                savedAttribute.setDefaultValue(attribute.getDefaultValue());
                savedAttribute.setDescription(attribute.getDescription());
                savedAttribute.setMultiple(attribute.isMultiple());
                savedAttribute.setPlaceholder(attribute.getPlaceholder());
                savedAttribute.setUnmodifiable(attribute.isUnmodifiable());
                formAttributeService.save(savedAttribute);
                changed = true;
            }
        }
        seq++;
    }
    if (changed) {
        formDefinition = get(formDefinition.getId());
    }
    return formDefinition;
}

Example 4 with IdmFormAttributeDto

use of eu.bcvsolutions.idm.core.eav.api.dto.IdmFormAttributeDto in project CzechIdMng by bcvsolutions.

the class InitDemoData method init.

protected void init() {
    // we need to be ensured admin and and admin role exists.
    initApplicationData.init();
    // 
    securityService.setSystemAuthentication();
    // 
    try {
        IdmIdentityDto identityAdmin = this.identityService.getByUsername(InitApplicationData.ADMIN_USERNAME);
        // 
        Page<IdmTreeNodeDto> rootsList = treeNodeService.findRoots((UUID) null, new PageRequest(0, 1));
        IdmTreeNodeDto rootOrganization = null;
        if (!rootsList.getContent().isEmpty()) {
            rootOrganization = rootsList.getContent().get(0);
        } else {
            IdmTreeNodeDto organizationRoot = new IdmTreeNodeDto();
            organizationRoot.setCode("root");
            organizationRoot.setName("Organization ROOT");
            organizationRoot.setTreeType(treeTypeService.getByCode(InitApplicationData.DEFAULT_TREE_TYPE).getId());
            organizationRoot = this.treeNodeService.save(organizationRoot);
        }
        // 
        if (!configurationService.getBooleanValue(PARAMETER_DEMO_DATA_CREATED, false)) {
            LOG.info("Creating demo data ...");
            // 
            // create default password policy for validate
            IdmPasswordPolicyDto passValidate = null;
            try {
                passValidate = this.passwordPolicyService.getDefaultPasswordPolicy(IdmPasswordPolicyType.VALIDATE);
            } catch (ResultCodeException e) {
            // nothing, password policy for validate not exist
            }
            // default password policy not exist, try to found by name
            if (passValidate == null) {
                passValidate = this.passwordPolicyService.findOneByName("DEFAULT_VALIDATE_POLICY");
            }
            // if password policy still not exist create default password policy
            if (passValidate == null) {
                passValidate = new IdmPasswordPolicyDto();
                passValidate.setName("DEFAULT_VALIDATE_POLICY");
                passValidate.setDefaultPolicy(true);
                passValidate.setType(IdmPasswordPolicyType.VALIDATE);
                passwordPolicyService.save(passValidate);
            }
            // 
            // create default password policy for generate
            IdmPasswordPolicyDto passGenerate = null;
            try {
                passGenerate = this.passwordPolicyService.getDefaultPasswordPolicy(IdmPasswordPolicyType.GENERATE);
            } catch (ResultCodeException e) {
            // nothing, password policy for generate password not exist
            }
            // try to found password policy by name
            if (passGenerate == null) {
                passGenerate = this.passwordPolicyService.findOneByName("DEFAULT_GENERATE_POLICY");
            }
            // if still not exist create default generate password policy
            if (passGenerate == null) {
                passGenerate = new IdmPasswordPolicyDto();
                passGenerate.setName("DEFAULT_GENERATE_POLICY");
                passGenerate.setDefaultPolicy(true);
                passGenerate.setType(IdmPasswordPolicyType.GENERATE);
                passGenerate.setMinLowerChar(2);
                passGenerate.setMinNumber(2);
                passGenerate.setMinSpecialChar(2);
                passGenerate.setMinUpperChar(2);
                passGenerate.setMinPasswordLength(8);
                passGenerate.setMaxPasswordLength(12);
                passwordPolicyService.save(passGenerate);
            }
            // 
            // role may exists from another module initialization
            IdmRoleDto role1 = this.roleService.getByCode(DEFAULT_ROLE_NAME);
            if (role1 == null) {
                role1 = new IdmRoleDto();
                role1.setName(DEFAULT_ROLE_NAME);
                role1 = this.roleService.save(role1);
            }
            // self policy
            IdmAuthorizationPolicyDto selfPolicy = new IdmAuthorizationPolicyDto();
            selfPolicy.setPermissions(IdmBasePermission.AUTOCOMPLETE, IdmBasePermission.READ, IdentityBasePermission.PASSWORDCHANGE, IdentityBasePermission.CHANGEPERMISSION);
            selfPolicy.setRole(role1.getId());
            selfPolicy.setGroupPermission(CoreGroupPermission.IDENTITY.getName());
            selfPolicy.setAuthorizableType(IdmIdentity.class.getCanonicalName());
            selfPolicy.setEvaluator(SelfIdentityEvaluator.class);
            authorizationPolicyService.save(selfPolicy);
            // read identity roles by identity
            IdmAuthorizationPolicyDto identityRolePolicy = new IdmAuthorizationPolicyDto();
            identityRolePolicy.setRole(role1.getId());
            identityRolePolicy.setGroupPermission(CoreGroupPermission.IDENTITYROLE.getName());
            identityRolePolicy.setAuthorizableType(IdmIdentityRole.class.getCanonicalName());
            identityRolePolicy.setEvaluator(IdentityRoleByIdentityEvaluator.class);
            authorizationPolicyService.save(identityRolePolicy);
            // read identity contracts by identity
            IdmAuthorizationPolicyDto identityContractPolicy = new IdmAuthorizationPolicyDto();
            identityContractPolicy.setRole(role1.getId());
            identityContractPolicy.setGroupPermission(CoreGroupPermission.IDENTITYCONTRACT.getName());
            identityContractPolicy.setAuthorizableType(IdmIdentityContract.class.getCanonicalName());
            identityContractPolicy.setEvaluator(IdentityContractByIdentityEvaluator.class);
            authorizationPolicyService.save(identityContractPolicy);
            // read contract guarantees by identity contract
            IdmAuthorizationPolicyDto contractGuaranteePolicy = new IdmAuthorizationPolicyDto();
            contractGuaranteePolicy.setRole(role1.getId());
            contractGuaranteePolicy.setGroupPermission(CoreGroupPermission.CONTRACTGUARANTEE.getName());
            contractGuaranteePolicy.setAuthorizableType(IdmContractGuarantee.class.getCanonicalName());
            contractGuaranteePolicy.setEvaluator(ContractGuaranteeByIdentityContractEvaluator.class);
            authorizationPolicyService.save(contractGuaranteePolicy);
            // only autocomplete roles that can be requested
            IdmAuthorizationPolicyDto applyForPolicy = new IdmAuthorizationPolicyDto();
            applyForPolicy.setPermissions(IdmBasePermission.AUTOCOMPLETE);
            applyForPolicy.setRole(role1.getId());
            applyForPolicy.setGroupPermission(CoreGroupPermission.ROLE.getName());
            applyForPolicy.setAuthorizableType(IdmRole.class.getCanonicalName());
            applyForPolicy.setEvaluator(RoleCanBeRequestedEvaluator.class);
            authorizationPolicyService.save(applyForPolicy);
            // role requests by identity
            IdmAuthorizationPolicyDto roleRequestByIdentityPolicy = new IdmAuthorizationPolicyDto();
            roleRequestByIdentityPolicy.setRole(role1.getId());
            roleRequestByIdentityPolicy.setGroupPermission(CoreGroupPermission.ROLEREQUEST.getName());
            roleRequestByIdentityPolicy.setAuthorizableType(IdmRoleRequest.class.getCanonicalName());
            roleRequestByIdentityPolicy.setEvaluator(RoleRequestByIdentityEvaluator.class);
            authorizationPolicyService.save(roleRequestByIdentityPolicy);
            // self role requests
            IdmAuthorizationPolicyDto selfRoleRequestPolicy = new IdmAuthorizationPolicyDto();
            selfRoleRequestPolicy.setPermissions(IdmBasePermission.READ, IdmBasePermission.UPDATE, IdmBasePermission.CREATE, IdmBasePermission.DELETE);
            selfRoleRequestPolicy.setRole(role1.getId());
            selfRoleRequestPolicy.setGroupPermission(CoreGroupPermission.ROLEREQUEST.getName());
            selfRoleRequestPolicy.setAuthorizableType(IdmRoleRequest.class.getCanonicalName());
            selfRoleRequestPolicy.setEvaluator(SelfRoleRequestEvaluator.class);
            authorizationPolicyService.save(selfRoleRequestPolicy);
            // role rerquests in approval
            IdmAuthorizationPolicyDto roleRequestByWfPolicy = new IdmAuthorizationPolicyDto();
            roleRequestByWfPolicy.setPermissions(IdmBasePermission.READ, IdmBasePermission.UPDATE);
            roleRequestByWfPolicy.setRole(role1.getId());
            roleRequestByWfPolicy.setGroupPermission(CoreGroupPermission.ROLEREQUEST.getName());
            roleRequestByWfPolicy.setAuthorizableType(IdmRoleRequest.class.getCanonicalName());
            roleRequestByWfPolicy.setEvaluator(RoleRequestByWfInvolvedIdentityEvaluator.class);
            authorizationPolicyService.save(roleRequestByWfPolicy);
            // tree node - autocomplete
            IdmAuthorizationPolicyDto treeNodePolicy = new IdmAuthorizationPolicyDto();
            treeNodePolicy.setPermissions(IdmBasePermission.AUTOCOMPLETE);
            treeNodePolicy.setRole(role1.getId());
            treeNodePolicy.setGroupPermission(CoreGroupPermission.TREENODE.getName());
            treeNodePolicy.setAuthorizableType(IdmTreeNode.class.getCanonicalName());
            treeNodePolicy.setEvaluator(BasePermissionEvaluator.class);
            authorizationPolicyService.save(treeNodePolicy);
            // tree type - autocomplete all
            IdmAuthorizationPolicyDto treeTypePolicy = new IdmAuthorizationPolicyDto();
            treeTypePolicy.setPermissions(IdmBasePermission.AUTOCOMPLETE);
            treeTypePolicy.setRole(role1.getId());
            treeTypePolicy.setGroupPermission(CoreGroupPermission.TREETYPE.getName());
            treeTypePolicy.setAuthorizableType(IdmTreeType.class.getCanonicalName());
            treeTypePolicy.setEvaluator(BasePermissionEvaluator.class);
            authorizationPolicyService.save(treeTypePolicy);
            // workflow task read and execute
            IdmAuthorizationPolicyDto workflowTaskPolicy = new IdmAuthorizationPolicyDto();
            workflowTaskPolicy.setPermissions(IdmBasePermission.READ, IdmBasePermission.EXECUTE);
            workflowTaskPolicy.setRole(role1.getId());
            workflowTaskPolicy.setGroupPermission(CoreGroupPermission.WORKFLOWTASK.getName());
            workflowTaskPolicy.setEvaluator(BasePermissionEvaluator.class);
            authorizationPolicyService.save(workflowTaskPolicy);
            // 
            LOG.info(MessageFormat.format("Role created [id: {0}]", role1.getId()));
            // 
            IdmRoleDto role2 = new IdmRoleDto();
            role2.setName("customRole");
            // TODO: subroles are disabled for now
            // List<IdmRoleComposition> subRoles = new ArrayList<>();
            // subRoles.add(new IdmRoleComposition(role2, superAdminRole));
            // role2.setSubRoles(subRoles);
            role2 = this.roleService.save(role2);
            LOG.info(MessageFormat.format("Role created [id: {0}]", role2.getId()));
            // 
            IdmRoleDto roleManager = new IdmRoleDto();
            roleManager.setName("manager");
            roleManager = this.roleService.save(roleManager);
            LOG.info(MessageFormat.format("Role created [id: {0}]", roleManager.getId()));
            // 
            // 
            IdmIdentityDto identity = new IdmIdentityDto();
            identity.setUsername("tomiska");
            identity.setPassword(new GuardedString("heslo"));
            identity.setFirstName("Radek");
            identity.setLastName("Tomiška");
            identity.setEmail("radek.tomiska@bcvsolutions.eu");
            identity = this.identityService.save(identity);
            LOG.info(MessageFormat.format("Identity created [id: {0}]", identity.getId()));
            // 
            // create prime contract
            IdmIdentityContractDto identityContract = identityContractService.getPrimeContract(identity.getId());
            if (identityContract == null) {
                identityContract = identityContractService.prepareMainContract(identity.getId());
                identityContract = identityContractService.save(identityContract);
            }
            // 
            IdmIdentityRoleDto identityRole1 = new IdmIdentityRoleDto();
            identityRole1.setIdentityContract(identityContract.getId());
            identityRole1.setRole(role1.getId());
            identityRole1 = identityRoleService.save(identityRole1);
            // 
            IdmIdentityRoleDto identityRole2 = new IdmIdentityRoleDto();
            identityRole2.setIdentityContract(identityContract.getId());
            identityRole2.setRole(role2.getId());
            identityRole2 = identityRoleService.save(identityRole2);
            // 
            IdmIdentityDto identity2 = new IdmIdentityDto();
            identity2.setUsername("svanda");
            identity2.setFirstName("Vít");
            identity2.setPassword(new GuardedString("heslo"));
            identity2.setLastName("Švanda");
            identity2.setEmail("vit.svanda@bcvsolutions.eu");
            identity2 = this.identityService.save(identity2);
            LOG.info(MessageFormat.format("Identity created [id: {0}]", identity2.getId()));
            // 
            IdmIdentityDto identity3 = new IdmIdentityDto();
            identity3.setUsername("kopr");
            identity3.setFirstName("Ondrej");
            identity3.setPassword(new GuardedString("heslo"));
            identity3.setLastName("Kopr");
            identity3.setEmail("ondrej.kopr@bcvsolutions.eu");
            identity3 = this.identityService.save(identity3);
            LOG.info(MessageFormat.format("Identity created [id: {0}]", identity3.getId()));
            // 
            // get tree type for organization
            IdmTreeTypeDto treeType = treeTypeService.getByCode(InitApplicationData.DEFAULT_TREE_TYPE);
            // 
            IdmTreeNodeDto organization1 = new IdmTreeNodeDto();
            organization1.setCode("one");
            organization1.setName("Organization One");
            organization1.setParent(rootOrganization.getId());
            organization1.setTreeType(treeType.getId());
            organization1 = this.treeNodeService.save(organization1);
            // 
            IdmTreeNodeDto organization2 = new IdmTreeNodeDto();
            organization2.setCode("two");
            organization2.setName("Organization Two");
            organization2.setCreator("ja");
            organization2.setParent(rootOrganization.getId());
            organization2.setTreeType(treeType.getId());
            organization2 = this.treeNodeService.save(organization2);
            // 
            IdmIdentityContractDto identityWorkPosition = new IdmIdentityContractDto();
            identityWorkPosition.setIdentity(identityAdmin.getId());
            identityWorkPosition.setWorkPosition(organization2.getId());
            identityWorkPosition = identityContractService.save(identityWorkPosition);
            IdmContractGuaranteeDto contractGuarantee = new IdmContractGuaranteeDto();
            contractGuarantee.setIdentityContract(identityWorkPosition.getId());
            contractGuarantee.setGuarantee(identity2.getId());
            contractGuaranteeService.save(contractGuarantee);
            // 
            LOG.info("Demo data was created.");
            // 
            configurationService.setBooleanValue(PARAMETER_DEMO_DATA_CREATED, true);
            // 
            // demo eav identity form
            IdmFormAttributeDto letter = new IdmFormAttributeDto();
            letter.setCode("letter");
            letter.setName("Favorite letter");
            letter.setPlaceholder("Character");
            letter.setDescription("Some favorite character");
            letter.setPersistentType(PersistentType.CHAR);
            letter.setRequired(true);
            letter = formService.saveAttribute(IdmIdentity.class, letter);
            IdmFormAttributeDto phone = new IdmFormAttributeDto();
            phone.setCode(FORM_ATTRIBUTE_PHONE);
            phone.setName("Phone");
            phone.setDescription("Additional identitiy's phone");
            phone.setPersistentType(PersistentType.TEXT);
            phone = formService.saveAttribute(IdmIdentity.class, phone);
            IdmFormAttributeDto description = new IdmFormAttributeDto();
            description.setCode("description");
            description.setName("Description");
            description.setDescription("Some longer optional text (2000 characters)");
            description.setPersistentType(PersistentType.TEXT);
            description.setFaceType(BaseFaceType.TEXTAREA);
            description = formService.saveAttribute(IdmIdentity.class, description);
            IdmFormAttributeDto rich = new IdmFormAttributeDto();
            rich.setCode("rich");
            rich.setName("RichText");
            rich.setDescription("Some rich text (2000 characters)");
            rich.setPersistentType(PersistentType.TEXT);
            description.setFaceType(BaseFaceType.RICHTEXTAREA);
            rich = formService.saveAttribute(IdmIdentity.class, rich);
            IdmFormAttributeDto sure = new IdmFormAttributeDto();
            sure.setCode("sure");
            sure.setName("Registration");
            sure.setPersistentType(PersistentType.BOOLEAN);
            sure.setDefaultValue(Boolean.TRUE.toString());
            sure = formService.saveAttribute(IdmIdentity.class, sure);
            IdmFormAttributeDto intNumber = new IdmFormAttributeDto();
            intNumber.setCode("intNumber");
            intNumber.setName("Int number");
            intNumber.setPersistentType(PersistentType.INT);
            intNumber = formService.saveAttribute(IdmIdentity.class, intNumber);
            IdmFormAttributeDto longNumber = new IdmFormAttributeDto();
            longNumber.setCode("longNumber");
            longNumber.setName("Long number");
            longNumber.setPersistentType(PersistentType.LONG);
            longNumber = formService.saveAttribute(IdmIdentity.class, longNumber);
            IdmFormAttributeDto doubleNumber = new IdmFormAttributeDto();
            doubleNumber.setCode("doubleNumber");
            doubleNumber.setName("Double number");
            doubleNumber.setPersistentType(PersistentType.DOUBLE);
            doubleNumber = formService.saveAttribute(IdmIdentity.class, doubleNumber);
            IdmFormAttributeDto currency = new IdmFormAttributeDto();
            currency.setCode("currency");
            currency.setName("Price");
            currency.setPersistentType(PersistentType.DOUBLE);
            currency.setFaceType(BaseFaceType.CURRENCY);
            currency = formService.saveAttribute(IdmIdentity.class, currency);
            IdmFormAttributeDto date = new IdmFormAttributeDto();
            date.setCode("date");
            date.setName("Date");
            date.setPersistentType(PersistentType.DATE);
            date.setRequired(true);
            date.setDescription("Important date");
            date = formService.saveAttribute(IdmIdentity.class, date);
            IdmFormAttributeDto datetime = new IdmFormAttributeDto();
            datetime.setCode(FORM_ATTRIBUTE_DATETIME);
            datetime.setName("Date and time");
            datetime.setPersistentType(PersistentType.DATETIME);
            datetime = formService.saveAttribute(IdmIdentity.class, datetime);
            IdmFormAttributeDto uuid = new IdmFormAttributeDto();
            uuid.setCode(FORM_ATTRIBUTE_UUID);
            uuid.setName("UUID");
            uuid.setDescription("Some uuid value");
            uuid.setPersistentType(PersistentType.UUID);
            uuid = formService.saveAttribute(IdmIdentity.class, uuid);
            IdmFormAttributeDto webPages = new IdmFormAttributeDto();
            webPages.setCode(FORM_ATTRIBUTE_WWW);
            webPages.setName("WWW");
            webPages.setDescription("Favorite web pages (every line in new value)");
            webPages.setPersistentType(PersistentType.TEXT);
            webPages.setMultiple(true);
            webPages = formService.saveAttribute(IdmIdentity.class, webPages);
            IdmFormAttributeDto password = new IdmFormAttributeDto();
            password.setCode(FORM_ATTRIBUTE_PASSWORD);
            password.setName("Custom password");
            password.setPersistentType(PersistentType.TEXT);
            password.setConfidential(true);
            password.setDescription("Test password");
            password = formService.saveAttribute(IdmIdentity.class, password);
            IdmFormAttributeDto byteArray = new IdmFormAttributeDto();
            byteArray.setCode("byteArray");
            byteArray.setName("Byte array");
            byteArray.setPersistentType(PersistentType.BYTEARRAY);
            byteArray.setConfidential(false);
            byteArray.setDescription("Test byte array");
            byteArray.setPlaceholder("or image :-)");
            byteArray = formService.saveAttribute(IdmIdentity.class, byteArray);
            List<IdmFormValueDto> values = new ArrayList<>();
            IdmFormValueDto phoneValue = new IdmFormValueDto();
            phoneValue.setFormAttribute(phone.getId());
            phoneValue.setStringValue("12345679");
            values.add(phoneValue);
            formService.saveValues(identity.getId(), IdmIdentity.class, null, values);
            // 
            // demo eav role form
            IdmFormAttributeDto roleExt = new IdmFormAttributeDto();
            roleExt.setCode("extAttr");
            roleExt.setName("Ext.attr");
            roleExt.setPersistentType(PersistentType.TEXT);
            roleExt.setConfidential(false);
            roleExt.setDescription("Role's custom extended attribute");
            roleExt = formService.saveAttribute(IdmRole.class, roleExt);
            // 
            // demo eav tree node form
            IdmFormAttributeDto treeNodeExt = new IdmFormAttributeDto();
            treeNodeExt.setCode("extAttr");
            treeNodeExt.setName("Ext.attr");
            treeNodeExt.setPersistentType(PersistentType.TEXT);
            treeNodeExt.setConfidential(false);
            treeNodeExt.setDescription("Tree node's custom extended attribute");
            treeNodeExt = formService.saveAttribute(IdmTreeNode.class, treeNodeExt);
            // 
            // demo eav identity contract's form
            IdmFormAttributeDto identityContractExt = new IdmFormAttributeDto();
            identityContractExt.setCode("extAttr");
            identityContractExt.setName("Ext.attr");
            identityContractExt.setPersistentType(PersistentType.TEXT);
            identityContractExt.setConfidential(false);
            identityContractExt.setDescription("Identity contract's custom extended attribute");
            identityContractExt = formService.saveAttribute(IdmIdentityContract.class, identityContractExt);
        }
    } catch (Exception ex) {
        LOG.warn("Demo data was not created", ex);
    } finally {
        SecurityContextHolder.clearContext();
    }
}

Example 5 with IdmFormAttributeDto

use of eu.bcvsolutions.idm.core.eav.api.dto.IdmFormAttributeDto in project CzechIdMng by bcvsolutions.

the class DefaultSysSystemServiceTest method testFormAttributes.

/**
 * Test add and delete extended attributes to owner
 */
@Test
public void testFormAttributes() {
    // create owner
    SysSystemDto system = new SysSystemDto();
    system.setName(SYSTEM_NAME_ONE);
    system = systemService.save(system);
    SysSystemDto systemOne = systemService.getByCode(SYSTEM_NAME_ONE);
    assertEquals(SYSTEM_NAME_ONE, systemOne.getName());
    // 
    // create definition one
    IdmFormDefinitionDto formDefinitionOne = new IdmFormDefinitionDto();
    formDefinitionOne.setType(SysSystem.class.getCanonicalName());
    formDefinitionOne.setCode("v1");
    formDefinitionOne = formDefinitionService.save(formDefinitionOne);
    IdmFormAttributeDto attributeDefinitionOne = new IdmFormAttributeDto();
    attributeDefinitionOne.setFormDefinition(formDefinitionOne.getId());
    attributeDefinitionOne.setCode("name_" + System.currentTimeMillis());
    attributeDefinitionOne.setName(attributeDefinitionOne.getCode());
    attributeDefinitionOne.setPersistentType(PersistentType.TEXT);
    attributeDefinitionOne = formAttributeService.save(attributeDefinitionOne);
    formDefinitionOne = formDefinitionService.get(formDefinitionOne.getId());
    // 
    // create definition two
    IdmFormDefinitionDto formDefinitionTwo = new IdmFormDefinitionDto();
    formDefinitionTwo.setType(SysSystem.class.getCanonicalName());
    formDefinitionTwo.setCode("v2");
    formDefinitionTwo = formDefinitionService.save(formDefinitionTwo);
    IdmFormAttributeDto attributeDefinitionTwo = new IdmFormAttributeDto();
    attributeDefinitionTwo.setFormDefinition(formDefinitionTwo.getId());
    attributeDefinitionTwo.setCode("name_" + System.currentTimeMillis());
    attributeDefinitionTwo.setName(attributeDefinitionTwo.getCode());
    attributeDefinitionTwo.setPersistentType(PersistentType.TEXT);
    attributeDefinitionTwo = formAttributeService.save(attributeDefinitionTwo);
    formDefinitionTwo = formDefinitionService.get(formDefinitionTwo.getId());
    // 
    IdmFormValueDto value1 = new IdmFormValueDto(attributeDefinitionOne);
    value1.setValue("test1");
    IdmFormValueDto value2 = new IdmFormValueDto(attributeDefinitionTwo);
    value2.setValue("test2");
    formService.saveValues(system, formDefinitionOne, Lists.newArrayList(value1));
    formService.saveValues(system, formDefinitionTwo, Lists.newArrayList(value2));
    assertEquals("test1", formService.getValues(system, formDefinitionOne).get(0).getStringValue());
    assertEquals("test2", formService.getValues(system, formDefinitionTwo).get(0).getStringValue());
    assertEquals("test2", formService.getValues(system, formDefinitionTwo, attributeDefinitionTwo.getName()).get(0).getValue());
    // 
    // create second owner
    SysSystemDto systemTwo = new SysSystemDto();
    systemTwo.setName(SYSTEM_NAME_TWO);
    systemTwo = systemService.save(systemTwo);
    assertEquals(0, formService.getValues(systemTwo, formDefinitionOne).size());
    assertEquals(0, formService.getValues(systemTwo, formDefinitionTwo).size());
    assertEquals(1, formService.getValues(system, formDefinitionOne).size());
    assertEquals(1, formService.getValues(system, formDefinitionTwo).size());
    systemService.delete(systemTwo);
    assertEquals(1, formService.getValues(system, formDefinitionOne).size());
    assertEquals(1, formService.getValues(system, formDefinitionTwo).size());
    formService.deleteValues(system, formDefinitionOne);
    assertEquals(0, formService.getValues(system, formDefinitionOne).size());
    assertEquals("test2", formService.getValues(system, formDefinitionTwo).get(0).getStringValue());
    systemService.delete(system);
}