Package org.apache.syncope.core.persistence.beans.membership

Examples of org.apache.syncope.core.persistence.beans.membership.Membership


            if (role == null) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Ignoring invalid role " + membershipTO.getRoleName());
                }
            } else {
                Membership membership = null;
                if (user.getId() != null) {
                    membership = user.getMembership(role.getId()) == null
                            ? membershipDAO.find(user, role)
                            : user.getMembership(role.getId());
                }
                if (membership == null) {
                    membership = new Membership();
                    membership.setSyncopeRole(role);
                    membership.setSyncopeUser(user);

                    user.addMembership(membership);
                }

                fill(membership, membershipTO, AttributableUtil.getInstance(AttributableType.MEMBERSHIP), scce);
View Full Code Here


        for (MembershipMod membToBeAdded : userMod.getMembershipsToBeAdded()) {
            membershipToBeAddedRoleIds.add(membToBeAdded.getRole());
        }

        // memberships to be removed
        Membership membership = null;
        for (Long membershipId : userMod.getMembershipsToBeRemoved()) {
            LOG.debug("Membership to be removed: {}", membershipId);

            membership = membershipDAO.find(membershipId);
            if (membership == null) {
                LOG.debug("Invalid membership id specified to be removed: {}", membershipId);
            } else {
                for (ExternalResource resource : membership.getSyncopeRole().getResources()) {

                    if (!membershipToBeAddedRoleIds.contains(membership.getSyncopeRole().getId())) {

                        propByRes.add(PropagationOperation.DELETE, resource.getName());
                    }
                }

                // In order to make the removeMembership() below to work,
                // we need to be sure to take exactly the same membership
                // of the user object currently in memory (which has potentially
                // some modifications compared to the one stored in the DB
                membership = user.getMembership(membership.getSyncopeRole().getId());
                if (membershipToBeAddedRoleIds.contains(membership.getSyncopeRole().getId())) {

                    Set<Long> attributeIds = new HashSet<Long>(membership.getAttributes().size());
                    for (AbstractAttr attribute : membership.getAttributes()) {
                        attributeIds.add(attribute.getId());
                    }
                    for (Long attributeId : attributeIds) {
                        attributeDAO.delete(attributeId, MAttr.class);
                    }
                    attributeIds.clear();

                    // remove derived attributes
                    for (AbstractDerAttr derAttr : membership.getDerivedAttributes()) {

                        attributeIds.add(derAttr.getId());
                    }
                    for (Long derAttrId : attributeIds) {
                        derAttrDAO.delete(derAttrId, MDerAttr.class);
                    }
                    attributeIds.clear();

                    // remove virtual attributes
                    for (AbstractVirAttr virAttr : membership.getVirtualAttributes()) {

                        attributeIds.add(virAttr.getId());
                    }
                    for (Long virAttrId : attributeIds) {
                        virAttrDAO.delete(virAttrId, MVirAttr.class);
                    }
                    attributeIds.clear();
                } else {
                    user.removeMembership(membership);

                    membershipDAO.delete(membershipId);
                }
            }
        }

        // memberships to be added
        for (MembershipMod membershipMod : userMod.getMembershipsToBeAdded()) {
            LOG.debug("Membership to be added: role({})", membershipMod.getRole());

            SyncopeRole role = roleDAO.find(membershipMod.getRole());
            if (role == null) {
                LOG.debug("Ignoring invalid role {}", membershipMod.getRole());
            } else {
                membership = user.getMembership(role.getId());
                if (membership == null) {
                    membership = new Membership();
                    membership.setSyncopeRole(role);
                    membership.setSyncopeUser(user);

                    user.addMembership(membership);

                    propByRes.addAll(PropagationOperation.UPDATE, role.getResourceNames());
                }
View Full Code Here

    public boolean removeMembership(final Membership membership) {
        return memberships.remove(membership);
    }

    public Membership getMembership(final Long syncopeRoleId) {
        Membership result = null;
        Membership membership;
        for (Iterator<Membership> itor = getMemberships().iterator(); result == null && itor.hasNext();) {

            membership = itor.next();
            if (membership.getSyncopeRole() != null && syncopeRoleId.equals(membership.getSyncopeRole().getId())) {

                result = membership;
            }
        }
View Full Code Here

                    doExtractAttributes(handler, memb, memb.getAttributeMap().keySet(), memb.getDerivedAttributeMap()
                            .keySet(), memb.getVirtualAttributeMap().keySet());

                    if (conf.getFeatures().contains(Feature.resources)) {
                        Membership actualMemb = user.getMembership(memb.getRoleId());
                        if (actualMemb == null) {
                            LOG.warn("Unexpected: cannot find membership for role {} for user {}", memb.getRoleId(),
                                    user);
                        } else {
                            doExtractResources(handler, roleDataBinder.getRoleTO(actualMemb.getSyncopeRole()));
                        }
                    }

                    handler.endElement("", "", "membership");
                }
View Full Code Here

        schema.setEnumerationValues("red" + AbstractSchema.enumValuesSeparator + "yellow");

        MSchema actualSchema = schemaDAO.save(schema);
        assertNotNull(actualSchema);

        Membership membership = membershipDAO.find(1L);
        assertNotNull(membership);

        MAttr attribute = new MAttr();
        attribute.setSchema(actualSchema);
        attribute.setOwner(membership);
        attribute.addValue("yellow", AttributableUtil.getInstance(AttributableType.MEMBERSHIP));
        membership.addAttribute(attribute);

        MAttr actualAttribute = attrDAO.save(attribute);
        assertNotNull(actualAttribute);

        membership = membershipDAO.find(1L);
        assertNotNull(membership);
        assertNotNull(membership.getAttribute(schema.getName()));
        assertNotNull(membership.getAttribute(schema.getName()).getValues());

        assertEquals(membership.getAttribute(schema.getName()).getValues().size(), 1);
    }
View Full Code Here

    @Autowired
    private RoleDAO syncopeRoleDAO;

    @Test
    public void delete() {
        Membership membership = membershipDAO.find(4L);
        SyncopeUser user = membership.getSyncopeUser();
        SyncopeRole role = membership.getSyncopeRole();

        membershipDAO.delete(4L);

        membershipDAO.flush();
View Full Code Here

        }
    }

    @Test
    public void deleteAndCreate() {
        Membership membership = membershipDAO.find(3L);
        SyncopeUser user = membership.getSyncopeUser();
        SyncopeRole role = membership.getSyncopeRole();

        // 1. delete that membership
        membershipDAO.delete(membership.getId());

        // if not flushing here, the INSERT below will be executed
        // before the DELETE above
        membershipDAO.flush();

        // 2. (in the same transaction) create new membership with same user
        // and role (in order to check the UNIQE constraint on Membership)
        membership = new Membership();
        membership.setSyncopeUser(user);
        membership.setSyncopeRole(role);

        membership = membershipDAO.save(membership);
    }
View Full Code Here

        assertEquals(6, list.size());
    }

    @Test
    public void find() {
        Membership membership = membershipDAO.find(1L);
        assertNotNull("did not find expected membership", membership);
    }
View Full Code Here

    @Test
    public void save() {
        SyncopeUser user = userDAO.find(4L);
        SyncopeRole role = roleDAO.find(1L);

        Membership membership = new Membership();
        membership.setSyncopeUser(user);
        membership.setSyncopeRole(role);

        membership = membershipDAO.save(membership);

        Membership actual = membershipDAO.find(membership.getId());
        assertNotNull("expected save to work", actual);
    }
View Full Code Here

        assertNotNull("expected save to work", actual);
    }

    @Test
    public void delete() {
        Membership membership = membershipDAO.find(4L);
        membershipDAO.delete(membership.getId());

        Membership actual = membershipDAO.find(4L);
        assertNull("delete did not work", actual);
    }
View Full Code Here

TOP

Related Classes of org.apache.syncope.core.persistence.beans.membership.Membership

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.