D-Net

package eu.dnetlib.openaire.rest;

import com.google.gson.Gson;

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

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

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

import org.apache.log4j.Logger;

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

import org.springframework.stereotype.Component;

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.List;

/**

 * Created by kiatrop on 15/4/2016.

 */

@Component

@Path("/claimsService")

public class HelloWorldService {

    Logger logger = Logger.getLogger(HelloWorldService.class);

    @Autowired

    private FetchClaimHandler fetchClaimHandler = null;

    @Autowired

    private ClaimHandler claimHandler = null;

    @GET

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

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

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

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

                           @Context HttpServletRequest request) {

        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);

            total = fetchClaimHandler.countClaimsByProject(projectId);

        } catch (Exception e) {

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

            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();

    }

    /*

    @GET

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

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

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

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

        if (contextId == null || contextId.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.fetchClaimsByContext(contextId, limit, offset);

        } catch (Exception e) {

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

            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(new Gson().toJson(claims)).build();

    }

    @GET

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

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

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

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

        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.fetchClaimsByContext(resultId, limit, offset);

        } catch (Exception e) {

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

            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(new Gson().toJson(claims)).build();

    }

    @GET

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

    public Response getUserClaims(@PathParam("userMail") String userMail,

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

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

        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();

        }

        List<Claim> claims = null;

        try {

            claims = fetchClaimHandler.fetchClaimsByUser(userMail, limit, offset);

        } catch (Exception e) {

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

            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(new Gson().toJson(claims)).build();

    }

    @GET

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

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

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

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

        List<Claim> claims = null;

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

            try {

                claims = fetchClaimHandler.fetchAllClaims(limit, offset);

                return Response.status(200).entity(new Gson().toJson(claims)).build();

            } catch (Exception e) {

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

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

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

            }

        }

        claims = new ArrayList<Claim>();

        Claim claim =  null;

        if(claim != null) {

            claims.add(claim);

        }

        return Response.status(200).entity(new Gson().toJson(claims)).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."))

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

        }

        try {

            claimHandler.deleteClaim(claimId);

        } 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(200).entity(compose200Message()).type(MediaType.APPLICATION_JSON).build();

    }

    @POST

    @Path("/addClaim")

    @Produces(MediaType.APPLICATION_JSON)

    @Consumes(MediaType.APPLICATION_JSON)

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

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

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

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

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

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

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

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

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

        try {

            claimHandler.buildAndInsertClaim(claimedBy, sourceType, sourceId, sourceCollectedFrom, targetType, targetId, targetCollectedFrom);

        } catch (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(200).entity(compose200PostMessage(request, "id")).type(MediaType.APPLICATION_JSON).build();

    }

*/

    @Path("/katerinaki")

    @GET

    @Produces(MediaType.APPLICATION_JSON)

    public Response fetchClaims() {

        try {

            String json = "{allakse pali}";

            return  Response.ok(json, MediaType.APPLICATION_JSON).build();

        } catch (Exception e) {

            e.printStackTrace();

        }

        return null;

    }

    private String compose400Message(String message) {

        return  "{ \"status\" : \"error\", \"code\" : \"400\", \"message\" : \"  " + message +" \" }";

    }

    private String compose404Message(String message) {

        return  "{ \"status\" : \"error\", \"code\" : \"404\", \"message\" : \"  " + message +" \" }";

    }

    private String compose500Message(String message, Exception exception) {

        return  "{ \"status\" : \"fail\", \"code\" : \"500\", \"message\" : \"  " + message + "\", " +

                "\"description\" : \""+  exception.getMessage() +"\" }";

    }

    private  String compose200Message(){

        return " { \"status\" : \"success\", \"code\": \"200\" }";

    }

    private  String compose200PostMessage(@Context HttpServletRequest request, String claimId){

        String url = request.getRequestURL().toString();

        String query = request.getQueryString();

        String reqString = url + " + " + query;

        return " { \"status\" : \"success\", \"code\": \"200\", \"link\": " + url + query + "\\claims\\" + claimId +" }";

    }

    private String composeDataResponse(HttpServletRequest request, List<Claim> claims, int total, int offset, int limit) {

        return " { \"status\" : \"success\", \"code\": \"200\", " + composePaging(request, total, offset, limit) + ", "

                + "\"data\" : " + new Gson().toJson(claims) + " }";

    }

    private String composePaging(HttpServletRequest request, int total, int currentOffset, int limit) {

        String url = request.getRequestURL().toString();

        String query = request.getQueryString();

        String first = url+query+"?offset=0&limit=20";

        int previousPage;

        int nextPage;

        int lastPage;

        if (total < currentOffset) {

            lastPage = 0;

        } else {

            if(total%limit == 0) {

                lastPage = total/limit-1;

            } else {

                lastPage = total/limit ;

            }

        }

        String last = url+query+"?offset=" + lastPage + "&limit=20";

        if (currentOffset-1 < 0) {

            previousPage = 0;

        } else {

            previousPage = currentOffset-1;

        }

        String previous = url+query+"?offset=" + previousPage + "&limit=20";

        if (currentOffset+1 > lastPage) {

            nextPage = lastPage;

        } else {

            nextPage = currentOffset + 1;

        }

        String next = url+query+"?offset=" + nextPage + "&limit=20";

        return "\"paging\": [" +  "{\"rel\":\"first\", \"href\":\"" + first +"\"}, {\"rel\":\"last\", \"href\":\"" + last + "\"}, {\"rel\":\"previous\", \"href\": \"" + previous + "\"}, {\"rel\":\"next\", \"href\":\"" +  next +"\"}"+ "]";

    }

   /* public static void main(String[] args) {

        HelloWorldService helloWorldService = new HelloWorldService();

        System.out.println(helloWorldService.composePaging(100, 0, 20, 0));

        System.out.println(helloWorldService.composePaging(100, 4, 20, 4));

        System.out.println(helloWorldService.composePaging(99, 4, 20, 0));

        System.out.println(helloWorldService.composePaging(99, 4, 20, 4));

        System.out.println(helloWorldService.composePaging(85, 4, 20, 4));

    }*/

}