df

@Service("contributionPersistenceService")
@Slf4j
@Transactional(
        rollbackFor = {
                ResourceForbiddenException.class,
                ResourceNotFoundException.class,
                ResourceConflictException.class,
                ConstraintViolationException.class
        }
)
@Validated
public class ContributionPersistenceServiceImpl implements ContributionPersistenceService {

    private final MovieRepository movieRepository;
    private final MovieInfoRepository movieInfoRepository;
    private final ContributionRepository contributionRepository;
    private final UserRepository userRepository;
    private final MoviePersistenceService moviePersistenceService;

    @PersistenceContext
    private EntityManager entityManager;

    /**
     * Constructor.
     *
     * @param movieRepository The movie repository to use
     * @param movieInfoRepository The movie info repository to use
     * @param contributionRepository The contribution repository to use
     * @param userRepository The user repository to use
     */
    @Autowired
    public ContributionPersistenceServiceImpl(
            @NotNull final MovieRepository movieRepository,
            @NotNull final MovieInfoRepository movieInfoRepository,
            @NotNull final ContributionRepository contributionRepository,
            @NotNull final UserRepository userRepository,
            @NotNull final MoviePersistenceService moviePersistenceService
    ) {
        this.movieRepository = movieRepository;
        this.movieInfoRepository = movieInfoRepository;
        this.contributionRepository = contributionRepository;
        this.userRepository = userRepository;
        this.moviePersistenceService = moviePersistenceService;
    }

    @Override
    public void updateOtherTitleContribution(
            ContributionUpdate<OtherTitle> contribution,
            Long contributionId,
            Long userId
    ) throws ResourceNotFoundException {
        log.info("Called with contribution {}, contributionId {}, userId {}",
                contribution, contributionId, userId);

        final UserEntity user = this.findUser(userId);
        final ContributionEntity contributionEntity = this.findContribution(contributionId, EditStatus.WAITING, user, MovieField.OTHER_TITLE);

        this.cleanUpIdsToAdd(contributionEntity.getIdsToAdd(), contribution.getElementsToAdd().keySet(), contributionEntity.getMovie().getOtherTitles());

        contribution.getNewElementsToAdd()
                .forEach(otherTitle -> {
                    final Long id = this.moviePersistenceService.createOtherTitle(otherTitle, contributionEntity.getMovie(), user);
                    contributionEntity.getIdsToAdd().add(id);
                });
    }

    private UserEntity findUser(final Long id) {
        return this.userRepository
                .findByIdAndEnabledTrue(id)
                .orElseThrow(() -> new ResourceNotFoundException("No user found with id " + id));
    }

    private ContributionEntity findContribution(final Long id, final EditStatus status, final UserEntity user, final MovieField field) {
        return this.contributionRepository
                .findByIdAndStatusAndUserAndField(id, status, user, field)
                .orElseThrow(() -> new ResourceNotFoundException("No contribution found with id " + id));
    }


    private void cleanUpIdsToAdd(final List<Long> idsToAddFromEntity, final Set<Long> idsToAddFromDto,
                                 final List<? extends MovieInfo> entites) {
        for (final Iterator<Long> it = idsToAddFromEntity.iterator(); it.hasNext(); ) {
            final Long id = it.next();
            if (!idsToAddFromDto.contains(id)) {
                it.remove();
                entites.removeIf(movieInfo -> movieInfo.getId().equals(id));
            }
        }
    }
}



@Service("moviePersistenceService")
@Slf4j
@Transactional(
        rollbackFor = {
                ResourceForbiddenException.class,
                ResourceNotFoundException.class,
                ResourceConflictException.class,
                ConstraintViolationException.class
        }
)
@Validated
public class MoviePersistenceServiceImpl implements MoviePersistenceService {
...
   @Override
    public Long createOtherTitle(
            @NotNull @Valid final OtherTitle otherTitle,
            @NotNull final MovieEntity movie,
            @NotNull final UserEntity user
    ) {
        final MovieOtherTitle movieOtherTitle = new MovieOtherTitle(otherTitle.getTitle(), otherTitle.getCountry());
        movieOtherTitle.setMovie(movie);
        movieOtherTitle.setUser(user);

        movie.getOtherTitles().add(movieOtherTitle);

        this.movieRepository.save(movie);

        return Iterables.getLast(movie.getOtherTitles()).getId();
    }
}