248 lines
8.5 KiB
TypeScript
248 lines
8.5 KiB
TypeScript
/*
|
|
* SPDX-FileCopyrightText: syuilo and other misskey contributors
|
|
* SPDX-License-Identifier: AGPL-3.0-only
|
|
*/
|
|
|
|
import { Inject, Injectable } from '@nestjs/common';
|
|
import { In } from 'typeorm';
|
|
import { Endpoint } from '@/server/api/endpoint-base.js';
|
|
import { IdService } from '@/core/IdService.js';
|
|
import { FederatedInstanceService } from '@/core/FederatedInstanceService.js';
|
|
import { HttpRequestService } from '@/core/HttpRequestService.js';
|
|
import { ApDbResolverService } from '@/core/activitypub/ApDbResolverService.js';
|
|
import { ApResolverService } from '@/core/activitypub/ApResolverService.js';
|
|
import { getApId, isActor, isPost } from '@/core/activitypub/type.js';
|
|
import { ApNoteService } from '@/core/activitypub/models/ApNoteService.js';
|
|
import { NoteEntityService } from '@/core/entities/NoteEntityService.js';
|
|
import { DI } from '@/di-symbols.js';
|
|
import type { NotesRepository } from '@/models/_.js';
|
|
import { MiNote, MiUser } from '@/models/_.js';
|
|
import { bindThis } from '@/decorators.js';
|
|
import { MiLocalUser } from '@/models/User.js';
|
|
import { SchemaType } from '@/misc/json-schema.js';
|
|
import { UtilityService } from '@/core/UtilityService.js';
|
|
import { UserEntityService } from '@/core/entities/UserEntityService.js';
|
|
import { MetaService } from '@/core/MetaService.js';
|
|
import { ApPersonService } from '@/core/activitypub/models/ApPersonService.js';
|
|
import { ApiError } from '../../error.js';
|
|
|
|
export const meta = {
|
|
tags: ['notes'],
|
|
|
|
res: {
|
|
type: 'array',
|
|
optional: false, nullable: false,
|
|
items: {
|
|
type: 'object',
|
|
optional: false, nullable: false,
|
|
ref: 'Note',
|
|
},
|
|
},
|
|
|
|
errors: {
|
|
hostIsNull: {
|
|
message: 'Host is null',
|
|
code: 'HOST_NULL',
|
|
id: 'PRSMSK-ANY-LTL-0001',
|
|
},
|
|
|
|
bothWithRepliesAndWithFiles: {
|
|
message: 'Specifying both withReplies and withFiles is not supported',
|
|
code: 'BOTH_WITH_REPLIES_AND_WITH_FILES',
|
|
id: 'dd9c8400-1cb5-4eef-8a31-200c5f933793',
|
|
},
|
|
remoteTokenIsNull: {
|
|
message: 'remoteToken is null',
|
|
code: 'REMOTE_TOKEN_NULL',
|
|
id: 'PRSMSK-ANY-LTL-0002',
|
|
},
|
|
},
|
|
} as const;
|
|
|
|
export const paramDef = {
|
|
type: 'object',
|
|
properties: {
|
|
withFiles: { type: 'boolean', default: false },
|
|
withRenotes: { type: 'boolean', default: true },
|
|
withReplies: { type: 'boolean', default: false },
|
|
limit: { type: 'integer', minimum: 1, maximum: 100, default: 10 },
|
|
sinceId: { type: 'string', format: 'misskey:id' },
|
|
untilId: { type: 'string', format: 'misskey:id' },
|
|
allowPartial: { type: 'boolean', default: false }, // true is recommended but for compatibility false by default
|
|
sinceDate: { type: 'integer' },
|
|
untilDate: { type: 'integer' },
|
|
host: { type: 'string' },
|
|
remoteToken: { type: 'string' },
|
|
},
|
|
required: [],
|
|
} as const;
|
|
|
|
@Injectable()
|
|
export default class extends Endpoint<typeof meta, typeof paramDef> { // eslint-disable-line import/no-default-export
|
|
constructor(
|
|
@Inject(DI.notesRepository)
|
|
private notesRepository: NotesRepository,
|
|
private idService: IdService,
|
|
private federatedInstanceService: FederatedInstanceService,
|
|
private httpRequestService: HttpRequestService,
|
|
private utilityService: UtilityService,
|
|
private userEntityService: UserEntityService,
|
|
private noteEntityService: NoteEntityService,
|
|
private metaService: MetaService,
|
|
private apResolverService: ApResolverService,
|
|
private apDbResolverService: ApDbResolverService,
|
|
private apPersonService: ApPersonService,
|
|
private apNoteService: ApNoteService,
|
|
) {
|
|
super(meta, paramDef, async (ps, me) => {
|
|
const untilId = ps.untilId ?? (ps.untilDate ? this.idService.gen(ps.untilDate!) : null);
|
|
const sinceId = ps.sinceId ?? (ps.sinceDate ? this.idService.gen(ps.sinceDate!) : null);
|
|
if (ps.host === undefined) throw new ApiError(meta.errors.hostIsNull);
|
|
if (ps.remoteToken === undefined) throw new ApiError(meta.errors.remoteTokenIsNull);
|
|
const i = await this.federatedInstanceService.fetch(ps.host);
|
|
const noteIds = [];
|
|
|
|
if (i.softwareName === 'misskey') {
|
|
const remoteTimeline: string[] = await (await this.httpRequestService.send('https://' + ps.host + '/api/notes/local-timeline', {
|
|
method: 'POST',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
},
|
|
body: JSON.stringify({
|
|
i: ps.remoteToken,
|
|
withFiles: ps.withFiles,
|
|
withRenotes: ps.withRenotes,
|
|
withReplies: ps.withReplies,
|
|
limit: 30,
|
|
}),
|
|
})).json() as string[];
|
|
|
|
if (remoteTimeline.length > 0) {
|
|
for (const note of remoteTimeline) {
|
|
const uri = `https://${ps.host}/notes/${note.id}`;
|
|
const note_ = await this.fetchAny(uri, me);
|
|
if (note_ == null) continue;
|
|
noteIds.push(note_.id);
|
|
}
|
|
}
|
|
|
|
let notes = await this.notesRepository.findBy({ id: In(noteIds) });
|
|
let packedNote: any[] = await this.noteEntityService.packMany(notes, me, { detail: true });
|
|
if (untilId) {
|
|
let lastRemoteId;
|
|
const lastUri = packedNote[packedNote.length - 1].uri;
|
|
lastRemoteId = lastUri.split('/')[lastUri.split('/').length - 1];
|
|
do {
|
|
const remoteTimeline: string[] = await (await this.httpRequestService.send('https://' + ps.host + '/api/notes/local-timeline', {
|
|
method: 'POST',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
},
|
|
body: JSON.stringify({
|
|
i: ps.remoteToken,
|
|
withFiles: ps.withFiles,
|
|
withRenotes: ps.withRenotes,
|
|
withReplies: ps.withReplies,
|
|
untilId: lastRemoteId,
|
|
limit: 30,
|
|
}),
|
|
})).json() as string[];
|
|
|
|
if (remoteTimeline.length > 0) {
|
|
for (const note of remoteTimeline) {
|
|
const uri = `https://${ps.host}/notes/${note.id}`;
|
|
const note_ = await this.fetchAny(uri, me);
|
|
if (note_ == null) continue;
|
|
//noteIds.push(note_.id);
|
|
lastRemoteId = note_.id;
|
|
if (lastRemoteId === ps.untilId) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} while (lastRemoteId !== ps.untilId);
|
|
const remoteTimeline: string[] = await (await this.httpRequestService.send('https://' + ps.host + '/api/notes/local-timeline', {
|
|
method: 'POST',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
},
|
|
body: JSON.stringify({
|
|
i: ps.remoteToken,
|
|
withFiles: ps.withFiles,
|
|
withRenotes: ps.withRenotes,
|
|
withReplies: ps.withReplies,
|
|
untilId: lastRemoteId,
|
|
limit: 30,
|
|
}),
|
|
})).json() as string[];
|
|
|
|
if (remoteTimeline.length > 0) {
|
|
for (const note of remoteTimeline) {
|
|
const uri = `https://${ps.host}/notes/${note.id}`;
|
|
const note_ = await this.fetchAny(uri, me);
|
|
if (note_ == null) continue;
|
|
noteIds.push(note_.id);
|
|
}
|
|
}
|
|
}
|
|
|
|
notes = await this.notesRepository.findBy({ id: In(noteIds) });
|
|
packedNote = await this.noteEntityService.packMany(notes, me, { detail: true });
|
|
return packedNote.reverse();
|
|
}
|
|
});
|
|
}
|
|
@bindThis
|
|
private async fetchAny(uri: string, me: MiLocalUser | null | undefined) {
|
|
// ブロックしてたら中断
|
|
const fetchedMeta = await this.metaService.fetch();
|
|
if (this.utilityService.isBlockedHost(fetchedMeta.blockedHosts, this.utilityService.extractDbHost(uri))) return null;
|
|
|
|
let local = await this.mergePack(me, ...await Promise.all([
|
|
this.apDbResolverService.getUserFromApId(uri),
|
|
this.apDbResolverService.getNoteFromApId(uri),
|
|
]));
|
|
if (local != null) return local;
|
|
|
|
// リモートから一旦オブジェクトフェッチ
|
|
let object;
|
|
try {
|
|
const resolver = this.apResolverService.createResolver();
|
|
object = await resolver.resolve(uri) as any;
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
if (!object) return null;
|
|
// /@user のような正規id以外で取得できるURIが指定されていた場合、ここで初めて正規URIが確定する
|
|
// これはDBに存在する可能性があるため再度DB検索
|
|
if (uri !== object.id) {
|
|
local = await this.mergePack(me, ...await Promise.all([
|
|
this.apDbResolverService.getUserFromApId(object.id),
|
|
this.apDbResolverService.getNoteFromApId(object.id),
|
|
]));
|
|
if (local != null) return local;
|
|
}
|
|
|
|
return await this.mergePack(
|
|
me,
|
|
isActor(object) ? await this.apPersonService.createPerson(getApId(object)) : null,
|
|
isPost(object) ? await this.apNoteService.createNote(getApId(object), undefined, true) : null,
|
|
);
|
|
}
|
|
|
|
@bindThis
|
|
private async mergePack(me: MiLocalUser | null | undefined, user: MiUser | null | undefined, note: MiNote | null | undefined) {
|
|
if (note != null) {
|
|
try {
|
|
const object = await this.noteEntityService.pack(note, me, { detail: true });
|
|
|
|
return object;
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|