SEEC-BOK/seecoder-bok-server/src/main/java/cn/seecoder/seecoderbokserver/web/rest/UserInteractionController.java

package cn.seecoder.seecoderbokserver.web.rest;

import cn.seecoder.bok.common.api.SeecoderBokUserInteractiveApi;
import cn.seecoder.bok.common.dto.CollectDTO;
import cn.seecoder.bok.common.dto.RateDTO;
import cn.seecoder.bok.common.vo.InteractionVO;
import cn.seecoder.bok.common.vo.QuestionVO;
import cn.seecoder.seecoderbokserver.domain.Interaction;
import cn.seecoder.seecoderbokserver.mapper.InteractionMapper;
import cn.seecoder.seecoderbokserver.mapper.QuestionMapper;
import cn.seecoder.seecoderbokserver.service.UserInteractionService;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author Kunduin
 */
@RestController
@RequestMapping("/api/user")
public class UserInteractionController implements SeecoderBokUserInteractiveApi {

    private final UserInteractionService interactionService;
    private final QuestionMapper questionMapper;
    private final InteractionMapper interactionMapper;

    public UserInteractionController(UserInteractionService interactionService, QuestionMapper questionMapper, InteractionMapper interactionMapper) {
        this.interactionService = interactionService;
        this.questionMapper = questionMapper;
        this.interactionMapper = interactionMapper;
    }

    @Override
    @PostMapping("/{userId}/question/{questionId}/collection")
    public void collectQuestion(
            @PathVariable("userId") @Valid @NotBlank String userId,
            @PathVariable("questionId") @Valid @NotBlank String questionId,
            @RequestBody @Valid @NotNull CollectDTO collectDTO) {
        interactionService.collectQuestion(userId, questionId, collectDTO);
    }

    @Override
    @PostMapping("/{userId}/question/{questionId}/rate")
    public void rateQuestion(
            @PathVariable("userId") @Valid @NotBlank String userId,
            @PathVariable("questionId") @Valid @NotBlank String questionId,
            @RequestBody @Valid @NotNull RateDTO rateDTO) {
        interactionService.rateQuestion(userId, questionId, rateDTO);
    }

    @Override
    @GetMapping("/{userId}/question")
    public Page<QuestionVO> getUserInteractiveQuestions(
            @PathVariable("userId") @Valid @NotBlank String userId,
            @RequestParam(value = "collection", required = false) Boolean collect,
            @RequestParam(value = "rate", required = false) Boolean rate,
            Pageable pageable) {
        return interactionService.getUserInteractiveQuestions(userId, collect, rate, pageable)
                .map(questionMapper::questionToQuestionVO);
    }

    @Override
    @GetMapping("/{userId}/question/{questionId}")
    public Optional<InteractionVO> getUserInteractiveQuestion(
            @PathVariable("userId") @Valid @NotBlank String userId,
            @PathVariable("questionId") @Valid @NotBlank String questionId) {
        return interactionService.getUserInteractiveQuestion(userId, questionId)
                .map(interactionMapper::interactionToInteractionVO);
    }

    @Override
    @GetMapping("/{userId}/questionInList")
    public List<InteractionVO> getUserInteractiveQuestionIn(
            @PathVariable("userId") @Valid @NotBlank String userId,
            @RequestParam(value = "questionId", required = false) List<String> questionIdList) {
        return interactionService.getUserInteractiveQuestionIn(userId, questionIdList)
                .stream().map(interactionMapper::interactionToInteractionVO).collect(Collectors.toList());
    }

    @Override
    @GetMapping("/allInteractions")
    public List<InteractionVO> getAllInteractionQuestions() {
        return interactionService.getAll().stream().map(interactionMapper::interactionToInteractionVO).collect(Collectors.toList());
    }

    @GetMapping("/init")
    public void init() {

        List<String> collectRaw = null;
        List<String> rateRaw = null;
        try {
            collectRaw = Files.readAllLines(Paths.get("C:\\Users\\Kunduin\\Downloads\\interactive_collect.csv"));
            rateRaw = Files.readAllLines(Paths.get("C:\\Users\\Kunduin\\Downloads\\interactive_rate.csv"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        assert collectRaw != null;
        List<String> collectLines = collectRaw.subList(1, collectRaw.size());
        assert rateRaw != null;
        List<String> rateLines = rateRaw.subList(1, rateRaw.size());

        Function<String, String> removeQuotation = raw -> raw.substring(1, raw.length() - 1);
        List<Interaction> collectionInteractions = collectLines.stream().map(raw -> {
            String[] items = raw.split(",");
            Interaction interaction = new Interaction();
            interaction.setQuestionId(removeQuotation.apply(items[0]));
            interaction.setUserId(removeQuotation.apply(items[1]));
            interaction.setCollection(Boolean.parseBoolean(removeQuotation.apply(items[2])));
            return interaction;
        }).collect(Collectors.toList());

        List<Interaction> ratingWithCollectionInteractions = rateLines.stream().map(raw -> {
            String[] items = raw.split(",");
            Interaction ratingInteractions = new Interaction();
            ratingInteractions.setQuestionId(removeQuotation.apply(items[0]));
            ratingInteractions.setUserId(removeQuotation.apply(items[1]));
            ratingInteractions.setRate(Integer.parseInt(removeQuotation.apply(items[2])));

            collectionInteractions.stream()
                    .filter(interaction -> interaction.getQuestionId().equals(ratingInteractions.getQuestionId())
                            && interaction.getUserId().equals(ratingInteractions.getUserId()))
                    .findFirst().ifPresent(interaction -> ratingInteractions.setCollection(interaction.getCollection()));
            return ratingInteractions;
        }).collect(Collectors.toList());

        List<Interaction> collectResult = collectionInteractions.stream().filter(interaction -> {
            long size = ratingWithCollectionInteractions.parallelStream()
                    .filter(rateInteraction -> interaction.getUserId().equals(rateInteraction.getUserId())
                            && interaction.getQuestionId().equals(rateInteraction.getQuestionId()))
                    .count();
            return size == 0;
        }).collect(Collectors.toList());
        ratingWithCollectionInteractions.addAll(collectResult);
        interactionService.saveAll(ratingWithCollectionInteractions);
    }
}