+=head2 InsertData
+
+Load some sort of data into the database, takes path to a file.
+
+=cut
+
+sub InsertData {
+ my $self = shift;
+ my $datafile = shift;
+
+ # Slurp in stuff to insert from the datafile. Possible things to go in here:-
+ our (@Groups, @Users, @ACL, @Queues, @ScripActions, @ScripConditions,
+ @Templates, @CustomFields, @Scrips, @Attributes, @Initial, @Final);
+ local (@Groups, @Users, @ACL, @Queues, @ScripActions, @ScripConditions,
+ @Templates, @CustomFields, @Scrips, @Attributes, @Initial, @Final);
+
+ local $@;
+ $RT::Logger->debug("Going to load '$datafile' data file");
+ eval { require $datafile }
+ or return (0, "Couldn't load data from '$datafile' for import:\n\nERROR:". $@);
+
+ if ( @Initial ) {
+ $RT::Logger->debug("Running initial actions...");
+ foreach ( @Initial ) {
+ local $@;
+ eval { $_->(); 1 } or return (0, "One of initial functions failed: $@");
+ }
+ $RT::Logger->debug("Done.");
+ }
+ if ( @Groups ) {
+ $RT::Logger->debug("Creating groups...");
+ foreach my $item (@Groups) {
+ my $new_entry = RT::Group->new( $RT::SystemUser );
+ my $member_of = delete $item->{'MemberOf'};
+ my ( $return, $msg ) = $new_entry->_Create(%$item);
+ unless ( $return ) {
+ $RT::Logger->error( $msg );
+ next;
+ } else {
+ $RT::Logger->debug($return .".");
+ }
+ if ( $member_of ) {
+ $member_of = [ $member_of ] unless ref $member_of eq 'ARRAY';
+ foreach( @$member_of ) {
+ my $parent = RT::Group->new($RT::SystemUser);
+ if ( ref $_ eq 'HASH' ) {
+ $parent->LoadByCols( %$_ );
+ }
+ elsif ( !ref $_ ) {
+ $parent->LoadUserDefinedGroup( $_ );
+ }
+ else {
+ $RT::Logger->error(
+ "(Error: wrong format of MemberOf field."
+ ." Should be name of user defined group or"
+ ." hash reference with 'column => value' pairs."
+ ." Use array reference to add to multiple groups)"
+ );
+ next;
+ }
+ unless ( $parent->Id ) {
+ $RT::Logger->error("(Error: couldn't load group to add member)");
+ next;
+ }
+ my ( $return, $msg ) = $parent->AddMember( $new_entry->Id );
+ unless ( $return ) {
+ $RT::Logger->error( $msg );
+ } else {
+ $RT::Logger->debug( $return ."." );
+ }
+ }
+ }
+ }
+ $RT::Logger->debug("done.");
+ }
+ if ( @Users ) {
+ $RT::Logger->debug("Creating users...");
+ foreach my $item (@Users) {
+ my $new_entry = new RT::User( $RT::SystemUser );
+ my ( $return, $msg ) = $new_entry->Create(%$item);
+ unless ( $return ) {
+ $RT::Logger->error( $msg );
+ } else {
+ $RT::Logger->debug( $return ."." );
+ }
+ }
+ $RT::Logger->debug("done.");
+ }
+ if ( @Queues ) {
+ $RT::Logger->debug("Creating queues...");
+ for my $item (@Queues) {
+ my $new_entry = new RT::Queue($RT::SystemUser);
+ my ( $return, $msg ) = $new_entry->Create(%$item);
+ unless ( $return ) {
+ $RT::Logger->error( $msg );
+ } else {
+ $RT::Logger->debug( $return ."." );
+ }
+ }
+ $RT::Logger->debug("done.");
+ }
+ if ( @CustomFields ) {
+ $RT::Logger->debug("Creating custom fields...");
+ for my $item ( @CustomFields ) {
+ my $new_entry = new RT::CustomField( $RT::SystemUser );
+ my $values = delete $item->{'Values'};
+
+ my @queues;
+ # if ref then it's list of queues, so we do things ourself
+ if ( exists $item->{'Queue'} && ref $item->{'Queue'} ) {
+ $item->{'LookupType'} ||= 'RT::Queue-RT::Ticket';
+ @queues = @{ delete $item->{'Queue'} };
+ }
+
+ my ( $return, $msg ) = $new_entry->Create(%$item);
+ unless( $return ) {
+ $RT::Logger->error( $msg );
+ next;
+ }
+
+ foreach my $value ( @{$values} ) {
+ my ( $return, $msg ) = $new_entry->AddValue(%$value);
+ $RT::Logger->error( $msg ) unless $return;
+ }
+
+ # apply by default
+ if ( !@queues && !exists $item->{'Queue'} && $item->{LookupType} ) {
+ my $ocf = RT::ObjectCustomField->new($RT::SystemUser);
+ $ocf->Create( CustomField => $new_entry->Id );
+ }
+
+ for my $q (@queues) {
+ my $q_obj = RT::Queue->new($RT::SystemUser);
+ $q_obj->Load($q);
+ unless ( $q_obj->Id ) {
+ $RT::Logger->error("Could not find queue ". $q );
+ next;
+ }
+ my $OCF = RT::ObjectCustomField->new($RT::SystemUser);
+ ( $return, $msg ) = $OCF->Create(
+ CustomField => $new_entry->Id,
+ ObjectId => $q_obj->Id,
+ );
+ $RT::Logger->error( $msg ) unless $return and $OCF->Id;
+ }
+ }
+
+ $RT::Logger->debug("done.");
+ }
+ if ( @ACL ) {
+ $RT::Logger->debug("Creating ACL...");
+ for my $item (@ACL) {
+
+ my ($princ, $object);
+
+ # Global rights or Queue rights?
+ if ( $item->{'CF'} ) {
+ $object = RT::CustomField->new( $RT::SystemUser );
+ my @columns = ( Name => $item->{'CF'} );
+ push @columns, Queue => $item->{'Queue'} if $item->{'Queue'} and not ref $item->{'Queue'};
+ $object->LoadByName( @columns );
+ } elsif ( $item->{'Queue'} ) {
+ $object = RT::Queue->new($RT::SystemUser);
+ $object->Load( $item->{'Queue'} );
+ } else {
+ $object = $RT::System;
+ }
+
+ $RT::Logger->error("Couldn't load object") and next unless $object and $object->Id;
+
+ # Group rights or user rights?
+ if ( $item->{'GroupDomain'} ) {
+ $princ = RT::Group->new($RT::SystemUser);
+ if ( $item->{'GroupDomain'} eq 'UserDefined' ) {
+ $princ->LoadUserDefinedGroup( $item->{'GroupId'} );
+ } elsif ( $item->{'GroupDomain'} eq 'SystemInternal' ) {
+ $princ->LoadSystemInternalGroup( $item->{'GroupType'} );
+ } elsif ( $item->{'GroupDomain'} eq 'RT::System-Role' ) {
+ $princ->LoadSystemRoleGroup( $item->{'GroupType'} );
+ } elsif ( $item->{'GroupDomain'} eq 'RT::Queue-Role' &&
+ $item->{'Queue'} )
+ {
+ $princ->LoadQueueRoleGroup( Type => $item->{'GroupType'},
+ Queue => $object->id);
+ } else {
+ $princ->Load( $item->{'GroupId'} );
+ }
+ } else {
+ $princ = RT::User->new($RT::SystemUser);
+ $princ->Load( $item->{'UserId'} );
+ }
+
+ # Grant it
+ my ( $return, $msg ) = $princ->PrincipalObj->GrantRight(
+ Right => $item->{'Right'},
+ Object => $object
+ );
+ unless ( $return ) {
+ $RT::Logger->error( $msg );
+ }
+ else {
+ $RT::Logger->debug( $return ."." );
+ }
+ }
+ $RT::Logger->debug("done.");
+ }
+
+ if ( @ScripActions ) {
+ $RT::Logger->debug("Creating ScripActions...");
+
+ for my $item (@ScripActions) {
+ my $new_entry = RT::ScripAction->new($RT::SystemUser);
+ my ( $return, $msg ) = $new_entry->Create(%$item);
+ unless ( $return ) {
+ $RT::Logger->error( $msg );
+ }
+ else {
+ $RT::Logger->debug( $return ."." );
+ }
+ }
+
+ $RT::Logger->debug("done.");
+ }
+
+ if ( @ScripConditions ) {
+ $RT::Logger->debug("Creating ScripConditions...");
+
+ for my $item (@ScripConditions) {
+ my $new_entry = RT::ScripCondition->new($RT::SystemUser);
+ my ( $return, $msg ) = $new_entry->Create(%$item);
+ unless ( $return ) {
+ $RT::Logger->error( $msg );
+ }
+ else {
+ $RT::Logger->debug( $return ."." );
+ }
+ }
+
+ $RT::Logger->debug("done.");
+ }
+
+ if ( @Templates ) {
+ $RT::Logger->debug("Creating templates...");
+
+ for my $item (@Templates) {
+ my $new_entry = new RT::Template($RT::SystemUser);
+ my ( $return, $msg ) = $new_entry->Create(%$item);
+ unless ( $return ) {
+ $RT::Logger->error( $msg );
+ }
+ else {
+ $RT::Logger->debug( $return ."." );
+ }
+ }
+ $RT::Logger->debug("done.");
+ }
+ if ( @Scrips ) {
+ $RT::Logger->debug("Creating scrips...");
+
+ for my $item (@Scrips) {
+ my $new_entry = new RT::Scrip($RT::SystemUser);
+
+ my @queues = ref $item->{'Queue'} eq 'ARRAY'? @{ $item->{'Queue'} }: $item->{'Queue'} || 0;
+ push @queues, 0 unless @queues; # add global queue at least
+
+ foreach my $q ( @queues ) {
+ my ( $return, $msg ) = $new_entry->Create( %$item, Queue => $q );
+ unless ( $return ) {
+ $RT::Logger->error( $msg );
+ }
+ else {
+ $RT::Logger->debug( $return ."." );
+ }
+ }
+ }
+ $RT::Logger->debug("done.");
+ }
+ if ( @Attributes ) {
+ $RT::Logger->debug("Creating predefined searches...");
+ my $sys = RT::System->new($RT::SystemUser);
+
+ for my $item (@Attributes) {
+ my $obj = delete $item->{Object}; # XXX: make this something loadable
+ $obj ||= $sys;
+ my ( $return, $msg ) = $obj->AddAttribute (%$item);
+ unless ( $return ) {
+ $RT::Logger->error( $msg );
+ }
+ else {
+ $RT::Logger->debug( $return ."." );
+ }
+ }
+ $RT::Logger->debug("done.");
+ }
+ if ( @Final ) {
+ $RT::Logger->debug("Running final actions...");
+ for ( @Final ) {
+ local $@;
+ eval { $_->(); };
+ $RT::Logger->error( "Failed to run one of final actions: $@" )
+ if $@;
+ }
+ $RT::Logger->debug("done.");
+ }
+
+ my $db_type = RT->Config->Get('DatabaseType');
+ $RT::Handle->Disconnect() unless $db_type eq 'SQLite';
+
+ $RT::Logger->debug("Done setting up database content.");
+
+# TODO is it ok to return 1 here? If so, the previous codes in this sub
+# should return (0, $msg) if error happens instead of just warning.
+# anyway, we need to return something here to tell if everything is ok
+ return( 1, 'Done inserting data' );
+}
+
+=head2 ACLEquivGroupId
+
+Given a userid, return that user's acl equivalence group
+
+=cut
+
+sub ACLEquivGroupId {
+ my $id = shift;
+
+ my $cu = $RT::SystemUser;
+ unless ( $cu ) {
+ require RT::CurrentUser;
+ $cu = new RT::CurrentUser;
+ $cu->LoadByName('RT_System');
+ warn "Couldn't load RT_System user" unless $cu->id;
+ }
+
+ my $equiv_group = RT::Group->new( $cu );
+ $equiv_group->LoadACLEquivalenceGroup( $id );
+ return $equiv_group->Id;
+}
+
+__PACKAGE__->FinalizeDatabaseType;
+