common/securis.git

package net.curisit.securis.services;

import java.security.Principal;
import java.util.Date;
import java.util.List;

import javax.annotation.security.RolesAllowed;
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.Pack;
import net.curisit.securis.security.BasicSecurityContext;
import net.curisit.securis.security.Securable;
import net.curisit.securis.utils.TokenHelper;

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

import com.google.inject.persist.Transactional;

/**
 * Pack resource, this service will provide methods to create, modify and delete packs
 * 
 * @author roberto <roberto.sanchez@curisit.net>
 */
@Path("/pack")
public class PackResource {

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

    @Inject
    TokenHelper tokenHelper;

    @Inject
    Provider<EntityManager> emProvider;

    public PackResource() {
    }

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

        EntityManager em = emProvider.get();
        // TypedQuery<Pack> q = em.createNamedQuery("list-packs-by-orgs", Pack.class);

        TypedQuery<Pack> q;
        if (bsc.isUserInRole(BasicSecurityContext.ROL_ADMIN)) {
            log.info("Getting all packs for user: " + bsc.getUserPrincipal());
            q = em.createNamedQuery("list-packs", Pack.class);
        } else {
            q = em.createNamedQuery("list-packs-by-orgs", Pack.class);
            if (bsc.getOrganizationsIds() == null)
                Response.ok().build();
            // log.info("Getting only {} orgs for user: {}", securityContext.getOrganizationsIds(), securityContext.getUserPrincipal());
            q.setParameter("list_ids", bsc.getOrganizationsIds());
        }

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

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

    private Response generateErrorUnathorizedAccess(Pack pack, Principal user) {
        log.error("Pack with id {} not accesible by user {}", pack, user);
        return Response.status(Status.UNAUTHORIZED).header(DefaultExceptionHandler.ERROR_MESSAGE_HEADER, "Unathorized access to pack").build();
    }

    /**
     * 
     * @return the server version in format majorVersion.minorVersion
     */
    @GET
    @Path("/{packId}")
    @Securable
    @Produces(
        { MediaType.APPLICATION_JSON })
    public Response get(@PathParam("packId") String packId, @Context BasicSecurityContext bsc) {
        log.info("Getting pack data for id: {}: ", packId);
        if (packId == null || packId.equals("")) {
            log.error("Pack ID is mandatory");
            return Response.status(Status.NOT_FOUND).build();
        }

        EntityManager em = emProvider.get();
        Pack pack = em.find(Pack.class, Integer.parseInt(packId));
        if (pack == null) {
            log.error("Pack with id {} not found in DB", packId);
            return Response.status(Status.NOT_FOUND).build();
        }
        if (bsc.isUserInRole(BasicSecurityContext.ROL_ADVANCE)) {
            if (bsc.getOrganizationsIds() == null || !bsc.getOrganizationsIds().contains(pack.getOrgId())) {
                return generateErrorUnathorizedAccess(pack, bsc.getUserPrincipal());
            }
        }
        return Response.ok(pack).build();
    }

    @POST
    @Path("/")
    @Securable
    @RolesAllowed(BasicSecurityContext.ROL_ADMIN)
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(
        { MediaType.APPLICATION_JSON })
    @Transactional
    public Response create(Pack pack, @HeaderParam(TokenHelper.TOKEN_HEADER_PÀRAM) String token) {
        log.info("Creating new pack");
        EntityManager em = emProvider.get();

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

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

    @PUT
    @POST
    @Path("/{packId}")
    @Transactional
    @Securable
    @RolesAllowed(BasicSecurityContext.ROL_ADMIN)
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(
        { MediaType.APPLICATION_JSON })
    public Response modify(Pack pack, @PathParam("packId") String packId, @HeaderParam(TokenHelper.TOKEN_HEADER_PÀRAM) String token) {
        log.info("Modifying pack with id: {}", packId);
        EntityManager em = emProvider.get();

        em.persist(pack);

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

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

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

}