247 lines
8.7 KiB
TypeScript
247 lines
8.7 KiB
TypeScript
import { Note } from "@/models/entities/note.js";
|
|
import { ILocalUser, User } from "@/models/entities/user.js";
|
|
import {
|
|
Followings,
|
|
FollowRequests,
|
|
NoteFavorites,
|
|
NoteReactions,
|
|
Notes,
|
|
UserProfiles,
|
|
Users
|
|
} from "@/models/index.js";
|
|
import { makePaginationQuery } from "@/server/api/common/make-pagination-query.js";
|
|
import { generateRepliesQuery } from "@/server/api/common/generate-replies-query.js";
|
|
import { generateVisibilityQuery } from "@/server/api/common/generate-visibility-query.js";
|
|
import { generateMutedUserQuery } from "@/server/api/common/generate-muted-user-query.js";
|
|
import { generateBlockedUserQuery } from "@/server/api/common/generate-block-query.js";
|
|
import { NoteHelpers } from "@/server/api/mastodon/helpers/note.js";
|
|
import Entity from "megalodon/src/entity.js";
|
|
import AsyncLock from "async-lock";
|
|
import { getUser } from "@/server/api/common/getters.js";
|
|
import { PaginationHelpers } from "@/server/api/mastodon/helpers/pagination.js";
|
|
import { awaitAll } from "@/prelude/await-all.js";
|
|
import createFollowing from "@/services/following/create.js";
|
|
import deleteFollowing from "@/services/following/delete.js";
|
|
import cancelFollowRequest from "@/services/following/requests/cancel.js";
|
|
|
|
export type AccountCache = {
|
|
locks: AsyncLock;
|
|
accounts: Entity.Account[];
|
|
users: User[];
|
|
};
|
|
|
|
export type LinkPaginationObject<T> = {
|
|
data: T;
|
|
maxId?: string | undefined;
|
|
minId?: string | undefined;
|
|
}
|
|
|
|
type RelationshipType = 'followers' | 'following';
|
|
|
|
export class UserHelpers {
|
|
public static async followUser(target: User, localUser: ILocalUser, reblogs: boolean, notify: boolean) {
|
|
//FIXME: implement reblogs & notify params
|
|
const following = await Followings.exist({where: {followerId: localUser.id, followeeId: target.id}});
|
|
const requested = await FollowRequests.exist({where: {followerId: localUser.id, followeeId: target.id}});
|
|
if (!following && !requested)
|
|
await createFollowing(localUser, target);
|
|
|
|
return this.getUserRelationshipTo(target, localUser);
|
|
}
|
|
|
|
public static async unfollowUser(target: User, localUser: ILocalUser) {
|
|
const following = await Followings.exist({where: {followerId: localUser.id, followeeId: target.id}});
|
|
const requested = await FollowRequests.exist({where: {followerId: localUser.id, followeeId: target.id}});
|
|
if (following)
|
|
await deleteFollowing(localUser, target);
|
|
if (requested)
|
|
await cancelFollowRequest(target, localUser);
|
|
|
|
return this.getUserRelationshipTo(target, localUser);
|
|
}
|
|
|
|
public static async getUserStatuses(user: User, localUser: ILocalUser | null, maxId: string | undefined, sinceId: string | undefined, minId: string | undefined, limit: number = 20, onlyMedia: boolean = false, excludeReplies: boolean = false, excludeReblogs: boolean = false, pinned: boolean = false, tagged: string | undefined): Promise<Note[]> {
|
|
if (limit > 40) limit = 40;
|
|
|
|
if (pinned) {
|
|
//FIXME respect pinned
|
|
return [];
|
|
}
|
|
|
|
if (tagged !== undefined) {
|
|
//FIXME respect tagged
|
|
return [];
|
|
}
|
|
|
|
const query = PaginationHelpers.makePaginationQuery(
|
|
Notes.createQueryBuilder("note"),
|
|
sinceId,
|
|
maxId,
|
|
minId
|
|
)
|
|
.andWhere("note.userId = :userId", { userId: user.id });
|
|
|
|
if (excludeReblogs) query.andWhere("(note.renoteId IS NOT NULL) OR (note.text IS NOT NULL)");
|
|
|
|
query
|
|
.leftJoinAndSelect("note.renote", "renote");
|
|
|
|
//this doesn't exclude replies to your own reply to someone else's post
|
|
//this also breaks when checking your own profile
|
|
//FIXME write new the replies query generator specific to the mastodon client api
|
|
generateRepliesQuery(query, !excludeReplies, localUser);
|
|
generateVisibilityQuery(query, localUser);
|
|
if (localUser) {
|
|
generateMutedUserQuery(query, localUser, user);
|
|
generateBlockedUserQuery(query, localUser);
|
|
}
|
|
|
|
if (onlyMedia) query.andWhere("note.fileIds != '{}'");
|
|
|
|
query.andWhere("note.visibility != 'hidden'");
|
|
|
|
return PaginationHelpers.execQuery(query, limit, minId !== undefined);
|
|
}
|
|
|
|
public static async getUserBookmarks(localUser: ILocalUser, maxId: string | undefined, sinceId: string | undefined, minId: string | undefined, limit: number = 20): Promise<LinkPaginationObject<Note[]>> {
|
|
if (limit > 40) limit = 40;
|
|
|
|
const query = PaginationHelpers.makePaginationQuery(
|
|
NoteFavorites.createQueryBuilder("favorite"),
|
|
sinceId,
|
|
maxId,
|
|
minId
|
|
)
|
|
.andWhere("favorite.userId = :meId", { meId: localUser.id })
|
|
.leftJoinAndSelect("favorite.note", "note");
|
|
|
|
generateVisibilityQuery(query, localUser);
|
|
|
|
return PaginationHelpers.execQuery(query, limit, minId !== undefined)
|
|
.then(res => {
|
|
return {
|
|
data: res.map(p => p.note as Note),
|
|
maxId: res.map(p => p.id).at(-1),
|
|
minId: res.map(p => p.id)[0],
|
|
};
|
|
});
|
|
}
|
|
|
|
public static async getUserFavorites(localUser: ILocalUser, maxId: string | undefined, sinceId: string | undefined, minId: string | undefined, limit: number = 20): Promise<LinkPaginationObject<Note[]>> {
|
|
if (limit > 40) limit = 40;
|
|
|
|
const query = PaginationHelpers.makePaginationQuery(
|
|
NoteReactions.createQueryBuilder("reaction"),
|
|
sinceId,
|
|
maxId,
|
|
minId
|
|
)
|
|
.andWhere("reaction.userId = :meId", { meId: localUser.id })
|
|
.leftJoinAndSelect("reaction.note", "note");
|
|
|
|
generateVisibilityQuery(query, localUser);
|
|
|
|
return PaginationHelpers.execQuery(query, limit, minId !== undefined)
|
|
.then(res => {
|
|
return {
|
|
data: res.map(p => p.note as Note),
|
|
maxId: res.map(p => p.id).at(-1),
|
|
minId: res.map(p => p.id)[0],
|
|
};
|
|
});
|
|
}
|
|
|
|
private static async getUserRelationships(type: RelationshipType, user: User, localUser: ILocalUser | null, maxId: string | undefined, sinceId: string | undefined, minId: string | undefined, limit: number = 40): Promise<LinkPaginationObject<User[]>> {
|
|
if (limit > 80) limit = 80;
|
|
|
|
const profile = await UserProfiles.findOneByOrFail({ userId: user.id });
|
|
if (profile.ffVisibility === "private") {
|
|
if (!localUser || user.id !== localUser.id) return { data: [] };
|
|
}
|
|
else if (profile.ffVisibility === "followers") {
|
|
if (!localUser) return { data: [] };
|
|
if (user.id !== localUser.id) {
|
|
const isFollowed = await Followings.exist({
|
|
where: {
|
|
followeeId: user.id,
|
|
followerId: localUser.id,
|
|
},
|
|
});
|
|
if (!isFollowed) return { data: [] };
|
|
}
|
|
}
|
|
|
|
const query = PaginationHelpers.makePaginationQuery(
|
|
Followings.createQueryBuilder("following"),
|
|
sinceId,
|
|
maxId,
|
|
minId
|
|
);
|
|
|
|
if (type === "followers") {
|
|
query.andWhere("following.followeeId = :userId", {userId: user.id})
|
|
.innerJoinAndSelect("following.follower", "follower");
|
|
} else {
|
|
query.andWhere("following.followerId = :userId", {userId: user.id})
|
|
.innerJoinAndSelect("following.followee", "followee");
|
|
}
|
|
|
|
return query.take(limit).getMany().then(p => {
|
|
if (minId !== undefined) p = p.reverse();
|
|
|
|
return {
|
|
data: p.map(p => type === "followers" ? p.follower : p.followee).filter(p => p) as User[],
|
|
maxId: p.map(p => p.id).at(-1),
|
|
minId: p.map(p => p.id)[0],
|
|
};
|
|
});
|
|
}
|
|
|
|
public static async getUserFollowers(user: User, localUser: ILocalUser | null, maxId: string | undefined, sinceId: string | undefined, minId: string | undefined, limit: number = 40): Promise<LinkPaginationObject<User[]>> {
|
|
return this.getUserRelationships('followers', user, localUser, maxId, sinceId, minId, limit);
|
|
}
|
|
|
|
public static async getUserFollowing(user: User, localUser: ILocalUser | null, maxId: string | undefined, sinceId: string | undefined, minId: string | undefined, limit: number = 40): Promise<LinkPaginationObject<User[]>> {
|
|
return this.getUserRelationships('following', user, localUser, maxId, sinceId, minId, limit);
|
|
}
|
|
|
|
public static async getUserRelationshipTo(target: User, localUser: ILocalUser): Promise<MastodonEntity.Relationship> {
|
|
const relation = await Users.getRelation(localUser.id, target.id);
|
|
const response = {
|
|
id: target.id,
|
|
following: relation.isFollowing,
|
|
followed_by: relation.isFollowed,
|
|
blocking: relation.isBlocking,
|
|
blocked_by: relation.isBlocked,
|
|
muting: relation.isMuted,
|
|
muting_notifications: relation.isMuted,
|
|
requested: relation.hasPendingFollowRequestFromYou,
|
|
domain_blocking: false, //FIXME
|
|
showing_reblogs: !relation.isRenoteMuted,
|
|
endorsed: false,
|
|
notifying: false, //FIXME
|
|
note: '' //FIXME
|
|
}
|
|
|
|
return awaitAll(response);
|
|
}
|
|
|
|
public static async getUserCached(id: string, cache: AccountCache = UserHelpers.getFreshAccountCache()): Promise<User> {
|
|
return cache.locks.acquire(id, async () => {
|
|
const cacheHit = cache.users.find(p => p.id == id);
|
|
if (cacheHit) return cacheHit;
|
|
return getUser(id).then(p => {
|
|
cache.users.push(p);
|
|
return p;
|
|
});
|
|
});
|
|
}
|
|
|
|
public static getFreshAccountCache(): AccountCache {
|
|
return {
|
|
locks: new AsyncLock(),
|
|
accounts: [],
|
|
users: [],
|
|
};
|
|
}
|
|
}
|