misskey-awawa/src/models/user.ts

509 lines
13 KiB
TypeScript
Raw Normal View History

2017-09-07 19:13:01 +00:00
import * as mongo from 'mongodb';
2018-06-18 00:54:53 +00:00
const deepcopy = require('deepcopy');
2018-06-18 05:28:43 +00:00
const sequential = require('promise-sequential');
2018-02-01 23:06:01 +00:00
import rap from '@prezzemolo/rap';
2018-03-29 11:32:18 +00:00
import db from '../db/mongodb';
2018-04-17 13:33:27 +00:00
import Note, { pack as packNote, deleteNote } from './note';
2018-04-11 22:13:15 +00:00
import Following, { deleteFollowing } from './following';
2018-04-11 20:50:45 +00:00
import Mute, { deleteMute } from './mute';
2018-04-19 03:43:25 +00:00
import { getFriendIds } from '../server/api/common/get-friends';
2018-04-02 04:15:53 +00:00
import config from '../config';
2018-04-11 18:46:32 +00:00
import AccessToken, { deleteAccessToken } from './access-token';
import NoteWatching, { deleteNoteWatching } from './note-watching';
import Favorite, { deleteFavorite } from './favorite';
import NoteReaction, { deleteNoteReaction } from './note-reaction';
2018-04-11 19:05:03 +00:00
import MessagingMessage, { deleteMessagingMessage } from './messaging-message';
import MessagingHistory, { deleteMessagingHistory } from './messaging-history';
2018-04-11 19:22:06 +00:00
import DriveFile, { deleteDriveFile } from './drive-file';
import DriveFolder, { deleteDriveFolder } from './drive-folder';
2018-04-11 22:19:28 +00:00
import PollVote, { deletePollVote } from './poll-vote';
2018-04-11 22:25:46 +00:00
import FollowingLog, { deleteFollowingLog } from './following-log';
import FollowedLog, { deleteFollowedLog } from './followed-log';
2018-04-11 22:32:35 +00:00
import SwSubscription, { deleteSwSubscription } from './sw-subscription';
2018-04-14 21:34:55 +00:00
import Notification, { deleteNotification } from './notification';
2018-04-24 01:08:15 +00:00
import UserList, { deleteUserList } from './user-list';
2018-05-31 09:11:28 +00:00
import FollowRequest, { deleteFollowRequest } from './follow-request';
2017-01-17 00:12:33 +00:00
2018-02-01 23:06:01 +00:00
const User = db.get<IUser>('users');
2016-12-28 22:49:51 +00:00
2018-04-14 05:42:18 +00:00
User.createIndex('username');
User.createIndex('usernameLower');
2018-04-14 05:29:18 +00:00
User.createIndex(['username', 'host'], { unique: true });
User.createIndex(['usernameLower', 'host'], { unique: true });
2018-04-15 03:40:48 +00:00
User.createIndex('token', { sparse: true, unique: true });
2018-04-08 14:29:27 +00:00
User.createIndex('uri', { sparse: true, unique: true });
2016-12-28 22:49:51 +00:00
2018-02-01 23:06:01 +00:00
export default User;
2016-12-28 22:49:51 +00:00
2018-04-01 19:01:34 +00:00
type IUserBase = {
2017-09-07 19:13:01 +00:00
_id: mongo.ObjectID;
2018-03-29 05:48:47 +00:00
createdAt: Date;
2018-04-26 11:22:51 +00:00
deletedAt?: Date;
2018-03-29 05:48:47 +00:00
followersCount: number;
followingCount: number;
2018-04-05 16:36:34 +00:00
name?: string;
2018-04-07 17:30:37 +00:00
notesCount: number;
2017-09-07 19:13:01 +00:00
username: string;
2018-03-29 05:48:47 +00:00
usernameLower: string;
avatarId: mongo.ObjectID;
bannerId: mongo.ObjectID;
2018-06-09 23:41:57 +00:00
avatarUrl?: string;
bannerUrl?: string;
2018-06-06 20:14:37 +00:00
wallpaperId: mongo.ObjectID;
2018-07-27 22:52:48 +00:00
wallpaperUrl?: string;
2017-09-07 19:13:01 +00:00
data: any;
description: string;
2018-04-07 17:30:37 +00:00
pinnedNoteId: mongo.ObjectID;
2018-05-31 09:08:47 +00:00
/**
*
*/
2018-03-29 05:48:47 +00:00
isSuspended: boolean;
2018-05-31 09:08:47 +00:00
/**
*
*/
isLocked: boolean;
2018-05-31 16:12:02 +00:00
/**
*
*/
pendingReceivedFollowRequestsCount: number;
2018-04-02 02:14:45 +00:00
host: string;
2017-09-07 19:13:01 +00:00
};
2017-10-06 22:23:00 +00:00
2018-04-01 19:48:38 +00:00
export interface ILocalUser extends IUserBase {
host: null;
2018-04-07 18:58:11 +00:00
keypair: string;
email: string;
password: string;
token: string;
twitter: {
accessToken: string;
accessTokenSecret: string;
userId: string;
screenName: string;
2018-04-01 19:48:38 +00:00
};
2018-04-07 18:58:11 +00:00
line: {
userId: string;
};
profile: {
location: string;
birthday: string; // 'YYYY-MM-DD'
tags: string[];
};
lastUsedAt: Date;
isBot: boolean;
2018-05-21 02:08:08 +00:00
isCat: boolean;
2018-07-24 16:14:38 +00:00
isAdmin?: boolean;
isVerified?: boolean;
2018-04-07 18:58:11 +00:00
twoFactorSecret: string;
twoFactorEnabled: boolean;
2018-04-26 11:22:51 +00:00
twoFactorTempSecret?: string;
2018-04-07 18:58:11 +00:00
clientSettings: any;
settings: any;
2018-05-28 16:25:54 +00:00
hasUnreadNotification: boolean;
hasUnreadMessagingMessage: boolean;
2018-04-01 19:48:38 +00:00
}
export interface IRemoteUser extends IUserBase {
2018-04-07 18:58:11 +00:00
inbox: string;
2018-07-19 13:40:44 +00:00
sharedInbox?: string;
2018-05-16 08:06:12 +00:00
endpoints: string[];
2018-04-07 18:58:11 +00:00
uri: string;
2018-04-15 09:38:40 +00:00
url?: string;
2018-04-07 18:58:11 +00:00
publicKey: {
id: string;
publicKeyPem: string;
2018-04-01 19:48:38 +00:00
};
2018-04-17 06:37:18 +00:00
updatedAt: Date;
2018-08-20 16:03:58 +00:00
isAdmin: false;
2018-04-01 19:48:38 +00:00
}
2018-04-01 19:01:34 +00:00
2018-04-01 19:52:11 +00:00
export type IUser = ILocalUser | IRemoteUser;
2018-04-01 19:01:34 +00:00
export const isLocalUser = (user: any): user is ILocalUser =>
user.host === null;
export const isRemoteUser = (user: any): user is IRemoteUser =>
!isLocalUser(user);
2018-03-31 10:55:00 +00:00
2018-04-02 02:14:45 +00:00
//#region Validators
2018-04-01 19:52:11 +00:00
export function validateUsername(username: string): boolean {
return typeof username == 'string' && /^[a-zA-Z0-9_]{1,20}$/.test(username);
2018-04-01 19:52:11 +00:00
}
export function validatePassword(password: string): boolean {
return typeof password == 'string' && password != '';
}
2018-04-05 16:36:34 +00:00
export function isValidName(name?: string): boolean {
2018-05-16 08:04:39 +00:00
return name === null || (typeof name == 'string' && name.length < 50 && name.trim() != '');
2018-04-01 19:52:11 +00:00
}
export function isValidDescription(description: string): boolean {
return typeof description == 'string' && description.length < 500 && description.trim() != '';
}
export function isValidLocation(location: string): boolean {
return typeof location == 'string' && location.length < 50 && location.trim() != '';
}
export function isValidBirthday(birthday: string): boolean {
return typeof birthday == 'string' && /^([0-9]{4})\-([0-9]{2})-([0-9]{2})$/.test(birthday);
}
2018-04-02 02:14:45 +00:00
//#endregion
2018-04-01 19:52:11 +00:00
2018-04-11 18:46:32 +00:00
/**
* Userを物理削除します
*/
export async function deleteUser(user: string | mongo.ObjectID | IUser) {
2018-04-11 09:24:42 +00:00
let u: IUser;
// Populate
if (mongo.ObjectID.prototype.isPrototypeOf(user)) {
u = await User.findOne({
_id: user
});
} else if (typeof user === 'string') {
u = await User.findOne({
_id: new mongo.ObjectID(user)
});
} else {
u = user as IUser;
}
2018-04-15 02:57:33 +00:00
console.log(u == null ? `User: delete skipped ${user}` : `User: deleting ${u._id}`);
2018-04-11 09:24:42 +00:00
if (u == null) return;
2018-04-11 18:46:32 +00:00
// このユーザーのAccessTokenをすべて削除
await Promise.all((
await AccessToken.find({ userId: u._id })
).map(x => deleteAccessToken(x)));
// このユーザーのNoteをすべて削除
2018-05-26 04:25:10 +00:00
await sequential((
await Note.find({ userId: u._id })
).map(x => () => deleteNote(x)));
2018-04-11 18:46:32 +00:00
// このユーザーのNoteReactionをすべて削除
await Promise.all((
await NoteReaction.find({ userId: u._id })
).map(x => deleteNoteReaction(x)));
// このユーザーのNoteWatchingをすべて削除
await Promise.all((
await NoteWatching.find({ userId: u._id })
).map(x => deleteNoteWatching(x)));
2018-04-11 22:19:28 +00:00
// このユーザーのPollVoteをすべて削除
await Promise.all((
await PollVote.find({ userId: u._id })
).map(x => deletePollVote(x)));
2018-04-11 18:46:32 +00:00
// このユーザーのFavoriteをすべて削除
await Promise.all((
await Favorite.find({ userId: u._id })
).map(x => deleteFavorite(x)));
// このユーザーのMessageをすべて削除
2018-04-11 19:05:03 +00:00
await Promise.all((
await MessagingMessage.find({ userId: u._id })
).map(x => deleteMessagingMessage(x)));
2018-04-11 09:24:42 +00:00
2018-04-11 18:46:32 +00:00
// このユーザーへのMessageをすべて削除
2018-04-11 19:05:03 +00:00
await Promise.all((
await MessagingMessage.find({ recipientId: u._id })
).map(x => deleteMessagingMessage(x)));
// このユーザーの関わるMessagingHistoryをすべて削除
await Promise.all((
await MessagingHistory.find({ $or: [{ partnerId: u._id }, { userId: u._id }] })
).map(x => deleteMessagingHistory(x)));
2018-04-11 09:24:42 +00:00
2018-04-11 18:46:32 +00:00
// このユーザーのDriveFileをすべて削除
2018-04-11 19:22:06 +00:00
await Promise.all((
await DriveFile.find({ 'metadata.userId': u._id })
).map(x => deleteDriveFile(x)));
// このユーザーのDriveFolderをすべて削除
await Promise.all((
await DriveFolder.find({ userId: u._id })
).map(x => deleteDriveFolder(x)));
2018-04-11 09:24:42 +00:00
2018-04-11 20:50:45 +00:00
// このユーザーのMuteをすべて削除
await Promise.all((
await Mute.find({ muterId: u._id })
).map(x => deleteMute(x)));
// このユーザーへのMuteをすべて削除
await Promise.all((
await Mute.find({ muteeId: u._id })
).map(x => deleteMute(x)));
2018-04-11 18:46:32 +00:00
// このユーザーのFollowingをすべて削除
2018-04-11 22:13:15 +00:00
await Promise.all((
await Following.find({ followerId: u._id })
).map(x => deleteFollowing(x)));
2018-04-11 09:24:42 +00:00
2018-04-11 18:46:32 +00:00
// このユーザーへのFollowingをすべて削除
2018-04-11 22:13:15 +00:00
await Promise.all((
await Following.find({ followeeId: u._id })
).map(x => deleteFollowing(x)));
2018-04-11 09:24:42 +00:00
2018-05-31 09:08:47 +00:00
// このユーザーのFollowRequestをすべて削除
await Promise.all((
await FollowRequest.find({ followerId: u._id })
).map(x => deleteFollowRequest(x)));
// このユーザーへのFollowRequestをすべて削除
await Promise.all((
await FollowRequest.find({ followeeId: u._id })
).map(x => deleteFollowRequest(x)));
2018-04-11 20:50:45 +00:00
// このユーザーのFollowingLogをすべて削除
2018-04-11 22:25:46 +00:00
await Promise.all((
await FollowingLog.find({ userId: u._id })
).map(x => deleteFollowingLog(x)));
2018-04-11 20:50:45 +00:00
// このユーザーのFollowedLogをすべて削除
2018-04-11 22:25:46 +00:00
await Promise.all((
await FollowedLog.find({ userId: u._id })
).map(x => deleteFollowedLog(x)));
2018-04-11 20:50:45 +00:00
2018-04-11 22:32:35 +00:00
// このユーザーのSwSubscriptionをすべて削除
await Promise.all((
await SwSubscription.find({ userId: u._id })
).map(x => deleteSwSubscription(x)));
2018-04-14 21:34:55 +00:00
// このユーザーのNotificationをすべて削除
await Promise.all((
await Notification.find({ notifieeId: u._id })
).map(x => deleteNotification(x)));
// このユーザーが原因となったNotificationをすべて削除
await Promise.all((
await Notification.find({ notifierId: u._id })
).map(x => deleteNotification(x)));
2018-04-24 01:08:15 +00:00
// このユーザーのUserListをすべて削除
await Promise.all((
await UserList.find({ userId: u._id })
).map(x => deleteUserList(x)));
2018-04-24 05:12:19 +00:00
// このユーザーが入っているすべてのUserListからこのユーザーを削除
2018-04-24 01:08:15 +00:00
await Promise.all((
await UserList.find({ userIds: u._id })
).map(x =>
UserList.update({ _id: x._id }, {
$pull: { userIds: u._id }
})
));
2018-04-11 09:24:42 +00:00
// このユーザーを削除
2018-04-14 21:37:55 +00:00
await User.remove({
_id: u._id
});
2018-04-15 02:57:33 +00:00
console.log(`User: deleted ${u._id}`);
2018-04-11 09:24:42 +00:00
}
2018-02-01 23:06:01 +00:00
/**
* Pack a user for API response
*
* @param user target
* @param me? serializee
* @param options? serialize options
* @return Packed user
*/
export const pack = (
user: string | mongo.ObjectID | IUser,
me?: string | mongo.ObjectID | IUser,
options?: {
detail?: boolean,
includeSecrets?: boolean
}
) => new Promise<any>(async (resolve, reject) => {
const opts = Object.assign({
detail: false,
includeSecrets: false
}, options);
let _user: any;
const fields = opts.detail ? {
} : {
2018-04-07 18:58:11 +00:00
settings: false,
clientSettings: false,
profile: false,
keywords: false,
domains: false
2018-02-01 23:06:01 +00:00
};
// Populate the user if 'user' is ID
if (mongo.ObjectID.prototype.isPrototypeOf(user)) {
_user = await User.findOne({
_id: user
}, { fields });
} else if (typeof user === 'string') {
_user = await User.findOne({
_id: new mongo.ObjectID(user)
}, { fields });
} else {
_user = deepcopy(user);
}
2018-04-09 20:02:44 +00:00
// TODO: ここでエラーにするのではなくダミーのユーザーデータを返す
// SEE: https://github.com/syuilo/misskey/issues/1432
2018-02-01 23:06:01 +00:00
if (!_user) return reject('invalid user arg.');
// Me
const meId: mongo.ObjectID = me
? mongo.ObjectID.prototype.isPrototypeOf(me)
? me as mongo.ObjectID
: typeof me === 'string'
? new mongo.ObjectID(me)
: (me as IUser)._id
: null;
// Rename _id to id
_user.id = _user._id;
delete _user._id;
2018-04-07 18:58:11 +00:00
if (_user.host == null) {
2018-03-27 07:51:12 +00:00
// Remove private properties
2018-04-07 18:58:11 +00:00
delete _user.keypair;
delete _user.password;
delete _user.token;
delete _user.twoFactorTempSecret;
delete _user.twoFactorSecret;
2018-03-29 05:48:47 +00:00
delete _user.usernameLower;
2018-04-07 18:58:11 +00:00
if (_user.twitter) {
delete _user.twitter.accessToken;
delete _user.twitter.accessTokenSecret;
2018-03-27 07:51:12 +00:00
}
2018-04-07 18:58:11 +00:00
delete _user.line;
2018-03-27 07:51:12 +00:00
// Visible via only the official client
if (!opts.includeSecrets) {
2018-04-07 18:58:11 +00:00
delete _user.email;
delete _user.settings;
delete _user.clientSettings;
2018-03-27 07:51:12 +00:00
}
if (!opts.detail) {
2018-04-07 18:58:11 +00:00
delete _user.twoFactorEnabled;
2018-03-27 07:51:12 +00:00
}
2018-04-17 10:43:49 +00:00
} else {
delete _user.publicKey;
2018-02-01 23:06:01 +00:00
}
2018-06-09 23:34:46 +00:00
if (_user.avatarUrl == null) {
2018-07-27 22:52:48 +00:00
_user.avatarUrl = `${config.drive_url}/default-avatar.jpg`;
2018-02-01 23:06:01 +00:00
2018-07-27 22:52:48 +00:00
// 互換性のため
if (_user.avatarId) {
_user.avatarUrl = `${config.drive_url}/${_user.avatarId}`;
}
2018-06-09 23:34:46 +00:00
}
2018-02-01 23:06:01 +00:00
2018-07-27 22:52:48 +00:00
// 互換性のため
if (_user.bannerId && _user.bannerUrl == null) {
_user.bannerUrl = `${config.drive_url}/${_user.bannerId}`;
}
2018-06-06 20:14:37 +00:00
2018-02-01 23:06:01 +00:00
if (!meId || !meId.equals(_user.id) || !opts.detail) {
2018-03-29 05:48:47 +00:00
delete _user.avatarId;
delete _user.bannerId;
2018-05-28 16:25:54 +00:00
delete _user.hasUnreadMessagingMessage;
delete _user.hasUnreadNotification;
2018-02-01 23:06:01 +00:00
}
if (meId && !meId.equals(_user.id)) {
2018-05-31 15:42:37 +00:00
const [following1, following2, followReq1, followReq2, mute] = await Promise.all([
2018-04-19 03:43:25 +00:00
Following.findOne({
2018-03-29 05:48:47 +00:00
followerId: meId,
followeeId: _user.id
2018-04-19 03:43:25 +00:00
}),
Following.findOne({
2018-03-29 05:48:47 +00:00
followerId: _user.id,
followeeId: meId
2018-04-19 03:43:25 +00:00
}),
2018-05-31 15:42:37 +00:00
_user.isLocked ? FollowRequest.findOne({
followerId: meId,
followeeId: _user.id
}) : Promise.resolve(null),
FollowRequest.findOne({
followerId: _user.id,
followeeId: meId
}),
2018-04-19 03:43:25 +00:00
Mute.findOne({
muterId: meId,
muteeId: _user.id
})
]);
// Whether the user is following
_user.isFollowing = following1 !== null;
_user.isStalking = following1 && following1.stalk;
2018-05-31 15:42:37 +00:00
_user.hasPendingFollowRequestFromYou = followReq1 !== null;
_user.hasPendingFollowRequestToYou = followReq2 !== null;
2018-04-19 03:43:25 +00:00
// Whether the user is followed
_user.isFollowed = following2 !== null;
2018-02-01 23:06:01 +00:00
// Whether the user is muted
2018-04-19 03:43:25 +00:00
_user.isMuted = mute !== null;
2018-02-01 23:06:01 +00:00
}
if (opts.detail) {
2018-04-07 17:30:37 +00:00
if (_user.pinnedNoteId) {
// Populate pinned note
_user.pinnedNote = packNote(_user.pinnedNoteId, meId, {
2018-02-01 23:06:01 +00:00
detail: true
});
}
if (meId && !meId.equals(_user.id)) {
2018-04-19 03:43:25 +00:00
const myFollowingIds = await getFriendIds(meId);
2018-02-01 23:06:01 +00:00
// Get following you know count
2018-03-29 05:48:47 +00:00
_user.followingYouKnowCount = Following.count({
followeeId: { $in: myFollowingIds },
followerId: _user.id
2018-02-01 23:06:01 +00:00
});
// Get followers you know count
2018-03-29 05:48:47 +00:00
_user.followersYouKnowCount = Following.count({
followeeId: _user.id,
followerId: { $in: myFollowingIds }
2018-02-01 23:06:01 +00:00
});
}
}
// resolve promises in _user object
_user = await rap(_user);
resolve(_user);
});
/*
function img(url) {
return {
thumbnail: {
large: `${url}`,
medium: '',
small: ''
}
};
}
*/
2018-04-26 11:30:49 +00:00
export function getGhost(): Promise<ILocalUser> {
return User.findOne({ _id: new mongo.ObjectId(config.ghost) });
}