bflows-bandi-be/src/main/java/net/gepafin/tendermanagement/dao/FlowDao.java

package net.gepafin.tendermanagement.dao;

import net.gepafin.tendermanagement.config.Translator;
import net.gepafin.tendermanagement.constants.GepafinConstant;
import net.gepafin.tendermanagement.entities.CallEntity;
import net.gepafin.tendermanagement.entities.FlowDataEntity;
import net.gepafin.tendermanagement.entities.FlowEdgesEntity;
import net.gepafin.tendermanagement.enums.CallStatusEnum;
import net.gepafin.tendermanagement.model.request.FlowDataRequestBean;
import net.gepafin.tendermanagement.model.request.FlowEdgesRequestBean;
import net.gepafin.tendermanagement.model.request.FlowRequestBean;
import net.gepafin.tendermanagement.model.response.FlowDataResponseBean;
import net.gepafin.tendermanagement.model.response.FlowEdgesResponseBean;
import net.gepafin.tendermanagement.model.response.FlowResponseBean;
import net.gepafin.tendermanagement.repositories.CallRepository;
import net.gepafin.tendermanagement.repositories.FlowDataRepository;
import net.gepafin.tendermanagement.repositories.FlowEdgesRepository;
import net.gepafin.tendermanagement.service.CallService;
import net.gepafin.tendermanagement.service.FormService;
import net.gepafin.tendermanagement.util.DateTimeUtil;
import net.gepafin.tendermanagement.util.FieldValidator;
import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
import net.gepafin.tendermanagement.web.rest.api.errors.Status;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;

@Component
public class FlowDao {

    @Autowired
    private FlowDataRepository flowDataRepository;

    @Autowired
    private FlowEdgesRepository flowEdgesRepository;

    @Autowired
    private CallRepository callRepository;

    @Autowired
    private CallService callService;

    @Autowired
    private FormService formService;

    @Autowired
    private CallDao callDao;

    public FlowResponseBean createOrUpdateFlow(FlowRequestBean flowRequestBean, Long callId) {
        validateFlowRequestBean(flowRequestBean);
        CallEntity call = callService.validateCall(callId);
        checkIfFlowExits(call);
        call= setInitialAndFinalFormInCall(flowRequestBean, call);
        validateFlowRequest(flowRequestBean);
        List<FlowDataEntity> flowDataEntities = createFlowData(flowRequestBean,call);
        List<FlowEdgesEntity> flowEdgesEntities = createFlowEdges(flowRequestBean,call);
        FlowResponseBean flowResponseBean = getFlowByCallId(call.getId());
        return flowResponseBean;
    }

    public void validateFlowRequestBean(FlowRequestBean flowRequestBean){
        if (FieldValidator.isNullOrZero(flowRequestBean.getInitialForm()) || FieldValidator.isNullOrZero(flowRequestBean.getFinalForm())) {
            throw new CustomValidationException(Status.BAD_REQUEST,Translator.toLocale(GepafinConstant.INITAL_AND_FINAL_FORM_CANNOT_NULL));
        }

        if (flowRequestBean.getFlowEdges() == null || flowRequestBean.getFlowEdges().isEmpty()) {
            throw new CustomValidationException(Status.BAD_REQUEST, Translator.toLocale(GepafinConstant.FLOW_REQUEST_NOT_PROPER));
        }
    }

    public void checkIfFlowExits(CallEntity call) {
        callDao.validateUpdate(call);
        List<FlowDataEntity> flowDataEntities = flowDataRepository.findByCallId(call.getId());
        List<FlowEdgesEntity> flowEdgesEntities = flowEdgesRepository.findByCallId(call.getId());
        if (Boolean.FALSE.equals(flowDataEntities.isEmpty())  || Boolean.FALSE.equals(flowEdgesEntities.isEmpty())) {
            call.setInitialForm(null);
            call.setFinalForm(null);
            call=callRepository.save(call);
            flowDataRepository.deleteAll(flowDataEntities);
            flowEdgesRepository.deleteAll(flowEdgesEntities);
        }
    }

    public void validateFlowRequest(FlowRequestBean flowRequestBean) {
        formService.validateForm(flowRequestBean.getInitialForm());
        formService.validateForm(flowRequestBean.getFinalForm());
        if(flowRequestBean.getFlowData()!=null && !flowRequestBean.getFlowData().isEmpty()) {
            flowRequestBean.getFlowData().forEach(flowData -> formService.validateForm(flowData.getFormId()));
        }
    }

    private List<FlowEdgesResponseBean> createFlowEdgesResponseBean(List<FlowEdgesEntity> flowEdgesEntities) {
        List<FlowEdgesResponseBean> flowEdgesResponseBeans = flowEdgesEntities.stream()
                .map(this::convertFlowEdgesEntityToFlowEdgesResponseBean).collect(Collectors.toList());
        return flowEdgesResponseBeans;
    }

    private List<FlowDataResponseBean> createFlowDataResponseBean(List<FlowDataEntity> flowDataEntities) {
        List<FlowDataResponseBean> flowDataResponseBeans = flowDataEntities.stream()
                .map(this::convertFlowDataEntityToFlowDataResponseBean).collect(Collectors.toList());
        return flowDataResponseBeans;
    }

    public FlowResponseBean setInitialAndFinalFormInFlowResponseBean(FlowResponseBean flowResponseBean, CallEntity call) {
        flowResponseBean.setInitialForm(call.getInitialForm());
        flowResponseBean.setFinalForm(call.getFinalForm());
        return flowResponseBean;
    }

    private CallEntity setInitialAndFinalFormInCall(FlowRequestBean flowRequestBean, CallEntity call) {
        call.setInitialForm(flowRequestBean.getInitialForm());
        call.setFinalForm(flowRequestBean.getFinalForm());
        call.setUpdatedDate(DateTimeUtil.DateServerToUTC(LocalDateTime.now()));
        call = callRepository.save(call);
        return call;
    }

    public List<FlowDataEntity> createFlowData(FlowRequestBean flowRequestBean, CallEntity call) {
        if (flowRequestBean.getFlowData() != null || !flowRequestBean.getFlowEdges().isEmpty()) {
            List<FlowDataEntity> flowDataEntities = flowRequestBean.getFlowData().stream()
                    .map(flowDataRequestBean -> createFlowDataEntity(flowDataRequestBean, call))
                    .collect(Collectors.toList());
            return flowDataRepository.saveAll(flowDataEntities);
        }
        return null;
    }

    public FlowDataEntity createFlowDataEntity(FlowDataRequestBean flowDataRequestBean,CallEntity call) {
        FlowDataEntity flowDataEntity = new FlowDataEntity();
        flowDataEntity.setFormId(flowDataRequestBean.getFormId());
        if(Boolean.FALSE.equals(flowDataRequestBean.getChosenField().isEmpty()) || flowDataRequestBean.getChosenField()!=null){
        flowDataEntity.setChoosenField(flowDataRequestBean.getChosenField());
        }
        if(Boolean.FALSE.equals(flowDataRequestBean.getChosenValue().isEmpty()) || flowDataRequestBean.getChosenValue()!=null) {
            flowDataEntity.setChoosenValue(flowDataRequestBean.getChosenValue());
        }
            flowDataEntity.setCallId(call.getId());
        return flowDataEntity;
    }

    public List<FlowEdgesEntity> createFlowEdges(FlowRequestBean flowRequestBean, CallEntity call) {
        List<FlowEdgesEntity> flowEdgesEntities = flowRequestBean.getFlowEdges().stream()
                .map(flowEdgesRequestBean -> createFlowEdgesEntity(flowEdgesRequestBean, call))
                .collect(Collectors.toList());
        return flowEdgesRepository.saveAll(flowEdgesEntities);
    }

    public FlowEdgesEntity createFlowEdgesEntity(FlowEdgesRequestBean flowEdgesRequestBean,CallEntity call) {
        FlowEdgesEntity flowEdgesEntity = new FlowEdgesEntity();
        flowEdgesEntity.setTrackingId(flowEdgesRequestBean.getId());
        flowEdgesEntity.setSourceId(Long.valueOf(flowEdgesRequestBean.getSource()));
        flowEdgesEntity.setTargetId(Long.valueOf(flowEdgesRequestBean.getTarget()));
        flowEdgesEntity.setType(flowEdgesRequestBean.getType());
        flowEdgesEntity.setCallId(call.getId());
        return flowEdgesEntity;
    }

    public FlowDataResponseBean convertFlowDataEntityToFlowDataResponseBean(FlowDataEntity flowDataEntity) {
        FlowDataResponseBean flowDataResponseBean = new FlowDataResponseBean();
        flowDataResponseBean.setId(flowDataEntity.getId());
        flowDataResponseBean.setFormId(flowDataEntity.getFormId());
        flowDataResponseBean.setChosenField(flowDataEntity.getChoosenField());
        flowDataResponseBean.setChosenValue(flowDataEntity.getChoosenValue());
        return flowDataResponseBean;
    }

    public FlowEdgesResponseBean convertFlowEdgesEntityToFlowEdgesResponseBean(FlowEdgesEntity flowEdgesEntity) {
        FlowEdgesResponseBean flowEdgesResponseBean = new FlowEdgesResponseBean();
        flowEdgesResponseBean.setId(flowEdgesEntity.getTrackingId());
        flowEdgesResponseBean.setType(flowEdgesEntity.getType());
        flowEdgesResponseBean.setSource(String.valueOf(flowEdgesEntity.getSourceId()));
        flowEdgesResponseBean.setTarget(String.valueOf(flowEdgesEntity.getTargetId()));
        return flowEdgesResponseBean;
    }

    public FlowResponseBean getFlowByCallId(Long callId){
        CallEntity call= callService.validateCall(callId);
        FlowResponseBean flowResponseBean=new FlowResponseBean();
        List<FlowDataEntity> flowDataEntities=flowDataRepository.findByCallId(call.getId());
        List<FlowEdgesEntity> flowEdgesEntities=flowEdgesRepository.findByCallId(call.getId());
        List<FlowDataResponseBean> flowDataResponseBeans=createFlowDataResponseBean(flowDataEntities);
        List<FlowEdgesResponseBean> flowEdgesResponseBeans=createFlowEdgesResponseBean(flowEdgesEntities);
        flowResponseBean.setFlowData(flowDataResponseBeans);
        flowResponseBean.setFlowEdges(flowEdgesResponseBeans);
        if( flowResponseBean.getFlowEdges().isEmpty()){
            return null;
        }
        flowResponseBean.setCallId(call.getId());
        flowResponseBean.setCallStatus(CallStatusEnum.valueOf(call.getStatus()));
        flowResponseBean.setInitialForm(call.getInitialForm());
        flowResponseBean.setFinalForm(call.getFinalForm());
        return flowResponseBean;
    }

}