cgi-bin/LJ/NotificationInbox.pm

   1 package LJ::NotificationInbox;
   2
   3 use strict;
   4 use warnings;
   5
   6 # External modules
   7 use Carp 'croak';
   8 use Class::Autouse qw{
   9     LJ::Event::JournalNewComment
  10     LJ::Event::InboxUserMessageRecvd
  11     LJ::Event LJ::NotificationArchive
  12 };
  13
  14 # Internal modules
  15 use LJ::MemCacheProxy;
  16 use LJ::NotificationItem;
  17
  18 my ($comment_typeid, $rmessage_typeid, $smessage_typeid);
  19
  20 # constructor takes a $u
  21 sub new {
  22     my ($class, $user) = @_;
  23
  24     croak 'Invalid args to construct LJ::NotificationInbox' unless $class and $user;
  25     croak 'Invalid user' unless LJ::isu($user);
  26
  27     # return singleton from $u if it already exists
  28     return $LJ::REQ_CACHE_INBOX{'inbox'} if $LJ::REQ_CACHE_INBOX{'inbox'};
  29
  30     my $self = {
  31         userid    => $user->id,
  32         user      => $user,
  33     };
  34
  35     $comment_typeid  ||= LJ::Event::JournalNewComment->etypeid;
  36     $rmessage_typeid ||= LJ::Event::UserMessageRecvd->etypeid;
  37     $smessage_typeid ||= LJ::Event::UserMessageSent->etypeid;
  38
  39     return $LJ::REQ_CACHE_INBOX{'inbox'} = bless $self;
  40 }
  41
  42 # returns the user object associated with this queue
  43 *u = \&owner;
  44 sub owner { $_[0]->{'user'} }
  45
  46 # Returns a list of LJ::NotificationItems in this queue.
  47 sub items {
  48     return @{ $_[0]->{'items'} }
  49         if $_[0]->{'items'};
  50
  51     my $user = &owner;
  52
  53     $_[0]->{'items'} = [map {
  54         LJ::NotificationItem->new($user, $_);
  55     } &_load];
  56
  57     # optimization:
  58     #   now items are defined ... if any are comment
  59     #   objects we'll instantiate those ahead of time
  60     #   so that if one has its data loaded they will
  61     #   all benefit from a coalesced load
  62     &instantiate_singletons;
  63
  64     return @{ $_[0]->{'items'} };
  65 }
  66
  67 # returns a list of all notification items except for sent user messages
  68 sub all_items {
  69     grep { $_->{state} ne 'S' } grep { $_->event->class ne "LJ::Event::UserMessageSent" } grep {$_->event} $_[0]->items;
  70 }
  71
  72 # returns a list of friend-related notificationitems
  73 sub friend_items {
  74     my @friend_events = friend_event_list();
  75
  76     my %friend_events = map { "LJ::Event::" . $_ => 1 } @friend_events;
  77
  78     grep { $friend_events{$_->event->class} } grep {$_->event} $_[0]->items;
  79 }
  80
  81 # returns a list of friend-related notificationitems
  82 sub friendplus_items {
  83     my @friend_events = friendplus_event_list();
  84
  85     my %friend_events = map { "LJ::Event::" . $_ => 1 } @friend_events;
  86
  87     grep { $friend_events{$_->event->class} } grep {$_->event} $_[0]->items;
  88 }
  89
  90 # returns a list of non user-messaging notificationitems
  91 sub non_usermsg_items {
  92     my @usermsg_events = qw(
  93                            UserMessageRecvd
  94                            UserMessageSent
  95                            );
  96
  97     @usermsg_events = (@usermsg_events, (LJ::run_hook('usermsg_notification_types') || ()));
  98
  99     my %usermsg_events = map { "LJ::Event::" . $_ => 1 } @usermsg_events;
 100
 101     grep { !$usermsg_events{$_->event->class} } grep {$_->event} $_[0]->items;
 102 }
 103
 104 # returns a list of non user-message recvd notificationitems
 105 sub usermsg_recvd_items {
 106     my @events = ( 'UserMessageRecvd' );
 107     my @items = $_[0]->subset_items(@events);
 108
 109     @items = grep { $_->{state} ne 'S' } @items if LJ::is_enabled('spam_inbox');
 110
 111     return @items;
 112 }
 113
 114 # returns a list of non user-message recvd notificationitems
 115 sub usermsg_sent_items {
 116     $_[0]->subset_items('UserMessageSent');
 117 }
 118
 119 # returns a list of spam notificationitems
 120 sub spam_items {
 121     grep { $_->{'state'} eq 'S' } $_[0]->subset_items('UserMessageRecvd');
 122 }
 123
 124 sub birthday_items {
 125     $_[0]->subset_items('Birthday');
 126 }
 127
 128 sub befriended_items {
 129     $_[0]->subset_items('Befriended');
 130 }
 131
 132 sub entrycomment_items {
 133     $_[0]->subset_items(entrycomment_event_list());
 134 }
 135
 136 # return a subset of notificationitems
 137 sub subset_items {
 138     my ($self, @subset) = @_;
 139
 140     my %subset_events = map { "LJ::Event::" . $_ => 1 } @subset;
 141     return grep { $subset_events{$_->event->class} } $self->items;
 142 }
 143
 144 # return flagged notifications
 145 sub bookmark_items {
 146     grep { $_[0]->is_bookmark($_->qid) } $_[0]->items;
 147 }
 148
 149 # return archived notifications
 150 sub archived_items {
 151     &owner->notification_archive->items;
 152 }
 153
 154 sub count {
 155     my $count = LJ::MemCacheProxy::get(&_count_memkey);
 156
 157     return $count
 158         if defined $count;
 159
 160     &_load;
 161
 162     $count = @{ $LJ::REQ_CACHE_INBOX{'events'} };
 163
 164     LJ::MemCacheProxy::set(&_count_memkey, $count, 86400);
 165
 166     return $count;
 167 } # count
 168
 169 # returns number of unread items in inbox
 170 sub unread_count {
 171     my $self = $_[0];
 172
 173     my $unread = LJ::MemCacheProxy::get(&_unread_memkey);
 174
 175     return $unread
 176         if defined $unread;
 177
 178     &_load;
 179
 180     $unread = grep {
 181         'N' eq uc $_->{'state'}
 182     } @{ $LJ::REQ_CACHE_INBOX{'events'} };
 183
 184     LJ::MemCacheProxy::set(&_unread_memkey, $unread, 86400);
 185
 186     return $unread;
 187 } # unread_count
 188
 189 # unread message count
 190 sub unread_message_count {
 191
 192     my $unread = LJ::MemCacheProxy::get(&_unread_msg_memkey);
 193
 194     return $unread
 195         if defined $unread;
 196
 197     &_load;
 198
 199     $unread = grep {
 200         'N' eq uc $_->{'state'}
 201     } grep {
 202         $_->{'etypeid'} == $rmessage_typeid
 203     } @{ $LJ::REQ_CACHE_INBOX{'events'} };
 204
 205     LJ::MemCacheProxy::set(&_unread_msg_memkey, $unread, 86400);
 206
 207     return $unread;
 208 } # unread_message_count
 209
 210 # unread message count
 211 sub unread_event_count {
 212     &_load;
 213
 214     return scalar grep {
 215         'N' eq uc $_->{'state'}
 216     } grep {
 217         $_->{'etypeid'} != $rmessage_typeid and
 218         $_->{'etypeid'} != $smessage_typeid
 219     } @{ $LJ::REQ_CACHE_INBOX{'events'} };
 220 } # unread_msg_count
 221
 222 sub spam_event_count {
 223      &_load;
 224
 225     return scalar grep {
 226         'S' eq $_->{'state'}
 227     } @{ $LJ::REQ_CACHE_INBOX{'events'} };
 228 } # spam_event_count
 229
 230 # load the items in this queue
 231 # returns internal items hashref
 232 sub _load {
 233     &LJ::NotificationItem::_load;
 234
 235     return
 236         unless defined wantarray;
 237
 238     return map $_->{'qid'}, @{ $LJ::REQ_CACHE_INBOX{'events'} };
 239 }
 240
 241 sub instantiate_singletons {
 242     return 1 unless $LJ::DISABLED{'inbox_controller'};
 243
 244     foreach (&items) {
 245         my $event = $_->event() or next;
 246         my $etypeid = $event->etypeid();
 247
 248         # instantiate all the comment singletons so that they will all be
 249         # loaded efficiently later as soon as preload_rows is called on
 250         # the first comment object
 251         LJ::Comment->new(
 252             $event->event_journal,
 253             jtalkid => $event->{'args'}[0],
 254         ) if $etypeid == $comment_typeid;
 255
 256         # instantiate all the message singletons so that they will all be
 257         # loaded efficiently later as soon as preload_rows is called on
 258         # the first message object
 259         LJ::Message->new({
 260             msgid     => $event->{'args'}[0],
 261             otherid   => $event->{'args'}[1],
 262             journalid => $event->{'userid'},
 263         }) if $etypeid == $rmessage_typeid or $etypeid == $smessage_typeid;
 264     }
 265
 266     return 1;
 267 }
 268
 269 sub _memkey {
 270     my $userid = $_[0]->{'userid'};
 271     return [$userid, "inbox:$userid"];
 272 }
 273
 274 sub _count_memkey {
 275     my $userid = $_[0]->{'userid'};
 276     return [$userid, "inbox:cnt:$userid"];
 277 }
 278
 279 sub _unread_memkey {
 280     my $userid = $_[0]->{'userid'};
 281     return [$userid, "inbox:newct:$userid"];
 282 }
 283
 284 sub _unread_msg_memkey {
 285     my $userid = $_[0]->{'userid'};
 286     return [$userid, "inbox:newct:msg:$userid"];
 287 }
 288
 289 sub _bookmark_memkey {
 290     my $userid = $_[0]->{'userid'};
 291     return [$userid, "inbox:bookmarks:$userid"];
 292 }
 293
 294 *_events_memkey = \&LJ::NotificationItem::_events_memkey;
 295
 296 # deletes an Event that is queued for this user
 297 # args: Queue ID to remove from queue
 298 sub delete_from_queue {
 299     my ($self, $item) = @_;
 300
 301     my $qid = $item->qid();
 302
 303     croak 'no queueid for queue item passed to delete_from_queue'
 304         unless int $qid;
 305
 306     my $user = &owner
 307         or die 'No user object';
 308
 309     # Try to remove bookmark first
 310     $self->remove_bookmark($qid);
 311
 312     $user->do('DELETE FROM notifyqueue WHERE userid=? AND qid=?', undef, $self->{'userid'}, $qid);
 313
 314     die $user->errstr
 315         if $user->err;
 316
 317     # invalidate caches
 318     &expire_cache;
 319
 320     return 1;
 321 }
 322
 323 sub expire_cache {
 324     my $self = $_[0];
 325
 326     delete $self->{'items'};
 327
 328     $self->{'_loaded'} = 0;
 329
 330     delete $LJ::REQ_CACHE_INBOX{'events'};
 331
 332     LJ::MemCacheProxy::delete(&_memkey);
 333     LJ::MemCacheProxy::delete(&_count_memkey);
 334     LJ::MemCacheProxy::delete(&_unread_memkey);
 335     LJ::MemCacheProxy::delete(&_unread_msg_memkey);
 336     LJ::MemCacheProxy::delete(&_events_memkey);
 337     LJ::MemCacheProxy::delete(&_bookmark_memkey);
 338 }
 339
 340 # This will enqueue an event object
 341 # Returns the enqueued item
 342 sub enqueue {
 343     my ($self, %opts) = @_;
 344     my $evt     = delete $opts{event};
 345     my $archive = delete $opts{archive} || 1;
 346
 347     croak "No event" unless $evt;
 348     croak "Extra args passed to enqueue" if %opts;
 349
 350     my $u = &owner or die "No user";
 351
 352     # if over the max, delete the oldest notification
 353     my $max  = $u->get_cap('inbox_max');
 354     my $skip = $max - 1; # number to skip to get to max
 355
 356     if ($max && $self->count >= $max) {
 357
 358         # Get list of bookmarks and ignore them when checking inbox limits
 359         my $bmarks = join ',', $self->get_bookmarks_ids;
 360         my $bookmark_sql = ($bmarks) ? "AND qid NOT IN ($bmarks) " : '';
 361
 362         my $too_old_qid = $u->selectrow_array
 363             ("SELECT qid FROM notifyqueue ".
 364              "WHERE userid=? $bookmark_sql".
 365              "ORDER BY qid DESC LIMIT $skip,1",
 366              undef, $u->id);
 367
 368         if ($too_old_qid) {
 369             $u->do("DELETE FROM notifyqueue WHERE userid=? AND qid <= ? $bookmark_sql",
 370                    undef, $u->id, $too_old_qid);
 371             $self->expire_cache;
 372         }
 373     }
 374
 375     # get a qid
 376     my $qid  = LJ::alloc_user_counter($u, 'Q');
 377     my $spam = 0;
 378
 379     unless ($qid) {
 380         die "Could not alloc new queue ID";
 381     }
 382
 383     # Check spam
 384     if ($evt->etypeid == LJ::Event::UserMessageRecvd->etypeid) {
 385         if (my $msg = $evt->load_message()) {
 386             if ($msg->is_spam) {
 387                 $spam = 1;
 388             }
 389         }
 390     }
 391
 392     my %item = (qid        => $qid,
 393                 userid     => $u->{userid},
 394                 journalid  => $evt->userid,
 395                 etypeid    => $evt->etypeid,
 396                 arg1       => $evt->arg1,
 397                 arg2       => $evt->arg2,
 398                 state      => $spam ? 'S' : $evt->mark_read ? 'R' : 'N',
 399                 createtime => $evt->eventtime_unix || time());
 400
 401     # insert this event into the notifyqueue table
 402     $u->do("INSERT INTO notifyqueue (" . join(",", keys %item) . ") VALUES (" .
 403            join(",", map { '?' } values %item) . ")", undef, values %item)
 404         or die $u->errstr;
 405
 406     if ($archive) {
 407         # insert into the notifyarchive table with State defaulted to space
 408         $item{state} = ' ';
 409         $u->do("INSERT INTO notifyarchive (" . join(",", keys %item) . ") VALUES (" .
 410                join(",", map { '?' } values %item) . ")", undef, values %item)
 411             or die $u->errstr;
 412     }
 413
 414     # send notification
 415     if ( LJ::Event::UserMessageRecvd->etypeid == $evt->etypeid ) {
 416         $self->__send_notify({
 417             'u'         => $u,
 418             'journal_u' => LJ::want_user($evt->arg2),
 419             'msgid'     => $evt->arg1,
 420             'etypeid'   => $evt->etypeid,
 421         });
 422     }
 423
 424     # invalidate memcache
 425     $self->expire_cache;
 426
 427     return LJ::NotificationItem->new($u, $qid);
 428 }
 429
 430 sub __send_notify {
 431     my ($self, $data) = @_;
 432     my $msgid       = $data->{'msgid'};
 433     my $u           = $data->{'u'};
 434     my $journal_u   = $data->{'journal_u'};
 435
 436     LJ::Event::InboxUserMessageRecvd->new($u, $msgid, $journal_u)->fire;
 437 }
 438
 439 # return true if item is bookmarked
 440 sub is_bookmark {
 441     my ($self, $qid) = @_;
 442
 443     # load bookmarks if they don't already exist
 444     &load_bookmarks
 445         unless $self->{'bookmarks'};
 446
 447     return $self->{'bookmarks'}{$qid}? 1 : 0;
 448 }
 449
 450 sub is_contact {
 451     my ($class, $u, $target) = @_;
 452     die 'Expected parameter $u in is_contact' unless $u;
 453     die 'Expected parameter $target in is_contact' unless $target;
 454
 455     my $uid = $u->id;
 456     my $tid = $target->id;
 457
 458     return unless $uid;
 459     return unless $tid;
 460
 461     my $key = [$uid, "inbox:contacts:$uid"];
 462     my $val = LJ::MemCacheProxy::get($key);
 463
 464     if ($val) {
 465         my %uids = unpack '(VC)*', $val;
 466
 467         if (exists $uids{$uid}) {
 468             return $uids{$uid};
 469         }
 470     }
 471
 472     my $dbh = LJ::get_cluster_master($u);
 473
 474     return unless $dbh;
 475
 476     my $res = $dbh->selectcol_arrayref(qq[
 477             SELECT
 478                 1
 479             FROM
 480                 usermsg
 481             WHERE
 482                 type = 'out'
 483             AND
 484                 journalid = ?
 485             AND
 486                 otherid = ?
 487             LIMIT
 488                 1
 489         ],
 490         undef,
 491         $uid,
 492         $tid
 493     );
 494
 495     if ($dbh->err) {
 496         return;
 497     }
 498
 499     if ($res->[0]) {
 500         $res = 1;
 501     } else {
 502         $res = 0;
 503     }
 504
 505     $val ||= '';
 506     $val .= pack 'VC', $uid, $res;
 507
 508     if ($val) {
 509         LJ::MemCacheProxy::set($key, $val, 86400);
 510     }
 511
 512     return $res;
 513 }
 514
 515 # populate the bookmark hash
 516 sub load_bookmarks {
 517     my ($self) = @_;
 518     my $format = 'N*';
 519
 520     return scalar keys %{ $self->{'bookmarks'} }
 521         if $self->{'bookmarks'};
 522
 523     my $u = &owner;
 524     my $row = LJ::MemCacheProxy::get(&_bookmark_memkey);
 525
 526     if ($row) {
 527         $self->{'bookmarks'}{$_} = 1
 528             foreach unpack $format, $row;
 529
 530         &_load;
 531
 532         my %items = map { $_->{'qid'} => 1 } @{ $LJ::REQ_CACHE_INBOX{'events'} };
 533
 534         my @obsolete = grep {
 535             not exists $items{$_}
 536         } keys %{ $self->{'bookmarks'} };
 537
 538         return scalar keys %{ $self->{'bookmarks'} }
 539             unless @obsolete;
 540
 541         $self->{'bookmarks'} = {};
 542
 543         $u->do(join(join(',', map '?', @obsolete), 'DELETE FROM notifybookmarks WHERE userid=? AND qid IN (', ')'), undef, $self->{'userid'}, @obsolete);
 544     }
 545
 546     my $qids = $u->selectcol_arrayref('SELECT qid FROM notifybookmarks WHERE userid=?', undef, $self->{'userid'});
 547
 548     die sprintf "Failed to load bookmarks: %s\n", $u->errstr
 549         if $u->err;
 550
 551     $self->{'bookmarks'}{$_} = 1
 552         foreach @$qids;
 553
 554     $row = pack $format, @$qids;
 555
 556     LJ::MemCacheProxy::set(&_bookmark_memkey, $row, 86400);
 557
 558     return scalar keys %{ $self->{'bookmarks'} };
 559 } # load_bookmarks
 560
 561 ## returns array of qid of 'bookmarked' messages
 562 sub get_bookmarks_ids {
 563     my $self = $_[0];
 564
 565     &load_bookmarks
 566         unless $self->{'bookmarks'};
 567
 568     return keys %{ $self->{'bookmarks'} };
 569 }
 570
 571 # add a bookmark
 572 sub add_bookmark {
 573     my ($self, $qid) = @_;
 574
 575     my $user = &owner;
 576
 577     return 0
 578         unless &can_add_bookmark;
 579
 580     return 1
 581         if &is_bookmark;
 582
 583     $user->do('INSERT IGNORE INTO notifybookmarks (userid, qid) VALUES (?, ?)', undef, $self->{'userid'}, $qid);
 584
 585     die $user->errstr
 586         if $user->err;
 587
 588     # try to load message by qid
 589     $rmessage_typeid ||= LJ::Event::UserMessageRecvd->etypeid;
 590     $smessage_typeid ||= LJ::Event::UserMessageSent->etypeid;
 591
 592     if (my ($msgid) = $user->selectrow_array("
 593         SELECT arg1
 594         FROM notifyqueue
 595         WHERE userid=? AND qid=? AND etypeid IN (?, ?)",
 596         undef, $self->{'userid'}, $qid, $rmessage_typeid, $smessage_typeid)) {
 597
 598         $user->do('INSERT IGNORE INTO usermsgbookmarks (journalid, msgid) VALUES (?, ?)', undef, $self->{'userid'}, $msgid);
 599
 600         die $user->errstr
 601            if $user->err;
 602     }
 603
 604     # Make sure notice is in inbox
 605     $self->ensure_queued($qid);
 606
 607     $self->{'bookmarks'}{$qid} = 1;
 608
 609     LJ::MemCacheProxy::delete(&_bookmark_memkey);
 610
 611     return 1;
 612 }
 613
 614 # remove bookmark
 615 sub remove_bookmark {
 616     my ($self, $qid) = @_;
 617
 618     my $user = &owner;
 619
 620     return 0
 621         unless &is_bookmark;
 622
 623     $user->do('DELETE FROM notifybookmarks WHERE userid=? AND qid=?', undef, $self->{'userid'}, $qid);
 624
 625     die $user->errstr
 626         if $user->err;
 627
 628     # try to load message by qid
 629     $rmessage_typeid ||= LJ::Event::UserMessageRecvd->etypeid;
 630     $smessage_typeid ||= LJ::Event::UserMessageSent->etypeid;
 631
 632     if (my ($msgid) = $user->selectrow_array("
 633         SELECT arg1
 634         FROM notifyqueue
 635         WHERE userid=? AND qid=? AND etypeid IN (?, ?)",
 636         undef, $self->{'userid'}, $qid, $rmessage_typeid, $smessage_typeid)) {
 637
 638         $user->do('DELETE FROM usermsgbookmarks WHERE journalid=? AND msgid=?', undef, $self->{'userid'}, $msgid);
 639
 640         die $user->errstr
 641            if $user->err;
 642     }
 643
 644     delete $self->{'bookmarks'}{$qid};
 645
 646     LJ::MemCacheProxy::delete(&_bookmark_memkey);
 647
 648     return 1;
 649 }
 650
 651 # add or remove bookmark based on whether it is already bookmarked
 652 sub toggle_bookmark { &is_bookmark? &remove_bookmark : &add_bookmark }
 653
 654 # return true if can add a bookmark
 655 sub can_add_bookmark {
 656     my $max = &owner->get_cap('inbox_max');
 657
 658     return 0 if $max <= &load_bookmarks + 1;
 659     return 1;
 660 }
 661
 662 sub delete_all {
 663     my ( $self, $view, %opts ) = @_;
 664     my @items;
 665
 666     # Unless in folder 'Bookmarks', don't fetch any bookmarks
 667     if ( $view eq 'all' ) {
 668         @items = $self->all_items;
 669         push @items, $self->usermsg_sent_items;
 670     } elsif ( $view eq 'usermsg_recvd' ) {
 671         @items = $self->usermsg_recvd_items;
 672     } elsif ( $view eq 'friendplus' ) {
 673         @items = $self->friendplus_items;
 674         push @items, $self->birthday_items;
 675         push @items, $self->befriended_items;
 676     } elsif ( $view eq 'birthday' ) {
 677         @items = $self->birthday_items;
 678     } elsif ( $view eq 'befriended' ) {
 679         @items = $self->befriended_items;
 680     } elsif ( $view eq 'entrycomment' ) {
 681         @items = $self->entrycomment_items;
 682     } elsif ( $view eq 'bookmark' ) {
 683         @items = $self->bookmark_items;
 684     } elsif ( $view eq 'usermsg_sent' ) {
 685         @items = $self->usermsg_sent_items;
 686     } elsif ( $view eq 'spam' ) {
 687         @items = $self->spam_items;
 688     }
 689
 690     @items = grep { !$self->is_bookmark($_->qid) } @items
 691         unless $view eq 'bookmark';
 692
 693     my @ret;
 694     foreach my $item (@items) {
 695         push @ret, {qid => $item->qid};
 696     }
 697
 698     my $u = &owner;
 699     my $interface = $opts{'interface'};
 700
 701     LJ::User::UserlogRecord::InboxMassDelete->create( $u,
 702         'remote' => $u,
 703         'items'  => scalar @items,
 704         'method' => 'delete_all',
 705         'view'   => $view,
 706         'via'    => $interface,
 707     );
 708
 709     # Delete items
 710     foreach my $item (@items) {
 711         if ($opts{spam}) {
 712             my $msg = $item->event->load_message();
 713             $msg->mark_as_spam();
 714         }
 715         $item->delete;
 716     }
 717
 718     return @ret;
 719 }
 720
 721 sub delete_all_from_sender {
 722     my ( $self, $senderid ) = @_;
 723     my @items;
 724
 725     @items = grep { $_->event->class ne "LJ::Event::UserMessageSent" } grep {$_->event} $self->items;
 726
 727     @items = grep { !$self->is_bookmark($_->qid) } @items;
 728
 729     my @ret;
 730     # Delete items
 731     foreach my $item (@items) {
 732         next unless $item->event->arg2 == $senderid;
 733         push @ret, {qid => $item->qid};
 734         $item->delete;
 735     }
 736
 737     return @ret;
 738 }
 739
 740 sub mark_all_read {
 741     my ( $self, $view ) = @_;
 742     my @items;
 743
 744     # Only get items in currently viewed folder and subfolders
 745     if ( $view eq 'all' ) {
 746         @items = $self->all_items;
 747         push @items, $self->usermsg_sent_items;
 748     } elsif ( $view eq 'usermsg_recvd' ) {
 749         @items = $self->usermsg_recvd_items;
 750     } elsif ( $view eq 'friendplus' ) {
 751         @items = $self->friendplus_items;
 752         push @items, $self->birthday_items;
 753         push @items, $self->befriended_items;
 754     } elsif ( $view eq 'birthday' ) {
 755         @items = $self->birthday_items;
 756     } elsif ( $view eq 'befriended' ) {
 757         @items = $self->befriended_items;
 758     } elsif ( $view eq 'entrycomment' ) {
 759         @items = $self->entrycomment_items;
 760     } elsif ( $view eq 'bookmark' ) {
 761         @items = $self->bookmark_items;
 762     } elsif ( $view eq 'usermsg_sent' ) {
 763         @items = $self->usermsg_sent_items;
 764     }
 765
 766     # Mark read
 767     $_->mark_read foreach @items;
 768     return @items;
 769 }
 770
 771 # Copy archive notice to inbox
 772 # Needed when bookmarking a notice that only lives in archive
 773 sub ensure_queued {
 774     my ($self, $qid) = @_;
 775
 776     my $u = &owner
 777         or die "No user object";
 778
 779     my $sth = $u->prepare
 780         ("SELECT userid, qid, journalid, etypeid, arg1, arg2, state, createtime " .
 781          "FROM notifyarchive WHERE userid=? AND qid=?");
 782     $sth->execute($u->{userid}, $qid);
 783     die $sth->errstr if $sth->err;
 784
 785     my $row = $sth->fetchrow_hashref;
 786     if ($row) {
 787         my %item = (qid        => $row->{qid},
 788                     userid     => $row->{userid},
 789                     journalid  => $row->{journalid},
 790                     etypeid    => $row->{etypeid},
 791                     arg1       => $row->{arg1},
 792                     arg2       => $row->{arg2},
 793                     state      => 'R',
 794                     createtime => $row->{createtime});
 795
 796         # insert this event into the notifyqueue table
 797         $u->do("INSERT IGNORE INTO notifyqueue (" . join(",", keys %item) . ") VALUES (" .
 798                join(",", map { '?' } values %item) . ")", undef, values %item)
 799             or die $u->errstr;
 800
 801         # invalidate memcache
 802         $self->expire_cache;
 803     }
 804
 805     return;
 806 }
 807
 808 # return a count of a subset of notificationitems
 809 sub subset_unread_count {
 810     my ($self, @subset) = @_;
 811
 812     my %subset_events = map { "LJ::Event::" . $_ => 1 } @subset;
 813     my @events = grep { $subset_events{$_->event->class} && $_->unread } grep {$_->event} $self->items;
 814     return scalar @events;
 815 }
 816
 817 sub all_event_count {
 818     scalar grep { $_->event->class ne 'LJ::Event::UserMessageSent' && $_->unread } grep { $_->event } $_[0]->items;
 819 }
 820
 821 sub friend_event_count {
 822     $_[0]->subset_unread_count(friend_event_list());
 823 }
 824
 825 sub friendplus_event_count {
 826     $_[0]->subset_unread_count(friendplus_event_list());
 827 }
 828
 829 sub entrycomment_event_count {
 830     $_[0]->subset_unread_count(entrycomment_event_list());
 831 }
 832
 833 sub usermsg_recvd_event_count {
 834     $_[0]->subset_unread_count('UserMessageRecvd');
 835 }
 836
 837 sub usermsg_sent_event_count {
 838     $_[0]->subset_unread_count('UserMessageSent');
 839 }
 840
 841
 842 # Methods that return Arrays of Event categories
 843 sub friend_event_list {
 844     my @events = qw(
 845                     Befriended
 846                     InvitedFriendJoins
 847                     CommunityInvite
 848                     NewUserpic
 849                     );
 850     @events = (@events, (LJ::run_hook('friend_notification_types') || ()));
 851     return @events;
 852 }
 853
 854 sub friendplus_event_list {
 855     my @events = qw(
 856                     Befriended
 857                     InvitedFriendJoins
 858                     CommunityInvite
 859                     NewUserpic
 860                     NewVGift
 861                     Birthday
 862                     );
 863     @events = (@events, (LJ::run_hook('friend_notification_types') || ()));
 864     return @events;
 865 }
 866
 867 sub entrycomment_event_list {
 868     my @events = qw(
 869                      JournalNewEntry
 870                      JournalNewRepost
 871                      JournalNewComment
 872                      );
 873     return @events;
 874 }
 875
 876 1;