UserMapperImpl.java

package com.wilzwert.myjobs.infrastructure.persistence.mongo.mapper;

import com.wilzwert.myjobs.core.domain.model.job.JobStatus;
import com.wilzwert.myjobs.core.domain.model.job.JobStatusMeta;
import com.wilzwert.myjobs.core.domain.model.user.EmailStatus;
import com.wilzwert.myjobs.core.domain.model.user.Lang;
import com.wilzwert.myjobs.core.domain.model.user.User;
import com.wilzwert.myjobs.core.domain.model.user.UserId;
import com.wilzwert.myjobs.core.domain.model.user.UserSummary;
import com.wilzwert.myjobs.core.domain.model.user.UserView;
import com.wilzwert.myjobs.core.domain.model.user.command.RegisterUserCommand;
import com.wilzwert.myjobs.core.domain.model.user.command.UpdateUserCommand;
import com.wilzwert.myjobs.infrastructure.api.rest.dto.RegisterUserRequest;
import com.wilzwert.myjobs.infrastructure.api.rest.dto.UpdateUserRequest;
import com.wilzwert.myjobs.infrastructure.api.rest.dto.UserResponse;
import com.wilzwert.myjobs.infrastructure.api.rest.dto.UserSummaryResponse;
import com.wilzwert.myjobs.infrastructure.persistence.mongo.entity.MongoUser;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.processing.Generated;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2025-06-18T09:42:43+0000",
    comments = "version: 1.6.2, compiler: javac, environment: Java 21.0.7 (Eclipse Adoptium)"
)
@Component
public class UserMapperImpl implements UserMapper {

    @Autowired
    private IdMapper idMapper;

    @Override
    public UserResponse toResponseFromView(UserView view) {
        if ( view == null ) {
            return null;
        }

        UserResponse.UserResponseBuilder userResponse = UserResponse.builder();

        userResponse.firstName( view.getFirstName() );
        userResponse.lastName( view.getLastName() );
        userResponse.email( view.getEmail() );
        userResponse.username( view.getUsername() );
        userResponse.createdAt( view.getCreatedAt() );
        if ( view.getEmailStatus() != null ) {
            userResponse.emailStatus( view.getEmailStatus().name() );
        }
        userResponse.jobFollowUpReminderDays( view.getJobFollowUpReminderDays() );
        userResponse.jobFollowUpReminderSentAt( view.getJobFollowUpReminderSentAt() );
        userResponse.lang( view.getLang() );

        return userResponse.build();
    }

    @Override
    public UserView toDomainView(MongoUser entity) {
        if ( entity == null ) {
            return null;
        }

        UserView.Builder userView = UserView.builder();

        userView.email( entity.getEmail() );
        if ( entity.getEmailStatus() != null ) {
            userView.emailStatus( Enum.valueOf( EmailStatus.class, entity.getEmailStatus() ) );
        }
        userView.username( entity.getUsername() );
        userView.firstName( entity.getFirstName() );
        userView.lastName( entity.getLastName() );
        userView.jobFollowUpReminderDays( entity.getJobFollowUpReminderDays() );
        userView.createdAt( entity.getCreatedAt() );
        userView.lang( entity.getLang() );
        userView.jobFollowUpReminderSentAt( entity.getJobFollowUpReminderSentAt() );

        return userView.build();
    }

    @Override
    public List<UserView> toDomainView(List<MongoUser> entity) {
        if ( entity == null ) {
            return null;
        }

        List<UserView> list = new ArrayList<UserView>( entity.size() );
        for ( MongoUser mongoUser : entity ) {
            list.add( toDomainView( mongoUser ) );
        }

        return list;
    }

    @Override
    public List<UserResponse> toResponseFromView(List<UserView> views) {
        if ( views == null ) {
            return null;
        }

        List<UserResponse> list = new ArrayList<UserResponse>( views.size() );
        for ( UserView userView : views ) {
            list.add( toResponseFromView( userView ) );
        }

        return list;
    }

    @Override
    public MongoUser toEntity(User domain) {
        if ( domain == null ) {
            return null;
        }

        MongoUser mongoUser = new MongoUser();

        mongoUser.setId( idMapper.toEntity( domain.getId() ) );
        mongoUser.setEmail( domain.getEmail() );
        if ( domain.getEmailStatus() != null ) {
            mongoUser.setEmailStatus( domain.getEmailStatus().name() );
        }
        mongoUser.setEmailValidationCode( domain.getEmailValidationCode() );
        mongoUser.setPassword( domain.getPassword() );
        mongoUser.setUsername( domain.getUsername() );
        mongoUser.setFirstName( domain.getFirstName() );
        mongoUser.setLastName( domain.getLastName() );
        mongoUser.setJobFollowUpReminderDays( domain.getJobFollowUpReminderDays() );
        mongoUser.setLang( domain.getLang() );
        mongoUser.setRole( domain.getRole() );
        mongoUser.setResetPasswordToken( domain.getResetPasswordToken() );
        mongoUser.setResetPasswordExpiresAt( domain.getResetPasswordExpiresAt() );
        mongoUser.setCreatedAt( domain.getCreatedAt() );
        mongoUser.setUpdatedAt( domain.getUpdatedAt() );
        mongoUser.setJobFollowUpReminderSentAt( domain.getJobFollowUpReminderSentAt() );

        return mongoUser;
    }

    @Override
    public List<MongoUser> toEntity(List<User> domains) {
        if ( domains == null ) {
            return null;
        }

        List<MongoUser> list = new ArrayList<MongoUser>( domains.size() );
        for ( User user : domains ) {
            list.add( toEntity( user ) );
        }

        return list;
    }

    @Override
    public User toDomain(MongoUser entity) {
        if ( entity == null ) {
            return null;
        }

        User.Builder user = User.builder();

        user.id( idMapper.mapUserId( entity.getId() ) );
        user.email( entity.getEmail() );
        if ( entity.getEmailStatus() != null ) {
            user.emailStatus( Enum.valueOf( EmailStatus.class, entity.getEmailStatus() ) );
        }
        user.emailValidationCode( entity.getEmailValidationCode() );
        user.password( entity.getPassword() );
        user.username( entity.getUsername() );
        user.firstName( entity.getFirstName() );
        user.lastName( entity.getLastName() );
        user.jobFollowUpReminderDays( entity.getJobFollowUpReminderDays() );
        user.lang( entity.getLang() );
        user.role( entity.getRole() );
        user.resetPasswordToken( entity.getResetPasswordToken() );
        user.resetPasswordExpiresAt( entity.getResetPasswordExpiresAt() );
        user.createdAt( entity.getCreatedAt() );
        user.updatedAt( entity.getUpdatedAt() );
        user.jobFollowUpReminderSentAt( entity.getJobFollowUpReminderSentAt() );

        return user.build();
    }

    @Override
    public List<User> toDomain(List<MongoUser> entities) {
        if ( entities == null ) {
            return null;
        }

        List<User> list = new ArrayList<User>( entities.size() );
        for ( MongoUser mongoUser : entities ) {
            list.add( toDomain( mongoUser ) );
        }

        return list;
    }

    @Override
    public UserResponse toResponse(User domain) {
        if ( domain == null ) {
            return null;
        }

        UserResponse.UserResponseBuilder userResponse = UserResponse.builder();

        userResponse.firstName( domain.getFirstName() );
        userResponse.lastName( domain.getLastName() );
        userResponse.email( domain.getEmail() );
        userResponse.username( domain.getUsername() );
        userResponse.createdAt( domain.getCreatedAt() );
        if ( domain.getEmailStatus() != null ) {
            userResponse.emailStatus( domain.getEmailStatus().name() );
        }
        userResponse.jobFollowUpReminderDays( domain.getJobFollowUpReminderDays() );
        userResponse.jobFollowUpReminderSentAt( domain.getJobFollowUpReminderSentAt() );
        userResponse.lang( domain.getLang() );

        return userResponse.build();
    }

    @Override
    public List<UserResponse> toResponse(List<User> domains) {
        if ( domains == null ) {
            return null;
        }

        List<UserResponse> list = new ArrayList<UserResponse>( domains.size() );
        for ( User user : domains ) {
            list.add( toResponse( user ) );
        }

        return list;
    }

    @Override
    public RegisterUserCommand toCommand(RegisterUserRequest request) {
        if ( request == null ) {
            return null;
        }

        String email = null;
        String password = null;
        String username = null;
        String firstName = null;
        String lastName = null;
        Lang lang = null;
        Integer jobFollowUpReminderDays = null;

        email = request.getEmail();
        password = request.getPassword();
        username = request.getUsername();
        firstName = request.getFirstName();
        lastName = request.getLastName();
        if ( request.getLang() != null ) {
            lang = Enum.valueOf( Lang.class, request.getLang() );
        }
        jobFollowUpReminderDays = request.getJobFollowUpReminderDays();

        RegisterUserCommand registerUserCommand = new RegisterUserCommand( email, password, username, firstName, lastName, lang, jobFollowUpReminderDays );

        return registerUserCommand;
    }

    @Override
    public UpdateUserCommand toUpdateCommand(UpdateUserRequest request) {
        if ( request == null ) {
            return null;
        }

        String email = null;
        String username = null;
        String firstName = null;
        String lastName = null;
        Integer jobFollowUpReminderDays = null;

        email = request.getEmail();
        username = request.getUsername();
        firstName = request.getFirstName();
        lastName = request.getLastName();
        jobFollowUpReminderDays = request.getJobFollowUpReminderDays();

        UserId userId = null;

        UpdateUserCommand updateUserCommand = new UpdateUserCommand( email, username, firstName, lastName, jobFollowUpReminderDays, userId );

        return updateUserCommand;
    }

    @Override
    public UpdateUserCommand toUpdateCommand(UpdateUserRequest updateUserRequest, UserId userId) {
        if ( updateUserRequest == null && userId == null ) {
            return null;
        }

        String email = null;
        String username = null;
        String firstName = null;
        String lastName = null;
        Integer jobFollowUpReminderDays = null;
        if ( updateUserRequest != null ) {
            email = updateUserRequest.getEmail();
            username = updateUserRequest.getUsername();
            firstName = updateUserRequest.getFirstName();
            lastName = updateUserRequest.getLastName();
            jobFollowUpReminderDays = updateUserRequest.getJobFollowUpReminderDays();
        }
        UserId userId1 = null;
        userId1 = userId;

        UpdateUserCommand updateUserCommand = new UpdateUserCommand( email, username, firstName, lastName, jobFollowUpReminderDays, userId1 );

        return updateUserCommand;
    }

    @Override
    public UserSummaryResponse toResponse(UserSummary userSummary) {
        if ( userSummary == null ) {
            return null;
        }

        UserSummaryResponse.UserSummaryResponseBuilder userSummaryResponse = UserSummaryResponse.builder();

        userSummaryResponse.jobsCount( userSummary.getJobsCount() );
        userSummaryResponse.activeJobsCount( userSummary.getActiveJobsCount() );
        userSummaryResponse.inactiveJobsCount( userSummary.getInactiveJobsCount() );
        userSummaryResponse.lateJobsCount( userSummary.getLateJobsCount() );
        Map<JobStatus, Integer> map = userSummary.getJobStatuses();
        if ( map != null ) {
            userSummaryResponse.jobStatuses( new LinkedHashMap<JobStatus, Integer>( map ) );
        }
        Set<JobStatusMeta> set = userSummary.getUsableJobStatusMetas();
        if ( set != null ) {
            userSummaryResponse.usableJobStatusMetas( new LinkedHashSet<JobStatusMeta>( set ) );
        }

        return userSummaryResponse.build();
    }
}