raex_back/src/main/java/com/izouma/nineth/service/MetaUserFriendService.java

package com.izouma.nineth.service;

import com.alibaba.fastjson.JSONArray;
import com.izouma.nineth.domain.*;
import com.izouma.nineth.dto.*;
import com.izouma.nineth.enums.MetaUserFriendOperateType;
import com.izouma.nineth.repo.MetaUserFriendApplyRecordRepo;
import com.izouma.nineth.repo.MetaUserFriendOperateRecordRepo;
import com.izouma.nineth.repo.MetaUserFriendRepo;
import com.izouma.nineth.repo.UserRepo;
import com.izouma.nineth.utils.SecurityUtils;
import lombok.AllArgsConstructor;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;

@Service
@AllArgsConstructor
public class MetaUserFriendService {

    private MetaUserFriendRepo               metaUserFriendRepo;
    private UserRepo                         userRepo;
    private MetaUserFriendApplyRecordRepo    metaUserFriendApplyRecordRepo;
    private MetaUserFriendApplyRecordService metaUserFriendApplyRecordService;
    private MetaUserFriendOperateRecordRepo  metaUserFriendOperateRecordRepo;

    public MetaRestResult<MetaUserFriendAndApplyDTO> allFriendsAndApply() {
        Long userId = SecurityUtils.getAuthenticatedUser().getId();
        MetaUserFriendAndApplyDTO metaUserFriendAndApplyDTO = new MetaUserFriendAndApplyDTO();
        List<Long> friendIds = metaUserFriendRepo.findFriendIdByUserId(userId);
        setMetaUserFriendDTOS(metaUserFriendAndApplyDTO, friendIds);
        List<Map<String, String>> map = metaUserFriendApplyRecordRepo.findApplyUserIds(userId);
        if (CollectionUtils.isEmpty(map)) {
            metaUserFriendAndApplyDTO.setMetaUserFriendApplyDTOS(new ArrayList<>());
            return MetaRestResult.returnSuccess(metaUserFriendAndApplyDTO);
        }
        JSONArray jsonArray = new JSONArray();
        jsonArray.addAll(map);
        List<MetaUserFriendApplyDTO> metaUserFriendApplyDTOS = jsonArray.toJavaList(MetaUserFriendApplyDTO.class);
        setMetaUserFriendApplyDTOS(metaUserFriendAndApplyDTO, metaUserFriendApplyDTOS);
        return MetaRestResult.returnSuccess(metaUserFriendAndApplyDTO);
    }

    private void setMetaUserFriendDTOS(MetaUserFriendAndApplyDTO metaUserFriendAndApplyDTO, List<Long> friendIds) {
        List<MetaUserFriendDTO> metaUserFriendDTOS = new ArrayList<>();
        if (CollectionUtils.isEmpty(friendIds)) {
            metaUserFriendAndApplyDTO.setMetaUserFriendDTOS(metaUserFriendDTOS);
            return;
        }
        friendIds.forEach(friendId -> {
            User user = userRepo.findById(friendId).orElse(null);
            if (Objects.nonNull(user)) {
                metaUserFriendDTOS.add(new MetaUserFriendDTO(friendId, user.getNickname(), user.getAvatar()));
            }
        });
        metaUserFriendAndApplyDTO.setMetaUserFriendDTOS(metaUserFriendDTOS);
    }

    private void setMetaUserFriendApplyDTOS(MetaUserFriendAndApplyDTO metaUserFriendAndApplyDTO, List<MetaUserFriendApplyDTO> metaUserFriendApplyDTOS) {
        if (CollectionUtils.isEmpty(metaUserFriendApplyDTOS)) {
            metaUserFriendAndApplyDTO.setMetaUserFriendApplyDTOS(metaUserFriendApplyDTOS);
            return;
        }
        metaUserFriendApplyDTOS.forEach(metaUserFriendApplyDTO -> {
            User user = userRepo.findById(metaUserFriendApplyDTO.getUserId()).orElse(null);
            if (Objects.nonNull(user)) {
                metaUserFriendApplyDTO.setAvatar(user.getAvatar());
                metaUserFriendApplyDTO.setNickname(user.getNickname());
            }
        });
        metaUserFriendAndApplyDTO.setMetaUserFriendApplyDTOS(metaUserFriendApplyDTOS);
    }

    public MetaRestResult<List<MetaUserFriend>> allFriends() {
        List<MetaUserFriend> metaUserFriends = metaUserFriendRepo.findByUserIdAndDel(SecurityUtils.getAuthenticatedUser().getId(), false);
        metaUserFriends.forEach(metaUserFriend -> {
            User user = userRepo.findById(metaUserFriend.getFriendId()).orElse(null);
            if (Objects.nonNull(user)) {
                metaUserFriend.setFriendAvatar(user.getAvatar());
                metaUserFriend.setFriendNickname(user.getNickname());
            }
        });
        return MetaRestResult.returnSuccess(metaUserFriends);
    }

    public MetaRestResult<List<MetaUserFriendApplyRecord>> allApply() {
        List<MetaUserFriendApplyRecord> metaUserFriendApplyRecords = metaUserFriendApplyRecordRepo.findByFriendIdAndOperateTypeAndDel(SecurityUtils.getAuthenticatedUser().getId(), MetaUserFriendOperateType.APPLY, false);
        metaUserFriendApplyRecords.forEach(metaUserFriendApplyRecord -> {
            User user = userRepo.findById(metaUserFriendApplyRecord.getUserId()).orElse(null);
            if (Objects.nonNull(user)) {
                metaUserFriendApplyRecord.setUserAvatar(user.getAvatar());
                metaUserFriendApplyRecord.setUserNickname(user.getNickname());
            }
        });
        return MetaRestResult.returnSuccess(metaUserFriendApplyRecords);
    }

    public MetaRestResult<MetaUserFriendApplyRecord> apply(MetaUserFriendApplyRecord metaUserFriendApplyRecord) {
        return metaUserFriendApplyRecordService.apply(metaUserFriendApplyRecord);
    }

    public MetaRestResult<Void> delApply(Long applyRecordId) {
        MetaUserFriendApplyRecord metaUserFriendApplyRecord = metaUserFriendApplyRecordRepo.findById(applyRecordId).orElse(null);
        if (Objects.isNull(metaUserFriendApplyRecord)) {
            return MetaRestResult.returnError("申请单不存在");
        }
        if (!metaUserFriendApplyRecord.getFriendId().equals(SecurityUtils.getAuthenticatedUser().getId())) {
            return MetaRestResult.returnError("该申请单不属于你");
        }
        metaUserFriendApplyRecord.setDel(true);
        metaUserFriendApplyRecordRepo.save(metaUserFriendApplyRecord);
        return MetaRestResult.returnSuccess("删除成功");
    }

    @Transactional
    public MetaRestResult<Void> operatingApply(Long metaUserFriendApplyRecordId, MetaUserFriendOperateType operateType) {
        if (Objects.isNull(metaUserFriendApplyRecordId)) {
            return MetaRestResult.returnError("Illegal parameter : metaUserFriendApplyRecordId can not be null");
        }
        // 判断申请记录
        MetaUserFriendApplyRecord metaUserFriendApplyRecord = metaUserFriendApplyRecordRepo.findById(metaUserFriendApplyRecordId).orElse(null);
        if (Objects.isNull(metaUserFriendApplyRecord)) {
            return MetaRestResult.returnError("暂无申请信息");
        }
        if (!metaUserFriendApplyRecord.getFriendId().equals(SecurityUtils.getAuthenticatedUser().getId())) {
            return MetaRestResult.returnError("当前用户不可操作该申请单");
        }
        if (!MetaUserFriendOperateType.APPLY.equals(metaUserFriendApplyRecord.getOperateType())) {
            return MetaRestResult.returnError("当前申请单已经处理过，不可重复处理");
        }
        if (MetaUserFriendOperateType.PASS.equals(operateType)) {
            MetaUserFriend myExist = metaUserFriendRepo.findByUserIdAndFriendIdAndDel(metaUserFriendApplyRecord.getUserId(), metaUserFriendApplyRecord.getFriendId(), false);
            MetaUserFriend friendExist = metaUserFriendRepo.findByUserIdAndFriendIdAndDel(metaUserFriendApplyRecord.getFriendId(), metaUserFriendApplyRecord.getUserId(), false);
            // 双方互为好友关系，不可添加
            if (Objects.nonNull(myExist) && Objects.nonNull(friendExist)) {
                MetaServiceResult result = metaUserFriendApplyRecordService.operatingApply(metaUserFriendApplyRecord, MetaUserFriendOperateType.CANCEL);
                if (!result.isSuccess()) {
                    return MetaRestResult.returnError(result.getMessage());
                }
                return MetaRestResult.returnError(String.format("用户[%S]已经是您好友", metaUserFriendApplyRecord.getFriendId()));
            }
            // 己方关系为空，添加己方关系
            if (Objects.isNull(myExist)) {
                MetaUserFriend my = new MetaUserFriend();
                my.setUserId(metaUserFriendApplyRecord.getUserId());
                my.setFriendId(metaUserFriendApplyRecord.getFriendId());
                my.setAddTime(LocalDateTime.now());
                metaUserFriendRepo.save(my);
            }
            // 好友方好友关系为空，添加好友方好友关系
            if (Objects.isNull(friendExist)) {
                MetaUserFriend friend = new MetaUserFriend();
                friend.setUserId(metaUserFriendApplyRecord.getFriendId());
                friend.setFriendId(metaUserFriendApplyRecord.getUserId());
                friend.setAddTime(LocalDateTime.now());
                metaUserFriendRepo.save(friend);
            }
        }
        MetaServiceResult result = metaUserFriendApplyRecordService.operatingApply(metaUserFriendApplyRecord, operateType);
        if (!result.isSuccess()) {
            return MetaRestResult.returnError(result.getMessage());
        }
        return MetaRestResult.returnSuccess("操作成功");
    }

    @Transactional
    public MetaRestResult<Void> del(Long friendId) {
        Long userId = SecurityUtils.getAuthenticatedUser().getId();
        // 判断是否为好友
        MetaUserFriend metaUserFriend = metaUserFriendRepo.findByUserIdAndFriendIdAndDel(userId, friendId, false);
        if (Objects.isNull(metaUserFriend)) {
            return MetaRestResult.returnError(String.format("删除失败，用户[%S]不是你的好友", friendId));
        }
        // 删除己方好友关系
        metaUserFriendRepo.delFriends(userId, friendId);
        // 删除好友方好友关系
        metaUserFriendRepo.delFriends(friendId, userId);
        // 保存操作记录
        LocalDateTime now = LocalDateTime.now();
        MetaUserFriendOperateRecord metaUserFriendOperateRecord = new MetaUserFriendOperateRecord();
        metaUserFriendOperateRecord.setUserId(userId);
        metaUserFriendOperateRecord.setFriendId(friendId);
        metaUserFriendOperateRecord.setOperateType(MetaUserFriendOperateType.DEL);
        metaUserFriendOperateRecord.setOperatingTime(now);
        metaUserFriendOperateRecord.setRemark(String.format("用户[%S]于[%S]删除好友[%S]，此操作为双向删除", userId, now, friendId));
        metaUserFriendOperateRecordRepo.save(metaUserFriendOperateRecord);
        return MetaRestResult.returnSuccess("删除好友成功");
    }
}