D-Net

package eu.dnetlib.openaire.rest;

import com.google.gson.*;

import eu.dnetlib.api.enabling.ISLookUpService;

import eu.dnetlib.api.enabling.ISLookUpServiceException;

import eu.dnetlib.data.claims.migration.ClaimValidationException;

import eu.dnetlib.data.claims.migration.entity.Claim;

import eu.dnetlib.data.claims.migration.handler.ClaimHandler;

import eu.dnetlib.data.claims.migration.handler.DirectIndexHandler;

import eu.dnetlib.data.claims.migration.handler.FetchClaimHandler;

import eu.dnetlib.data.claims.migration.handler.FetchProjectHandler;

import eu.dnetlib.data.claimsDemo.SQLStoreException;

import gr.uoa.di.driver.util.ServiceLocator;

import org.apache.commons.validator.EmailValidator;

import org.apache.log4j.Logger;

import org.json.XML;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import javax.annotation.Resource;

import javax.servlet.http.HttpServletRequest;

import javax.ws.rs.*;

import javax.ws.rs.core.Context;

import javax.ws.rs.core.MediaType;

import javax.ws.rs.core.Response;

import java.util.ArrayList;

import java.util.List;

/**

 * Created by kiatrop on 15/4/2016.

 */

@Component

@Path("/claimsService")

public class HelloWorldService {

    private static final Logger logger = Logger.getLogger(HelloWorldService.class);

    @Autowired

    private FetchClaimHandler fetchClaimHandler = null;

    @Autowired

    private FetchProjectHandler fetchProjectHandler= null;

    @Resource

    private ServiceLocator<ISLookUpService> lookupServiceLocator = null;

    @Autowired

    private ClaimHandler claimHandler = null;

    @Autowired

    private DirectIndexHandler directIndexHandler = null;

    @Autowired

    public Authorization authorization = null;

    @GET

    @Path("projects/{projectId}/claims")

    @Produces(MediaType.APPLICATION_JSON)

    public Response getProjectClaims(@PathParam("projectId") String projectId,

                           @DefaultValue("0") @QueryParam("offset") int offset,

                           @DefaultValue("20") @QueryParam("limit") int limit,

                           @DefaultValue("") @QueryParam("keyword") String keyword,

                           @DefaultValue("") @QueryParam("sortby") String orderby,

                           @DefaultValue("true") @QueryParam("descending") boolean descending,

                           @DefaultValue("") @QueryParam("types") List<String> types,

                                     @HeaderParam("X-XSRF-TOKEN") String token,

                                     @CookieParam("AccessToken") String  cookie,

                           @Context HttpServletRequest request) {

        if(token == null || token.isEmpty() || cookie == null || cookie.isEmpty() || !cookie.equals(token)){

            authorization.logStatus(token,cookie);

            return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access. Maybe you are not registered."))

                    .type(MediaType.APPLICATION_JSON)

                    .build();

        }

        if(authorization.isAdmin(token)) {

            int total = -1;

            if (projectId == null || projectId.isEmpty()) {

                return Response.status(Response.Status.BAD_REQUEST).entity(compose400Message("Project id cannot be empty."))

                        .type(MediaType.APPLICATION_JSON).build();

            }

            List<Claim> claims = null;

            try {

                claims = fetchClaimHandler.fetchClaimsByProject(projectId, limit, offset, keyword, orderby, descending, types,false);

                total = fetchClaimHandler.countClaimsByProject(projectId, keyword, types);

            } catch (SQLStoreException|Exception e) {  //TODO check this with exception

                logger.error("Could not fetch claims for project with id " + projectId, e);

                return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(compose500Message("Fail to fetch claims" +

                        " for projects with id " + projectId + ".", e)).type(MediaType.APPLICATION_JSON).build();

            }

            return Response.status(200).entity(composeDataResponse(request, claims, total, offset, limit)).build();

        }

        return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access"))

                .type(MediaType.APPLICATION_JSON)

                .build();

    }

    @GET

    @Path("project/claims")

    @Produces(MediaType.APPLICATION_JSON)

    public Response getProjectClaimsByToken(@QueryParam("projectToken") String projectToken,

                                     @DefaultValue("-1") @QueryParam("offset") int offset,

                                     @DefaultValue("-1") @QueryParam("limit") int limit,

                                     @DefaultValue("") @QueryParam("keyword") String keyword,

                                     @DefaultValue("") @QueryParam("sortby") String orderby,

                                     @DefaultValue("true") @QueryParam("descending") boolean descending,

                                     @DefaultValue("") @QueryParam("types") List<String> types,

                                     @HeaderParam("X-XSRF-TOKEN") String token,

                                     @CookieParam("AccessToken") String  cookie,

                                     @Context HttpServletRequest request) {

        if(token == null || token.isEmpty() || cookie == null || cookie.isEmpty() || !cookie.equals(token)){

            authorization.logStatus(token,cookie);

            return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access. Maybe you are not registered."))

                    .type(MediaType.APPLICATION_JSON)

                    .build();

        }

        UserInfo userInfo = authorization.getUserHandler().getUserInfo(token);

        if(authorization.isProjectCurator(userInfo)) {

            String userMail = userInfo.getEmail();

            int total = -1;

            if (projectToken == null || projectToken.isEmpty()) {

                return Response.status(Response.Status.BAD_REQUEST).entity(compose400Message("Project token cannot be empty."))

                        .type(MediaType.APPLICATION_JSON).build();

            }

            List<Claim> claims = null;

            try {

                String projectId = fetchProjectHandler.fetchProjectIdByToken(projectToken,userMail);

                if(projectId == null){

                    return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access"))

                            .type(MediaType.APPLICATION_JSON)

                            .build();

                }else{

                    if(offset == -1 && limit == -1) {

                        // when offset and limit are -1 fetch claims with null values, to ignore paging and limit clause

                        claims = fetchClaimHandler.fetchClaimsByProject(projectId, null, null, keyword, orderby, descending, types, true);

                    } else {

                        claims = fetchClaimHandler.fetchClaimsByProject(projectId, limit, offset, keyword, orderby, descending, types, true);

                    }

                    total = fetchClaimHandler.countClaimsByProject(projectId, keyword, types);

                    return Response.status(200).entity(composeDataResponse(request, claims, total, offset, limit)).build();

                }

            } catch (SQLStoreException|Exception e) {

                logger.error("Could not fetch claims for project token " + projectToken, e);

                return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(compose500Message("Fail to fetch claims" +

                        " for projects with token " + projectToken + ".", e)).type(MediaType.APPLICATION_JSON).build();

            }

        }

        return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access"))

                .type(MediaType.APPLICATION_JSON)

                .build();

    }

    @GET

    @Path("/contexts/{contextId}/claims")

    @Produces(MediaType.APPLICATION_JSON)

    public Response getContextClaims(@PathParam("contextId") String contextId,

                           @DefaultValue("0") @QueryParam("offset") int offset,

                           @DefaultValue("20") @QueryParam("limit") int limit,

                           @DefaultValue("") @QueryParam("keyword") String keyword,

                           @DefaultValue("") @QueryParam("sortby") String orderby,

                           @DefaultValue("true") @QueryParam("descending") boolean descending,

                           @DefaultValue("") @QueryParam("types") List<String> types,

                                     @HeaderParam("X-XSRF-TOKEN") String token,

                                     @CookieParam("AccessToken") String  cookie,

                                     @Context HttpServletRequest request) {

//        @RequestParam(value="includeStates[]", defaultValue="1,2,3") String[] includeStates

        if(token == null || token.isEmpty() || cookie == null || cookie.isEmpty() || !cookie.equals(token)){

            authorization.logStatus(token,cookie);

            return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access. Maybe you are not registered."))

                    .type(MediaType.APPLICATION_JSON)

                    .build();

        }

//        logger.debug("Calling API for context with token " + token);

        if(authorization.isAdmin(token)) {

            int total = -1;

            if (contextId == null || contextId.isEmpty()) {

                return Response.status(Response.Status.BAD_REQUEST).entity(compose400Message("Context id cannot be empty."))

                        .type(MediaType.APPLICATION_JSON).build();

            }

            logger.debug("Types are " + types);

            List<Claim> claims = null;

            try {

                claims = fetchClaimHandler.fetchClaimsByContext(contextId, limit, offset, keyword, orderby, descending, types,false);

                total = fetchClaimHandler.countClaimsByContext(contextId, keyword, types);

            } catch (SQLStoreException|Exception e) {

                logger.error("Could not fetch claims for context with id " + contextId, e);

                return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(compose500Message("Fail to fetch claims" +

                        " for context with id " + contextId + ".", e)).type(MediaType.APPLICATION_JSON).build();

            }

            return Response.status(200).entity(composeDataResponse(request, claims, total, offset, limit)).build();

        }

        return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access"))

                .type(MediaType.APPLICATION_JSON)

                .build();

    }

    @GET

    @Path("/results/{resultId}/claims")

    @Produces(MediaType.APPLICATION_JSON)

    public Response getResultClaims(@PathParam("resultId") String resultId,

                                    @DefaultValue("0") @QueryParam("offset") int offset,

                                    @DefaultValue("20") @QueryParam("limit") int limit,

                                    @DefaultValue("") @QueryParam("keyword") String keyword,

                                    @DefaultValue("") @QueryParam("sortby") String orderby,

                                    @DefaultValue("true") @QueryParam("descending") boolean descending,

                                    @DefaultValue("") @QueryParam("types") List<String> types,

                                    @HeaderParam("X-XSRF-TOKEN") String token,

                                    @CookieParam("AccessToken") String  cookie,

                                    @Context HttpServletRequest request) {

        if(token == null || token.isEmpty() || cookie == null || cookie.isEmpty() || !cookie.equals(token)){

            authorization.logStatus(token,cookie);

            return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access. Maybe you are not registered."))

                    .type(MediaType.APPLICATION_JSON)

                    .build();

        }

        if(authorization.isAdmin(token)) {

            int total = -1;

            if (resultId == null || resultId.isEmpty()) {

                return Response.status(Response.Status.BAD_REQUEST).entity(compose400Message("Context id cannot be empty."))

                        .type(MediaType.APPLICATION_JSON).build();

            }

            List<Claim> claims = null;

            try {

                claims = fetchClaimHandler.fetchClaimsByResult(resultId, limit, offset, keyword, orderby, descending, types,false);

                total = fetchClaimHandler.countClaimsByResult(resultId, keyword, types);

            } catch (SQLStoreException|Exception e) {

                logger.error("Could not fetch claims for result with id " + resultId, e);

                return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(compose500Message("Fail to fetch claims" +

                        " for result with id " + resultId + ".", e)).type(MediaType.APPLICATION_JSON).build();

            }

            return Response.status(200).entity(composeDataResponse(request, claims, total, offset, limit)).build();

        }

        return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access"))

                .type(MediaType.APPLICATION_JSON)

                .build();

    }

    @GET

    @Path("/users/claims")

    @Produces(MediaType.APPLICATION_JSON)

    public Response getUserClaims(@DefaultValue("0") @QueryParam("offset") int offset,

                                  @DefaultValue("20") @QueryParam("limit") int limit,

                                  @DefaultValue("") @QueryParam("keyword") String keyword,

                                  @DefaultValue("") @QueryParam("sortby") String orderby,

                                  @DefaultValue("true") @QueryParam("descending") boolean descending,

                                  @DefaultValue("") @QueryParam("types") List<String> types,

                                  @HeaderParam("X-XSRF-TOKEN") String token,

                                  @CookieParam("AccessToken") String  cookie,

                                  @Context HttpServletRequest request) {

        if(token == null || token.isEmpty() || cookie == null || cookie.isEmpty() || !cookie.equals(token)){

            return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access. Maybe you are not registered."))

                    .type(MediaType.APPLICATION_JSON)

                    .build();

        }

        UserInfo userInfo = authorization.getUserHandler().getUserInfo(token);

        if(authorization.isRegistered(userInfo)) {

            String userMail = userInfo.getEmail();

            logger.debug("User is registerd "  );

            int total = -1;

            EmailValidator emailValidator = EmailValidator.getInstance();

            if (userMail == null || userMail.isEmpty()) {

                return Response.status(Response.Status.BAD_REQUEST).entity(compose400Message("User e-mail cannot be empty."))

                        .type(MediaType.APPLICATION_JSON).build();

            }

            if (!emailValidator.isValid(userMail)) {

                return Response.status(Response.Status.BAD_REQUEST).entity(compose400Message("User e-mail is not valid."))

                        .type(MediaType.APPLICATION_JSON).build();

            }

            List<Claim> claims = null;

            try {

                logger.debug("About to fetch claims"  );

                claims = fetchClaimHandler.fetchClaimsByUser(userMail, limit, offset, keyword, orderby, descending, types,false);

                total = fetchClaimHandler.countClaimsByUser(userMail, keyword, types);

            } catch (SQLStoreException|Exception e) {

                logger.error("Could not fetch claims for user with mail " + userMail, e);

                return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(compose500Message("Fail to fetch claims" +

                        " for user with e-mail " + userMail + ".", e)).type(MediaType.APPLICATION_JSON).build();

            }

            return Response.status(200).entity(composeDataResponse(request, claims, total, offset, limit)).build();

        }

        logger.debug("User is *NOT* registerd "  );

        return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access. You are not registered."))

                .type(MediaType.APPLICATION_JSON)

                .build();

    }

    @GET

    @Path("/claims/{claimId}")

    @Produces(MediaType.APPLICATION_JSON)

    public Response getClaimsById(@PathParam("claimId") String claimId,

                                  @DefaultValue("0") @QueryParam("offset") int offset,

                                  @DefaultValue("20") @QueryParam("limit") int limit,

                                  @HeaderParam("X-XSRF-TOKEN") String token,

                                  @CookieParam("AccessToken") String  cookie,

                                  @Context HttpServletRequest request) {

        if(token == null || token.isEmpty() || cookie == null || cookie.isEmpty() || !cookie.equals(token)){

            return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access. Maybe you are not registered."))

                    .type(MediaType.APPLICATION_JSON)

                    .build();

        }

        if(authorization.isRegistered(token)) {

            List<Claim> claims = null;

            int total = -1;

            if (claimId == null || claimId.isEmpty()) {

                try {

                    claims = fetchClaimHandler.fetchAllClaims(limit, offset,false);

                    total = fetchClaimHandler.countAllClaims("", new ArrayList<String>());

                    return Response.status(200).entity(composeDataResponse(request, claims, total, offset, limit)).type(MediaType.APPLICATION_JSON).build();

                } catch (SQLStoreException|Exception e) {

                    logger.error("Could not fetch claims.", e);

                    return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(compose500Message("Fail to fetch claims.", e))

                            .type(MediaType.APPLICATION_JSON).build();

                }

            }

            try {

                Claim claim = fetchClaimHandler.fetchClaimById(claimId,false);

                if (claim == null) {

                    return Response.status(Response.Status.NOT_FOUND).entity(compose404Message("Cannot find claim with id " + claimId + "."))

                            .type(MediaType.APPLICATION_JSON).build();

                }

                return Response.status(200).entity(composeDataResponse(claim)).build();

            } catch (SQLStoreException|Exception e) {

                return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(compose500Message("Fail to fetch claim " +

                        "with id " + claimId + " id.", e)).type(MediaType.APPLICATION_JSON).build();

            }

        }

        return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access. You are not registered."))

                .type(MediaType.APPLICATION_JSON)

                .build();

    }

    @GET

    @Path("/claims")

    @Produces(MediaType.APPLICATION_JSON)

    public Response getAllClaims(@DefaultValue("0") @QueryParam("offset") int offset,

                                  @DefaultValue("20") @QueryParam("limit") int limit,

                                  @DefaultValue("") @QueryParam("keyword") String keyword,

                                  @DefaultValue("date") @QueryParam("sortby") String orderby,

                                  @DefaultValue("true") @QueryParam("descending") boolean descending,

                                  @DefaultValue("") @QueryParam("types") List<String> types,

                                 @HeaderParam("X-XSRF-TOKEN") String token,

                                 @HeaderParam("Origin") String origin,

                                 @CookieParam("AccessToken") String  cookie,

                                  @Context HttpServletRequest request) {

        logger.debug("Header  \"Origin\" has value  " + origin);

        if(token == null || token.isEmpty() || cookie == null || cookie.isEmpty() || !cookie.equals(token)){

            logger.debug("User is not  authorized - Eroor 403");

            return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access. Maybe you are not registered."))

                    .type(MediaType.APPLICATION_JSON)

                    .build();

        }

        if(authorization.isAdmin(token)) {

            logger.debug("User is authorized ! !");

            List<Claim> claims = null;

            int total = -1;

            try {

                claims = fetchClaimHandler.fetchAllClaims(limit, offset, keyword, orderby, descending, types,false);

                total = fetchClaimHandler.countAllClaims(keyword, types);

                return Response.status(200).entity(composeDataResponse(request, claims, total, offset, limit)).build();

            } catch (SQLStoreException|Exception e) {

                logger.error("Could not fetch claims.", e);

                return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(compose500Message("Fail to fetch claims.", e))

                        .type(MediaType.APPLICATION_JSON).build();

            }

        }

        return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access"))

               .type(MediaType.APPLICATION_JSON)

               .build();

    }

    //ARGIRO TODO: Na thn tsekarw

//    @POST

//    @Path("/claims/{claimId}")

//    @Produces(MediaType.APPLICATION_JSON)

//    public Response deleteClaim(@PathParam("claimId") String claimId,

//                                @QueryParam("token") String token) {

//

//        if(!JWTValidator.isValid(token)) {

//            return Response.status(Response.Status.UNAUTHORIZED).entity(compose404Message("Not valid Token"))

//                    .type(MediaType.APPLICATION_JSON)

//                    .build();

//        }

//        try {

//

//            if (authorization.isRegistered(token) && (authorization.getUserHandler().getMail(token).equals(fetchClaimHandler.fetchClaimById(claimId).getUserMail()))) {

//                if (claimId == null || claimId.isEmpty()) {

//                    return Response.status(Response.Status.NOT_FOUND).entity(compose404Message("Claim id cannot be empty."))

//                            .type(MediaType.APPLICATION_JSON).build();

//                }

//

//                try {

//                    if (claimHandler.deleteClaim(claimId)) {

//                        return Response.status(204).entity(compose204Message()).type(MediaType.APPLICATION_JSON).build();

//                    }

//

//                } catch (Exception e) {

//                    logger.error("Fail to delete claim with id " + claimId + ".", e);

//                    return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(compose500Message("Fail to delete claim with id " + claimId + ".", e))

//                            .type(MediaType.APPLICATION_JSON).build();

//                }

//

//                return Response.status(Response.Status.NOT_FOUND).entity(compose404Message("Claim id cannot be empty."))

//                        .type(MediaType.APPLICATION_JSON).build();

//            }

//

//            return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access. Maybe you are not registered."))

//                    .type(MediaType.APPLICATION_JSON)

//                    .build();

//

//        } catch (Exception e) {

//            logger.error("Could not fetch claims.", e);

//            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(compose500Message("Fail to fetch claims.", e))

//                    .type(MediaType.APPLICATION_JSON).build();

//        }

//    }

/*

    @DELETE

    @Path("/claims/{claimId}")

    public Response deleteClaim(@PathParam("claimId") String claimId) {

        if (claimId == null || claimId.isEmpty()) {

            return Response.status(Response.Status.NOT_FOUND).entity(compose404Message("Claim id cannot be empty.")).header("Access-Control-Allow-Origin", "*")

                    .header("Access-Control-Allow-Methods", "DELETE")

                    .type(MediaType.APPLICATION_JSON).build();

        }

        try {

            if(claimHandler.deleteClaim(claimId)) {

                return Response.status(204).entity(compose204Message()).header("Access-Control-Allow-Origin", "*")

                        .header("Access-Control-Allow-Methods", "DELETE").type(MediaType.APPLICATION_JSON).build();

            }

        } catch (Exception e) {return Response.status(Response.Status.UNAUTHORIZED).entity(compose404Message("Not valid Token"))

                    .type(MediaType.APPLICATION_JSON)

                    .build();

            logger.error("Fail to delete claim with id " + claimId + ".", e);

            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(compose500Message("Fail to delete claim with id " + claimId +".", e))

                    .header("Access-Control-Allow-Origin", "*")

                    .header("Access-Control-Allow-Methods", "DELETE")

                    .type(MediaType.APPLICATION_JSON).build();

        }

        return Response.status(Response.Status.NOT_FOUND).entity(compose404Message("Claim id cannot be empty.")).header("Access-Control-Allow-Origin", "*")

                .header("Access-Control-Allow-Methods", "DELETE")

                .type(MediaType.APPLICATION_JSON).build();

    }

 */

    @DELETE

    @Path("/claims/bulk")

    @Produces(MediaType.APPLICATION_JSON)

    public Response deleteBulkClaims(@QueryParam("claimId") List<String> claimIds,

                                     @HeaderParam("X-XSRF-TOKEN") String token,

                                     @HeaderParam("Origin") String origin,

                                     @CookieParam("AccessToken") String  cookie){

         if(token == null || token.isEmpty() || cookie == null || cookie.isEmpty() || !cookie.equals(token)|| !authorization.hasValidOrigin(origin)){

             return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access. Maybe you are not registered."))

                     .type(MediaType.APPLICATION_JSON)

                     .build();

         }

        ArrayList<String> deletedIds= new ArrayList<String>();

        ArrayList<String> notFoundIds= new ArrayList<String>();

        if (claimIds == null || claimIds.size() == 0) {

            return Response.status(Response.Status.NOT_FOUND).entity(compose404BulkDeleteMessage("Claim ids cannot be empty.",deletedIds,notFoundIds))

                    .type(MediaType.APPLICATION_JSON).build();

        }

        logger.debug("Trying to delete claims with ids: " + claimIds.toString() + ".");

        UserInfo userInfo = authorization.getUserHandler().getUserInfo(token);

        for (String claimId : claimIds) {

            try {

                if (authorization.isRegistered(userInfo)) {

                    if (authorization.isAdmin(userInfo) || userInfo.getEmail().equals(fetchClaimHandler.fetchClaimById(claimId,false).getUserMail())) {

                        if (claimHandler.deleteClaim(claimId)) {

                            deletedIds.add(claimId);

                        } else {

                            notFoundIds.add(claimId);

                        }

                    } else {

                        return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to delete."))

                                .type(MediaType.APPLICATION_JSON)

                                .build();

                    }

                } else {

                    return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access. Maybe you are not registered."))

                            .type(MediaType.APPLICATION_JSON)

                            .build();

                }

            } catch (SQLStoreException|Exception e) {

                logger.error("Fail to delete claim with id " + claimId + ".", e);

                notFoundIds.add(claimId);

            }

        }

        logger.debug("Successfully deleted " + deletedIds.size() + " from " + claimIds.size()  +". Deleted claims with ids: " + deletedIds.toString() + ".");

        if (claimIds.size() == notFoundIds.size()) {

            return Response.status(Response.Status.NOT_FOUND).entity(compose404BulkDeleteMessage("Claim ids cannot be empty.",deletedIds,notFoundIds))

                    .type(MediaType.APPLICATION_JSON).build();

        } else if (claimIds.size() == notFoundIds.size()) {

            return Response.status(204).entity(compose204BulkDeleteMessage(deletedIds,notFoundIds)).type(MediaType.APPLICATION_JSON).build();

        } else {

            return Response.status(204).entity(compose204BulkDeleteMessage(deletedIds,notFoundIds)).type(MediaType.APPLICATION_JSON).build();

        }

    }

    @POST

    @Path("/claims")

    @Produces(MediaType.APPLICATION_JSON)

    @Consumes(MediaType.APPLICATION_JSON)

    public Response addClaim(String input, @Context HttpServletRequest request,

                             @HeaderParam("X-XSRF-TOKEN") String token,

                             @HeaderParam("Origin") String origin,

                             @CookieParam("AccessToken") String  cookie) {

        if(token == null || token.isEmpty() || cookie == null || cookie.isEmpty() || !cookie.equals(token) || !authorization.hasValidOrigin(origin)){

            return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access. Maybe you are not registered."))

                    .type(MediaType.APPLICATION_JSON)

                    .build();

        }

        UserInfo userInfo = authorization.getUserHandler().getUserInfo(token);

        if(authorization.isRegistered(userInfo)) {

            JsonObject jsonObject = new JsonParser().parse(input).getAsJsonObject();

            String claimedBy = userInfo.getEmail();

            logger.info("claimedBy " + claimedBy);

            String sourceId = jsonObject.get("sourceId").getAsString();

            logger.info("sourceId " + sourceId);

            String sourceType = jsonObject.get("sourceType").getAsString();

            logger.info("sourceType " + sourceType);

            String sourceCollectedFrom = jsonObject.get("sourceCollectedFrom").getAsString();

            logger.info("sourceCollectedFrom " + sourceCollectedFrom);

            String sourceAccessRights = jsonObject.get("sourceAccessRights").getAsString();

            logger.info("sourceAccessRights " + sourceAccessRights);

            String sourceEmbargoEndDate = jsonObject.get("sourceEmbargoEndDate").getAsString();

            sourceEmbargoEndDate = (sourceEmbargoEndDate != null && sourceEmbargoEndDate.equals("")) ? null : sourceEmbargoEndDate;

            logger.info("sourceEmbargoEndDate " + sourceEmbargoEndDate);

            String targetId = jsonObject.get("targetId").getAsString();

            logger.info("targetId " + targetId);

            String targetType = jsonObject.get("targetType").getAsString();

            logger.info("targetType " + targetType);

            String targetCollectedFrom = jsonObject.get("targetCollectedFrom").getAsString();

            logger.info("targetCollectedFrom " + targetCollectedFrom);

            String targetAccessRights = jsonObject.get("targetAccessRights").getAsString();

            logger.info("targetAccessRights " + targetAccessRights);

            String targetEmbargoEndDate = jsonObject.get("targetEmbargoEndDate").getAsString();

            targetEmbargoEndDate = (targetEmbargoEndDate != null && targetEmbargoEndDate.equals("")) ? null : targetEmbargoEndDate;

            logger.info("targetEmbargoEndDate " + targetEmbargoEndDate);

            EmailValidator emailValidator = EmailValidator.getInstance();

            if (!emailValidator.isValid(claimedBy)) {

                return Response.status(Response.Status.BAD_REQUEST).entity(compose400Message("User e-mail is invalid."))

                        .type(MediaType.APPLICATION_JSON).build();

            }

            try {

                String claimId = claimHandler.buildAndInsertClaim(claimedBy, sourceType, sourceId, sourceCollectedFrom, sourceAccessRights, sourceEmbargoEndDate, targetType, targetId, targetCollectedFrom, targetAccessRights, targetEmbargoEndDate);

                return Response.status(200).entity(compose201PostMessage(request, claimId)).type(MediaType.APPLICATION_JSON).build();

            } catch (ClaimValidationException ve) {

                return Response.status(Response.Status.BAD_REQUEST).entity(compose400Message("The given ids are wrong.", ve))

                        .type(MediaType.APPLICATION_JSON).build();

            } catch (SQLStoreException|Exception e) {

                logger.error("Fail to add new claim.", e);

                return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(compose500Message("Fail to add new claim.", e))

                        .type(MediaType.APPLICATION_JSON).build();

            }

        }

        return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access."))

                .type(MediaType.APPLICATION_JSON)

                .build();

    }

    @POST

    @Path("/claims/bulk")

    @Produces(MediaType.APPLICATION_JSON)

    @Consumes(MediaType.APPLICATION_JSON)

    public Response addBulkClaims(String input, @Context HttpServletRequest request,

                                  @HeaderParam("X-XSRF-TOKEN") String token,

                                  @HeaderParam("Origin") String origin,

                                  @CookieParam("AccessToken") String  cookie) {

        if(token == null || token.isEmpty() || cookie == null || cookie.isEmpty() || !cookie.equals(token)|| !authorization.hasValidOrigin(origin)){

            return Response.status(Response.Status.FORBIDDEN).entity(compose403Message("Forbidden: You don't have permission to access. Maybe you are not registered."))

                    .type(MediaType.APPLICATION_JSON)

                    .build();

        }

        UserInfo userInfo = authorization.getUserHandler().getUserInfo(token);

        if(authorization.isRegistered(userInfo)) {

            ArrayList<String> insertedIds = new ArrayList<String>();

            JsonArray errorInClaims = new JsonArray();

            int code200 = 0;

            int code400 = 0;

            int code500 = 0;

            JsonArray jsonArray = new JsonParser().parse(input).getAsJsonArray();

            for (JsonElement je : jsonArray) {

                JsonObject jsonObject = je.getAsJsonObject();

                logger.info("targetId " + jsonObject.toString());

                String claimedBy = userInfo.getEmail();

                logger.info("claimedBy " + claimedBy);

                String sourceId = jsonObject.get("sourceId").getAsString();

                logger.info("sourceId " + sourceId);

                String sourceType = jsonObject.get("sourceType").getAsString();

                logger.info("sourceType " + sourceType);

                String sourceCollectedFrom = jsonObject.get("sourceCollectedFrom").getAsString();

                logger.info("sourceCollectedFrom " + sourceCollectedFrom);

                String sourceAccessRights = jsonObject.get("sourceAccessRights").getAsString();

                logger.info("sourceAccessRights " + sourceAccessRights);

                String sourceEmbargoEndDate = jsonObject.get("sourceEmbargoEndDate").getAsString();

                sourceEmbargoEndDate = (sourceEmbargoEndDate != null && sourceEmbargoEndDate.equals("")) ? null : sourceEmbargoEndDate;

                logger.info("sourceEmbargoEndDate " + sourceEmbargoEndDate);