MethodServiceImpl.java

/*
 * Copyright 2026 Global Crop Diversity Trust
 * Licensed under the Apache License, Version 2.0
 * See LICENSE file in project root folder or http://www.apache.org/licenses/LICENSE-2.0
 */

package org.gringlobal.service.impl;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

import org.genesys.filerepository.InvalidRepositoryFileDataException;
import org.genesys.filerepository.InvalidRepositoryPathException;

import org.gringlobal.custom.elasticsearch.SearchException;
import org.gringlobal.model.Method;
import org.gringlobal.model.MethodAttach;
import org.gringlobal.model.QMethodAttach;
import org.gringlobal.persistence.MethodRepository;
import org.gringlobal.service.MethodAttachmentService;
import org.gringlobal.service.MethodAttachmentService.MethodAttachmentRequest;
import org.gringlobal.service.MethodService;
import org.gringlobal.service.filter.MethodFilter;

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.multipart.MultipartFile;

/**
 * @author Maxym Borodenko
 */
@Service
@Transactional(readOnly = true)
@Validated
@Slf4j
public class MethodServiceImpl extends FilteredCRUDService2Impl<Method, MethodFilter, MethodRepository> implements MethodService {

	@Override
	@Transactional
	@PreAuthorize("@ggceSec.actionAllowed('MethodData', 'CREATE')")
	public Method create(final Method source) {
		return _lazyLoad(createFast(source));
	}

	@Override
	@Transactional
	@PreAuthorize("@ggceSec.actionAllowed('MethodData', 'CREATE')")
	public Method createFast(Method source) {
		log.debug("Create Method. Input data {}", source);
		Method method = new Method();
		method.apply(source);
		return repository.save(method);
	}

	@Override
	@Transactional
	@PreAuthorize("@ggceSec.actionAllowed('MethodData', 'WRITE')")
	public Method update(Method updated) {
		return super.update(updated);
	}

	@Override
	@Transactional
	@PreAuthorize("@ggceSec.actionAllowed('MethodData', 'WRITE')")
	public Method update(Method updated, Method target) {
		return _lazyLoad(updateFast(updated, target));
	}

	@Override
	@Transactional
	@PreAuthorize("@ggceSec.actionAllowed('MethodData', 'WRITE')")
	public Method updateFast(Method updated, Method target) {
		log.debug("Update Method. Input data {}", updated);
		target.apply(updated);
		return repository.save(target);
	}

	@Override
	public Page<Method> list(MethodFilter filter, Pageable page) throws SearchException {
		var methodPage = super.list(Method.class, filter, page);
		methodPage.getContent().forEach(Method::lazyLoad);
		return methodPage;
	}

	@Override
	@Transactional
	@PreAuthorize("@ggceSec.actionAllowed('MethodData', 'DELETE')")
	public Method remove(Method entity) {
		return super.remove(entity);
	}


	@Component
	protected static class AttachmentSupport extends BaseAttachmentSupport<Method, MethodAttach, MethodAttachmentRequest> implements MethodAttachmentService {

		public AttachmentSupport() {
			super(QMethodAttach.methodAttach.method().id, QMethodAttach.methodAttach.id);
		}

		@Override
		public Page<MethodAttach> list(Method method, Pageable page) {
			return (Page<MethodAttach>) attachFinder.findAll(QMethodAttach.methodAttach.method().eq(method), page);
		}

		@Override
		@PreAuthorize("hasAuthority('GROUP_ADMINS') or @ggceSec.actionAllowed('MethodData', 'WRITE')")
		@Transactional(propagation = Propagation.REQUIRES_NEW)
		public MethodAttach uploadFile(Method entity, MultipartFile file, MethodAttachmentRequest metadata) throws IOException, InvalidRepositoryPathException, InvalidRepositoryFileDataException {
			return super.uploadFile(entity, file, metadata);
		}

		@Override
		@PreAuthorize("hasAuthority('GROUP_ADMINS') or @ggceSec.actionAllowed('MethodData', 'WRITE')")
		public MethodAttach removeFile(Method entity, Long attachmentId) {
			return super.removeFile(entity, attachmentId);
		}

		@Override
		public Path createRepositoryPath(Method method) {
			method = owningEntityRepository.getReferenceById(method.getId());
			return Paths.get("/method/" + method.getName());
		}

		@Override
		@PreAuthorize("hasAuthority('GROUP_ADMINS') or @ggceSec.actionAllowed('MethodData', 'WRITE')")
		protected MethodAttach createAttach(Method entity, MethodAttach source) {
			MethodAttach attach = new MethodAttach();
			attach.apply(source);
			attach.setVirtualPath(source.getVirtualPath()); // SOAP uses this to create the record
			attach.setMethod(entity);
			return attach;
		}

		@Override
		@Transactional
		@PreAuthorize("hasAuthority('GROUP_ADMINS') or @ggceSec.actionAllowed('MethodData', 'WRITE')")
		public MethodAttach create(MethodAttach source) {
			return _lazyLoad(createFast(source));
		}

		@Override
		@Transactional
		@PreAuthorize("hasAuthority('GROUP_ADMINS') or @ggceSec.actionAllowed('MethodData', 'WRITE')")
		public MethodAttach createFast(MethodAttach source) {
			var owningEntity = owningEntityRepository.getReferenceById(source.getMethod().getId());

			var attach = createAttach(owningEntity, source);
			return repository.save(attach);
		}

		@Override
		@Transactional
		@PreAuthorize("hasAuthority('GROUP_ADMINS') or @ggceSec.actionAllowed('MethodData', 'WRITE')")
		public MethodAttach update(MethodAttach updated, MethodAttach target) {
			return _lazyLoad(updateFast(updated, target));
		}

		@Override
		@Transactional
		@PreAuthorize("hasAuthority('GROUP_ADMINS') or @ggceSec.actionAllowed('MethodData', 'WRITE')")
		public MethodAttach updateFast(MethodAttach updated, MethodAttach target) {
			target.apply(updated);
			updateRepositoryFileMetadata(updated, target);
			return repository.save(target);
		}

		@Override
		@PreAuthorize("hasAuthority('GROUP_ADMINS') or @ggceSec.actionAllowed('MethodData', 'WRITE')")
		public MethodAttach remove(MethodAttach entity) {
			return super.remove(entity);
		}
	}

}