client/src/models/network.js

   1 (function () {
   2
   3     _kiwi.model.Network = Backbone.Model.extend({
   4         defaults: {
   5             connection_id: 0,
   6             /**
   7             *   The name of the network
   8             *   @type    String
   9             */
  10             name: 'Network',
  11
  12             /**
  13             *   The address (URL) of the network
  14             *   @type    String
  15             */
  16             address: '',
  17
  18             /**
  19             *   The port for the network
  20             *   @type    Int
  21             */
  22             port: 6667,
  23
  24             /**
  25             *   If this network uses SSL
  26             *   @type    Bool
  27             */
  28             ssl: false,
  29
  30             /**
  31             *   The password to connect to this network
  32             *   @type    String
  33             */
  34             password: '',
  35
  36             /**
  37             *   The current nickname
  38             *   @type   String
  39             */
  40             nick: '',
  41
  42             /**
  43             *   The channel prefix for this network
  44             *   @type    String
  45             */
  46             channel_prefix: '#',
  47
  48             /**
  49             *   The user prefixes for channel owner/admin/op/voice etc. on this network
  50             *   @type   Array
  51             */
  52             user_prefixes: [
  53                 {symbol: '~', mode: 'q'},
  54                 {symbol: '&', mode: 'a'},
  55                 {symbol: '@', mode: 'o'},
  56                 {symbol: '%', mode: 'h'},
  57                 {symbol: '+', mode: 'v'}
  58             ],
  59
  60             /**
  61             *   List of nicks we are ignoring
  62             *   @type Array
  63             */
  64             ignore_list: []
  65         },
  66
  67
  68         initialize: function () {
  69             // If we already have a connection, bind our events
  70             if (typeof this.get('connection_id') !== 'undefined') {
  71                 this.gateway = _kiwi.global.components.Network(this.get('connection_id'));
  72                 this.bindGatewayEvents();
  73             }
  74
  75             // Create our panel list (tabs)
  76             this.panels = new _kiwi.model.PanelList([], this);
  77             //this.panels.network = this;
  78
  79             // Automatically create a server tab
  80             var server_panel = new _kiwi.model.Server({name: 'Server', network: this});
  81             this.panels.add(server_panel);
  82             this.panels.server = this.panels.active = server_panel;
  83         },
  84
  85
  86         reconnect: function(callback_fn) {
  87             var that = this,
  88                 server_info = {
  89                     nick:       this.get('nick'),
  90                     host:       this.get('address'),
  91                     port:       this.get('port'),
  92                     ssl:        this.get('ssl'),
  93                     password:   this.get('password')
  94                 };
  95
  96             _kiwi.gateway.makeIrcConnection(server_info, function(err, connection_id) {
  97                 if (!err) {
  98                     that.gateway.dispose();
  99
 100                     that.set('connection_id', connection_id);
 101                     that.gateway = _kiwi.global.components.Network(that.get('connection_id'));
 102                     that.bindGatewayEvents();
 103
 104                     // Reset each of the panels connection ID
 105                     that.panels.forEach(function(panel) {
 106                         panel.set('connection_id', connection_id);
 107                     });
 108
 109                     callback_fn && callback_fn(err);
 110
 111                 } else {
 112                     console.log("_kiwi.gateway.socket.on('error')", {reason: err});
 113                     callback_fn && callback_fn(err);
 114                 }
 115             });
 116         },
 117
 118
 119         bindGatewayEvents: function () {
 120             //this.gateway.on('all', function() {console.log('ALL', this.get('connection_id'), arguments);});
 121
 122             this.gateway.on('connect', onConnect, this);
 123             this.gateway.on('disconnect', onDisconnect, this);
 124
 125             this.gateway.on('nick', function(event) {
 126                 if (event.nick === this.get('nick')) {
 127                     this.set('nick', event.newnick);
 128                 }
 129             }, this);
 130
 131             this.gateway.on('options', onOptions, this);
 132             this.gateway.on('motd', onMotd, this);
 133             this.gateway.on('channel:join', onJoin, this);
 134             this.gateway.on('channel:part', onPart, this);
 135             this.gateway.on('channel:kick', onKick, this);
 136             this.gateway.on('quit', onQuit, this);
 137             this.gateway.on('message', onMessage, this);
 138             this.gateway.on('nick', onNick, this);
 139             this.gateway.on('ctcp_request', onCtcpRequest, this);
 140             this.gateway.on('ctcp_response', onCtcpResponse, this);
 141             this.gateway.on('topic', onTopic, this);
 142             this.gateway.on('topicsetby', onTopicSetBy, this);
 143             this.gateway.on('userlist', onUserlist, this);
 144             this.gateway.on('userlist_end', onUserlistEnd, this);
 145             this.gateway.on('banlist', onBanlist, this);
 146             this.gateway.on('mode', onMode, this);
 147             this.gateway.on('whois', onWhois, this);
 148             this.gateway.on('whowas', onWhowas, this);
 149             this.gateway.on('away', onAway, this);
 150             this.gateway.on('list_start', onListStart, this);
 151             this.gateway.on('irc_error', onIrcError, this);
 152             this.gateway.on('unknown_command', onUnknownCommand, this);
 153             this.gateway.on('channel_info', onChannelInfo, this);
 154             this.gateway.on('wallops', onWallops, this);
 155         },
 156
 157
 158         /**
 159          * Create panels and join the channel
 160          * This will not wait for the join event to create a panel. This
 161          * increases responsiveness in case of network lag
 162          */
 163         createAndJoinChannels: function (channels) {
 164             var that = this,
 165                 panels = [];
 166
 167             // Multiple channels may come as comma-delimited
 168             if (typeof channels === 'string') {
 169                 channels = channels.split(',');
 170             }
 171
 172             $.each(channels, function (index, channel_name_key) {
 173                 // We may have a channel key so split it off
 174                 var spli = channel_name_key.trim().split(' '),
 175                     channel_name = spli[0],
 176                     channel_key = spli[1] || '';
 177
 178                 // Trim any whitespace off the name
 179                 channel_name = channel_name.trim();
 180
 181                 // Add channel_prefix in front of the first channel if missing
 182                 if (that.get('channel_prefix').indexOf(channel_name[0]) === -1) {
 183                     // Could be many prefixes but '#' is highly likely the required one
 184                     channel_name = '#' + channel_name;
 185                 }
 186
 187                 // Check if we have the panel already. If not, create it
 188                 channel = that.panels.getByName(channel_name);
 189                 if (!channel) {
 190                     channel = new _kiwi.model.Channel({name: channel_name, network: that});
 191                     that.panels.add(channel);
 192                 }
 193
 194                 panels.push(channel);
 195
 196                 that.gateway.join(channel_name, channel_key);
 197             });
 198
 199
 200             return panels;
 201         },
 202
 203
 204         /**
 205          * Join all the open channels we have open
 206          * Reconnecting to a network would typically call this.
 207          */
 208         rejoinAllChannels: function() {
 209             var that = this;
 210
 211             this.panels.forEach(function(panel) {
 212                 if (!panel.isChannel())
 213                     return;
 214
 215                 that.gateway.join(panel.get('name'));
 216             });
 217         },
 218
 219         isChannelName: function (channel_name) {
 220             var channel_prefix = this.get('channel_prefix');
 221
 222             if (!channel_name || !channel_name.length) return false;
 223             return (channel_prefix.indexOf(channel_name[0]) > -1);
 224         },
 225
 226         // Check a nick alongside our ignore list
 227         isNickIgnored: function (nick) {
 228             var idx, list = this.get('ignore_list');
 229             var pattern, regex;
 230
 231             for (idx = 0; idx < list.length; idx++) {
 232                 pattern = list[idx].replace(/([.+^$[\]\\(){}|-])/g, "\\$1")
 233                     .replace('*', '.*')
 234                     .replace('?', '.');
 235
 236                 regex = new RegExp(pattern, 'i');
 237                 if (regex.test(nick)) return true;
 238             }
 239
 240             return false;
 241         },
 242
 243         // Create a new query panel
 244         createQuery: function (nick) {
 245             var that = this,
 246                 query;
 247
 248             // Check if we have the panel already. If not, create it
 249             query = that.panels.getByName(nick);
 250             if (!query) {
 251                 query = new _kiwi.model.Query({name: nick});
 252                 that.panels.add(query);
 253             }
 254
 255             // In all cases, show the demanded query
 256             query.view.show();
 257
 258             return query;
 259         }
 260     });
 261
 262
 263
 264     function onDisconnect(event) {
 265         $.each(this.panels.models, function (index, panel) {
 266             if (!panel.isApplet()) {
 267                 panel.addMsg('', styleText('network_disconnected', {text: translateText('client_models_network_disconnected', [])}), 'action quit');
 268             }
 269         });
 270     }
 271
 272
 273
 274     function onConnect(event) {
 275         var panels, channel_names;
 276
 277         // Update our nick with what the network gave us
 278         this.set('nick', event.nick);
 279
 280         // If this is a re-connection then we may have some channels to re-join
 281         this.rejoinAllChannels();
 282
 283         // Auto joining channels
 284         if (this.auto_join && this.auto_join.channel) {
 285             panels = this.createAndJoinChannels(this.auto_join.channel + ' ' + (this.auto_join.key || ''));
 286
 287             // Show the last channel if we have one
 288             if (panels)
 289                 panels[panels.length - 1].view.show();
 290
 291             delete this.auto_join;
 292         }
 293     }
 294
 295
 296
 297     function onOptions(event) {
 298         var that = this;
 299
 300         $.each(event.options, function (name, value) {
 301             switch (name) {
 302             case 'CHANTYPES':
 303                 that.set('channel_prefix', value.join(''));
 304                 break;
 305             case 'NETWORK':
 306                 that.set('name', value);
 307                 break;
 308             case 'PREFIX':
 309                 that.set('user_prefixes', value);
 310                 break;
 311             }
 312         });
 313
 314         this.set('cap', event.cap);
 315     }
 316
 317
 318
 319     function onMotd(event) {
 320         this.panels.server.addMsg(this.get('name'), styleText('motd', {text: event.msg}), 'motd');
 321     }
 322
 323
 324
 325     function onJoin(event) {
 326         var c, members, user;
 327         c = this.panels.getByName(event.channel);
 328         if (!c) {
 329             c = new _kiwi.model.Channel({name: event.channel, network: this});
 330             this.panels.add(c);
 331         }
 332
 333         members = c.get('members');
 334         if (!members) return;
 335
 336         // Do we already have this member?
 337         if (members.getByNick(event.nick)) {
 338             return;
 339         }
 340
 341         user = new _kiwi.model.Member({
 342             nick: event.nick,
 343             ident: event.ident,
 344             hostname: event.hostname,
 345             user_prefixes: this.get('user_prefixes')
 346         });
 347
 348         _kiwi.global.events.emit('channel:join', {channel: event.channel, user: user})
 349         .then(function() {
 350             members.add(user, {kiwi: event});
 351         });
 352     }
 353
 354
 355
 356     function onPart(event) {
 357         var channel, members, user,
 358             part_options = {};
 359
 360         part_options.type = 'part';
 361         part_options.message = event.message || '';
 362         part_options.time = event.time;
 363
 364         channel = this.panels.getByName(event.channel);
 365         if (!channel) return;
 366
 367         // If this is us, close the panel
 368         if (event.nick === this.get('nick')) {
 369             channel.close();
 370             return;
 371         }
 372
 373         members = channel.get('members');
 374         if (!members) return;
 375
 376         user = members.getByNick(event.nick);
 377         if (!user) return;
 378
 379         _kiwi.global.events.emit('channel:leave', {channel: event.channel, user: user, type: 'part', message: part_options.message})
 380         .then(function() {
 381             members.remove(user, {kiwi: part_options});
 382         });
 383     }
 384
 385
 386
 387     function onQuit(event) {
 388         var member, members,
 389             quit_options = {};
 390
 391         quit_options.type = 'quit';
 392         quit_options.message = event.message || '';
 393         quit_options.time = event.time;
 394
 395         $.each(this.panels.models, function (index, panel) {
 396             // Let any query panels know they quit
 397             if (panel.isQuery() && panel.get('name').toLowerCase() === event.nick.toLowerCase()) {
 398                 panel.addMsg(' ', styleText('channel_quit', {
 399                     nick: event.nick,
 400                     text: translateText('client_models_channel_quit', [quit_options.message])
 401                 }), 'action quit', {time: quit_options.time});
 402             }
 403
 404             // Remove the nick from any channels
 405             if (panel.isChannel()) {
 406                 member = panel.get('members').getByNick(event.nick);
 407                 if (member) {
 408                     _kiwi.global.events.emit('channel:leave', {channel: panel.get('name'), user: member, type: 'quit', message: part_options.message})
 409                     .then(function() {
 410                         panel.get('members').remove(member, {kiwi: quit_options});
 411                     });
 412                 }
 413             }
 414         });
 415     }
 416
 417
 418
 419     function onKick(event) {
 420         var channel, members, user,
 421             part_options = {};
 422
 423         part_options.type = 'kick';
 424         part_options.by = event.nick;
 425         part_options.message = event.message || '';
 426         part_options.current_user_kicked = (event.kicked == this.get('nick'));
 427         part_options.current_user_initiated = (event.nick == this.get('nick'));
 428         part_options.time = event.time;
 429
 430         channel = this.panels.getByName(event.channel);
 431         if (!channel) return;
 432
 433         members = channel.get('members');
 434         if (!members) return;
 435
 436         user = members.getByNick(event.kicked);
 437         if (!user) return;
 438
 439
 440         _kiwi.global.events.emit('channel:leave', {channel: event.channel, user: user, type: 'kick', message: part_options.message})
 441         .then(function() {
 442             members.remove(user, {kiwi: part_options});
 443
 444             if (part_options.current_user_kicked) {
 445                 members.reset([]);
 446             }
 447         });
 448     }
 449
 450
 451
 452     function onMessage(event) {
 453         _kiwi.global.events.emit('message:new', {network: this, message: event})
 454         .then(_.bind(function() {
 455             var panel,
 456                 is_pm = ((event.target || '').toLowerCase() == this.get('nick').toLowerCase());
 457
 458             // An ignored user? don't do anything with it
 459             if (this.isNickIgnored(event.nick)) {
 460                 return;
 461             }
 462
 463             if (event.type == 'notice') {
 464                 if (event.from_server) {
 465                     panel = this.panels.server;
 466
 467                 } else {
 468                     panel = this.panels.getByName(event.target) || this.panels.getByName(event.nick);
 469
 470                     // Forward ChanServ messages to its associated channel
 471                     if (event.nick && event.nick.toLowerCase() == 'chanserv' && event.msg.charAt(0) == '[') {
 472                         channel_name = /\[([^ \]]+)\]/gi.exec(event.msg);
 473                         if (channel_name && channel_name[1]) {
 474                             channel_name = channel_name[1];
 475
 476                             panel = this.panels.getByName(channel_name);
 477                         }
 478                     }
 479
 480                 }
 481
 482                 if (!panel) {
 483                     panel = this.panels.server;
 484                 }
 485
 486             } else if (is_pm) {
 487                 // If a panel isn't found for this PM, create one
 488                 panel = this.panels.getByName(event.nick);
 489                 if (!panel) {
 490                     panel = new _kiwi.model.Query({name: event.nick, network: this});
 491                     this.panels.add(panel);
 492                 }
 493
 494             } else {
 495                 // If a panel isn't found for this target, reroute to the
 496                 // server panel
 497                 panel = this.panels.getByName(event.target);
 498                 if (!panel) {
 499                     panel = this.panels.server;
 500                 }
 501             }
 502
 503             switch (event.type){
 504             case 'message':
 505                 panel.addMsg(event.nick, styleText('privmsg', {text: event.msg}), 'privmsg', {time: event.time});
 506                 break;
 507
 508             case 'action':
 509                 panel.addMsg('', styleText('action', {nick: event.nick, text: event.msg}), 'action', {time: event.time});
 510                 break;
 511
 512             case 'notice':
 513                 panel.addMsg('[' + (event.nick||'') + ']', styleText('notice', {text: event.msg}), 'notice', {time: event.time});
 514
 515                 // Show this notice to the active panel if it didn't have a set target, but only in an active channel or query window
 516                 active_panel = _kiwi.app.panels().active;
 517
 518                 if (!event.from_server && panel === this.panels.server && active_panel !== this.panels.server) {
 519                     if (active_panel.get('network') === this && (active_panel.isChannel() || active_panel.isQuery()))
 520                         active_panel.addMsg('[' + (event.nick||'') + ']', styleText('notice', {text: event.msg}), 'notice', {time: event.time});
 521                 }
 522                 break;
 523             }
 524         }, this));
 525     }
 526
 527
 528
 529     function onNick(event) {
 530         var member;
 531
 532         $.each(this.panels.models, function (index, panel) {
 533             if (panel.get('name') == event.nick)
 534                 panel.set('name', event.newnick);
 535
 536             if (!panel.isChannel()) return;
 537
 538             member = panel.get('members').getByNick(event.nick);
 539             if (member) {
 540                 member.set('nick', event.newnick);
 541                 panel.addMsg('', styleText('nick_changed', {nick: event.nick, text: translateText('client_models_network_nickname_changed', [event.newnick]), channel: name}), 'action nick', {time: event.time});
 542             }
 543         });
 544     }
 545
 546
 547
 548     function onCtcpRequest(event) {
 549         // An ignored user? don't do anything with it
 550         if (this.isNickIgnored(event.nick)) {
 551             return;
 552         }
 553
 554         // Reply to a TIME ctcp
 555         if (event.msg.toUpperCase() === 'TIME') {
 556             this.gateway.ctcpResponse(event.type, event.nick, (new Date()).toString());
 557         } else if(event.type.toUpperCase() === 'PING') { // CTCP PING reply
 558             this.gateway.ctcpResponse(event.type, event.nick, event.msg.substr(5));
 559         }
 560     }
 561
 562
 563
 564     function onCtcpResponse(event) {
 565         // An ignored user? don't do anything with it
 566         if (this.isNickIgnored(event.nick)) {
 567             return;
 568         }
 569
 570         this.panels.server.addMsg('[' + event.nick + ']',  styleText('ctcp', {text: event.msg}), 'ctcp', {time: event.time});
 571     }
 572
 573
 574
 575     function onTopic(event) {
 576         var c;
 577         c = this.panels.getByName(event.channel);
 578         if (!c) return;
 579
 580         // Set the channels topic
 581         c.set('topic', event.topic);
 582
 583         // If this is the active channel, update the topic bar too
 584         if (c.get('name') === this.panels.active.get('name')) {
 585             _kiwi.app.topicbar.setCurrentTopic(event.topic);
 586         }
 587     }
 588
 589
 590
 591     function onTopicSetBy(event) {
 592         var c, when;
 593         c = this.panels.getByName(event.channel);
 594         if (!c) return;
 595
 596         when = new Date(event.when * 1000);
 597         c.set('topic_set_by', {nick: event.nick, when: when});
 598     }
 599
 600
 601
 602     function onChannelInfo(event) {
 603         var channel = this.panels.getByName(event.channel);
 604         if (!channel) return;
 605
 606         if (event.url) {
 607             channel.set('info_url', event.url);
 608         } else if (event.modes) {
 609             channel.set('info_modes', event.modes);
 610         }
 611     }
 612
 613
 614
 615     function onUserlist(event) {
 616         var that = this,
 617             channel = this.panels.getByName(event.channel);
 618
 619         // If we didn't find a channel for this, may aswell leave
 620         if (!channel) return;
 621
 622         channel.temp_userlist = channel.temp_userlist || [];
 623         _.each(event.users, function (item) {
 624             var user = new _kiwi.model.Member({
 625                 nick: item.nick,
 626                 modes: item.modes,
 627                 user_prefixes: that.get('user_prefixes')
 628             });
 629             channel.temp_userlist.push(user);
 630         });
 631     }
 632
 633
 634
 635     function onUserlistEnd(event) {
 636         var channel;
 637         channel = this.panels.getByName(event.channel);
 638
 639         // If we didn't find a channel for this, may aswell leave
 640         if (!channel) return;
 641
 642         // Update the members list with the new list
 643         channel.get('members').reset(channel.temp_userlist || []);
 644
 645         // Clear the temporary userlist
 646         delete channel.temp_userlist;
 647     }
 648
 649
 650
 651     function onBanlist(event) {
 652         var channel = this.panels.getByName(event.channel);
 653         if (!channel)
 654             return;
 655
 656         channel.set('banlist', event.bans || []);
 657     }
 658
 659
 660
 661     function onMode(event) {
 662         var channel, i, prefixes, members, member, find_prefix,
 663             request_updated_banlist = false;
 664
 665         // Build a nicely formatted string to be displayed to a regular human
 666         function friendlyModeString (event_modes, alt_target) {
 667             var modes = {}, return_string;
 668
 669             // If no default given, use the main event info
 670             if (!event_modes) {
 671                 event_modes = event.modes;
 672                 alt_target = event.target;
 673             }
 674
 675             // Reformat the mode object to make it easier to work with
 676             _.each(event_modes, function (mode){
 677                 var param = mode.param || alt_target || '';
 678
 679                 // Make sure we have some modes for this param
 680                 if (!modes[param]) {
 681                     modes[param] = {'+':'', '-':''};
 682                 }
 683
 684                 modes[param][mode.mode[0]] += mode.mode.substr(1);
 685             });
 686
 687             // Put the string together from each mode
 688             return_string = [];
 689             _.each(modes, function (modeset, param) {
 690                 var str = '';
 691                 if (modeset['+']) str += '+' + modeset['+'];
 692                 if (modeset['-']) str += '-' + modeset['-'];
 693                 return_string.push(str + ' ' + param);
 694             });
 695             return_string = return_string.join(', ');
 696
 697             return return_string;
 698         }
 699
 700
 701         channel = this.panels.getByName(event.target);
 702         if (channel) {
 703             prefixes = this.get('user_prefixes');
 704             find_prefix = function (p) {
 705                 return event.modes[i].mode[1] === p.mode;
 706             };
 707             for (i = 0; i < event.modes.length; i++) {
 708                 if (_.any(prefixes, find_prefix)) {
 709                     if (!members) {
 710                         members = channel.get('members');
 711                     }
 712                     member = members.getByNick(event.modes[i].param);
 713                     if (!member) {
 714                         console.log('MODE command recieved for unknown member %s on channel %s', event.modes[i].param, event.target);
 715                         return;
 716                     } else {
 717                         if (event.modes[i].mode[0] === '+') {
 718                             member.addMode(event.modes[i].mode[1]);
 719                         } else if (event.modes[i].mode[0] === '-') {
 720                             member.removeMode(event.modes[i].mode[1]);
 721                         }
 722                         members.sort();
 723                     }
 724                 } else {
 725                     // Channel mode being set
 726                     // TODO: Store this somewhere?
 727                     //channel.addMsg('', 'CHANNEL === ' + event.nick + ' set mode ' + event.modes[i].mode + ' on ' + event.target, 'action mode');
 728                 }
 729
 730                 // TODO: Be smart, remove this specific ban from the banlist rather than request a whole banlist
 731                 if (event.modes[i].mode[1] == 'b')
 732                     request_updated_banlist = true;
 733             }
 734
 735             channel.addMsg('', styleText('mode', {nick: event.nick, text: translateText('client_models_network_mode', [friendlyModeString()]), channel: event.target}), 'action mode', {time: event.time});
 736
 737             // TODO: Be smart, remove the specific ban from the banlist rather than request a whole banlist
 738             if (request_updated_banlist)
 739                 this.gateway.raw('MODE ' + channel.get('name') + ' +b');
 740
 741         } else {
 742             // This is probably a mode being set on us.
 743             if (event.target.toLowerCase() === this.get("nick").toLowerCase()) {
 744                 this.panels.server.addMsg('', styleText('selfmode', {nick: event.nick, text: translateText('client_models_network_mode', [friendlyModeString()]), channel: event.target}), 'action mode');
 745             } else {
 746                console.log('MODE command recieved for unknown target %s: ', event.target, event);
 747             }
 748         }
 749     }
 750
 751
 752
 753     function onWhois(event) {
 754         var logon_date, idle_time = '', panel;
 755
 756         if (event.end)
 757             return;
 758
 759         if (typeof event.idle !== 'undefined') {
 760             idle_time = secondsToTime(parseInt(event.idle, 10));
 761             idle_time = idle_time.h.toString().lpad(2, "0") + ':' + idle_time.m.toString().lpad(2, "0") + ':' + idle_time.s.toString().lpad(2, "0");
 762         }
 763
 764         panel = _kiwi.app.panels().active;
 765         if (event.ident) {
 766             panel.addMsg(event.nick, styleText('whois_ident', {nick: event.nick, ident: event.ident, host: event.hostname, text: event.msg}), 'whois');
 767
 768         } else if (event.chans) {
 769             panel.addMsg(event.nick, styleText('whois_channels', {nick: event.nick, text: translateText('client_models_network_channels', [event.chans])}), 'whois');
 770         } else if (event.irc_server) {
 771             panel.addMsg(event.nick, styleText('whois_server', {nick: event.nick, text: translateText('client_models_network_server', [event.irc_server, event.server_info])}), 'whois');
 772         } else if (event.msg) {
 773             panel.addMsg(event.nick, styleText('whois', {text: event.msg}), 'whois');
 774         } else if (event.logon) {
 775             logon_date = new Date();
 776             logon_date.setTime(event.logon * 1000);
 777             logon_date = formatDate(logon_date);
 778
 779             panel.addMsg(event.nick, styleText('whois_idle_and_signon', {nick: event.nick, text: translateText('client_models_network_idle_and_signon', [idle_time, logon_date])}), 'whois');
 780         } else if (event.away_reason) {
 781             panel.addMsg(event.nick, styleText('whois_away', {nick: event.nick, text: translateText('client_models_network_away', [event.away_reason])}), 'whois');
 782         } else {
 783             panel.addMsg(event.nick, styleText('whois_idle', {nick: event.nick, text: translateText('client_models_network_idle', [idle_time])}), 'whois');
 784         }
 785     }
 786
 787     function onWhowas(event) {
 788         var panel;
 789
 790         if (event.end)
 791             return;
 792
 793         panel = _kiwi.app.panels().active;
 794         if (event.hostname) {
 795             panel.addMsg(event.nick, styleText('who', {nick: event.nick, ident: event.ident, host: event.hostname, realname: event.real_name, text: event.msg}), 'whois');
 796         } else {
 797             panel.addMsg(event.nick, styleText('whois_notfound', {nick: event.nick, text: translateText('client_models_network_nickname_notfound', [])}), 'whois');
 798         }
 799     }
 800
 801
 802     function onAway(event) {
 803         $.each(this.panels.models, function (index, panel) {
 804             if (!panel.isChannel()) return;
 805
 806             member = panel.get('members').getByNick(event.nick);
 807             if (member) {
 808                 member.set('away', !(!event.reason));
 809             }
 810         });
 811     }
 812
 813
 814
 815     function onListStart(event) {
 816         var chanlist = _kiwi.model.Applet.loadOnce('kiwi_chanlist');
 817         chanlist.view.show();
 818     }
 819
 820
 821
 822     function onIrcError(event) {
 823         var panel, tmp;
 824
 825         if (event.channel !== undefined && !(panel = this.panels.getByName(event.channel))) {
 826             panel = this.panels.server;
 827         }
 828
 829         switch (event.error) {
 830         case 'banned_from_channel':
 831             panel.addMsg(' ', styleText('channel_banned', {nick: event.nick, text: translateText('client_models_network_banned', [event.channel, event.reason]), channel: event.channel}), 'status');
 832             _kiwi.app.message.text(_kiwi.global.i18n.translate('client_models_network_banned').fetch(event.channel, event.reason));
 833             break;
 834         case 'bad_channel_key':
 835             panel.addMsg(' ', styleText('channel_badkey', {nick: event.nick, text: translateText('client_models_network_channel_badkey', [event.channel]), channel: event.channel}), 'status');
 836             _kiwi.app.message.text(_kiwi.global.i18n.translate('client_models_network_channel_badkey').fetch(event.channel));
 837             break;
 838         case 'invite_only_channel':
 839             panel.addMsg(' ', styleText('channel_inviteonly', {nick: event.nick, text: translateText('client_models_network_channel_inviteonly', [event.nick, event.channel]), channel: event.channel}), 'status');
 840             _kiwi.app.message.text(event.channel + ' ' + _kiwi.global.i18n.translate('client_models_network_channel_inviteonly').fetch());
 841             break;
 842         case 'user_on_channel':
 843             panel.addMsg(' ', styleText('channel_alreadyin', {nick: event.nick, text: translateText('client_models_network_channel_alreadyin'), channel: event.channel}));
 844             break;
 845         case 'channel_is_full':
 846             panel.addMsg(' ', styleText('channel_limitreached', {nick: event.nick, text: translateText('client_models_network_channel_limitreached', [event.channel]), channel: event.channel}), 'status');
 847             _kiwi.app.message.text(event.channel + ' ' + _kiwi.global.i18n.translate('client_models_network_channel_limitreached').fetch(event.channel));
 848             break;
 849         case 'chanop_privs_needed':
 850             panel.addMsg(' ', styleText('chanop_privs_needed', {text: event.reason, channel: event.channel}), 'status');
 851             _kiwi.app.message.text(event.reason + ' (' + event.channel + ')');
 852             break;
 853         case 'cannot_send_to_channel':
 854             panel.addMsg(' ', '== ' + _kiwi.global.i18n.translate('Cannot send message to channel, you are not voiced').fetch(event.channel, event.reason), 'status');
 855             break;
 856         case 'no_such_nick':
 857             tmp = this.panels.getByName(event.nick);
 858             if (tmp) {
 859                 tmp.addMsg(' ', styleText('no_such_nick', {nick: event.nick, text: event.reason, channel: event.channel}), 'status');
 860             } else {
 861                 this.panels.server.addMsg(' ', styleText('no_such_nick', {nick: event.nick, text: event.reason, channel: event.channel}), 'status');
 862             }
 863             break;
 864         case 'nickname_in_use':
 865             this.panels.server.addMsg(' ', styleText('nickname_alreadyinuse', {nick: event.nick, text: translateText('client_models_network_nickname_alreadyinuse', [event.nick]), channel: event.channel}), 'status');
 866             if (this.panels.server !== this.panels.active) {
 867                 _kiwi.app.message.text(_kiwi.global.i18n.translate('client_models_network_nickname_alreadyinuse').fetch(event.nick));
 868             }
 869
 870             // Only show the nickchange component if the controlbox is open
 871             if (_kiwi.app.controlbox.$el.css('display') !== 'none') {
 872                 (new _kiwi.view.NickChangeBox()).render();
 873             }
 874
 875             break;
 876
 877         case 'password_mismatch':
 878             this.panels.server.addMsg(' ', styleText('channel_badpassword', {nick: event.nick, text: translateText('client_models_network_badpassword', []), channel: event.channel}), 'status');
 879             break;
 880
 881         case 'error':
 882             if (event.reason) {
 883                 this.panels.server.addMsg(' ', styleText('general_error', {text: event.reason}), 'status');
 884             }
 885             break;
 886
 887         default:
 888             // We don't know what data contains, so don't do anything with it.
 889             //_kiwi.front.tabviews.server.addMsg(null, ' ', '== ' + data, 'status');
 890         }
 891     }
 892
 893
 894     function onUnknownCommand(event) {
 895         var display_params = _.clone(event.params);
 896
 897         // A lot of commands have our nick as the first parameter. This is redundant for us
 898         if (display_params[0] && display_params[0] == this.get('nick')) {
 899             display_params.shift();
 900         }
 901
 902         this.panels.server.addMsg('', styleText('unknown_command', {text: '[' + event.command + '] ' + display_params.join(', ', '')}));
 903     }
 904
 905
 906     function onWallops(event) {
 907         var active_panel = _kiwi.app.panels().active;
 908
 909         // Send to server panel
 910         this.panels.server.addMsg('[' + (event.nick||'') + ']', styleText('wallops', {text: event.msg}), 'wallops', {time: event.time});
 911
 912         // Send to active panel if its a channel/query *and* it's related to this network
 913         if (active_panel !== this.panels.server && (active_panel.isChannel() || active_panel.isQuery()) && active_panel.get('network') === this)
 914             active_panel.addMsg('[' + (event.nick||'') + ']', styleText('wallops', {text: event.msg}), 'wallops', {time: event.time});
 915     }
 916
 917 }
 918
 919 )();