How to use the network/middleware/rpc.RpcRealm.Server function in network

avatar,
      color: info.color,
      pending: shouldAwaitAuthorization
    })
  )

  if (shouldAwaitAuthorization) {
    const content = translateEscaped('noticeUserRequestJoin', { userId: id, username: name })
    dispatch(addChat({ content, html: true, timestamp: Date.now() }))
    return ClientInitResponse.Pending
  }

  dispatch(authorizeClient(client))
  return ClientInitResponse.Ok
}
const server_initClient = rpc('initClient', RpcRealm.Server, initClient, {
  allowUnauthed: true
})

const authorizeClient = (client: NetConnection): AppThunkAction => {
  return async (dispatch, getState) => {
    const id = client.id.toString()
    dispatch(multi_userJoined(id))

    // Client has been fully authorized
    client.auth()

    dispatch(client_authorized({ serverTime: Date.now() })(id))
  }
}

const answerClient = (userId: string, allow: boolean): RpcThunk => (

const requestPlayPause = (): RpcThunk => (dispatch, getState, context) => {
  const state = getState()
  if (!hasPlaybackPermissions(state, context.client)) return

  const playback = getPlaybackState(state)
  const curTime = getPlaybackTime(state)

  switch (playback) {
    case PlaybackState.Playing:
    case PlaybackState.Paused:
      dispatch(playPauseMedia(curTime))
      dispatch(updatePlaybackTimer())
      break
  }
}
export const server_requestPlayPause = rpc('requestPlayPause', RpcRealm.Server, requestPlayPause)

const requestNextMedia = (): RpcThunk => (dispatch, getState, context) => {
  if (!hasPlaybackPermissions(getState(), context.client)) return
  dispatch(nextMedia())
}
export const server_requestNextMedia = rpc('requestNextMedia', RpcRealm.Server, requestNextMedia)

const requestRepeatMedia = (): RpcThunk => (dispatch, getState, context) => {
  if (!hasPlaybackPermissions(getState(), context.client)) return
  dispatch(repeatMedia())
}
export const server_requestRepeatMedia = rpc(
  'requestRepeatMedia',
  RpcRealm.Server,
  requestRepeatMedia
)

if (userId === localUserId()) return
  dispatch(recordTyping(userId))

  let timeout = userTypingTimeouts[userId]
  if (timeout) clearTimeout(timeout)
  userTypingTimeouts[userId] = setTimeout(() => {
    dispatch(clearTyping(userId))
  }, TYPING_DURATION) as any
}
const multi_broadcastTyping = rpc('broadcastTyping', RpcRealm.Multicast, broadcastTyping)

const rpcNotifyTyping = (): RpcThunk => (dispatch, getState, context) => {
  const userId = context.client.id.toString()
  dispatch(multi_broadcastTyping(userId))
}
export const server_notifyTyping = rpc('rpcNotifyTyping', RpcRealm.Server, rpcNotifyTyping)

}
export const multi_broadcastChat = rpc('broadcastChat', RpcRealm.Multicast, broadcastChat)

const rpcAddChat = (text: string): RpcThunk => (dispatch, getState, context) => {
  text = text.trim()
  if (text.length === 0) return false

  if (text.length > CHAT_MAX_MESSAGE_LENGTH) {
    text = text.substr(0, CHAT_MAX_MESSAGE_LENGTH)
  }

  const userId = context.client.id.toString()
  dispatch(multi_broadcastChat(text, userId))
  return true
}
const server_addChat = rpc('rpcAddChat', RpcRealm.Server, rpcAddChat)

export const sendChat = (text: string): AppThunkAction => {
  return async (dispatch, getState) => {
    if (isUrl(text)) {
      dispatch(sendMediaRequest({ url: text, source: 'chat' }))
      return
    }

    try {
      await dispatch(server_addChat(text))
    } catch {
      const content = t('chatMessageFailed')
      dispatch(addChat({ content, timestamp: Date.now() }))
    }
  }
}

requestDeleteMedia
)

const requestMoveToTop = (mediaId: string): RpcThunk => (dispatch, getState, context) => {
  if (!hasPlaybackPermissions(getState(), context.client)) return
  dispatch(moveToTop(mediaId))
}
export const server_requestMoveToTop = rpc('requestMoveToTop', RpcRealm.Server, requestMoveToTop)

const requestToggleQueueLock = (): RpcThunk => (dispatch, getState, context) => {
  if (!hasPlaybackPermissions(getState(), context.client)) return
  dispatch(lockQueue())
}
export const server_requestToggleQueueLock = rpc(
  'requestToggleQueueLock',
  RpcRealm.Server,
  requestToggleQueueLock
)

) => {
  const state = getState()
  const requesterId = context.client.id.toString()

  if (requesterId === targetId) return
  if (!isAdmin(state, requesterId)) return

  dispatch(
    setUserRole({
      userId: targetId,
      role,
      enabled: !hasRole(state, targetId, role)
    })
  )
}
export const server_toggleUserRole = rpc('toggleUserRole', RpcRealm.Server, toggleUserRole)

const requestUpdateUser = (newProfile: Partial): RpcThunk => (
  dispatch,
  getState,
  context
) => {
  const state = getState()
  const userId = context.client.id.toString()
  const user = getUser(state, userId)
  if (!user) return

  let nextName, nextColor, nextAvatar

  const { name, color, avatar } = newProfile
  if (name && validateDisplayName(name) && name !== user.name) {
    nextName = getUniqueName(state, name)

const requesterId = context.client.id.toString()

  if (requesterId === targetId) return
  if (!isAdmin(state, requesterId)) return

  const target = getUser(state, targetId)
  if (target) {
    dispatch(client_kick(NetworkDisconnectReason.Kicked)(targetId))

    const conn = context.server.getClientById(targetId)
    if (conn) {
      conn.close()
    }
  }
}
export const server_kickUser = rpc('kickUser', RpcRealm.Server, kickUser)

const toggleUserRole = (targetId: string, role: UserRole): RpcThunk => (
  dispatch,
  getState,
  context
) => {
  const state = getState()
  const requesterId = context.client.id.toString()

  if (requesterId === targetId) return
  if (!isAdmin(state, requesterId)) return

  dispatch(
    setUserRole({
      userId: targetId,
      role,

if (!isAdmin(state, client.id.toString())) return

  const user = getUser(state, userId)
  if (!user || !user.pending) return

  const userClient = server.getClientById(userId)
  if (!userClient) return

  if (allow) {
    dispatch(clearPendingUser(userId))
    dispatch(authorizeClient(userClient))
  } else {
    userClient.close()
  }
}
export const server_answerClient = rpc('answerClient', RpcRealm.Server, answerClient)