[rt-devel] Re: Issue with new users in RT CLI

Abhijit Menon-Sen ams at wiw.org
Wed Oct 15 17:34:42 EDT 2003


I took the plunge and munged Forms/ticket/default to fit into the scheme
described in my earlier post. I changed the logic slightly, though.

    if (!new) { Load existing object. }
    else {
        if (!changes) { Return default new form. }
        else { Create a new object. }
    }

    if (!changes) { Return object data. }
    else { Apply changes. }

The two visible changes are:

1. A temporary ticket is no longer created.
2. You can specify default text for the ticket when you're creating it,
   by filling in the Text field in the form. For example:

   id: ticket/new
   Queue: General
   Subject: my refrigerator is evil
   Priority: 666
   Text:
        My refrigerator is trying to take over the world.
        I don't know how to stop it, short of pulling the plug,
        but every time I try to do that, it charges at me.

        Help!

        -- ams

(A suitable MIMEObj will be created and added to the ticket in the same
transaction that's used to create it.)

Everything else should work as before.

I would appreciate it if somebody could try this out and let me know how
it works for them. (Just replace $RT/html/REST/1.0/Forms/ticket/default
with this and run rt show/edit etc as usual.)

-- ams
-------------- next part --------------
%# REST/1.0/Forms/ticket/default
%#
<%ARGS>
$id
$changes => {}
</%ARGS>
<%perl>
use MIME::Entity;

my @comments;
my ($c, $o, $k, $e) = ("", [], {}, 0);
my $ticket = new RT::Ticket $session{CurrentUser};
my @dates  = qw(Starts Started Due Resolved Told);
my @people = qw(Requestors Cc AdminCc);
my @create = qw(Queue Requestor Subject Cc AdminCc Owner Status Priority
                InitialPriority FinalPriority TimeEstimated TimeWorked
                TimeLeft Starts Started Due Resolved);
my @simple = qw(Subject Status Priority Disabled TimeEstimated TimeWorked
                TimeLeft InitialPriority FinalPriority);
my %dates  = map {lc $_ => $_} @dates;
my %people = map {lc $_ => $_} @people;
my %create = map {lc $_ => $_} @create;
my %simple = map {lc $_ => $_} @simple;

# Are we dealing with an existing ticket?
if ($id ne 'new') {
    $ticket->Load($id);
    if (!$ticket->Id) {
        return [ "# Ticket $id does not exist.", [], {}, 1 ];
    }
    elsif (!$ticket->CurrentUserHasRight('ShowTicket') ||
           ($changes && !$ticket->CurrentUserHasRight('ModifyTicket')))
    {
        my $act = $changes ? "modify" : "display";
        return [ "# You are not allowed to $act ticket $id.", [], {}, 1 ];
    }
}
else {
    if (%$changes == 0) {
        # GET ticket/new: Return a suitable default form.
        # We get defaults from queue/1 (XXX: What if it isn't there?).
        my $due = new RT::Date $session{CurrentUser};
        my $queue = new RT::Queue $session{CurrentUser};
        my $starts = new RT::Date $session{CurrentUser};
        $queue->Load(1);
        $due->SetToNow;
        $due->AddDays($queue->DefaultDueIn) if $queue->DefaultDueIn;
        $starts->SetToNow;

        return [
            "# Required: Queue, Requestor, Subject",
            [ qw(id Queue Requestor Subject Cc AdminCc Owner Status Priority
                 InitialPriority FinalPriority TimeEstimated Starts Due Text) ],
            {
                id               => "ticket/new",
                Queue            => $queue->Name,
                Requestor        => $session{CurrentUser}->Name,
                Subject          => "",
                Cc               => [],
                AdminCc          => [],
                Owner            => "",
                Status           => "new",
                Priority         => $queue->InitialPriority,
                InitialPriority  => $queue->InitialPriority,
                FinalPriority    => $queue->FinalPriority,
                TimeEstimated    => 0,
                Starts           => $starts->ISO,
                Due              => $due->ISO,
                Text             => "",
            },
            0
        ];
    }
    else {
        # We'll create a new ticket, and fall through to set fields that
        # can't be set in the call to Create().
        my (%v, $text);

        foreach my $k (keys %$changes) {
            if (exists $create{lc $k}) {
                $v{$create{lc $k}} = delete $changes->{$k};
            }
            elsif (lc $k eq 'text') {
                $text = delete $changes->{$k};
            }
        }

        if ($text) {
            $v{MIMEObj} =
                MIME::Entity->build(
                    From => $session{CurrentUser}->EmailAddress,
                    Subject => $v{Subject},
                    Data => $text
                );
        }

        $ticket->Create(%v);
        if (!$ticket->Id) {
            # XXX: Could we have better diagnostics here?
            $e = 1;
            push(@comments, "# Could not create ticket.");
            goto DONE;
        }

        delete $changes->{id};
        if (%$changes == 0) {
            $id = $ticket->Id;
            push(@comments, "# Ticket $id created.");
            goto DONE;
        }
    }
}

# Now we know we're dealing with an existing ticket.
if (%$changes == 0) {
    my ($time, $key, $val, @data);

    push @data, [ id    => "ticket/".$ticket->Id   ];
    push @data, [ Queue => $ticket->QueueObj->Name ];
    push @data, [ Owner => $ticket->OwnerObj->Name ];

    foreach (qw(Subject Status Priority InitialPriority FinalPriority)) {
        push @data, [$_ => $ticket->$_ ];
    }

    foreach $key (@people) {
        push @data, [ $key => [ $ticket->$key->MemberEmailAddresses ] ];
    }

    $time = new RT::Date ($session{CurrentUser});
    foreach $key (@dates) {
        $time->Set(Format => 'sql', Value => $ticket->$key);
        push @data, [ $key => $time->AsString ];
    }

    $time = new RT::Date ($session{CurrentUser});
    foreach $key (qw(TimeEstimated TimeWorked TimeLeft)) {
        $val = $ticket->$key || 0;
        $val = $time->DurationAsString($val*60) if $val;
        push @data, [ $key => $val ];
    }

    my %k = map {@$_} @data;
    $o = [ map {$_->[0]} @data ];
    $k = \%k;
}
else {
    my ($get, $set, $key, $val, $n, $s);
    my %data = %$changes;

    foreach $key (keys %data) {
        $val = $data{$key};
        $key = lc $key;
        $n = 1;

        if (ref $val eq 'ARRAY') {
            unless ($key =~ /^(?:Requestors|Cc|AdminCc)$/i) {
                $n = 0;
                $s = "$key may have only one value.";
                goto SET;
            }
        }

        if ($key =~ /^queue$/i) {
            next if $val eq $ticket->QueueObj->Name;
            ($n, $s) = $ticket->SetQueue($val);
        }
        elsif ($key =~ /^owner$/i) {
            next if $val eq $ticket->OwnerObj->Name;
            ($n, $s) = $ticket->SetOwner($val);
        }
        elsif (exists $simple{$key}) {
            $key = $simple{$key};
            $set = "Set$key";

            next if $val eq $ticket->$key;
            ($n, $s) = $ticket->$set($val);
        }
        elsif (exists $dates{$key}) {
            $key = $dates{$key};
            $set = "Set$key";

            my $time = new RT::Date $session{CurrentUser};
            $time->Set(Format => 'sql', Value => $ticket->$key);
            next if ($val =~ /^not set$/i || $val eq $time->AsString);
            ($n, $s) = $ticket->$set($val);
        }
        elsif (exists $people{$key}) {
            $key = $people{$key};
            my ($p, @msgs);

            my %new  = map {$_=>1} @{ vsplit($val) };
            my %old  = map {$_=>1} $ticket->$key->MemberEmailAddresses;
            my $type = $key eq 'Requestors' ? 'Requestor' : $key;

            foreach $p (keys %old) {
                unless (exists $new{$p}) {
                    ($s, $n) = $ticket->DeleteWatcher(Type => $type,
                                                      Email => $p);
                    push @msgs, [ $s, $n ];
                }
            }
            foreach $p (keys %new) {
                # XXX: This is a stupid test.
                unless ($p =~ /^[\w.+-]+\@([\w.-]+\.)*\w+.?$/) {
                    $s = 0;
                    $n = "$p is not a valid email address.";
                    push @msgs, [ $s, $n ];
                    next;
                }
                unless ($ticket->IsWatcher(Type => $type, Email => $p)) {
                    ($s, $n) = $ticket->AddWatcher(Type => $type,
                                                   Email => $p);
                    push @msgs, [ $s, $n ];
                }
            }

            $n = 1;
            if (@msgs = grep {$_->[0] == 0} @msgs) {
                $n = 0;
                $s = join "\n", map {"# ".$_->[1]} @msgs;
                $s =~ s/^# //;
            }
        }
        elsif ($key ne 'id' && $key ne 'type') {
            $n = 0;
            $s = "Unknown field.";
        }

    SET:
        if ($n == 0) {
            $e = 1;
            push @comments, "# $key: $s";
            unless (@$o) {
                @$o = ("id", keys %data);
                %$k = %data;
            }
        }
    }
    push(@comments, "# Ticket $id updated.") unless @comments;
}

DONE:
$c = join("\n", @comments) if @comments;
return [$c, $o, $k, $e];

</%perl>


More information about the Rt-devel mailing list