gistfile1.txt

package it.coopservice.api.service;

import io.quarkus.hibernate.orm.panache.PanacheEntity;
import io.quarkus.hibernate.orm.panache.PanacheQuery;
import org.jboss.logging.Logger;

import javax.persistence.NoResultException;
import javax.transaction.Transactional;
import javax.ws.rs.*;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.core.UriInfo;
import java.io.Serializable;
import java.util.List;

import static io.quarkus.panache.common.Page.of;

public abstract class RsRepositoryService<T extends PanacheEntity> extends RsResponseService implements Serializable {

    private static final long serialVersionUID = 1L;


    Logger logger = Logger.getLogger(getClass());

    public RsRepositoryService() {

    }


    protected void prePersist(T object) throws Exception {
    }

    @POST
    @Transactional
    public Response persist(T object) throws Exception {
        try {
            prePersist(object);
        } catch (Exception e) {
            logger.error(e.getMessage());
            return jsonMessageResponse(Status.BAD_REQUEST, e);
        }
        try {
            T persisted = doPersist(object);
            if (persisted == null || getId(persisted) == null) {
                logger.error("Failed to create resource: " + object);
                return jsonErrorMessageResponse(object);
            } else {
                return Response.status(Status.OK).entity(persisted).build();
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            return jsonErrorMessageResponse(object);
        } finally {
            try {
                postPersist(object);
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
            }
        }
    }

    protected T doPersist(T object) throws Exception {
        T.persist(object);
        return object;
    }

    protected void postPersist(T object) throws Exception {
    }

    protected void postFetch(T object) throws Exception {
    }

    /*
     * R
     */
    @GET
    @Path("/{id}")
    @Transactional
    public Response fetch(@PathParam("id") String id) {
        try {
            T t = doFind(id);
            if (t == null) {
                return jsonMessageResponse(Status.NOT_FOUND, id);
            } else {
                try {
                    postFetch(t);
                } catch (Exception e) {
                    logger.error(e.getMessage(), e);
                }
                return Response.status(Status.OK).entity(t).build();
            }
        } catch (NoResultException e) {
            logger.error(e.getMessage());
            return jsonMessageResponse(Status.NOT_FOUND, id);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            return jsonErrorMessageResponse(e);
        }
    }

    protected T doFind(String id) throws Exception {
        T t = T.findById(id);
        return t;
    }

    /*
     * U
     */
    protected T preUpdate(T object) throws Exception {
        return object;
    }


    @PUT
    @Path("/{id}")
    @Transactional
    public Response update(@PathParam("id") String id, T object) throws Exception {
        logger.info("@PUT update:" + object.toString());
        try {
            object = preUpdate(object);
        } catch (Exception e) {
            return jsonMessageResponse(Status.BAD_REQUEST, e);
        }
        try {

            return Response.status(Status.OK).entity(object).build();
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            return jsonErrorMessageResponse(object);
        } finally {
            try {
                postUpdate(object);
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
            }
        }
    }

    /**
     * concepita per chiamare robe async dopo l'update (o cmq robe fuori dalla tx principale che non rollbacka se erorri qui)
     *
     * @param object
     * @throws Exception
     */
    protected void postUpdate(T object) throws Exception {
    }

    /*
     * D
     */

    protected void preDelete(String id) throws Exception {
    }

    protected void doDelete(String id) throws Exception {
        T.delete(id);
    }

    @DELETE
    @Path("/{id}")
    @Transactional
    public Response delete(@PathParam("id") String id) throws Exception {
        logger.info("@DELETE:" + id);
        try {
            preDelete(id);
        } catch (Exception e) {
            return jsonMessageResponse(Status.BAD_REQUEST, e);
        }
        try {
            doDelete(id);
            postDelete(id);
            return jsonMessageResponse(Status.NO_CONTENT, id);
        } catch (NoResultException e) {
            logger.error(e.getMessage());
            return jsonMessageResponse(Status.NOT_FOUND, id);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            return jsonErrorMessageResponse(e);
        }
    }

    protected void postDelete(String id) throws Exception {
    }

    /*
     * E
     */
    @GET
    @Path("/{id}/exist")
    public Response exist(@PathParam("id") Long id) {
        logger.info("@GET exist:" + id);
        try {
            boolean exist = T.findById(id) != null;
            if (!exist) {
                return jsonMessageResponse(Status.NOT_FOUND, id);
            } else {
                return jsonMessageResponse(Status.OK, id);
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            return jsonErrorMessageResponse(e);
        }
    }


    @GET
    @Path("/listSize")
    @Transactional
    public Response getListSize(@Context UriInfo ui) {
        try {
            PanacheQuery<T> search = getSearch(ui, null);
            long listSize = search.count();
            return Response.status(Status.OK).entity(listSize)
                    .header("Access-Control-Expose-Headers", "listSize")
                    .header("listSize", listSize).build();
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            return jsonErrorMessageResponse(e);
        }
    }

    /*
     * Q
     */

    @GET
    @Transactional
    public Response getList(
            @DefaultValue("0") @QueryParam("startRow") Integer startRow,
            @DefaultValue("10") @QueryParam("pageSize") Integer pageSize,
            @QueryParam("orderBy") String orderBy, @Context UriInfo ui) {
        try {
            PanacheQuery<T> search = getSearch(ui, orderBy);
            long listSize = search.count();
            List<T> list = search.page(of(startRow, pageSize)).list();

            postList(list);
            return Response
                    .status(Status.OK)
                    .entity(list)
                    .header("Access-Control-Expose-Headers",
                            "startRow, pageSize, listSize").header("startRow", startRow)
                    .header("pageSize", pageSize).header("listSize", listSize).build();
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            return jsonErrorMessageResponse(e);
        }
    }

    protected void postList(List<T> list) throws Exception {
    }


    public abstract Object getId(T t);

    public abstract PanacheQuery<T> getSearch(UriInfo ui, String orderBy);
}

package it.coopservice.cognitive.service.rs;

import io.quarkus.hibernate.orm.panache.PanacheQuery;
import it.coopservice.api.service.RsRepositoryService;
import it.coopservice.cognitive.model.Elaborazione;

import javax.enterprise.context.ApplicationScoped;
import javax.transaction.Transactional;
import javax.ws.rs.Consumes;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.UriInfo;
import java.util.HashMap;
import java.util.Map;

@path("/elaborazioni")
@produces(MediaType.APPLICATION_JSON)
@consumes(MediaType.APPLICATION_JSON)
@ApplicationScoped
public class ElaborazioniService extends RsRepositoryService {

public ElaborazioniService() {
}

@Override
public Object getId(Elaborazione elaborazione) {
    return elaborazione.id;
}

@Override
public PanacheQuery<Elaborazione> getSearch(UriInfo ui, String orderBy) {
    Map<String, Object> params = new HashMap<>();
    StringBuffer queryBuffer = new StringBuffer();

    if (orderBy != null && !orderBy.trim().isEmpty()) {
        queryBuffer.append(" order by ").append(orderBy);
    }
    return Elaborazione.find(queryBuffer.toString(), params);
}

@Override
@Transactional
protected Elaborazione doPersist(Elaborazione elaborazione) throws Exception {
    elaborazione.persist();
    System.out.println("id: " + elaborazione.id);
    return elaborazione;
}

@Override
@Transactional
protected Elaborazione doFind(String id) throws Exception {
    return Elaborazione.findById(Long.valueOf(id));
}

// @post
// @transactional
// public Response persist(Elaborazione elaborazione) throws Exception {
// elaborazione.persist();
// System.out.println("id: " + elaborazione.id);
// return Response.ok(elaborazione).build();
// }

}

package it.coopservice.cognitive.model;

import io.quarkus.hibernate.orm.panache.PanacheEntity;

import javax.persistence.Entity;
import java.time.LocalDate;

@entity
public class Elaborazione extends PanacheEntity {
public String name;
private LocalDate dataRichiesta;
private LocalDate dataFine;
public String risultato;
}

package io.quarkus.hibernate.orm.panache;

import io.quarkus.hibernate.orm.panache.runtime.JpaOperations;
import io.quarkus.panache.common.Parameters;
import io.quarkus.panache.common.Sort;
import java.util.List;
import java.util.Map;
import java.util.stream.Stream;
import javax.json.bind.annotation.JsonbTransient;

public abstract class PanacheEntityBase {
public PanacheEntityBase() {
}

public void persist() {
    JpaOperations.persist(this);
}

public void delete() {
    JpaOperations.delete(this);
}

@JsonbTransient
public boolean isPersistent() {
    return JpaOperations.isPersistent(this);
}

public static <T extends PanacheEntityBase> T findById(Object id) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> PanacheQuery<T> find(String query, Object... params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> PanacheQuery<T> find(String query, Sort sort, Object... params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> PanacheQuery<T> find(String query, Map<String, Object> params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> PanacheQuery<T> find(String query, Sort sort, Map<String, Object> params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> PanacheQuery<T> find(String query, Parameters params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> PanacheQuery<T> find(String query, Sort sort, Parameters params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> PanacheQuery<T> findAll() {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> PanacheQuery<T> findAll(Sort sort) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> List<T> list(String query, Object... params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> List<T> list(String query, Sort sort, Object... params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> List<T> list(String query, Map<String, Object> params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> List<T> list(String query, Sort sort, Map<String, Object> params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> List<T> list(String query, Parameters params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> List<T> list(String query, Sort sort, Parameters params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> List<T> listAll() {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> List<T> listAll(Sort sort) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> Stream<T> stream(String query, Object... params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> Stream<T> stream(String query, Sort sort, Object... params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> Stream<T> stream(String query, Map<String, Object> params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> Stream<T> stream(String query, Sort sort, Map<String, Object> params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> Stream<T> stream(String query, Parameters params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> Stream<T> stream(String query, Sort sort, Parameters params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> Stream<T> streamAll() {
    throw JpaOperations.implementationInjectionMissing();
}

public static <T extends PanacheEntityBase> Stream<T> streamAll(Sort sort) {
    throw JpaOperations.implementationInjectionMissing();
}

public static long count() {
    throw JpaOperations.implementationInjectionMissing();
}

public static long count(String query, Object... params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static long count(String query, Map<String, Object> params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static long count(String query, Parameters params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static long deleteAll() {
    throw JpaOperations.implementationInjectionMissing();
}

public static long delete(String query, Object... params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static long delete(String query, Map<String, Object> params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static long delete(String query, Parameters params) {
    throw JpaOperations.implementationInjectionMissing();
}

public static void persist(Iterable<?> entities) {
    JpaOperations.persist(entities);
}

public static void persist(Stream<?> entities) {
    JpaOperations.persist(entities);
}

public static void persist(Object firstEntity, Object... entities) {
    JpaOperations.persist(firstEntity, entities);
}

}

@MappedSuperclass
public abstract class PanacheEntity extends PanacheEntityBase {
@id
@GeneratedValue
public Long id;

public PanacheEntity() {
}

}