manager.pm

Punjab is a jabber XMLRPC/SOAP/REST client. It is a xmlrpc, soap, or REST server that allows for p

package PunJab::Manager;
use warnings;
use strict;

use DBD::SQLite;
use POE;
use POE::Filter::XML;
use POE::Filter::XML::Node;
use POE::Filter::XML::NS qw/ :JABBER :IQ /;
use POE::Filter::XML::Utils;
use PunJab::Util;

use POSIX qw(strftime);
use Data::Uniqid qw ( suniqid uniqid luniqid );


sub new()
{
	my $class = shift;
	my $self =  $class . '->new()';
	die "$self requires an even amount of arguments" if(@_ & 1);

	my $args = {};

	while($#_ != -1)
	{
		my $key = lc(shift(@_));
		my $value = shift(@_);
		if(ref($value) eq 'HASH')
		{
			my $hash = {};
			foreach my $sub_key (keys %$value)
			{
				$hash->{lc($sub_key)} = $value->{$sub_key};
			}
			$args->{$key} = $hash;
			next;
		}
		$args->{$key} = $value;
	}
	my $session_id;
	POE::Session->create
	(
		inline_states => 
		{
			_start => 
				sub
				{
				    my $alias;
				    my ($kernel, $heap) = @_[KERNEL, HEAP];
				    $kernel->alias_set($args->{'alias'});
				    $heap->{'CONFIG'} = $args;
				    $session_id = $_[SESSION]->ID;
				    #my $dbd = "sql";
				    $heap->{'CONFIG'}->{sql}->{dbfile} = $args->{database}."/".$args->{'alias'};  
				    $heap->{'CONFIG'}->{sql}->{dbname} = "dbi:SQLite:dbname=".$args->{database}."/".$args->{'alias'};
				    # connect to the database
				    $heap->{dbh} = DBI->connect($heap->{'CONFIG'}->{sql}->{dbname});
				    if (!$heap->{dbh}) {
					die "Error connecting to $heap->{'CONFIG'}->{sql}->{dbname}\n\t$DBI::errstr\n";
				    }    
				    if ($heap->{'CONFIG'}->{debug}>0) {
					&debug('Started sqlite');
				    }

				    $heap->{dbh}->func( 'NOW', 0, sub { return strftime "%Y%m%d%H%M%S", localtime;
								       }, 'create_function' );
				    # grab the tables and if they are not created, create them
				    my @tables = $heap->{dbh}->tables();
				    # The database design is in flux right now.
				    # I hope soon we will decide on something.
				    
				    foreach my $table (@tables)
				    {
					
					if($table eq "roster")
					{
					    $heap->{'roster_table'} = 1;
					
					    next;
					}
					if($table eq "message")
					{
					    $heap->{'message_table'} = 1;
					
					    next;
					}
					if($table eq "iq")
					{
					    $heap->{'iq_table'} = 1;
					    next;
					}
					if($table eq "presence")
					{
					    $heap->{'presence_table'} = 1;
					    next;
					}
					if($table eq "groups")
					{
					    $heap->{'groups_table'} = 1;
					    next;
					}
			
				    }
				    # create the tables.
				    if (not $heap->{'roster_table'}) {
					if ($heap->{'CONFIG'}->{debug}>0) {
					    &debug("create roster table");
					}
					$heap->{dbh}->do(
							 "CREATE TABLE roster (
                                                                            id INTEGER PRIMARY KEY NOT NULL,
                                                                            jid varchar(255)  default '',
                                                                            name text,
                                                                            ask text,
                                                                            subscription text,
                                                                            group_name text,
                                                                            xml text)"
									);
				    }

				    if (not $heap->{'iq_table'}) {
					if ($heap->{'CONFIG'}->{debug}>0) {
					    &debug("create iq table");
					}
					$heap->{dbh}->do(
							 "CREATE TABLE iq (
                                                                            iq_id INTEGER PRIMARY KEY NOT NULL,
                                                                            from_attr varchar(255)  default '',
                                                                            type varchar(255)  default '',
                                                                            id varchar(255)  default '',
                                                                            xml text )"
									);
				    }

				    if (not $heap->{'message_table'}) {
					if ($heap->{'CONFIG'}->{debug}>0) {
					    &debug("create message table");
					}
					$heap->{dbh}->do(
							 "CREATE TABLE message (
                                                                            message_id INTEGER PRIMARY KEY NOT NULL,
                                                                            to_attr varchar(255)  default '',
                                                                            from_attr varchar(255)  default '',
                                                                            type varchar(255)  default '',
                                                                            body text,
                                                                            subject text,
                                                                            thread text,
                                                                            id varchar(255)  default '',
                                                                            time_stamp timestamp(14),
                                                                            xml text )"
									);
				    }
				    if (not $heap->{'presence_table'}) {
					if ($heap->{'CONFIG'}->{debug}>0) {
					    &debug("create presence table");
					}
					$heap->{dbh}->do(
							 "CREATE TABLE presence (
                                                                            presence_id INTEGER PRIMARY KEY NOT NULL,
                                                                            to_attr varchar(255)  default '',
                                                                            from_attr varchar(255)  default '',
                                                                            type varchar(255)  default '',
                                                                            show varchar(255)  default '',
                                                                            status varchar(255)  default '',
                                                                            priority varchar(255)  default '',
                                                                            id varchar(255)  default '',
                                                                            time_stamp timestamp(14),
                                                                            xml text )"
									);
				    }

				    # set up statement handles 
				    $heap->{'insert_message'} = $heap->{dbh}->prepare(
										      "INSERT INTO message (  
                                                                                                         to_attr, 
                                                                                                         from_attr,
                                                                                                         type,
                                                                                                         id,
                                                                                                         body,
                                                                                                         subject,
                                                                                                         thread,
                                                                                                         time_stamp,
                                                                                                         xml      
                                                                                                                 ) 
                                                                                                    VALUES (
                                                                                                              ?,
                                                                                                              ?,
                                                                                                              ?,
                                                                                                              ?,
                                                                                                              ?,
                                                                                                              ?,
                                                                                                              ?,
                                                                                                          NOW(),
                                                                                                               ?
                                                                                                                  )"
											    );
				    
				    $heap->{'insert_presence'} = $heap->{dbh}->prepare(
										       "INSERT INTO presence ( 
                                                                                                          to_attr, 
                                                                                                          from_attr,
                                                                                                          type,
                                                                                                          show,
                                                                                                          status,
                                                                                                          priority,
                                                                                                          id,
                                                                                                          time_stamp,
                                                                                                          xml      
                                                                                                         ) 
                                                                                                     VALUES (      
                                                                                                            ?,
                                                                                                            ?,
                                                                                                            ?,
                                                                                                            ?,
                                                                                                            ?,
                                                                                                            ?,
                                                                                                            ?,
                                                                                                        NOW(),
                                                                                                            ?
                                                                                                              )"
											     );
				    $heap->{'ins_r'} = $heap->{dbh}->prepare(
									     "INSERT INTO roster ( 
                                                                                                        jid,
                                                                                                        name,
                                                                                                        ask,
                                                                                                        subscription,
                                                                                                        group_name,
                                                                                                        xml 
                                                                                                        ) 
                                                                                                   VALUES (
                                                                                                          ?,
                                                                                                          ?,
                                                                                                          ?,
                                                                                                          ?,
                                                                                                          ?,
                                                                                                          ?
                                                                                                          )"
									     );
				    

				    $heap->{'select_roster'} = $heap->{dbh}->prepare(
							     "SELECT * FROM roster ORDER BY group_name"
										     );

 
				},
			_stop =>
				sub
				{
				    if ($_[HEAP]->{'CONFIG'}->{debug}>0) {
					&debug("Manager Stoped");
				    }
				    my $kernel = $_[KERNEL];				    
				    undef $_[HEAP]->{'dbh'};
				    unlink $_[HEAP]->{'CONFIG'}->{sql}->{dbfile};
				},
                       shutdown => 
                               sub {
				   my ($kernel, $heap) = @_[KERNEL, HEAP];
				   $heap->{shutdown} = 1;
						   
				   $kernel->alias_remove($args->{'alias'}) if defined $args->{'alias'};
				   $heap->{'dbh'}->disconnect() if defined $heap->{'dbh'};
				   undef $heap->{'dbh'};
				   unlink $_[HEAP]->{'CONFIG'}->{sql}->{dbfile};
				   
			       },
			input_event          => \&input_event,
                        start_roster         => \&start_roster,
                        start_browse         => \&start_browse,
                        start_vcard          => \&start_vcard,
                        manage_iq            => \&manage_iq,
			manage_roster        => \&manage_roster,
			manage_message       => \&manage_message,
                        start_message_event  => \&start_message_event,
			manage_presence      => \&manage_presence,
                        start_presence_event => \&start_presence_event,
                        manage_events        => \&manage_events, 
			get_managed_iq       => \&get_managed_iq,
			get_managed_roster   => \&get_managed_roster,
                        get_managed_message  => \&get_managed_message,
                        get_managed_presence => \&get_managed_presence,
                        check_managed_message=> \&check_managed_message,
                        delete_presence      => \&delete_presence,
		}
	);
    return $session_id;
}

sub input_event 
{
        my ($self, $kernel,$heap,$node) = @_[SESSION, KERNEL, HEAP, ARG0];
	
	if($node->name() eq 'iq')
	{
	    my $attrs = $node->get_attrs();
	    
	    if(defined($attrs->{'type'}) and $attrs->{'type'} eq +IQ_RESULT)
	    {
		my $children = $node->get_children_hash();
		if(defined($children->{'query'}) and 
		   $children->{'query'}->attr('xmlns') eq +NS_JABBER_ROSTER)
		{
		    $kernel->yield('manage_roster', $node);
		} else { 
		    $kernel->yield('manage_iq', $node);
		}
	    } else { 
		$kernel->yield('manage_iq', $node);
	    }
	    # if an event is associated with this node then act
	    # you can also use return_to_send in PCJ
	    if(exists($attrs->{'id'}))
	    {
		if(defined($heap->{'PENDING'}->{$attrs->{'id'}}))
		{
		    # if this turns into database, need to delete from it too
		    delete $heap->{'iq'}->{$attrs->{'id'}};
		    my $array = delete $heap->{'PENDING'}->{$attrs->{'id'}};
		    my $session = shift @$array;
		    my $event   = shift @$array;
		    $kernel->post($session, $event, $node,@$array);
		    
		}
	    }
	} elsif($node->name() eq 'message') {
	  
	    $kernel->yield('manage_message', $node);
	    
	} elsif($node->name() eq 'presence') {
	    $kernel->yield('manage_presence', $node);
	    
	}

	return 0;
}

sub start_message_event()
{
    my ($self, $sender,$kernel,$heap,$event,$event_param)
	= @_[SESSION,SENDER, KERNEL, HEAP, ARG0, ARG1];
    my $tmp_hash = { 
	sender => $sender , 
	event => $event , 
	param => $event_param 
	};
    push(@{$heap->{'manage_message_event'}},$tmp_hash);
}
# maybe combine these functions?
sub start_presence_event()
{
    my ($self, $sender,$kernel,$heap,$event,$event_param)
	= @_[SESSION,SENDER, KERNEL, HEAP, ARG0, ARG1];
    my $tmp_hash = { 
	sender => $sender , 
	event => $event , 
	param => $event_param 
	};
    push(@{$heap->{'manage_presence_event'}},$tmp_hash);
}

sub start_roster()
{
	my ($self, $sender,$kernel,$heap,$event,$event_param,$id,$sid,$jabber_session) 
	    = @_[SESSION,SENDER, KERNEL, HEAP, ARG0 .. ARG4];
	# clear out roster and groups
	$heap->{dbh}->do(
			  "DELETE FROM roster"
			 );


	my $node = POE::Filter::XML::Node->new('iq');
	$node->attr('type', +IQ_GET);
	$node->attr('id', $id);
	my $q = $node->insert_tag('query');
	$q->attr('xmlns',+NS_JABBER_ROSTER);
	
	
	$heap->{'PENDING'}->{$id}->[0] = $sender;
	$heap->{'PENDING'}->{$id}->[1] = $event;
	$heap->{'PENDING'}->{$id}->[2] = $event_param;
	$heap->{'PENDING'}->{$id}->[3] = $node;
	$heap->{'PENDING'}->{$id}->[4] = $sid;
	$heap->{'PENDING'}->{$id}->[5] = 'start_roster';
	$kernel->post($jabber_session, 'output_handler', $node);
	
}

sub start_browse()
{
	my ($self,$kernel,$heap,$event,$event_param,$sender,$id,$sid,$jid,$auto,$items) 
	    = @_[SESSION, KERNEL, HEAP, ARG0 .. ARG6];
	
	for (my $i=1;$i<=3;$i++) {
	    $heap->{'PENDING'}->{$id."$i"}->[0] = $sender;
	    $heap->{'PENDING'}->{$id."$i"}->[1] = $event;
	    $heap->{'PENDING'}->{$id."$i"}->[2] = $event_param;
	    $heap->{'PENDING'}->{$id."$i"}->[3] = $id;
	    $heap->{'PENDING'}->{$id."$i"}->[4] = $jid;
	    $heap->{'PENDING'}->{$id."$i"}->[5] = $sid;
	    $heap->{'PENDING'}->{$id."$i"}->[6] = $auto;
	    $heap->{'PENDING'}->{$id."$i"}->[7] = $items;
	}	

}

sub start_vcard()
{
	my ($self,$kernel,$heap,$event,$event_param,$sender,$jid,$id,$sid) 
	    = @_[SESSION, KERNEL, HEAP, ARG0 .. ARG5];
	
	    $heap->{'PENDING'}->{$id}->[0] = $sender;
	    $heap->{'PENDING'}->{$id}->[1] = $event;
	    $heap->{'PENDING'}->{$id}->[2] = $event_param;
	    $heap->{'PENDING'}->{$id}->[3] = $jid;
	    $heap->{'PENDING'}->{$id}->[4] = $sid;	
}

sub manage_events() {
    	my ($self, $sender, $kernel, $heap,$event,$event_param,$node,$sid) =