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 --new=mylist
 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: "| cd /path/to && ./sender.pl --inbox=mylist"
 mylist-bounce: "| cd /path/to && ./sender.pl --inbox=mylist --bounce"

=head2 Command options

=over 20

=cut

my $debug = 0;
my $verbose = 0;
my $opt;

my $result = GetOptions(
        "new=s" => \$opt->{'new'},
        "list:s" => \$opt->{'list'},
        "add=s" => \$opt->{'add'},
        "queue:s" => \$opt->{'queue'},
        "send:s" => \$opt->{'send'},
        "inbox=s" => \$opt->{'inbox'},
        "debug" => \$debug,
        "verbose" => \$verbose,
        "from=s" => \$opt->{'from'},
        "driver=s" => \$opt->{'email_send_driver'},
        "bounce" => \$opt->{'bounce'},
);

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
} );

my $list_name;


=item --new=list_name my-list@example.com

Adds new list. You can also feed list name as first line to C<STDIN>.

You can also add C<--from='Full name of list'> to specify full name (comment)
in outgoing e-mail.

=cut

if ($list_name = $opt->{'new'}) {

        my $email = shift @ARGV || <>;
        chomp($email);

        die "need e-mail address for list (as argument or on STDIN)\n" unless ($email);

        my $id = $nos->new_list(
                list => $list_name,
                from => ($opt->{'from'} || ''),
                email => $email,
        ) || die "can't add list $list_name\n";

        print "added list $list_name with ID $id\n";


=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

} elsif (defined($list_name = $opt->{'list'})) {

        my @lists;

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

        foreach my $list (@lists) {
                print $list->name," <",$list->email,">\n";
                foreach my $u ($nos->list_members( list => $list->name )) {
                        print "\t",$u->{'name'}, " <", $u->{'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

=cut

} elsif ($list_name = $opt->{'add'}) {

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

        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 => $list_name ));
        }

        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($list_name = $opt->{'queue'})) {

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

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

                my $id = $nos->add_message_to_list(
                        list => $list_name,
                        message => $message_text,
                ) || die "can't add message to list $list_name\n";

                print "added message $id to list $list_name\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(" %-15s %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.

Optional argument C<--driver=smtp> forces sending using SMTP server at
localhost (127.0.0.1).

=cut

} elsif (defined($list_name = $opt->{'send'})) {

        $nos->send_queued_messages($list_name, $opt->{'email_send_driver'});


=item --inbox=list_name

Feed incomming message back into notice sender.

Optional argument C<--bounce> define that this message is received to
bounce address.

=cut

} elsif ($list_name = $opt->{'inbox'}) {

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

        $nos->inbox_message(
                list => $list_name,
                message => $message,
                bounce => $opt->{'bounce'},
        ) || die "can't receive message for list $list_name";


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

=back


=head2 Helper options

=over 20

=item --debug

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

=item --verbose

Dump more info on screen.

=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	dpavlin	30	sender.pl --new=mylist
15	dpavlin	8	sender.pl --add=mylist members.txt
16	dpavlin	9	sender.pl --list[=mylist]
17	dpavlin	14	sender.pl --queue[=mylist message.txt]
18	dpavlin	8	sender.pl --send=mylist
19
20	dpavlin	29	In C</etc/aliases> something like:
21
22	dpavlin	48	mylist: "\| cd /path/to && ./sender.pl --inbox=mylist"
23			mylist-bounce: "\| cd /path/to && ./sender.pl --inbox=mylist --bounce"
24	dpavlin	29
25	dpavlin	15	=head2 Command options
26	dpavlin	8
27			=over 20
28
29	dpavlin	6	=cut
30
31	dpavlin	12	my $debug = 0;
32	dpavlin	15	my $verbose = 0;
33	dpavlin	30	my $opt;
34	dpavlin	1
35			my $result = GetOptions(
36	dpavlin	30	"new=s" => \$opt->{'new'},
37			"list:s" => \$opt->{'list'},
38			"add=s" => \$opt->{'add'},
39			"queue:s" => \$opt->{'queue'},
40			"send:s" => \$opt->{'send'},
41			"inbox=s" => \$opt->{'inbox'},
42	dpavlin	1	"debug" => \$debug,
43	dpavlin	15	"verbose" => \$verbose,
44	dpavlin	47	"from=s" => \$opt->{'from'},
45			"driver=s" => \$opt->{'email_send_driver'},
46	dpavlin	48	"bounce" => \$opt->{'bounce'},
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	dpavlin	30	my $list_name;
74	dpavlin	14
75	dpavlin	30
76			=item --new=list_name my-list@example.com
77
78			Adds new list. You can also feed list name as first line to C<STDIN>.
79
80	dpavlin	47	You can also add C<--from='Full name of list'> to specify full name (comment)
81			in outgoing e-mail.
82
83	dpavlin	30	=cut
84
85			if ($list_name = $opt->{'new'}) {
86
87			my $email = shift @ARGV \|\| <>;
88			chomp($email);
89
90			die "need e-mail address for list (as argument or on STDIN)\n" unless ($email);
91
92	dpavlin	33	my $id = $nos->new_list(
93	dpavlin	30	list => $list_name,
94	dpavlin	47	from => ($opt->{'from'} \|\| ''),
95	dpavlin	30	email => $email,
96			) \|\| die "can't add list $list_name\n";
97
98	dpavlin	33	print "added list $list_name with ID $id\n";
99	dpavlin	30
100
101	dpavlin	9	=item --list[=list_name]
102	dpavlin	8
103	dpavlin	14	List all available lists and users on them.
104	dpavlin	8
105	dpavlin	14	Optional value is name of list. With it, this option will produce just users
106			on that list.
107
108	dpavlin	8	=cut
109
110	dpavlin	30	} elsif (defined($list_name = $opt->{'list'})) {
111
112	dpavlin	9	my @lists;
113	dpavlin	30
114			if ($list_name ne '') {
115			@lists = $lists->search( name=> $list_name )->first \|\| die "can't find list $list_name";
116	dpavlin	9	} else {
117			@lists = $lists->retrieve_all;
118			}
119
120			foreach my $list (@lists) {
121	dpavlin	17	print $list->name," <",$list->email,">\n";
122	dpavlin	45	foreach my $u ($nos->list_members( list => $list->name )) {
123			print "\t",$u->{'name'}, " <", $u->{'email'}, ">\n";
124	dpavlin	1	}
125			}
126	dpavlin	8
127	dpavlin	30
128	dpavlin	8	=item --add=list_name
129
130			Add users to list. Users are stored in file (which can be supplied as
131			argument) or read from C<STDIN>. List should be in following format:
132
133			email@example.com Optional full name of person
134			dpavlin@rot13.org Dobrica Pavlinusic
135
136			=cut
137
138	dpavlin	30	} elsif ($list_name = $opt->{'add'}) {
139
140	dpavlin	2	my $list = $lists->find_or_create({
141	dpavlin	30	name => $list_name,
142			}) \|\| die "can't add list $list_name\n";
143	dpavlin	21
144	dpavlin	6	my $added = 0;
145
146	dpavlin	2	while(<>) {
147			chomp;
148			next if (/^#/ \|\| /^\s*$/);
149			my ($email, $name) = split(/\s+/,$_, 2);
150	dpavlin	30	$added++ if ($nos->add_member_to_list( email => $email, name => $name, list => $list_name ));
151	dpavlin	2	}
152	dpavlin	3
153	dpavlin	6	print "list ",$list->name," has $added users\n";
154
155	dpavlin	30
156	dpavlin	14	=item --queue[=list_name]
157	dpavlin	8
158			Queue message for later delivery. Message can be read from file (specified as
159			argument) or read from C<STDIN>.
160
161	dpavlin	16	This option without optional parametar will display pending queue. If you
162			add C<--verbose> flag, it will display all messages in queue.
163	dpavlin	14
164	dpavlin	8	=cut
165
166	dpavlin	30	} elsif (defined($list_name = $opt->{'queue'})) {
167	dpavlin	6
168	dpavlin	30	if ($list_name ne '') {
169	dpavlin	14	# add message to list queue
170
171			my $message_text;
172			while(<>) {
173			$message_text .= $_;
174			}
175
176	dpavlin	29	my $id = $nos->add_message_to_list(
177	dpavlin	30	list => $list_name,
178	dpavlin	24	message => $message_text,
179	dpavlin	32	) \|\| die "can't add message to list $list_name\n";
180	dpavlin	14
181	dpavlin	30	print "added message $id to list $list_name\n";
182	dpavlin	14
183			} else {
184			# list messages in queue
185
186			foreach my $m ($queue->retrieve_all) {
187	dpavlin	15	next if ($m->all_sent && ! $verbose);
188
189			my $l = $m->all_sent ? 'S' : 'Q';
190
191			my $date = $m->message_id->date;
192			$date =~ s/\..+$//;
193			my $msg = $m->message_id->message;
194			$msg =~ s/\s+/ /gs;
195
196	dpavlin	36	$l .= sprintf(" %-15s %15s : ", $m->list_id->name, $date);
197	dpavlin	15	$l .= substr($msg, 0, 79 - length($l));
198
199	dpavlin	14	print "$l\n";
200			}
201
202	dpavlin	6	}
203
204	dpavlin	30
205	dpavlin	14	=item --send[=list_name]
206	dpavlin	6
207	dpavlin	16	Send e-mails waiting in queue, or with optional argument, just send messages
208			for single list.
209	dpavlin	6
210	dpavlin	47	Optional argument C<--driver=smtp> forces sending using SMTP server at
211			localhost (127.0.0.1).
212
213	dpavlin	14	=cut
214	dpavlin	6
215	dpavlin	30	} elsif (defined($list_name = $opt->{'send'})) {
216	dpavlin	6
217	dpavlin	47	$nos->send_queued_messages($list_name, $opt->{'email_send_driver'});
218	dpavlin	6
219	dpavlin	30
220	dpavlin	29	=item --inbox=list_name
221
222			Feed incomming message back into notice sender.
223
224	dpavlin	48	Optional argument C<--bounce> define that this message is received to
225			bounce address.
226
227	dpavlin	29	=cut
228
229	dpavlin	36	} elsif ($list_name = $opt->{'inbox'}) {
230	dpavlin	29
231	dpavlin	36	my $message;
232			while(<>) {
233			$message .= $_;
234			}
235	dpavlin	29
236	dpavlin	36	$nos->inbox_message(
237			list => $list_name,
238			message => $message,
239	dpavlin	48	bounce => $opt->{'bounce'},
240	dpavlin	36	) \|\| die "can't receive message for list $list_name";
241
242
243	dpavlin	1	} else {
244	dpavlin	30	die "see perldoc $0 for help\n";
245	dpavlin	1	}
246
247	dpavlin	8	=back
248
249	dpavlin	15
250
251			=head2 Helper options
252
253			=over 20
254
255			=item --debug
256
257			Turn on debugging output from C<Class::DBI>
258
259			=item --verbose
260
261			Dump more info on screen.
262
263			=back
264
265
266
267	dpavlin	8	=head1 AUTHOR
268
269			Dobrica Pavlinusic <dpavlin@rot13.org>
270
271			=cut
272