ComponentDtoMapperImpl.java

package jasper.component.dto;

import jasper.domain.Ext;
import jasper.domain.External;
import jasper.domain.Metadata;
import jasper.domain.Plugin;
import jasper.domain.Ref;
import jasper.domain.Template;
import jasper.domain.User;
import jasper.service.dto.ExtDto;
import jasper.service.dto.ExternalDto;
import jasper.service.dto.MetadataDto;
import jasper.service.dto.PluginDto;
import jasper.service.dto.RefDto;
import jasper.service.dto.TemplateDto;
import jasper.service.dto.UserDto;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.processing.Generated;
import org.springframework.stereotype.Component;

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2026-05-20T19:49:23+0000",
    comments = "version: 1.6.3, compiler: javac, environment: Java 25.0.3 (Amazon.com Inc.)"
)
@Component
public class ComponentDtoMapperImpl extends ComponentDtoMapper {

    @Override
    public RefDto domainToDto(Ref ref) {
        if ( ref == null ) {
            return null;
        }

        RefDto refDto = new RefDto();

        refDto.setUrl( ref.getUrl() );
        refDto.setOrigin( ref.getOrigin() );
        refDto.setTitle( ref.getTitle() );
        refDto.setComment( ref.getComment() );
        List<String> list = ref.getTags();
        if ( list != null ) {
            refDto.setTags( new ArrayList<String>( list ) );
        }
        List<String> list1 = ref.getSources();
        if ( list1 != null ) {
            refDto.setSources( new ArrayList<String>( list1 ) );
        }
        List<String> list2 = ref.getAlternateUrls();
        if ( list2 != null ) {
            refDto.setAlternateUrls( new ArrayList<String>( list2 ) );
        }
        refDto.setPlugins( ref.getPlugins() );
        refDto.setMetadata( metadataToMetadataDto( ref.getMetadata() ) );
        refDto.setPublished( ref.getPublished() );
        refDto.setCreated( ref.getCreated() );
        refDto.setModified( ref.getModified() );

        return refDto;
    }

    @Override
    public UserDto domainToDto(User ref) {
        if ( ref == null ) {
            return null;
        }

        UserDto userDto = new UserDto();

        userDto.setTag( ref.getTag() );
        userDto.setOrigin( ref.getOrigin() );
        userDto.setName( ref.getName() );
        userDto.setRole( ref.getRole() );
        List<String> list = ref.getReadAccess();
        if ( list != null ) {
            userDto.setReadAccess( new ArrayList<String>( list ) );
        }
        List<String> list1 = ref.getWriteAccess();
        if ( list1 != null ) {
            userDto.setWriteAccess( new ArrayList<String>( list1 ) );
        }
        List<String> list2 = ref.getTagReadAccess();
        if ( list2 != null ) {
            userDto.setTagReadAccess( new ArrayList<String>( list2 ) );
        }
        List<String> list3 = ref.getTagWriteAccess();
        if ( list3 != null ) {
            userDto.setTagWriteAccess( new ArrayList<String>( list3 ) );
        }
        userDto.setModified( ref.getModified() );
        byte[] pubKey = ref.getPubKey();
        if ( pubKey != null ) {
            userDto.setPubKey( Arrays.copyOf( pubKey, pubKey.length ) );
        }
        userDto.setAuthorizedKeys( ref.getAuthorizedKeys() );
        userDto.setExternal( externalToExternalDto( ref.getExternal() ) );

        return userDto;
    }

    @Override
    public ExtDto domainToDto(Ext ref) {
        if ( ref == null ) {
            return null;
        }

        ExtDto extDto = new ExtDto();

        extDto.setTag( ref.getTag() );
        extDto.setOrigin( ref.getOrigin() );
        extDto.setName( ref.getName() );
        extDto.setConfig( ref.getConfig() );
        extDto.setModified( ref.getModified() );

        return extDto;
    }

    @Override
    public PluginDto domainToDto(Plugin ref) {
        if ( ref == null ) {
            return null;
        }

        PluginDto pluginDto = new PluginDto();

        pluginDto.setTag( ref.getTag() );
        pluginDto.setOrigin( ref.getOrigin() );
        pluginDto.setName( ref.getName() );
        pluginDto.setConfig( ref.getConfig() );
        pluginDto.setDefaults( ref.getDefaults() );
        pluginDto.setSchema( ref.getSchema() );
        pluginDto.setModified( ref.getModified() );

        return pluginDto;
    }

    @Override
    public TemplateDto domainToDto(Template ref) {
        if ( ref == null ) {
            return null;
        }

        TemplateDto templateDto = new TemplateDto();

        templateDto.setTag( ref.getTag() );
        templateDto.setOrigin( ref.getOrigin() );
        templateDto.setName( ref.getName() );
        templateDto.setConfig( ref.getConfig() );
        templateDto.setDefaults( ref.getDefaults() );
        templateDto.setSchema( ref.getSchema() );
        templateDto.setModified( ref.getModified() );

        return templateDto;
    }

    @Override
    public RefUpdateDto dtoToUpdateDto(RefDto ref) {
        if ( ref == null ) {
            return null;
        }

        RefUpdateDto refUpdateDto = new RefUpdateDto();

        refUpdateDto.setUrl( ref.getUrl() );
        refUpdateDto.setOrigin( ref.getOrigin() );
        refUpdateDto.setTitle( ref.getTitle() );
        refUpdateDto.setComment( ref.getComment() );
        List<String> list = ref.getTags();
        if ( list != null ) {
            refUpdateDto.setTags( new ArrayList<String>( list ) );
        }
        List<String> list1 = ref.getSources();
        if ( list1 != null ) {
            refUpdateDto.setSources( new ArrayList<String>( list1 ) );
        }
        List<String> list2 = ref.getAlternateUrls();
        if ( list2 != null ) {
            refUpdateDto.setAlternateUrls( new ArrayList<String>( list2 ) );
        }
        refUpdateDto.setPlugins( ref.getPlugins() );
        refUpdateDto.setMetadata( metadataDtoToMetadataUpdateDto( ref.getMetadata() ) );
        refUpdateDto.setPublished( ref.getPublished() );
        refUpdateDto.setCreated( ref.getCreated() );
        refUpdateDto.setModified( ref.getModified() );

        publicTags( refUpdateDto );

        return refUpdateDto;
    }

    protected Map<String, Integer> stringLongMapToStringIntegerMap(Map<String, Long> map) {
        if ( map == null ) {
            return null;
        }

        Map<String, Integer> map1 = LinkedHashMap.newLinkedHashMap( map.size() );

        for ( java.util.Map.Entry<String, Long> entry : map.entrySet() ) {
            String key = entry.getKey();
            Integer value = entry.getValue().intValue();
            map1.put( key, value );
        }

        return map1;
    }

    protected MetadataDto metadataToMetadataDto(Metadata metadata) {
        if ( metadata == null ) {
            return null;
        }

        MetadataDto metadataDto = new MetadataDto();

        metadataDto.setModified( metadata.getModified() );
        metadataDto.setResponses( countMetadata( metadata.getResponses() ) );
        metadataDto.setInternalResponses( countMetadata( metadata.getInternalResponses() ) );
        metadataDto.setPlugins( stringLongMapToStringIntegerMap( metadata.getPlugins() ) );
        metadataDto.setObsolete( metadata.isObsolete() );

        return metadataDto;
    }

    protected ExternalDto externalToExternalDto(External external) {
        if ( external == null ) {
            return null;
        }

        ExternalDto externalDto = new ExternalDto();

        List<String> list = external.getIds();
        if ( list != null ) {
            externalDto.setIds( new ArrayList<String>( list ) );
        }

        return externalDto;
    }

    protected MetadataUpdateDto metadataDtoToMetadataUpdateDto(MetadataDto metadataDto) {
        if ( metadataDto == null ) {
            return null;
        }

        MetadataUpdateDto metadataUpdateDto = new MetadataUpdateDto();

        metadataUpdateDto.setModified( metadataDto.getModified() );
        metadataUpdateDto.setResponses( metadataDto.getResponses() );
        metadataUpdateDto.setInternalResponses( metadataDto.getInternalResponses() );
        Map<String, Integer> map = metadataDto.getPlugins();
        if ( map != null ) {
            metadataUpdateDto.setPlugins( new LinkedHashMap<String, Integer>( map ) );
        }
        metadataUpdateDto.setObsolete( metadataDto.isObsolete() );

        publicMetadata( metadataUpdateDto );

        return metadataUpdateDto;
    }
}