File Coverage

blib/lib/E2/UserSearch.pm

Criterion	Covered	Total	%
statement	18	188	9.5
branch	0	100	0.0
condition	0	76	0.0
subroutine	6	35	17.1
pod	5	18	27.7
total	29	417	6.9

# E2::UserSearch
# Jose M. Weeks
# 06 July 2003
#
# See bottom for pod documentation.

package E2::UserSearch;

use 5.006;
use strict;
use warnings;
use Carp;

use E2::Ticker;
use E2::Writeup;

our $VERSION = "0.33";
our @ISA = qw(E2::Ticker);
our $DEBUG; *DEBUG = *E2::Interface::DEBUG;

sub new;
sub clear;

sub writeups;
sub sort_results;

sub new {
	my $arg   = shift;
	my $class = ref( $arg ) || $arg;
	my $self  = $class->SUPER::new();

	bless ($self, $class);

	$self->clear;

	return $self;
}

sub clear {
	my $self = shift or croak "Usage: clear E2USERSEARCH";

	warn "E2::UserSearch::clear\n"	if $DEBUG > 1;

	$self->{lastuser} 	= undef;	# username of last user searched
	@{ $self->{writeups} } 	= ();		# list of E2::Writeup

	return 1;
}

sub writeups {
	my $self = shift or croak "Usage: writeups E2USERSEARCH [ USER ] [, SORT_BY ] [, COUNT ] [, STARTAT ]";
	my $user = shift || $self->this_username;
	my $sort_by = shift;
	my $count = shift;
	my $startat = shift;

	warn "E2::UserSearch::writeups\n"	if $DEBUG > 1;

	if( !$user ) {
		warn "No user specified and not logged in" if $DEBUG;
		return undef;
	}

	my %opt;

	$opt{searchuser} = $user;
	$opt{startat} = $startat	if $startat;

	if( $sort_by ) {
		$sort_by = lc($sort_by);
		if( $sort_by ne 'rep' && $sort_by ne 'creation' &&
			$sort_by ne 'title' ) {
			croak "Invalid search option: $sort_by";
		}

		$opt{sort} = $sort_by;
	} else {
		$opt{nosort} = 1;
		$sort_by = "none";
	}

	if( $count && $count == -1 ) { # Get all
		$opt{nolimit} = 1;
	} elsif( $count ) {
		$opt{count} = $count;
	}

	$user = lc( $user );

	# We don't add this search to the last if this is a
	# search on a new user.

	if( $self->{lastuser} && $self->{lastuser} ne $user ) {
		$self->clear;
	}

	# Ugly stuff, but this keeps our place so we
	# can determine the rep-based order of
	# writeups across multiple search loads.

	$self->{rep_number} = 100000 - ($startat || 0);

	my $handlers = {
		'wu' => sub {
			(my $a, my $b) = @_;
			my $wu = new E2::Writeup;

			$wu->{type} = 'writeup';

			$wu->{createtime} = $b->{att}->{createtime};
			$wu->{marked}	= $b->{att}->{marked};
			$wu->{hidden}	= $b->{att}->{hidden};
			$wu->{wrtype}	= $b->{att}->{wrtype};

			$wu->{cool_count} = $b->{att}->{cools};

			if( my $rep = $b->first_child('rep') ) {
				$wu->{rep}->{up} = $rep->{att}->{up};
				$wu->{rep}->{down} = $rep->{att}->{down};
				$wu->{rep}->{total} = $rep->text;
			}

			if( my $lnk = $b->first_child( 'e2link' ) ) {
				$wu->{title} = $lnk->text;
				$wu->{node_id} = $lnk->{att}->{node_id};
			}

			if( my $parent = $b->first_child( 'parent' ) ) {
				my $l = $parent->first_child('e2link');
				$wu->{parent} = $l->text;
				$wu->{parent_id} = $l->{att}->{node_id};
			}

			# We're going to add a value to the E2::Writeup.
			# This is sort of a kludgy thing to do, but
			# the situation (having to infer reputation
			# based upon context) means we've got to store
			# it somewhere.

			if( $sort_by eq 'rep' ) {
				$wu->{_rep_position} = $self->{rep_number}--;
			} else {
				$wu->{_rep_position} = 0;
			}

			push @{ $self->{writeups} }, $wu;
		}
	};

	@{$self->{writeups}} = (); # clear

	return $self->parse(
		'usersearch',
		$handlers,
		$self->{writeups},
		%opt
	);
}

sub sort_results {
	my $self = shift or croak "Usage: sort_results E2USERSEARCH [, SORTBY [ , COUNT [ , STARTAT ] ] ]";
	my $sortby = shift;
	my $count = shift;
	my $startat = shift;

	my $sort;

	warn "E2::UserSearch::sort_results\n"	if $DEBUG > 1;

	# Define a bunch of sort routines
	# (This whole thing is a mess..... ugly...... but it works)

	sub sort_by_creation {
		$b->{createtime} =~ /(....)-(..)-(..) (..):(..):(..)/;
		(my $year1, my $month1, my $day1, my $hour1, my $min1, my $sec1 )
			= ($1, $2, $3, $4, $5, $6);
		$a->{createtime} =~ /(....)-(..)-(..) (..):(..):(..)/;
		(my $year2, my $month2, my $day2, my $hour2, my $min2, my $sec2 )
			= ($1, $2, $3, $4, $5, $6);

		$year1 <=> $year2 || $month1 <=> $month2 || $day1 <=> $day2 ||
			$hour1 <=> $hour2 || $min1 <=> $min2 || $sec1 <=> $sec2;
	};

	sub sort_by_creation_reverse {
		$a->{createtime} =~ /(....)-(..)-(..) (..):(..):(..)/;
		(my $year1, my $month1, my $day1, my $hour1, my $min1, my $sec1 )
			= ($1, $2, $3, $4, $5, $6);
		$b->{createtime} =~ /(....)-(..)-(..) (..):(..):(..)/;
		(my $year2, my $month2, my $day2, my $hour2, my $min2, my $sec2 )
			= ($1, $2, $3, $4, $5, $6);

		$year1 <=> $year2 || $month1 <=> $month2 || $day1 <=> $day2 ||
			$hour1 <=> $hour2 || $min1 <=> $min2 || $sec1 <=> $sec2;
	};

	sub sort_by_title { $a->title cmp $b->title };

	sub sort_by_title_reverse { $b->title cmp $a->title };

	sub sort_by_rep { ($b->rep->{total} || 0) <=> ($a->rep->{total} || 0) };

	sub sort_by_rep_position { $b->{_rep_position} <=> $a->{_rep_position} };

	sub sort_by_rep_position_reverse { $a->{_rep_position} <=> $b->{_rep_position} };

	sub sort_by_rep_reverse { ($a->rep->{total} || 0) <=> ($b->rep->{total} || 0) };

	sub sort_by_cools { $b->cool_count <=> $a->cool_count };

	sub sort_by_cools_reverse { $a->cools <=> $a->cools };

	sub sort_by_random{ int(rand(3))-1 };

	if( !$count )   { $count = -1; }
	if( !$startat ) { $startat = 0; }

	# Determine which way we want to sort and stick the method
	# into the subroutine $sort.

	if( ! defined $sortby ) {
		$sort = sub { sort_by_creation; }
	} elsif( ref( $sortby ) eq 'CODE' ) {
		$sort = $sortby;
	} elsif( lc($sortby) eq "creation" ) {
		$sort = sub { sort_by_creation; }
	} elsif( lc($sortby) eq "title" ) {
		$sort = sub { sort_by_title; }
	} elsif( lc($sortby) eq "rep" ) {
		$sort = sub { sort_by_rep || sort_by_rep_position || sort_by_creation; }
	} elsif( lc($sortby) eq "cools" ) {
		$sort = sub { sort_by_cools || sort_by_rep || sort_by_rep_position; }
	} elsif( lc($sortby) eq "creation_reverse" ) {
		$sort = sub { sort_by_creation_reverse; }
	} elsif( lc($sortby) eq "title_reverse" ) {
		$sort = sub { sort_by_title_reverse; }
	} elsif( lc($sortby) eq "rep_reverse" ) {
		$sort = sub { sort_by_rep_reverse || sort_by_rep_position_reverse ||
			sort_by_creation_reverse; }
	} elsif( lc($sortby) eq "cools_reverse" ) {
		$sort = sub { sort_by_cools_reverse || sort_by_rep_reverse ||
			sort_by_rep_position_reverse; }
	} elsif( lc($sortby) eq "random" ) {
		$sort = sub { sort_by_random; }
	} else {
		croak "Invalid sort type: $sortby";
	}

	# Sort

	my @sorted = sort $sort @{ $self->{writeups} };

	if( $count == -1 ) { return @sorted; }

	return splice @sorted, $startat, $count;
}

sub compare {
	my $self  = shift or croak "Usage: compare E2USERSEARCH, OLDUSERSEARCH";
	my $old   = shift or croak "Usage: compare E2USERSEARCH, OLDUSERSEARCH";

	warn "E2::UserSearch::compare\n"	if $DEBUG > 1;

	if( ! $self->{writeups} || ! $old->{writeups} ) {
		warn"Usersearch not loaded"	if $DEBUG;
		return undef;
	}

	my $stats;
	my @changes;

	# Build a mapping of node_id to node for $old

	my %map;

	foreach( @{$old->{writeups}} ) {
		$map{$_->node_id} = $_;
	}

	foreach( $self->sort_results( 'rep' ) ) {

		my $writeup = {
			title	  => $_->title,
			node_id   => $_->node_id,
			parent    => $_->parent,
			parent_id => $_->parent_id,
			rep	  => $_->rep,
			cools	  => $_->cool_count
		};

		# Get stats

		my $r = $_->rep->{total};

		if( !defined $stats->{min_rep} || $r < $stats->{min_rep} ) {
			$stats->{min_rep} = $r;
		}

		if( !defined $stats->{max_rep} || $r > $stats->{max_rep} ) {
			$stats->{max_rep} = $r;
		}

		# Store statistics

		$stats->{total_rep} += $r;
		$stats->{total_cools} += $_->cool_count;
		$stats->{$_->wrtype} += 1;

		# Get changes

		my $id = $_->node_id;
		my $changed = undef;

		if( !$map{$id} ) { # New writeup (not yet stored)
			$writeup->{new} = 1;
			$writeup->{change_up}		= $_->rep->{up};
			$writeup->{change_down}		= $_->rep->{down};
			$writeup->{change_cools}	= $_->cool_count;

			$changed = 1;

		} else {

			sub wr_diff {
				my ($a, $b) = @_;
				return $a->rep->{up} != $b->rep->{up} ||
					$a->rep->{down} != $b->rep->{down} ||
					$a->cool_count != $b->cool_count;
			}

			if( wr_diff( $_, $map{$id} ) ) {

				$writeup->{change_up} = $_->rep->{up} -
					$map{$id}->rep->{up};
				$writeup->{change_down} = $_->rep->{down} -
					$map{$id}->rep->{down};
				$writeup->{change_cools} = $_->cool_count -
					$map{$id}->cool_count;

				$changed = 1;
			}

			if( $_->title ne $map{$id}->title ) {
				$writeup->{old_title} = $map{$id}->title;

				$changed = 1;
			}

			delete $map{$id};
		}

		push @changes, $writeup		if $changed;
	}

	# Now store removed writeups

	foreach( keys %map ) {
		push @changes, {
			title => $_->title,
			rep   => $_->rep,
			cools => $_->cools,
			removed => 1
		}
	}

	# Store

	$self->{stats} = $stats;

	return @changes;
}

sub stats {
	my $self = shift	or croak "Usage: stats E2USERSEARCH";

	return $self->{stats};
}

1;
__END__