@Override public <T extends PlainAttr<?>> T newPlainAttr() { T result = null; switch (anyTypeKind) { case USER: result = (T) entityFactory.newEntity(UPlainAttr.class); break; case GROUP: result = (T) entityFactory.newEntity(GPlainAttr.class); break; case ANY_OBJECT: result = (T) entityFactory.newEntity(APlainAttr.class); break; default: } return result; }
@Override public AnyTypeClass create(final AnyTypeClassTO anyTypeClassTO) { AnyTypeClass anyTypeClass = entityFactory.newEntity(AnyTypeClass.class); update(anyTypeClass, anyTypeClassTO); return anyTypeClass; }
@Override public Notification create(final NotificationTO notificationTO) { Notification result = entityFactory.newEntity(Notification.class); update(result, notificationTO); return result; }
@Override public SecurityQuestion create(final SecurityQuestionTO securityQuestionTO) { SecurityQuestion result = entityFactory.newEntity(SecurityQuestion.class); update(result, securityQuestionTO); return result; }
@Override public Implementation create(final ImplementationTO implementationTO) { Implementation implementation = entityFactory.newEntity(Implementation.class); update(implementation, implementationTO); return implementation; }
@Override public Application create(final ApplicationTO applicationTO) { return update(entityFactory.newEntity(Application.class), applicationTO); }
@Override public PlainSchema create(final PlainSchemaTO schemaTO) { return fill(entityFactory.newEntity(PlainSchema.class), schemaTO); }
@Override public ExternalResource create(final ResourceTO resourceTO) { return update(entityFactory.newEntity(ExternalResource.class), resourceTO); }
@Override public DynRealm create(final DynRealmTO dynRealmTO) { return update(entityFactory.newEntity(DynRealm.class), dynRealmTO); }
@Override public Role create(final RoleTO roleTO) { return update(entityFactory.newEntity(Role.class), roleTO); }
@Override public DerSchema create(final DerSchemaTO schemaTO) { return fill(entityFactory.newEntity(DerSchema.class), schemaTO); }
@Override public RelationshipType create(final RelationshipTypeTO relationshipTypeTO) { RelationshipType relationshipType = entityFactory.newEntity(RelationshipType.class); update(relationshipType, relationshipTypeTO); return relationshipType; }
@Override public Domain create(final DomainTO domainTO) { Domain domain = entityFactory.newEntity(Domain.class); update(domain, domainTO); return domain; }
@Override public VirSchema create(final VirSchemaTO schemaTO) { return fill(entityFactory.newEntity(VirSchema.class), schemaTO); }
@Override public Conf get() { Conf instance = entityManager().find(entityFactory.confClass(), KEY); if (instance == null) { instance = entityFactory.newEntity(Conf.class); instance.setKey(KEY); instance = entityManager().merge(instance); } return instance; }
@PreAuthorize("hasRole('" + StandardEntitlement.REPORT_TEMPLATE_CREATE + "')") public ReportTemplateTO create(final String key) { if (reportTemplateDAO.find(key) != null) { throw new DuplicateException(key); } ReportTemplate reportTemplate = entityFactory.newEntity(ReportTemplate.class); reportTemplate.setKey(key); reportTemplateDAO.save(reportTemplate); return getReportTemplateTO(key); }
@PreAuthorize("hasRole('" + StandardEntitlement.MAIL_TEMPLATE_CREATE + "')") public MailTemplateTO create(final String key) { if (mailTemplateDAO.find(key) != null) { throw new DuplicateException(key); } MailTemplate mailTemplate = entityFactory.newEntity(MailTemplate.class); mailTemplate.setKey(key); mailTemplateDAO.save(mailTemplate); return getMailTemplateTO(key); }
private <S extends Schema, T extends SchemaTO> void labels(final T src, final S dst) { src.getLabels().forEach((locale, display) -> { SchemaLabel label = dst.getLabel(locale).orElse(null); if (label == null) { label = entityFactory.newEntity(SchemaLabel.class); label.setLocale(locale); label.setSchema(dst); dst.add(label); } label.setDisplay(display); }); dst.getLabels().removeIf(label -> !src.getLabels().containsKey(label.getLocale())); }
private void setDynMembership(final DynRealm dynRealm, final AnyType anyType, final String dynMembershipFIQL) { SearchCond dynMembershipCond = SearchCondConverter.convert(dynMembershipFIQL); if (!dynMembershipCond.isValid()) { SyncopeClientException sce = SyncopeClientException.build(ClientExceptionType.InvalidSearchExpression); sce.getElements().add(dynMembershipFIQL); throw sce; } DynRealmMembership dynMembership; if (dynRealm.getDynMembership(anyType).isPresent()) { dynMembership = dynRealm.getDynMembership(anyType).get(); } else { dynMembership = entityFactory.newEntity(DynRealmMembership.class); dynMembership.setDynRealm(dynRealm); dynMembership.setAnyType(anyType); dynRealm.add(dynMembership); } dynMembership.setFIQLCond(dynMembershipFIQL); }
private void setDynMembership(final Role role, final String dynMembershipFIQL) { SearchCond dynMembershipCond = SearchCondConverter.convert(dynMembershipFIQL); if (!dynMembershipCond.isValid()) { SyncopeClientException sce = SyncopeClientException.build(ClientExceptionType.InvalidSearchExpression); sce.getElements().add(dynMembershipFIQL); throw sce; } DynRoleMembership dynMembership; if (role.getDynMembership() == null) { dynMembership = entityFactory.newEntity(DynRoleMembership.class); dynMembership.setRole(role); role.setDynMembership(dynMembership); } else { dynMembership = role.getDynMembership(); } dynMembership.setFIQLCond(dynMembershipFIQL); }