fix:java项目性能优化

2026-05-28 15:51:39 +08:00
parent 8b65de36b8
commit 3bdd16cbd2
54 changed files with 3178 additions and 624 deletions
--- a/src/main/java/org/brapi/test/BrAPITestServer/controller/geno/GenotypingVariantWriteController.java
+++ b/src/main/java/org/brapi/test/BrAPITestServer/controller/geno/GenotypingVariantWriteController.java
@@ -0,0 +1,131 @@
+package org.brapi.test.BrAPITestServer.controller.geno;
+
+import java.util.List;
+
+import org.brapi.test.BrAPITestServer.controller.core.BrAPIController;
+import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerException;
+import org.brapi.test.BrAPITestServer.model.dto.geno.VariantSetWriteRequest;
+import org.brapi.test.BrAPITestServer.model.dto.geno.VariantWriteRequest;
+import org.brapi.test.BrAPITestServer.service.geno.VariantService;
+import org.brapi.test.BrAPITestServer.service.geno.VariantSetService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+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.RequestHeader;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import io.swagger.model.geno.Variant;
+import io.swagger.model.geno.VariantSet;
+import io.swagger.model.geno.VariantSetResponse;
+import io.swagger.model.geno.VariantSetsListResponse;
+import io.swagger.model.geno.VariantSetsListResponseResult;
+import io.swagger.model.geno.VariantSingleResponse;
+import io.swagger.model.geno.VariantsListResponse;
+import io.swagger.model.geno.VariantsListResponseResult;
+import jakarta.servlet.http.HttpServletRequest;
+
+@RestController
+public class GenotypingVariantWriteController extends BrAPIController {
+
+	private static final Logger log = LoggerFactory.getLogger(GenotypingVariantWriteController.class);
+
+	private final VariantSetService variantSetService;
+	private final VariantService variantService;
+	private final HttpServletRequest request;
+
+	@Autowired
+	public GenotypingVariantWriteController(VariantSetService variantSetService, VariantService variantService,
+			HttpServletRequest request) {
+		this.variantSetService = variantSetService;
+		this.variantService = variantService;
+		this.request = request;
+	}
+
+	@CrossOrigin
+	@RequestMapping(value = "/variantsets", produces = { "application/json" }, consumes = {
+			"application/json" }, method = RequestMethod.POST)
+	public ResponseEntity<VariantSetsListResponse> variantSetsPost(@RequestBody VariantSetWriteRequest body,
+			@RequestHeader(value = "Authorization", required = false) String authorization)
+			throws BrAPIServerException {
+		log.debug("Request: " + request.getRequestURI());
+		validateSecurityContext(request, "ROLE_USER");
+		validateAcceptHeader(request);
+		VariantSet data = variantSetService.saveVariantSet(body);
+		return responseOK(new VariantSetsListResponse(), new VariantSetsListResponseResult(), List.of(data));
+	}
+
+	@CrossOrigin
+	@RequestMapping(value = "/variantsets/{variantSetDbId}", produces = { "application/json" }, consumes = {
+			"application/json" }, method = RequestMethod.PUT)
+	public ResponseEntity<VariantSetResponse> variantSetsVariantSetDbIdPut(
+			@PathVariable("variantSetDbId") String variantSetDbId, @RequestBody VariantSetWriteRequest body,
+			@RequestHeader(value = "Authorization", required = false) String authorization)
+			throws BrAPIServerException {
+		log.debug("Request: " + request.getRequestURI());
+		validateSecurityContext(request, "ROLE_USER");
+		validateAcceptHeader(request);
+		VariantSet data = variantSetService.updateVariantSet(variantSetDbId, body);
+		return responseOK(new VariantSetResponse(), data);
+	}
+
+	@CrossOrigin
+	@RequestMapping(value = "/variantsets/{variantSetDbId}", produces = {
+			"application/json" }, method = RequestMethod.DELETE)
+	public ResponseEntity<VariantSetResponse> variantSetsVariantSetDbIdDelete(
+			@PathVariable("variantSetDbId") String variantSetDbId,
+			@RequestHeader(value = "Authorization", required = false) String authorization)
+			throws BrAPIServerException {
+		log.debug("Request: " + request.getRequestURI());
+		validateSecurityContext(request, "ROLE_USER");
+		validateAcceptHeader(request);
+		VariantSet data = variantSetService.deleteVariantSet(variantSetDbId);
+		return responseOK(new VariantSetResponse(), data);
+	}
+
+	@CrossOrigin
+	@RequestMapping(value = "/variants", produces = { "application/json" }, consumes = {
+			"application/json" }, method = RequestMethod.POST)
+	public ResponseEntity<VariantsListResponse> variantsPost(@RequestBody VariantWriteRequest body,
+			@RequestHeader(value = "Authorization", required = false) String authorization)
+			throws BrAPIServerException {
+		log.debug("Request: " + request.getRequestURI());
+		validateSecurityContext(request, "ROLE_USER");
+		validateAcceptHeader(request);
+		Variant data = variantService.saveVariant(body);
+		return responseOK(new VariantsListResponse(), new VariantsListResponseResult(), List.of(data));
+	}
+
+	@CrossOrigin
+	@RequestMapping(value = "/variants/{variantDbId}", produces = { "application/json" }, consumes = {
+			"application/json" }, method = RequestMethod.PUT)
+	public ResponseEntity<VariantSingleResponse> variantsVariantDbIdPut(
+			@PathVariable("variantDbId") String variantDbId, @RequestBody VariantWriteRequest body,
+			@RequestHeader(value = "Authorization", required = false) String authorization)
+			throws BrAPIServerException {
+		log.debug("Request: " + request.getRequestURI());
+		validateSecurityContext(request, "ROLE_USER");
+		validateAcceptHeader(request);
+		Variant data = variantService.updateVariant(variantDbId, body);
+		return responseOK(new VariantSingleResponse(), data);
+	}
+
+	@CrossOrigin
+	@RequestMapping(value = "/variants/{variantDbId}", produces = {
+			"application/json" }, method = RequestMethod.DELETE)
+	public ResponseEntity<VariantSingleResponse> variantsVariantDbIdDelete(
+			@PathVariable("variantDbId") String variantDbId,
+			@RequestHeader(value = "Authorization", required = false) String authorization)
+			throws BrAPIServerException {
+		log.debug("Request: " + request.getRequestURI());
+		validateSecurityContext(request, "ROLE_USER");
+		validateAcceptHeader(request);
+		Variant data = variantService.deleteVariant(variantDbId);
+		return responseOK(new VariantSingleResponse(), data);
+	}
+}
--- a/src/main/java/org/brapi/test/BrAPITestServer/model/dto/geno/VariantSetWriteRequest.java
+++ b/src/main/java/org/brapi/test/BrAPITestServer/model/dto/geno/VariantSetWriteRequest.java
@@ -0,0 +1,40 @@
+package org.brapi.test.BrAPITestServer.model.dto.geno;
+
+public class VariantSetWriteRequest {
+    private String variantSetDbId;
+    private String variantSetName;
+    private String referenceSetDbId;
+    private String studyDbId;
+
+    public String getVariantSetDbId() {
+        return variantSetDbId;
+    }
+
+    public void setVariantSetDbId(String variantSetDbId) {
+        this.variantSetDbId = variantSetDbId;
+    }
+
+    public String getVariantSetName() {
+        return variantSetName;
+    }
+
+    public void setVariantSetName(String variantSetName) {
+        this.variantSetName = variantSetName;
+    }
+
+    public String getReferenceSetDbId() {
+        return referenceSetDbId;
+    }
+
+    public void setReferenceSetDbId(String referenceSetDbId) {
+        this.referenceSetDbId = referenceSetDbId;
+    }
+
+    public String getStudyDbId() {
+        return studyDbId;
+    }
+
+    public void setStudyDbId(String studyDbId) {
+        this.studyDbId = studyDbId;
+    }
+}
--- a/src/main/java/org/brapi/test/BrAPITestServer/model/dto/geno/VariantWriteRequest.java
+++ b/src/main/java/org/brapi/test/BrAPITestServer/model/dto/geno/VariantWriteRequest.java
@@ -0,0 +1,141 @@
+package org.brapi.test.BrAPITestServer.model.dto.geno;
+
+import java.util.List;
+
+public class VariantWriteRequest {
+    private String variantDbId;
+    private String variantName;
+    private String variantType;
+    private String variantSetDbId;
+    private String referenceSetDbId;
+    private Integer start;
+    private Integer end;
+    private String referenceBases;
+    private Integer svlen;
+    private Boolean filtersApplied;
+    private Boolean filtersPassed;
+    private List<String> alternateBases;
+    private List<Integer> ciend;
+    private List<Integer> cipos;
+    private List<String> filtersFailed;
+
+    public String getVariantDbId() {
+        return variantDbId;
+    }
+
+    public void setVariantDbId(String variantDbId) {
+        this.variantDbId = variantDbId;
+    }
+
+    public String getVariantName() {
+        return variantName;
+    }
+
+    public void setVariantName(String variantName) {
+        this.variantName = variantName;
+    }
+
+    public String getVariantType() {
+        return variantType;
+    }
+
+    public void setVariantType(String variantType) {
+        this.variantType = variantType;
+    }
+
+    public String getVariantSetDbId() {
+        return variantSetDbId;
+    }
+
+    public void setVariantSetDbId(String variantSetDbId) {
+        this.variantSetDbId = variantSetDbId;
+    }
+
+    public String getReferenceSetDbId() {
+        return referenceSetDbId;
+    }
+
+    public void setReferenceSetDbId(String referenceSetDbId) {
+        this.referenceSetDbId = referenceSetDbId;
+    }
+
+    public Integer getStart() {
+        return start;
+    }
+
+    public void setStart(Integer start) {
+        this.start = start;
+    }
+
+    public Integer getEnd() {
+        return end;
+    }
+
+    public void setEnd(Integer end) {
+        this.end = end;
+    }
+
+    public String getReferenceBases() {
+        return referenceBases;
+    }
+
+    public void setReferenceBases(String referenceBases) {
+        this.referenceBases = referenceBases;
+    }
+
+    public Integer getSvlen() {
+        return svlen;
+    }
+
+    public void setSvlen(Integer svlen) {
+        this.svlen = svlen;
+    }
+
+    public Boolean getFiltersApplied() {
+        return filtersApplied;
+    }
+
+    public void setFiltersApplied(Boolean filtersApplied) {
+        this.filtersApplied = filtersApplied;
+    }
+
+    public Boolean getFiltersPassed() {
+        return filtersPassed;
+    }
+
+    public void setFiltersPassed(Boolean filtersPassed) {
+        this.filtersPassed = filtersPassed;
+    }
+
+    public List<String> getAlternateBases() {
+        return alternateBases;
+    }
+
+    public void setAlternateBases(List<String> alternateBases) {
+        this.alternateBases = alternateBases;
+    }
+
+    public List<Integer> getCiend() {
+        return ciend;
+    }
+
+    public void setCiend(List<Integer> ciend) {
+        this.ciend = ciend;
+    }
+
+    public List<Integer> getCipos() {
+        return cipos;
+    }
+
+    public void setCipos(List<Integer> cipos) {
+        this.cipos = cipos;
+    }
+
+    public List<String> getFiltersFailed() {
+        return filtersFailed;
+    }
+
+    public void setFiltersFailed(List<String> filtersFailed) {
+        this.filtersFailed = filtersFailed;
+    }
+}
--- a/src/main/java/org/brapi/test/BrAPITestServer/repository/geno/CallSetRepository.java
+++ b/src/main/java/org/brapi/test/BrAPITestServer/repository/geno/CallSetRepository.java
@@ -1,7 +1,19 @@
 package org.brapi.test.BrAPITestServer.repository.geno;

+import java.util.Collection;
+import java.util.List;
+
 import org.brapi.test.BrAPITestServer.model.entity.geno.CallSetEntity;
 import org.brapi.test.BrAPITestServer.repository.BrAPIRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+public interface CallSetRepository extends BrAPIRepository<CallSetEntity, String> {
+
+	@Query("SELECT COUNT(cs) FROM CallSetEntity cs JOIN cs.variantSets vs WHERE vs.id = :variantSetDbId")
+	long countByVariantSetDbId(@Param("variantSetDbId") String variantSetDbId);
+
+	@Query("SELECT vs.id, COUNT(cs) FROM CallSetEntity cs JOIN cs.variantSets vs WHERE vs.id IN :variantSetDbIds GROUP BY vs.id")
+	List<Object[]> countCallSetsGroupedByVariantSetId(@Param("variantSetDbIds") Collection<String> variantSetDbIds);

-public interface CallSetRepository extends BrAPIRepository<CallSetEntity, String>{
 }
--- a/src/main/java/org/brapi/test/BrAPITestServer/repository/geno/VariantRepository.java
+++ b/src/main/java/org/brapi/test/BrAPITestServer/repository/geno/VariantRepository.java
@@ -1,8 +1,18 @@
 package org.brapi.test.BrAPITestServer.repository.geno;

+import java.util.Collection;
+import java.util.List;
+
 import org.brapi.test.BrAPITestServer.model.entity.geno.VariantEntity;
 import org.brapi.test.BrAPITestServer.repository.BrAPIRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;

 public interface VariantRepository extends BrAPIRepository<VariantEntity, String> {

+	long countByVariantSet_Id(String variantSetId);
+
+	@Query("SELECT v.variantSet.id, COUNT(v) FROM VariantEntity v WHERE v.variantSet.id IN :variantSetDbIds GROUP BY v.variantSet.id")
+	List<Object[]> countVariantsGroupedByVariantSetId(@Param("variantSetDbIds") Collection<String> variantSetDbIds);
+
 }
--- a/src/main/java/org/brapi/test/BrAPITestServer/service/geno/VariantService.java
+++ b/src/main/java/org/brapi/test/BrAPITestServer/service/geno/VariantService.java
@@ -1,18 +1,29 @@
 package org.brapi.test.BrAPITestServer.service.geno;

 import java.util.Arrays;
+import java.util.Date;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;

 import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerDbIdNotFoundException;
 import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerException;
+import org.brapi.test.BrAPITestServer.model.dto.geno.VariantWriteRequest;
+import org.brapi.test.BrAPITestServer.model.entity.geno.CallEntity;
+import org.brapi.test.BrAPITestServer.model.entity.geno.MarkerPositionEntity;
+import org.brapi.test.BrAPITestServer.model.entity.geno.ReferenceSetEntity;
 import org.brapi.test.BrAPITestServer.model.entity.geno.VariantEntity;
+import org.brapi.test.BrAPITestServer.model.entity.geno.VariantSetEntity;
+import org.brapi.test.BrAPITestServer.repository.geno.CallRepository;
+import org.brapi.test.BrAPITestServer.repository.geno.MarkerPositionRepository;
 import org.brapi.test.BrAPITestServer.repository.geno.VariantRepository;
+import org.brapi.test.BrAPITestServer.repository.geno.VariantSetRepository;
 import org.brapi.test.BrAPITestServer.service.DateUtility;
 import org.brapi.test.BrAPITestServer.service.PagingUtility;
 import org.brapi.test.BrAPITestServer.service.SearchQueryBuilder;
+import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
@@ -25,9 +36,19 @@ import io.swagger.model.geno.VariantsSearchRequest;
 public class VariantService {

 	private final VariantRepository variantRepository;
+	private final CallRepository callRepository;
+	private final MarkerPositionRepository markerPositionRepository;
+	private final VariantSetRepository variantSetRepository;
+	private final ReferenceSetService referenceSetService;

-	public VariantService(VariantRepository variantRepository) {
+	public VariantService(VariantRepository variantRepository, CallRepository callRepository,
+			MarkerPositionRepository markerPositionRepository, VariantSetRepository variantSetRepository,
+			ReferenceSetService referenceSetService) {
 		this.variantRepository = variantRepository;
+		this.callRepository = callRepository;
+		this.markerPositionRepository = markerPositionRepository;
+		this.variantSetRepository = variantSetRepository;
+		this.referenceSetService = referenceSetService;
 	}

 	public List<Variant> findVariants(String variantDbId, String variantSetDbId, String referenceDbId,
@@ -61,7 +82,8 @@ public class VariantService {
 					"*callSet.id");
 		}
 		searchQuery = searchQuery.appendList(request.getVariantSetDbIds(), "variantSet.id")
-				.appendList(request.getVariantDbIds(), "id");
+				.appendList(request.getVariantDbIds(), "id")
+				.appendList(request.getReferenceSetDbIds(), "referenceSet.id");

 		Page<VariantEntity> page = variantRepository.findAllBySearch(searchQuery, pageReq);
 		PagingUtility.calculateMetaData(metadata, page);
@@ -99,14 +121,19 @@ public class VariantService {
 		variant.setFiltersFailed(entity.getFiltersFailed());
 		variant.setFiltersPassed(entity.getFiltersPassed());
 		variant.setReferenceBases(entity.getReferenceBases());
-		if (entity.getReferenceSet() != null)
+		if (entity.getReferenceSet() != null) {
+			variant.setReferenceSetDbId(entity.getReferenceSet().getId());
+			variant.setReferenceSetName(entity.getReferenceSet().getReferenceSetName());
 			variant.setReferenceName(entity.getReferenceSet().getReferenceSetName());
+		}
 		variant.setStart(entity.getStart());
 		variant.setSvlen(entity.getSvlen());
 		variant.setUpdated(DateUtility.toOffsetDateTime(entity.getUpdated()));
 		variant.setVariantDbId(entity.getId());
 		variant.setVariantNames(Arrays.asList(entity.getVariantName()));
-		variant.setVariantSetDbId(Arrays.asList(entity.getVariantSet().getId()));
+		if (entity.getVariantSet() != null) {
+			variant.setVariantSetDbId(Arrays.asList(entity.getVariantSet().getId()));
+		}
 		variant.setVariantType(entity.getVariantType());

 		return variant;
@@ -116,4 +143,108 @@ public class VariantService {
 		return variantRepository.save(entity);
 	}

+	public Variant saveVariant(VariantWriteRequest request) throws BrAPIServerException {
+		if (request.getVariantName() == null || request.getVariantName().isBlank()) {
+			throw new BrAPIServerException(HttpStatus.BAD_REQUEST, "variantName is required");
+		}
+		if (request.getVariantDbId() != null && variantRepository.findById(request.getVariantDbId()).isPresent()) {
+			throw new BrAPIServerException(HttpStatus.CONFLICT, "Variant already exists: " + request.getVariantDbId());
+		}
+		VariantEntity entity = new VariantEntity();
+		if (request.getVariantDbId() != null && !request.getVariantDbId().isBlank()) {
+			entity.setId(request.getVariantDbId().trim());
+		}
+		entity.setCreated(new Date());
+		entity.setUpdated(new Date());
+		updateEntity(entity, request);
+		return convertFromEntity(variantRepository.save(entity));
+	}
+
+	public Variant updateVariant(String variantDbId, VariantWriteRequest request) throws BrAPIServerException {
+		VariantEntity entity = getVariantEntity(variantDbId, HttpStatus.NOT_FOUND);
+		entity.setUpdated(new Date());
+		updateEntity(entity, request);
+		return convertFromEntity(variantRepository.save(entity));
+	}
+
+	public Variant deleteVariant(String variantDbId) throws BrAPIServerException {
+		VariantEntity entity = getVariantEntity(variantDbId, HttpStatus.NOT_FOUND);
+		assertNoVariantDependencies(variantDbId);
+		Variant deleted = convertFromEntity(entity);
+		try {
+			variantRepository.delete(entity);
+			variantRepository.flush();
+		} catch (DataIntegrityViolationException e) {
+			throw new BrAPIServerException(HttpStatus.CONFLICT, "Variant is in use and cannot be deleted");
+		}
+		return deleted;
+	}
+
+	private void assertNoVariantDependencies(String variantDbId) throws BrAPIServerException {
+		Pageable pageReq = PageRequest.of(0, 1);
+		SearchQueryBuilder<CallEntity> callQuery = new SearchQueryBuilder<CallEntity>(CallEntity.class)
+				.appendSingle(variantDbId, "variant.id");
+		if (callRepository.findAllBySearch(callQuery, pageReq).getTotalElements() > 0) {
+			throw new BrAPIServerException(HttpStatus.CONFLICT, "Variant is referenced by allele_call records");
+		}
+		SearchQueryBuilder<MarkerPositionEntity> markerQuery = new SearchQueryBuilder<MarkerPositionEntity>(
+				MarkerPositionEntity.class).appendSingle(variantDbId, "variant.id");
+		if (markerPositionRepository.findAllBySearch(markerQuery, pageReq).getTotalElements() > 0) {
+			throw new BrAPIServerException(HttpStatus.CONFLICT, "Variant is referenced by marker_position records");
+		}
+	}
+
+	private void updateEntity(VariantEntity entity, VariantWriteRequest request) throws BrAPIServerException {
+		entity.setVariantName(request.getVariantName().trim());
+		entity.setVariantType(request.getVariantType());
+		entity.setStart(request.getStart());
+		entity.setEnd(request.getEnd());
+		if (request.getStart() != null && request.getEnd() != null && request.getEnd() < request.getStart()) {
+			throw new BrAPIServerException(HttpStatus.BAD_REQUEST, "variant end cannot be less than start");
+		}
+		entity.setReferenceBases(request.getReferenceBases());
+		entity.setSvlen(request.getSvlen());
+		entity.setFiltersApplied(request.getFiltersApplied());
+		entity.setFiltersPassed(request.getFiltersPassed());
+		if (request.getAlternateBases() != null) {
+			entity.setAlternateBases(request.getAlternateBases());
+		}
+		if (request.getCiend() != null) {
+			entity.setCiend(request.getCiend());
+		}
+		if (request.getCipos() != null) {
+			entity.setCipos(request.getCipos());
+		}
+		if (request.getFiltersFailed() != null) {
+			entity.setFiltersFailed(request.getFiltersFailed());
+		}
+
+		VariantSetEntity variantSet = null;
+		if (request.getVariantSetDbId() != null && !request.getVariantSetDbId().isBlank()) {
+			variantSet = variantSetRepository.findById(request.getVariantSetDbId())
+					.orElseThrow(() -> new BrAPIServerDbIdNotFoundException("variantSet", request.getVariantSetDbId(),
+							HttpStatus.BAD_REQUEST));
+			entity.setVariantSet(variantSet);
+		} else if (request.getVariantSetDbId() != null) {
+			entity.setVariantSet(null);
+		}
+
+		ReferenceSetEntity referenceSet = null;
+		if (request.getReferenceSetDbId() != null && !request.getReferenceSetDbId().isBlank()) {
+			referenceSet = referenceSetService.getReferenceSetEntity(request.getReferenceSetDbId());
+			entity.setReferenceSet(referenceSet);
+		} else if (request.getReferenceSetDbId() != null) {
+			entity.setReferenceSet(null);
+		} else if (variantSet != null && variantSet.getReferenceSet() != null) {
+			entity.setReferenceSet(variantSet.getReferenceSet());
+		}
+
+		if (variantSet != null && referenceSet != null
+				&& variantSet.getReferenceSet() != null
+				&& !variantSet.getReferenceSet().getId().equals(referenceSet.getId())) {
+			throw new BrAPIServerException(HttpStatus.BAD_REQUEST,
+					"referenceSetDbId must match the reference set of the selected variantSet");
+		}
+	}
+
 }
--- a/src/main/java/org/brapi/test/BrAPITestServer/service/geno/VariantSetService.java
+++ b/src/main/java/org/brapi/test/BrAPITestServer/service/geno/VariantSetService.java
@@ -9,17 +9,24 @@ import java.util.stream.Collectors;

 import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerDbIdNotFoundException;
 import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerException;
+import org.brapi.test.BrAPITestServer.model.dto.geno.VariantSetWriteRequest;
+import org.brapi.test.BrAPITestServer.model.entity.core.StudyEntity;
 import org.brapi.test.BrAPITestServer.model.entity.geno.CallEntity;
+import org.brapi.test.BrAPITestServer.model.entity.geno.ReferenceSetEntity;
 import org.brapi.test.BrAPITestServer.model.entity.geno.CallSetEntity;
 import org.brapi.test.BrAPITestServer.model.entity.geno.VariantEntity;
 import org.brapi.test.BrAPITestServer.model.entity.geno.VariantSetAnalysisEntity;
 import org.brapi.test.BrAPITestServer.model.entity.geno.VariantSetAvailableFormatEntity;
 import org.brapi.test.BrAPITestServer.model.entity.geno.VariantSetEntity;
+import org.brapi.test.BrAPITestServer.repository.geno.CallSetRepository;
+import org.brapi.test.BrAPITestServer.repository.geno.VariantRepository;
 import org.brapi.test.BrAPITestServer.repository.geno.VariantSetRepository;
+import org.brapi.test.BrAPITestServer.service.core.StudyService;
 import org.brapi.test.BrAPITestServer.service.DateUtility;
 import org.brapi.test.BrAPITestServer.service.PagingUtility;
 import org.brapi.test.BrAPITestServer.service.SearchQueryBuilder;
 import org.brapi.test.BrAPITestServer.service.UpdateUtility;
+import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.http.HttpStatus;
@@ -41,16 +48,25 @@ import io.swagger.model.geno.VariantSetsExtractRequest;
 public class VariantSetService {

 	private final VariantSetRepository variantSetRepository;
+	private final VariantRepository variantRepository;
+	private final CallSetRepository callSetRepository;
 	private final VariantService variantService;
 	private final CallSetService callSetService;
 	private final CallService callService;
+	private final ReferenceSetService referenceSetService;
+	private final StudyService studyService;

-	public VariantSetService(VariantSetRepository variantSetRepository, VariantService variantService,
-			CallSetService callSetService, CallService callService) {
+	public VariantSetService(VariantSetRepository variantSetRepository, VariantRepository variantRepository,
+			CallSetRepository callSetRepository, VariantService variantService, CallSetService callSetService,
+			CallService callService, ReferenceSetService referenceSetService, StudyService studyService) {
 		this.variantSetRepository = variantSetRepository;
+		this.variantRepository = variantRepository;
+		this.callSetRepository = callSetRepository;
 		this.variantService = variantService;
 		this.callSetService = callSetService;
 		this.callService = callService;
+		this.referenceSetService = referenceSetService;
+		this.studyService = studyService;
 	}

 	public List<VariantSet> findVariantSets(String variantSetDbId, String variantDbId, String callSetDbId,
@@ -79,9 +95,7 @@ public class VariantSetService {
 	}

 	public List<VariantSet> findVariantSets(VariantSetsSearchRequest request, Metadata metadata) {
-		List<VariantSet> variantSets = findVariantSetEntities(request, metadata).stream().map(this::convertFromEntity)
-				.collect(Collectors.toList());
-		return variantSets;
+		return convertFromEntities(findVariantSetEntities(request, metadata));
 	}

 	private List<VariantSetEntity> findVariantSetEntities(VariantSetsSearchRequest request, Metadata metadata) {
@@ -95,7 +109,9 @@ public class VariantSetService {
 			searchQuery.join("variants", "variant").appendList(request.getVariantDbIds(), "*variant.id");
 		}
 		searchQuery.appendList(request.getStudyDbIds(), "study.id")
-				.appendList(request.getStudyNames(), "study.studyName").appendList(request.getVariantSetDbIds(), "id");
+				.appendList(request.getStudyNames(), "study.studyName")
+				.appendList(request.getReferenceSetDbIds(), "referenceSet.id")
+				.appendList(request.getVariantSetDbIds(), "id");

 		Page<VariantSetEntity> page = variantSetRepository.findAllBySearch(searchQuery, pageReq);
 		PagingUtility.calculateMetaData(metadata, page);
@@ -106,6 +122,74 @@ public class VariantSetService {
 		return convertFromEntity(getVariantSetEntity(variantSetDbId, HttpStatus.NOT_FOUND));
 	}

+	public VariantSet saveVariantSet(VariantSetWriteRequest request) throws BrAPIServerException {
+		if (request.getVariantSetName() == null || request.getVariantSetName().isBlank()) {
+			throw new BrAPIServerException(HttpStatus.BAD_REQUEST, "variantSetName is required");
+		}
+		if (request.getVariantSetDbId() != null
+				&& variantSetRepository.findById(request.getVariantSetDbId()).isPresent()) {
+			throw new BrAPIServerException(HttpStatus.CONFLICT,
+					"VariantSet already exists: " + request.getVariantSetDbId());
+		}
+		VariantSetEntity entity = new VariantSetEntity();
+		if (request.getVariantSetDbId() != null && !request.getVariantSetDbId().isBlank()) {
+			entity.setId(request.getVariantSetDbId().trim());
+		}
+		updateEntity(entity, request);
+		return convertFromEntity(variantSetRepository.save(entity));
+	}
+
+	public VariantSet updateVariantSet(String variantSetDbId, VariantSetWriteRequest request)
+			throws BrAPIServerException {
+		VariantSetEntity entity = getVariantSetEntity(variantSetDbId, HttpStatus.NOT_FOUND);
+		updateEntity(entity, request);
+		return convertFromEntity(variantSetRepository.save(entity));
+	}
+
+	public VariantSet deleteVariantSet(String variantSetDbId) throws BrAPIServerException {
+		VariantSetEntity entity = getVariantSetEntity(variantSetDbId, HttpStatus.NOT_FOUND);
+		assertNoVariantSetDependencies(entity);
+		VariantSet deleted = convertFromEntity(entity);
+		try {
+			variantSetRepository.delete(entity);
+			variantSetRepository.flush();
+		} catch (DataIntegrityViolationException e) {
+			throw new BrAPIServerException(HttpStatus.CONFLICT, "VariantSet is in use and cannot be deleted");
+		}
+		return deleted;
+	}
+
+	private void assertNoVariantSetDependencies(VariantSetEntity entity) throws BrAPIServerException {
+		if (entity.getVariants() != null && !entity.getVariants().isEmpty()) {
+			throw new BrAPIServerException(HttpStatus.CONFLICT, "VariantSet is referenced by Variant records");
+		}
+		if (entity.getCallSets() != null && !entity.getCallSets().isEmpty()) {
+			throw new BrAPIServerException(HttpStatus.CONFLICT, "VariantSet is referenced by CallSet records");
+		}
+		if (entity.getAnalysis() != null && !entity.getAnalysis().isEmpty()) {
+			throw new BrAPIServerException(HttpStatus.CONFLICT, "VariantSet is referenced by analysis records");
+		}
+		if (entity.getAvailableFormats() != null && !entity.getAvailableFormats().isEmpty()) {
+			throw new BrAPIServerException(HttpStatus.CONFLICT, "VariantSet is referenced by available format records");
+		}
+	}
+
+	private void updateEntity(VariantSetEntity entity, VariantSetWriteRequest request) throws BrAPIServerException {
+		entity.setVariantSetName(request.getVariantSetName().trim());
+		if (request.getReferenceSetDbId() != null && !request.getReferenceSetDbId().isBlank()) {
+			ReferenceSetEntity referenceSet = referenceSetService.getReferenceSetEntity(request.getReferenceSetDbId());
+			entity.setReferenceSet(referenceSet);
+		} else if (request.getReferenceSetDbId() != null) {
+			entity.setReferenceSet(null);
+		}
+		if (request.getStudyDbId() != null && !request.getStudyDbId().isBlank()) {
+			StudyEntity study = studyService.getStudyEntity(request.getStudyDbId());
+			entity.setStudy(study);
+		} else if (request.getStudyDbId() != null) {
+			entity.setStudy(null);
+		}
+	}
+
 	public VariantSetEntity getVariantSetEntity(String variantSetDbId) throws BrAPIServerException {
 		return getVariantSetEntity(variantSetDbId, HttpStatus.BAD_REQUEST);
 	}
@@ -122,7 +206,34 @@ public class VariantSetService {
 		return variantSet;
 	}

+	private List<VariantSet> convertFromEntities(List<VariantSetEntity> entities) {
+		if (entities.isEmpty()) {
+			return List.of();
+		}
+		List<String> variantSetDbIds = entities.stream().map(VariantSetEntity::getId).collect(Collectors.toList());
+		Map<String, Long> variantCounts = toCountMap(variantRepository.countVariantsGroupedByVariantSetId(variantSetDbIds));
+		Map<String, Long> callSetCounts = toCountMap(callSetRepository.countCallSetsGroupedByVariantSetId(variantSetDbIds));
+		return entities.stream()
+				.map(entity -> convertFromEntity(entity,
+						variantCounts.getOrDefault(entity.getId(), 0L),
+						callSetCounts.getOrDefault(entity.getId(), 0L)))
+				.collect(Collectors.toList());
+	}
+
+	private Map<String, Long> toCountMap(List<Object[]> rows) {
+		Map<String, Long> counts = new HashMap<>();
+		for (Object[] row : rows) {
+			counts.put((String) row[0], ((Number) row[1]).longValue());
+		}
+		return counts;
+	}
+
 	private VariantSet convertFromEntity(VariantSetEntity entity) {
+		return convertFromEntity(entity, variantRepository.countByVariantSet_Id(entity.getId()),
+				callSetRepository.countByVariantSetDbId(entity.getId()));
+	}
+
+	private VariantSet convertFromEntity(VariantSetEntity entity, long variantCount, long callSetCount) {
 		VariantSet variantSet = new VariantSet();
 		UpdateUtility.convertFromEntity(entity, variantSet);
 		if (entity.getAnalysis() != null)
@@ -131,14 +242,12 @@ public class VariantSetService {
 		if (entity.getAvailableFormats() != null)
 			variantSet.setAvailableFormats(
 					entity.getAvailableFormats().stream().map(this::convertFromEntity).collect(Collectors.toList()));
-		if (entity.getCallSets() != null)
-			variantSet.setCallSetCount(entity.getCallSets().size());
+		variantSet.setCallSetCount(toCountInteger(callSetCount));
 		if (entity.getReferenceSet() != null)
 			variantSet.setReferenceSetDbId(entity.getReferenceSet().getId());
 		if (entity.getStudy() != null)
 			variantSet.setStudyDbId(entity.getStudy().getId());
-		if (entity.getVariants() != null)
-			variantSet.setVariantCount(entity.getVariants().size());
+		variantSet.setVariantCount(toCountInteger(variantCount));
 		variantSet.setVariantSetDbId(entity.getId());
 		variantSet.setVariantSetName(entity.getVariantSetName());

@@ -163,6 +272,10 @@ public class VariantSetService {
 		return variantSet;
 	}

+	private Integer toCountInteger(long count) {
+		return count > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) count;
+	}
+
 	private Analysis convertFromEntity(VariantSetAnalysisEntity entity) {
 		Analysis analysis = new Analysis();
 		analysis.setAnalysisDbId(entity.getId());