682 lines
23 KiB
Perl
682 lines
23 KiB
Perl
#!/usr/bin/perl
|
|
# This code was forked from the LiveJournal project owned and operated
|
|
# by Live Journal, Inc. The code has been modified and expanded by
|
|
# Dreamwidth Studios, LLC. These files were originally licensed under
|
|
# the terms of the license supplied by Live Journal, Inc, which can
|
|
# currently be found at:
|
|
#
|
|
# http://code.livejournal.org/trac/livejournal/browser/trunk/LICENSE-LiveJournal.txt
|
|
#
|
|
# In accordance with the original license, this code and all its
|
|
# modifications are provided under the GNU General Public License.
|
|
# A copy of that license can be found in the LICENSE file included as
|
|
# part of this distribution.
|
|
|
|
package LJ::Memories;
|
|
use strict;
|
|
|
|
# <LJFUNC>
|
|
# name: LJ::Memories::count
|
|
# class: web
|
|
# des: Returns the number of memories that a user has.
|
|
# args: uuobj
|
|
# des-uuobj: Userid or user object to count memories of.
|
|
# returns: Some number; undef on error.
|
|
# </LJFUNC>
|
|
sub count {
|
|
my $u = shift;
|
|
$u = LJ::want_user($u);
|
|
return undef unless $u;
|
|
|
|
# check memcache first
|
|
my $count = LJ::MemCache::get( [ $u->{userid}, "memct:$u->{userid}" ] );
|
|
return $count if $count;
|
|
|
|
# now count
|
|
my $dbcr = LJ::get_cluster_def_reader($u);
|
|
$count = $dbcr->selectrow_array( 'SELECT COUNT(*) FROM memorable2 WHERE userid = ?',
|
|
undef, $u->{userid} );
|
|
return undef if $dbcr->err;
|
|
|
|
$count += 0;
|
|
|
|
# now put in memcache and return it
|
|
my $expiration = $LJ::MEMCACHE_EXPIRATION{'memct'} || 43200; # 12 hours
|
|
LJ::MemCache::set( [ $u->{userid}, "memct:$u->{userid}" ], $count, $expiration );
|
|
return $count;
|
|
}
|
|
|
|
# <LJFUNC>
|
|
# name: LJ::Memories::create
|
|
# class: web
|
|
# des: Create a new memory for a user.
|
|
# args: uuobj, opts, kwids?
|
|
# des-uuobj: User id or user object to insert memory for.
|
|
# des-opts: Hashref of options that define the memory; keys = journalid, ditemid, des, security.
|
|
# des-kwids: Optional; arrayref of keyword ids to categorize this memory under.
|
|
# returns: 1 on success, undef on error
|
|
# </LJFUNC>
|
|
sub create {
|
|
my ( $u, $opts, $kwids ) = @_;
|
|
$u = LJ::want_user($u);
|
|
return undef unless $u && %{ $opts || {} };
|
|
|
|
# make sure we got enough options
|
|
my ( $userid, $journalid, $ditemid, $des, $security ) =
|
|
( $u->userid, map { $opts->{$_} } qw(journalid ditemid des security) );
|
|
$userid += 0;
|
|
$journalid += 0;
|
|
$ditemid += 0;
|
|
$security ||= 'public';
|
|
$kwids ||= [ $u->get_keyword_id('*') ]; # * means no category
|
|
$des = LJ::trim($des);
|
|
return undef unless $userid && $journalid && $ditemid && $des && $security && @$kwids;
|
|
return undef unless $security =~ /^(?:public|friends|private)$/;
|
|
|
|
# we have valid data, now let's insert it
|
|
return undef unless $u->writer;
|
|
|
|
# allocate memory id to use
|
|
my $memid = LJ::alloc_user_counter( $u, 'R' );
|
|
return undef unless $memid;
|
|
|
|
# insert main memory
|
|
$u->do(
|
|
"INSERT INTO memorable2 (userid, memid, journalid, ditemid, des, security) "
|
|
. "VALUES (?, ?, ?, ?, ?, ?)",
|
|
undef, $userid, $memid, $journalid, $ditemid, $des, $security
|
|
);
|
|
return undef if $u->err;
|
|
|
|
# insert keywords
|
|
my $val = join ',', map { "($userid, $memid, $_)" } @$kwids;
|
|
$u->do("REPLACE INTO memkeyword2 (userid, memid, kwid) VALUES $val");
|
|
|
|
# Delete the appropriate memcache entries
|
|
LJ::MemCache::delete( [ $userid, "memct:$userid" ] );
|
|
my $filter = $journalid == $userid ? 'own' : 'other';
|
|
my $filter_char = _map_filter_to_char($filter);
|
|
my $security_char = _map_security_to_char($security);
|
|
my $memcache_key = "memkwcnt:$userid:$filter_char:$security_char";
|
|
LJ::MemCache::delete( [ $userid, $memcache_key ] );
|
|
|
|
return 1;
|
|
}
|
|
|
|
# <LJFUNC>
|
|
# name: LJ::Memories::delete_by_id
|
|
# class: web
|
|
# des: Deletes a bunch of memories by memid.
|
|
# args: uuobj, memids
|
|
# des-uuobj: User id or user object to delete memories of.
|
|
# des-memids: Arrayref of memids.
|
|
# returns: 1 on success; undef on error.
|
|
# </LJFUNC>
|
|
sub delete_by_id {
|
|
my ( $u, $memids ) = @_;
|
|
$u = LJ::want_user($u);
|
|
$memids = [$memids] if $memids && !ref $memids; # so they can just pass a single thing...
|
|
return undef unless $u && @{ $memids || [] };
|
|
|
|
# delete actual memory
|
|
my $in = join ',', map { $_ + 0 } @$memids;
|
|
$u->do( "DELETE FROM memorable2 WHERE userid = ? AND memid IN ($in)", undef, $u->{userid} );
|
|
return undef if $u->err;
|
|
|
|
# delete keyword associations
|
|
my $euser = "userid = $u->{userid} AND";
|
|
$u->do("DELETE FROM memkeyword2 WHERE $euser memid IN ($in)");
|
|
|
|
# delete cache of count and keyword counts
|
|
clear_memcache($u);
|
|
|
|
# success at this point, since the first delete succeeded
|
|
return 1;
|
|
}
|
|
|
|
# <LJFUNC>
|
|
# name: LJ::Memories::get_keyword_counts
|
|
# class: web
|
|
# des: Get a list of keywords and the counts for memories, showing how many memories are under
|
|
# each keyword.
|
|
# args: uuobj, opts?
|
|
# des-uuobj: User id or object of user.
|
|
# des-opts: Optional; hashref passed to _memory_getter, suggested keys are security and filter
|
|
# if you want to get only certain memories in the keyword list.
|
|
# returns: Hashref { kwid => count }; undef on error
|
|
# </LJFUNC>
|
|
sub get_keyword_counts {
|
|
my ( $u, $opts ) = @_;
|
|
$u = LJ::want_user($u);
|
|
return undef unless $u;
|
|
my $userid = $u->{userid};
|
|
|
|
my $filter_parm = $opts->{filter};
|
|
my @security_parm = $opts->{security} ? @{ $opts->{security} } : ();
|
|
|
|
my ( $cache_counts, $missing_keys ) =
|
|
_get_memcache_keyword_counts( $userid, $filter_parm, @security_parm );
|
|
return $cache_counts unless @$missing_keys;
|
|
|
|
# Get the user's memories based on filter and security
|
|
$opts->{filter_security_pairs} = $missing_keys;
|
|
$opts->{notext} = 1;
|
|
my $memories = LJ::Memories::_memory_getter( $u, $opts );
|
|
return undef unless defined $memories; # error case
|
|
|
|
# Generate mapping of memid to filter (e.g. own) and security (e.g. private)
|
|
my ( %mem_filter, @all_memids );
|
|
foreach my $memid ( keys %$memories ) {
|
|
push @all_memids, $memid;
|
|
my $memory_filter = $memories->{$memid}->{journalid} == $userid ? 'own' : 'other';
|
|
my $memory_security = $memories->{$memid}->{security};
|
|
$mem_filter{$memid} = [ $memory_filter, $memory_security ];
|
|
}
|
|
|
|
# now let's get the keywords these memories use
|
|
my $mem_kw_rows;
|
|
|
|
if (@all_memids) {
|
|
my $in = join ',', @all_memids;
|
|
my $dbcr = LJ::get_cluster_reader($u);
|
|
my $sql = "SELECT kwid, memid FROM memkeyword2 WHERE userid = $userid AND memid IN ($in)";
|
|
$mem_kw_rows = $dbcr->selectall_arrayref($sql);
|
|
return undef if $dbcr->err;
|
|
}
|
|
|
|
# Filter and Sum
|
|
my %counts;
|
|
foreach my $row ( @{ $mem_kw_rows || [] } ) {
|
|
my ( $kwid, $memid ) = @$row;
|
|
my ( $filter, $security ) = @{ $mem_filter{$memid} };
|
|
$counts{$filter}{$security}{$kwid}++;
|
|
}
|
|
|
|
# Add these new counts to our memcache counts to get totals
|
|
my $output_counts = $cache_counts;
|
|
foreach my $filter ( keys %counts ) {
|
|
foreach my $security ( keys %{ $counts{$filter} } ) {
|
|
if ( $counts{$filter}{$security} ) {
|
|
add_hash( $output_counts, $counts{$filter}{$security} );
|
|
}
|
|
}
|
|
}
|
|
|
|
# Create empty anonymous hashes for missing key combos
|
|
foreach my $missing_key (@$missing_keys) {
|
|
my ( $missing_filter, $missing_security ) = split /-/, $missing_key;
|
|
next if exists $counts{$missing_filter}{$missing_security};
|
|
$counts{$missing_filter}{$missing_security} = {};
|
|
}
|
|
|
|
# Store memcache entries with counts
|
|
foreach my $filter (qw/own other/) {
|
|
foreach my $security (qw/friends private public/) {
|
|
next unless exists $counts{$filter}{$security};
|
|
my $filter_char = _map_filter_to_char($filter);
|
|
my $security_char = _map_security_to_char($security);
|
|
my $memcache_key = "memkwcnt:$userid:$filter_char:$security_char";
|
|
my $expiration = $LJ::MEMCACHE_EXPIRATION{'memkwcnt'} || 86400;
|
|
LJ::MemCache::set( [ $userid, $memcache_key ],
|
|
$counts{$filter}{$security}, $expiration );
|
|
}
|
|
}
|
|
|
|
return $output_counts;
|
|
}
|
|
|
|
#
|
|
# Name: _map_security_to_char
|
|
# API: Private to this module
|
|
# Description: Map a verbose security name to a single character
|
|
# Parameter: Verbose security name
|
|
# Return: Single character representation of security
|
|
#
|
|
sub _map_security_to_char {
|
|
my $verbose_security = shift;
|
|
my %security_map = ( friends => 'f', private => 'v', public => 'u' );
|
|
return $security_map{$verbose_security}
|
|
|| die "Can't map security '" . LJ::ehtml($verbose_security) . "' to character";
|
|
}
|
|
|
|
#
|
|
# Name: _map_filter_to_char
|
|
# API: Private to this module
|
|
# Description: Map a verbose filter name to a single character
|
|
# Parameter: Verbose filter name
|
|
# Return: Single character representation of filter
|
|
#
|
|
sub _map_filter_to_char {
|
|
my $verbose_filter = shift;
|
|
my %filter_map = ( own => 'w', other => 't' );
|
|
return $filter_map{$verbose_filter}
|
|
|| die "Can't map filter '" . LJ::ehtml($verbose_filter) . "' to character";
|
|
}
|
|
|
|
#
|
|
# Name: _get_memcache_keyword_counts
|
|
#
|
|
# API: Private to this module
|
|
#
|
|
# Description:
|
|
# - Get keyword counts from memcache based on user, filter, and security
|
|
# - Return hash of counts and array of missing keys
|
|
#
|
|
# Parameters:
|
|
# - $userid = ID of the User
|
|
# - $filter_parm = {own|other}
|
|
# - @security_parm = array of values {friends|private|public} - () = all
|
|
#
|
|
# Return Values:
|
|
# - HashRef of counts by Keyword ID
|
|
# - ArrayRef of missing keys (e.g. 'owner-private')
|
|
#
|
|
sub _get_memcache_keyword_counts {
|
|
my ( $userid, $filter_parm, @security_parm ) = @_;
|
|
|
|
# Build up the memcache keys that we're looking for
|
|
my @memcache_keys;
|
|
my %filter_security_map;
|
|
foreach my $filter (qw/own other/) {
|
|
foreach my $security (qw/friends private public/) {
|
|
my $filter_matches = ( $filter_parm eq $filter ) || ( $filter_parm eq 'all' );
|
|
my $security_matches = @security_parm == 0 || grep( /$security/, @security_parm );
|
|
next unless $filter_matches && $security_matches;
|
|
my $filter_char = _map_filter_to_char($filter);
|
|
my $security_char = _map_security_to_char($security);
|
|
my $memcache_key = "memkwcnt:$userid:$filter_char:$security_char";
|
|
push @memcache_keys, $memcache_key;
|
|
$filter_security_map{"$filter_char:$security_char"} = [ $filter, $security ];
|
|
}
|
|
}
|
|
|
|
# Loop over our memcache results, get counts and total them as we go
|
|
my ( %output_counts, @missing_keys );
|
|
my $memcache_counts =
|
|
LJ::is_enabled('memkwcnt_memcaching')
|
|
? LJ::MemCache::get_multi( map { [ $userid, $_ ] } @memcache_keys )
|
|
: {};
|
|
foreach my $memcache_key (@memcache_keys) {
|
|
my $counts = $memcache_counts->{$memcache_key};
|
|
if ($counts) { # Add these memcache counts to totals
|
|
add_hash( \%output_counts, $counts );
|
|
}
|
|
else {
|
|
my ($filter_security_chars) = $memcache_key =~ /$userid:(.:.)$/;
|
|
my ( $filter, $security ) = @{ $filter_security_map{$filter_security_chars} };
|
|
push @missing_keys, $filter . '-' . $security;
|
|
}
|
|
}
|
|
|
|
return \%output_counts, \@missing_keys;
|
|
}
|
|
|
|
# <LJFUNC>
|
|
# name: LJ::Memories::add_hash
|
|
# class: web
|
|
# des: Add values of one hash, to the corresponding entries in another.
|
|
# args: HashRef1, HashRef2
|
|
# returns: Values are added to the first parameter hash.
|
|
# </LJFUNC>
|
|
sub add_hash {
|
|
my ( $hash1, $hash2 ) = @_;
|
|
|
|
while ( my ( $key, $value ) = each %$hash2 ) {
|
|
$hash1->{$key} += $value;
|
|
}
|
|
}
|
|
|
|
# <LJFUNC>
|
|
# name: LJ::Memories::get_keywordids
|
|
# class: web
|
|
# des: Get all keyword ids a user has used for a certain memory.
|
|
# args: uuobj, memid
|
|
# des-uuobj: User id or user object to check memory of.
|
|
# des-memid: Memory id to get keyword ids for.
|
|
# returns: Arrayref of keywordids; undef on error.
|
|
# </LJFUNC>
|
|
sub get_keywordids {
|
|
my ( $u, $memid ) = @_;
|
|
$u = LJ::want_user($u);
|
|
$memid += 0;
|
|
return undef unless $u && $memid;
|
|
|
|
# definitive reader/master because this function is usually called when
|
|
# someone is on an edit page.
|
|
my $dbcr = LJ::get_cluster_def_reader($u);
|
|
my $kwids =
|
|
$dbcr->selectcol_arrayref( 'SELECT kwid FROM memkeyword2 WHERE userid = ? AND memid = ?',
|
|
undef, $u->userid, $memid );
|
|
return undef if $dbcr->err;
|
|
|
|
# all good, return
|
|
return $kwids;
|
|
}
|
|
|
|
# <LJFUNC>
|
|
# name: LJ::Memories::update_memory
|
|
# class: web
|
|
# des: Updates the description and security of a memory.
|
|
# args: uuobj, memid, updopts
|
|
# des-uuobj: User id or user object to update memory of.
|
|
# des-memid: Memory id to update.
|
|
# des-updopts: Update options; hashref with keys 'des' and 'security', values being what
|
|
# you want to update the memory to have.
|
|
# returns: 1 on success, undef on error
|
|
# </LJFUNC>
|
|
# sub update_memory {
|
|
# my ($u, $memid, $upd) = @_;
|
|
# $u = LJ::want_user($u);
|
|
# $memid += 0;
|
|
# return unless $u && $memid && %{$upd || {}};
|
|
#
|
|
# # get database handle
|
|
# my ($db, $table) = ($u, '2');
|
|
# return undef unless $db;
|
|
#
|
|
# # construct update lines... only valid things we can update are des and security
|
|
# my @updates;
|
|
# my $security_updated;
|
|
# foreach my $what (keys %$upd) {
|
|
# next unless $what =~ m/^(?:des|security)$/;
|
|
# $security_updated = 1 if $what eq 'security';
|
|
# push @updates, "$what=" . $db->quote($upd->{$what});
|
|
# }
|
|
# my $updstr = join ',', @updates;
|
|
#
|
|
# # now perform update
|
|
# $db->do("UPDATE memorable$table SET $updstr WHERE userid = ? AND memid = ?",
|
|
# undef, $u->{userid}, $memid);
|
|
# return undef if $db->err;
|
|
#
|
|
# # Delete memcache entries if the security of the memory was updated
|
|
# clear_memcache($u) if $security_updated;
|
|
#
|
|
# return 1;
|
|
# }
|
|
|
|
# this messy function gets memories based on an options hashref. this is an
|
|
# API API and isn't recommended for use by BML etc... add to the API and have
|
|
# API functions call this if needed.
|
|
#
|
|
# options in $opts hashref:
|
|
# security => [ 'public', 'private', ... ], or some subset thereof
|
|
# filter => 'all' | 'own' | 'other', filter -- defaults to all
|
|
# filter_security_pairs => [ 'own-private', ... ], Pairs of filter/security
|
|
# notext => 1/0, if on, do not load/return description field
|
|
# byid => [ 1, 2, 3, ... ], load memories by *memid*
|
|
# byditemid => [ 1, 2, 3 ... ], load by ditemid (MUST specify journalid too)
|
|
# journalid => 1, find memories by ditemid (see above) for this journalid
|
|
#
|
|
# note that all memories are loaded from a single user, specified as the first
|
|
# parameter. does not let you load memories from more than one user.
|
|
sub _memory_getter {
|
|
my ( $u, $opts ) = @_;
|
|
$u = LJ::want_user($u);
|
|
$opts ||= {};
|
|
return undef unless $u;
|
|
|
|
# Specify filter/security by pair, or individually
|
|
my $secwhere = '';
|
|
my $extrawhere = '';
|
|
if ( $opts->{filter_security_pairs} ) {
|
|
my @pairs;
|
|
foreach my $filter_security_pair ( @{ $opts->{filter_security_pairs} } ) {
|
|
my ( $filter, $security ) = $filter_security_pair =~ /^(\w+)-(\w+)$/;
|
|
my $filter_predicate =
|
|
( $filter eq 'all' )
|
|
? ''
|
|
: 'journalid' . ( $filter eq 'own' ? '=' : '<>' ) . $u->{userid};
|
|
push @pairs, "($filter_predicate AND security='$security')";
|
|
}
|
|
$secwhere = 'AND (' . join( ' OR ', @pairs ) . ')';
|
|
}
|
|
else {
|
|
if ( @{ $opts->{security} || [] } ) {
|
|
my @secs;
|
|
foreach my $sec ( @{ $opts->{security} } ) {
|
|
push @secs, $sec
|
|
if $sec =~ /^(?:public|friends|private)$/;
|
|
}
|
|
$secwhere = "AND security IN (" . join( ',', map { "'$_'" } @secs ) . ")";
|
|
}
|
|
if ( $opts->{filter} eq 'all' ) { $extrawhere = ''; }
|
|
elsif ( $opts->{filter} eq 'own' ) { $extrawhere = "AND journalid = $u->{userid}"; }
|
|
elsif ( $opts->{filter} eq 'other' ) { $extrawhere = "AND journalid <> $u->{userid}"; }
|
|
}
|
|
|
|
my $des = $opts->{notext} ? '' : 'des, ';
|
|
my $selwhere = '';
|
|
if ( @{ $opts->{byid} || [] } ) {
|
|
|
|
# they want to get some explicit memories by memid
|
|
my $in = join ',', map { $_ + 0 } @{ $opts->{byid} };
|
|
$selwhere = "AND memid IN ($in)";
|
|
}
|
|
elsif ( $opts->{byditemid} && $opts->{journalid} ) {
|
|
|
|
# or, they want to see if a memory exists for a particular item
|
|
my $selitemid = "ditemid";
|
|
$opts->{byditemid} += 0;
|
|
$opts->{journalid} += 0;
|
|
$selwhere = "AND journalid = $opts->{journalid} AND $selitemid = $opts->{byditemid}";
|
|
}
|
|
elsif ( $opts->{byditemid} ) {
|
|
|
|
# get memory, OLD STYLE so journalid is 0
|
|
my $selitemid = "ditemid";
|
|
$opts->{byditemid} += 0;
|
|
$selwhere = "AND journalid = 0 AND $selitemid = $opts->{byditemid}";
|
|
}
|
|
|
|
# load up memories into hashref
|
|
my ( %memories, $sth );
|
|
my $dbcr = LJ::get_cluster_reader($u);
|
|
my $sql = "SELECT memid, userid, journalid, ditemid, $des security "
|
|
. "FROM memorable2 WHERE userid = ? $selwhere $secwhere $extrawhere";
|
|
$sth = $dbcr->prepare($sql);
|
|
|
|
# general execution and fetching for return
|
|
$sth->execute( $u->{userid} );
|
|
return undef if $sth->err;
|
|
while ( $_ = $sth->fetchrow_hashref() ) {
|
|
|
|
# we have to do this ditemid->jitemid to make old code work,
|
|
# but this can probably go away at some point...
|
|
if ( defined $_->{ditemid} ) {
|
|
$_->{jitemid} = $_->{ditemid};
|
|
}
|
|
else {
|
|
$_->{ditemid} = $_->{jitemid};
|
|
}
|
|
$memories{ $_->{memid} } = $_;
|
|
}
|
|
|
|
my @jids = map { $_->{journalid} } values %memories;
|
|
my $us = LJ::load_userids(@jids);
|
|
foreach my $mem ( values %memories ) {
|
|
next unless $mem->{journalid};
|
|
$mem->{user} = $us->{ $mem->{journalid} }->user;
|
|
}
|
|
|
|
return \%memories;
|
|
}
|
|
|
|
# <LJFUNC>
|
|
# name: LJ::Memories::get_by_id
|
|
# class: web
|
|
# des: Get memories given some memory ids.
|
|
# args: uuobj, memids
|
|
# des-uuobj: User id or user object to get memories for.
|
|
# des-memids: The rest of the memory ids. Array. (Pass them in as individual parameters...)
|
|
# returns: Hashref of memories with keys being memid; undef on error.
|
|
# </LJFUNC>
|
|
# sub get_by_id {
|
|
# my $u = shift;
|
|
# return {} unless @_; # make sure they gave us some ids
|
|
#
|
|
# # pass to getter to get by id
|
|
# return LJ::Memories::_memory_getter($u, { byid => [ map { $_+0 } @_ ] });
|
|
# }
|
|
|
|
# <LJFUNC>
|
|
# name: LJ::Memories::get_by_ditemid
|
|
# class: web
|
|
# des: Get memory for a given journal entry.
|
|
# args: uuobj, journalid, ditemid
|
|
# des-uuobj: User id or user object to get memories for.
|
|
# des-journalid: Userid for journal entry is in.
|
|
# des-ditemid: Display itemid of entry.
|
|
# returns: Hashref of individual memory.
|
|
# </LJFUNC>
|
|
sub get_by_ditemid {
|
|
my ( $u, $jid, $ditemid ) = @_;
|
|
$jid += 0;
|
|
$ditemid += 0;
|
|
return undef unless $ditemid; # _memory_getter checks $u and $jid isn't necessary
|
|
# because this might be an old-style memory
|
|
|
|
# pass to getter with appropriate options
|
|
my $memhash = LJ::Memories::_memory_getter( $u, { byditemid => $ditemid, journalid => $jid } );
|
|
return undef unless %{ $memhash || {} };
|
|
return [ values %$memhash ]->[0]; # ugly
|
|
}
|
|
|
|
# <LJFUNC>
|
|
# name: LJ::Memories::get_by_user
|
|
# class: web
|
|
# des: Get memories given a user.
|
|
# args: uuobj
|
|
# des-uuobj: User id or user object to get memories for.
|
|
# returns: Hashref of memories with keys being memid; undef on error.
|
|
# </LJFUNC>
|
|
# sub get_by_user {
|
|
# # simply passes through to _memory_getter
|
|
# return LJ::Memories::_memory_getter(@_);
|
|
# }
|
|
|
|
# <LJFUNC>
|
|
# name: LJ::Memories::get_by_keyword
|
|
# class: web
|
|
# des: Get memories given a user and a keyword/keyword id.
|
|
# args: uuobj, kwoid, opts
|
|
# des-uuobj: User id or user object to get memories for.
|
|
# des-kwoid: Keyword (string) or keyword id (number) to get memories for.
|
|
# des-opts: Hashref of extra options to pass through to memory getter. Suggested options
|
|
# are filter and security for limiting the memories returned.
|
|
# returns: Hashref of memories with keys being memid; undef on error.
|
|
# </LJFUNC>
|
|
sub get_by_keyword {
|
|
my ( $u, $kwoid, $opts ) = @_;
|
|
$u = LJ::want_user($u);
|
|
my $kwid = $kwoid + 0;
|
|
my $kw = defined $kwoid && !$kwid ? $kwoid : undef;
|
|
return undef unless $u && ( $kwid || defined $kw );
|
|
|
|
my $memids;
|
|
my $dbcr = LJ::get_cluster_reader($u);
|
|
return undef unless $dbcr;
|
|
|
|
# get keyword id if we don't have it
|
|
if ( defined $kw ) {
|
|
$kwid = $dbcr->selectrow_array(
|
|
'SELECT kwid FROM userkeywords WHERE userid = ? AND keyword = ?',
|
|
undef, $u->userid, $kw ) + 0;
|
|
}
|
|
return undef unless $kwid;
|
|
|
|
# now get the actual memory ids
|
|
$memids =
|
|
$dbcr->selectcol_arrayref( 'SELECT memid FROM memkeyword2 WHERE userid = ? AND kwid = ?',
|
|
undef, $u->{userid}, $kwid );
|
|
return undef if $dbcr->err;
|
|
|
|
# return
|
|
$memids = [] unless defined($memids);
|
|
my $memories =
|
|
@$memids > 0
|
|
? LJ::Memories::_memory_getter( $u, { %{ $opts || {} }, byid => $memids } )
|
|
: {};
|
|
return $memories;
|
|
}
|
|
|
|
# <LJFUNC>
|
|
# name: LJ::Memories::get_keywords
|
|
# class:
|
|
# des: Retrieves keyword/keyids without big joins, returns a hashref.
|
|
# args: uobj
|
|
# des-uobj: User object to get keyword pairs for.
|
|
# returns: Hashref; { keywordid => keyword }
|
|
# </LJFUNC>
|
|
sub get_keywords {
|
|
my $u = shift;
|
|
$u = LJ::want_user($u);
|
|
return undef unless $u;
|
|
|
|
my $use_reader = 0;
|
|
my $memkey = [ $u->{userid}, "memkwid:$u->{userid}" ];
|
|
my $ret = LJ::MemCache::get($memkey);
|
|
return $ret if defined $ret;
|
|
$ret = {};
|
|
|
|
my $dbcm = LJ::get_cluster_def_reader($u);
|
|
unless ($dbcm) {
|
|
$use_reader = 1;
|
|
$dbcm = LJ::get_cluster_reader($u);
|
|
}
|
|
my $ids = $dbcm->selectcol_arrayref( 'SELECT DISTINCT kwid FROM memkeyword2 WHERE userid = ?',
|
|
undef, $u->userid );
|
|
if ( @{ $ids || [] } ) {
|
|
my $in = join ",", @$ids;
|
|
my $rows = $dbcm->selectall_arrayref(
|
|
'SELECT kwid, keyword FROM userkeywords ' . "WHERE userid = ? AND kwid IN ($in)",
|
|
undef, $u->userid );
|
|
$ret->{ $_->[0] } = $_->[1] foreach @{ $rows || [] };
|
|
}
|
|
|
|
my $expiration = $LJ::MEMCACHE_EXPIRATION{'memkwid'} || 86400;
|
|
LJ::MemCache::set( $memkey, $ret, $expiration ) unless $use_reader;
|
|
return $ret;
|
|
}
|
|
|
|
# <LJFUNC>
|
|
# name: LJ::Memories::updated_keywords
|
|
# class: web
|
|
# des: Deletes memcached keyword data.
|
|
# args: uobj
|
|
# des-uobj: User object to clear memcached keywords for.
|
|
# returns: undef.
|
|
# </LJFUNC>
|
|
sub updated_keywords {
|
|
return clear_memcache(shift);
|
|
}
|
|
|
|
# <LJFUNC>
|
|
# name: LJ::Memories::clear_memcache
|
|
# class: web
|
|
# des: Deletes memcached keyword data.
|
|
# args: uobj
|
|
# des-uobj: User object to clear memcached keywords for.
|
|
# returns: undef.
|
|
# </LJFUNC>
|
|
sub clear_memcache {
|
|
my $u = shift;
|
|
return unless ref $u;
|
|
my $userid = $u->{userid};
|
|
|
|
LJ::MemCache::delete( [ $userid, "memct:$userid" ] );
|
|
|
|
LJ::MemCache::delete( [ $userid, "memkwid:$userid" ] );
|
|
|
|
# Delete all memkwcnt entries
|
|
LJ::MemCache::delete( [ $userid, "memkwcnt:$userid:w:f" ] );
|
|
LJ::MemCache::delete( [ $userid, "memkwcnt:$userid:w:v" ] );
|
|
LJ::MemCache::delete( [ $userid, "memkwcnt:$userid:w:u" ] );
|
|
LJ::MemCache::delete( [ $userid, "memkwcnt:$userid:t:f" ] );
|
|
LJ::MemCache::delete( [ $userid, "memkwcnt:$userid:t:v" ] );
|
|
LJ::MemCache::delete( [ $userid, "memkwcnt:$userid:t:u" ] );
|
|
|
|
return undef;
|
|
}
|
|
|
|
1;
|