Sequence.java

package cz.mendelu.model;

import com.fasterxml.jackson.annotation.JsonIgnore;
import io.quarkus.runtime.annotations.RegisterForReflection;
import org.hibernate.annotations.CreationTimestamp;

import javax.persistence.*;
import java.util.*;
import java.util.stream.Collectors;

@Entity
@Table(name = "sequences")
public class Sequence extends UUIDPanacheEntity {

    @JsonIgnore
    @Column(name = "buffer_id")
    public UUID bufferId;

    public String name;

    @Temporal(TemporalType.TIMESTAMP)
    @CreationTimestamp
    public Date created;

    public SequenceType type;

    public Boolean circular;

    public Integer length;

    public String ncbi;

    @ElementCollection
    public Set<String> tags;

    @Column(name = "owner_id")
    @JsonIgnore
    public UUID ownerId;

    @Column(name = "fasta_comment")
    public String fastaComment;

    @ElementCollection
    @CollectionTable(name = "sequence_nucleic_counts")
    @MapKeyColumn(name = "nucleic_counts_key")
    @Column(name = "nucleic_counts")
    public Map<Nucleotide, Integer> nucleicCounts;

    public Map<Nucleotide, Integer> getNucleicCounts() {
        return (nucleicCounts == null || nucleicCounts.isEmpty())
                ? null
                : Collections.unmodifiableMap(nucleicCounts);
    }

    public static List<Sequence> findAllByOwnerIsNull() {
        return list("ownerId IS NULL");
    }

    public static Optional<String> getNcbi(UUID id) {
        Optional<Sequence> sequence = findByIdOptional(id);

        return sequence.map(s -> s.ncbi);
    }

    public static Optional<String> getName(UUID id) {
        Optional<Sequence> sequence = findByIdOptional(id);

        return sequence.map(s -> s.name);
    }

    public static List<Sequence> findAll(UUID ownerId) {
        return list("ownerId = ?1", ownerId);
    }

    public static List<Sequence> findAll(UUID ownerId, String tag) {
        return list("ownerId = ?1 and ?2 member of tags", ownerId, tag);
    }

    public static Optional<Sequence> findById(UUID id, UUID ownerId) {
        return find("id = ?1 and ownerId = ?2", id, ownerId)
                .firstResultOptional();
    }

    public static List<String> findAllTags(UUID ownerId) {
        List<TagRecord> tagRecords = Sequence.find("SELECT DISTINCT t FROM Sequence s, IN (s.tags) t WHERE s.ownerId = ?1", ownerId)
                .project(TagRecord.class)
                .list();

        return tagRecords.stream()
                .map(TagRecord::tag)
                .collect(Collectors.toList());
    }

    public static List<Sequence> findByNcbi(String ncbi) {
        return list("ncbi", ncbi);
    }

    @RegisterForReflection
    public record TagRecord(String tag) {
    }
}