aswi2022code-of-duty-gitlab/backend/src/main/java/cz/zcu/kiv/backendapi/catalog/CatalogItemServiceImpl.java @ ad885d86

package cz.zcu.kiv.backendapi.catalog;

import cz.zcu.kiv.backendapi.alternativename.CatalogItemName;
import cz.zcu.kiv.backendapi.bibliography.Bibliography;
import cz.zcu.kiv.backendapi.country.Country;
import cz.zcu.kiv.backendapi.exception.ApiRequestException;
import cz.zcu.kiv.backendapi.path.PathDto;
import cz.zcu.kiv.backendapi.type.ITypeService;
import cz.zcu.kiv.backendapi.type.Type;
import cz.zcu.kiv.backendapi.writtenform.WrittenForm;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Predicate;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * Catalog item service implementation
 */
@Service
@Transactional
@RequiredArgsConstructor
@Slf4j
public class CatalogItemServiceImpl implements ICatalogItemService {
    /**
     * Regex for one arbitrary character in string
     */
    private static final String WILDCARD_CHARACTER_REGEX = "\\?";

    /**
     * Regex for one arbitrary character in string used in Java
     */
    private static final String WILDCARD_CHARACTER_REGEX_JAVA = ".";

    /**
     * Regex for any number of arbitrary characters in string
     */
    private static final String WILDCARD_CHARACTERS_REGEX = "\\*";

    /**
     * Regex for any number of arbitrary characters in string used in Java
     */
    private static final String WILDCARD_CHARACTERS_REGEX_JAVA = ".*";

    /**
     * Regex for finding punctuation at the start of word
     */
    private static final String START_PUNCTUATION_REGEX = "^[\\p{Punct}\\p{IsPunctuation}]+";

    /**
     * Regex for finding punctuation at the end of word
     */
    private static final String END_PUNCTUATION_REGEX = "[\\p{Punct}\\p{IsPunctuation}]+$";

    /**
     * Pattern for finding punctuation at the start of word
     */
    private static final Pattern START_PUNCTUATION_PATTERN = Pattern.compile(START_PUNCTUATION_REGEX);

    /**
     * Pattern for finding punctuation at the end of word
     */
    private static final Pattern END_PUNCTUATION_PATTERN = Pattern.compile(END_PUNCTUATION_REGEX);

    /**
     * Message for exception when catalog item is not found by id
     */
    private static final String CATALOG_ITEM_NOT_FOUND = "Catalog item not found";


    /**
     * Catalog repository
     */
    private final CatalogItemRepository catalogItemRepository;

    /**
     * Type service
     */
    private final ITypeService typeService;

    @Override
    public void saveCatalogItems(List<CatalogItemDto> catalogItemDtoList) {
        log.info("Saving catalog");
        catalogItemDtoList.forEach(this::saveCatalogItem);
        log.info("Catalog saved");
    }

    @Override
    public void saveCatalogItem(CatalogItemDto catalogItemDto) {
        log.info("Saving catalog item");
        CatalogItem catalogItem;
        Optional<CatalogItem> optionalCatalogItem;
        if (catalogItemDto.getId() != null && (optionalCatalogItem = catalogItemRepository.findById(catalogItemDto.getId())).isPresent()) {
            catalogItem = optionalCatalogItem.get();
        } else {
            catalogItem = new CatalogItem();
        }
        convertDtoToEntity(catalogItemDto, catalogItem);
        saveCatalogEntity(catalogItem);
        log.info("Catalog item saved");
    }

    @Override
    public void deleteCatalogItem(UUID id) {
        if (!catalogItemRepository.existsById(id)) {
            log.error(CATALOG_ITEM_NOT_FOUND);
            throw new ApiRequestException(CATALOG_ITEM_NOT_FOUND, HttpStatus.NOT_FOUND);
        }
        catalogItemRepository.deleteById(id);
        log.info("Catalog item deleted");
    }

    @Override
    public CatalogItemDto getCatalogItem(UUID id) {
        CatalogItem catalogItem = catalogItemRepository.findById(id).orElseThrow(() -> {
            log.error(CATALOG_ITEM_NOT_FOUND);
            throw new ApiRequestException(CATALOG_ITEM_NOT_FOUND, HttpStatus.NOT_FOUND);
        });

        return convertEntityToDto(catalogItem);
    }

    @Override
    public PathDto getPath(String text) {
        log.info("Searching path");
        PathDto pathDto = new PathDto();
        StringBuilder highlightedText = new StringBuilder();
        List<List<CatalogItemDto>> foundCatalogItems = new ArrayList<>();

        Set<String> types = typeService.getAllTypesAsString();

        List<CatalogItem> catalog = catalogItemRepository.findAll();
        Map<String, List<CatalogItem>> nameToCatalogItemMap = new HashMap<>();
        for (CatalogItem catalogItem : catalog) {
            for (CatalogItemName name : catalogItem.getAllNames()) {
                if (!nameToCatalogItemMap.containsKey(name.getName())) {
                    nameToCatalogItemMap.put(name.getName(), new ArrayList<>());
                }
                nameToCatalogItemMap.get(name.getName()).add(catalogItem);
            }
        }

        String[] tokens = text.split("((?<=\\s)|(?=\\s+))");
        for (String token : tokens) {
            if (StringUtils.isBlank(token) || token.matches(START_PUNCTUATION_REGEX)) {
                highlightedText.append(token);
                continue;
            }

            Matcher matcherStart = START_PUNCTUATION_PATTERN.matcher(token);
            Matcher matcherEnd = END_PUNCTUATION_PATTERN.matcher(token);
            String prefix = "";
            String suffix = "";
            String textToFind;
            int startTextIndex = 0;
            int endTextIndex = token.length();

            if (matcherStart.find()) {
                int start = matcherStart.start();
                startTextIndex = matcherStart.end();
                prefix = token.substring(start, startTextIndex);
            }

            if (matcherEnd.find()) {
                endTextIndex = matcherEnd.start();
                int end = matcherEnd.end();
                suffix = token.substring(endTextIndex, end);
            }

            textToFind = token.substring(startTextIndex, endTextIndex);

            if (types.contains(textToFind)) {
                textToFind = "<b>" + textToFind + "</b>";
            } else {
                if (nameToCatalogItemMap.containsKey(textToFind)) {
                    List<CatalogItem> foundItems = nameToCatalogItemMap.get(textToFind);
                    if (foundItems.stream().anyMatch(c -> c.getLatitude() != null && c.getLongitude() != null)) {
                        textToFind = "<span style='color:green'>" + textToFind + "</span>";
                    } else {
                        textToFind = "<span style='color:red'>" + textToFind + "</span>";
                    }
                    foundCatalogItems.add(foundItems.stream().map(this::convertEntityToDto).collect(Collectors.toList()));
                }
            }
            highlightedText.append(prefix).append(textToFind).append(suffix);
        }

        pathDto.setText(highlightedText.toString());
        pathDto.setFoundCatalogItems(foundCatalogItems);
        log.info("Path searched");
        return pathDto;
    }

    @Override
    public List<CatalogItemDto> getCatalog(String name, String country, String type, String writtenForm) {
        log.info("Retrieving catalog");
        String finalName = name.replaceAll(WILDCARD_CHARACTER_REGEX, WILDCARD_CHARACTER_REGEX_JAVA).replaceAll(WILDCARD_CHARACTERS_REGEX, WILDCARD_CHARACTERS_REGEX_JAVA);
        String finalCountry = country.replaceAll(WILDCARD_CHARACTER_REGEX, WILDCARD_CHARACTER_REGEX_JAVA).replaceAll(WILDCARD_CHARACTERS_REGEX, WILDCARD_CHARACTERS_REGEX_JAVA);
        String finalType = type.replaceAll(WILDCARD_CHARACTER_REGEX, WILDCARD_CHARACTER_REGEX_JAVA).replaceAll(WILDCARD_CHARACTERS_REGEX, WILDCARD_CHARACTERS_REGEX_JAVA);
        String finalWrittenForm = writtenForm.replaceAll(WILDCARD_CHARACTER_REGEX, WILDCARD_CHARACTER_REGEX_JAVA).replaceAll(WILDCARD_CHARACTERS_REGEX, WILDCARD_CHARACTERS_REGEX_JAVA);

        Pattern patternName = Pattern.compile(finalName, Pattern.CASE_INSENSITIVE);
        Pattern patternCountry = Pattern.compile(finalCountry, Pattern.CASE_INSENSITIVE);
        Pattern patternType = Pattern.compile(finalType, Pattern.CASE_INSENSITIVE);
        Pattern patternWrittenForm = Pattern.compile(finalWrittenForm, Pattern.CASE_INSENSITIVE);

        List<CatalogItem> catalogItems = catalogItemRepository.findAll();

        Predicate<CatalogItem> predicateType = i -> finalType.equals("") || i.getTypes().stream().anyMatch(t -> patternType.matcher(t.getType()).matches());
        Predicate<CatalogItem> predicateCountry = i -> finalCountry.equals("") || i.getCountries().stream().anyMatch(t -> patternCountry.matcher(t.getName()).matches());
        Predicate<CatalogItem> predicateName = i -> finalName.equals("") || patternName.matcher(i.getName()).matches() || i.getAllNames().stream().anyMatch(t -> patternName.matcher(t.getName()).matches());
        Predicate<CatalogItem> predicateWrittenForm = i -> finalWrittenForm.equals("") || i.getWrittenForms().stream().anyMatch(t -> patternWrittenForm.matcher(t.getForm()).matches());

        catalogItems = catalogItems.stream().filter(predicateName.and(predicateCountry).and(predicateType).and(predicateWrittenForm)).collect(Collectors.toList());
        return catalogItems.stream().map(this::convertEntityToDto).collect(Collectors.toList());
    }

    /**
     * Saves catalog item to database
     *
     * @param catalogItem catalog item
     */
    private void saveCatalogEntity(CatalogItem catalogItem) {
        for (Type type : catalogItem.getTypes()) {
            if (typeService.getTypeByName(type.getType()).isEmpty()) {
                typeService.saveType(type);
            }
        }
        catalogItemRepository.save(catalogItem);
    }

    /**
     * Converts catalog item DTO to catalog item entity
     *
     * @param catalogItemDto catalog item DTO
     * @param catalogItem    catalog item entity
     */
    private void convertDtoToEntity(CatalogItemDto catalogItemDto, CatalogItem catalogItem) {
        AtomicInteger counter = new AtomicInteger(1);

        catalogItem.setName(catalogItemDto.getName());
        catalogItem.setCertainty(catalogItemDto.getCertainty());
        catalogItem.setLatitude(catalogItemDto.getLatitude());
        catalogItem.setLongitude(catalogItemDto.getLongitude());

        catalogItem.getBibliography().clear();
        catalogItem.getBibliography().addAll(catalogItemDto.getBibliography()
                .stream().map(s -> new Bibliography(s, catalogItem, counter.getAndIncrement())).collect(Collectors.toCollection(LinkedHashSet::new)));

        catalogItem.getTypes().clear();
        catalogItem.getTypes().addAll(catalogItemDto.getTypes()
                .stream().map(Type::new).collect(Collectors.toCollection(LinkedHashSet::new)));

        catalogItem.getCountries().clear();
        counter.set(1);
        catalogItem.getCountries().addAll(catalogItemDto.getCountries()
                .stream().map(s -> new Country(s, catalogItem, counter.getAndIncrement())).collect(Collectors.toCollection(LinkedHashSet::new)));

        catalogItem.getAllNames().clear();
        counter.set(1);
        Set<String> allNames = new LinkedHashSet<>();
        allNames.add(catalogItemDto.getName());
        allNames.addAll(catalogItemDto.getAllNames());
        catalogItem.getAllNames().addAll(allNames
                .stream().map(s -> new CatalogItemName(s, catalogItem, counter.getAndIncrement())).collect(Collectors.toCollection(LinkedHashSet::new)));

        catalogItem.getWrittenForms().clear();
        counter.set(1);
        catalogItem.getWrittenForms().addAll(catalogItemDto.getWrittenForms()
                .stream().map(s -> new WrittenForm(s, catalogItem, counter.getAndIncrement())).collect(Collectors.toCollection(LinkedHashSet::new)));

        catalogItem.setDescription(catalogItemDto.getDescription());
    }

    /**
     * Converts catalog item entity to catalog item DTO
     *
     * @param catalogItem catalog item entity
     * @return catalog item DTO
     */
    private CatalogItemDto convertEntityToDto(CatalogItem catalogItem) {
        CatalogItemDto catalogItemDto = new CatalogItemDto();
        catalogItemDto.setId(catalogItem.getId());
        catalogItemDto.setName(catalogItem.getName());
        catalogItemDto.setLatitude(catalogItem.getLatitude());
        catalogItemDto.setLongitude(catalogItem.getLongitude());
        catalogItemDto.setCertainty(catalogItem.getCertainty());
        catalogItemDto.setBibliography(catalogItem.getBibliography()
                .stream().map(Bibliography::getSource).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setTypes(catalogItem.getTypes()
                .stream().map(Type::getType).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setCountries(catalogItem.getCountries()
                .stream().map(Country::getName).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setAllNames(catalogItem.getAllNames()
                .stream().map(CatalogItemName::getName).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setWrittenForms(catalogItem.getWrittenForms()
                .stream().map(WrittenForm::getForm).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setDescription(catalogItem.getDescription());
        return catalogItemDto;
    }

}