common/securis.git

package net.curisit.securis.services;

import java.util.Date;
import java.util.List;

import javax.inject.Inject;
import javax.inject.Provider;
import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.HeaderParam;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;

import net.curisit.integrity.commons.Utils;
import net.curisit.securis.DefaultExceptionHandler;
import net.curisit.securis.db.Application;
import net.curisit.securis.db.LicenseType;
import net.curisit.securis.utils.TokenHelper;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.inject.persist.Transactional;

/**
 * LicenseType resource, this service will provide methods to create, modify and delete license types
 * 
 * @author roberto <roberto.sanchez@curisit.net>
 */
@Path("/licensetype")
public class LicenseTypeResource {

    private static final Logger log = LoggerFactory.getLogger(LicenseTypeResource.class);

    @Inject
    TokenHelper tokenHelper;

    @Inject
    Provider<EntityManager> emProvider;

    public LicenseTypeResource() {
    }

    /**
     * 
     * @return the server version in format majorVersion.minorVersion
     */
    @GET
    @Path("/")
    @Produces(
        { MediaType.APPLICATION_JSON })
    public Response index() {
        log.info("Getting license types list ");

        EntityManager em = emProvider.get();
        TypedQuery<LicenseType> q = em.createNamedQuery("list-license_types", LicenseType.class);
        List<LicenseType> list = q.getResultList();

        return Response.ok(list).build();
    }

    /**
     * 
     * @return the server version in format majorVersion.minorVersion
     */
    @GET
    @Path("/{ltid}")
    @Produces(
        { MediaType.APPLICATION_JSON })
    public Response get(@PathParam("ltid") String ltid, @HeaderParam(TokenHelper.TOKEN_HEADER_PÀRAM) String token) {
        log.info("Getting license type data for id: {}: ", ltid);
        if (ltid == null || ltid.equals("")) {
            log.error("LicenseType ID is mandatory");
            return Response.status(Status.NOT_FOUND).build();
        }

        EntityManager em = emProvider.get();
        LicenseType lt = em.find(LicenseType.class, Integer.parseInt(ltid));
        if (lt == null) {
            log.error("LicenseType with id {} not found in DB", ltid);
            return Response.status(Status.NOT_FOUND).build();
        }
        return Response.ok(lt).build();
    }

    @POST
    @Path("/")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(
        { MediaType.APPLICATION_JSON })
    @Transactional
    public Response create(LicenseType lt, @HeaderParam(TokenHelper.TOKEN_HEADER_PÀRAM) String token) {
        log.info("Creating new license type");
        EntityManager em = emProvider.get();
        Application app = null;
        if (lt.getApplicationId() != null) {
            app = em.find(Application.class, lt.getApplicationId());
            if (app == null) {
                log.error("LicenseType application with id {} not found in DB", lt.getApplicationId());
                return Response.status(Status.NOT_FOUND).header(DefaultExceptionHandler.ERROR_MESSAGE_HEADER, "License type's app not found with ID: " + lt.getApplicationId()).build();
            }
        } else {
            log.error("Application is missing for current license type data");
            return Response.status(Status.NOT_FOUND).header(DefaultExceptionHandler.ERROR_MESSAGE_HEADER, "Application is missing for current license type data").build();
        }

        lt.setApplication(app);
        lt.setCreationTimestamp(new Date());
        em.persist(lt);

        return Response.ok(lt).build();
    }

    @PUT
    @POST
    @Path("/{ltid}")
    @Transactional
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(
        { MediaType.APPLICATION_JSON })
    public Response modify(LicenseType lt, @PathParam("ltid") String ltid, @HeaderParam(TokenHelper.TOKEN_HEADER_PÀRAM) String token) {
        log.info("Modifying license type with id: {}", ltid);
        EntityManager em = emProvider.get();
        LicenseType currentlt = em.find(LicenseType.class, Integer.parseInt(ltid));
        if (currentlt == null) {
            log.error("LicenseType with id {} not found in DB", ltid);
            return Response.status(Status.NOT_FOUND).header(DefaultExceptionHandler.ERROR_MESSAGE_HEADER, "License type not found with ID: " + ltid).build();
        }
        Application app = null;
        if (lt.getApplicationId() != null) {
            app = em.find(Application.class, lt.getApplicationId());
            if (app == null) {
                log.error("LicenseType application with id {} not found in DB", lt.getApplicationId());
                return Response.status(Status.NOT_FOUND).header(DefaultExceptionHandler.ERROR_MESSAGE_HEADER, "License type's app not found with ID: " + lt.getApplicationId()).build();
            }
        }
        currentlt.setCode(lt.getCode());
        currentlt.setName(lt.getName());
        currentlt.setDescription(lt.getDescription());
        currentlt.setApplication(app);
        em.persist(currentlt);

        return Response.ok(currentlt).build();
    }

    @DELETE
    @Path("/{ltid}")
    @Transactional
    @Produces(
        { MediaType.APPLICATION_JSON })
    public Response delete(@PathParam("ltid") String ltid, @Context HttpServletRequest request) {
        log.info("Deleting app with id: {}", ltid);
        EntityManager em = emProvider.get();
        LicenseType app = em.find(LicenseType.class, Integer.parseInt(ltid));
        if (app == null) {
            log.error("LicenseType with id {} can not be deleted, It was not found in DB", ltid);
            return Response.status(Status.NOT_FOUND).build();
        }

        em.remove(app);
        return Response.ok(Utils.createMap("success", true, "id", ltid)).build();
    }

}