UserMapperImpl.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.EmailMapper;
import org.openwms.core.uaa.UserDetailsMapper;
import org.openwms.core.uaa.UserMapper;
import org.openwms.core.uaa.api.AuthenticatedUserVO;
import org.openwms.core.uaa.api.EmailVO;
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 UserMapperImpl implements UserMapper {

    private final EmailMapper emailMapper;
    private final UserDetailsMapper userDetailsMapper;

    @Autowired
    public UserMapperImpl(EmailMapper emailMapper, UserDetailsMapper userDetailsMapper) {

        this.emailMapper = emailMapper;
        this.userDetailsMapper = userDetailsMapper;
    }

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

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

        return list;
    }

    @Override
    public UserVO convertToVO(User eo) {
        if ( eo == null ) {
            return null;
        }

        if (eo instanceof User) {
            return convertToAuthenticatedUserVO( (User) eo );
        }
        else {
            UserVO userVO = new UserVO();

            if ( eo.hasPersistentKey() ) {
                userVO.setpKey( eo.getPersistentKey() );
            }
            userVO.setOl( eo.getOl() );
            userVO.setExtern( eo.isExternalUser() );
            userVO.setRoleNames( convertToStrings( eo.getRoles() ) );
            userVO.setCreateDt( eo.getCreateDt() );
            userVO.setLastModifiedDt( eo.getLastModifiedDt() );
            userVO.setEmailAddresses( emailSetToEmailVOList( eo.getEmailAddresses() ) );
            userVO.setUsername( eo.getUsername() );
            userVO.setLastPasswordChange( eo.getLastPasswordChange() );
            userVO.setLocked( eo.isLocked() );
            userVO.setEnabled( eo.isEnabled() );
            userVO.setExpirationDate( eo.getExpirationDate() );
            userVO.setFullname( eo.getFullname() );
            if ( eo.hasUserDetails() ) {
                userVO.setUserDetails( userDetailsMapper.map( eo.getUserDetails() ) );
            }

            return userVO;
        }
    }

    @Override
    public AuthenticatedUserVO convertToAuthenticatedUserVO(User eo) {
        if ( eo == null ) {
            return null;
        }

        AuthenticatedUserVO authenticatedUserVO = new AuthenticatedUserVO();

        if ( eo.hasPersistentKey() ) {
            authenticatedUserVO.setpKey( eo.getPersistentKey() );
        }
        authenticatedUserVO.setOl( eo.getOl() );
        authenticatedUserVO.setExtern( eo.isExternalUser() );
        authenticatedUserVO.setPassword( eo.getPassword() );
        authenticatedUserVO.setRoleNames( convertToStrings( eo.getRoles() ) );
        authenticatedUserVO.setCreateDt( eo.getCreateDt() );
        authenticatedUserVO.setLastModifiedDt( eo.getLastModifiedDt() );
        authenticatedUserVO.setEmailAddresses( emailSetToEmailVOList( eo.getEmailAddresses() ) );
        authenticatedUserVO.setUsername( eo.getUsername() );
        authenticatedUserVO.setLastPasswordChange( eo.getLastPasswordChange() );
        authenticatedUserVO.setLocked( eo.isLocked() );
        authenticatedUserVO.setEnabled( eo.isEnabled() );
        authenticatedUserVO.setExpirationDate( eo.getExpirationDate() );
        authenticatedUserVO.setFullname( eo.getFullname() );
        if ( eo.hasUserDetails() ) {
            authenticatedUserVO.setUserDetails( userDetailsMapper.map( eo.getUserDetails() ) );
        }

        return authenticatedUserVO;
    }

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

        List<UserVO> list = new ArrayList<UserVO>( eo.size() );
        for ( User user : eo ) {
            list.add( convertToAuthenticatedUserVO( user ) );
        }

        return list;
    }

    @Override
    public User convertFrom(UserVO vo) {
        if ( vo == null ) {
            return null;
        }

        String username = null;

        username = vo.getUsername();

        User user = new User( username );

        user.setPersistentKey( vo.getpKey() );
        if ( vo.getExtern() != null ) {
            user.setExternalUser( vo.getExtern() );
        }
        if ( vo.getOl() != null ) {
            user.setOl( vo.getOl() );
        }
        user.setLastPasswordChange( vo.getLastPasswordChange() );
        if ( vo.getLocked() != null ) {
            user.setLocked( vo.getLocked() );
        }
        if ( vo.getEnabled() != null ) {
            user.setEnabled( vo.getEnabled() );
        }
        user.setExpirationDate( vo.getExpirationDate() );
        user.setFullname( vo.getFullname() );
        user.setEmailAddresses( emailVOListToEmailSet( vo.getEmailAddresses() ) );
        user.setUserDetails( userDetailsMapper.mapToEO( vo.getUserDetails() ) );

        enhanceEmail( user );

        return user;
    }

    @Override
    public void copy(User source, User target) {
        if ( source == null ) {
            return;
        }

        if ( source.hasPersistentKey() ) {
            target.setPersistentKey( source.getPersistentKey() );
        }
        target.setOl( source.getOl() );
        target.setUsername( source.getUsername() );
        target.setExternalUser( source.isExternalUser() );
        target.setLastPasswordChange( source.getLastPasswordChange() );
        target.setLocked( source.isLocked() );
        target.setEnabled( source.isEnabled() );
        target.setExpirationDate( source.getExpirationDate() );
        if ( target.getRoles() != null ) {
            List<Role> list = source.getRoles();
            if ( list != null ) {
                target.getRoles().clear();
                target.getRoles().addAll( list );
            }
            else {
                target.setRoles( null );
            }
        }
        else {
            List<Role> list = source.getRoles();
            if ( list != null ) {
                target.setRoles( new ArrayList<Role>( list ) );
            }
        }
        target.setFullname( source.getFullname() );
        if ( target.getEmailAddresses() != null ) {
            Set<Email> set = source.getEmailAddresses();
            if ( set != null ) {
                target.getEmailAddresses().clear();
                target.getEmailAddresses().addAll( set );
            }
            else {
                target.setEmailAddresses( null );
            }
        }
        else {
            Set<Email> set = source.getEmailAddresses();
            if ( set != null ) {
                target.setEmailAddresses( new LinkedHashSet<Email>( set ) );
            }
        }
        if ( source.hasUserDetails() ) {
            target.setUserDetails( source.getUserDetails() );
        }
        else {
            target.setUserDetails( null );
        }
        if ( target.getGrants() != null ) {
            target.getGrants().clear();
            List<SecurityObject> list1 = source.getGrants();
            if ( list1 != null ) {
                target.getGrants().addAll( list1 );
            }
        }
        if ( target.getPasswords() != null ) {
            target.getPasswords().clear();
            List<UserPassword> list2 = source.getPasswords();
            if ( list2 != null ) {
                target.getPasswords().addAll( list2 );
            }
        }

        enhanceEmail( target );
    }

    protected List<EmailVO> emailSetToEmailVOList(Set<Email> set) {
        if ( set == null ) {
            return null;
        }

        List<EmailVO> list = new ArrayList<EmailVO>( set.size() );
        for ( Email email : set ) {
            list.add( emailMapper.convertToVO( email ) );
        }

        return list;
    }

    protected Set<Email> emailVOListToEmailSet(List<EmailVO> list) {
        if ( list == null ) {
            return null;
        }

        Set<Email> set = LinkedHashSet.newLinkedHashSet( list.size() );
        for ( EmailVO emailVO : list ) {
            set.add( emailMapper.convertFrom( emailVO ) );
        }

        return set;
    }
}