DiversityTreeApiServiceImpl.java

/*
 * Copyright 2025 Global Crop Diversity Trust
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.genesys.server.api.v2.facade.impl;

import com.fasterxml.jackson.annotation.JsonUnwrapped;
import com.google.common.collect.Lists;
import com.opencsv.CSVParser;
import com.opencsv.CSVParserBuilder;
import com.opencsv.CSVReader;
import com.opencsv.CSVReaderBuilder;
import lombok.extern.slf4j.Slf4j;
import org.genesys.filerepository.InvalidRepositoryFileDataException;
import org.genesys.filerepository.InvalidRepositoryPathException;
import org.genesys.server.api.FilteredPage;
import org.genesys.server.api.v2.facade.DiversityTreeApiService;
import org.genesys.server.api.v2.mapper.MapstructMapper;
import org.genesys.server.api.v2.model.impl.DiversityTreeAccessionRefDTO;
import org.genesys.server.api.v2.model.impl.DiversityTreeCreatorDTO;
import org.genesys.server.api.v2.model.impl.DiversityTreeDTO;
import org.genesys.server.exception.DetailedConstraintViolationException;
import org.genesys.server.exception.SearchException;
import org.genesys.server.model.impl.DiversityTree;
import org.genesys.server.model.impl.DiversityTreeAccessionRef;
import org.genesys.server.service.DiversityTreeService;
import org.genesys.server.service.ElasticsearchService;
import org.genesys.server.service.filter.DiversityTreeFilter;
import org.genesys.taxonomy.gringlobal.component.CabReader;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.persistence.EntityManager;
import javax.validation.ConstraintViolation;
import javax.validation.Validator;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

@Transactional(readOnly = true)
@Service
@Slf4j
public class DiversityTreeApiServiceImpl implements DiversityTreeApiService {

	@Autowired
	private DiversityTreeService service;

	@Autowired
	private Validator validator;

	@Autowired
	private MapstructMapper mapper;

	@Autowired
	private EntityManager entityManager;

	@Override
	public DiversityTreeDTO load(UUID uuid) {
		return mapper.map(service.load(uuid));
	}

	@Override
	@Transactional
	public DiversityTreeDTO create(DiversityTreeDTO source) {
		return mapper.map(service.create(mapper.map(source)));
	}

	@Override
	@Transactional
	public DiversityTreeDTO update(DiversityTreeDTO source) {
		return mapper.map(service.update(mapper.map(source)));
	}

	@Override
	@Transactional
	public DiversityTreeDTO remove(UUID uuid, int version) {
		return mapper.map(service.remove(service.get(uuid, version)));
	}

	@Override
	public Page<DiversityTreeDTO> list(DiversityTreeFilter filter, Pageable page) throws SearchException {
		return mapper.map(service.list(filter, page), mapper::map);
	}

	@Override
	public Page<DiversityTreeDTO> listForCurrentUser(DiversityTreeFilter filter, Pageable page) {
		return mapper.map(service.listForCurrentUser(filter, page), mapper::map);
	}

	@Override
	public Page<DiversityTreeAccessionRefDTO> listAccessions(UUID uuid, Pageable page) {
		return mapper.map(service.listAccessionRefs(service.get(uuid), page), mapper::map);
	}

	@Override
	@Transactional
	public DiversityTreeDTO addAccessions(UUID uuid, int version, Set<DiversityTreeAccessionRefDTO> accessionRefs) {
		DiversityTree tree = service.get(uuid, version);
		log.info("Want to add {} accessionRefs to tree {}", accessionRefs.size(), tree.getUuid());

		final Authentication contextAuth = SecurityContextHolder.getContext().getAuthentication();
		Lists.partition(new ArrayList<>(accessionRefs), 2000).parallelStream().forEach(batch -> {
			final Authentication prevAuth = SecurityContextHolder.getContext().getAuthentication();
			try {
				SecurityContextHolder.getContext().setAuthentication(contextAuth);
				service.addAccessionRefs(tree, mapper.map(batch, mapper::map));
			} finally {
				SecurityContextHolder.getContext().setAuthentication(prevAuth);
			}
		});

		service.rematchAccessions(tree);
		return this.load(uuid);
	}

	@Override
	@Transactional
	public DiversityTreeDTO setAccessions(UUID uuid, int version, Set<DiversityTreeAccessionRefDTO> accessionRefs) {
		var tree = service.get(uuid, version);
		tree = service.setAccessionRefs(tree, mapper.map(accessionRefs, mapper::map));
		tree = service.rematchAccessions(tree);
		return mapper.map(tree);
	}

	@Override
	@Transactional
	public DiversityTreeDTO uploadAccessions(UUID uuid, int version, char separator, char quotechar, MultipartFile file) throws IOException {
		DiversityTree tree = service.get(uuid, version);
		List<DiversityTreeAccessionRef> accessionRefs = new ArrayList<>();

		// Build CSV parser
		CSVParser csvParser = new CSVParserBuilder().withSeparator(separator).withQuoteChar(quotechar).withEscapeChar((char) 0)
			.withStrictQuotes(false).withIgnoreLeadingWhiteSpace(false).withIgnoreQuotations(true).build();
		// Read file bytes as CSV
		try (CSVReader reader = new CSVReaderBuilder(CabReader.bomSafeReader(file.getInputStream())).withSkipLines(0).withCSVParser(csvParser).build()) {
			Iterator<DiversityTreeAccessionRef> beanReader = CabReader.beanReader(DiversityTreeAccessionRef.class, reader).iterator();
			DiversityTreeAccessionRef dtAcceRef = null;
			while (beanReader.hasNext() && (dtAcceRef = beanReader.next()) != null) {
				Set<ConstraintViolation<DiversityTreeAccessionRef>> violations = validator.validate(dtAcceRef);
				if (violations == null || violations.isEmpty()) {
					accessionRefs.add(dtAcceRef);
				} else {
					throw new DetailedConstraintViolationException("Failed to read CSV file in line " + reader.getLinesRead(), violations);
				}
			}
		}
		tree = service.setAccessionRefs(tree, accessionRefs);
		entityManager.detach(tree);
		tree = service.rematchAccessions(tree);

		return load(tree.getUuid());
	}

	@Override
	@Transactional
	public DiversityTreeDTO rematchAccessions(UUID uuid, int version) {
		return mapper.map(service.rematchAccessions(service.get(uuid, version)));
	}

	@Override
	@Transactional
	public DiversityTreeDTO approve(UUID uuid, int version) {
		return mapper.map(service.approve(service.get(uuid, version)));
	}

	@Override
	@Transactional
	public DiversityTreeDTO reject(UUID uuid, int version) {
		return mapper.map(service.reject(service.get(uuid, version)));
	}

	@Override
	@Transactional
	public DiversityTreeDTO createNewVersion(UUID uuid) {
		return mapper.map(service.createNewVersion(service.load(uuid)));
	}

	@Override
	@Transactional
	public DiversityTreeDTO uploadFile(UUID uuid, MultipartFile file) throws IOException, InvalidRepositoryPathException, InvalidRepositoryFileDataException {
		return mapper.map(service.uploadFile(service.get(uuid), file));
	}

	@Override
	public Page<DiversityTreeCreatorDTO> listCreators(UUID uuid, Pageable page) {
		return mapper.map(service.listCreators(uuid, page), mapper::map);
	}

	@Override
	public DiversityTreeCreatorDTO loadCreator(UUID creatorUuid) {
		return mapper.map(service.loadCreator(creatorUuid));
	}

	@Override
	@Transactional
	public DiversityTreeCreatorDTO create(UUID uuid, DiversityTreeCreatorDTO creator) {
		final DiversityTree tree = service.get(uuid);
		return mapper.map(service.createCreator(tree, mapper.map(creator)));
	}

	@Override
	@Transactional
	public DiversityTreeCreatorDTO update(UUID uuid, DiversityTreeCreatorDTO creator) {
		final DiversityTree tree = service.get(uuid);
		return mapper.map(service.updateCreator(tree, mapper.map(creator)));
	}

	@Override
	@Transactional
	public DiversityTreeCreatorDTO remove(UUID treeUuid, UUID creatorUuid, int version) {
		final DiversityTree tree = service.get(treeUuid);
		return mapper.map(service.removeCreator(tree, service.loadCreator(creatorUuid, version)));
	}

	@Override
	public List<DiversityTreeCreatorDTO> autocompleteCreators(String term) {
		return mapper.map(service.autocompleteCreators(term), mapper::map);
	}

	public static class DiversityTreeSuggestionPageDTO {
		@JsonUnwrapped
		public FilteredPage<DiversityTreeDTO, DiversityTreeFilter> page;
		public Map<String, ElasticsearchService.TermResult> suggestions;

		public static DiversityTreeSuggestionPageDTO from(FilteredPage<DiversityTreeDTO, DiversityTreeFilter> page, Map<String, ElasticsearchService.TermResult> suggestions) {
			DiversityTreeSuggestionPageDTO res = new DiversityTreeSuggestionPageDTO();
			res.page = page;
			res.suggestions = suggestions;
			return res;
		}
	}
}