view release on metacpan or  search on metacpan

Mercury.pm  view on Meta::CPAN

    # set up and preparation - independent of page

    $self->get_mailboxes;

    my $box = $self->{'current_box'} = $self->get_current_mailbox;

    my $need_sort;
    if ($args{$box.'_sortby'} and
	$args{$box.'_sortby'} ne ($self->{$box}->{'sortby'} .
				  ($self->{$box}->{'sortdir'}
				   ? '__'.$self->{$box}->{'sortdir'} : ''))) {
	my ($sort, $updown) = split('__', $args{$box.'_sortby'});
	$need_sort = $self->set_sortby(undef, $sort, $updown);
    } elsif (!$self->{$box}->{'sortby'}) {
	$need_sort = $self->set_sortby;
    }

    # hit database if user wants or if more than 10 minutes has past since last
    if ($q->param('check_mail') or !$self->{'last_mail_check'} or
	$controller->get_time > $self->{'last_mail_check'}+600) {
	$self->check_mail;
	$need_sort = 0; # since mail checking automtically sorts
    }

    # cannot sort until boxes are made (by checkmail)
    # but only sort if sortby was changed and mail was not checked
    $self->sort_mailbox if $need_sort;

    # actions, non-displaying

    if ($q->param('delete')) {
	$self->delete_messages;
    } elsif ($q->param('transfer')) {
	$self->transfer_messages;
    }

    # change state if we're now trying to view messages in an empty mailbox
    $self->{'state'} = 'message_center'
      if ($self->{'state'} eq 'view_messages' and
	  $#{$self->{$box}->{'index'}} < 0);

    # outputting and page creation

    if ($q->param('cancel')) {
	$self->cancel_operation;

	$self->{'state'} = 'message_center';
	$self->show_mail_center;
	$controller->sitemark('/messaging');

    } elsif ($q->param('message_center')) {

	$self->{'state'} = 'message_center';
	$self->show_mail_center;
	$controller->sitemark('/messaging');

    } elsif ($self->{'state'} eq 'edit_settings' or $args{'edit_mail_prefs'}) {

	if ($q->param('add_box')) {
	    if ($self->verify_new_mailbox($q->param('new_box'))) {
		$self->add_new_mailbox($q->param('new_box'));
		$self->checkmail;
		$q->delete('new_box');
	    }
	} elsif ($q->param('delete_box')) {
	    $self->delete_mailbox($q->param('custom_box'),
				  $q->param('delete_mail_in_box'));
	    $self->checkmail;
	    $q->delete('custom_box');
	    $q->delete('delete_mail_in_box');
	} elsif ($q->param('commit_filter')) {
	    $self->edit_filters;
	    $self->checkmail;
#	    $q->delete('trans_filter');
	} elsif ($q->param('update_auto_forward')) {
	    $self->update_auto_forward;
	    $self->checkmail;
	}
	$self->{'state'} = 'edit_settings';
	$self->show_mail_settings;
	$controller->sitemark('/messaging.settings');

    } elsif ($self->{'state'} eq 'compose_message') {

	$self->save_compose_message_fields;
	$controller->sitemark('/messaging.compose');

	$controller->infomsg("You must take action on your existing composition before creating a transaction-related message.")
	  if ($q->param('reply_trans') or $q->param('compose_trans'));

	if ($q->param('preview')) {
	    my ($fail, $recip, $recip_desc) =
	      $self->verify_recipient($self->{compose_msg}->{'sent_to'}, 1);
	    unless ($fail) {
		$self->{compose_msg}->{'sent_to'} = $recip;
		$self->{compose_msg}->{'recipient_desc'} = $recip_desc;

		$self->{'state'} = 'preview_message';
		$self->show_mail_preview;
		$controller->sitemark('/messaging.preview');
		return;
	    }
	} elsif ($q->param('return')) {
	    $controller->infomsg("Your composition has been saved in memory.  It will be removed when you log out.");
	    $self->{'state'} = 'message_center';
	    $self->show_mail_center;
	    $controller->sitemark('/messaging');
	    return;
	} elsif ($q->param('reset')) {
	    $self->reset_compose_message;
	} elsif ($q->param('change_recip')) {
	    $self->{compose_msg}->{'action'} .= "-changed_recip";
	} elsif ($q->param('memo')) {
	    $self->{compose_msg}->{'sent_to'} = $self->{user_manager}->userprofile('user');
	    $self->{compose_msg}->{'recipient_desc'} = $self->{user_manager}->userprofile('user_desc');
	} elsif ($q->param('nonmemo')) {
	    $self->{compose_msg}->{'sent_to'} = '';
	    $self->{compose_msg}->{'recipient_desc'} = '';
	} elsif (defined (my $attach_no = $q->param('remove_attach'))) {
	    splice(@{$self->{compose_msg}->{'Attachments'}}, $attach_no, 1);
	}

	$self->show_mail_compose;

    } elsif ($self->{'state'} eq 'preview_message') {

	$self->save_compose_message_fields;
	$controller->sitemark('/messaging.preview');

	$controller->infomsg("You must take action on your existing composition before creating a transaction-related message.")
	  if ($q->param('reply_trans') or $q->param('compose_trans'));

	if ($q->param('send')) {
	    $self->{'state'} = 'message_center';
	    $self->message_send;
	    $self->check_mail;
	    $self->show_mail_center;
	    $controller->sitemark('/messaging');
	} elsif ($q->param('make_changes')) {
	    $self->{'state'} = 'compose_message';
	    $self->show_mail_compose;
	    $controller->sitemark('/messaging.compose');
	} elsif ($q->param('return')) {
	    $controller->infomsg("Your composition has been saved in memory.  It will be removed when you log out.");
	    $self->{'state'} = 'message_center';
	    $self->show_mail_center;
	    $controller->sitemark('/messaging');
	} else {
	    $self->show_mail_preview;
	}

    } elsif ($q->param('compose') or $q->param('compose_trans')) {

	if (ref $self->{compose_msg} ne "Apache::App::Mercury::Message") {
	    $self->reset_compose_message;
	    $self->{compose_msg}->{'transcode'} = $q->param('transcode')
	      if $q->param('compose_trans');
	} elsif ($q->param('compose_trans')) {
	    $controller->infomsg("You must take action on your saved composition before creating a new transaction-related message.");
	}

	$self->{'state'} = 'compose_message';
	$self->show_mail_compose;
	$controller->sitemark('/messaging.compose');

    } elsif ($args{'mailto'}) {

	if (ref $self->{compose_msg} ne "Apache::App::Mercury::Message") {
	    $self->reset_compose_message;
	    my ($fail, $recip, $recip_desc) =
	      $self->verify_recipient($args{'mailto'}, 1);
	    unless ($fail) {
		$self->{compose_msg}->{'action'} = 'mailto';
		$self->{compose_msg}->{'sent_to'} = $recip;
		$self->{compose_msg}->{'recipient_desc'} = $recip_desc;
	    }
	} else {
	    $controller->infomsg("You must take action on your saved composition before creating a new message.");
	}

	$self->{'state'} = 'compose_message';
	$self->show_mail_compose;
	$controller->sitemark('/messaging.compose');

    } elsif ($self->{'state'} eq 'view_messages' or defined $args{'read'} or
	     $q->param('reply_trans') or
	     ($self->{'cur_index'} and ($q->param('read_prev') or
					$q->param('read_next')))) {

	$self->set_current_index($args{'read'});

	$self->{'state'} = 'compose_message';
	$controller->sitemark('/messaging.compose');

	if ($q->param('print')) {
	    $self->{'state'} = 'view_messages';
	    $controller->sitemark('/messaging.print');
	    $self->show_mail_print_message;
	    $self->make_read;
	} elsif ($q->param('reply') or $q->param('reply_trans')) {
	    if (ref $self->{compose_msg} ne "Apache::App::Mercury::Message") {
		$self->reset_compose_message;
		unless ($self->set_compose_reply
			($self->retrieve_message($q->param('msg_id')))) {
		    $self->show_mail_message;
		    return;
		}
	    } else {
		$controller->infomsg("You must take action on your saved composition before creating a new message reply.");
	    }
	    $self->show_mail_compose;
	} elsif ($q->param('forward')) {
	    if (ref $self->{compose_msg} ne "Apache::App::Mercury::Message") {
		$self->reset_compose_message;
		$self->set_compose_forward
		  ($self->retrieve_message($q->param('msg_id')));
	    } else {
		$controller->infomsg("You must take action on your saved composition before creating a new message forward.");
	    }
	    $self->show_mail_compose;
	} elsif ($q->param('re-send')) {
	    if (ref $self->{compose_msg} ne "Apache::App::Mercury::Message") {
		$self->reset_compose_message;
		$self->set_compose_resend
		  ($self->retrieve_message($q->param('msg_id')));
	    } else {
		$controller->infomsg("You must take action on your saved composition before creating a new message re-send.");
	    }
	    $self->show_mail_compose;
	} else {
	    $self->{'state'} = 'view_messages';

Mercury.pm  view on Meta::CPAN

    if ($box ne 'outbox' and
	$self->{$box}->{'msgs'}->{$msg}->{'status'} eq 'unread') {
	if ($self->change_status(undef, 'read', undef, $msg)) {
	    $self->check_mail;
	}
    }
}

sub retrieve_message {
    my ($self, $id) = @_;
    my $msgs = $self->{$self->{'current_box'}}->{'msgs'};

    return undef unless defined $id;

    # retrieve it from memory if its easily accessible
    return $msgs->{$id} if ref $msgs->{$id} eq "Apache::App::Mercury::Message";

    # otherwise get out of table (for transactions)
    return $self->get_messages(undef, undef, [ $id ])->{$id};
}

sub save_compose_message_fields {
    my ($self) = @_;
    my $q = $self->{q};

    $self->{compose_msg}->{'sent_to'} = $q->param('recipient')
      if defined $q->param('recipient');
    $self->{compose_msg}->{'subject'} = $q->param('subject')
      if defined $q->param('subject');
    $self->{compose_msg}->{'body'} = $q->param('body')
      if defined $q->param('body');
    $self->{compose_msg}->{'num_to_attach'} =
      $q->param('num_files_to_attach')
	if defined $q->param('num_files_to_attach');
    $self->{compose_msg}->{'security'} = $q->param('security')
      if defined $q->param('security');
}

sub reset_compose_message {
    my ($self) = @_;
    my $q = $self->{q};
    $self->{compose_msg} = Apache::App::Mercury::Message->new
      ({ 'sender' => $self->{user_manager}->userprofile('user') });
    $self->{compose_msg}->initialize($self);

    $self->{compose_msg}->{'action'} = 'new';
    $self->{compose_msg}->{'subject'} = '';
    $self->{compose_msg}->{'sent_to'} = '';
    $self->{compose_msg}->{'recipient_desc'} = '';
    $self->{compose_msg}->{'transcode'} = '';
    $self->{compose_msg}->{'body'} = '';
    delete $self->{compose_msg}->{'Attachments'};
}

sub set_compose_reply {
    my ($self, $origmsg) = @_;
    my $new = $self->{compose_msg};

    my ($fail, $recip, $recip_desc) =
      $self->verify_recipient($origmsg->{'sender'}, 1);
    return 0 if $fail;

    $new->{'action'} = 'reply';
    $new->{'subject'} = "Re: ".$origmsg->{'subject'};
    $new->{'sent_to'} = $recip;
    $new->{'recipient_desc'} = $recip_desc;
    $new->{'transcode'} = $origmsg->{'transcode'};
    $new->{'body'} = $origmsg->{'sender'}." wrote:\n\n".$origmsg->{'body'};
    $new->{'body'} =~ s/^/> /gm;
    $new->{'body'} = "\n\n\n".$new->{'body'};
    $new->{'security'} = $origmsg->{'security'};
    $new->{'security_fixed'} = 1 if $origmsg->{'security_fixed'};
    $new->{'Attachments'} = dclone $origmsg->{'Attachments'}
      if ref $origmsg->{'Attachments'} eq "ARRAY";

    return 1;
}

sub set_compose_forward {
    my ($self, $origmsg) = @_;
    my $new = $self->{compose_msg};

    $new->{'action'} = 'forward';
    $new->{'subject'} = "Fwd: ".$origmsg->{'subject'};
    $new->{'sent_to'} = '';
    $new->{'recipient_desc'} = '';
    $new->{'transcode'} = $origmsg->{'transcode'};
    $new->{'body'} = $origmsg->{'sender'}." wrote:\n\n".$origmsg->{'body'};
    $new->{'body'} =~ s/^/> /gm;
    $new->{'body'} = "\n\n\n".$new->{'body'};
    $new->{'security'} = $origmsg->{'security'};
    $new->{'security_fixed'} = 1 if $origmsg->{'security_fixed'};
    $new->{'Attachments'} = dclone $origmsg->{'Attachments'}
      if ref $origmsg->{'Attachments'} eq "ARRAY";
}

sub set_compose_resend {
    my ($self, $origmsg) = @_;
    my $new = $self->{compose_msg};

    $new->{'action'} = 're-send';
    $new->{'subject'} = "Rs: ".$origmsg->{'subject'};
    $new->{'sent_to'} = '';
    $new->{'recipient_desc'} = '';
    $new->{'transcode'} = $origmsg->{'transcode'};
    $new->{'body'} = $origmsg->{'body'};
    $new->{'security'} = $origmsg->{'security'};
    $new->{'security_fixed'} = 1 if $origmsg->{'security_fixed'};
    $new->{'Attachments'} = dclone $origmsg->{'Attachments'}
      if ref $origmsg->{'Attachments'} eq "ARRAY";
}


sub verify_recipient {
    my ($self, $recip, $show_fail_message) = @_;
    my $q = $self->{q};
    my $controller = $self->{controller};

    # remove all whitespace (user_names can't have any)
    $recip =~ s/\s//g;

    $self->warn("->verify_recipient: checking '$recip'.");
    if (!$recip) {
	$controller->infomsg("You must enter a recipient.") if $show_fail_message;
	return ('fail', undef, undef);
    } elsif ($recip eq $self->{user_manager}->userprofile('user')) {
	return (0, $self->{user_manager}->userprofile('user'),
		"(".$self->{user_manager}->userprofile('user_desc').")");
    } else {
	my @recps = split(';', $recip);
	my @chk_recip = $self->{user_manager}->get_userinfo(@recps);
	my ($usrs, $descript);
	unless (@chk_recip) {
	    $controller->infomsg("Unknown user id: " . $recip)
	      if $show_fail_message;
	    return ('fail', undef, undef);
	}
	my $dispclass = Apache::App::Mercury::Config::DISPLAY_CLASS();
	foreach (@chk_recip) {
	    $usrs .= ($usrs ? ';' : '') . $_->{'user'};
	    $descript .=
	      (($descript ? '; ' : '') .
	       ($dispclass->can("USER_INFO_HREF")
		? $dispclass->USER_INFO_HREF($_->{'user'}, $q)
		: '') .
	       " (" . $_->{'fname'}." ".$_->{'lname'} . ")");
	}
	$controller->infomsg("Not all user ids were valid.  You may wish to ".$q->em("make changes")." and try again.")
	  if ($show_fail_message and $#recps != $#chk_recip);
	return (0, $usrs, $descript);
    }
}

sub cancel_operation {
    my ($self) = @_;
    my $q = $self->{q};

    $self->{controller}->infomsg("The previous operation has been cancelled.");

    # delete appropriate data and params
    $q->delete('cancel');
    delete $self->{compose_msg};
}

sub message_send {
    my ($self) = @_;
    my $q = $self->{q};
    my $compose = $self->{compose_msg};

    my $is_memo = ($compose->{'sender'} eq $compose->{'sent_to'});

    # add to msg object new attachments from CGI POST data that browser sent
    $compose->read_attachments_from_cgi;

    # tell message object to store itself
    if ($compose->store) {
	$self->{controller}->infomsg(!$is_memo ? "Your message has been sent." : "Your memo has been committed.");
	delete $self->{compose_msg};
    } else {
	$self->{controller}->infomsg("There was an error ".(!$is_memo ? "sending your message" : "committing your memo").".  Please contact technical support.");
    }
}

sub verify_new_mailbox {
    my ($self, $new_box) = @_;
    my $controller = $self->{controller};

    # make sure there is a new_box
    if (!$new_box) {
	$controller->infomsg("You did not enter a name for your new mailbox!");
	return 0;
    }
    # make sure there are no commas
    if (($new_box) =~ (m/,/)) {
	$controller->infomsg("Sorry, your mailbox names cannot contain commas (,).  Please try again.");
	return 0;
    }
    # make sure this mailbox name doesn't already exist
    foreach (@{$self->{'mailboxes'}}) {
	if (ucfirst($_) eq ucfirst($new_box)) {
	    $controller->infomsg("You already have a mailbox with the name ".ucfirst($new_box).".  Please pick a different name.");
	    return 0;
	}
    }
    return 1;
}

sub add_new_mailbox {
    my ($self, $new_box) = @_;
    my $controller = $self->{controller};
    my $user = $self->{user_manager}->userprofile('user');

    my @old_boxes = $self->{user_manager}->mailboxes;

    if ($#old_boxes == 14) {
	$controller->infomsg("You already have 15 custom mailboxes, which is the maximum currently allowed.");
	return;
    }

    push(@old_boxes, $new_box);

    if ($self->{user_manager}->mailboxes($user, @old_boxes)) {
	$controller->infomsg("Mailbox ".ucfirst($new_box)." has been created.");
    }
}

sub delete_mailbox {
    my ($self, $old_box, $delete_mail_in_box) = @_;
    my $controller = $self->{controller};
    my $user = $self->{user_manager}->userprofile('user');

    my $num_displaced = $#{$self->{$old_box}->{'index'}} + 1;

    # get rid of filters, if necessary
    $self->remove_filters_for($old_box);

    # then move out the mail
    if ($delete_mail_in_box) {
	$self->change_status(undef, 'deleted', $old_box);
    } else {
	$self->change_box('inbox', $old_box);
    }

    my @boxes = $self->{user_manager}->mailboxes;