Sharkey/src/services/note/create.ts

454 lines
11 KiB
TypeScript
Raw Normal View History

2018-07-04 14:13:05 +03:00
import es from '../../db/elasticsearch';
2018-04-07 20:30:37 +03:00
import Note, { pack, INote } from '../../models/note';
2018-05-06 22:08:39 +03:00
import User, { isLocalUser, IUser, isRemoteUser, IRemoteUser, ILocalUser } from '../../models/user';
2018-07-11 03:36:30 +03:00
import stream, { publishLocalTimelineStream, publishHybridTimelineStream, publishGlobalTimelineStream, publishUserListStream } from '../../stream';
2018-04-04 18:40:34 +03:00
import Following from '../../models/following';
2018-04-05 17:24:51 +03:00
import { deliver } from '../../queue';
2018-04-04 18:40:34 +03:00
import renderNote from '../../remote/activitypub/renderer/note';
import renderCreate from '../../remote/activitypub/renderer/create';
2018-04-08 00:55:26 +03:00
import renderAnnounce from '../../remote/activitypub/renderer/announce';
2018-04-13 08:39:08 +03:00
import packAp from '../../remote/activitypub/renderer';
2018-04-04 18:40:34 +03:00
import { IDriveFile } from '../../models/drive-file';
2018-07-07 21:19:04 +03:00
import notify from '../../notify';
2018-04-07 20:30:37 +03:00
import NoteWatching from '../../models/note-watching';
2018-04-04 18:40:34 +03:00
import watch from './watch';
import Mute from '../../models/mute';
2018-07-07 13:19:00 +03:00
import event from '../../stream';
import parse from '../../mfm/parse';
2018-04-04 18:50:57 +03:00
import { IApp } from '../../models/app';
2018-04-25 12:04:16 +03:00
import UserList from '../../models/user-list';
2018-05-06 21:19:24 +03:00
import resolveUser from '../../remote/resolve-user';
2018-06-16 04:40:53 +03:00
import Meta from '../../models/meta';
2018-07-04 07:21:30 +03:00
import config from '../../config';
2018-04-02 11:11:14 +03:00
2018-06-21 05:35:28 +03:00
type Type = 'reply' | 'renote' | 'quote' | 'mention';
2018-05-06 22:08:39 +03:00
/**
2018-06-21 05:35:28 +03:00
*
2018-05-06 22:08:39 +03:00
*/
class NotificationManager {
2018-06-21 05:35:28 +03:00
private notifier: IUser;
2018-06-24 10:09:41 +03:00
private note: INote;
2018-05-06 22:08:39 +03:00
2018-06-24 10:09:41 +03:00
constructor(notifier: IUser, note: INote) {
2018-06-21 05:35:28 +03:00
this.notifier = notifier;
2018-05-06 22:08:39 +03:00
this.note = note;
}
2018-06-24 09:51:03 +03:00
public async push(notifiee: ILocalUser['_id'], type: Type) {
2018-05-06 22:08:39 +03:00
// 自分自身へは通知しない
2018-06-21 05:35:28 +03:00
if (this.notifier._id.equals(notifiee)) return;
2018-05-06 22:08:39 +03:00
2018-06-24 09:51:03 +03:00
// ミュート情報を取得
const mentioneeMutes = await Mute.find({
muterId: notifiee
});
2018-05-06 22:08:39 +03:00
2018-06-24 09:51:03 +03:00
const mentioneesMutedUserIds = mentioneeMutes.map(m => m.muteeId.toString());
2018-05-06 22:08:39 +03:00
2018-06-24 09:51:03 +03:00
// 通知される側のユーザーが通知する側のユーザーをミュートしていない限りは通知する
if (!mentioneesMutedUserIds.includes(this.notifier._id.toString())) {
notify(notifiee, this.notifier._id, type, {
noteId: this.note._id
2018-05-06 22:08:39 +03:00
});
2018-06-24 09:51:03 +03:00
}
2018-05-06 22:08:39 +03:00
}
}
2018-04-05 22:04:50 +03:00
export default async (user: IUser, data: {
2018-04-05 12:43:06 +03:00
createdAt?: Date;
text?: string;
2018-04-07 20:30:37 +03:00
reply?: INote;
renote?: INote;
2018-04-05 12:43:06 +03:00
media?: IDriveFile[];
geo?: any;
2018-04-04 21:21:11 +03:00
poll?: any;
2018-04-05 12:43:06 +03:00
viaMobile?: boolean;
2018-04-04 21:21:11 +03:00
tags?: string[];
cw?: string;
visibility?: string;
2018-04-28 22:30:51 +03:00
visibleUsers?: IUser[];
2018-04-04 18:50:57 +03:00
uri?: string;
app?: IApp;
2018-04-07 20:30:37 +03:00
}, silent = false) => new Promise<INote>(async (res, rej) => {
2018-04-05 22:04:50 +03:00
if (data.createdAt == null) data.createdAt = new Date();
if (data.visibility == null) data.visibility = 'public';
2018-04-08 00:55:26 +03:00
if (data.viaMobile == null) data.viaMobile = false;
2018-04-04 21:21:11 +03:00
let tags = data.tags || [];
2018-04-02 11:11:14 +03:00
2018-05-06 22:08:39 +03:00
let tokens: any[] = null;
2018-04-02 11:11:14 +03:00
2018-04-05 22:04:50 +03:00
if (data.text) {
2018-04-04 18:40:34 +03:00
// Analyze
2018-04-05 22:04:50 +03:00
tokens = parse(data.text);
2018-04-02 11:11:14 +03:00
2018-04-04 18:40:34 +03:00
// Extract hashtags
const hashtags = tokens
.filter(t => t.type == 'hashtag')
.map(t => t.hashtag);
hashtags.forEach(tag => {
if (tags.indexOf(tag) == -1) {
tags.push(tag);
}
});
2018-04-02 11:11:14 +03:00
}
tags = tags.filter(tag => tag.length <= 100);
2018-04-28 22:30:51 +03:00
if (data.visibleUsers) {
data.visibleUsers = data.visibleUsers.filter(x => x != null);
}
2018-04-05 22:04:50 +03:00
const insert: any = {
createdAt: data.createdAt,
mediaIds: data.media ? data.media.map(file => file._id) : [],
replyId: data.reply ? data.reply._id : null,
2018-04-07 20:30:37 +03:00
renoteId: data.renote ? data.renote._id : null,
2018-04-05 22:04:50 +03:00
text: data.text,
poll: data.poll,
2018-04-22 11:04:52 +03:00
cw: data.cw == null ? null : data.cw,
2018-04-04 18:40:34 +03:00
tags,
2018-06-16 09:23:03 +03:00
tagsLower: tags.map(tag => tag.toLowerCase()),
2018-04-04 18:40:34 +03:00
userId: user._id,
2018-04-05 22:04:50 +03:00
viaMobile: data.viaMobile,
geo: data.geo || null,
appId: data.app ? data.app._id : null,
visibility: data.visibility,
2018-04-28 23:28:34 +03:00
visibleUserIds: data.visibility == 'specified'
? data.visibleUsers
? data.visibleUsers.map(u => u._id)
: []
: [],
2018-04-02 11:11:14 +03:00
2018-04-04 18:40:34 +03:00
// 以下非正規化データ
2018-04-05 22:04:50 +03:00
_reply: data.reply ? { userId: data.reply.userId } : null,
2018-04-07 20:30:37 +03:00
_renote: data.renote ? { userId: data.renote.userId } : null,
2018-04-05 22:04:50 +03:00
_user: {
host: user.host,
2018-04-08 00:55:26 +03:00
inbox: isRemoteUser(user) ? user.inbox : undefined
2018-04-05 22:04:50 +03:00
}
2018-04-05 09:50:52 +03:00
};
2018-04-05 22:04:50 +03:00
if (data.uri != null) insert.uri = data.uri;
2018-04-05 09:50:52 +03:00
// 投稿を作成
2018-04-18 08:53:17 +03:00
let note: INote;
try {
note = await Note.insert(insert);
} catch (e) {
// duplicate key error
2018-04-19 03:17:42 +03:00
if (e.code === 11000) {
2018-04-18 08:53:17 +03:00
return res(null);
}
console.error(e);
return rej('something happened');
}
2018-04-02 11:11:14 +03:00
2018-04-07 20:30:37 +03:00
res(note);
2018-04-04 17:12:35 +03:00
2018-06-16 04:40:53 +03:00
//#region Increment notes count
if (isLocalUser(user)) {
Meta.update({}, {
$inc: {
'stats.notesCount': 1,
'stats.originalNotesCount': 1
}
}, { upsert: true });
} else {
Meta.update({}, {
$inc: {
'stats.notesCount': 1
}
}, { upsert: true });
}
//#endregion
// Increment notes count (user)
2018-04-04 17:12:35 +03:00
User.update({ _id: user._id }, {
$inc: {
2018-04-07 20:30:37 +03:00
notesCount: 1
2018-04-04 17:12:35 +03:00
}
});
2018-05-28 18:36:52 +03:00
if (data.reply) {
Note.update({ _id: data.reply._id }, {
$push: {
_replyIds: note._id
}
});
}
const isQuote = data.renote && (data.text || data.poll || data.media);
if (isQuote) {
Note.update({ _id: data.renote._id }, {
$push: {
_quoteIds: note._id
}
});
}
2018-04-04 18:40:34 +03:00
// Serialize
2018-04-07 20:30:37 +03:00
const noteObj = await pack(note);
2018-04-04 17:12:35 +03:00
2018-06-24 10:09:41 +03:00
const nm = new NotificationManager(user, note);
2018-05-06 22:08:39 +03:00
2018-05-06 21:19:24 +03:00
const render = async () => {
const content = data.renote && data.text == null
? renderAnnounce(data.renote.uri ? data.renote.uri : await renderNote(data.renote))
: renderCreate(await renderNote(note));
return packAp(content);
};
2018-06-12 23:40:12 +03:00
//#region メンション
if (data.text) {
// TODO: Drop dupulicates
const mentionTokens = tokens
.filter(t => t.type == 'mention');
// TODO: Drop dupulicates
const mentionedUsers = (await Promise.all(mentionTokens.map(async m => {
try {
return await resolveUser(m.username, m.host);
} catch (e) {
return null;
}
}))).filter(x => x != null);
// Append mentions data
if (mentionedUsers.length > 0) {
const set = {
mentions: mentionedUsers.map(u => u._id),
mentionedRemoteUsers: mentionedUsers.filter(u => isRemoteUser(u)).map(u => ({
uri: (u as IRemoteUser).uri,
username: u.username,
host: u.host
}))
};
Note.update({ _id: note._id }, {
$set: set
});
Object.assign(note, set);
}
mentionedUsers.filter(u => isLocalUser(u)).forEach(async u => {
event(u, 'mention', noteObj);
// 既に言及されたユーザーに対する返信や引用renoteの場合も無視
if (data.reply && data.reply.userId.equals(u._id)) return;
if (data.renote && data.renote.userId.equals(u._id)) return;
// Create notification
nm.push(u._id, 'mention');
});
if (isLocalUser(user)) {
mentionedUsers.filter(u => isRemoteUser(u)).forEach(async u => {
deliver(user, await render(), (u as IRemoteUser).inbox);
});
}
}
//#endregion
2018-05-06 22:08:39 +03:00
if (!silent) {
if (isLocalUser(user)) {
if (note.visibility == 'private' || note.visibility == 'followers' || note.visibility == 'specified') {
// Publish event to myself's stream
stream(note.userId, 'note', await pack(note, user, {
detail: true
}));
} else {
// Publish event to myself's stream
stream(note.userId, 'note', noteObj);
2018-07-11 03:36:30 +03:00
// Publish note to local and hybrid timeline stream
2018-05-06 22:08:39 +03:00
if (note.visibility != 'home') {
publishLocalTimelineStream(noteObj);
2018-07-13 18:34:05 +03:00
}
if (note.visibility == 'public') {
2018-07-11 08:33:03 +03:00
publishHybridTimelineStream(null, noteObj);
2018-04-29 01:01:47 +03:00
}
2018-04-05 22:04:50 +03:00
}
2018-05-06 22:08:39 +03:00
}
2018-04-05 22:04:50 +03:00
2018-05-06 22:08:39 +03:00
// Publish note to global timeline stream
2018-06-05 16:54:03 +03:00
if (note.visibility == 'public' && note.replyId == null) {
publishGlobalTimelineStream(noteObj);
}
2018-04-25 12:04:16 +03:00
2018-05-06 22:08:39 +03:00
if (note.visibility == 'specified') {
data.visibleUsers.forEach(async u => {
2018-07-13 18:34:05 +03:00
const n = await pack(note, u, {
2018-05-06 22:08:39 +03:00
detail: true
2018-07-13 18:34:05 +03:00
});
stream(u._id, 'note', n);
publishHybridTimelineStream(u._id, n);
2018-05-06 22:08:39 +03:00
});
}
2018-04-25 12:04:16 +03:00
2018-05-06 22:08:39 +03:00
if (note.visibility == 'public' || note.visibility == 'home' || note.visibility == 'followers') {
// フォロワーに配信
Following.find({
followeeId: note.userId
}).then(followers => {
followers.map(async following => {
const follower = following._follower;
if (isLocalUser(follower)) {
// ストーキングしていない場合
if (!following.stalk) {
// この投稿が返信ならスキップ
if (note.replyId && !note._reply.userId.equals(following.followerId) && !note._reply.userId.equals(note.userId)) return;
2018-04-25 12:04:16 +03:00
}
2018-05-06 22:08:39 +03:00
// Publish event to followers stream
stream(following.followerId, 'note', noteObj);
2018-07-14 07:47:36 +03:00
if (note.visibility != 'public') {
publishHybridTimelineStream(following.followerId, noteObj);
}
2018-05-06 22:08:39 +03:00
} else {
//#region AP配送
// フォロワーがリモートユーザーかつ投稿者がローカルユーザーなら投稿を配信
if (isLocalUser(user)) {
deliver(user, await render(), follower.inbox);
}
//#endergion
}
2018-04-25 12:04:16 +03:00
});
});
}
2018-04-19 06:43:25 +03:00
2018-05-06 22:08:39 +03:00
// リストに配信
UserList.find({
userIds: note.userId
}).then(lists => {
lists.forEach(list => {
publishUserListStream(list._id, 'note', noteObj);
});
});
}
2018-04-25 12:04:16 +03:00
2018-05-06 22:08:39 +03:00
//#region リプライとAnnounceのAP配送
2018-04-25 12:04:16 +03:00
2018-05-06 22:08:39 +03:00
// 投稿がリプライかつ投稿者がローカルユーザーかつリプライ先の投稿の投稿者がリモートユーザーなら配送
if (data.reply && isLocalUser(user) && isRemoteUser(data.reply._user)) {
deliver(user, await render(), data.reply._user.inbox);
2018-04-04 17:12:35 +03:00
}
2018-05-06 22:08:39 +03:00
// 投稿がRenoteかつ投稿者がローカルユーザーかつRenote元の投稿の投稿者がリモートユーザーなら配送
if (data.renote && isLocalUser(user) && isRemoteUser(data.renote._user)) {
deliver(user, await render(), data.renote._user.inbox);
}
//#endergion
2018-04-04 17:12:35 +03:00
2018-04-07 20:30:37 +03:00
// If has in reply to note
2018-04-05 22:04:50 +03:00
if (data.reply) {
2018-04-04 18:40:34 +03:00
// Increment replies count
2018-04-07 20:30:37 +03:00
Note.update({ _id: data.reply._id }, {
2018-04-04 18:40:34 +03:00
$inc: {
repliesCount: 1
}
});
// Fetch watchers
2018-04-07 20:30:37 +03:00
NoteWatching.find({
noteId: data.reply._id,
2018-04-04 18:40:34 +03:00
userId: { $ne: user._id },
// 削除されたドキュメントは除く
deletedAt: { $exists: false }
}, {
fields: {
userId: true
}
}).then(watchers => {
watchers.forEach(watcher => {
2018-06-21 05:35:28 +03:00
nm.push(watcher.userId, 'reply');
2018-04-04 18:40:34 +03:00
});
});
// この投稿をWatchする
2018-04-07 21:58:11 +03:00
if (isLocalUser(user) && user.settings.autoWatch !== false) {
2018-04-05 22:04:50 +03:00
watch(user._id, data.reply);
2018-04-04 18:40:34 +03:00
}
2018-07-04 07:21:30 +03:00
// 通知
2018-05-06 22:08:39 +03:00
nm.push(data.reply.userId, 'reply');
2018-04-04 18:40:34 +03:00
}
2018-04-07 20:30:37 +03:00
// If it is renote
if (data.renote) {
2018-04-04 18:40:34 +03:00
// Notify
2018-04-07 20:30:37 +03:00
const type = data.text ? 'quote' : 'renote';
2018-06-21 05:35:28 +03:00
nm.push(data.renote.userId, type);
2018-04-04 18:40:34 +03:00
// Fetch watchers
2018-04-07 20:30:37 +03:00
NoteWatching.find({
noteId: data.renote._id,
2018-04-08 00:55:26 +03:00
userId: { $ne: user._id }
2018-04-04 18:40:34 +03:00
}, {
fields: {
userId: true
}
}).then(watchers => {
watchers.forEach(watcher => {
2018-06-21 05:35:28 +03:00
nm.push(watcher.userId, type);
2018-04-04 18:40:34 +03:00
});
});
// この投稿をWatchする
2018-04-07 21:58:11 +03:00
if (isLocalUser(user) && user.settings.autoWatch !== false) {
2018-04-07 20:30:37 +03:00
watch(user._id, data.renote);
2018-04-04 18:40:34 +03:00
}
2018-04-07 20:30:37 +03:00
// If it is quote renote
2018-04-05 22:04:50 +03:00
if (data.text) {
2018-04-04 18:40:34 +03:00
// Add mention
2018-05-06 22:08:39 +03:00
nm.push(data.renote.userId, 'quote');
2018-04-04 18:40:34 +03:00
} else {
// Publish event
2018-04-07 20:30:37 +03:00
if (!user._id.equals(data.renote.userId)) {
event(data.renote.userId, 'renote', noteObj);
2018-04-04 18:40:34 +03:00
}
}
2018-05-12 21:08:00 +03:00
//#region TODO: これ重い
2018-04-07 20:30:37 +03:00
// 今までで同じ投稿をRenoteしているか
2018-05-12 21:16:31 +03:00
//const existRenote = await Note.findOne({
// userId: user._id,
// renoteId: data.renote._id,
// _id: {
// $ne: note._id
// }
//});
const existRenote: INote | null = null;
2018-05-12 21:08:00 +03:00
//#endregion
2018-04-04 17:12:35 +03:00
2018-04-07 20:30:37 +03:00
if (!existRenote) {
// Update renoteee status
Note.update({ _id: data.renote._id }, {
2018-04-04 18:40:34 +03:00
$inc: {
2018-04-07 20:30:37 +03:00
renoteCount: 1
2018-04-04 18:40:34 +03:00
}
});
}
}
2018-07-04 07:21:30 +03:00
// Register to search database
if (note.text && config.elasticsearch) {
es.index({
index: 'misskey',
type: 'note',
id: note._id.toString(),
body: {
text: note.text
}
});
}
2018-04-04 18:40:34 +03:00
});