User Notification Settings

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

const settings = await Client.notifications()
  .user()
  .getSettings();

const isEnabled = settings.isEnabled;

settings.modules.forEach(module => {
  const moduleName = module.moduleName;
  const moduleEnabled = module.isEnabled;

  if (module.rolesFilter?.type === NotificationRolesFilterTypeEnum.ONLY) {
    const roleIds = module.rolesFilter.roleIds;
    updateUI({ moduleName, moduleEnabled, roleIds });
  }
});

let notificationManager = client.notificationManager
let settings = try await notificationManager.getSettings()

let isEnabled = settings.isEnabled

for module in settings.modules {
    switch module.moduleType {
    case .chat:
        print("chat enabled: \(module.isEnabled)")
    case .social:
        print("social enabled: \(module.isEnabled)")
    case .videoStreaming:
        print("video streaming enabled: \(module.isEnabled)")
    @unknown default:
        print("unknown module enabled: \(module.isEnabled)")
    }
}

AmityCoreClient.notifications()
    .user()
    .getSettings()
    .doOnSuccess { settings ->
        val isEnabled = settings.isEnabled()

        settings.getModules()?.forEach { module ->
            when (module) {
                is AmityUserNotificationModule.CHAT -> {
                    val moduleEnabled = module.isEnabled()
                }
                is AmityUserNotificationModule.SOCIAL -> {
                    val moduleEnabled = module.isEnabled()
                    val rolesFilter = module.getRolesFilter()
                }
                is AmityUserNotificationModule.VIDEO_STREAMING -> {
                    val moduleEnabled = module.isEnabled()
                }
                else -> Unit
            }
        }
    }
    .doOnError { error ->
        // Handle error.
    }
    .subscribe()

final settings = await AmityCoreClient
    .notifications()
    .user()
    .getSettings();

final isEnabled = settings.isEnabled;

settings.events?.forEach((module) {
  final moduleEnabled = module.isEnabled;
  final rolesFilter = module.rolesFilter;
});

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

await Client.notifications()
  .user()
  .enable([
    {
      moduleName: UserNotificationModuleNameEnum.CHAT,
      isEnabled: true,
    },
    {
      moduleName: UserNotificationModuleNameEnum.SOCIAL,
      isEnabled: true,
      rolesFilter: {
        type: NotificationRolesFilterTypeEnum.ONLY,
        roleIds: ['community-moderator'],
      },
    },
    {
      moduleName: UserNotificationModuleNameEnum.VIDEO_STREAMING,
      isEnabled: false,
    },
  ]);

await Client.notifications()
  .user()
  .disableAllNotifications();

let notificationManager = client.notificationManager

try await notificationManager.enable(for: [
    AmityUserNotificationModule(
        moduleType: .chat,
        isEnabled: true,
        roleFilter: nil
    ),
    AmityUserNotificationModule(
        moduleType: .social,
        isEnabled: true,
        roleFilter: AmityRoleFilter.onlyFilter(withRoleIds: ["community-moderator"])
    ),
    AmityUserNotificationModule(
        moduleType: .videoStreaming,
        isEnabled: false,
        roleFilter: nil
    ),
])

try await notificationManager.disableAllNotifications()

val rolesFilter = AmityRolesFilter.ONLY(AmityRoles(listOf("community-moderator")))

val chatModifier = AmityUserNotificationModule.CHAT.enable()
val socialModifier = AmityUserNotificationModule.SOCIAL.enable(rolesFilter)
val videoStreamingModifier = AmityUserNotificationModule.VIDEO_STREAMING.disable()

AmityCoreClient.notifications()
    .user()
    .enable(
        moduleModifiers = listOf(
            chatModifier,
            socialModifier,
            videoStreamingModifier
        )
    )
    .doOnComplete {
        // User notification settings updated.
    }
    .doOnError { error ->
        // Handle error.
    }
    .subscribe()

AmityCoreClient.notifications()
    .user()
    .disableAllNotifications()
    .subscribe()

final rolesFilter = Only(AmityRoles(roles: ['community-moderator']));

await AmityCoreClient
    .notifications()
    .user()
    .enable([
      Chat.enable(null),
      Social.enable(rolesFilter),
      VideoStreaming.disable(),
    ]);

await AmityCoreClient
    .notifications()
    .user()
    .disable();