notice-sender/trunk/sender.pl

#!/usr/bin/perl -w

use strict;
use blib;
use Nos;
use Getopt::Long;

=head1 NAME

sender.pl - command line notify sender utility

=head1 SYNOPSYS

 sender.pl --add=mylist members.txt
 sender.pl --list[=mylist]
 sender.pl --queue[=mylist message.txt]
 sender.pl --send=mylist

In C</etc/aliases> something like:

 mylist: "| /path/to/sender.pl --inbox=mylist"

=head2 Command options

=over 20

=cut

my $debug = 0;
my $verbose = 0;
my $list_opt;
my $add_opt;
my $queue_opt;
my $send_opt;
my $email_opt;
my $inbox_opt;

my $result = GetOptions(
        "list:s" => \$list_opt,
        "add=s" => \$add_opt,
        "queue:s" => \$queue_opt,
        "send:s" => \$send_opt,
        "inbox=s" => \$inbox_opt,
        "debug" => \$debug,
        "verbose" => \$verbose,
        "email=s" => \$email_opt,
);

my $nos = new Nos(
        dsn => 'dbi:Pg:dbname=notices',
        user => 'dpavlin',
        passwd => '',
        debug => $debug,
        verbose => $verbose,
);

my $loader = $nos->{'loader'} || die "can't find loader?";

my $lists = $loader->find_class('lists');
my $users = $loader->find_class('users');
my $user_list = $loader->find_class('user_list');
my $messages = $loader->find_class('messages');
my $queue = $loader->find_class('queue');
my $sent = $loader->find_class('sent');

$queue->set_sql( list_queue => qq{
        SELECT messages.message, messages.date AS date, lists.name AS list
        FROM queue
        JOIN messages on message_id = messages.id
        JOIN lists on list_id = lists.id
} );


=item --list[=list_name]

List all available lists and users on them.

Optional value is name of list. With it, this option will produce just users
on that list.

=cut

if (defined($list_opt)) {
        my @lists;
        if ($list_opt ne '') {
                @lists = $lists->search( name=> $list_opt )->first || die "can't find list $list_opt";
        } else {
                @lists = $lists->retrieve_all;
        }

        foreach my $list (@lists) {
                print $list->name," <",$list->email,">\n";
                foreach my $user_on_list ($user_list->search(list_id => $list->id)) {
                        my $user = $users->retrieve( id => $user_on_list->user_id );
                        print "\t",$user->full_name," <", $user->email, ">\n";
                }
        }

=item --add=list_name

Add users to list. Users are stored in file (which can be supplied as
argument) or read from C<STDIN>. List should be in following format:

 email@example.com      Optional full name of person
 dpavlin@rot13.org      Dobrica Pavlinusic

You may use C<--email> parametar at any time to set From: e-mail address for list.
B<This seems somewhat cludgy, and it will probably change in future>.

=cut

} elsif ($add_opt) {
        my $list = $lists->find_or_create({
                name => $add_opt,
        }) || die "can't add list $add_opt\n";

        if ($email_opt && $list->email ne $email_opt) {
                $list->email($email_opt);
                $list->update;
                $list->dbi_commit;
        }

        my $added = 0;

        while(<>) {
                chomp;
                next if (/^#/ || /^\s*$/);
                my ($email, $name) = split(/\s+/,$_, 2);
                $added++ if ($nos->add_member_to_list( email => $email, name => $name, list => $add_opt ));
        }

        print "list ",$list->name," has $added users\n";

=item --queue[=list_name]

Queue message for later delivery. Message can be read from file (specified as
argument) or read from C<STDIN>.

This option without optional parametar will display pending queue. If you
add C<--verbose> flag, it will display all messages in queue.

=cut

} elsif (defined($queue_opt)) {

        if ($queue_opt ne '') {
                # add message to list queue

                my $message_text;
                while(<>) {
                        $message_text .= $_;
                }

                my $id = $nos->add_message_to_list(
                        list => $queue_opt,
                        message => $message_text,
                );

                print "added message $id to list $queue_opt\n";

        } else {
                # list messages in queue        

                foreach my $m ($queue->retrieve_all) {
                        next if ($m->all_sent && ! $verbose);

                        my $l = $m->all_sent ? 'S' : 'Q';

                        my $date = $m->message_id->date;
                        $date =~ s/\..+$//;
                        my $msg = $m->message_id->message;
                        $msg =~ s/\s+/ /gs;

                        $l .= sprintf(" %-10s %15s : ", $m->list_id->name, $date);
                        $l .= substr($msg, 0, 79 - length($l));

                        print "$l\n";
                }

        }

=item --send[=list_name]

Send e-mails waiting in queue, or with optional argument, just send messages
for single list.

=cut

} elsif (defined($send_opt)) {

        $nos->send_queued_messages($send_opt);

=item --inbox=list_name

Feed incomming message back into notice sender.

=cut

} elsif ($inbox_opt) {

        warn "inbox option is not implemented";

} else  {
        die "see perldoc $0 for help";
}

=back


=head2 Helper options

=over 20

=item --debug

Turn on debugging output from C<Class::DBI>

=item --verbose

Dump more info on screen.

=item --email

Used to specify e-mail address where needed.

=back


=head1 AUTHOR

Dobrica Pavlinusic <dpavlin@rot13.org>

=cut

1	dpavlin	1	#!/usr/bin/perl -w
2
3			use strict;
4	dpavlin	20	use blib;
5			use Nos;
6	dpavlin	1	use Getopt::Long;
7
8	dpavlin	6	=head1 NAME
9
10			sender.pl - command line notify sender utility
11
12	dpavlin	8	=head1 SYNOPSYS
13
14			sender.pl --add=mylist members.txt
15	dpavlin	9	sender.pl --list[=mylist]
16	dpavlin	14	sender.pl --queue[=mylist message.txt]
17	dpavlin	8	sender.pl --send=mylist
18
19	dpavlin	29	In C</etc/aliases> something like:
20
21			mylist: "\| /path/to/sender.pl --inbox=mylist"
22
23	dpavlin	15	=head2 Command options
24	dpavlin	8
25			=over 20
26
27	dpavlin	6	=cut
28
29	dpavlin	12	my $debug = 0;
30	dpavlin	15	my $verbose = 0;
31	dpavlin	12	my $list_opt;
32	dpavlin	2	my $add_opt;
33	dpavlin	6	my $queue_opt;
34	dpavlin	14	my $send_opt;
35	dpavlin	18	my $email_opt;
36	dpavlin	29	my $inbox_opt;
37	dpavlin	1
38			my $result = GetOptions(
39	dpavlin	9	"list:s" => \$list_opt,
40	dpavlin	2	"add=s" => \$add_opt,
41	dpavlin	14	"queue:s" => \$queue_opt,
42			"send:s" => \$send_opt,
43	dpavlin	29	"inbox=s" => \$inbox_opt,
44	dpavlin	1	"debug" => \$debug,
45	dpavlin	15	"verbose" => \$verbose,
46	dpavlin	18	"email=s" => \$email_opt,
47	dpavlin	1	);
48
49	dpavlin	20	my $nos = new Nos(
50			dsn => 'dbi:Pg:dbname=notices',
51			user => 'dpavlin',
52			passwd => '',
53			debug => $debug,
54			verbose => $verbose,
55	dpavlin	1	);
56
57	dpavlin	20	my $loader = $nos->{'loader'} \|\| die "can't find loader?";
58
59	dpavlin	2	my $lists = $loader->find_class('lists');
60			my $users = $loader->find_class('users');
61			my $user_list = $loader->find_class('user_list');
62	dpavlin	6	my $messages = $loader->find_class('messages');
63	dpavlin	11	my $queue = $loader->find_class('queue');
64	dpavlin	15	my $sent = $loader->find_class('sent');
65	dpavlin	2
66	dpavlin	14	$queue->set_sql( list_queue => qq{
67	dpavlin	15	SELECT messages.message, messages.date AS date, lists.name AS list
68	dpavlin	14	FROM queue
69			JOIN messages on message_id = messages.id
70			JOIN lists on list_id = lists.id
71			} );
72
73
74	dpavlin	9	=item --list[=list_name]
75	dpavlin	8
76	dpavlin	14	List all available lists and users on them.
77	dpavlin	8
78	dpavlin	14	Optional value is name of list. With it, this option will produce just users
79			on that list.
80
81	dpavlin	8	=cut
82
83	dpavlin	9	if (defined($list_opt)) {
84			my @lists;
85			if ($list_opt ne '') {
86			@lists = $lists->search( name=> $list_opt )->first \|\| die "can't find list $list_opt";
87			} else {
88			@lists = $lists->retrieve_all;
89			}
90
91			foreach my $list (@lists) {
92	dpavlin	17	print $list->name," <",$list->email,">\n";
93	dpavlin	1	foreach my $user_on_list ($user_list->search(list_id => $list->id)) {
94			my $user = $users->retrieve( id => $user_on_list->user_id );
95			print "\t",$user->full_name," <", $user->email, ">\n";
96			}
97			}
98	dpavlin	8
99			=item --add=list_name
100
101			Add users to list. Users are stored in file (which can be supplied as
102			argument) or read from C<STDIN>. List should be in following format:
103
104			email@example.com Optional full name of person
105			dpavlin@rot13.org Dobrica Pavlinusic
106
107	dpavlin	18	You may use C<--email> parametar at any time to set From: e-mail address for list.
108			B<This seems somewhat cludgy, and it will probably change in future>.
109
110	dpavlin	8	=cut
111
112	dpavlin	2	} elsif ($add_opt) {
113			my $list = $lists->find_or_create({
114			name => $add_opt,
115			}) \|\| die "can't add list $add_opt\n";
116	dpavlin	21
117	dpavlin	18	if ($email_opt && $list->email ne $email_opt) {
118			$list->email($email_opt);
119			$list->update;
120			$list->dbi_commit;
121			}
122	dpavlin	6
123			my $added = 0;
124
125	dpavlin	2	while(<>) {
126			chomp;
127			next if (/^#/ \|\| /^\s*$/);
128			my ($email, $name) = split(/\s+/,$_, 2);
129	dpavlin	23	$added++ if ($nos->add_member_to_list( email => $email, name => $name, list => $add_opt ));
130	dpavlin	2	}
131	dpavlin	3
132	dpavlin	6	print "list ",$list->name," has $added users\n";
133
134	dpavlin	14	=item --queue[=list_name]
135	dpavlin	8
136			Queue message for later delivery. Message can be read from file (specified as
137			argument) or read from C<STDIN>.
138
139	dpavlin	16	This option without optional parametar will display pending queue. If you
140			add C<--verbose> flag, it will display all messages in queue.
141	dpavlin	14
142	dpavlin	8	=cut
143
144	dpavlin	14	} elsif (defined($queue_opt)) {
145	dpavlin	6
146	dpavlin	14	if ($queue_opt ne '') {
147			# add message to list queue
148
149			my $message_text;
150			while(<>) {
151			$message_text .= $_;
152			}
153
154	dpavlin	29	my $id = $nos->add_message_to_list(
155	dpavlin	24	list => $queue_opt,
156			message => $message_text,
157			);
158	dpavlin	14
159	dpavlin	24	print "added message $id to list $queue_opt\n";
160	dpavlin	14
161			} else {
162			# list messages in queue
163
164			foreach my $m ($queue->retrieve_all) {
165	dpavlin	15	next if ($m->all_sent && ! $verbose);
166
167			my $l = $m->all_sent ? 'S' : 'Q';
168
169			my $date = $m->message_id->date;
170			$date =~ s/\..+$//;
171			my $msg = $m->message_id->message;
172			$msg =~ s/\s+/ /gs;
173
174			$l .= sprintf(" %-10s %15s : ", $m->list_id->name, $date);
175			$l .= substr($msg, 0, 79 - length($l));
176
177	dpavlin	14	print "$l\n";
178			}
179
180	dpavlin	6	}
181
182	dpavlin	14	=item --send[=list_name]
183	dpavlin	6
184	dpavlin	16	Send e-mails waiting in queue, or with optional argument, just send messages
185			for single list.
186	dpavlin	6
187	dpavlin	14	=cut
188	dpavlin	6
189	dpavlin	14	} elsif (defined($send_opt)) {
190	dpavlin	6
191	dpavlin	22	$nos->send_queued_messages($send_opt);
192	dpavlin	6
193	dpavlin	29	=item --inbox=list_name
194
195			Feed incomming message back into notice sender.
196
197			=cut
198
199			} elsif ($inbox_opt) {
200
201			warn "inbox option is not implemented";
202
203	dpavlin	1	} else {
204	dpavlin	8	die "see perldoc $0 for help";
205	dpavlin	1	}
206
207	dpavlin	8	=back
208
209	dpavlin	15
210
211			=head2 Helper options
212
213			=over 20
214
215			=item --debug
216
217			Turn on debugging output from C<Class::DBI>
218
219			=item --verbose
220
221			Dump more info on screen.
222
223	dpavlin	18	=item --email
224
225			Used to specify e-mail address where needed.
226
227	dpavlin	15	=back
228
229
230
231	dpavlin	8	=head1 AUTHOR
232
233			Dobrica Pavlinusic <dpavlin@rot13.org>
234
235			=cut
236