BoardGameMapperImpl.java

package com.codecool.bytebattlers.mapper;

import com.codecool.bytebattlers.controller.dto.BoardGameDto;
import com.codecool.bytebattlers.model.BoardGame;
import com.codecool.bytebattlers.model.Category;
import com.codecool.bytebattlers.model.Publisher;
import com.codecool.bytebattlers.model.Rating;
import com.codecool.bytebattlers.model.Review;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.UUID;
import javax.annotation.processing.Generated;
import org.springframework.stereotype.Component;

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2025-01-25T06:38:34+0000",
    comments = "version: 1.5.5.Final, compiler: javac, environment: Java 17.0.14 (Azul Systems, Inc.)"
)
@Component
public class BoardGameMapperImpl implements BoardGameMapper {

    @Override
    public BoardGame toEntity(BoardGameDto boardGameDto) {
        if ( boardGameDto == null ) {
            return null;
        }

        BoardGame boardGame = new BoardGame();

        boardGame.setPublisher( boardGameDtoToPublisher( boardGameDto ) );
        boardGame.setPublicID( boardGameDto.publicID() );
        boardGame.setGameName( boardGameDto.gameName() );
        boardGame.setMinPlayer( boardGameDto.minPlayer() );
        boardGame.setMaxPlayer( boardGameDto.maxPlayer() );
        boardGame.setPlayTimeInMinutes( boardGameDto.playTimeInMinutes() );
        boardGame.setCategories( categoryDto1SetToCategorySet( boardGameDto.categories() ) );
        boardGame.setRecommendedAge( boardGameDto.recommendedAge() );
        boardGame.setDescription( boardGameDto.description() );
        boardGame.setReviews( reviewDto1SetToReviewSet( boardGameDto.reviews() ) );
        boardGame.setRatings( ratingDtoSetToRatingSet( boardGameDto.ratings() ) );

        linkReviews( boardGame );
        linkRatings( boardGame );

        return boardGame;
    }

    @Override
    public BoardGameDto toDto(BoardGame boardGame) {
        if ( boardGame == null ) {
            return null;
        }

        String publisherPublisherName = null;
        UUID publisherPublicID = null;
        UUID publicID = null;
        String gameName = null;
        int minPlayer = 0;
        int maxPlayer = 0;
        int playTimeInMinutes = 0;
        Set<BoardGameDto.CategoryDto1> categories = null;
        int recommendedAge = 0;
        String description = null;
        Set<BoardGameDto.ReviewDto1> reviews = null;
        Set<BoardGameDto.RatingDto> ratings = null;

        publisherPublisherName = boardGamePublisherPublisherName( boardGame );
        publisherPublicID = boardGamePublisherPublicID( boardGame );
        publicID = boardGame.getPublicID();
        gameName = boardGame.getGameName();
        minPlayer = boardGame.getMinPlayer();
        maxPlayer = boardGame.getMaxPlayer();
        playTimeInMinutes = boardGame.getPlayTimeInMinutes();
        categories = categorySetToCategoryDto1Set( boardGame.getCategories() );
        recommendedAge = boardGame.getRecommendedAge();
        description = boardGame.getDescription();
        reviews = reviewSetToReviewDto1Set( boardGame.getReviews() );
        ratings = ratingSetToRatingDtoSet( boardGame.getRatings() );

        Set<UUID> appUserPublicIDS = null;

        BoardGameDto boardGameDto = new BoardGameDto( publicID, gameName, minPlayer, maxPlayer, playTimeInMinutes, categories, recommendedAge, description, publisherPublicID, publisherPublisherName, reviews, appUserPublicIDS, ratings );

        return boardGameDto;
    }

    @Override
    public BoardGame partialUpdate(BoardGameDto boardGameDto, BoardGame boardGame) {
        if ( boardGameDto == null ) {
            return boardGame;
        }

        if ( boardGame.getPublisher() == null ) {
            boardGame.setPublisher( new Publisher() );
        }
        boardGameDtoToPublisher1( boardGameDto, boardGame.getPublisher() );
        if ( boardGameDto.publicID() != null ) {
            boardGame.setPublicID( boardGameDto.publicID() );
        }
        if ( boardGameDto.gameName() != null ) {
            boardGame.setGameName( boardGameDto.gameName() );
        }
        boardGame.setMinPlayer( boardGameDto.minPlayer() );
        boardGame.setMaxPlayer( boardGameDto.maxPlayer() );
        boardGame.setPlayTimeInMinutes( boardGameDto.playTimeInMinutes() );
        if ( boardGame.getCategories() != null ) {
            Set<Category> set = categoryDto1SetToCategorySet( boardGameDto.categories() );
            if ( set != null ) {
                boardGame.getCategories().clear();
                boardGame.getCategories().addAll( set );
            }
        }
        else {
            Set<Category> set = categoryDto1SetToCategorySet( boardGameDto.categories() );
            if ( set != null ) {
                boardGame.setCategories( set );
            }
        }
        boardGame.setRecommendedAge( boardGameDto.recommendedAge() );
        if ( boardGameDto.description() != null ) {
            boardGame.setDescription( boardGameDto.description() );
        }
        if ( boardGame.getReviews() != null ) {
            Set<Review> set1 = reviewDto1SetToReviewSet( boardGameDto.reviews() );
            if ( set1 != null ) {
                boardGame.getReviews().clear();
                boardGame.getReviews().addAll( set1 );
            }
        }
        else {
            Set<Review> set1 = reviewDto1SetToReviewSet( boardGameDto.reviews() );
            if ( set1 != null ) {
                boardGame.setReviews( set1 );
            }
        }
        if ( boardGame.getRatings() != null ) {
            Set<Rating> set2 = ratingDtoSetToRatingSet( boardGameDto.ratings() );
            if ( set2 != null ) {
                boardGame.getRatings().clear();
                boardGame.getRatings().addAll( set2 );
            }
        }
        else {
            Set<Rating> set2 = ratingDtoSetToRatingSet( boardGameDto.ratings() );
            if ( set2 != null ) {
                boardGame.setRatings( set2 );
            }
        }

        linkReviews( boardGame );
        linkRatings( boardGame );

        return boardGame;
    }

    protected Publisher boardGameDtoToPublisher(BoardGameDto boardGameDto) {
        if ( boardGameDto == null ) {
            return null;
        }

        Publisher publisher = new Publisher();

        publisher.setPublisherName( boardGameDto.publisherPublisherName() );
        publisher.setPublicID( boardGameDto.publisherPublicID() );

        return publisher;
    }

    protected Category categoryDto1ToCategory(BoardGameDto.CategoryDto1 categoryDto1) {
        if ( categoryDto1 == null ) {
            return null;
        }

        Category category = new Category();

        category.setPublicID( categoryDto1.publicID() );
        category.setName( categoryDto1.name() );
        category.setDescription( categoryDto1.description() );

        return category;
    }

    protected Set<Category> categoryDto1SetToCategorySet(Set<BoardGameDto.CategoryDto1> set) {
        if ( set == null ) {
            return null;
        }

        Set<Category> set1 = new LinkedHashSet<Category>( Math.max( (int) ( set.size() / .75f ) + 1, 16 ) );
        for ( BoardGameDto.CategoryDto1 categoryDto1 : set ) {
            set1.add( categoryDto1ToCategory( categoryDto1 ) );
        }

        return set1;
    }

    protected Review reviewDto1ToReview(BoardGameDto.ReviewDto1 reviewDto1) {
        if ( reviewDto1 == null ) {
            return null;
        }

        Review review = new Review();

        review.setPublicID( reviewDto1.publicID() );
        review.setDescription( reviewDto1.description() );

        return review;
    }

    protected Set<Review> reviewDto1SetToReviewSet(Set<BoardGameDto.ReviewDto1> set) {
        if ( set == null ) {
            return null;
        }

        Set<Review> set1 = new LinkedHashSet<Review>( Math.max( (int) ( set.size() / .75f ) + 1, 16 ) );
        for ( BoardGameDto.ReviewDto1 reviewDto1 : set ) {
            set1.add( reviewDto1ToReview( reviewDto1 ) );
        }

        return set1;
    }

    protected Rating ratingDtoToRating(BoardGameDto.RatingDto ratingDto) {
        if ( ratingDto == null ) {
            return null;
        }

        Rating rating = new Rating();

        rating.setRatingNumber( ratingDto.ratingNumber() );

        return rating;
    }

    protected Set<Rating> ratingDtoSetToRatingSet(Set<BoardGameDto.RatingDto> set) {
        if ( set == null ) {
            return null;
        }

        Set<Rating> set1 = new LinkedHashSet<Rating>( Math.max( (int) ( set.size() / .75f ) + 1, 16 ) );
        for ( BoardGameDto.RatingDto ratingDto : set ) {
            set1.add( ratingDtoToRating( ratingDto ) );
        }

        return set1;
    }

    private String boardGamePublisherPublisherName(BoardGame boardGame) {
        if ( boardGame == null ) {
            return null;
        }
        Publisher publisher = boardGame.getPublisher();
        if ( publisher == null ) {
            return null;
        }
        String publisherName = publisher.getPublisherName();
        if ( publisherName == null ) {
            return null;
        }
        return publisherName;
    }

    private UUID boardGamePublisherPublicID(BoardGame boardGame) {
        if ( boardGame == null ) {
            return null;
        }
        Publisher publisher = boardGame.getPublisher();
        if ( publisher == null ) {
            return null;
        }
        UUID publicID = publisher.getPublicID();
        if ( publicID == null ) {
            return null;
        }
        return publicID;
    }

    protected BoardGameDto.CategoryDto1 categoryToCategoryDto1(Category category) {
        if ( category == null ) {
            return null;
        }

        UUID publicID = null;
        String name = null;
        String description = null;

        publicID = category.getPublicID();
        name = category.getName();
        description = category.getDescription();

        BoardGameDto.CategoryDto1 categoryDto1 = new BoardGameDto.CategoryDto1( publicID, name, description );

        return categoryDto1;
    }

    protected Set<BoardGameDto.CategoryDto1> categorySetToCategoryDto1Set(Set<Category> set) {
        if ( set == null ) {
            return null;
        }

        Set<BoardGameDto.CategoryDto1> set1 = new LinkedHashSet<BoardGameDto.CategoryDto1>( Math.max( (int) ( set.size() / .75f ) + 1, 16 ) );
        for ( Category category : set ) {
            set1.add( categoryToCategoryDto1( category ) );
        }

        return set1;
    }

    protected BoardGameDto.ReviewDto1 reviewToReviewDto1(Review review) {
        if ( review == null ) {
            return null;
        }

        UUID publicID = null;
        String description = null;

        publicID = review.getPublicID();
        description = review.getDescription();

        BoardGameDto.ReviewDto1 reviewDto1 = new BoardGameDto.ReviewDto1( publicID, description );

        return reviewDto1;
    }

    protected Set<BoardGameDto.ReviewDto1> reviewSetToReviewDto1Set(Set<Review> set) {
        if ( set == null ) {
            return null;
        }

        Set<BoardGameDto.ReviewDto1> set1 = new LinkedHashSet<BoardGameDto.ReviewDto1>( Math.max( (int) ( set.size() / .75f ) + 1, 16 ) );
        for ( Review review : set ) {
            set1.add( reviewToReviewDto1( review ) );
        }

        return set1;
    }

    protected BoardGameDto.RatingDto ratingToRatingDto(Rating rating) {
        if ( rating == null ) {
            return null;
        }

        Double ratingNumber = null;

        ratingNumber = rating.getRatingNumber();

        BoardGameDto.RatingDto ratingDto = new BoardGameDto.RatingDto( ratingNumber );

        return ratingDto;
    }

    protected Set<BoardGameDto.RatingDto> ratingSetToRatingDtoSet(Set<Rating> set) {
        if ( set == null ) {
            return null;
        }

        Set<BoardGameDto.RatingDto> set1 = new LinkedHashSet<BoardGameDto.RatingDto>( Math.max( (int) ( set.size() / .75f ) + 1, 16 ) );
        for ( Rating rating : set ) {
            set1.add( ratingToRatingDto( rating ) );
        }

        return set1;
    }

    protected void boardGameDtoToPublisher1(BoardGameDto boardGameDto, Publisher mappingTarget) {
        if ( boardGameDto == null ) {
            return;
        }

        if ( boardGameDto.publisherPublisherName() != null ) {
            mappingTarget.setPublisherName( boardGameDto.publisherPublisherName() );
        }
        if ( boardGameDto.publisherPublicID() != null ) {
            mappingTarget.setPublicID( boardGameDto.publisherPublicID() );
        }
    }
}