Solstice::Subgroup - Manages subsets of people.

  # See Solstice::Group
  #   This disables subgroup management, and classlists but is otherwise the same.

package Solstice::Subgroup;

# $Id: Group.pm 2253 2005-05-18 22:06:27Z mcrawfor $

use 5.006_000;
use strict;
use warnings;

use base qw(Solstice::Group);

use Solstice::Database;
use Solstice::Factory::Person;
use Solstice::ImplementationManager;

our ($VERSION) = ('$Revision: 2253 $' =~ /^\$Revision:\s*([\d.]*)/);
use constant TRUE  => 1;
use constant FALSE => 0;

our $id_creation_counter = 0;

sub new {
    my $obj = shift;
    my $input = shift;
    
    my $self = $obj->SUPER::new($input);

    return unless defined $self;
    
    unless (defined $input) {
        # This is a new subgroup, which is unsaved.  We need to be able to track it, 
        # So we'll give it a name that should be unique across all hosts...
        # If we're offline this will be null, and that's OK.
        my $host = $ENV{'SERVER_ADDR'} || '';
        $host =~ s/\./_/g;
        $self->_setID('unsaved_'.$$.'_'.$host.'_'.$id_creation_counter);
        $id_creation_counter++;
    }
    
    return $self;
}

sub clone {
    my $self = shift;

    my $clone = Solstice::Subgroup->new();
    $clone->setName($self->getName());
    $clone->addMembers($self->getMembers());

    for my $subgroup (@{$self->getSubgroups()->getAll()}) {
        $clone->addSubgroup($subgroup->clone());
    }
        
    return $clone;
}

sub delete {
    my $self = shift;

    return FALSE unless defined $self->getID();

    # Use Solstice::ImplementationManager to inform tools that this group
    # has been deleted
    my $impl_manager = Solstice::ImplementationManager->new();
    my $tool_list = $impl_manager->createList({
        method => 'subgroupDeleted',
        args   => [$self],
    });
    
    my $db = Solstice::Database->new();
    my $id = $self->getID();

    my $config = Solstice::Configure->new();
    my $db_name = $config->getDBName();

    $db->writeQuery('DELETE FROM '.$db_name.'.Subgroup WHERE subgroup_id = ?', $id);
    $db->writeQuery('DELETE FROM '.$db_name.'.PeopleInSubgroup WHERE subgroup_id = ?', $id);

    for my $subgroup (@{$self->getSubgroups()->getAll()}) {
        $subgroup->delete();
    }
    
    return TRUE;
}

sub store {
    my $self = shift;

    $self->_initializeMembers() unless $self->{'_initialized_members'};
    $self->_initializeSubgroups() unless $self->{'_initialized_subgroups'};
    
    my $db = Solstice::Database->new();
    my $config = Solstice::Configure->new();
    my $db_name = $config->getDBName();
    
    my $id = $self->getID();

    my $name = $self->getName();
    
    if (defined $id and $id =~ /^\d+$/) {
    
        $db->writeQuery('UPDATE '.$db_name.'.Subgroup
                SET name=?, date_modified=NOW()
                WHERE subgroup_id = ?',
        $name, $id);
    }
    else {
        $db->writeQuery('INSERT INTO '.$db_name.'.Subgroup
                (name, date_modified, date_created)
                VALUES (?, NOW(), NOW())', $name);

        $id = $db->getLastInsertID();
        $self->_setID($id);
    }
    
    # We should probably come up with a better way of doing this... deleting everyone and readding is a bit crude.
    # XXX - make this smarter
    my $person_insert;
    my @person_data;
    foreach my $person_id (keys %{$self->{'_member_people'}}) {
        $person_insert .= "(?, ?),";
        push @person_data, $person_id;
        push @person_data, $id;
    }

    $db->writeQuery('DELETE FROM '.$db_name.'.PeopleInSubgroup WHERE subgroup_id = ?', $id);
    if (defined $person_insert and $person_insert) {
        chop $person_insert;
        $db->writeQuery('INSERT INTO '.$db_name.'.PeopleInSubgroup (person_id, subgroup_id) VALUES '.$person_insert, @person_data);
    }

    my $subgroup_insert = '';
    my @subgroup_data;
    
    foreach my $subgroup_id (keys %{$self->{'_subgroups'}}) {
        my $subgroup = $self->{'_subgroups'}->{$subgroup_id};
        $subgroup->store();

        my $new_subgroup_id = $subgroup->getID();
        if ($new_subgroup_id ne $subgroup_id) {
            delete $self->{'_subgroups'}->{$subgroup_id};
            $self->{'_subgroups'}->{$new_subgroup_id} = $subgroup;
        }
        $subgroup_insert .= "(NULL, ?, ?),";
        push @subgroup_data, $id;
        push @subgroup_data, $new_subgroup_id;
    }
    chop $subgroup_insert;
    
    $db->writeQuery('DELETE FROM '.$db_name.'.SubgroupsInSubgroup WHERE parent_subgroup_id = ?', $id);
    if ($subgroup_insert) {
        $db->writeQuery('INSERT INTO '.$db_name.'.SubgroupsInSubgroup VALUES '.$subgroup_insert, @subgroup_data);
    }
    
    for my $subgroup_id (keys %{$self->{'_removed_subgroups'}}) {
        my $subgroup = $self->{'_subgroups'}->{$subgroup_id};
        $subgroup->delete();
    }
    $self->{'_removed_subgroups'} = undef;
    
    # Use Solstice::ImplementationManager to inform tools that subgroup has been modified
    my $impl_manager = Solstice::ImplementationManager->new();
    my $tool_list = $impl_manager->createList({
        method => 'subgroupModified',
        args   => [$self],
    });

    return TRUE;
}

sub _initFromHash {
    my $self = shift;
    my $input = shift;

    $self->{'_initialized_subgroups'} = FALSE;
    $self->{'_initialized_members'} = FALSE;
    
    $self->_setID($input->{'id'});
    $self->setName($input->{'name'});
    $self->_setModificationDate($input->{'modification_date'});
    $self->_setCreationDate($input->{'creation_date'});
    $self->setRootGroupID($input->{'root_group_id'});

    return TRUE;
}

sub _initMin {
    my $self = shift;
    my $input = shift;

    return FALSE unless $self->isValidInteger($input);

    my $db = Solstice::Database->new();
    my $config = Solstice::Configure->new();
    my $db_name = $config->getDBName();

    $db->readQuery('SELECT
        s.subgroup_id, s.name, s.date_created, s.date_modified, sig.parent_group_id
        FROM '.$db_name.'.Subgroup AS s, '.$db_name.'.SubgroupsInGroup AS sig
        WHERE s.subgroup_id = sig.subgroup_id AND s.subgroup_id=?', $input);
    
    my $data = $db->fetchRow();

    my $subgroup_id = $data->{'subgroup_id'};
    my $parent_id   = $data->{'parent_group_id'};
    
    if (!defined $subgroup_id) {
        $db->readQuery('SELECT
                s.subgroup_id, s.name, s.date_created, s.date_modified, sig.parent_subgroup_id
                FROM '.$db_name.'.Subgroup AS s, '.$db_name.'.SubgroupsInSubgroup AS sig
                WHERE s.subgroup_id = sig.subgroup_id AND s.subgroup_id=?', $input);
        
        $data = $db->fetchRow();
        $subgroup_id = $data->{'subgroup_id'};
        $parent_id   = $data->{'parent_subgroup_id'};
    }
    
    return FALSE unless defined $subgroup_id;

    $self->{'_initialized_subgroups'} = FALSE;
    $self->{'_initialized_members'} = FALSE;
    
    $self->_setID($subgroup_id);
    $self->setName($data->{'name'});
    $self->_setModificationDate(Solstice::DateTime->new($data->{'date_modified'}));
    $self->_setCreationDate(Solstice::DateTime->new($data->{'date_created'}));
    $self->setRootGroupID($parent_id);

    return TRUE;
}

sub _initializeMembers {
    my $self = shift;

    return FALSE unless defined $self->getID();

    my $db = Solstice::Database->new();
    my $config = Solstice::Configure->new();
    my $db_name = $config->getDBName();

    $db->readQuery('SELECT person_id 
        FROM '.$db_name.'.PeopleInSubgroup
        WHERE subgroup_id = ?', $self->getID());
    
    my @member_ids;
    while (my $data = $db->fetchRow()) {
        push @member_ids, $data->{'person_id'}; 
    }

    my $person_factory = Solstice::Factory::Person->new();
    my $people = $person_factory->createByIDs(\@member_ids)->getAll();
    
    $self->{'_member_people'} = {};
    for my $person (@$people) {
        $self->{'_member_people'}->{$person->getID()} = $person;
    }

    return $self->{'_initialized_members'} = TRUE;
}

sub _initializeOwners {
    return TRUE;
}

sub _initializeMemberGroups {
    return TRUE;
}

sub _initializeRemoteGroups {
    return TRUE;
}

sub _initializeSubgroups {
    my $self = shift;

    return FALSE unless defined $self->getID();

    my $db = Solstice::Database->new();
    my $config = Solstice::Configure->new();
    my $db_name = $config->getDBName();

    $db->readQuery('SELECT subgroup_id
        FROM '.$db_name.'.SubgroupsInSubgroup
        WHERE parent_subgroup_id = ?', $self->getID());
    
    $self->{'_subgroups'} = {};
    while (my $data = $db->fetchRow()) {
        my $subgroup = Solstice::Subgroup->new($data->{'subgroup_id'});
        if (defined $subgroup) {
            $self->{'_subgroups'}->{$data->{'subgroup_id'}} = $subgroup;
        }
    }

    return $self->{'_initialized_subgroups'} = TRUE;    
}

sub _getAllMembers {
    my $self = shift;
    my $seen_groups = shift;
    $seen_groups = {} unless defined $seen_groups;

    my $group_id = $self->getID();
    return {} unless defined $group_id;

    $seen_groups->{$group_id} = TRUE;

    # Make sure we have the data we need to proceed...
    $self->_initializeMembers() unless $self->{'_initialized_members'};
    
    return { map {%$_} $self->{'_member_people'} };
}

sub _populateMemberHash {
    my $self = shift;
    my $member_hash = shift;

    if ($self->{'_initialized_members'}) {
        for my $person_id (keys %{$self->{'_member_people'}}) {
            $member_hash->{$person_id} = TRUE;
        }
    } else {
        $self->_populateDBMemberHash($member_hash);
    }
    return $member_hash;
}

sub _populateDBMemberHash {
    my $self = shift;
    my $member_hash = shift;

    return $member_hash unless defined $self->getID();

    my $db = Solstice::Database->new();
    my $config = Solstice::Configure->new();
    my $db_name = $config->getDBName();

    $db->readQuery('SELECT DISTINCT person_id
        FROM '.$db_name.'.PeopleInSubgroup
        WHERE subgroup_id = ?', $self->getID());

    while (my $data = $db->fetchRow()) {
        $member_hash->{$data->{'person_id'}} = TRUE;
    }

    return $member_hash;
}

sub _getAccessorDefinition {
    return [
        {
            name => 'Name',
            key  => '_name',
            type => 'String',
        },
        {
            name => 'RootGroupID',
            key  => '_root_group_id',
            type => 'Integer',
        }
    ];
}

1;

__END__