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.integrity.exception.CurisException;
import net.curisit.securis.DefaultExceptionHandler;
import net.curisit.securis.db.License;
import net.curisit.securis.db.Pack;
import net.curisit.securis.db.User;
import net.curisit.securis.utils.TokenHelper;

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

import com.google.inject.persist.Transactional;

/**
 * License resource, this service will provide methods to create, modify and delete licenses
 * 
 * @author roberto <roberto.sanchez@curisit.net>
 */
@Path("/organization")
public class LicenseResource {

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

    @Inject
    TokenHelper tokenHelper;

    @Inject
    Provider<EntityManager> emProvider;

    public LicenseResource() {
    }

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

        EntityManager em = emProvider.get();
        TypedQuery<License> q = em.createNamedQuery("list-licenses-by-pack", License.class);

        List<License> list = q.getResultList();

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

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

        EntityManager em = emProvider.get();
        License lt = em.find(License.class, Integer.parseInt(licId));
        if (lt == null) {
            log.error("License with id {} not found in DB", licId);
            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(License lic, @HeaderParam(TokenHelper.TOKEN_HEADER_PÀRAM) String token) {
        log.info("Creating new organization");
        EntityManager em = emProvider.get();
        Pack pack = null;
        if (lic.getPackId() != null) {
            pack = em.find(Pack.class, lic.getPackId());
            if (pack == null) {
                log.error("License pack with id {} not found in DB", lic.getPackId());
                return Response.status(Status.NOT_FOUND).header(DefaultExceptionHandler.ERROR_MESSAGE_HEADER, "License's pack not found with ID: " + lic.getPackId()).build();
            }
        }

        try {
            User createdBy = getUser(lic.getCreatedById(), em);
            lic.setCreatedBy(createdBy);
        } catch (CurisException ex) {
            String createdByUsername = lic.getCreatedById();
            log.error("License created by user with id {} not found in DB", createdByUsername);
            return Response.status(Status.NOT_FOUND).header(DefaultExceptionHandler.ERROR_MESSAGE_HEADER, "License's created by user not found with ID: " + createdByUsername).build();
        }

        try {
            User canceledBy = getUser(lic.getCanceledById(), em);
            lic.setCanceledBy(canceledBy);
        } catch (CurisException ex) {
            String canceledByUsername = lic.getCreatedById();
            log.error("License canceled by user with id {} not found in DB", canceledByUsername);
            return Response.status(Status.NOT_FOUND).header(DefaultExceptionHandler.ERROR_MESSAGE_HEADER, "License's canceled by user not found with ID: " + canceledByUsername).build();
        }

        lic.setCreationTimestamp(new Date());
        em.persist(lic);

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

    private User getUser(String username, EntityManager em) throws CurisException {
        User user = null;
        if (username != null) {
            user = em.find(User.class, username);
            if (user == null) {
                throw new CurisException("User not found");
            }
        }
        return user;
    }

    @PUT
    @POST
    @Path("/{licId}")
    @Transactional
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(
        { MediaType.APPLICATION_JSON })
    public Response modify(License lic, @PathParam("licId") String licId, @HeaderParam(TokenHelper.TOKEN_HEADER_PÀRAM) String token) {
        log.info("Modifying organization with id: {}", licId);
        EntityManager em = emProvider.get();

        Pack pack = null;
        if (lic.getPackId() != null) {
            pack = em.find(Pack.class, lic.getPackId());
            if (pack == null) {
                log.error("License pack with id {} not found in DB", lic.getPackId());
                return Response.status(Status.NOT_FOUND).header(DefaultExceptionHandler.ERROR_MESSAGE_HEADER, "License's pack not found with ID: " + lic.getPackId()).build();
            }
        }
        User createdBy = null;
        try {
            createdBy = getUser(lic.getCreatedById(), em);
        } catch (CurisException ex) {
            String createdByUsername = lic.getCreatedById();
            log.error("License created by user with id {} not found in DB", createdByUsername);
            return Response.status(Status.NOT_FOUND).header(DefaultExceptionHandler.ERROR_MESSAGE_HEADER, "License's created by user not found with ID: " + createdByUsername).build();
        }

        User canceledBy = null;
        try {
            canceledBy = getUser(lic.getCanceledById(), em);
        } catch (CurisException ex) {
            String canceledByUsername = lic.getCreatedById();
            log.error("License canceled by user with id {} not found in DB", canceledByUsername);
            return Response.status(Status.NOT_FOUND).header(DefaultExceptionHandler.ERROR_MESSAGE_HEADER, "License's canceled by user not found with ID: " + canceledByUsername).build();
        }

        lic.setCreatedBy(createdBy);
        lic.setCanceledBy(canceledBy);
        lic.setPack(pack);
        em.persist(lic);

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

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

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

}