Hooks

import { useEvent, useMessage, Format } from 'alemonjs'
export default async () => {
  const [event] = useEvent()
  const [message] = useMessage()

  // 发送消息
  const format = Format.create().addText('hello word')
  message.send({ format })

  // 删除消息
  await message.delete({ messageId: event.current.MessageId })

  // 编辑消息
  await message.edit({
    format: Format.create().addText('edited'),
    messageId: event.current.MessageId
  })

  // 置顶 / 取消置顶
  await message.pin({ messageId: event.current.MessageId })
  await message.unpin({ messageId: event.current.MessageId })

  // 获取消息详情
  const detail = await message.get({ messageId: event.current.MessageId })
}

import { useMention } from 'alemonjs'
export default async () => {
  const [mention] = useMention()
  // 查找用户类型的 @ 提及，默认排除 bot
  const user = await mention.findOne()
  if (!user.count || !user.data) {
    return // 未找到用户
  }
  console.log('User:', user)
}

import { Format, useMessage, useSubscribe } from 'alemonjs'

export default () => {
  const [message] = useMessage()
  const [subscribe] = useSubscribe(['message.create', 'private.message.create'])

  message.send({
    format: Format.create().addText('请输入密码')
  })

  // 订阅 res 挂载之前的事件
  const sub = subscribe.mount(
    (event, next) => {
      const [message] = useMessage(event)
      const text = event.MessageText

      if (text === '123456') {
        message.send({
          format: Format.create().addText('密码正确')
        })
        clearTimeout(timeout)
      } else if (text == '/close') {
        message.send({
          format: Format.create().addText('取消登录')
        })
        clearTimeout(timeout)
      } else {
        message.send({
          format: Format.create().addText('密码不正确')
        })
        // 保持订阅
        next()
      }
    },
    ['UserId']
  )

  const timeout = setTimeout(() => {
    subscribe.cancel(sub)
    message.send({
      format: Format.create().addText('登录超时')
    })
  }, 1000 * 10)
}

import { useEvent, useMember } from 'alemonjs'
export default async () => {
  const [event] = useEvent()
  const [member] = useMember()

  // 获取成员信息
  const info = await member.info({ userId: event.current.UserId })

  // 获取成员列表
  const list = await member.list({ guildId: event.current.GuildId })

  // 搜索成员
  const result = await member.search({ keyword: '管理' })

  // 踢出成员
  await member.kick({ userId: '123' })

  // 封禁 / 解封
  await member.ban({ userId: '123', reason: '违规', duration: 3600 })
  await member.unban({ userId: '123' })

  // 禁言（秒），0 = 解除
  await member.mute({ userId: '123', duration: 60 })

  // 设置管理员
  await member.admin({ userId: '123', enable: true })

  // 设置名片
  await member.card({ userId: '123', card: '新昵称' })

  // 设置专属头衔
  await member.title({ userId: '123', title: 'VIP', duration: -1 })
}

import { useEvent, useChannel } from 'alemonjs'
export default async () => {
  const [event] = useEvent()
  const [channel] = useChannel()

  // 获取频道信息
  const info = await channel.info({ channelId: event.current.ChannelId })

  // 获取频道列表
  const list = await channel.list({ guildId: event.current.GuildId })

  // 创建频道
  await channel.create({ name: '新频道', guildId: event.current.GuildId })

  // 更新频道
  await channel.update({
    channelId: event.current.ChannelId,
    name: '改名',
    topic: '新话题'
  })

  // 删除频道
  await channel.delete({ channelId: event.current.ChannelId })
}

import { useEvent, useGuild } from 'alemonjs'
export default async () => {
  const [event] = useEvent()
  const [guild] = useGuild()

  // 获取服务器信息
  const info = await guild.info({ guildId: event.current.GuildId })

  // 获取服务器列表
  const list = await guild.list()

  // 更新服务器设置
  await guild.update({ name: '新名称' })

  // 退出服务器
  await guild.leave({ guildId: event.current.GuildId })

  // 全员禁言
  await guild.mute({ enable: true })
}

import { useEvent, useRole } from 'alemonjs'
export default async () => {
  const [event] = useEvent()
  const [role] = useRole()

  // 获取角色列表
  const list = await role.list({ guildId: event.current.GuildId })

  // 创建角色
  const created = await role.create({ name: 'VIP', color: 0xff0000 })

  // 更新角色
  await role.update({ roleId: '123', name: '超级VIP' })

  // 删除角色
  await role.delete({ roleId: '123' })

  // 分配 / 移除角色
  await role.assign({ userId: event.current.UserId, roleId: '123' })
  await role.remove({ userId: event.current.UserId, roleId: '123' })
}

import { useEvent, useReaction } from 'alemonjs'
export default async () => {
  const [event] = useEvent()
  const [reaction] = useReaction()

  // 添加表情回应
  await reaction.add({ emojiId: '👍' })

  // 移除表情回应
  await reaction.remove({ emojiId: '👍', messageId: event.current.MessageId })

  // 获取回应用户列表
  const list = await reaction.list({ emojiId: '👍', limit: 20 })
}

import { useMe } from 'alemonjs'
export default async () => {
  const [me] = useMe()

  const info = await me.info()
  const guilds = await me.guilds()
  const threads = await me.threads()
  const friends = await me.friends()
}

import { useEvent, useUser } from 'alemonjs'
export default async () => {
  const [event] = useEvent()
  const [user] = useUser()
  const info = await user.info({ userId: event.current.UserId })
}

import { useRequest } from 'alemonjs'
export default async () => {
  const [request] = useRequest()

  // 同意好友请求
  await request.friend({ flag: 'xxx', approve: true, remark: '备注' })

  // 同意入群请求
  await request.guild({ flag: 'xxx', subType: 'add', approve: true })
}

import { useMedia } from 'alemonjs'
export default async () => {
  const [media] = useMedia()

  // 上传媒体（仅上传，不发送）
  await media.upload({ type: 'image', url: 'https://example.com/img.png' })

  // 发送媒体到频道
  await media.sendChannel({ type: 'image', url: 'https://example.com/img.png' })

  // 发送媒体到用户
  await media.sendUser({
    userId: '123',
    type: 'audio',
    url: 'https://example.com/a.mp3'
  })
}

import { useEvent, useHistory } from 'alemonjs'
export default async () => {
  const [event] = useEvent()
  const [history] = useHistory()
  const messages = await history.list({
    limit: 50,
    before: event.current.MessageId
  })
}

import { useEvent, usePermission } from 'alemonjs'
export default async () => {
  const [event] = useEvent()
  const [permission] = usePermission()

  // 获取权限
  const perm = await permission.get({ userId: event.current.UserId })

  // 设置权限
  await permission.set({ userId: event.current.UserId, allow: '1', deny: '0' })
}

import { useEvent, useAnnounce } from 'alemonjs'
export default async () => {
  const [event] = useEvent()
  const [announce] = useAnnounce()

  // 设置公告
  await announce.set({ messageId: event.current.MessageId })

  // 删除公告
  await announce.remove({ messageId: event.current.MessageId })
}

import { API, platform } from '@alemonjs/qq-bot'
import { useEvent, useClient } from 'alemonjs'
export default () => {
  const [event] = useEvent()
  if (event.current.Platform === platform) {
    const [client] = useClient(API)
    client.usersMe()
  }
}