Sharkey/src/services/note/create.ts

651 lines
17 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';
import { publishMainStream, publishHomeTimelineStream, publishLocalTimelineStream, publishHybridTimelineStream, publishGlobalTimelineStream, publishUserListStream, publishHashtagStream } 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-10-23 01:04:00 +03:00
import DriveFile, { 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';
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-07-18 01:19:24 +03:00
import registerHashtag from '../register-hashtag';
2018-07-20 23:35:43 +03:00
import isQuote from '../../misc/is-quote';
2018-10-22 23:36:35 +03:00
import notesChart from '../../chart/notes';
import perUserNotesChart from '../../chart/per-user-notes';
import { erase } from '../../prelude/array';
2018-09-19 08:18:34 +03:00
import insertNoteUnread from './unread';
2018-10-24 00:17:55 +03:00
import registerInstance from '../register-instance';
import Instance from '../../models/instance';
2018-12-19 04:16:29 +02:00
import extractMentions from '../../misc/extract-mentions';
import extractEmojis from '../../misc/extract-emojis';
import extractHashtags from '../../misc/extract-hashtags';
2018-04-02 11:11:14 +03:00
2018-07-21 05:08:27 +03:00
type NotificationType = 'reply' | 'renote' | 'quote' | 'mention';
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-07-21 02:47:48 +03:00
private queue: Array<{
target: ILocalUser['_id'];
2018-07-21 05:08:27 +03:00
reason: NotificationType;
2018-07-21 02:47:48 +03:00
}>;
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-07-21 02:47:48 +03:00
this.queue = [];
2018-05-06 22:08:39 +03:00
}
2018-07-21 05:08:27 +03:00
public push(notifiee: ILocalUser['_id'], reason: NotificationType) {
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-07-21 02:47:48 +03:00
const exist = this.queue.find(x => x.target.equals(notifiee));
2018-05-06 22:08:39 +03:00
2018-07-21 02:47:48 +03:00
if (exist) {
// 「メンションされているかつ返信されている」場合は、メンションとしての通知ではなく返信としての通知にする
if (reason != 'mention') {
exist.reason = reason;
}
} else {
this.queue.push({
reason: reason,
target: notifiee
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-07-21 02:47:48 +03:00
public async deliver() {
for (const x of this.queue) {
2018-07-21 02:47:48 +03:00
// ミュート情報を取得
const mentioneeMutes = await Mute.find({
muterId: x.target
});
const mentioneesMutedUserIds = mentioneeMutes.map(m => m.muteeId.toString());
// 通知される側のユーザーが通知する側のユーザーをミュートしていない限りは通知する
if (!mentioneesMutedUserIds.includes(this.notifier._id.toString())) {
notify(x.target, this.notifier._id, x.reason, {
noteId: this.note._id
});
}
}
2018-07-21 02:47:48 +03:00
}
2018-05-06 22:08:39 +03:00
}
2018-07-21 00:59:53 +03:00
type Option = {
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-09-05 13:32:46 +03:00
files?: IDriveFile[];
2018-04-05 12:43:06 +03:00
geo?: any;
2018-04-04 21:21:11 +03:00
poll?: any;
2018-04-05 12:43:06 +03:00
viaMobile?: boolean;
localOnly?: boolean;
2018-04-04 21:21:11 +03:00
cw?: string;
visibility?: string;
2018-04-28 22:30:51 +03:00
visibleUsers?: IUser[];
apMentions?: IUser[];
apHashtags?: string[];
apEmojis?: string[];
2018-04-04 18:50:57 +03:00
uri?: string;
app?: IApp;
2018-07-21 00:59:53 +03:00
};
export default async (user: IUser, data: Option, silent = false) => new Promise<INote>(async (res, rej) => {
2018-08-14 02:16:21 +03:00
const isFirstNote = user.notesCount === 0;
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;
if (data.localOnly == null) data.localOnly = false;
2018-04-04 21:21:11 +03:00
2018-04-28 22:30:51 +03:00
if (data.visibleUsers) {
2018-09-06 18:02:55 +03:00
data.visibleUsers = erase(null, data.visibleUsers);
2018-04-28 22:30:51 +03:00
}
2018-09-09 19:54:08 +03:00
// リプライ対象が削除された投稿だったらreject
if (data.reply && data.reply.deletedAt != null) {
return rej('Reply target has been deleted');
}
2018-09-09 19:54:08 +03:00
// Renote対象が削除された投稿だったらreject
if (data.renote && data.renote.deletedAt != null) {
return rej('Renote target has been deleted');
}
2018-09-24 10:02:01 +03:00
// Renote対象が「ホームまたは全体」以外の公開範囲ならreject
if (data.renote && data.renote.visibility != 'public' && data.renote.visibility != 'home') {
return rej('Renote target is not public or home');
2018-09-24 10:02:01 +03:00
}
// ローカルのみをRenoteしたらローカルのみにする
if (data.renote && data.renote.localOnly) {
data.localOnly = true;
}
// ローカルのみにリプライしたらローカルのみにする
if (data.reply && data.reply.localOnly) {
data.localOnly = true;
}
2018-08-03 19:09:00 +03:00
if (data.text) {
data.text = data.text.trim();
}
let tags = data.apHashtags;
let emojis = data.apEmojis;
let mentionedUsers = data.apMentions;
2018-04-02 11:11:14 +03:00
// Parse MFM if needed
if (!tags || !emojis || !mentionedUsers) {
const tokens = data.text ? parse(data.text) : [];
const cwTokens = data.cw ? parse(data.cw) : [];
const combinedTokens = tokens.concat(cwTokens);
2018-04-05 09:50:52 +03:00
tags = data.apHashtags || extractHashtags(combinedTokens);
2018-12-08 03:20:43 +02:00
emojis = data.apEmojis || extractEmojis(combinedTokens);
mentionedUsers = data.apMentions || await extractMentionedUsers(user, combinedTokens);
}
2018-07-20 23:35:43 +03:00
2018-12-19 19:20:56 +02:00
// MongoDBのインデックス対象は128文字以上にできない
tags = tags.filter(tag => tag.length <= 100);
if (data.reply && !user._id.equals(data.reply.userId) && !mentionedUsers.some(u => u._id.equals(data.reply.userId))) {
mentionedUsers.push(await User.findOne({ _id: data.reply.userId }));
}
if (data.visibility == 'specified') {
for (const u of data.visibleUsers) {
if (!mentionedUsers.some(x => x._id.equals(u._id))) {
mentionedUsers.push(u);
}
}
for (const u of mentionedUsers) {
if (!data.visibleUsers.some(x => x._id.equals(u._id))) {
data.visibleUsers.push(u);
}
}
}
const note = await insertNote(user, data, tags, emojis, mentionedUsers);
2018-07-20 23:35:43 +03:00
2018-07-21 00:59:53 +03:00
res(note);
2018-04-18 08:53:17 +03:00
2018-07-21 00:59:53 +03:00
if (note == null) {
return;
2018-04-18 08:53:17 +03:00
}
2018-04-02 11:11:14 +03:00
2018-08-18 17:56:44 +03:00
// 統計を更新
2018-10-22 23:36:35 +03:00
notesChart.update(note, true);
perUserNotesChart.update(user, note, true);
2018-08-18 17:56:44 +03:00
2018-10-24 00:17:55 +03:00
// Register host
if (isRemoteUser(user)) {
registerInstance(user.host).then(i => {
Instance.update({ _id: i._id }, {
$inc: {
notesCount: 1
}
});
// TODO
//perInstanceChart.newNote();
});
}
2018-07-18 01:19:24 +03:00
// ハッシュタグ登録
for (const tag of tags) registerHashtag(user, tag);
2018-07-18 01:19:24 +03:00
2018-10-23 01:04:00 +03:00
// ファイルが添付されていた場合ドライブのファイルの「このファイルが添付された投稿一覧」プロパティにこの投稿を追加
if (data.files) {
for (const file of data.files) {
2018-10-23 01:04:00 +03:00
DriveFile.update({ _id: file._id }, {
$push: {
'metadata.attachedNoteIds': note._id
}
});
}
2018-10-23 01:04:00 +03:00
}
2018-07-20 23:35:43 +03:00
// Increment notes count
incNotesCount(user);
2018-06-16 04:40:53 +03:00
// Increment notes count (user)
2018-07-20 23:35:43 +03:00
incNotesCountOfUser(user);
2018-04-04 17:12:35 +03:00
2018-09-19 08:18:34 +03:00
// 未読通知を作成
if (data.visibility == 'specified') {
for (const u of data.visibleUsers) {
2018-09-19 08:18:34 +03:00
insertNoteUnread(u, note, true);
}
2018-09-19 08:18:34 +03:00
} else {
for (const u of mentionedUsers) {
2018-09-19 08:18:34 +03:00
insertNoteUnread(u, note, false);
}
2018-09-19 08:18:34 +03:00
}
2018-05-28 18:36:52 +03:00
if (data.reply) {
2018-07-20 23:35:43 +03:00
saveReply(data.reply, note);
2018-05-28 18:36:52 +03:00
}
2018-07-21 01:05:51 +03:00
if (data.renote) {
incRenoteCount(data.renote);
}
2018-07-20 23:35:43 +03:00
if (isQuote(note)) {
saveQuote(data.renote, note);
2018-05-28 18:36:52 +03:00
}
2018-07-20 23:35:43 +03:00
// Pack the note
2018-04-07 20:30:37 +03:00
const noteObj = await pack(note);
2018-04-04 17:12:35 +03:00
2018-08-14 02:16:21 +03:00
if (isFirstNote) {
noteObj.isFirstNote = true;
}
if (tags.length > 0) {
publishHashtagStream(noteObj);
}
2018-07-20 23:35:43 +03:00
const nm = new NotificationManager(user, note);
2018-07-21 02:47:48 +03:00
const nmRelatedPromises = [];
2018-06-12 23:40:12 +03:00
createMentionedEvents(mentionedUsers, note, nm);
2018-06-12 23:40:12 +03:00
2018-07-21 01:05:51 +03:00
const noteActivity = await renderActivity(data, note);
2018-12-28 19:55:46 +02:00
if (isLocalUser(user)) {
2018-07-20 23:35:43 +03:00
deliverNoteToMentionedRemoteUsers(mentionedUsers, user, noteActivity);
2018-06-12 23:40:12 +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
// Fetch watchers
2018-07-21 02:47:48 +03:00
nmRelatedPromises.push(notifyToWatchersOfReplyee(data.reply, user, nm));
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-08-02 03:37:13 +03:00
if (isLocalUser(data.reply._user)) {
nm.push(data.reply.userId, 'reply');
publishMainStream(data.reply.userId, 'reply', noteObj);
2018-08-02 03:37:13 +03:00
}
2018-04-04 18:40:34 +03:00
}
2018-04-07 20:30:37 +03:00
// If it is renote
if (data.renote) {
const type = data.text ? 'quote' : 'renote';
2018-08-02 03:37:13 +03:00
// Notify
if (isLocalUser(data.renote._user)) {
nm.push(data.renote.userId, type);
}
2018-04-04 18:40:34 +03:00
// Fetch watchers
2018-07-21 02:47:48 +03:00
nmRelatedPromises.push(notifyToWatchersOfRenotee(data.renote, user, nm, 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-08-02 03:37:13 +03:00
// Publish event
2018-08-11 15:34:12 +03:00
if (!user._id.equals(data.renote.userId) && isLocalUser(data.renote._user)) {
publishMainStream(data.renote.userId, 'renote', noteObj);
2018-04-04 18:40:34 +03:00
}
2018-07-21 01:05:51 +03:00
}
2018-04-04 18:40:34 +03:00
2018-07-21 01:05:51 +03:00
if (!silent) {
publish(user, note, noteObj, data.reply, data.renote, data.visibleUsers, noteActivity);
2018-04-04 18:40:34 +03:00
}
2018-07-04 07:21:30 +03:00
2018-07-21 02:47:48 +03:00
Promise.all(nmRelatedPromises).then(() => {
nm.deliver();
});
2018-07-04 07:21:30 +03:00
// Register to search database
2018-07-20 23:35:43 +03:00
index(note);
});
2018-07-21 01:05:51 +03:00
async function renderActivity(data: Option, note: INote) {
if (data.localOnly) return null;
2018-09-08 20:59:14 +03:00
const content = data.renote && data.text == null && data.poll == null && (data.files == null || data.files.length == 0)
? renderAnnounce(data.renote.uri ? data.renote.uri : `${config.url}/notes/${data.renote._id}`, note)
2018-08-25 08:12:44 +03:00
: renderCreate(await renderNote(note, false), note);
2018-07-21 01:05:51 +03:00
return packAp(content);
}
function incRenoteCount(renote: INote) {
Note.update({ _id: renote._id }, {
$inc: {
2018-10-25 01:04:15 +03:00
renoteCount: 1,
score: 1
2018-07-21 01:05:51 +03:00
}
});
}
2018-07-21 00:59:53 +03:00
async function publish(user: IUser, note: INote, noteObj: any, reply: INote, renote: INote, visibleUsers: IUser[], noteActivity: any) {
if (isLocalUser(user)) {
// 投稿がリプライかつ投稿者がローカルユーザーかつリプライ先の投稿の投稿者がリモートユーザーなら配送
if (reply && isRemoteUser(reply._user)) {
deliver(user, noteActivity, reply._user.inbox);
}
// 投稿がRenoteかつ投稿者がローカルユーザーかつRenote元の投稿の投稿者がリモートユーザーなら配送
if (renote && isRemoteUser(renote._user)) {
deliver(user, noteActivity, renote._user.inbox);
}
2018-12-28 19:55:46 +02:00
if (['followers', 'specified'].includes(note.visibility)) {
2018-09-09 20:07:13 +03:00
const detailPackedNote = await pack(note, user, {
2018-07-21 00:59:53 +03:00
detail: true
2018-09-09 20:07:13 +03:00
});
// Publish event to myself's stream
publishHomeTimelineStream(note.userId, detailPackedNote);
2018-09-09 20:07:13 +03:00
publishHybridTimelineStream(note.userId, detailPackedNote);
2018-07-21 00:59:53 +03:00
} else {
// Publish event to myself's stream
publishHomeTimelineStream(note.userId, noteObj);
2018-07-21 00:59:53 +03:00
// Publish note to local and hybrid timeline stream
if (note.visibility != 'home') {
publishLocalTimelineStream(noteObj);
}
if (note.visibility == 'public') {
publishHybridTimelineStream(null, noteObj);
2018-09-09 23:45:29 +03:00
} else {
// Publish event to myself's stream
publishHybridTimelineStream(note.userId, noteObj);
2018-07-21 00:59:53 +03:00
}
}
}
// Publish note to global timeline stream
if (note.visibility == 'public' && note.replyId == null) {
publishGlobalTimelineStream(noteObj);
}
if (['public', 'home', 'followers'].includes(note.visibility)) {
// フォロワーに配信
publishToFollowers(note, user, noteActivity);
2018-07-21 00:59:53 +03:00
}
// リストに配信
publishToUserLists(note, noteObj);
}
async function insertNote(user: IUser, data: Option, tags: string[], emojis: string[], mentionedUsers: IUser[]) {
2018-07-21 00:59:53 +03:00
const insert: any = {
createdAt: data.createdAt,
2018-09-05 13:32:46 +03:00
fileIds: data.files ? data.files.map(file => file._id) : [],
2018-07-21 00:59:53 +03:00
replyId: data.reply ? data.reply._id : null,
renoteId: data.renote ? data.renote._id : null,
text: data.text,
poll: data.poll,
cw: data.cw == null ? null : data.cw,
tags,
tagsLower: tags.map(tag => tag.toLowerCase()),
emojis,
2018-07-21 00:59:53 +03:00
userId: user._id,
viaMobile: data.viaMobile,
localOnly: data.localOnly,
2018-07-21 00:59:53 +03:00
geo: data.geo || null,
appId: data.app ? data.app._id : null,
visibility: data.visibility,
visibleUserIds: data.visibility == 'specified'
? data.visibleUsers
? data.visibleUsers.map(u => u._id)
: []
: [],
// 以下非正規化データ
2018-08-16 18:05:57 +03:00
_reply: data.reply ? {
userId: data.reply.userId,
user: {
host: data.reply._user.host
}
} : null,
_renote: data.renote ? {
userId: data.renote.userId,
user: {
2018-08-16 18:07:23 +03:00
host: data.renote._user.host
2018-08-16 18:05:57 +03:00
}
} : null,
2018-07-21 00:59:53 +03:00
_user: {
host: user.host,
inbox: isRemoteUser(user) ? user.inbox : undefined
2018-09-05 13:32:46 +03:00
},
_files: data.files ? data.files : []
2018-07-21 00:59:53 +03:00
};
if (data.uri != null) insert.uri = data.uri;
// Append mentions data
if (mentionedUsers.length > 0) {
insert.mentions = mentionedUsers.map(u => u._id);
insert.mentionedRemoteUsers = mentionedUsers.filter(u => isRemoteUser(u)).map(u => ({
uri: (u as IRemoteUser).uri,
username: u.username,
host: u.host
}));
}
// 投稿を作成
try {
return await Note.insert(insert);
} catch (e) {
// duplicate key error
if (e.code === 11000) {
return null;
}
console.error(e);
throw 'something happened';
}
}
2018-07-20 23:35:43 +03:00
function index(note: INote) {
if (note.text == null || config.elasticsearch == null) return;
es.index({
index: 'misskey',
type: 'note',
id: note._id.toString(),
body: {
text: note.text
}
});
}
2018-07-21 05:08:27 +03:00
async function notifyToWatchersOfRenotee(renote: INote, user: IUser, nm: NotificationManager, type: NotificationType) {
2018-07-20 23:35:43 +03:00
const watchers = await NoteWatching.find({
noteId: renote._id,
userId: { $ne: user._id }
}, {
2018-07-23 07:56:25 +03:00
fields: {
userId: true
}
});
2018-07-20 23:35:43 +03:00
for (const watcher of watchers) {
2018-07-20 23:35:43 +03:00
nm.push(watcher.userId, type);
}
2018-07-20 23:35:43 +03:00
}
async function notifyToWatchersOfReplyee(reply: INote, user: IUser, nm: NotificationManager) {
const watchers = await NoteWatching.find({
noteId: reply._id,
userId: { $ne: user._id }
}, {
2018-07-23 07:56:25 +03:00
fields: {
userId: true
}
});
2018-07-20 23:35:43 +03:00
for (const watcher of watchers) {
2018-07-20 23:35:43 +03:00
nm.push(watcher.userId, 'reply');
}
2018-07-20 23:35:43 +03:00
}
async function publishToUserLists(note: INote, noteObj: any) {
const lists = await UserList.find({
userIds: note.userId
});
for (const list of lists) {
2018-07-20 23:35:43 +03:00
publishUserListStream(list._id, 'note', noteObj);
}
2018-07-20 23:35:43 +03:00
}
async function publishToFollowers(note: INote, user: IUser, noteActivity: any) {
2018-09-09 20:43:16 +03:00
const detailPackedNote = await pack(note, null, {
detail: true,
skipHide: true
});
2018-07-20 23:35:43 +03:00
const followers = await Following.find({
followeeId: note.userId
});
2018-07-21 13:33:56 +03:00
const queue: string[] = [];
for (const following of followers) {
2018-07-20 23:35:43 +03:00
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-07-04 07:21:30 +03:00
}
2018-07-20 23:35:43 +03:00
// Publish event to followers stream
publishHomeTimelineStream(following.followerId, detailPackedNote);
2018-07-20 23:35:43 +03:00
if (isRemoteUser(user) || note.visibility != 'public') {
2018-09-09 20:43:16 +03:00
publishHybridTimelineStream(following.followerId, detailPackedNote);
2018-07-20 23:35:43 +03:00
}
} else {
// フォロワーがリモートユーザーかつ投稿者がローカルユーザーなら投稿を配信
if (isLocalUser(user)) {
2018-07-21 13:33:56 +03:00
const inbox = follower.sharedInbox || follower.inbox;
if (!queue.includes(inbox)) queue.push(inbox);
2018-07-20 23:35:43 +03:00
}
}
}
2018-07-21 13:33:56 +03:00
for (const inbox of queue) {
2018-07-23 07:56:25 +03:00
deliver(user as any, noteActivity, inbox);
}
2018-07-20 23:35:43 +03:00
}
function deliverNoteToMentionedRemoteUsers(mentionedUsers: IUser[], user: ILocalUser, noteActivity: any) {
for (const u of mentionedUsers.filter(u => isRemoteUser(u))) {
2018-07-20 23:35:43 +03:00
deliver(user, noteActivity, (u as IRemoteUser).inbox);
}
2018-07-20 23:35:43 +03:00
}
async function createMentionedEvents(mentionedUsers: IUser[], note: INote, nm: NotificationManager) {
for (const u of mentionedUsers.filter(u => isLocalUser(u))) {
const detailPackedNote = await pack(note, u, {
detail: true
});
publishMainStream(u._id, 'mention', detailPackedNote);
2018-07-20 23:35:43 +03:00
// Create notification
nm.push(u._id, 'mention');
}
2018-07-20 23:35:43 +03:00
}
function saveQuote(renote: INote, note: INote) {
Note.update({ _id: renote._id }, {
$push: {
_quoteIds: note._id
2018-10-25 02:42:07 +03:00
}
2018-07-20 23:35:43 +03:00
});
}
function saveReply(reply: INote, note: INote) {
Note.update({ _id: reply._id }, {
$inc: {
repliesCount: 1
}
});
}
function incNotesCountOfUser(user: IUser) {
User.update({ _id: user._id }, {
$set: {
updatedAt: new Date()
},
2018-07-20 23:35:43 +03:00
$inc: {
notesCount: 1
}
});
}
function incNotesCount(user: IUser) {
if (isLocalUser(user)) {
Meta.update({}, {
$inc: {
'stats.notesCount': 1,
'stats.originalNotesCount': 1
}
}, { upsert: true });
} else {
Meta.update({}, {
$inc: {
'stats.notesCount': 1
}
}, { upsert: true });
2018-07-04 07:21:30 +03:00
}
2018-07-20 23:35:43 +03:00
}
async function extractMentionedUsers(user: IUser, tokens: ReturnType<typeof parse>): Promise<IUser[]> {
2018-07-20 23:35:43 +03:00
if (tokens == null) return [];
2018-12-19 04:16:29 +02:00
const mentions = extractMentions(tokens);
2018-07-21 05:06:01 +03:00
2018-10-30 14:55:16 +02:00
let mentionedUsers =
erase(null, await Promise.all(mentions.map(async m => {
2018-07-21 05:06:01 +03:00
try {
return await resolveUser(m.username, m.host ? m.host : user.host);
2018-07-21 05:06:01 +03:00
} catch (e) {
return null;
}
2018-10-30 14:55:16 +02:00
})));
// Drop duplicate users
mentionedUsers = mentionedUsers.filter((u, i, self) =>
i === self.findIndex(u2 => u._id.equals(u2._id))
2018-09-06 18:10:03 +03:00
);
2018-07-20 23:35:43 +03:00
return mentionedUsers;
}