argos/dmp-backend/src/main/java/rest/DMPs.java

package rest;

import java.util.List;
import java.util.UUID;

import org.apache.commons.lang3.SerializationUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import dao.entities.DMPDao;
import dao.entities.DMPProfileDao;
import dao.entities.DataRepositoryDao;
import dao.entities.DatasetDao;
import dao.entities.DatasetProfileDao;
import dao.entities.DatasetProfileRulesetDao;
import dao.entities.DatasetProfileViewstyleDao;
import dao.entities.OrganisationDao;
import dao.entities.ProjectDao;
import dao.entities.RegistryDao;
import dao.entities.ResearcherDao;
import dao.entities.ServiceDao;
import entities.DMP;
import entities.Dataset;
import entities.DatasetProfile;
import entities.DatasetProfileRuleset;
import entities.Project;
import entities.responses.IDLabelPair;
import helpers.Transformers;
import responses.RestResponse;


@RestController
@CrossOrigin
public class DMPs  {
	
	@Autowired private DataRepositoryDao dataRepositoryDao;
	@Autowired private DatasetDao datasetDao;
	@Autowired private DatasetProfileDao datasetProfileDao;
	@Autowired private DatasetProfileRulesetDao datasetProfileRulesetDao;
	@Autowired private DatasetProfileViewstyleDao datasetProfileViewstyleDao;
	@Autowired private DMPDao dMPDao;
	@Autowired private DMPProfileDao dMPProfileDao;
	@Autowired private OrganisationDao organisationDao;
	@Autowired private ProjectDao projectDao;
	@Autowired private RegistryDao registryDao;
	@Autowired private ResearcherDao researcherDao;
	@Autowired private ServiceDao serviceDao;
	

	
	
	// FETCH BY DMP(S)
	
	@RequestMapping(method = RequestMethod.GET, value = { "/DMP" }, produces="text/plain")
	public @ResponseBody ResponseEntity<Object> listDMPs(){
		try {
			List<UUID> allIDs = dMPDao.listAllIDs();
			return ResponseEntity.status(HttpStatus.OK).body(new ObjectMapper().writeValueAsString(allIDs));
		}
		catch(Exception ex) {
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Serialization issue: "+ex.getMessage());
		}
	}

	@RequestMapping(method = RequestMethod.GET, value = { "/listDMPLabelID" }, produces="text/plain")
	public @ResponseBody ResponseEntity<Object> listDmpLabelID(){
		try {
			List<IDLabelPair> allIDLabels = dMPDao.listAllIDsLabels();
			return ResponseEntity.status(HttpStatus.OK).body(new ObjectMapper().writeValueAsString(allIDLabels));
		}
		catch(Exception ex) {
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Serialization issue: "+ex.getMessage());
		}
	}
	

	@RequestMapping(method = RequestMethod.GET, value = { "/DMP/{id}" }, produces="application/json")
	public @ResponseBody ResponseEntity<Object> getDMP(@PathVariable("id") String id){
		try {
			DMP dmp = dMPDao.read(UUID.fromString(id));
			return ResponseEntity.status(HttpStatus.OK).body(new ObjectMapper().writeValueAsString(dmp));
		}
		catch(Exception ex) {
			return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("Erroneous input: "+ex.getMessage());
		}
	}
	
	
	/**
	 * This should be called on extreme cases. It's computationally intensive
	 */
	@RequestMapping(method = RequestMethod.GET, value = { "/getAllDMPs" }, produces="application/json")
	public @ResponseBody ResponseEntity<Object> getAllDMPs(){
		try {
			List<DMP> allDMPs = dMPDao.getAll();
			return ResponseEntity.status(HttpStatus.OK).body(new ObjectMapper().writeValueAsString(allDMPs));
		}
		catch(Exception ex) {
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Serialization issue: "+ex.getMessage());
		}
	}
	
	
	
	@RequestMapping(method = RequestMethod.POST, value = { "/setDMP" }, consumes = "application/json", produces="text/plain")
	public @ResponseBody ResponseEntity<Object> setDMP(@RequestBody DMP dmp) {
		
		//This function is a little bit tricky to implement (due to the irregular ORM mappings of the hibernate).
		// Please make changes only if you are sure about what you're altering.
		
		Dataset dataset = SerializationUtils.clone(dmp.getDataset());
		
		dmp.setDataset(null);
		
		int failsDMP = 0;
		String reasonDmp = "";
		DMP storedDMP = null;
		//try first to create DMP
		try {
			storedDMP = dMPDao.create(dmp);
		}
		catch(Exception e) {
			e.printStackTrace();
			failsDMP++;
			reasonDmp += e.getMessage();
			//try updating DMP
			try {
				storedDMP = dMPDao.update(dmp);
			}
			catch(Exception ex) {
				reasonDmp += (System.lineSeparator()+e.getMessage());
				failsDMP++;
				ex.printStackTrace();
			}
		}
		
		if(failsDMP==2)
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Could not create or update DMP! Reason: " + reasonDmp);
		
		dataset.setDmp(storedDMP); //very important!
		
		int failsDataset = 0;
		String reasonDataset = "";
		Dataset storedDataset = null;
		if(dataset != null) {
			//try first to create DMP
			try {
				storedDataset = datasetDao.create(dataset);
			}
			catch(Exception e) {
				e.printStackTrace();
				failsDataset++;
				reasonDataset += e.getMessage();
				//try updating DMP
				try {
					storedDataset = datasetDao.update(dataset);
				}
				catch(Exception ex) {
					reasonDataset += (System.lineSeparator()+e.getMessage());
					failsDataset++;
					ex.printStackTrace();
				}
			}
		}
		
		if(failsDataset != 2) {
			if(failsDMP==0)
				return ResponseEntity.status(HttpStatus.CREATED).body("Created DMP with id: " + storedDMP.getId());
			else if(failsDMP==1)
				return ResponseEntity.status(HttpStatus.CREATED).body("Updated DMP with id: " + storedDMP.getId());
			else
				return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Could not create DMP! Reason:"+ reasonDmp);
		}
		else {
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Could not create DMP! Failed to create or update its Dataset. Reason: "+reasonDataset);
		}

		
	}
	
	
	
	@RequestMapping(method = RequestMethod.POST, value = { "/setDMPByForm" }, consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE, produces="text/plain")
	public @ResponseBody ResponseEntity<Object> setDMPByForm(@RequestBody MultiValueMap<String,String> formData) {
		//create the whole dmp structure by the form fields 
		DMP dmp = Transformers.createDMPfromMap(formData);
		return setDMP(dmp);
	}
	
	@RequestMapping(method = RequestMethod.POST, value = { "/editDMPByForm" }, consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE, produces="text/plain")
	public @ResponseBody ResponseEntity<Object> editDMPByForm(@RequestBody MultiValueMap<String,String> formData) {
		//get previous DMP by id, replace fields, and update
		DMP dmp = dMPDao.read(UUID.fromString(formData.getFirst("dmp-id")));
		dmp.getDataset().getProfile().setDefinition(formData.getFirst("DatasetProfile.definition"));
		dmp.getDataset().getProfile().getRuleset().setDefinition(formData.getFirst("DatasetProfileRuleset.definition"));
		dmp.getDataset().getProfile().getViewstyle().setDefinition(formData.getFirst("DatasetProfileViewStyle.definition"));
		return setDMP(dmp);
	}
	
	
	
	
}