108 lines
3.1 KiB
TypeScript
108 lines
3.1 KiB
TypeScript
import type { GuildTextChannel, User } from '../../mod.ts'
|
|
import type { Client } from '../client/mod.ts'
|
|
import type { Guild } from '../structures/guild.ts'
|
|
import { Invite } from '../structures/invite.ts'
|
|
import { CHANNEL_INVITES, GUILD_INVITES, INVITE } from '../types/endpoint.ts'
|
|
import type { InvitePayload } from '../types/invite.ts'
|
|
import { BaseManager } from './base.ts'
|
|
|
|
export enum InviteTargetUserType {
|
|
STREAM = 1
|
|
}
|
|
|
|
export interface CreateInviteOptions {
|
|
maxAge?: number
|
|
maxUses?: number
|
|
temporary?: boolean
|
|
unique?: boolean
|
|
targetUser?: string | User
|
|
targetUserType?: InviteTargetUserType
|
|
}
|
|
|
|
export class InviteManager extends BaseManager<InvitePayload, Invite> {
|
|
guild: Guild
|
|
|
|
constructor(client: Client, guild: Guild) {
|
|
super(client, `invites:${guild.id}`, Invite)
|
|
this.guild = guild
|
|
}
|
|
|
|
async get(key: string): Promise<Invite | undefined> {
|
|
const raw = await this._get(key)
|
|
if (raw === undefined) return
|
|
return new Invite(this.client, raw)
|
|
}
|
|
|
|
/** Fetch an Invite */
|
|
async fetch(id: string, withCounts: boolean = true): Promise<Invite> {
|
|
return await new Promise((resolve, reject) => {
|
|
this.client.rest
|
|
.get(`${INVITE(id)}${withCounts ? '?with_counts=true' : ''}`)
|
|
.then(async (data) => {
|
|
this.set(id, data as InvitePayload)
|
|
const newInvite = await this.get(data.code)
|
|
resolve(newInvite as Invite)
|
|
})
|
|
.catch((e) => reject(e))
|
|
})
|
|
}
|
|
|
|
/** Fetch all Invites of a Guild or a specific Channel */
|
|
async fetchAll(channel?: string | GuildTextChannel): Promise<Invite[]> {
|
|
const rawInvites = (await this.client.rest.get(
|
|
channel === undefined
|
|
? GUILD_INVITES(this.guild.id)
|
|
: CHANNEL_INVITES(typeof channel === 'string' ? channel : channel.id)
|
|
)) as InvitePayload[]
|
|
|
|
const res: Invite[] = []
|
|
|
|
for (const raw of rawInvites) {
|
|
await this.set(raw.code, raw)
|
|
res.push(new Invite(this.client, raw))
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
/** Delete an Invite */
|
|
async delete(invite: string | Invite): Promise<boolean> {
|
|
await this.client.rest.delete(
|
|
INVITE(typeof invite === 'string' ? invite : invite.code)
|
|
)
|
|
return true
|
|
}
|
|
|
|
/** Create an Invite */
|
|
async create(
|
|
channel: string | GuildTextChannel,
|
|
options?: CreateInviteOptions
|
|
): Promise<Invite> {
|
|
const raw = ((await this.client.rest.post(
|
|
CHANNEL_INVITES(typeof channel === 'string' ? channel : channel.id),
|
|
{
|
|
max_age: options?.maxAge,
|
|
max_uses: options?.maxUses,
|
|
temporary: options?.temporary,
|
|
unique: options?.unique,
|
|
target_user:
|
|
options?.targetUser === undefined
|
|
? undefined
|
|
: typeof options.targetUser === 'string'
|
|
? options.targetUser
|
|
: options.targetUser.id,
|
|
target_user_type: options?.targetUserType
|
|
}
|
|
)) as unknown) as InvitePayload
|
|
|
|
return new Invite(this.client, raw)
|
|
}
|
|
|
|
async fromPayload(invites: InvitePayload[]): Promise<boolean> {
|
|
for (const invite of invites) {
|
|
await this.set(invite.code, invite)
|
|
}
|
|
return true
|
|
}
|
|
}
|