com.arextest.schedule.model.converter.ReplayNoiseConverterImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of arex-schedule-web-api
There is a newer version: 2.0.4
package com.arextest.schedule.model.converter;

import com.arextest.diff.model.log.NodeEntity;
import com.arextest.schedule.model.dao.mongodb.ReplayNoiseCollection;
import com.arextest.schedule.model.noiseidentify.QueryNoiseResponseType;
import com.arextest.schedule.model.noiseidentify.ReplayNoiseDto;
import com.arextest.schedule.model.noiseidentify.ReplayNoiseItemDto;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Generated;

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2024-08-22T12:50:10+0000",
    comments = "version: 1.5.5.Final, compiler: javac, environment: Java 11.0.24 (Eclipse Adoptium)"
)
public class ReplayNoiseConverterImpl implements ReplayNoiseConverter {

    @Override
    public ReplayNoiseCollection daoFromDto(ReplayNoiseDto dto) {
        if ( dto == null ) {
            return null;
        }

        ReplayNoiseCollection replayNoiseCollection = new ReplayNoiseCollection();

        replayNoiseCollection.setPlanId( dto.getPlanId() );
        replayNoiseCollection.setPlanItemId( dto.getPlanItemId() );
        replayNoiseCollection.setCategoryName( dto.getCategoryName() );
        replayNoiseCollection.setOperationId( dto.getOperationId() );
        replayNoiseCollection.setOperationName( dto.getOperationName() );
        replayNoiseCollection.setMayIgnoreItems( stringReplayNoiseItemDtoMapToStringReplayNoiseItemDaoMap( dto.getMayIgnoreItems() ) );
        replayNoiseCollection.setMayDisorderItems( stringReplayNoiseItemDtoMapToStringReplayNoiseItemDaoMap( dto.getMayDisorderItems() ) );

        return replayNoiseCollection;
    }

    @Override
    public ReplayNoiseDto dtoFromDao(ReplayNoiseCollection dao) {
        if ( dao == null ) {
            return null;
        }

        ReplayNoiseDto replayNoiseDto = new ReplayNoiseDto();

        replayNoiseDto.setPlanId( dao.getPlanId() );
        replayNoiseDto.setPlanItemId( dao.getPlanItemId() );
        replayNoiseDto.setCategoryName( dao.getCategoryName() );
        replayNoiseDto.setOperationId( dao.getOperationId() );
        replayNoiseDto.setOperationName( dao.getOperationName() );
        replayNoiseDto.setMayIgnoreItems( stringReplayNoiseItemDaoMapToStringReplayNoiseItemDtoMap( dao.getMayIgnoreItems() ) );
        replayNoiseDto.setMayDisorderItems( stringReplayNoiseItemDaoMapToStringReplayNoiseItemDtoMap( dao.getMayDisorderItems() ) );

        return replayNoiseDto;
    }

    @Override
    public ReplayNoiseCollection.ReplayNoiseItemDao daoFromDto(ReplayNoiseItemDto dto) {
        if ( dto == null ) {
            return null;
        }

        ReplayNoiseCollection.ReplayNoiseItemDao replayNoiseItemDao = new ReplayNoiseCollection.ReplayNoiseItemDao();

        List list = dto.getNodePath();
        if ( list != null ) {
            replayNoiseItemDao.setNodePath( new ArrayList( list ) );
        }
        List list1 = dto.getLogIndexes();
        if ( list1 != null ) {
            replayNoiseItemDao.setLogIndexes( new ArrayList( list1 ) );
        }
        Map map = dto.getSubPaths();
        if ( map != null ) {
            replayNoiseItemDao.setSubPaths( new LinkedHashMap( map ) );
        }
        replayNoiseItemDao.setPathCount( dto.getPathCount() );
        replayNoiseItemDao.setCaseCount( dto.getCaseCount() );
        replayNoiseItemDao.setStatus( dto.getStatus() );

        replayNoiseItemDao.setCompareResultId( dto == null || dto.getCompareResult() == null ? null : dto.getCompareResult().getId() );

        return replayNoiseItemDao;
    }

    @Override
    public ReplayNoiseItemDto dtoFromDao(ReplayNoiseCollection.ReplayNoiseItemDao dao) {
        if ( dao == null ) {
            return null;
        }

        ReplayNoiseItemDto replayNoiseItemDto = new ReplayNoiseItemDto();

        List list = dao.getNodePath();
        if ( list != null ) {
            replayNoiseItemDto.setNodePath( new ArrayList( list ) );
        }
        replayNoiseItemDto.setCompareResultId( dao.getCompareResultId() );
        List list1 = dao.getLogIndexes();
        if ( list1 != null ) {
            replayNoiseItemDto.setLogIndexes( new ArrayList( list1 ) );
        }
        Map map = dao.getSubPaths();
        if ( map != null ) {
            replayNoiseItemDto.setSubPaths( new LinkedHashMap( map ) );
        }
        if ( dao.getCaseCount() != null ) {
            replayNoiseItemDto.setCaseCount( dao.getCaseCount() );
        }
        replayNoiseItemDto.setStatus( dao.getStatus() );

        return replayNoiseItemDto;
    }

    @Override
    public QueryNoiseResponseType.NoiseItem toNoiseItem(ReplayNoiseItemDto dto) {
        if ( dto == null ) {
            return null;
        }

        QueryNoiseResponseType.NoiseItem noiseItem = new QueryNoiseResponseType.NoiseItem();

        List list = dto.getNodePath();
        if ( list != null ) {
            noiseItem.setNodeEntity( new ArrayList( list ) );
        }
        List list1 = dto.getLogIndexes();
        if ( list1 != null ) {
            noiseItem.setLogIndexes( new ArrayList( list1 ) );
        }
        noiseItem.setCompareResultId( dto.getCompareResultId() );
        noiseItem.setStatus( dto.getStatus() );

        return noiseItem;
    }

    protected Map stringReplayNoiseItemDtoMapToStringReplayNoiseItemDaoMap(Map map) {
        if ( map == null ) {
            return null;
        }

        Map map1 = new LinkedHashMap( Math.max( (int) ( map.size() / .75f ) + 1, 16 ) );

        for ( java.util.Map.Entry entry : map.entrySet() ) {
            String key = entry.getKey();
            ReplayNoiseCollection.ReplayNoiseItemDao value = daoFromDto( entry.getValue() );
            map1.put( key, value );
        }

        return map1;
    }

    protected Map stringReplayNoiseItemDaoMapToStringReplayNoiseItemDtoMap(Map map) {
        if ( map == null ) {
            return null;
        }

        Map map1 = new LinkedHashMap( Math.max( (int) ( map.size() / .75f ) + 1, 16 ) );

        for ( java.util.Map.Entry entry : map.entrySet() ) {
            String key = entry.getKey();
            ReplayNoiseItemDto value = dtoFromDao( entry.getValue() );
            map1.put( key, value );
        }

        return map1;
    }
}