Logging & Errors

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

const unsubscribe = Client.onNetworkActivities((request, response) => {
  console.log(request.method, request.url);
  console.log(response.status, response.statusText);
  console.log(response.data);
});

// Stop observing when the debug session ends.
unsubscribe();

client.observeNetworkActivities { request, response, data in
    if let request {
        print("\(request.httpMethod ?? "GET") \(request.url?.absoluteString ?? "")")
    }

    if let response {
        print("status: \(response.statusCode)")
    }

    if let data {
        print("response bytes: \(data.count)")
    }
}

// Stop observing when the debug session ends.
client.observeNetworkActivities(nil)

val disposable = AmityCoreClient.observeNetworkActivities()
    .doOnNext { activity ->
        print(activity)
    }
    .doOnError { exception ->
        val amityError = AmityError.from(exception)
        print(amityError)
    }
    .subscribe()

// Stop observing when the debug session ends.
disposable.dispose()

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

// Session-level: a global ban ends the session.
const unsubscribe = Client.onConnectionError(error => {
  if (error.code === Amity.ServerError.GLOBAL_BAN) {
    console.log('The current user is globally banned.');
  }
});

unsubscribe();

// Action-level: global mute and unsafe content reject only the failed call.
async function sendTextMessage(subChannelId: string, text: string) {
  try {
    await MessageRepository.createMessage({
      subChannelId,
      dataType: MessageContentType.TEXT,
      data: { text },
    });
  } catch (error) {
    const { code } = error as { code?: number };

    if (code === Amity.ServerError.GLOBAL_MUTE) {
      console.log('The current user is globally muted and cannot post right now.');
    } else if (code === Amity.ServerError.UNSAFE_CONTENT) {
      console.log('The content was rejected by moderation. Edit it before sending again.');
    } else {
      throw error;
    }
  }
}

func handleSdkError(_ error: Error) {
    let sdkError = error as NSError

    guard let amityError = AmityErrorCode(rawValue: sdkError.code) else {
        showErrorMessage("Unknown SDK error", error: error)
        return
    }

    if amityError == .globalBan {
        showErrorMessage("The current user is globally banned", error: error)
    }
}

fun handleSdkError(exception: Throwable) {
    val amityError = AmityError.from(exception)

    if (amityError == AmityError.USER_IS_GLOBAL_BANNED) {
        print("The current user is globally banned.")
    }
}

// Action-level: global mute and unsafe content reject only the failed call.
fun sendTextMessage(subChannelId: String, text: String): Disposable {
    return AmityChatClient.newMessageRepository()
        .createTextMessage(subChannelId, text)
        .build()
        .send()
        .subscribe({}, { exception ->
            when (AmityError.from(exception)) {
                AmityError.USER_IS_GLOBAL_MUTED ->
                    print("The current user is globally muted and cannot post right now.")
                AmityError.UNSAFE_CONTENT ->
                    print("The content was rejected by moderation. Edit it before sending again.")
                else -> print(exception)
            }
        })
}

final Object error = AmityException(
  message: 'The current user is globally banned.',
  code: 400312,
);

if (error is AmityException) {
  final amityError = error.toAmityError();

  if (amityError == AmityError.USER_IS_GLOBAL_BANNED) {
    showError(error);
  }
}