Pin and Unpin Messages

import { Client } from '@amityco/ts-sdk';

const client = Client.createClient('your-api-key', 'sg');

// A network-level grant (Console) shows up on the user; a channel role shows up on the channel.
const permission = client.hasPermission('PIN_MESSAGE');
const canPin = permission.currentUser() || permission.channel(channelId);

if (canPin) {
  // Show the pin control in the message action menu.
}

Task { @MainActor in
    let canPin = await client.hasPermission(
        .pinMessage,
        forChannel: "channel-id"
    )

    if canPin {
        // Show the pin control in the message action menu.
    }
}

fun checkPinPermission(channelId: String) {
    AmityCoreClient.hasPermission(AmityPermission.PIN_MESSAGE)
        .atChannel(channelId)
        .check()
        .doOnNext { canPin: Boolean ->
            if (canPin) {
                // Show the pin control in the message action menu.
            }
        }
        .subscribe()
}

import { MessageRepository } from '@amityco/ts-sdk';

const channel = await MessageRepository.pinMessage(messageId);

renderResults(channel.pinnedMessage);

do {
    let channel = try await messageRepository.pinMessage(withId: "message-id")
    showSuccessMessage(channel.pinnedMessage?.messageId)
} catch {
    handleError(error)
}

val disposable = messageRepository
    .pinMessage(messageId = messageId)
    .subscribe(
        { channel -> showSuccessMessage(channel.getPinnedMessage()?.getMessageId()) },
        { error -> handleGeneralError(error) },
    )

import { MessageRepository } from '@amityco/ts-sdk';

const channel = await MessageRepository.unpinMessage(messageId);

renderResults(channel.pinnedMessage); // null

do {
    let channel = try await messageRepository.unpinMessage(withId: "message-id")
    showSuccessMessage(channel.pinnedMessage == nil)
} catch {
    handleError(error)
}

val disposable = messageRepository
    .unpinMessage(messageId = messageId)
    .subscribe(
        { channel -> showSuccessMessage(channel.getPinnedMessage() == null) },
        { error -> handleGeneralError(error) },
    )

import { ChannelRepository } from '@amityco/ts-sdk';

const unsubscribe = ChannelRepository.getChannel(
  channelId,
  ({ data: channel, loading, error }) => {
    if (error) handleError(error);

    if (!loading && channel) {
      renderResults(channel.pinnedMessage ?? null);
    }
  },
);

unsubscribe();

let liveChannel = channelRepository.getChannel("channel-id")

token = liveChannel.observe { liveObject, error in
    if let error {
        handleError(error)
        return
    }

    guard let channel = liveObject.snapshot else { return }

    if let pinned = channel.pinnedMessage {
        showSuccessMessage(pinned.data?["text"] as? String)
    } else {
        // Nothing is pinned. Hide the banner.
    }
}

val disposable = channelRepository
    .getChannel(channelId = channelId)
    .subscribe(
        { channel ->
            val pinned: AmityPinnedMessage? = channel.getPinnedMessage()
            if (pinned != null) {
                // getData() returns AmityMessage.Data. Cast it to read the text.
                val text = (pinned.getData() as? AmityMessage.Data.TEXT)?.getText()
                showSuccessMessage(text)
            } else {
                // Nothing is pinned. Hide the banner.
            }
        },
        { error -> handleGeneralError(error) },
    )

import { ChannelRepository } from '@amityco/ts-sdk';

const unsubscribePinned = ChannelRepository.onChannelMessagePinned((channel) => {
  renderResults(channel.pinnedMessage);
});

const unsubscribeUnpinned = ChannelRepository.onChannelMessageUnpinned((channel) => {
  renderResults(channel.pinnedMessage); // null
});

unsubscribePinned();
unsubscribeUnpinned();

var currentPinnedMessageId: String?

let liveChannel = channelRepository.getChannel("channel-id")

token = liveChannel.observe { liveObject, error in
    if let error {
        handleError(error)
        return
    }

    guard let channel = liveObject.snapshot else { return }
    let pinned = channel.pinnedMessage

    switch (currentPinnedMessageId, pinned?.messageId) {
    case (nil, let newId?):
        // channel.messagePinned: show the banner.
        showSuccessMessage("Pinned \(newId)")
    case (let oldId?, let newId?) where oldId != newId:
        // channel.messagePinned with a replacement: re-render the banner collapsed.
        showSuccessMessage("Replaced \(oldId) with \(newId)")
    case (_?, nil):
        // channel.messageUnpinned, or the pinned message was deleted: hide the banner.
        showSuccessMessage("Unpinned")
    default:
        break
    }

    currentPinnedMessageId = pinned?.messageId
}

var currentPinnedMessageId: String? = null

val disposable = channelRepository
    .getChannel(channelId = channelId)
    .subscribe(
        { channel ->
            val newId = channel.getPinnedMessage()?.getMessageId()
            val oldId = currentPinnedMessageId

            when {
                oldId == null && newId != null -> {
                    // channel.messagePinned: show the banner.
                    showSuccessMessage("Pinned $newId")
                }
                oldId != null && newId != null && oldId != newId -> {
                    // channel.messagePinned with a replacement: re-render the banner collapsed.
                    showSuccessMessage("Replaced $oldId with $newId")
                }
                oldId != null && newId == null -> {
                    // channel.messageUnpinned, or the pinned message was deleted: hide the banner.
                    showSuccessMessage("Unpinned")
                }
            }

            currentPinnedMessageId = newId
        },
        { error -> handleGeneralError(error) },
    )

import { MessageRepository } from '@amityco/ts-sdk';

try {
  await MessageRepository.pinMessage(messageId);
} catch (error) {
  // The pin did not change. Hide the pin control after a 403,
  // and let the channel observer keep the banner in sync.
  handleError(error);
}

do {
    _ = try await messageRepository.pinMessage(withId: "message-id")
} catch {
    // The pin did not change. Re-check hasPermission(.pinMessage, forChannel:)
    // after a 403, and let the channel observer keep the banner in sync.
    handleError(error)
}

val disposable = messageRepository
    .pinMessage(messageId = messageId)
    .subscribe(
        { /* Channel observer renders the new pin. */ },
        { error ->
            // The pin did not change. The permission Flowable re-emits after a 403,
            // and the channel observer keeps the banner in sync.
            handleGeneralError(error)
        },
    )