Handle kick, rename server to network

client/js/modules/documentTitle.js

@@ -1,18 +1,18 @@
 import capitalize from 'lodash/capitalize';
 import { getRouter } from 'state';
-import { getCurrentServerName } from 'state/servers';
+import { getCurrentNetworkName } from 'state/networks';
 import { observe } from 'utils/observe';
 
 export default function documentTitle({ store }) {
-  observe(store, [getRouter, getCurrentServerName], (router, serverName) => {
+  observe(store, [getRouter, getCurrentNetworkName], (router, networkName) => {
     let title;
 
     if (router.route === 'chat') {
-      const { server, name } = router.params;
+      const { network, name } = router.params;
       if (name) {
-        title = `${name} @ ${serverName || server}`;
+        title = `${name} @ ${networkName || network}`;
       } else {
-        title = serverName || server;
+        title = networkName || network;
       }
     } else {
       title = capitalize(router.route);

client/js/modules/initialState.js

@@ -8,15 +8,15 @@ import { when } from 'utils/observe';
 function loadState({ store }, env) {
   store.dispatch(setSettings(env.settings, true));
 
-  if (env.servers) {
+  if (env.networks) {
     store.dispatch({
-      type: socketActions.SERVERS,
-      data: env.servers
+      type: socketActions.NETWORKS,
+      data: env.networks
     });
 
     when(store, getConnected, () =>
-      // Cache top channels for each server
-      env.servers.forEach(({ host }) =>
+      // Cache top channels for each network
+      env.networks.forEach(({ host }) =>
         store.dispatch(searchChannels(host, ''))
       )
     );
@@ -56,8 +56,8 @@ function loadState({ store }, env) {
     // Wait until wrapWidth gets initialized so that height calculations
     // only happen once for these messages
     when(store, getWrapWidth, () => {
-      const { messages, server, to, next } = env.messages;
-      store.dispatch(addMessages(messages, server, to, false, next));
+      const { messages, network, to, next } = env.messages;
+      store.dispatch(addMessages(messages, network, to, false, next));
     });
   }
 }

client/js/modules/socket.js

@@ -1,4 +1,5 @@
 import { socketAction } from 'state/actions';
+import { kicked } from 'state/channels';
 import {
   print,
   addMessage,
@@ -7,15 +8,15 @@ import {
   broadcastEvent
 } from 'state/messages';
 import { openModal } from 'state/modals';
-import { reconnect } from 'state/servers';
+import { reconnect } from 'state/networks';
 import { select } from 'state/tab';
 import { find } from 'utils';
 
-function findChannels(state, server, user) {
+function findChannels(state, network, user) {
   const channels = [];
 
-  Object.keys(state.channels[server]).forEach(channel => {
-    if (find(state.channels[server][channel].users, u => u.nick === user)) {
+  Object.keys(state.channels[network]).forEach(channel => {
+    if (find(state.channels[network][channel].users, u => u.nick === user)) {
       channels.push(channel);
     }
   });
@@ -29,51 +30,56 @@ export default function handleSocket({
 }) {
   const handlers = {
     message(message) {
-      dispatch(addMessage(message, message.server, message.to));
+      dispatch(addMessage(message, message.network, message.to));
       return false;
     },
 
     pm(message) {
-      dispatch(addMessage(message, message.server, message.from));
+      dispatch(addMessage(message, message.network, message.from));
       return false;
     },
 
-    messages({ messages, server, to, prepend, next }) {
-      dispatch(addMessages(messages, server, to, prepend, next));
+    messages({ messages, network, to, prepend, next }) {
+      dispatch(addMessages(messages, network, to, prepend, next));
       return false;
     },
 
-    join({ user, server, channels }) {
-      dispatch(addEvent(server, channels[0], 'join', user));
+    join({ user, network, channels }) {
+      dispatch(addEvent(network, channels[0], 'join', user));
     },
 
-    part({ user, server, channel, reason }) {
-      dispatch(addEvent(server, channel, 'part', user, reason));
+    part({ user, network, channel, reason }) {
+      dispatch(addEvent(network, channel, 'part', user, reason));
     },
 
-    quit({ user, server, reason }) {
-      const channels = findChannels(getState(), server, user);
-      dispatch(broadcastEvent(server, channels, 'quit', user, reason));
+    quit({ user, network, reason }) {
+      const channels = findChannels(getState(), network, user);
+      dispatch(broadcastEvent(network, channels, 'quit', user, reason));
     },
 
-    nick({ server, oldNick, newNick }) {
+    kick({ network, channel, sender, user, reason }) {
+      dispatch(kicked(network, channel, user));
+      dispatch(addEvent(network, channel, 'kick', user, sender, reason));
+    },
+
+    nick({ network, oldNick, newNick }) {
       if (oldNick) {
-        const channels = findChannels(getState(), server, oldNick);
-        dispatch(broadcastEvent(server, channels, 'nick', oldNick, newNick));
+        const channels = findChannels(getState(), network, oldNick);
+        dispatch(broadcastEvent(network, channels, 'nick', oldNick, newNick));
       }
     },
 
-    topic({ server, channel, topic, nick }) {
+    topic({ network, channel, topic, nick }) {
       if (nick) {
-        dispatch(addEvent(server, channel, 'topic', nick, topic));
+        dispatch(addEvent(network, channel, 'topic', nick, topic));
       }
     },
 
-    motd({ content, server }) {
+    motd({ content, network }) {
       dispatch(
         addMessages(
           content.map(line => ({ content: line })),
-          server
+          network
         )
       );
       return false;
@@ -92,7 +98,7 @@ export default function handleSocket({
             `Server: ${data.server}`,
             `Channels: ${data.channels}`
           ],
-          tab.server,
+          tab.network,
           tab.name
         )
       );
@@ -101,24 +107,26 @@ export default function handleSocket({
 
     print(message) {
       const tab = getState().tab.selected;
-      dispatch(addMessage(message, tab.server, tab.name));
+      dispatch(addMessage(message, tab.network, tab.name));
       return false;
     },
 
-    error({ server, target, message }) {
-      dispatch(addMessage({ content: message, type: 'error' }, server, target));
+    error({ network, target, message }) {
+      dispatch(
+        addMessage({ content: message, type: 'error' }, network, target)
+      );
       return false;
     },
 
-    connection_update({ server, errorType }) {
+    connection_update({ network, errorType }) {
       if (errorType === 'verify') {
         dispatch(
           openModal('confirm', {
             question:
-              'The server is using a self-signed certificate, continue anyway?',
+              'The network is using a self-signed certificate, continue anyway?',
             onConfirm: () =>
               dispatch(
-                reconnect(server, {
+                reconnect(network, {
                   skipVerify: true
                 })
               )
@@ -127,12 +135,12 @@ export default function handleSocket({
       }
     },
 
-    dcc_send({ server, from, filename, url }) {
-      const serverName = getState().servers[server]?.name || server;
+    dcc_send({ network, from, filename, url }) {
+      const networkName = getState().networks[network]?.name || network;
 
       dispatch(
         openModal('confirm', {
-          question: `${from} on ${serverName} is sending you: ${filename}`,
+          question: `${from} on ${networkName} is sending you: ${filename}`,
           confirmation: 'Download',
           onConfirm: () => {
             const a = document.createElement('a');
@@ -148,8 +156,11 @@ export default function handleSocket({
     channel_forward(forward) {
       const { selected } = getState().tab;
 
-      if (selected.server === forward.server && selected.name === forward.old) {
-        dispatch(select(forward.server, forward.new, true));
+      if (
+        selected.network === forward.network &&
+        selected.name === forward.old
+      ) {
+        dispatch(select(forward.network, forward.new, true));
       }
     }
   };

client/js/modules/storage.js

@@ -11,7 +11,7 @@ const saveTab = debounce(
 
 export default function storage({ store }) {
   observe(store, getSelectedTab, tab => {
-    if (tab.server) {
+    if (tab.network) {
       saveTab(tab);
     }
   });