monkeeShark/src/remote/activitypub/models/person.ts

390 lines
11 KiB
TypeScript
Raw Normal View History

2018-04-17 13:20:25 +00:00
import * as mongo from 'mongodb';
2018-04-08 19:08:56 +00:00
import { toUnicode } from 'punycode';
import * as debug from 'debug';
import config from '../../../config';
import User, { validateUsername, isValidName, IUser, IRemoteUser, isRemoteUser } from '../../../models/user';
2018-04-08 19:08:56 +00:00
import Resolver from '../resolver';
import { resolveImage } from './image';
import { isCollectionOrOrderedCollection, isCollection, IPerson } from '../type';
2018-06-09 23:34:46 +00:00
import { IDriveFile } from '../../../models/drive-file';
2018-06-16 01:40:53 +00:00
import Meta from '../../../models/meta';
import htmlToMFM from '../../../mfm/html-to-mfm';
2018-10-22 20:36:35 +00:00
import usersChart from '../../../chart/users';
2018-08-29 07:10:03 +00:00
import { URL } from 'url';
import { resolveNote } from './note';
2018-10-23 21:17:55 +00:00
import registerInstance from '../../../services/register-instance';
import Instance from '../../../models/instance';
2018-10-31 13:35:02 +00:00
import getDriveFileUrl from '../../../misc/get-drive-file-url';
2018-04-08 19:08:56 +00:00
const log = debug('misskey:activitypub');
2018-08-29 07:10:03 +00:00
/**
* Validate Person object
* @param x Fetched person object
* @param uri Fetch target URI
*/
function validatePerson(x: any, uri: string) {
const expectHost = toUnicode(new URL(uri).hostname.toLowerCase());
2018-07-26 08:13:55 +00:00
if (x == null) {
return new Error('invalid person: object is null');
}
if (x.type != 'Person' && x.type != 'Service') {
return new Error(`invalid person: object is not a person or service '${x.type}'`);
}
if (typeof x.preferredUsername !== 'string') {
return new Error('invalid person: preferredUsername is not a string');
}
if (typeof x.inbox !== 'string') {
return new Error('invalid person: inbox is not a string');
}
if (!validateUsername(x.preferredUsername, true)) {
2018-07-26 08:13:55 +00:00
return new Error('invalid person: invalid username');
}
if (!isValidName(x.name == '' ? null : x.name)) {
return new Error('invalid person: invalid name');
}
2018-08-29 07:10:03 +00:00
if (typeof x.id !== 'string') {
return new Error('invalid person: id is not a string');
}
const idHost = toUnicode(new URL(x.id).hostname.toLowerCase());
if (idHost !== expectHost) {
return new Error('invalid person: id has different host');
}
if (typeof x.publicKey.id !== 'string') {
return new Error('invalid person: publicKey.id is not a string');
}
const publicKeyIdHost = toUnicode(new URL(x.publicKey.id).hostname.toLowerCase());
if (publicKeyIdHost !== expectHost) {
return new Error('invalid person: publicKey.id has different host');
}
2018-07-26 08:13:55 +00:00
return null;
}
2018-04-08 19:08:56 +00:00
/**
* Personをフェッチします
*
* Misskeyに対象のPersonが登録されていればそれを返します
*/
2018-08-29 07:10:03 +00:00
export async function fetchPerson(uri: string, resolver?: Resolver): Promise<IUser> {
if (typeof uri !== 'string') throw 'uri is not string';
2018-04-08 19:08:56 +00:00
// URIがこのサーバーを指しているならデータベースからフェッチ
if (uri.startsWith(config.url + '/')) {
2018-04-17 13:20:25 +00:00
const id = new mongo.ObjectID(uri.split('/').pop());
return await User.findOne({ _id: id });
2018-04-08 19:08:56 +00:00
}
//#region このサーバーに既に登録されていたらそれを返す
const exist = await User.findOne({ uri });
if (exist) {
return exist;
}
//#endregion
return null;
}
/**
* Personを作成します
*/
2018-08-29 07:10:03 +00:00
export async function createPerson(uri: string, resolver?: Resolver): Promise<IUser> {
if (typeof uri !== 'string') throw 'uri is not string';
2018-04-08 19:08:56 +00:00
if (resolver == null) resolver = new Resolver();
2018-08-29 07:10:03 +00:00
const object = await resolver.resolve(uri) as any;
2018-04-08 19:08:56 +00:00
2018-08-29 07:10:03 +00:00
const err = validatePerson(object, uri);
2018-06-23 10:16:50 +00:00
2018-07-26 08:13:55 +00:00
if (err) {
throw err;
2018-04-08 19:08:56 +00:00
}
const person: IPerson = object;
log(`Creating the Person: ${person.id}`);
2018-08-29 07:10:03 +00:00
const [followersCount = 0, followingCount = 0, notesCount = 0] = await Promise.all([
2018-04-08 19:08:56 +00:00
resolver.resolve(person.followers).then(
resolved => isCollectionOrOrderedCollection(resolved) ? resolved.totalItems : undefined,
() => undefined
),
resolver.resolve(person.following).then(
resolved => isCollectionOrOrderedCollection(resolved) ? resolved.totalItems : undefined,
() => undefined
),
resolver.resolve(person.outbox).then(
resolved => isCollectionOrOrderedCollection(resolved) ? resolved.totalItems : undefined,
() => undefined
2018-08-29 07:10:03 +00:00
)
2018-04-08 19:08:56 +00:00
]);
2018-08-29 07:10:03 +00:00
const host = toUnicode(new URL(object.id).hostname.toLowerCase());
2018-04-08 19:08:56 +00:00
2018-06-23 10:18:14 +00:00
const isBot = object.type == 'Service';
2018-04-08 19:08:56 +00:00
// Create user
2018-04-19 09:58:57 +00:00
let user: IRemoteUser;
try {
user = await User.insert({
avatarId: null,
bannerId: null,
createdAt: Date.parse(person.published) || null,
lastFetchedAt: new Date(),
description: htmlToMFM(person.summary),
2018-04-19 09:58:57 +00:00
followersCount,
followingCount,
notesCount,
name: person.name,
2018-05-31 09:34:15 +00:00
isLocked: person.manuallyApprovesFollowers,
2018-04-19 09:58:57 +00:00
username: person.preferredUsername,
usernameLower: person.preferredUsername.toLowerCase(),
host,
publicKey: {
id: person.publicKey.id,
publicKeyPem: person.publicKey.publicKeyPem
},
inbox: person.inbox,
2018-07-19 13:40:44 +00:00
sharedInbox: person.sharedInbox,
featured: person.featured,
2018-05-16 08:06:12 +00:00
endpoints: person.endpoints,
2018-04-19 09:58:57 +00:00
uri: person.id,
2018-06-23 10:18:14 +00:00
url: person.url,
2018-08-22 00:16:52 +00:00
isBot: isBot,
2018-12-02 10:35:41 +00:00
isCat: (person as any).isCat === true
2018-04-19 09:58:57 +00:00
}) as IRemoteUser;
} catch (e) {
// duplicate key error
if (e.code === 11000) {
throw new Error('already registered');
}
console.error(e);
throw e;
}
2018-04-08 19:08:56 +00:00
2018-10-23 21:17:55 +00:00
// Register host
registerInstance(host).then(i => {
Instance.update({ _id: i._id }, {
$inc: {
usersCount: 1
}
});
// TODO
//perInstanceChart.newUser();
});
2018-06-16 01:40:53 +00:00
//#region Increment users count
Meta.update({}, {
$inc: {
'stats.usersCount': 1
}
}, { upsert: true });
2018-08-18 20:26:34 +00:00
2018-10-22 20:36:35 +00:00
usersChart.update(user, true);
2018-06-16 01:40:53 +00:00
//#endregion
2018-04-08 19:08:56 +00:00
//#region アイコンとヘッダー画像をフェッチ
2018-06-09 23:41:57 +00:00
const [avatar, banner] = (await Promise.all<IDriveFile>([
2018-04-08 19:08:56 +00:00
person.icon,
person.image
].map(img =>
img == null
? Promise.resolve(null)
: resolveImage(user, img).catch(() => null)
2018-06-09 23:41:57 +00:00
)));
const avatarId = avatar ? avatar._id : null;
const bannerId = banner ? banner._id : null;
const avatarUrl = getDriveFileUrl(avatar, true);
const bannerUrl = getDriveFileUrl(banner, false);
const avatarColor = avatar && avatar.metadata.properties.avgColor ? avatar.metadata.properties.avgColor : null;
const bannerColor = banner && avatar.metadata.properties.avgColor ? banner.metadata.properties.avgColor : null;
2018-06-09 23:41:57 +00:00
await User.update({ _id: user._id }, {
$set: {
avatarId,
bannerId,
avatarUrl,
bannerUrl,
avatarColor,
bannerColor
2018-06-09 23:41:57 +00:00
}
});
2018-04-08 19:08:56 +00:00
user.avatarId = avatarId;
user.bannerId = bannerId;
2018-06-09 23:41:57 +00:00
user.avatarUrl = avatarUrl;
user.bannerUrl = bannerUrl;
user.avatarColor = avatarColor;
user.bannerColor = bannerColor;
2018-04-08 19:08:56 +00:00
//#endregion
await updateFeatured(user._id).catch(err => console.log(err));
2018-10-23 21:17:55 +00:00
2018-04-08 19:08:56 +00:00
return user;
}
2018-04-17 06:30:58 +00:00
/**
* Personの情報を更新します
* Misskeyに対象のPersonが登録されていなければ無視します
2018-09-01 08:53:38 +00:00
* @param uri URI of Person
* @param resolver Resolver
* @param hint Hint of Person object (Personの場合Remote resolveをせずに更新に利用します)
2018-04-17 06:30:58 +00:00
*/
2018-09-01 08:53:38 +00:00
export async function updatePerson(uri: string, resolver?: Resolver, hint?: object): Promise<void> {
2018-08-29 07:10:03 +00:00
if (typeof uri !== 'string') throw 'uri is not string';
2018-04-17 06:30:58 +00:00
// URIがこのサーバーを指しているならスキップ
if (uri.startsWith(config.url + '/')) {
return;
}
//#region このサーバーに既に登録されているか
const exist = await User.findOne({ uri }) as IRemoteUser;
if (exist == null) {
return;
}
//#endregion
if (resolver == null) resolver = new Resolver();
2018-09-01 08:53:38 +00:00
const object = hint || await resolver.resolve(uri) as any;
2018-04-17 06:30:58 +00:00
2018-08-29 07:10:03 +00:00
const err = validatePerson(object, uri);
2018-07-26 08:13:55 +00:00
if (err) {
throw err;
2018-04-17 06:30:58 +00:00
}
const person: IPerson = object;
log(`Updating the Person: ${person.id}`);
const [followersCount = 0, followingCount = 0, notesCount = 0] = await Promise.all([
resolver.resolve(person.followers).then(
resolved => isCollectionOrOrderedCollection(resolved) ? resolved.totalItems : undefined,
() => undefined
),
resolver.resolve(person.following).then(
resolved => isCollectionOrOrderedCollection(resolved) ? resolved.totalItems : undefined,
() => undefined
),
resolver.resolve(person.outbox).then(
resolved => isCollectionOrOrderedCollection(resolved) ? resolved.totalItems : undefined,
() => undefined
)
]);
// アイコンとヘッダー画像をフェッチ
2018-06-09 23:34:46 +00:00
const [avatar, banner] = (await Promise.all<IDriveFile>([
2018-04-17 06:30:58 +00:00
person.icon,
person.image
].map(img =>
img == null
? Promise.resolve(null)
: resolveImage(exist, img).catch(() => null)
2018-06-09 23:34:46 +00:00
)));
2018-04-17 06:30:58 +00:00
// Update user
await User.update({ _id: exist._id }, {
$set: {
lastFetchedAt: new Date(),
2018-07-19 13:40:44 +00:00
inbox: person.inbox,
sharedInbox: person.sharedInbox,
featured: person.featured,
2018-06-09 23:34:46 +00:00
avatarId: avatar ? avatar._id : null,
bannerId: banner ? banner._id : null,
2018-10-31 13:35:02 +00:00
avatarUrl: getDriveFileUrl(avatar, true),
bannerUrl: getDriveFileUrl(banner, false),
avatarColor: avatar && avatar.metadata.properties.avgColor ? avatar.metadata.properties.avgColor : null,
bannerColor: banner && banner.metadata.properties.avgColor ? banner.metadata.properties.avgColor : null,
description: htmlToMFM(person.summary),
2018-04-17 06:30:58 +00:00
followersCount,
followingCount,
notesCount,
name: person.name,
2018-05-16 08:06:12 +00:00
url: person.url,
2018-08-22 00:16:52 +00:00
endpoints: person.endpoints,
2018-09-01 07:46:41 +00:00
isBot: object.type == 'Service',
isCat: (person as any).isCat === true,
isLocked: person.manuallyApprovesFollowers,
createdAt: Date.parse(person.published) || null,
publicKey: {
id: person.publicKey.id,
publicKeyPem: person.publicKey.publicKeyPem
},
2018-04-17 06:30:58 +00:00
}
});
await updateFeatured(exist._id).catch(err => console.log(err));
2018-04-17 06:30:58 +00:00
}
2018-04-08 19:08:56 +00:00
/**
* Personを解決します
*
* Misskeyに対象のPersonが登録されていればそれを返し
* Misskeyに登録しそれを返します
*/
export async function resolvePerson(uri: string, verifier?: string, resolver?: Resolver): Promise<IUser> {
2018-08-29 07:10:03 +00:00
if (typeof uri !== 'string') throw 'uri is not string';
2018-04-08 19:08:56 +00:00
//#region このサーバーに既に登録されていたらそれを返す
const exist = await fetchPerson(uri);
if (exist) {
return exist;
}
//#endregion
// リモートサーバーからフェッチしてきて登録
if (resolver == null) resolver = new Resolver();
return await createPerson(uri, resolver);
}
export async function updateFeatured(userId: mongo.ObjectID) {
const user = await User.findOne({ _id: userId });
if (!isRemoteUser(user)) return;
if (!user.featured) return;
log(`Updating the featured: ${user.uri}`);
const resolver = new Resolver();
// Resolve to (Ordered)Collection Object
const collection = await resolver.resolveCollection(user.featured);
if (!isCollectionOrOrderedCollection(collection)) throw new Error(`Object is not Collection or OrderedCollection`);
// Resolve to Object(may be Note) arrays
const unresolvedItems = isCollection(collection) ? collection.items : collection.orderedItems;
const items = await resolver.resolve(unresolvedItems);
if (!Array.isArray(items)) throw new Error(`Collection items is not an array`);
// Resolve and regist Notes
const featuredNotes = await Promise.all(items
.filter(item => item.type === 'Note')
.slice(0, 5)
.map(item => resolveNote(item, resolver)));
await User.update({ _id: user._id }, {
$set: {
pinnedNoteIds: featuredNotes.map(note => note._id)
}
});
2018-04-08 19:08:56 +00:00
}