org.cloudfoundry.multiapps.controller.persistence.services.AsyncUploadJobService Maven / Gradle / Ivy

Go to download
package org.cloudfoundry.multiapps.controller.persistence.services;

import jakarta.inject.Inject;
import jakarta.inject.Named;
import jakarta.persistence.EntityManagerFactory;

import org.cloudfoundry.multiapps.common.ConflictException;
import org.cloudfoundry.multiapps.common.NotFoundException;
import org.cloudfoundry.multiapps.controller.persistence.Messages;
import org.cloudfoundry.multiapps.controller.persistence.dto.AsyncUploadJobDto;
import org.cloudfoundry.multiapps.controller.persistence.model.AsyncUploadJobEntry;
import org.cloudfoundry.multiapps.controller.persistence.model.ImmutableAsyncUploadJobEntry;
import org.cloudfoundry.multiapps.controller.persistence.query.AsyncUploadJobsQuery;
import org.cloudfoundry.multiapps.controller.persistence.query.impl.AsyncUploadJobsQueryImpl;

@Named
public class AsyncUploadJobService extends PersistenceService {

    @Inject
    public AsyncUploadJobService(EntityManagerFactory entityManagerFactory) {
        super(entityManagerFactory);
    }

    public AsyncUploadJobsQuery createQuery() {
        return new AsyncUploadJobsQueryImpl(createEntityManager());
    }

    @Override
    protected PersistenceObjectMapper getPersistenceObjectMapper() {
        return new AsyncUploadJobMapper();
    }

    @Override
    protected void onEntityConflict(AsyncUploadJobDto dto, Throwable t) {
        throw new ConflictException(t, Messages.ASYNC_UPLOAD_JOB_ALREADY_EXISTS, dto.getPrimaryKey());
    }

    @Override
    protected void onEntityNotFound(String primaryKey) {
        throw new NotFoundException(Messages.ASYNC_UPLOAD_JOB_NOT_FOUND, primaryKey);
    }

    public static class AsyncUploadJobMapper implements PersistenceObjectMapper {

        @Override
        public AsyncUploadJobEntry fromDto(AsyncUploadJobDto dto) {
            return ImmutableAsyncUploadJobEntry.builder()
                                               .id(dto.getPrimaryKey())
                                               .user(dto.getMtaUser())
                                               .state(AsyncUploadJobEntry.State.valueOf(dto.getState()))
                                               .addedAt(dto.getAddedAt())
                                               .startedAt(dto.getStartedAt())
                                               .finishedAt(dto.getFinishedAt())
                                               .namespace(dto.getNamespace())
                                               .spaceGuid(dto.getSpaceGuid())
                                               .url(dto.getUrl())
                                               .mtaId(dto.getMtaId())
                                               .fileId(dto.getFileId())
                                               .error(dto.getError())
                                               .instanceIndex(dto.getInstanceIndex())
                                               .build();
        }

        @Override
        public AsyncUploadJobDto toDto(AsyncUploadJobEntry entry) {
            return new AsyncUploadJobDto(entry.getId(),
                                         entry.getUser(),
                                         entry.getState()
                                              .toString(),
                                         entry.getUrl(),
                                         entry.getAddedAt(),
                                         entry.getStartedAt(),
                                         entry.getFinishedAt(),
                                         entry.getNamespace(),
                                         entry.getSpaceGuid(),
                                         entry.getMtaId(),
                                         entry.getFileId(),
                                         entry.getError(),
                                         entry.getInstanceIndex());
        }
    }

}