File Coverage

blib/lib/Newsletter/Html/Templ.pm
Criterion Covered Total %
statement 10 12 83.3
branch n/a
condition n/a
subroutine 4 4 100.0
pod n/a
total 14 16 87.5


line stmt bran cond sub pod time code
1             package Newsletter::Html::Templ;
2              
3 1     1   5 use warnings;
  1         1  
  1         24  
4              
5 1     1   4 use strict;
  1         2  
  1         20  
6 1     1   13943 use CGI;
  1         8476149  
  1         10  
7 1     1   224 use Newsletter;
  0            
  0            
8             use File::Path;
9             use File::Type;
10              
11             sub init {
12             my ($self) = @_;
13             $self->{'cgi'} = new CGI;
14             }
15              
16              
17             sub forumBegin {
18             my ($self, %param) = @_;
19             $self->_out( $self->{'cgi'}->start_form( -method=> 'GET', %param ) );
20             }
21              
22              
23             sub forumEnd {
24             my ($self) = @_;
25             $self->_out( "" );
26             }
27              
28              
29             sub startpage {
30             my ($self) = @_;
31              
32              
33              
34             $self->forumBegin;
35             $self->_out( qq~
36            
37            
38            
39            

Email Lists
40            
41            
42            
43            

Available Lists
44            
45             ~);
46             foreach my $name ( $self->{'nl'}->list( get => "listnames") ) {
47            
48             my $memebersCount = $self->{'nl'}->list( count => $name);
49              
50             if( exists $self->{'persistent'}->{"pOpenList"} ) {
51             if( $self->{'persistent'}->{"pOpenList"} eq $name ) {
52             $self->_out( qq~
53            
54             ~);
55             } else {
56             $self->_out( qq~
57            
58             ~);
59             }
60             } else {
61             $self->_out( qq~
62            
63             ~);
64             }
65             }
66             $self->_out( qq~
67            
68             Send
69             Edit
70            

71            

72            
73            
74             ~);
75             $self->forumEnd;
76             $self->forumBegin;
77             $self->_out( qq~
78            
79            
80            

Create a new Newsletter List
81             List
82            
83            
84             List name is equal to the "from" field in the email! E.g. a valid list name: foo\@bar.com
85            
86            
87            
88            
89             ~);
90             $self->forumEnd;
91              
92              
93             $self->forumBegin;
94             $self->_out( qq~
95            
96            

Email Templates
97            
98            
99            
100            

Schema
101            
102             ~);
103              
104             my %short = (
105             +HEADER => 'H',
106             +FOOTER => 'F'
107             );
108              
109             my %already = ();
110              
111             foreach my $name ( $self->{'nl'}->template( get => { schema => "*" } ) ) {
112             next if( exists $already{ $name->{'schema'} } );
113             next if( $name->{'schema'} eq 'undef' );
114              
115             if( exists $self->{'persistent'}->{"pOpenSchema"} ) {
116             if( $self->{'persistent'}->{"pOpenSchema"} eq $name->{'schema'}) {
117             $self->_out( qq~
118            
119             $name->{'schema'}
120            
121             ~);
122             } else {
123             $self->_out( qq~
124            
125             $name->{'schema'}
126            
127             ~);
128             }
129             } else {
130             $self->_out( qq~
131            
132             $name->{'schema'}
133            
134             ~);
135             }
136              
137             $already{ $name->{'schema'} } = 1;
138             }
139              
140             $self->_out( qq~
141            
142            
143            
144            
145            
146            
147            

All Files
148            
149             ~);
150             foreach my $name ( $self->{'nl'}->template( get => {} ) ) {
151             if( exists $self->{'persistent'}->{"plOpenFile"} ) {
152              
153             my $found = 0;
154             foreach my $tf ( @{ $self->{'persistent'}->{"plOpenFile"} } ) {
155             if( $tf eq $name->{'filename'}.'-is-'.$name->{'is'} ) {
156             $found = 1;
157             last;
158             }
159             }
160              
161             if( $found == 1) {
162             $self->_out( qq~
163            
164             [$name->{'filename'}] [$short{$name->{'is'}}] [$name->{'type'}]
165            
166             ~);
167             } else {
168             $self->_out( qq~
169            
170             [$name->{'filename'}] [$short{$name->{'is'}}] [$name->{'type'}]
171            
172             ~);
173             }
174             } else {
175             $self->_out( qq~
176            
177             [$name->{'filename'}] [$short{$name->{'is'}}] [$name->{'type'}]
178            
179             ~);
180             }
181             }
182              
183             $self->_out( qq~
184            
185            
186            
187             [H]=Header [F]=Footer
188             ~);
189             $self->forumEnd;
190              
191              
192             $self->forumBegin;
193             $self->_out( qq~
194            
195            
196            


197             ~);
198             $self->forumEnd;
199              
200              
201             $self->forumBegin;
202             $self->_out( qq~
203            
204            
205            
206            
207            
208            
209             ~ );
210              
211             $self->forumEnd;
212              
213             $self->_out( qq~
214            
215            

Email Archiv
216            
217            
218            
219             ~ );
220             my $path = $self->{'nl'}->archiv( get => "archivPath" );
221             my %mailByTime = $self->{'nl'}->archiv( get => "mails" );
222             my $countMail = 8;
223             foreach my $mail ( sort {$b cmp $a} keys %mailByTime ) {
224             $mailByTime{ $mail } =~/(.+\d\d\d\d)\_(.*)/;
225             my $mailDate = $1;
226             my $linkName = $2;
227             $self->_out(
228             qq~ [$linkName]
229             ~ );
230              
231             if( -e "$path/$mailByTime{ $mail }/explode/file.html") {
232             $self->_out(
233             qq~ [html]
234             ~ );
235             }
236            
237             if( -e "$path/$mailByTime{ $mail }/explode/file.txt") {
238             $self->_out(
239             qq~ [text]
240             ~ );
241             }
242              
243             $self->_out(
244             qq~
($mailDate)
245             ~ );
246              
247             last if($countMail == 0);
248             $countMail--;
249             }
250              
251              
252             $self->_out( qq~
253            

[ complete archiv ]
254            
255            
256            
257            
258            
259            
260             ~ );
261              
262             if( $self->{'nl'}->error ) {
263             $self->_info( $self->{'nl'}->error );
264             }
265              
266             }
267              
268              
269             sub openList {
270             my ($self) = @_;
271              
272             my $listname = $self->{'persistent'}->{"pOpenList"};
273              
274             $self->forumBegin;
275             $self->_out( qq~
276            
277            
278            
279            
280            

List Members from

$listname
281             search

282            
283             ~);
284              
285             if( $self->{'cgi'}->param("searchList") ) {
286             my $search = $self->{'cgi'}->param("searchList");
287             foreach my $name ( $self->{'nl'}->list( get => $listname) ) {
288             last if( ref($name) ne "HASH" );
289             next if( $name->{'mail'} !~ /$search/ );
290             $self->_out( qq~
291            
292             ~);
293             }
294             } else {
295             foreach my $name ( $self->{'nl'}->list( get => $listname) ) {
296             last if( ref($name) ne "HASH" );
297             $self->_out( qq~
298            
299             ~);
300             }
301             }
302              
303             $self->_out( qq~
304            
305             search
306             Selected delete
307            

308            
309            
310            
311            
312            
313            
314            

Add new members
315             ~ );
316             $self->forumEnd;
317              
318             $self->forumBegin;
319             for( my $m = 1; $m < 7; $m++ ) {
320             my $formatedNr = sprintf("%04d",$m);
321             $self->_out( qq~
322            

323             ~);
324             }
325              
326             $self->_out( qq~
327            
328            
329             ~ );
330             $self->forumEnd;
331              
332             if( $listname ) {
333             $self->forumBegin;
334             $self->_out( qq~
335            

Delete List
336             Delete:No
337             Yes
338            
339            
340            
341             ~ );
342             $self->forumEnd;
343             }
344              
345             $self->_out( qq~
346            
347            
348            
349            
350            
351            
352             ~ );
353              
354             if( $self->{'nl'}->error ) {
355             $self->_info( $self->{'nl'}->error(1) );
356             }
357              
358             }
359              
360              
361             sub editTmpl {
362             my ($self) = @_;
363              
364             $self->forumBegin;
365             $self->_out( qq~
366              
367            
368            
369            
370            

All Templates Files
371             Header Files
372            
373             ~);
374             my %short = (
375             +HEADER => 'H',
376             +FOOTER => 'F'
377             );
378              
379              
380             foreach my $name ( $self->{'nl'}->template( get => {} ) ) {
381             next if( $name->{'is'} eq +FOOTER );
382             $self->_out( qq~
383            
384             [$name->{'filename'}] [$name->{'schema'}] [$short{$name->{'is'}}] [$name->{'type'}]
385            
386             ~);
387             }
388              
389             $self->_out( qq~
390            
391             Footer Files
392            
393             ~);
394              
395             foreach my $name ( $self->{'nl'}->template( get => {} ) ) {
396             next if( $name->{'is'} eq +HEADER );
397             $self->_out( qq~
398            
399             [$name->{'filename'}] [$name->{'schema'}] [$short{$name->{'is'}}] [$name->{'type'}]
400            
401             ~);
402             }
403            
404              
405             $self->_out( qq~
406            
407             [H]=Header [F]=Footer
408            
409             open
410             delete
411            

412            
413            
414             ~ );
415             $self->forumEnd;
416              
417             my $html = +HTML_TMPL;
418             my $text = +TEXT_TMPL;
419             my $header = +HEADER;
420             my $footer = +FOOTER;
421              
422             $self->forumBegin( -enctype => "multipart/form-data", -method => "post" );
423             $self->_out( qq~
424            
425            
426            
427            
428            

Add new Template File
429            

430             Html
431             Text
432             Header
433             Footer
434            
435             Create new Schema
436            

437             Add to existing Schema
438            
439            
440             ~ );
441             my %already = ();
442              
443             foreach my $name ( $self->{'nl'}->template( get => { schema => "*" } ) ) {
444             next if( exists $already{ $name->{'schema'} } );
445             next if( $name->{'schema'} eq 'undef' );
446             $self->_out( qq~
447            
448             $name->{'schema'}
449            
450             ~);
451             $already{ $name->{'schema'} } = 1;
452             }
453            
454             $self->_out( qq~
455            


456            
457            
458            
459            
460            
461             ~ );
462              
463             $self->forumEnd;
464              
465             $self->_out( qq~
466            
467            
468            
469             ~ );
470              
471             }
472              
473              
474             sub openTmpl {
475             my ($self, $path, $type) = @_;
476              
477             my $nr = int(rand(10000) + 1);
478              
479             $self->_out( qq~
480            
501             ~);
502             }
503              
504              
505             sub fileuploadTmpl {
506             my ($self) = @_;
507              
508             my $fileName = $self->fileUpload("tmplFileUpload");
509              
510             $self->forumBegin( -enctype => "multipart/form-data", -method => "post" );
511              
512             $self->_out( qq~
513            
514            
515            
516            

Add embedded Files
517             Filename:$fileName
518             Is:$self->{'persistent'}->{"pTmplFileUploadIs"}
519             Type:$self->{'persistent'}->{"pTmplFileUploadType"}
520             Schema:
521             ~);
522            
523             if( $self->{'persistent'}->{"pTmplFileUploadSchemaNew"} ) {
524             $self->_out( qq~
525             $self->{'persistent'}->{"pTmplFileUploadSchemaNew"}
526            
527             ~);
528             }
529             elsif( $self->{'persistent'}->{"pTmplFileUploadSchema"} ne "none") {
530             $self->_out( qq~
531             $self->{'persistent'}->{"pTmplFileUploadSchema"}
532            
533             ~);
534             } else {
535             $self->_out( qq~
536             None
537             ~);
538             }
539              
540             $self->_out( qq~
541            

Upload Embedded
542             ~);
543            
544             for(my $a = 0; $a < 10; $a++ ) {
545             $self->_out( qq~
~);
546             }
547              
548             $self->_out( qq~
549            

550            
551            
552            
553            
554            
555            
556             ~);
557              
558             $self->forumEnd;
559              
560             }
561              
562              
563             sub sendList {
564             my ($self) = @_;
565              
566             if(! exists $self->{'persistent'}->{"pOpenList"} ) {
567             $self->startpage;
568             $self->_info( "No Mailing List is selected!" );
569             return;
570             }
571              
572             if(! $self->{'persistent'}->{"pOpenList"} ) {
573             $self->startpage;
574             $self->_info( "No Mailing List is selected!" );
575             return;
576             }
577              
578              
579              
580             $self->forumBegin( -enctype => "multipart/form-data", -method => "post" );
581              
582              
583             my %mailType = (
584             'text' => 'Text',
585             'multipart/related' => 'Html',
586             'multipart/mixed' => 'Html + Text'
587             );
588              
589             $self->_out( qq~
590            
591            
592            
593            
594            

Create Email
595             ~); ~); ~);
596            
597             Mail Type
598            
599            
600             ~);
601             if( exists $self->{'persistent'}->{"pMailType"} ) {
602             foreach my $key (keys %mailType ) {
603             if( $self->{'persistent'}->{"pMailType"} eq $key) {
604             $self->_out( qq~
605            
606             ~);
607             } else {
608             $self->_out( qq~
609            
610             ~);
611             }
612             }
613             } else {
614             $self->_out( qq~
615            
616            
617            
618             ~);
619             }
620              
621             $self->_out( qq~
622            
623            
624            
625            
626             Subject
627             ~);
628              
629              
630             if( $self->{'persistent'}->{"pMailSubject"} ) {
631             $self->_out( qq~
632            
633             ~);
634             } else {
635             $self->_out( qq~
636             }
637              
638             $self->_out( qq~
639            
640              
641            
642             Mail from File
643             Html
644             Text
645            
646              
647            
648             Mail Html Body
649             ~);
650              
651             if( $self->{'persistent'}->{"pMailBodyHtml"} ) {
652             $self->_out( qq~
653            
654             ~);
655             } else {
656             $self->_out( qq~
657             }
658            
659              
660             $self->_out( qq~
661            
662            
663             Mail Text Body
664             ~);
665              
666             if( $self->{'persistent'}->{"pMailBodyText"} ) {
667             $self->_out( qq~
668            
669             ~);
670             } else {
671             $self->_out( qq~
672             }
673              
674              
675             $self->_out( qq~
676            
677              
678            
679             Embedded Files
680            
681            
682            
683            
684            
685            
686            
687            
688              
689            
690             Attachments
691            
692            
693            
694            
695            
696            
697            
698            
699            
700            
701            
702            
703            
704            
705            
706             ~);
707             $self->forumEnd;
708              
709             $self->sendListSetting;
710              
711             $self->_out( qq~
712            
713            
714            
715             ~);
716             }
717              
718              
719             sub sendListSetting {
720             my($self) = @_;
721            
722             $self->forumBegin();
723             $self->_out( qq~
724            

Settings
725             ~); ~);
726            
727             Maillist
728             $self->{'persistent'}->{"pOpenList"}
729            
730             ~);
731              
732             if( $self->{'persistent'}->{"pOpenSchema"} ) {
733             $self->_out( qq~
734            
735             Schema
736             $self->{'persistent'}->{"pOpenSchema"}
737            
738            
739             Schema Files
740            
741             ~);
742              
743            
744             foreach my $name ( $self->{'nl'}->template( get => { schema => $self->{'persistent'}->{"pOpenSchema"} } ) ) {
745             $self->_out( qq~
746             $name->{'filename'}
747             ~);
748             }
749             $self->_out( qq~
750              
751             } else {
752              
753             if( $self->{'persistent'}->{"plOpenFile"}->[0] ) {
754             $self->_out( qq~
755            
756             Selected Files
757            
758             ~);
759             foreach my $tf ( @{ $self->{'persistent'}->{"plOpenFile"} } ) {
760             my @tmp = split(/-is-/,$tf);
761            
762             $self->_out( qq~ $tmp[0]
~);
763             }
764             $self->_out( qq~
765             }
766              
767             }
768              
769             $self->_out( qq~
770            

771             ~);
772              
773             if( $self->{'persistent'}->{'pMailFromFileHtml'} ) {
774             $self->_out( qq~
775            
776             Body Html File
777            
778             $self->{'persistent'}->{'pMailFromFileHtml'}
779            
780             Delete: No
781             Yes
782            
783            
784             ~);
785             }
786              
787              
788             if( $self->{'persistent'}->{'pMailFromFileText'} ) {
789             $self->_out( qq~
790            
791             Body Text File
792            
793             $self->{'persistent'}->{'pMailFromFileText'}
794            
795             Delete: No
796             Yes
797            
798            
799             ~);
800             }
801              
802              
803             if( $self->{'persistent'}->{"pMailEmbFile1"} ) {
804              
805             $self->_out( qq~
806            
Embedded
807             ~);
808             for( my $a = 1; $a < 11; $a++ ) {
809             if( $self->{'persistent'}->{"pMailEmbFile$a"} ) {
810             $self->_out( qq~
811             $self->{'persistent'}->{"pMailEmbFile$a"} -
812             {'persistent'}->{"pMailEmbFile$a"}>
813             Delete {'persistent'}->{"pMailEmbFile$a"} checked="checked">No
814             Yes
815             ~);
816             }
817             }
818             $self->_out( qq~
819            
820             ~);
821             }
822              
823              
824             if( $self->{'persistent'}->{"pMailAttFile1"} ) {
825              
826             $self->_out( qq~
827            
Attachments
828             ~);
829             for( my $a = 1; $a < 5; $a++ ) {
830             if( $self->{'persistent'}->{"pMailAttFile$a"} ) {
831             $self->_out( qq~
832             $self->{'persistent'}->{"pMailAttFile$a"} -
833             {'persistent'}->{"pMailAttFile$a"}>
834             Delete {'persistent'}->{"pMailAttFile$a"} checked="checked">No
835             Yes
836             ~);
837             }
838             }
839             $self->_out( qq~
840            
841             ~);
842             }
843              
844              
845             $self->_out( qq~
846            
847            
848            
849             ~);
850              
851             if( $self->{'persistent'}->{"pSection"} eq "sendListEdit" || $self->{'persistent'}->{"pSection"} eq "sendListPreview") {
852             $self->_out( qq~
853             Preview
854             Edit (Go back!)
855             ~);
856             } else {
857             $self->_out( qq~
858            
859            
860             ~);
861             }
862              
863             $self->_out( qq~
864            
865            
866            
867            
868             ~);
869              
870             $self->forumEnd;
871             }
872              
873              
874             sub sendListFileupload {
875             my($self) = @_;
876              
877             if( $self->{'cgi'}->param("mailFromFileHtml") ) {
878             $self->{'persistent'}->{'pMailFromFileHtml'} = $self->fileUpload("mailFromFileHtml");
879             $self->_out( qq~
880            
881             ~);
882             }
883              
884             if( $self->{'cgi'}->param("mailFromFileText") ) {
885             $self->{'persistent'}->{'pMailFromFileText'} = $self->fileUpload("mailFromFileText");
886             $self->_out( qq~
887            
888             ~);
889             }
890              
891              
892             for( my $a = 1; $a < 11; $a++ ) {
893             if( $self->{'cgi'}->param("mailEmbFile$a") ) {
894             $self->{'persistent'}->{"pMailEmbFile$a"} = $self->fileUpload("mailEmbFile$a");
895             $self->_out( qq~
896             {'persistent'}->{"pMailEmbFile$a"}>
897             ~);
898             }
899              
900             if( $self->{'cgi'}->param("mailAttFile$a") ) {
901             $self->{'persistent'}->{"pMailAttFile$a"} = $self->fileUpload("mailAttFile$a");
902             $self->_out( qq~
903             {'persistent'}->{"pMailAttFile$a"}>
904             ~);
905             }
906             }
907             }
908              
909              
910             sub sendListFileDelete {
911             my($self) = @_;
912            
913             if( $self->{'cgi'}->param("delMailFromFileHtml") ) {
914             my $file = $self->{'cgi'}->param("delMailFromFileHtml");
915             $self->_out( qx "rm $self->{'uploadPath'}/$file 2>&1" );
916             }
917              
918             if( $self->{'cgi'}->param("delMailFromFileText") ) {
919             my $file = $self->{'cgi'}->param("delMailFromFileText");
920             $self->_out( qx "rm $self->{'uploadPath'}/$file 2>&1" );
921             }
922            
923              
924             for( my $a = 1; $a < 11; $a++ ) {
925             if( $self->{'cgi'}->param("delMailEmbFile$a") ) {
926             my $file = $self->{'cgi'}->param("delMailEmbFile$a");
927             $self->_out( qx "rm $self->{'uploadPath'}/$file 2>&1" );
928             }
929             }
930              
931             for( my $a = 1; $a < 5; $a++ ) {
932             if( $self->{'cgi'}->param("delMailAttFile$a") ) {
933             my $file = $self->{'cgi'}->param("delMailAttFile$a");
934             $self->_out( qx "rm $self->{'uploadPath'}/$file 2>&1" );
935             }
936             }
937              
938             }
939              
940              
941             sub sendListPreview {
942             my($self) = @_;
943              
944             if(! $self->{'persistent'}->{"pMailSubject"} ) {
945             $self->sendList;
946             $self->_info( "Alert no mail subject!" );
947             return;
948             }
949              
950              
951              
952             $self->forumBegin( );
953             $self->sendListFileupload;
954             $self->sendListBuild;
955              
956             $self->_out( qq~
957            
958            
959              
960            
961            

Preview Email
962            
963            
964             Subject
965             $self->{'persistent'}->{"pMailSubject"}
966            
967             ~);
968            
969             my $mailFile = $self->{'nl'}->previewMailFile( preview => 1 );
970              
971             if( $mailFile ) {
972             $self->_out( qq~
973            
974             Preview Mail
975             [Open Mail]
976            
977             ~);
978              
979             if( $self->{'nl'}->error ) {
980             $self->_info( $self->{'nl'}->error(1) );
981             }
982              
983             my %explodeFiles;
984              
985             my $headers = $self->{'nl'}->previewMailFileExplode( $mailFile );
986             for my $part ( sort{ $a cmp $b } keys( %{ $headers } ) ) {
987             for my $k ( keys( %{ $headers->{$part} } ) ) {
988             if( $k eq 'content-disposition' ) {
989             if( exists $headers->{$part}->{'content-disposition'}->{'filename'} ) {
990             #warn $headers->{$part}->{'content-disposition'}->{'filename'};
991             if( !exists $explodeFiles{ $headers->{$part}->{'content-disposition'}->{'filename'} } ) {
992             $explodeFiles{ $headers->{$part}->{'content-disposition'}->{'filename'} } = 1;
993             }
994             }
995             }
996             }
997             }
998              
999              
1000             my $explodePath = $self->{'nl'}->previewMailFile( getpath => 1 )."/explode";
1001              
1002             # remove attachment files from list!
1003             for( my $a = 1; $a < 5; $a++ ) {
1004             if( $self->{'persistent'}->{"pMailAttFile$a"} ) {
1005             if( exists $explodeFiles{ $self->{'persistent'}->{"pMailAttFile$a"} } ) {
1006             delete $explodeFiles{ $self->{'persistent'}->{"pMailAttFile$a"} };
1007             }
1008             }
1009             }
1010              
1011             foreach my $file ( sort keys %explodeFiles ) {
1012             #warn "[$file]\n";
1013             if( $file =~ /\.html/) {
1014             $self->_out( qq~
1015            
1016             Preview HTML
1017            
1018             ~);
1019             open(FILE, "<$explodePath/$file") or die "preview html file:$explodePath/$file:$!\n";
1020             while( defined( my $line = ) ) {
1021             $line =~ s/src="cid:/src="$explodePath\//gi;
1022             $self->_out( qq~ $line ~);
1023             }
1024             close(FILE);
1025             $self->_out( qq~
1026            
1027            
1028             ~);
1029             }
1030            
1031             elsif( $file =~ /\.txt/ || $file !~ /\./ ) {
1032             $self->_out( qq~
1033            
1034             Preview Text
1035             
 ~);
1036              
1037             open(FILE, "<$explodePath/$file") or warn "preview text file:$explodePath/$file:$!\n";
1038             while( defined( my $line = ) ) {
1039             $self->_out( qq~ $line ~);
1040             }
1041             close(FILE);
1042             $self->_out( qq~
1043            
1044            
1045            
1046             ~);
1047             }
1048             }
1049              
1050             if( $self->{'nl'}->error ) {
1051             $self->_info( $self->{'nl'}->error );
1052             }
1053             } else {
1054             if( $self->{'nl'}->error ) {
1055             $self->_info( $self->{'nl'}->error );
1056             }
1057             }
1058              
1059              
1060             # $self->_out( qq~
1061             #
1062             # Mail Source
1063             #
1064             #
1079             #
1080             #
1081             # ~);
1082              
1083              
1084             $self->_out( qq~
1085            
1086            
1087            
1088            
1089            
1090            
1091            
1092            
1093            
1094            
1095             ~);
1096              
1097             $self->forumEnd;
1098              
1099             $self->sendListSetting;
1100             $self->_out( qq~
1101            
1102            
1103            
1104             ~);
1105             }
1106              
1107              
1108             sub sendListBuild {
1109             my($self) = @_;
1110              
1111             # Set Sender type
1112             $self->{'nl'}->sender(
1113             type => $self->{'persistent'}->{"pMailType"}
1114             );
1115              
1116              
1117             # Load Footer / Header
1118             if( $self->{'persistent'}->{"pOpenSchema"} ) {
1119             $self->{'nl'}->template(
1120             use => {
1121             schema => $self->{'persistent'}->{"pOpenSchema"}
1122             }
1123             );
1124             } else {
1125              
1126             if( $self->{'persistent'}->{"plOpenFile"}->[0] ) {
1127             foreach my $tf ( @{ $self->{'persistent'}->{"plOpenFile"} } ) {
1128             my @tmp = split(/-is-/,$tf);
1129            
1130             $self->{'nl'}->template(
1131             use => {
1132             is => $tmp[1],
1133             filename => $tmp[0]
1134             }
1135             );
1136             }
1137             }
1138             }
1139              
1140             # Load Subject
1141             if( $self->{'persistent'}->{"pMailSubject"} ) {
1142             $self->{'nl'}->body( subject => $self->{'persistent'}->{"pMailSubject"} );
1143             }
1144              
1145              
1146             # Load Body Html
1147             my @embHtml = ();
1148             for( my $a = 1; $a < 11; $a++ ) {
1149             if( $self->{'persistent'}->{"pMailEmbFile$a"} ) {
1150             push( @embHtml, $self->{'uploadPath'}.'/'.$self->{'persistent'}->{"pMailEmbFile$a"} );
1151             }
1152             }
1153              
1154             if( exists $self->{'persistent'}->{'pMailFromFileHtml'} ) {
1155             if( $self->{'persistent'}->{'pMailFromFileHtml'} ) {
1156             $self->{'nl'}->body(
1157             file => {
1158             path => $self->{'uploadPath'}.'/'.$self->{'persistent'}->{'pMailFromFileHtml'},
1159             type => 'html',
1160             embedded => \@embHtml,
1161             }
1162             );
1163             } else {
1164             $self->{'nl'}->body(
1165             data => {
1166             value => $self->{'persistent'}->{'pMailBodyHtml'},
1167             type => 'html',
1168             embedded => \@embHtml,
1169             }
1170             );
1171             }
1172             } else {
1173             $self->{'nl'}->body(
1174             data => {
1175             value => $self->{'persistent'}->{'pMailBodyHtml'},
1176             type => 'html',
1177             embedded => \@embHtml,
1178             }
1179             );
1180             }
1181              
1182              
1183             # Load Body Text
1184             if( exists $self->{'persistent'}->{'pMailFromFileText'} ) {
1185             if( $self->{'persistent'}->{'pMailFromFileText'} ) {
1186             $self->{'nl'}->body(
1187             file => {
1188             path => $self->{'uploadPath'}.'/'.$self->{'persistent'}->{'pMailFromFileText'},
1189             type => 'text',
1190             }
1191             );
1192             } else {
1193             $self->{'nl'}->body(
1194             data => {
1195             value => $self->{'persistent'}->{'pMailBodyText'},
1196             type => 'text',
1197             }
1198             );
1199             }
1200             } else {
1201             $self->{'nl'}->body(
1202             data => {
1203             value => $self->{'persistent'}->{'pMailBodyText'},
1204             type => 'text',
1205             }
1206             );
1207             }
1208              
1209              
1210             # add attachments
1211             my $msg = $self->{'nl'}->sender;
1212             if( $msg ) {
1213             my $ft = File::Type->new();
1214              
1215             for( my $a = 1; $a < 5; $a++ ) {
1216             if( $self->{'persistent'}->{"pMailAttFile$a"} ) {
1217              
1218             # 'file' and 'file.html' not allowed
1219             if( $self->{'persistent'}->{"pMailAttFile$a"} =~ /file/ ||
1220             $self->{'persistent'}->{"pMailAttFile$a"} =~ /file\.html/
1221             ) {
1222             next;
1223             $self->_info( "'file' and 'file.html' not allowed as attachment filenames\n" );
1224             }
1225              
1226             $msg->attach(
1227             Type => $ft->checktype_filename( $self->{'uploadPath'}.'/'.$self->{'persistent'}->{"pMailAttFile$a"} ),
1228             Path => $self->{'uploadPath'}.'/'.$self->{'persistent'}->{"pMailAttFile$a"}
1229             );
1230             warn "Path => ".$self->{'uploadPath'}.'/'.$self->{'persistent'}->{"pMailAttFile$a"};
1231             }
1232             }
1233             }
1234              
1235             if( $self->{'nl'}->error ) {
1236             $self->_info( $self->{'nl'}->error );
1237             }
1238             }
1239              
1240              
1241              
1242              
1243             sub sendListMail {
1244             my($self) = @_;
1245              
1246              
1247             $self->sendListBuild;
1248            
1249             # add attachments
1250             # my $msg = $self->{'nl'}->sender;
1251             # if( $msg ) {
1252             # for( my $a = 1; $a < 5; $a++ ) {
1253             # if( $self->{'persistent'}->{"pMailAttFile$a"} ) {
1254             #
1255             # # 'file' and 'file.html' not allowed
1256             # if( $self->{'persistent'}->{"pMailAttFile$a"} =~ /file/ ||
1257             # $self->{'persistent'}->{"pMailAttFile$a"} =~ /file\.html/
1258             # ) {
1259             # next;
1260             # $self->_info( "'file' and 'file.html' not allowed as attachment filenames\n" );
1261             # }
1262             #
1263             # $msg->attach(
1264             # Path => $self->{'uploadPath'}.'/'.$self->{'persistent'}->{"pMailAttFile$a"}
1265             # );
1266             # warn "Path => ".$self->{'uploadPath'}.'/'.$self->{'persistent'}->{"pMailAttFile$a"};
1267             # }
1268             # }
1269             # }
1270              
1271              
1272             # open mail list
1273             $self->{'nl'}->list(
1274             list => { name => $self->{'persistent'}->{"pOpenList"} }
1275             );
1276              
1277              
1278             if( $self->{'nl'}->error ) {
1279             $self->_info( $self->{'nl'}->error );
1280             }
1281              
1282             # send !!!
1283             print qq~ 
~;
1284             $self->{'nl'}->send(1);
1285             print qq~ ~;
1286              
1287              
1288             if( $self->{'nl'}->error ) {
1289             $self->_info( $self->{'nl'}->error );
1290             }
1291              
1292             # copy to archiv
1293             $self->{'nl'}->archiv( save => 1 );
1294              
1295             if( $self->{'nl'}->error ) {
1296             $self->_info( $self->{'nl'}->error );
1297             }
1298              
1299             # cleanup upload files
1300             $self->sendListClean();
1301              
1302             }
1303              
1304              
1305             sub sendListClean {
1306             my($self) = @_;
1307              
1308             rmtree $self->{'uploadPath'};
1309             }
1310              
1311              
1312              
1313             =head1 NAME
1314              
1315             Newsletter::Html::Templ - Html parts!
1316              
1317             =head1 VERSION
1318              
1319             Version 0.01
1320              
1321             =cut
1322              
1323             our $VERSION = '0.01';
1324              
1325             =head1 SYNOPSIS
1326              
1327             The html parts for the newsletter module
1328              
1329             Perhaps a little code snippet.
1330              
1331             use Newsletter::Html::Templ;
1332              
1333             my $foo = Newsletter::Html::Templ->new();
1334             ...
1335              
1336             =head1 EXPORT
1337              
1338             A list of functions that can be exported. You can delete this section
1339             if you don't export anything, such as for a purely object-oriented module.
1340              
1341             =head1 FUNCTIONS
1342              
1343             =head1 AUTHOR
1344              
1345             Dominik Hochreiter, C<< >>
1346              
1347             =head1 BUGS
1348              
1349             Please report any bugs or feature requests to
1350             C, or through the web interface at
1351             L.
1352             I will be notified, and then you'll automatically be notified of progress on
1353             your bug as I make changes.
1354              
1355             =head1 SUPPORT
1356              
1357             You can find documentation for this module with the perldoc command.
1358              
1359             perldoc Newsletter
1360              
1361             You can also look for information at:
1362              
1363             =over 4
1364              
1365             =item * AnnoCPAN: Annotated CPAN documentation
1366              
1367             L
1368              
1369             =item * CPAN Ratings
1370              
1371             L
1372              
1373             =item * RT: CPAN's request tracker
1374              
1375             L
1376              
1377             =item * Search CPAN
1378              
1379             L
1380              
1381             =back
1382              
1383             =head1 ACKNOWLEDGEMENTS
1384              
1385             =head1 COPYRIGHT & LICENSE
1386              
1387             Copyright 2006 Dominik Hochreiter, all rights reserved.
1388              
1389             This program is free software; you can redistribute it and/or modify it
1390             under the same terms as Perl itself.
1391              
1392             =cut
1393              
1394             1; # End of Newsletter::Html::Templ