source: trunk/gsdl/perllib/classify/NewList.pm@ 13839

###########################################################################
#
# NewList.pm --
# A component of the Greenstone digital library software
# from the New Zealand Digital Library Project at the 
# University of Waikato, New Zealand.
#
# Copyright (C) 1999 New Zealand Digital Library Project
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#
###########################################################################

# simple list classifier plugin 
# to see the options, run "perl -S classinfo.pl NewList"

use BasClas;
package NewList;

use strict;
no strict 'refs'; # allow filehandles to be variables and viceversa
use diagnostics;
use sorttools;

sub BEGIN {
    @NewList::ISA = ('BasClas');
}

my $arguments =   
    [ { 'name' => "after_specified_date",
    'desc' => "{NewList.after_specified_date}",
    'type' => "string" },
      { 'name' => "return_doc_size", 
    'desc' => "{NewList.return_doc_size}",
    'type' => "int",
    'deft' => "20",
        'reqd' => "no"},
      ];

my $options = { 'name'     => "NewList",
        'desc'     => "{NewList.desc}",
        'abstract' => "no",
        'inherits' => "yes",
        'args'     => $arguments };


sub new {
    my ($class) = shift (@_);

    my ($classifierslist,$inputargs,$hashArgOptLists) = @_;
    push(@$classifierslist, $class);

    if(defined $arguments){ push(@{$hashArgOptLists->{"ArgList"}},@{$arguments});}
    if(defined $options) { push(@{$hashArgOptLists->{"OptList"}},$options)};

    my $self = new BasClas($classifierslist, $inputargs, $hashArgOptLists);

    # Transfer value from Auto Parsing to the variable name that used in previous GreenStone.
    my (@meta_list,$meta1);
    if ($self->{"metadata"}) {
    @meta_list = split(/,/, $self->{"metadata"});
    $meta1 = $meta_list[0];
    $self->{'meta_list'} = \@meta_list;
    } else {
    $meta1=undef;
    @meta_list = undef;
    }

    if (!$self->{"buttonname"}) {
    if (defined ($self->{'metadata'})) {
        $self->{"buttonname"} = $self->generate_title_from_metadata($self->{'metadata'});
    } else {
        $self->{"buttonname"} = 'NewList';
    }
    }


    # Further setup
 
    $self->{'list'} = [];

    # Clean out the unused keys
    delete $self->{"metadata"}; # Delete this key
    return bless $self, $class;
}

sub init {
    my $self = shift (@_);

}

sub classify {
    use Time::Local;
    my $self = shift (@_);
    my ($doc_obj) = @_;

    my $doc_OID = $doc_obj->get_OID();

    # are we sorting the list??
    my $nosort = 0;
    if (defined $self->{'sort'} && $self->{'sort'} eq "nosort") {
    $nosort = 1;
    }
    
    if (defined $self->{'after_specified_date'}){
    my $topsection=$doc_obj->get_top_section();
    my @values=split('/',$self->{'after_specified_date'});

    my $specified_date=timelocal(0,0,0,$values[0],$values[1]-1,$values[2]);
    
    my $value_lastmodified=
            $doc_obj->get_metadata_element($topsection, 'lastmodified');

    my @values_lastmodi=(localtime($value_lastmodified))[3,4,5];
    #print STDERR "$values_lastmodi[0],  $values_lastmodi[1],  $values_lastmodi[2]+1900  \n";
    my $lastmodified_date=timelocal(0,0,0,$values_lastmodi[0],$values_lastmodi[1],$values_lastmodi[2]+1900);

    #print STDERR "specified_date : " .  localtime($specified_date)  . "\n";
    if ($lastmodified_date>=$specified_date){
        print STDERR " lastmodified_value: ", localtime($value_lastmodified), "\n";
        push (@{$self->{'lastmodified_values'}},$value_lastmodified);
        push (@{$self->{'list'}}, $doc_OID);
    }else{
        return;
    }
    
    }else{
    return;
    }

    my $id = $self->get_number();
    $doc_obj->add_metadata($doc_obj->get_top_section(), "memberof", "CL$id");
}


sub get_classify_info {
    my $self = shift (@_);
    my ($no_thistype) = @_;
   # $no_thistype = 0 unless defined $no_thistype;
    my $memberof = &supports_memberof();
    my $return_doc_size=0;
    if (defined $self->{'return_doc_size'}){
    $return_doc_size=$self->{'return_doc_size'};
    }

    my @list = ();
    @list = @{$self->{'list'}};


    # organise into classification structure
     my %classifyinfo = ('childtype'=>'VList',
            'Title'=>$self->{'buttonname'},
            'contains'=>[]);

    $classifyinfo{'thistype'} = 'Invisible';
    #$classifyinfo{'thistype'} = 'Invisible' unless $no_thistype;
    # always supports memberof
    $classifyinfo{'supportsmemberof'} = $memberof;

    #mapping lastmodified with OID in a hashtable
    my %metavaluetoOIDhash=();
    my $size= @{$self->{'lastmodified_values'}};
    print STDERR "size of lastmodified_values: ", $size, "\n";
    my @lastmodified_values=();
    @lastmodified_values = @{$self->{'lastmodified_values'}};

    my $i;
    for ($i=0;($i<$size);$i++){
    #print STDERR "lastmodified_values : " .  $lastmodified_values[$i] .  "list : " .  $list[$i], "\n";
    $metavaluetoOIDhash{$list[$i]}=$lastmodified_values[$i];
    }
    
    #sort the hashtable by values, then form an array containing keys
    my @sortedOIDbylastmodified = sort { $metavaluetoOIDhash{$b} <=> $metavaluetoOIDhash{$a} } keys %metavaluetoOIDhash;

    my $j=0;
    for ($i=0;($i<$size);$i++){
    my $OID= $sortedOIDbylastmodified[$i];
    my $hashref={};
    # special oid format, if using offsets (from AZCompactList)
    if ($OID =~ s/\.offset(\d+)$//) {
        $hashref->{'offset'}=$1;
    }
    $hashref->{'OID'}=$OID;

    push (@{$classifyinfo{'contains'}}, $hashref);
    $j++;
    
    if($return_doc_size>0 && $j>=$return_doc_size){
        last;
    }
    }

    return \%classifyinfo;
}

sub supports_memberof {
    my $self = shift(@_);

    return "true";
}


1;