src/main/java/org/eclipse/openk/contactbasedata/service/InternalPersonService.java

package org.eclipse.openk.contactbasedata.service;

import lombok.extern.log4j.Log4j2;
import org.eclipse.openk.contactbasedata.constants.Constants;
import org.eclipse.openk.contactbasedata.exceptions.NotFoundException;
import org.eclipse.openk.contactbasedata.mapper.ContactMapper;
import org.eclipse.openk.contactbasedata.mapper.ExternalPersonMapper;
import org.eclipse.openk.contactbasedata.mapper.InternalPersonMapper;
import org.eclipse.openk.contactbasedata.model.*;
import org.eclipse.openk.contactbasedata.repository.*;
import org.eclipse.openk.contactbasedata.viewmodel.ExternalPersonDto;
import org.eclipse.openk.contactbasedata.viewmodel.InternalPersonDto;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.UUID;

@Log4j2
@Service
public class InternalPersonService {
    @Autowired
    private InternalPersonRepository internalPersonRepository;

    @Autowired
    private ContactRepository contactRepository;

    @Autowired
    private SalutationRepository salutationRepository;

    @Autowired
    private PersonTypeRepository personTypeRepository;

    @Autowired
    private InternalPersonMapper internalPersonMapper;

    @Autowired
    private ContactMapper contactMapper;

    @Autowired
    private BaseContactService baseContactService;

    public InternalPersonDto findInternalPerson(UUID contactUuid) {
        return internalPersonMapper.toInternalPersonDto(
                internalPersonRepository.findByTblContactUuid(contactUuid).orElseThrow(NotFoundException::new)
        );
    }

    public Page<InternalPersonDto> findInternalPersons(Pageable pageable) {
        return internalPersonRepository.findAll(pageable).map(internalPersonMapper::toInternalPersonDto);
    }


    @Transactional
    public InternalPersonDto insertInternalPerson(InternalPersonDto internalPersonDto) {
        TblContact contactToSave = new TblContact();
        contactToSave.setUuid(UUID.randomUUID());
        contactToSave.setContactType(Constants.CONTACT_TYPE_INTERNAL_PERSON);

        TblInternalPerson internalPersonToSave = internalPersonMapper.toTblInternalPerson(internalPersonDto);
        internalPersonToSave.setContact(contactToSave);
        contactRepository.save(internalPersonToSave.getContact());

        setFromInternalPersonDto( internalPersonToSave, internalPersonDto );
        // Save Contact first

        // Then save dependent Model-Object
        return internalPersonMapper.toInternalPersonDto(internalPersonRepository.save(internalPersonToSave));
    }

    @Transactional
    public InternalPersonDto updateInternalPerson(InternalPersonDto internalPersonDto){
        TblInternalPerson internalPersonUpdated;

        //Interne Person holen
        TblInternalPerson existingInternalPerson = internalPersonRepository
                .findByTblContactUuid(internalPersonDto.getContactId())
                .orElseThrow(() -> new NotFoundException("contact.uuid.not.existing"));

        existingInternalPerson.setLastName(internalPersonDto.getLastName());
        existingInternalPerson.setFirstName(internalPersonDto.getFirstName());
        existingInternalPerson.setTitle(internalPersonDto.getTitle());

        setFromInternalPersonDto( existingInternalPerson, internalPersonDto );
        internalPersonUpdated = internalPersonRepository.save(existingInternalPerson);

        return internalPersonMapper.toInternalPersonDto(internalPersonUpdated);
    }

    private void setFromInternalPersonDto( TblInternalPerson destTblInternalPerson, InternalPersonDto sourceDto ) {
        RefSalutation salutationUpdated = salutationRepository
                .findByUuid(sourceDto.getSalutationId())
                .orElseThrow(() -> new NotFoundException("salutation.uuid.not.existing"));
        RefPersonType personTypeUpdated = personTypeRepository
                .findByUuid(sourceDto.getPersonTypeId())
                .orElseThrow(() -> new NotFoundException("person.type.uuid.not.existing"));

        destTblInternalPerson.setSalutation(salutationUpdated);
        destTblInternalPerson.setRefPersonType(personTypeUpdated);

        destTblInternalPerson.getContact().setNote(sourceDto.getContactNote());
    }
}