DtoMapperImpl.java

package jasper.service.dto;

import jasper.component.Storage;
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 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 DtoMapperImpl extends DtoMapper {

    @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() );

        filterTags( refDto );
        filterPlugins( refDto );

        return refDto;
    }

    @Override
    public RefNodeDto domainToNodeDto(Ref ref) {
        if ( ref == null ) {
            return null;
        }

        RefNodeDto refNodeDto = new RefNodeDto();

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

        filterTags( refNodeDto );
        filterPlugins( refNodeDto );

        return refNodeDto;
    }

    @Override
    public RefReplDto dtoToRepl(RefDto ref) {
        if ( ref == null ) {
            return null;
        }

        RefReplDto refReplDto = new RefReplDto();

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

        filterTags( refReplDto );
        filterPlugins( refReplDto );

        return refReplDto;
    }

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

        ExtDto extDto = new ExtDto();

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

        return extDto;
    }

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

        UserDto userDto = new UserDto();

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

        filterTags( userDto );

        return userDto;
    }

    @Override
    public ExternalDto domainToDto(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;
    }

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

        PluginDto pluginDto = new PluginDto();

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

        return pluginDto;
    }

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

        TemplateDto templateDto = new TemplateDto();

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

        return templateDto;
    }

    @Override
    public BackupDto domainToDto(Storage.StorageRef plugin) {
        if ( plugin == null ) {
            return null;
        }

        BackupDto.BackupDtoBuilder backupDto = BackupDto.builder();

        backupDto.id( plugin.id() );
        backupDto.size( plugin.size() );

        return backupDto.build();
    }

    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() );

        filterMetadata( metadataDto );
        userUrlsMetadata( metadata, metadataDto );

        return metadataDto;
    }

    private List<String> refMetadataResponses(Ref ref) {
        Metadata metadata = ref.getMetadata();
        if ( metadata == null ) {
            return null;
        }
        return metadata.getResponses();
    }
}