# Initial data for a fresh RT3 Installation.

@Users = (
    {  Name         => 'root',
       Gecos        => 'root',
       RealName     => 'Enoch Root',
       Password     => 'password',
       EmailAddress => "root\@localhost",
       Comments     => 'SuperUser',
       Privileged   => '1',
    },
);

@Groups = (
);

@Queues = ({ Name              => 'General',
             Description       => 'The default queue',
             CorrespondAddress => "",
             CommentAddress    => "", },
           { Name        => '___Approvals',
             Description => 'A system-internal queue for the approvals system',
             Disabled    => 2, } );

@ScripActions = (

    {  Name        => 'Autoreply To Requestors',    # loc
       Description =>
'Always sends a message to the requestors independent of message sender' ,                                            # loc
       ExecModule => 'Autoreply',
       Argument   => 'Requestor' },
    { Name        => 'Notify Requestors',                    # loc
      Description => 'Sends a message to the requestors',    # loc
      ExecModule  => 'Notify',
      Argument    => 'Requestor' },
    { Name        => 'Notify Owner as Comment',              # loc
      Description => 'Sends mail to the owner',              # loc
      ExecModule  => 'NotifyAsComment',
      Argument    => 'Owner' },
    { Name        => 'Notify Owner',                         # loc
      Description => 'Sends mail to the owner',              # loc
      ExecModule  => 'Notify',
      Argument    => 'Owner' },
    { Name        => 'Notify Ccs as Comment',              # loc
      Description => 'Sends mail to the Ccs as a comment', # loc
      ExecModule  => 'NotifyAsComment',
      Argument    => 'Cc' },
    { Name        => 'Notify Ccs',                                   # loc
      Description => 'Sends mail to the Ccs',                        # loc
      ExecModule  => 'Notify',
      Argument    => 'Cc' },
    { Name        => 'Notify AdminCcs as Comment',                        # loc
      Description => 'Sends mail to the administrative Ccs as a comment', # loc
      ExecModule  => 'NotifyAsComment',
      Argument    => 'AdminCc' },
    { Name        => 'Notify AdminCcs',                                   # loc
      Description => 'Sends mail to the administrative Ccs',              # loc
      ExecModule  => 'Notify',
      Argument    => 'AdminCc' },

    { Name        => 'Notify Requestors and Ccs as Comment',              # loc
      Description => 'Send mail to requestors and Ccs as a comment',      # loc
      ExecModule  => 'NotifyAsComment',
      Argument    => 'Requestor,Cc' },

    { Name        => 'Notify Requestors and Ccs',                         # loc
      Description => 'Send mail to requestors and Ccs',                   # loc
      ExecModule  => 'Notify',
      Argument    => 'Requestor,Cc' },

    { Name        => 'Notify Requestors, Ccs and AdminCcs as Comment',    # loc
      Description => 'Send mail to all watchers as a "comment"',          # loc
      ExecModule  => 'NotifyAsComment',
      Argument    => 'All' },
    { Name        => 'Notify Requestors, Ccs and AdminCcs',               # loc
      Description => 'Send mail to all watchers',                         # loc
      ExecModule  => 'Notify',
      Argument    => 'All' },
    { Name        => 'Notify Other Recipients as Comment',                # loc
      Description => 'Sends mail to explicitly listed Ccs and Bccs',      # loc
      ExecModule  => 'NotifyAsComment',
      Argument    => 'OtherRecipients' },
    { Name        => 'Notify Other Recipients',                           # loc
      Description => 'Sends mail to explicitly listed Ccs and Bccs',      # loc
      ExecModule  => 'Notify',
      Argument    => 'OtherRecipients' },
    { Name        => 'User Defined',                                      # loc
      Description => 'Perform a user-defined action',                     # loc
      ExecModule  => 'UserDefined', },
    {  Name        => 'Create Tickets',                                    # loc
       Description =>
         'Create new tickets based on this scrip\'s template',             # loc
       ExecModule => 'CreateTickets', },
    { Name        => 'Open Tickets',                                      # loc
      Description => 'Open tickets on correspondence',                    # loc
      ExecModule  => 'AutoOpen' },
    { Name        => 'Extract Subject Tag',                               # loc
      Description => 'Extract tags from a Transaction\'s subject and add them to the Ticket\'s subject.', # loc
      ExecModule  => 'ExtractSubjectTag' },
);

@ScripConditions = (
    { Name                 => 'On Create',                                # loc
      Description          => 'When a ticket is created',                 # loc
      ApplicableTransTypes => 'Create',
      ExecModule           => 'AnyTransaction', },

    { Name                 => 'On Transaction',                           # loc
      Description          => 'When anything happens',                    # loc
      ApplicableTransTypes => 'Any',
      ExecModule           => 'AnyTransaction', },
    {

      Name                 => 'On Correspond',                             # loc
      Description          => 'Whenever correspondence comes in',          # loc
      ApplicableTransTypes => 'Correspond',
      ExecModule           => 'AnyTransaction', },

    {

      Name                 => 'On Comment',                                # loc
      Description          => 'Whenever comments come in',                 # loc
      ApplicableTransTypes => 'Comment',
      ExecModule           => 'AnyTransaction' },
    {

      Name                 => 'On Status Change',                          # loc
      Description          => 'Whenever a ticket\'s status changes',       # loc
      ApplicableTransTypes => 'Status',
      ExecModule           => 'AnyTransaction',

    },
    {

      Name                 => 'On Priority Change',                       # loc
      Description          => 'Whenever a ticket\'s priority changes',    # loc
      ApplicableTransTypes => 'Set',
      ExecModule           => 'PriorityChange',
    },
    {

      Name                 => 'On Owner Change',                           # loc
      Description          => 'Whenever a ticket\'s owner changes',        # loc
      ApplicableTransTypes => 'Any',
      ExecModule           => 'OwnerChange',

    },
    {

      Name                 => 'On Queue Change',                           # loc
      Description          => 'Whenever a ticket\'s queue changes',        # loc
      ApplicableTransTypes => 'Set',
      ExecModule           => 'QueueChange',

    },
    {  Name                 => 'On Resolve',                               # loc
       Description          => 'Whenever a ticket is resolved',            # loc
       ApplicableTransTypes => 'Status',
       ExecModule           => 'StatusChange',
       Argument             => 'resolved'

    },

    {  Name                 => 'User Defined',                             # loc
       Description          => 'Whenever a user-defined condition occurs', # loc
       ApplicableTransTypes => 'Any',
       ExecModule           => 'UserDefined'

    },

    {  Name                 => 'On Close',                                 # loc
       Description          => 'Whenever a ticket is closed', # loc
       ApplicableTransTypes => 'Status,Set',
       ExecModule           => 'CloseTicket',
    },
    {  Name                 => 'On Reopen',                                # loc
       Description          => 'Whenever a ticket is reopened', # loc
       ApplicableTransTypes => 'Status,Set',
       ExecModule           => 'ReopenTicket',
    },

);

@Templates = (
    { Queue       => '0',
      Name        => 'Blank',                                             # loc
      Description => 'A blank template',                                  # loc
      Content     => '', },
    {  Queue       => '0',
       Name        => 'Autoreply',                                         # loc
       Description => 'Default Autoresponse template',                     # loc
       Content     => 'Subject: AutoReply: {$Ticket->Subject}


Greetings,

This message has been automatically generated in response to the
creation of a trouble ticket regarding:
	"{$Ticket->Subject()}", 
a summary of which appears below.

There is no need to reply to this message right now.  Your ticket has been
assigned an ID of [{$Ticket->QueueObj->SubjectTag || $rtname} #{$Ticket->id()}].

Please include the string:

         [{$Ticket->QueueObj->SubjectTag || $rtname} #{$Ticket->id}]

in the subject line of all future correspondence about this issue. To do so, 
you may reply to this message.

                        Thank you,
                        {$Ticket->QueueObj->CorrespondAddress()}

-------------------------------------------------------------------------
{$Transaction->Content()}
'
    },

    {  Queue       => '0',
       Name        => 'Transaction',                     # loc
       Description => 'Default transaction template',    # loc
       Content     => 'RT-Attach-Message: yes


{$Transaction->CreatedAsString}: Request {$Ticket->id} was acted upon.
Transaction: {$Transaction->Description}
       Queue: {$Ticket->QueueObj->Name}
     Subject: {$Transaction->Subject || $Ticket->Subject || "(No subject given)"}
       Owner: {$Ticket->OwnerObj->Name}
  Requestors: {$Ticket->RequestorAddresses}
      Status: {$Ticket->Status}
 Ticket <URL: {RT->Config->Get(\'WebURL\')}Ticket/Display.html?id={$Ticket->id} >


{$Transaction->Content()}
'
    },

    {

      Queue       => '0',
      Name        => 'Admin Correspondence',                     # loc
      Description => 'Default admin correspondence template',    # loc
      Content     => 'RT-Attach-Message: yes


<URL: {RT->Config->Get(\'WebURL\')}Ticket/Display.html?id={$Ticket->id} >

{$Transaction->Content()}
'
    },

    {  Queue       => '0',
       Name        => 'Correspondence',                          # loc
       Description => 'Default correspondence template',         # loc
       Content     => 'RT-Attach-Message: yes

{$Transaction->Content()}
'
    },

    {  Queue       => '0',
       Name        => 'Admin Comment',                           # loc
       Description => 'Default admin comment template',          # loc
       Content     =>
'Subject: [Comment] {my $s=($Transaction->Subject||$Ticket->Subject); $s =~ s/\\[Comment\\]//g; $s =~ s/^Re//i; $s;}


{RT->Config->Get(\'WebURL\')}Ticket/Display.html?id={$Ticket->id}
This is a comment.  It is not sent to the Requestor(s):

{$Transaction->Content()}
'
    },

    {  Queue       => '0',
       Name        => 'Status Change',                                     # loc
       Description => 'Ticket status changed',                             # loc
       Content     => 'Subject: Status Changed to: {$Transaction->NewValue}


{RT->Config->Get(\'WebURL\')}Ticket/Display.html?id={$Ticket->id}

{$Transaction->Content()}
'
    },

    {

      Queue       => '0',
      Name        => 'Resolved',                 # loc
      Description => 'Ticket Resolved',          # loc
      Content     => 'Subject: Resolved: {$Ticket->Subject}

According to our records, your request has been resolved. If you have any
further questions or concerns, please respond to this message.
'
    },
    {  Queue       => '___Approvals',
       Name        => "New Pending Approval",    # loc
       Description =>
         "Notify Owners and AdminCcs of new items pending their approval", # loc
       Content => 'Subject: New Pending Approval: {$Ticket->Subject}

Greetings,

There is a new item pending your approval: "{$Ticket->Subject()}", 
a summary of which appears below.

Please visit {RT->Config->Get(\'WebURL\')}Approvals/Display.html?id={$Ticket->id}
to approve or reject this ticket, or {RT->Config->Get(\'WebURL\')}Approvals/ to
batch-process all your pending approvals.

-------------------------------------------------------------------------
{$Transaction->Content()}
'
    },
    {  Queue       => '___Approvals',
       Name        => "Approval Passed",    # loc
       Description =>
         "Notify Owner of their ticket has been approved by some approver", # loc
       Content => 'Subject: Ticket Approved: {$Ticket->Subject}

Greetings,

Your ticket has been approved by { eval { $Approval->OwnerObj->Name } }.
Other approvals may be pending.
'
    },
    {  Queue       => '___Approvals',
       Name        => "All Approvals Passed",    # loc
       Description =>
         "Notify Owner of their ticket has been approved by all approvers", # loc
       Content => 'Subject: Ticket Approved: {$Ticket->Subject}

Greetings,

Your ticket has been approved.  Its Owner may now start to act on it.
'
    },
    {  Queue       => '___Approvals',
       Name        => "Approval Rejected",    # loc
       Description =>
         "Notify Owner of their rejected ticket", # loc
       Content => 'Subject: Ticket Rejected: {$Ticket->Subject}

Greetings,

Your ticket has been rejected by { eval { $Approval->OwnerObj->Name } }.
'
    },
    {  Queue       => 0,
       Name        => "Forward",    # loc
       Description => "Heading of a forwarded message", # loc
       Content => q{

This is forward of transaction #{ $Transaction->id } of a ticket #{ $Ticket->id }
}
    },
    {  Queue       => 0,
       Name        => "Error: public key",    # loc
       Description =>
         "Inform user that he has problems with public key and couldn't recieve encrypted content", # loc
       Content => q{Subject: We have no your public key or it's wrong

You received this message as we have no your public PGP key or we have a problem with your key. Inform the administrator about the problem.
}
    },
    {  Queue       => 0,
       Name        => "Error to RT owner: public key",    # loc
       Description =>
         "Inform RT owner that user(s) have problems with public keys", # loc
       Content => q{Subject: Some users have problems with public keys

You received this message as RT has problems with public keys of the following user:
{
    foreach my $e ( @BadRecipients ) {
        $OUT .= "* ". $e->{'Message'} ."\n";
    }
}}
    },
    {  Queue       => 0,
       Name        => "Error: no private key",    # loc
       Description =>
         "Inform user that we received an encrypted email and we have no private keys to decrypt", # loc
       Content => q{Subject: we received message we cannot decrypt

You sent an encrypted message with subject '{ $Message->head->get('Subject') }',
but we have no private key it's encrypted to.

Please, check that you encrypt messages with correct keys
or contact the system administrator.}
    },
    {  Queue       => 0,
       Name        => "Error: bad GnuPG data",    # loc
       Description =>
         "Inform user that a message he sent has invalid GnuPG data", # loc
       Content => q{Subject: We received a message we cannot handle

You sent us a message that we cannot handle due to corrupted GnuPG signature or encrypted block. we get the following error(s):
{ foreach my $msg ( @Messages ) {
    $OUT .= "* $msg\n";
  }
}}
    },
    {  Queue       => 0,
       Name        => "PasswordChange",    # loc
       Description =>
         "Inform user that his password has been reset", # loc
       Content => q{Subject: [{RT->Config->Get('rtname')}] Password reset

Greetings,

Someone at {$ENV{'REMOTE_ADDR'}} requested a password reset for you on {RT->Config->Get('WebURL')}

Your new password is:
  {$NewPassword}
}
    },

	       {   Queue       => '0',
		   Name        => 'Email Digest',    # loc
		   Description => 'Email template for periodic notification digests',  # loc
		   Content => q[Subject: RT Email Digest

{ $Argument }
],
               },

{
    Queue       => 0,
    Name        => "Error: Missing dashboard",    # loc
    Description =>
      "Inform user that a dashboard he subscribed to is missing", # loc
    Content => q{Subject: [{RT->Config->Get('rtname')}] Missing dashboard!

Greetings,

You are subscribed to a dashboard that is currently missing. Most likely, the dashboard was deleted.

RT will remove this subscription as it is no longer useful. Here's the information RT had about your subscription:

DashboardID:  { $SubscriptionObj->SubValue('DashboardId') }
Frequency:    { $SubscriptionObj->SubValue('Frequency') }
Hour:         { $SubscriptionObj->SubValue('Hour') }
{
    $SubscriptionObj->SubValue('Frequency') eq 'weekly'
    ? "Day of week:  " . $SubscriptionObj->SubValue('Dow')
    : $SubscriptionObj->SubValue('Frequency') eq 'monthly'
      ? "Day of month: " . $SubscriptionObj->SubValue('Dom')
      : ''
}
}
},
);
# }}}

@Scrips = (
    {  Description    => 'On Correspond Open Tickets',
       ScripCondition => 'On Correspond',
       ScripAction    => 'Open Tickets',
       Template       => 'Blank' },
    {  Description    => 'On Owner Change Notify Owner',
       ScripCondition => 'On Owner Change',
       ScripAction    => 'Notify Owner',
       Template       => 'Transaction' },
    {  Description    => 'On Create Autoreply To Requestors',
       ScripCondition => 'On Create',
       ScripAction    => 'AutoReply To Requestors',
       Template       => 'AutoReply' },
    {  Description    => 'On Create Notify AdminCcs',
       ScripCondition => 'On Create',
       ScripAction    => 'Notify AdminCcs',
       Template       => 'Transaction' },
    {  Description    => 'On Correspond Notify AdminCcs',
       ScripCondition => 'On Correspond',
       ScripAction    => 'Notify AdminCcs',
       Template       => 'Admin Correspondence' },
    {  Description    => 'On Correspond Notify Requestors and Ccs',
       ScripCondition => 'On Correspond',
       ScripAction    => 'Notify Requestors And Ccs',
       Template       => 'Correspondence' },
    {  Description    => 'On Correspond Notify Other Recipients',
       ScripCondition => 'On Correspond',
       ScripAction    => 'Notify Other Recipients',
       Template       => 'Correspondence' },
    {  Description    => 'On Comment Notify AdminCcs as Comment',
       ScripCondition => 'On Comment',
       ScripAction    => 'Notify AdminCcs As Comment',
       Template       => 'Admin Comment' },
    {  Description    => 'On Comment Notify Other Recipients as Comment',
       ScripCondition => 'On Comment',
       ScripAction    => 'Notify Other Recipients As Comment',
       Template       => 'Correspondence' },
    {  Description    => 'On Resolve Notify Requestors',
       ScripCondition => 'On Resolve',
       ScripAction    => 'Notify Requestors',
       Template       => 'Resolved' },
    {  Description    => "On transaction, add any tags in the transaction's subject to the ticket's subject",
       ScripCondition => 'On Transaction',
       ScripAction    => 'Extract Subject Tag',
       Template       => 'Blank' },
    {  Description => "When an approval ticket is created, notify the Owner and AdminCc of the item awaiting their approval",    # loc
       Queue          => '___Approvals',
       ScripCondition => 'User Defined',
       CustomIsApplicableCode => q[
	    $self->TicketObj->Type eq 'approval'	and
	    $self->TransactionObj->Field eq 'Status'	and
	    $self->TransactionObj->NewValue eq 'open'   and
	    eval { $T::Approving = ($self->TicketObj->AllDependedOnBy( Type => 'ticket' ))[0] }
       ],
       ScripAction    => 'Notify Owner',
       Template       => 'New Pending Approval' },
    {  Description => "If an approval is rejected, reject the original and delete pending approvals",    # loc
       Queue            => '___Approvals',
       ScripCondition   => 'On Status Change',
       ScripAction      => 'User Defined',
       CustomPrepareCode => q[
# ------------------------------------------------------------------- #
return(0) unless ( lc($self->TransactionObj->NewValue) eq "rejected" or
	           lc($self->TransactionObj->NewValue) eq "deleted" );

my $rejected = 0;
my $links = $self->TicketObj->DependedOnBy;
foreach my $link (@{ $links->ItemsArrayRef }) {
    my $obj = $link->BaseObj;
    if ($obj->QueueObj->IsActiveStatus($obj->Status)) {
	if ($obj->Type eq 'ticket') {
	    $obj->Comment(
		Content	=> $self->loc("Your request was rejected."),
	    );
	    $obj->SetStatus(
		Status	=> 'rejected',
		Force	=> 1,
	    );

	    $T::Approval = $self->TicketObj; # so we can access it inside templates
	    $self->{TicketObj} = $obj;  # we want the original id in the token line
	    $rejected = 1;
	}
	else {
	    $obj->SetStatus(
		Status	=> 'deleted',
		Force	=> 1,
	    );
	}
    }
}

$links = $self->TicketObj->DependsOn;
foreach my $link (@{ $links->ItemsArrayRef }) {
    my $obj = $link->TargetObj;
    if ($obj->QueueObj->IsActiveStatus($obj->Status)) {
	$obj->SetStatus(
	    Status	=> 'deleted',
	    Force	=> 1,
	);
    }
}

# Now magically turn myself into a Requestor Notify object...
require RT::Action::Notify; bless($self, 'RT::Action::Notify');
$self->{Argument} = 'Requestor'; $self->Prepare;

return $rejected;
# ------------------------------------------------------------------- #
	],
       CustomCommitCode => '"never needed"',
       Template          => 'Approval Rejected', },
    {  Description => "When a ticket has been approved by any approver, add correspondence to the original ticket", # loc
       Queue             => '___Approvals',
       ScripCondition    => 'On Resolve',
       ScripAction       => 'User Defined',
       CustomPrepareCode => q[
# ------------------------------------------------------------------- #
return(0) unless ($self->TicketObj->Type eq 'approval');

my $note;
my $t = $self->TicketObj->Transactions;
while (my $o = $t->Next) {
    $note .= $o->Content . "\n" if $o->ContentObj
	    and $o->Content !~ /Default Approval/;
}

foreach my $obj ($self->TicketObj->AllDependedOnBy( Type => 'ticket' )) {
    $obj->Comment(
	Content => $self->loc( "Your request has been approved by [_1]. Other approvals may still be pending.", # loc
	    $self->TransactionObj->CreatorObj->Name,
	) . "\n" . $self->loc( "Approver's notes: [_1]", # loc
	    $note
	),
    );
    $T::Approval = $self->TicketObj; # so we can access it inside templates
    $self->{TicketObj} = $obj;  # we want the original id in the token line
}

# Now magically turn myself into a Requestor Notify object...
require RT::Action::Notify; bless($self, 'RT::Action::Notify');
$self->{Argument} = 'Requestor'; $self->Prepare;

return 1;
# ------------------------------------------------------------------- #
	],
       CustomCommitCode => '"never needed"',
       Template => 'Approval Passed' },
    {  Description => "When a ticket has been approved by all approvers, add correspondence to the original ticket", # loc
       Queue             => '___Approvals',
       ScripCondition    => 'On Resolve',
       ScripAction       => 'User Defined',
       CustomPrepareCode  => q[
# ------------------------------------------------------------------- #
# Find all the tickets that depend on this (that this is approving)

my $Ticket = $self->TicketObj;
my @TOP    = $Ticket->AllDependedOnBy( Type => 'ticket' );
my $links  = $Ticket->DependedOnBy;
my $passed = 0;

while (my $link = $links->Next) {
    my $obj = $link->BaseObj;
    next if ($obj->HasUnresolvedDependencies( Type => 'approval' ));

    if ($obj->Type eq 'ticket') {
	$obj->Comment(
	    Content	=> $self->loc("Your request has been approved."),
	);
	$T::Approval  = $Ticket;    # so we can access it inside templates
	$self->{TicketObj} = $obj;  # we want the original id in the token line
	$passed = 1;
    }
    elsif ($obj->Type eq 'approval') {
	$obj->SetStatus( Status => 'open', Force => 1 );
    }
    elsif (RT->Config->Get('UseCodeTickets') and $obj->Type eq 'code') {
        #XXX: RT->Config->Get('UseCodeTickets') used only once here!!!
	my $code = $obj->Transactions->First->Content;
	my $rv;

	foreach my $TOP (@TOP) {
	    local $@;
	    $rv++ if eval $code;
	    $RT::Logger->error("Cannot eval code: $@") if $@;
	}

	if ($rv or !@TOP) {
	    $obj->SetStatus( Status	=> 'resolved', Force	=> 1,);
	}
	else {
	    $obj->SetStatus( Status	=> 'rejected', Force	=> 1,);
	}
    }
}

# Now magically turn myself into a Requestor Notify object...
require RT::Action::Notify; bless($self, 'RT::Action::Notify');
$self->{Argument} = 'Requestor'; $self->Prepare;

return 0; # ignore $passed;
# ------------------------------------------------------------------- #
	],
       CustomCommitCode => '"never needed"',
       Template => 'All Approvals Passed', },

);

@ACL = (
    { UserId => 'root',        # - principalid
      Right  => 'SuperUser', },

);

# Predefined searches

@Attributes = (
    { Name => 'Search - My Tickets',
      Description => '[_1] highest priority tickets I own', # loc
      Content     =>
      { Format =>  q{'<a href="__WebPath__/Ticket/Display.html?id=__id__">__id__</a>/TITLE:#',}
                 . q{'<a href="__WebPath__/Ticket/Display.html?id=__id__">__Subject__</a>/TITLE:Subject',}
                 . q{Priority, QueueName, ExtendedStatus},
        Query   => " Owner = '__CurrentUser__' AND ( Status = 'new' OR Status = 'open')",
        OrderBy => 'Priority',
        Order   => 'DESC'
      },
    },
    { Name => 'Search - Unowned Tickets',
      Description => '[_1] newest unowned tickets', # loc
      Content     =>
# 'Take' #loc
      { Format =>  q{'<a href="__WebPath__/Ticket/Display.html?id=__id__">__id__</a>/TITLE:#',}
                 . q{'<a href="__WebPath__/Ticket/Display.html?id=__id__">__Subject__</a>/TITLE:Subject',}
                 . q{QueueName, ExtendedStatus, CreatedRelative, }
                 . q{'<A HREF="__WebPath__/Ticket/Display.html?Action=Take&id=__id__">__loc(Take)__</a>/TITLE:NBSP'},
        Query   => " Owner = 'Nobody' AND ( Status = 'new' OR Status = 'open')",
        OrderBy => 'Created',
        Order   => 'DESC'
      },
    },
    { Name => 'Search - Bookmarked Tickets',
      Description => 'Bookmarked Tickets', #loc
      Content     =>
      { Format => q{'<a href="__WebPath__/Ticket/Display.html?id=__id__">__id__</a>/TITLE:#',}
                . q{'<a href="__WebPath__/Ticket/Display.html?id=__id__">__Subject__</a>/TITLE:Subject',}
                . q{Priority, QueueName, ExtendedStatus, Bookmark},
        Query   => "__Bookmarks__",
        OrderBy => 'LastUpdated',
        Order   => 'DESC' },
    },
    { Name => 'HomepageSettings',
      Description => 'HomepageSettings',
      Content =>
      { 'body' => # loc
	[ { type => 'system', name => 'My Tickets' },
	  { type => 'system', name => 'Unowned Tickets' },
	  { type => 'system', name => 'Bookmarked Tickets' },
	  { type => 'component',  name => 'QuickCreate'},
	],
        'summary' => # loc
	[ 
	  { type => 'component', name => 'MyReminders' },
          { type => 'component', name => 'Quicksearch' },
	  { type => 'component', name => 'Dashboards' },
	  { type => 'component', name => 'RefreshHomepage' },
	]
    },
}
);