RoleMapperImpl.java

package org.openwms.core.uaa.impl;

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import javax.annotation.processing.Generated;
import org.openwms.core.uaa.RoleMapper;
import org.openwms.core.uaa.SecurityObjectMapper;
import org.openwms.core.uaa.UserMapper;
import org.openwms.core.uaa.api.RoleVO;
import org.openwms.core.uaa.api.SecurityObjectVO;
import org.openwms.core.uaa.api.UserVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Generated(
    value = "org.mapstruct.ap.MappingProcessor"
)
@Component
public class RoleMapperImpl implements RoleMapper {

    private final UserMapper userMapper;
    private final SecurityObjectMapper securityObjectMapper;

    @Autowired
    public RoleMapperImpl(UserMapper userMapper, SecurityObjectMapper securityObjectMapper) {

        this.userMapper = userMapper;
        this.securityObjectMapper = securityObjectMapper;
    }

    @Override
    public RoleVO convertToVO(Role eo) {
        if ( eo == null ) {
            return null;
        }

        RoleVO.Builder roleVO = RoleVO.newBuilder();

        if ( eo.hasPersistentKey() ) {
            roleVO.pKey( eo.getPersistentKey() );
        }
        roleVO.ol( eo.getOl() );
        roleVO.users( userSetToUserVOSet( eo.getUsers() ) );
        roleVO.immutable( eo.getImmutable() );
        roleVO.grants( securityObjectSetToSecurityObjectVOSet( eo.getGrants() ) );
        roleVO.name( eo.getName() );
        roleVO.description( eo.getDescription() );

        return roleVO.build();
    }

    @Override
    public List<RoleVO> convertToVO(List<Role> eo) {
        if ( eo == null ) {
            return null;
        }

        List<RoleVO> list = new ArrayList<RoleVO>( eo.size() );
        for ( Role role : eo ) {
            list.add( convertToVO( role ) );
        }

        return list;
    }

    @Override
    public Role convertFrom(RoleVO vo) {
        if ( vo == null ) {
            return null;
        }

        String name = null;

        name = vo.getName();

        Role role = new Role( name );

        role.setPersistentKey( vo.getpKey() );
        Set<User> set = userVOSetToUserSet( vo.getUsers() );
        if ( set != null ) {
            role.setUsers( set );
        }
        Set<SecurityObject> set1 = securityObjectVOSetToSecurityObjectSet( vo.getGrants() );
        if ( set1 != null ) {
            role.setGrants( set1 );
        }
        role.setDescription( vo.getDescription() );
        role.setImmutable( vo.getImmutable() );

        return role;
    }

    @Override
    public SecurityObject convertToRole(SecurityObjectVO vo) {
        if ( vo == null ) {
            return null;
        }

        if (vo instanceof RoleVO) {
            return convertFrom( (RoleVO) vo );
        }
        else {
            String name = null;

            name = vo.getName();

            SecurityObject securityObject = new SecurityObject( name );

            securityObject.setPersistentKey( vo.getpKey() );
            securityObject.setDescription( vo.getDescription() );

            return securityObject;
        }
    }

    protected Set<UserVO> userSetToUserVOSet(Set<User> set) {
        if ( set == null ) {
            return null;
        }

        Set<UserVO> set1 = LinkedHashSet.newLinkedHashSet( set.size() );
        for ( User user : set ) {
            set1.add( userMapper.convertToVO( user ) );
        }

        return set1;
    }

    protected Set<SecurityObjectVO> securityObjectSetToSecurityObjectVOSet(Set<SecurityObject> set) {
        if ( set == null ) {
            return null;
        }

        Set<SecurityObjectVO> set1 = LinkedHashSet.newLinkedHashSet( set.size() );
        for ( SecurityObject securityObject : set ) {
            set1.add( securityObjectMapper.convertToVO( securityObject ) );
        }

        return set1;
    }

    protected Set<User> userVOSetToUserSet(Set<UserVO> set) {
        if ( set == null ) {
            return null;
        }

        Set<User> set1 = LinkedHashSet.newLinkedHashSet( set.size() );
        for ( UserVO userVO : set ) {
            set1.add( userMapper.convertFrom( userVO ) );
        }

        return set1;
    }

    protected Set<SecurityObject> securityObjectVOSetToSecurityObjectSet(Set<SecurityObjectVO> set) {
        if ( set == null ) {
            return null;
        }

        Set<SecurityObject> set1 = LinkedHashSet.newLinkedHashSet( set.size() );
        for ( SecurityObjectVO securityObjectVO : set ) {
            set1.add( convertToRole( securityObjectVO ) );
        }

        return set1;
    }
}