package com.qianwen.smartman.modules.dnc.service.impl;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.mp.base.BaseServiceImpl;
import com.qianwen.core.secure.utils.AuthUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.common.utils.Lambda;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.smartman.modules.cps.dto.WorkstationDTO;
import com.qianwen.smartman.modules.cps.entity.Workstation;
import com.qianwen.smartman.modules.cps.entity.WorkstationOfMachine;
import com.qianwen.smartman.modules.cps.service.IWorkstationOfMachineService;
import com.qianwen.smartman.modules.cps.service.IWorkstationService;
import com.qianwen.smartman.modules.cps.vo.WorkstationVO;
import com.qianwen.smartman.modules.dnc.dto.TransferDirectoryDto;
import com.qianwen.smartman.modules.dnc.dto.TransferDirectoryGroupDto;
import com.qianwen.smartman.modules.dnc.dto.WorkstationDirectoryDto;
import com.qianwen.smartman.modules.dnc.entity.DncFixedSpace;
import com.qianwen.smartman.modules.dnc.entity.DncWsRelationTd;
import com.qianwen.smartman.modules.dnc.entity.TransferDirectory;
import com.qianwen.smartman.modules.dnc.entity.TransferDirectoryFile;
import com.qianwen.smartman.modules.dnc.entity.TransferDirectoryGroup;
import com.qianwen.smartman.modules.dnc.enums.DncEnums;
import com.qianwen.smartman.modules.dnc.mapper.TransferDirectoryMapper;
import com.qianwen.smartman.modules.dnc.service.IDncFixedSpaceService;
import com.qianwen.smartman.modules.dnc.service.IDncWsRelationTdService;
import com.qianwen.smartman.modules.dnc.service.ITransferDirectoryFileService;
import com.qianwen.smartman.modules.dnc.service.ITransferDirectoryGroupService;
import com.qianwen.smartman.modules.dnc.service.ITransferDirectoryService;
import com.qianwen.smartman.modules.dnc.vo.FtpDirectoryRelationWorkstationVO;
import com.qianwen.smartman.modules.dnc.vo.FtpDirectorySearchVO;
import com.qianwen.smartman.modules.dnc.vo.FtpTransferDirectoryVO;
import com.qianwen.smartman.modules.dnc.vo.TransferDirectorAddVO;
import com.qianwen.smartman.modules.dnc.vo.UpdateDirectoryVO;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/dnc/service/impl/TransferDirectoryServiceImpl.class */
public class TransferDirectoryServiceImpl extends BaseServiceImpl<TransferDirectoryMapper, TransferDirectory> implements ITransferDirectoryService {
    @Autowired
    private TransferDirectoryMapper transferDirectoryMapper;
    @Autowired
    @Lazy
    private ITransferDirectoryGroupService groupService;
    @Autowired
    @Lazy
    private IWorkstationService workstationService;
    @Autowired
    @Lazy
    private ITransferDirectoryFileService transferDirectoryFileService;
    @Autowired
    @Lazy
    private IDncWsRelationTdService wsRelationTdService;
    @Autowired
    @Lazy
    private IDncFixedSpaceService dncFixedSpaceService;
    @Autowired
    @Lazy
    private IWorkstationOfMachineService workstationOfMachineService;


    @Override // org.springblade.modules.dnc.service.ITransferDirectoryService
    @Transactional(rollbackFor = {Exception.class})
    public Long saveWorkstationDirectory(WorkstationDirectoryDto workstationDirectoryDto) {
        TransferDirectory transferDirectory = new TransferDirectory();
        TransferDirectoryGroup group = getDirectoryGroup(workstationDirectoryDto.getWorkstationId(), workstationDirectoryDto.getWorkstationParentId());
        transferDirectory.setGroupAllPath(group.getAllPath());
        transferDirectory.setGroupId(group.getId());
        TransferDirectory directory = getOne(Wrappers.<TransferDirectory>lambdaQuery()
                .eq(TransferDirectory::getWorkstationId, workstationDirectoryDto.getWorkstationId()));
        /*
        TransferDirectory directory = (TransferDirectory) getOne((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getWorkstationId();
        }, workstationDirectoryDto.getWorkstationId()));*/
        transferDirectory.setDeptId(workstationDirectoryDto.getDeptId());
        transferDirectory.setTenantId("000000");
        transferDirectory.setName(workstationDirectoryDto.getWorkstationName());
        transferDirectory.setWorkstationId(workstationDirectoryDto.getWorkstationId());
        TransferDirectoryDto transferDirectoryDto = new TransferDirectoryDto();
        transferDirectoryDto.setWorkstationId(workstationDirectoryDto.getWorkstationId()).setName(workstationDirectoryDto.getWorkstationName()).setGroupAllPath(group.getAllPath()).setAllPathName(group.getName()).setGroupId(group.getId()).setDeptId(workstationDirectoryDto.getDeptId());
        if (directory == null) {
            save(transferDirectory);
        } else {
            updateById(transferDirectory);
        }
        return transferDirectory.getId();
    }

    @Override // org.springblade.modules.dnc.service.ITransferDirectoryService
    public Boolean updateWorkstationDirectory(WorkstationDirectoryDto workstationDirectoryDto) {
        boolean result = false;
        TransferDirectoryGroup transferDirectoryGroup = this.groupService.getOne(Wrappers.<TransferDirectoryGroup>lambdaQuery().eq(TransferDirectoryGroup::getWorkstationGroupId, workstationDirectoryDto.getWorkstationParentId()));
        /*
        TransferDirectoryGroup transferDirectoryGroup = (TransferDirectoryGroup) this.groupService.getOne((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getWorkstationGroupId();
        }, workstationDirectoryDto.getWorkstationParentId()));*/
        if (transferDirectoryGroup != null) {
        	TransferDirectory transferDirectory = getOne(Wrappers.<TransferDirectory>lambdaQuery().eq(TransferDirectory::getWorkstationId, workstationDirectoryDto.getWorkstationId()));
        	/*
            TransferDirectory transferDirectory = (TransferDirectory) getOne((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
                return v0.getWorkstationId();
            }, workstationDirectoryDto.getWorkstationId()));*/
            if (Func.isNotEmpty(transferDirectory)) {
                transferDirectory.setGroupId(transferDirectoryGroup.getId());
                transferDirectory.setGroupAllPath(transferDirectoryGroup.getAllPath());
                result = updateById(transferDirectory);
            }
        }
        return Boolean.valueOf(result);
    }

    @Override // org.springblade.modules.dnc.service.ITransferDirectoryService
    public Boolean deleteWorkstationDirectory(Long workstationDirectoryId) {
        boolean result = false;
        TransferDirectory transferDirectory = getOne(Wrappers.<TransferDirectory>lambdaQuery().eq(TransferDirectory::getWorkstationId, workstationDirectoryId));
        /*
        TransferDirectory transferDirectory = (TransferDirectory) getOne((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getWorkstationId();
        }, workstationDirectoryId));*/
        if (transferDirectory != null) {
        	List<TransferDirectoryFile> list = this.transferDirectoryFileService.list(Wrappers.<TransferDirectoryFile>lambdaQuery().eq(TransferDirectoryFile::getTransferDirectoryId, transferDirectory.getId()));
        	/*
            List<TransferDirectoryFile> list = this.transferDirectoryFileService.list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
                return v0.getTransferDirectoryId();
            }, transferDirectory.getId()));*/
            if (Func.isNotEmpty(list)) {
                list.forEach(transferDirectoryFile -> {
                    this.transferDirectoryFileService.saveOperationLog(transferDirectoryFile, DncEnums.LogOperationType.DELETE.getCode());
                });
                this.transferDirectoryFileService.removeByIds(list.stream().map((v0) -> {
                    return v0.getId();
                }).collect(Collectors.toList()));
            }
            result = removeById(transferDirectory.getId());
        }
        return Boolean.valueOf(result);
    }

    @Override // org.springblade.modules.dnc.service.ITransferDirectoryService
    public TransferDirectory findByWorkStationId(Long workstationId) {
    	return getOne(Wrappers.<TransferDirectory>lambdaQuery().eq(TransferDirectory::getWorkstationId, workstationId));
    	/*
        return (TransferDirectory) getOne((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getWorkstationId();
        }, workstationId));*/
    }

    @Override // org.springblade.modules.dnc.service.ITransferDirectoryService
    public TransferDirectory findByNameAndWorkStationId(Long workstationId, String directoryName) {
    	return getOne(Wrappers.<TransferDirectory>lambdaQuery()
    	        .eq(TransferDirectory::getName, directoryName)
    	        .eq(TransferDirectory::getWorkstationId, workstationId));
    	/*
        return (TransferDirectory) getOne((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getName();
        }, directoryName)).eq((v0) -> {
            return v0.getWorkstationId();
        }, workstationId));*/
    }

    @Override // org.springblade.modules.dnc.service.ITransferDirectoryService
    public List<FtpTransferDirectoryVO> getFtpList() {
        List<TransferDirectory> list = list();
        if (Func.isNotEmpty(list)) {
            return list.stream().map(s -> {
                FtpTransferDirectoryVO ftp = new FtpTransferDirectoryVO();
                ftp.setId(s.getId());
                ftp.setName(s.getName());
                return ftp;
            }).collect(Collectors.toList());
        }
        return new ArrayList<>();
    }

    @Override // org.springblade.modules.dnc.service.ITransferDirectoryService
    public List<FtpDirectoryRelationWorkstationVO> getFtpListRelationWorkstation(FtpDirectorySearchVO ftpDirectorySearchVO) {
        String name = ftpDirectorySearchVO.getName();
        List<String> workstationIds = ftpDirectorySearchVO.getWorkstationIds();
        Map<Long, Workstation> workstationMap = this.workstationService.list().stream().collect(Collectors.toMap(Workstation::getId, Function.identity()));
        
        Map<Long, List<DncWsRelationTd>> wsListMap = null;
        List<Long> tranIds = null;
        List<DncWsRelationTd> list = this.wsRelationTdService.list(Wrappers.<DncWsRelationTd>lambdaQuery().in(Func.isNotEmpty(workstationIds), DncWsRelationTd::getWorkstationId, workstationIds));
        if (Func.isNotEmpty(list)) {
            wsListMap = list.stream().collect(Collectors.groupingBy((v0) -> {
                return v0.getTransferDirectorId();
            }));
            if (Func.isNotEmpty(workstationIds)) {
                tranIds =  list.stream().map((v0) -> {
                    return v0.getTransferDirectorId();
                }).distinct().collect(Collectors.toList());
            }
        }
        if (Func.isNotEmpty(workstationIds) && Func.isEmpty(list)) {
            return new ArrayList<>();
        }
        
        List<TransferDirectory> directoryList = list(Wrappers.<TransferDirectory>lambdaQuery()
                .in(Func.isNotEmpty(tranIds), TransferDirectory::getId, tranIds)
                .likeRight(Func.isNotBlank(name), TransferDirectory::getName, name).orderByDesc(TransferDirectory::getCreateTime));
        /*
        List<TransferDirectory> directoryList = list((Wrapper) Wrappers.lambdaQuery().in(Func.isNotEmpty(tranIds), (v0) -> {
            return v0.getId();
        }, tranIds).likeRight(Func.isNotBlank(name), (v0) -> {
            return v0.getName();
        }, name).orderByDesc((v0) -> {
            return v0.getCreateTime();
        }));*/
        if (Func.isNotEmpty(directoryList)) {
            Map<Long, List<DncWsRelationTd>> finalWsListMap = wsListMap;
            return directoryList.stream().map(s -> {
                Long directoryId = s.getId();
                FtpDirectoryRelationWorkstationVO ftpDir = new FtpDirectoryRelationWorkstationVO();
                ftpDir.setId(directoryId);
                ftpDir.setName(s.getName());
                if (finalWsListMap != null) {
                    List<WorkstationDTO> workstations = new LinkedList<>();
                    List<DncWsRelationTd> dncWsRelationTdList = finalWsListMap.get(directoryId);
                    if (Func.isNotEmpty(dncWsRelationTdList)) {
                        dncWsRelationTdList.forEach(a -> {
                            Long workstationId = a.getWorkstationId();
                            Workstation workstation = (Workstation) workstationMap.get(workstationId);
                            if (workstation != null) {
                                WorkstationDTO workstationDTO = new WorkstationDTO();
                                workstationDTO.setId(workstation.getId());
                                workstationDTO.setCode(workstation.getCode());
                                workstationDTO.setName(workstation.getName());
                                workstations.add(workstationDTO);
                            }
                        });
                        if (Func.isNotEmpty(workstations)) {
                            ftpDir.setWorkstationDTOS(workstations);
                        }
                    }
                }
                return ftpDir;
            }).collect(Collectors.toList());
        }
        return new ArrayList();
    }

    @Override // org.springblade.modules.dnc.service.ITransferDirectoryService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean saveTransferDirectory(TransferDirectorAddVO transferDirectorAddVO) {
        String name = transferDirectorAddVO.getName();
        /*
        TransferDirectory existSameDirectory = (TransferDirectory) getOne((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getName();
        }, name));*/
        TransferDirectory existSameDirectory = getOne(Wrappers.<TransferDirectory>lambdaQuery().eq(TransferDirectory::getName, name));
        
        if (existSameDirectory != null) {
            throw new ServiceException(MessageUtils.message("dnc.workstation.directory.create.same.name.exists", new Object[0]));
        }
        List<DncWsRelationTd> list = new LinkedList<>();
        TransferDirectory transferDirectory = new TransferDirectory();
        transferDirectory.setName(name);
        boolean save = save(transferDirectory);
        this.dncFixedSpaceService.initializeRootNode("0", transferDirectorAddVO.getName(), String.valueOf(transferDirectory.getId()));
        List<String> workstationIds = transferDirectorAddVO.getWorkstationIds();
        if (Func.isNotEmpty(workstationIds)) {
            workstationIds.forEach(id -> {
                DncWsRelationTd dncWsRelationTd = new DncWsRelationTd();
                dncWsRelationTd.setTransferDirectorId(transferDirectory.getId());
                dncWsRelationTd.setWorkstationId(Long.valueOf(Long.parseLong(id)));
                list.add(dncWsRelationTd);
            });
            this.wsRelationTdService.saveBatch(list);
        }
        return Boolean.valueOf(save);
    }

    @Override // org.springblade.modules.dnc.service.ITransferDirectoryService
    public Boolean deleteDirectory(String directoryId) {
        long id = Func.toLong(directoryId);
        List<DncFixedSpace> list = this.dncFixedSpaceService.list(Wrappers.<DncFixedSpace>lambdaQuery().eq(DncFixedSpace::getTdId, Long.valueOf(id)));
        /*
        List<DncFixedSpace> list = this.dncFixedSpaceService.list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getTdId();
        }, Long.valueOf(id)));*/
        if (Func.isNotEmpty(list)) {
            List<Long> ids = list.stream().map((v0) -> {
                return v0.getId();
            }).collect(Collectors.toList());
            this.dncFixedSpaceService.removeByIds(ids);
        }
        List<DncWsRelationTd> dncWsRelationTdList = this.wsRelationTdService.list(Wrappers.<DncWsRelationTd>lambdaQuery().eq(DncWsRelationTd::getTransferDirectorId, Long.valueOf(id)));
        /*
        List<DncWsRelationTd> dncWsRelationTdList = this.wsRelationTdService.list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getTransferDirectorId();
        }, Long.valueOf(id)));*/
        if (Func.isNotEmpty(dncWsRelationTdList)) {
            List<Long> ids2 = dncWsRelationTdList.stream().map((v0) -> {
                return v0.getId();
            }).collect(Collectors.toList());
            this.wsRelationTdService.removeByIds(ids2);
        }
        return Boolean.valueOf(removeById(Long.valueOf(id)));
    }

    @Override // org.springblade.modules.dnc.service.ITransferDirectoryService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean updateDirectory(UpdateDirectoryVO updateDirectoryVO) {
        //DncFixedSpace one;
        String directorId = updateDirectoryVO.getDirectorId();
        String directorName = updateDirectoryVO.getDirectorName();
        List<String> oldWorkstationIds = updateDirectoryVO.getOldWorkstationIds();
        List<String> newWorkstationIds = updateDirectoryVO.getNewWorkstationIds();
        boolean result = false;
        TransferDirectory transferDirectory = getOne(Wrappers.<TransferDirectory>lambdaQuery().eq(TransferDirectory::getId, directorId));
        /*
        TransferDirectory transferDirectory = (TransferDirectory) getOne((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getId();
        }, directorId));*/
        if (transferDirectory != null) {
            if (!directorName.equals(transferDirectory.getName())) {
                transferDirectory.setName(directorName);
                updateById(transferDirectory);
            }
            if (Func.isNotEmpty(oldWorkstationIds)) {
                List<String> delWorkstationIds = oldWorkstationIds.stream().filter(item -> {
                    return !newWorkstationIds.contains(item);
                }).collect(Collectors.toList());
                if (Func.isNotEmpty(delWorkstationIds)) {
                	List<DncWsRelationTd> list = this.wsRelationTdService.list(Wrappers.<DncWsRelationTd>lambdaQuery()
                            .eq(DncWsRelationTd::getTransferDirectorId, transferDirectory.getId()).in(DncWsRelationTd::getWorkstationId, delWorkstationIds));
                	/*
                    List<DncWsRelationTd> list = this.wsRelationTdService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
                        return v0.getTransferDirectorId();
                    }, transferDirectory.getId())).in((v0) -> {
                        return v0.getWorkstationId();
                    }, delWorkstationIds));*/
                    if (Func.isNotEmpty(list)) {
                        result = this.wsRelationTdService.removeBatchByIds(list);
                    }
                }
            }
            if (Func.isNotEmpty(newWorkstationIds)) {
                List<DncWsRelationTd> wsRelationTds = new LinkedList<>();
                List<String> addWorkstationIds = newWorkstationIds.stream().filter(item2 -> {
                    return !oldWorkstationIds.contains(item2);
                }).collect(Collectors.toList());
                if (Func.isNotEmpty(addWorkstationIds)) {
                    List<DncWsRelationTd> list2 = this.wsRelationTdService.list();
                    if (Func.isNotEmpty(list2)) {
                        long count = list2.stream().filter(s -> {
                            return addWorkstationIds.contains(String.valueOf(s.getWorkstationId()));
                        }).count();
                        if (count > 0) {
                            throw new ServiceException(MessageUtils.message("dnc.file.station.has.been.bound.by.other.ftp", new Object[0]));
                        }
                    }
                    addWorkstationIds.forEach(item3 -> {
                        DncWsRelationTd dncWsRelationTd = new DncWsRelationTd();
                        dncWsRelationTd.setTenantId("000000");
                        dncWsRelationTd.setWorkstationId(Long.valueOf(Long.parseLong(item3)));
                        dncWsRelationTd.setTransferDirectorId(transferDirectory.getId());
                        wsRelationTds.add(dncWsRelationTd);
                    });
                    if (Func.isNotEmpty(wsRelationTds)) {
                        result = this.wsRelationTdService.saveBatch(wsRelationTds);
                    }
                } else {
                    result = Boolean.TRUE.booleanValue();
                }
            }
            if (Func.isNotBlank(directorName)) {
                DncFixedSpace one = this.dncFixedSpaceService.getOne(Wrappers.<DncFixedSpace>lambdaQuery().eq(DncFixedSpace::getTdId, directorId).eq(DncFixedSpace::getSpaceLocation, 1));
                if (one != null && !directorName.equals(one.getName())) {
                  one.setName(directorName);
                  result = this.dncFixedSpaceService.updateById(one);
                } 
             } 
            /*
            if (Func.isNotBlank(directorName) && (one = (DncFixedSpace) this.dncFixedSpaceService.getOne((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
                return v0.getTdId();
            }, directorId)).eq((v0) -> {
                return v0.getSpaceLocation();
            }, 1))) != null && !directorName.equals(one.getName())) {
                one.setName(directorName);
                result = this.dncFixedSpaceService.updateById(one);
            }*/
        }
        return Boolean.valueOf(result);
    }

    @Override // org.springblade.modules.dnc.service.ITransferDirectoryService
    public TransferDirectoryGroup getDirectoryGroup(Long workstationId, Long workstationGroupId) {
        WorkstationVO workstationVO = this.workstationService.getDetail(workstationId);
        TransferDirectoryGroup group = this.groupService.getOne(Wrappers.<TransferDirectoryGroup>lambdaQuery().eq(TransferDirectoryGroup::getWorkstationGroupId, workstationGroupId));
        /*
        TransferDirectoryGroup group = (TransferDirectoryGroup) this.groupService.getOne((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getWorkstationGroupId();
        }, workstationGroupId));*/
        if (group == null) {
            List<TransferDirectoryGroup> groupList = this.groupService.list();
            List<Long> workstationGroupIds = groupList.stream().map((v0) -> {
                return v0.getWorkstationGroupId();
            }).collect(Collectors.toList());
            if (!workstationGroupIds.contains(workstationVO.getGroupId())) {
                TransferDirectoryGroupDto directoryGroupDto = new TransferDirectoryGroupDto();
                directoryGroupDto.setWorkStationGroupId(workstationVO.getGroupId());
                directoryGroupDto.setWorkStationGroupName(workstationVO.getGroupName());
                group = this.groupService.saveWorkstationGroup(directoryGroupDto);
            }
        }
        return group;
    }

    private void checkWorkstation(TransferDirectoryDto transferDirectoryDto) {
    	QueryWrapper<TransferDirectory> queryWrapper = new QueryWrapper<>();
    	queryWrapper.lambda().eq(TransferDirectory::getWorkstationId, transferDirectoryDto.getWorkstationId());
    	
        Optional.ofNullable(this.transferDirectoryMapper.selectOne(queryWrapper)).ifPresent(po -> {
            if (!po.getWorkstationId().equals(transferDirectoryDto.getWorkstationId())) {
                throw new ServiceException(MessageUtils.message("workstation.directory.name.already.exists", new Object[0]));
            }
        });
        List<TransferDirectoryGroup> transferDirectoryGroups = this.groupService.list(Wrappers.<TransferDirectoryGroup>lambdaQuery()
                .eq(Func.isNotEmpty(transferDirectoryDto.getGroupId()), TransferDirectoryGroup::getParentId, transferDirectoryDto.getGroupId())
                .eq(TransferDirectoryGroup::getTenantId, AuthUtil.getTenantId()));
        /*
        List<TransferDirectoryGroup> transferDirectoryGroups = this.groupService.list((Wrapper) Wrappers.lambdaQuery().eq(Func.isNotEmpty(transferDirectoryDto.getGroupId()), (v0) -> {
            return v0.getParentId();
        }, transferDirectoryDto.getGroupId()).eq((v0) -> {
            return v0.getTenantId();
        }, AuthUtil.getTenantId()));*/
        if (Func.isNotEmpty(transferDirectoryGroups)) {
            throw new ServiceException(MessageUtils.message("workstation.directory.name.already.exists", new Object[0]));
        }
    }

    @Override // org.springblade.modules.dnc.service.ITransferDirectoryService
    public List<FtpTransferDirectoryVO> getMachineOfWorkstationForFtp(Long id) {
        List<WorkstationOfMachine> list = this.workstationOfMachineService.list(Lambda.eq((v0) -> {
            return v0.getMachineId();
        }, id));
        if (Func.isEmpty(list)) {
            return getFtpList();
        }
        List<Long> workStationIdList = list.stream().map((v0) -> {
            return v0.getWorkstationId();
        }).collect(Collectors.toList());
        List<Long> transferDirectorList = this.wsRelationTdService.list(Lambda.in((v0) -> {
            return v0.getWorkstationId();
        }, workStationIdList)).stream().map((v0) -> {
            return v0.getTransferDirectorId();
        }).collect(Collectors.toList());
        if (Func.isEmpty(transferDirectorList)) {
            return getFtpList();
        }
        long count = transferDirectorList.stream().distinct().count();
        if (count > 1) {
            throw new ServiceException(MessageUtils.message("dnc.ftp.have.multiple.workstation.in.machine", new Object[0]));
        }
        TransferDirectory transferDirectory = (TransferDirectory) getById(transferDirectorList.get(0));
        FtpTransferDirectoryVO transferDirectoryVO = new FtpTransferDirectoryVO();
        transferDirectoryVO.setId(transferDirectory.getId());
        transferDirectoryVO.setName(transferDirectory.getName());
        List<FtpTransferDirectoryVO> ftpTransferDirectoryVOList = new ArrayList<>();
        ftpTransferDirectoryVOList.add(transferDirectoryVO);
        return ftpTransferDirectoryVOList;
    }

    @Override // org.springblade.modules.dnc.service.ITransferDirectoryService
    public Boolean judgeAndSaveWorkStationFtp(String machineId, Long workStationId, String directoryId) {
        List<WorkstationOfMachine> workstationOfMachineList = this.workstationOfMachineService.list(Lambda.eq((v0) -> {
            return v0.getMachineId();
        }, machineId));
        List<Long> workstationIdList = workstationOfMachineList.stream().map((v0) -> {
            return v0.getWorkstationId();
        }).collect(Collectors.toList());
        if (Func.isEmpty(workstationOfMachineList)) {
            return true;
        }
        List<Long> workstationIdFilterList =  workstationOfMachineList.stream().map((v0) -> {
            return v0.getWorkstationId();
        }).filter(item -> {
            return !Objects.equals(item, workStationId);
        }).collect(Collectors.toList());
        List<Long> ftpWorkStationIdList =  this.wsRelationTdService.list(Lambda.in((v0) -> {
            return v0.getWorkstationId();
        }, workstationIdList)).stream().map((v0) -> {
            return v0.getWorkstationId();
        }).collect(Collectors.toList());
        if (Func.isEmpty(ftpWorkStationIdList)) {
            TransferDirectory transferDirectory = (TransferDirectory) getById(directoryId);
            UpdateDirectoryVO updateDirectoryVO = new UpdateDirectoryVO();
            updateDirectoryVO.setDirectorId(directoryId);
            updateDirectoryVO.setDirectorName(transferDirectory.getName());
            updateDirectoryVO.setOldWorkstationIds(new ArrayList<>());
            updateDirectoryVO.setNewWorkstationIds(workstationIdFilterList.stream().map((v0) -> {
                return String.valueOf(v0);
            }).collect(Collectors.toList()));
            return updateDirectory(updateDirectoryVO);
        }
        workstationIdFilterList.removeAll(ftpWorkStationIdList);
        if (Func.isEmpty(workstationIdFilterList)) {
            return true;
        }
        TransferDirectory transferDirectory2 = (TransferDirectory) getById(directoryId);
        UpdateDirectoryVO updateDirectoryVO2 = new UpdateDirectoryVO();
        updateDirectoryVO2.setDirectorId(directoryId);
        updateDirectoryVO2.setDirectorName(transferDirectory2.getName());
        updateDirectoryVO2.setOldWorkstationIds(ftpWorkStationIdList.stream().map((v0) -> {
            return String.valueOf(v0);
        }).collect(Collectors.toList()));
        updateDirectoryVO2.setNewWorkstationIds(workstationIdFilterList.stream().map((v0) -> {
            return String.valueOf(v0);
        }).collect(Collectors.toList()));
        return updateDirectory(updateDirectoryVO2);
    }
}