uni-app 即时聊天：朋友圈 ​

const mongoose = require("mongoose")

// 动态表
const dynamicSchema = new mongoose.Schema({
    userID: { type: mongoose.Schema.Types.ObjectId, ref: "user" },	//用户id
    logList: [
        { text: String, imgList: Array, originalList: Array, comments: Array, like: Array, date: Date, address: String }
    ],
    // imgList 存储压缩图的数组（为什么添加这个属性：因为在加载朋友圈图片时如果直接加载原图片速度会很慢，所以在上传图片的时候需要进行图片压缩，在加载的时候先加载压缩图，点击预览时加载原图片,图片压缩的办法在后面会提到）
    // originalList 存储原始图片的数组
    // text 文字内容
    // comments 评论
    // like 点赞
    // date 日期
    // address 位置
})

module.exports = mongoose.model("dynamic", dynamicSchema);

const mongoose = require("mongoose")

// 朋友圈动态表（包括好友和自己的动态）
const socialSchema = new mongoose.Schema({
    userID: { type: mongoose.Schema.Types.ObjectId, ref: "user" },	//用户id
    dynamicList: [
        { friend: String, date: Date }
        // friend  存储用户id
        // date  动态发布的时间
    ],
})

module.exports = mongoose.model("social", socialSchema);

const mongoose = require("mongoose")

// 评论通知表
const comNotifySchema = new mongoose.Schema({
    userID: String,	//用户id
    notify_list: [],
    // notify_list传入的对象，示例如下
    // {  
    //     fromUser: id,              // 点赞或者评论用户的id
    //     fromName: String,          // 点赞或者评论用户的名字
    //     toUser: id,                // 评论谁或者是回复谁（id） ,点赞时为null
    //     toName: String,            // 评论谁或者是回复谁（名字）,点赞时为null
    //     date, logDate,
    //     type: "like" || "comment", // 类型：评论，点赞
    //     content: null || String,   // 内容：评论则存在对应的内容，点赞则为null
    //     unRead: false || true      // 用户是否已读
    // }
})
module.exports = mongoose.model("comNotify", comNotifySchema);

const images = require("images")


// 上传朋友圈图片
"POST /upload/dynamic": async ctx => {
        // let data = ctx.req.body 
        let url = basePath + ctx.req.body.savePath + "/" + ctx.req.file.filename
        let imgPath = "public/" + ctx.req.body.savePath + "/" + ctx.req.file.filename
        let zipUrl = compression(imgPath, ctx.req.body.savePath, ctx.req.file.filename, 200)
        ctx.body = {
            imgUrl: zipUrl, // 压缩图地址 
            url // 原图片地址
        }
},


// 图片压缩的方法
function compression(filePath, savePath, fileName, num) {
    //根据文件路径读取文件，返回文件列表
    let zipPath = "public/" + savePath + "/" + "zip" + fileName  //压缩后保存的路径
    let number = num ? num : 150     //缩放的图片像素宽度
    images(filePath)                 //Load image from file 
        //加载图像文件
        .size(number)                          //Geometric scaling the image to 400 pixels width
        //等比缩放图像到150像素宽

        .save(zipPath, {               //Save the image to a file, with the quality of 50
            quality: 100                    //保存图片到文件,图片质量为100
        });
    return basePath + savePath + "/" + "zip" + fileName  //压缩后保存的路径
}

// 发布动态
exports.published = async data => {
    let { token, text, imgList, comments, originalList, like, date, address } = data
    let tokenRes = verifyToken(token)
    let user = await User.findById(tokenRes.id)
    // 添加到我的动态表中
    let tokenDynamic = await Dynamic.findOne({ userID: tokenRes.id })
    if (tokenDynamic) { // 个人动态表存在
        let logList = tokenDynamic.logList
        logList.unshift({
            text, imgList, originalList, comments, like, date, address
        })
        res = await Dynamic.updateOne({ userID: tokenRes.id }, { $set: { logList } })
    } else {  // 个人动态表不存在
        res = await Dynamic.create({
            userID: tokenRes.id,
            logList: [{
                text, imgList, originalList, comments, like, date, address
            }]
        })
    }
    if (res.userID || res.nModified == 1) {  // 将动态成功存储在个人动态表中后
        let friends = await Friend.findOne({ userID: tokenRes.id }) // 获取好友表
        let friend_list = friends.friend_list
        friend_list.push({  //将token用户也添加到好友表中
            user: tokenRes.id,
            nickName: ""
        })
        // 遍历好友表将动态添加到好友的朋友圈动态表中，因为循环体中包含了 async 和 await 所以必须使用Promise.all包裹
        // 如果直接遍历会导致循环体中的代码失效
        let result = await Promise.all(friend_list.map(async item => {
            let d_list = await Social.findOne({ userID: item.user })
            if (d_list) {
                let dynamicList = d_list.dynamicList
                dynamicList.unshift({
                    friend: tokenRes.id, date,
                })
                let d_res = await Social.updateOne({ userID: item.user }, { $set: { dynamicList } })
            } else {
                let d_res = await Social.create({
                    userID: item.user,
                    dynamicList: [
                        { friend: tokenRes.id, date }
                    ]
                })
            }

            // 添加到好友动态通知表中
            if (item.user != tokenRes.id) {
                let dy = await DyNotify.findOne({ userID: item.user })
                if (dy) { // 动态通知表存在
                    let notify_list = dy.notify_list
                    notify_list[0] = {
                        fromUser: user._id,
                        fromImg: user.avatars
                    }
                    let d_res = await DyNotify.updateOne({ userID: item.user }, { $set: { notify_list } })
                } else { // 动态通知表不存在
                    let d_res = await DyNotify.create({
                        userID: item.user,
                        notify_list: [
                            {
                                ormUser: user._id,
                                fromImg: user.avatars
                            }
                        ]
                    })
                }
                let socketUser = await userSocket.findOne({ userId: item.user })
                // 已经将socket.io对象挂载到global对象上，所以可以直接调用
                io.to(socketUser.socketId).emit("getDyNotify")
            }
        }))
        return { status: 1, msg: "发布成功" }
    } else {
        return { status: 0, msg: "发布失败" }
    }

}

<template>
	<view class="content">
		<comtarbar class="comtarbar">
			<template #center>
				<view class="title">编辑</view>
			</template>
			<template #right>
				<view class="btn" @tap="uploadImg">发表</view>
			</template>
		</comtarbar>
		<view class="edit_box">
			<view class="textarea-box"><textarea v-model="content" placeholder="请输入文字" /></view>
			<view class="e_title">
				<view class="title">添加图片</view>
				<view v-if="imglist.length > 2"><view class="btn" @tap="deleteAll">移除全部</view></view>
			</view>
			<view class="imagebox">
				<view class="image_item" v-for="(item, index) in imglist" :key="index">
					<image @tap="previewImg(index)" class="c_image" :src="item" mode="aspectFill"></image>
					<image @tap="deleteImg(index)" class="yc" src="../../../static/images/edit/yc.png" mode="widthFix"></image>
				</view>
				<view class="image_item" v-if="imglist.length < 9" @tap="choose">
					<image class="c_image" src="../../../static/images/group/addimage.png" mode="widthFix"></image>
				</view>
			</view>
			<view class="e_title"><view class="title">添加位置</view></view>
			<view class="localtion">
				<view class="localtion_btn" @tap="getLocaltion">定位</view>
				<view v-if="address != ''" class="address">{{ address }}</view>
			</view>
		</view>
	</view>
</template>

<script>
import request from '../../../api/request.js';
import { mapGetters } from 'vuex';
export default {
	data() {
		return {
			content: '',
			imglist: [],
			address: '',
			path: ''
		};
	},
	onLoad(options) {
		this.path = options.path;
	},
	computed: {
		...mapGetters(['getUser'])
	},
	methods: {
		// 选择图片
		choose() {
			uni.chooseImage({
				count: 9, //默认9
				sizeType: ['original', 'compressed'], //可以指定是原图还是压缩图，默认二者都有
				sourceType: ['album', 'camera '], //从相册选择
				success: res => {
					res.tempFilePaths.map(item => {
						if (this.imglist.length < 9) {
							this.imglist.push(item);
						}
						return item;
					});
				}
			});
		},
		// 移除图片
		deleteImg(index) {
			this.imglist.splice(index, 1);
		},
		// 移除全部图片
		deleteAll() {
			this.imglist = [];
		},
		// 预览图片
		previewImg(index) {
			uni.previewImage({
				urls: this.imglist,
				current: index,
				longPressActions: {
					itemList: ['发送给朋友', '保存图片', '收藏'],
					success: function(data) {
						console.log('选中了第' + (data.tapIndex + 1) + '个按钮,第' + (data.index + 1) + '张图片');
					},
					fail: function(err) {
						console.log(err.errMsg);
					}
				}
			});
		},
		// 获取位置
		getLocaltion() {
			uni.chooseLocation({
				success: res => {
					this.address = res.address;
				}
			});
		},
		// 上传图片
		uploadImg() {
			// 如果有图片
			if (this.imglist.length > 0) {
				let list = [];
				let originalList = [];
				this.imglist.map(item => {
					//遍历上传图片
					uni.uploadFile({
					    url: 'http://localhost:3000/upload/dynamic',
						filePath: item,
						name: 'file',
						formData: {
							token: uni.getStorageSync('token'),
							savePath: 'dynamic'
						},
						success: uploadFileRes => {
							let { imgUrl, url } = JSON.parse(uploadFileRes.data);
							list.push(imgUrl);
							originalList.push(url);
							if (list.length == this.imglist.length) {
								//图片上传完毕后发布动态
								this.published(list, originalList);
							}
						}
					});
					return item;
				});
			} else {
				//没有图片
				this.published();
			}
		},
		// 发布动态
		async published(list, originalList) {
			let res = await request({
				url: '/dynamic/published',
				data: {
					token: uni.getStorageSync('token'),
					text: this.content,
					imgList: list ? list : [],
					originalList: originalList ? originalList : [],
					comments: [],
					like: [],
					date: new Date(),
					address: this.address
				},
				method: 'POST'
			});
			res = res[1].data;
			if (res.status) {
				uni.showToast({
					title: res.msg,
					duration: 1000
				});
				setTimeout(() => {
					uni.navigateBack({
						delta: 1
					});
					if (this.path == 'dynamic') {
						uni.$emit('refresh'); //刷新数据
						uni.navigateTo({
							url: '../dynamic/dynamic'
						});
					} else {
						uni.$emit('refreshSocial'); //刷新数据
						uni.$emit('refresh'); //刷新数据
						uni.navigateTo({
							url: '../individual/individual?id=' + this.getUser._id
						});
					}
				}, 1300);
			} else {
				uni.showToast({
					title: res.msg,
					icon: 'none',
					duration: 1000
				});
			}
		}
	}
};
</script>

// 删除动态
exports.deleteDynamic = async data => {
    let { token, date } = data
    let tokenRes = verifyToken(token)
    let tokenDynamic = await Dynamic.findOne({ userID: tokenRes.id })

    // 从动态表中删除该动态
    let logList = tokenDynamic.logList
    let index = logList.findIndex(item => {
        return new Date(item.date).getTime() == new Date(date).getTime()
    })

    // 删除图片
    let imgList = logList[index].imgList
    let originalList = logList[index].originalList
    let newImgList = [...imgList, ...originalList]
    let basePath = "http://localhost:3000"
    // let basePath = "http://yemengs.cn"
    if (newImgList.length > 0) {
        newImgList.forEach(element => {
            let path = element.replace(basePath, "public")
            if (fs.existsSync(path)) {
                fs.unlinkSync(path);
            }
            console.log(path)
        });
    }

    logList.splice(index, 1)
	
    // 更新个人动态表
    let res = await Dynamic.updateOne({ userID: tokenRes.id }, { $set: { logList } }) 


	
    let friends = await Friend.findOne({ userID: tokenRes.id })
    if (friends) {
        let friend_list = friends.friend_list
        if (friend_list.length > 0) {
            // 将动态从自己和好友的朋友圈动态表中移除
            let result = await Promise.all(friend_list.map(async item => {
                let social = await Social.findOne({ userID: item.user })
                let dynamicList = social.dynamicList
                let index = dynamicList.findIndex(item2 => {
                    return item2.friend.toString() == tokenRes.id.toString() && new Date(item2.date).getTime() == new Date(date).getTime()
                })
                if (index > -1) {
                    dynamicList.splice(index, 1)
                    let updateSocial = await Social.updateOne({ userID: item.user }, { $set: { dynamicList } })
                }
            }))
        }
    }
    if (res.nModified > 0) {
        return { status: 1, msg: "删除成功" }
    } else {
        return { status: 0, msg: "删除失败" }
    }
}

// 删除动态
deleteLog(date) {
	uni.showModal({
		title: '提示',
		content: '确定删除该动态吗',
		success: async res => {
			if (res.confirm) {
				let res = await request({
					url: '/dynamic/delete',
					data: {
						date,
						token: uni.getStorageSync('token')
					},
					method: 'POST'
				});
				res = res[1].data;
				if (res.status == 1) {
					// 本地删除数据 ,为了不刷新数据造成scroll-view跳转的情况
					let index = this.social.findIndex(item => {
						return new Date(item.date).getTime() == new Date(date).getTime();
					});
					if (index > -1) {
						this.social.splice(index, 1);
					}
					uni.$emit('refresh'); //刷新数据
				}
			} else if (res.cancel) {
			}
		}
	});
},

// 评论
exports.comment = async data => {
    let { token, id, date, toUser, toName, content } = data
    let tokenRes = verifyToken(token)
    let user = await User.findById(tokenRes.id)
    let idDynamic = await Dynamic.findOne({ userID: id })
    let logList = idDynamic.logList
    let index = logList.findIndex(item => {
        return new Date(item.date).getTime() == new Date(date).getTime()
    })
    logList[index].comments.unshift({
        fromUser: user._id,
        fromName: user.name,
        toUser,
        toName,
        content,
    })
    // 更新动态评论
    let res = await Dynamic.updateOne({ userID: id }, { $set: { logList } })
    if (res.nModified == 1) {
        // 添加到通知表
        let arr = []
        if (toUser == id && user._id != id) {  //当toUser和id相同时并且fromUser和id不同时，只需通知一个人(动态的主人)
            // console.log("第一种情况")
            arr = [{ to: id, id: tokenRes.id, name: user.name }]
        } else if (user._id == id && toUser != id) { //当fromUser和id相同而toUser不同时，只需通知一个人（toUser）
            // console.log("第二种情况", toName)
            arr = [{ to: toUser, id: tokenRes.id, name: user.name }]
        } else if (toUser == id && user._id == id) {
            // console.log("第三种情况")
        } else { //不同时，则需要通知两个人
            // console.log("第四种情况")
            arr = [{ to: id, id: tokenRes.id, name: user.name }, { to: toUser, id: tokenRes.id, name: user.name }]
        }
        let pro_result = await Promise.all(arr.map((async item => {
            let comNotify = await ComNotify.findOne({ userID: item.to })
            let result = null
            if (comNotify) {
                let obj = {
                    fromUser: item.id,
                    fromName: item.name,
                    toUser,
                    toName,
                    date: new Date(),
                    logDate: date,
                    type: "comment",
                    content,
                    text: logList[index].text,
                    unRead: false,
                    id
                }
                let notify_list = comNotify.notify_list
                notify_list.unshift(obj)
                result = await ComNotify.updateOne({ userID: id }, { $set: { notify_list } })
            } else {
                let notify_list = [{
                    fromUser: item.id,
                    fromName: item.name,
                    toUser,
                    toName,
                    date: new Date(),
                    logDate: date,
                    type: "comment",
                    content,
                    text: logList[index].text,
                    unRead: false,
                    id
                }]
                result = await ComNotify.create({ userID: item.to, notify_list })
            }
            if (result.userID || result.nModified > 0) {
                let socketUser = await userSocket.findOne({ userId: item.to })
                // 已经将socket.io对象挂载到global对象上，所以可以直接调用
                io.to(socketUser.socketId).emit("getComNotify")
            }
        })))
        return { status: 1, msg: "评论成功" }
    } else {
        return { status: 0, msg: "评论失败" }
    }

}

// 评论
async comment(content) {
	this.showComment = false; // 隐藏评论组件
	// 本地添加数据(减少请求)
	this.social.map(item => {
		if (item.id == this.id && new Date(item.log.date).getTime() == new Date(this.date).getTime()) {
			item.log.comments.unshift({
				fromUser: this.getUser._id,
				fromName: this.getUser.name,
				toUser: this.toUser,
				toName: this.toName,
				content
			});
		}
		return item;
	});

	// 向服务器发送数据
	let res = await request({
		url: '/dynamic/comment',
		data: {
			token: uni.getStorageSync('token'),
			id: this.id,
			date: this.date,
			toUser: this.toUser,
			toName: this.toName,
			content
		},
		method: 'POST'
	});
	if(res[1].data.status){
		uni.showToast({
			title: "评论成功",
			duration:1000
		});
	}else{
		uni.showToast({
			title: "发表评论失败",
			icon:"none",
			duration:1000
		});
	}
},

// 点赞
exports.giveALike = async data => {
    // id:动态所属用户的id
    let { token, id, date } = data  
    let tokenRes = verifyToken(token)
    let user = await User.findById(tokenRes.id)
    let idDynamic = await Dynamic.findOne({ userID: id })
    let logList = idDynamic.logList
    let index = logList.findIndex(item => {
        return new Date(item.date).getTime() == new Date(date).getTime()
    })
    // 在点赞的数组中查找该用户是否已经点过赞
    let likeIndex = logList[index].like.findIndex(item2 => {
        return item2.id.toString() == user._id.toString()
    })
    let res = null
    if (likeIndex > -1) { // 已经点过赞则执行取消点赞操作
        logList[index].like.splice(likeIndex, 1)
        res = await Dynamic.updateOne({ userID: id }, { $set: { logList } })
    } else {  // 没有则执行点赞操作
        logList[index].like.unshift({ id: user._id, nickName: null })
        res = await Dynamic.updateOne({ userID: id }, { $set: { logList } })
        if (res.nModified > 0) {
            if (tokenRes.id != id) {
                // 添加到通知表
                let comNotify = await ComNotify.findOne({ userID: id })
                let result = null
                if (comNotify) {
                    let obj = {
                        fromUser: tokenRes.id,
                        fromName: user.name,
                        toUser: null,
                        toName: null,
                        date: new Date(),
                        logDate: date,
                        type: "like",
                        content: null,
                        text: logList[index].text,
                        unRead: false,
                        id
                    }
                    let notify_list = comNotify.notify_list
                    notify_list.unshift(obj)
                    result = await ComNotify.updateOne({ userID: id }, { $set: { notify_list } })
                } else {
                    let notify_list = [{
                        fromUser: tokenRes.id,
                        fromName: user.name,
                        toUser: null,
                        toName: null,
                        date: new Date(),
                        logDate: date,
                        type: "like",
                        content: null,
                        text: logList[index].text,
                        unRead: false,
                        id
                    }]
                    result = await ComNotify.create({ userID: id, notify_list })
                }
                if (result.userID || result.nModified > 0) { // 点赞成功，通知用户 
                    let socketUser = await userSocket.findOne({ userId: id })
                    global.io.to(socketUser.socketId).emit("getComNotify")
                }
            }
        }
    }
    return {}
}

// 点赞触发的事件
async giveALike(id, date) {
    // index 是 点赞和评论组件的索引值
	this.index = -1; 
	// 本地添加数据
	this.social.map(item => {
		if (item.id == id && new Date(item.log.date).getTime() == new Date(date).getTime()) {
			// 判断点赞数组中是否存在该用户
			let index = item.log.like.findIndex(item => {
				//通过或来判断，因为存到数据库是存的id,本地存的是name
				return item.id == this.getUser._id;
			});
			if (index == -1) {
				//如果不存在则添加
				item.log.like.unshift({ id: this.getUser._id, nickName: this.getUser.name });
			} else {
				//存在则删除
				item.log.like.splice(index, 1);
			}
		}
		return item;
	});
	// 向服务器发送数据
	let res = await request({
		url: '/dynamic/like',
		data: {
			token: uni.getStorageSync('token'),
			id, // 动态所属用户的id
			date
		},
		method: 'POST'
	});
},

// 获取个人动态
exports.acquire = async data => {
    let { token, id, page, limit } = data
    let tokenRes = verifyToken(token)
    let tokenUser = await User.findById(tokenRes.id)
    let obj = {}
    let result = await Friend.findOne({ userID: tokenRes.id }).populate("friend_list.user", "avatars")
    let friend_list = []
    if (result) {
        friend_list = result.friend_list
    }
    if (tokenRes.id == id) {//是用户自己
        obj.avatars = tokenUser.avatars
        obj.id = tokenUser._id
        obj.nickName = tokenUser.name
    } else {
        let index = friend_list.findIndex(item => { //在好友表中查找并获取好友信息（昵称和用户头像）
            return item.user._id == id
        })
        if (index > -1) { //是好友
            let friend = friend_list[index]
            obj.avatars = friend.user.avatars
            obj.id = friend.user._id
            obj.nickName = friend.nickName
        } else { //不是好友
            let idUser = await User.findById(id)
            obj.avatars = idUser.avatars
            obj.id = id
            obj.nickName = idUser.name
        }
    }
    let res = await Dynamic.findOne({ userID: id })
    if (res) {
        let logList = res.logList
        let count = logList.length
        let maxPage = Math.ceil(count / limit)
        if (page > maxPage) {
            return { logList: [], avatars: obj.avatars, name: obj.nickName }
        }
        let skip = (page - 1) * limit
        let spliceLogList = logList.splice(skip, limit)

        let oldLogList = []
        let mapRes = await Promise.all(spliceLogList.map(async item => {
            let like = [] //存储点赞里是好友关系的用户
            // 遍历点赞，在朋友中寻找，不是好友关系则屏蔽
            item.like.map(item4 => {
                if (item4.id == tokenRes.id) { //是token用户自身
                    item4.nickName = tokenUser.name
                    like.push(item4)
                } else { //不是token用户自身则从好友列表中查找
                    friend_list.map(item5 => {
                        if (item5.user._id.toString() == item4.id.toString()) {
                            item4.nickName = item5.nickName
                            like.push(item4)
                        }
                        return item5
                    })
                }
                return item4
            })
            item.like = like
            let comCount = item.comments.length  //评论的个数
            let comments = [] //存储评论里是好友关系的用户
            // 遍历评论，在朋友中寻找，不是好友关系则屏蔽
            for (let i = 0; i < item.comments.length; i++) {
                if (i > 4) {
                    break
                }
                let item6 = item.comments[i]
                // 下面两个变量是为了确定回复者和被回复者与token用户是否是好友关系
                let isFriends1 = false
                let isFriends2 = false

                if (item6.fromUser == tokenRes.id) { //是token用户自身
                    item6.fromName = tokenUser.name
                    isFriends1 = true
                }
                if (item6.toUser == tokenRes.id) { //是token用户自身
                    item6.toUser == tokenUser.name
                    isFriends2 = true
                }
                if (isFriends1 != true || isFriends2 != true) {
                    friend_list.map(item7 => { //判断回复者的好友关系
                        if (item7.user._id.toString() == item6.fromUser.toString()) {
                            item6.fromName = item7.nickName
                            isFriends1 = true
                        }
                        if (item7.user._id.toString() == item6.toUser.toString()) {
                            item6.toName = item7.nickName
                            isFriends2 = true
                        }
                        return item7
                    })
                }
                if (isFriends1 && isFriends2) {//当两个人与token用户都是好友关系时才显示
                    comments.push(item6)
                }
            }
            // item.comments.map(item6 => {

            //     return item6
            // })
            item.comments = comments
            let newObj = {
                comCount,
                avatars: obj.avatars,
                id: obj.id,
                nickName: obj.nickName,
                text: item.text,
                imgList: item.imgList,
                originalList: item.originalList,
                comments: item.comments,
                like: item.like,
                date: item.date,
                address: item.address,
                _id: item._id,
            }
            // let newObj = Object.assign(obj, item)
            // console.log(newObj)
            oldLogList.push(newObj)
            // console.log(newDynamicList)
            return item
        }))
        // 排序（因为以上map遍历以及内嵌了await 导致执行顺序会乱）
        function listSort(a, b) {
            return new Date(b.date).getTime() - new Date(a.date).getTime()
        }
        let newLogList = oldLogList.sort(listSort)
        return { logList: newLogList, avatars: obj.avatars, name: obj.nickName }
    } else {
        return { logList: [], avatars: obj.avatars, name: obj.nickName }
    }

}