io.rocketbase.commons.service.AssetJpaRepository Maven / Gradle / Ivy

Go to download
package io.rocketbase.commons.service;

import com.google.common.hash.Hashing;
import io.rocketbase.commons.dto.asset.QueryAsset;
import io.rocketbase.commons.model.AssetJpaEntity;
import io.rocketbase.commons.repository.AssetEntityRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.util.StringUtils;

import javax.persistence.criteria.Predicate;
import javax.transaction.Transactional;
import java.nio.charset.Charset;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.UUID;

@RequiredArgsConstructor
public class AssetJpaRepository implements AssetRepository, PredicateHelper {

    private final AssetEntityRepository assetEntityRepository;

    /**
     * search first by id, when not found by systemRefId
     *
     * @param sid database id or systemRefId
     */
    @Override
    public Optional findByIdOrSystemRefId(String sid) {
        Optional optional = findById(sid);
        if (!optional.isPresent()) {
            return findBySystemRefId(sid);
        }
        return optional;
    }

    @Override
    public Optional findById(String sid) {
        return assetEntityRepository.findById(sid);
    }

    @Override
    public Optional findBySystemRefId(String systemRefId) {
        return assetEntityRepository.findBySystemRefId(systemRefId);
    }

    @Override
    @Transactional
    public boolean delete(String id) {
        Optional optional = findById(id);
        assetEntityRepository.deleteById(id);
        return optional.isPresent();
    }

    @Override
    @Transactional
    public AssetJpaEntity save(AssetJpaEntity entity) {
        if (!StringUtils.isEmpty(entity.getReferenceUrl())) {
            entity.setReferenceHash(Hashing.sha256().hashString(entity.getReferenceUrl(), Charset.forName("UTF8")).toString());
        }
        return assetEntityRepository.save(entity);
    }

    @Override
    public Page findAll(QueryAsset query, Pageable pageable) {
        if (query == null) {
            return assetEntityRepository.findAll(pageable);
        }

        Specification specification = (Specification) (root, criteriaQuery, cb) -> {
            List predicates = new ArrayList<>();
            if (query.getBefore() != null) {
                predicates.add(cb.lessThanOrEqualTo(root.get("created"), query.getBefore()));
            }
            if (query.getAfter() != null) {
                predicates.add(cb.greaterThanOrEqualTo(root.get("created"), query.getAfter()));
            }

            addToListIfNotEmpty(predicates, query.getOriginalFilename(), "originalFilename", root, cb);

            if (query.getReferenceUrl() != null) {
                String referenceHash = Hashing.sha256().hashString(query.getReferenceUrl(), Charset.forName("UTF8")).toString();
                predicates.add(cb.equal(root.get("referenceHash"), referenceHash));
            }
            addToListIfNotEmpty(predicates, query.getContext(), "context", root, cb);

            if (query.getTypes() != null && !query.getTypes().isEmpty()) {
                predicates.add(cb.in(root.get("type")).value(query.getTypes()));
            }
            if (query.getHasEolValue() != null) {
                if (query.getHasEolValue()) {
                    predicates.add(cb.isNotNull(root.get("eol")));
                } else {
                    predicates.add(cb.isNull(root.get("eol")));
                }
            }

            if (query.getIsEol() != null) {
                if (query.getIsEol()) {
                    predicates.add(cb.and(cb.isNotNull(root.get("eol")), cb.lessThan(root.get("eol"), Instant.now())));
                } else {
                    predicates.add(cb.or(cb.isNull(root.get("eol")), cb.greaterThanOrEqualTo(root.get("eol"), Instant.now())));
                }
            }
            return cb.and(predicates.toArray(new Predicate[]{}));
        };

        return assetEntityRepository.findAll(specification, pageable);
    }

    @Override
    public AssetJpaEntity initNewInstance() {
        return AssetJpaEntity.builder()
                .id(UUID.randomUUID().toString())
                .created(Instant.now())
                .build();
    }

}