| 5 |
5 |
use utf8;
|
| 6 |
6 |
|
| 7 |
7 |
use Carp;
|
|
8 |
use Params::Validate qw(:all);
|
|
9 |
use List::MoreUtils qw(any);
|
| 8 |
10 |
use IO::Socket::INET;
|
| 9 |
11 |
use IO::Socket::SSL;
|
| 10 |
12 |
use Mail::IMAPClient;
|
| ... | ... | |
| 19 |
21 |
use SL::DB::EmailImport;
|
| 20 |
22 |
use SL::DB::EmailJournal;
|
| 21 |
23 |
use SL::DB::EmailJournalAttachment;
|
|
24 |
use SL::DB::Order::TypeData;
|
| 22 |
25 |
|
| 23 |
26 |
use SL::DB::Order;
|
| 24 |
27 |
|
| 25 |
28 |
sub new {
|
| 26 |
|
my ($class, %params) = @_;
|
| 27 |
|
my $config = $::lx_office_conf{imap_client} || {};
|
|
29 |
my $class = shift;
|
|
30 |
my %params = validate(@_, {
|
|
31 |
enabled => {
|
|
32 |
type => BOOLEAN,
|
|
33 |
callbacks => {'is enabled' => sub { !!shift }}
|
|
34 |
},
|
|
35 |
hostname => { type => SCALAR, },
|
|
36 |
port => { type => SCALAR, optional => 1, },
|
|
37 |
ssl => { type => BOOLEAN, },
|
|
38 |
username => { type => SCALAR, },
|
|
39 |
password => { type => SCALAR, },
|
|
40 |
base_folder => { type => SCALAR, default => 'INBOX', },
|
|
41 |
});
|
|
42 |
|
|
43 |
# get translation at runtime
|
|
44 |
my $client_locale = $::locale;
|
| 28 |
45 |
my $server_locale = Locale->new($::lx_office_conf{server}->{language});
|
| 29 |
|
my %record_type_to_folder = (
|
| 30 |
|
sales_quotation => $server_locale->text('Sales Quotations'),
|
| 31 |
|
sales_order => $server_locale->text('Sales Orders'),
|
| 32 |
|
);
|
|
46 |
$::locale = $server_locale;
|
|
47 |
my %record_type_to_folder =
|
|
48 |
map { $_ => SL::DB::Order::TypeData->can('get3')->($_, 'text', 'list') }
|
|
49 |
@{SL::DB::Order::TypeData->valid_types()};
|
|
50 |
$::locale = $client_locale;
|
| 33 |
51 |
my %record_folder_to_type = reverse %record_type_to_folder;
|
|
52 |
|
| 34 |
53 |
my $self = bless {
|
| 35 |
|
enabled => $config->{enabled},
|
| 36 |
|
hostname => $config->{hostname},
|
| 37 |
|
port => $config->{port},
|
| 38 |
|
ssl => $config->{ssl},
|
| 39 |
|
username => $config->{username},
|
| 40 |
|
password => $config->{password},
|
| 41 |
|
base_folder => $config->{base_folder} || 'INBOX',
|
|
54 |
%params,
|
| 42 |
55 |
record_type_to_folder => \%record_type_to_folder,
|
| 43 |
56 |
record_folder_to_type => \%record_folder_to_type,
|
| 44 |
|
%params,
|
| 45 |
57 |
}, $class;
|
| 46 |
|
return unless $self->{enabled};
|
| 47 |
58 |
$self->_create_imap_client();
|
| 48 |
59 |
return $self;
|
| 49 |
60 |
}
|
| ... | ... | |
| 56 |
67 |
}
|
| 57 |
68 |
|
| 58 |
69 |
sub store_email_in_email_folder {
|
| 59 |
|
my ($self, $email_string, $folder_path) = @_;
|
| 60 |
|
$folder_path ||= $self->{base_folder};
|
|
70 |
my $self = shift;
|
|
71 |
my %params = validate(@_, {
|
|
72 |
email_as_string => {
|
|
73 |
type => SCALAR,
|
|
74 |
callbacks => {'is not empty' => sub {shift ne ''}},
|
|
75 |
},
|
|
76 |
folder => {
|
|
77 |
type => SCALAR,
|
|
78 |
callbacks => {'is not empty' => sub {shift ne ''}},
|
|
79 |
},
|
|
80 |
});
|
| 61 |
81 |
|
| 62 |
|
my $folder_string = $self->get_folder_string_from_path($folder_path);
|
| 63 |
|
$self->{imap_client}->append_string($folder_string, $email_string)
|
|
82 |
my $folder_string = $self->get_folder_string_from_path(folder_path => $params{folder});
|
|
83 |
$self->{imap_client}->append_string($folder_string, $params{email_as_string})
|
| 64 |
84 |
or die "Could not store email in folder '$folder_string': "
|
| 65 |
85 |
. $self->{imap_client}->LastError() . "\n";
|
| 66 |
86 |
}
|
| 67 |
87 |
|
| 68 |
88 |
sub set_flag_for_email {
|
| 69 |
|
my ($self, $email_journal, $imap_flag) = @_;
|
| 70 |
|
return unless $imap_flag;
|
|
89 |
my $self = shift;
|
|
90 |
my %params = validate(@_, {
|
|
91 |
email_journal => { isa => 'SL::DB::EmailJournal', },
|
|
92 |
flag => { type => SCALAR, },
|
|
93 |
});
|
|
94 |
my $email_journal = $params{email_journal};
|
|
95 |
my $flag = $params{flag};
|
| 71 |
96 |
|
| 72 |
97 |
my $folder_string = $email_journal->folder;
|
| 73 |
98 |
|
| ... | ... | |
| 82 |
107 |
}
|
| 83 |
108 |
|
| 84 |
109 |
my $uid = $email_journal->uid;
|
| 85 |
|
$self->{imap_client}->set_flag($imap_flag, [$uid])
|
| 86 |
|
or die "Could not add flag '$imap_flag' to message '$uid': "
|
|
110 |
$self->{imap_client}->set_flag($flag, [$uid])
|
|
111 |
or die "Could not add flag '$flag' to message '$uid': "
|
| 87 |
112 |
. $self->{imap_client}->LastError() . "\n";
|
| 88 |
113 |
}
|
| 89 |
114 |
|
| 90 |
115 |
sub update_emails_from_folder {
|
| 91 |
|
my ($self, $folder_path, $params) = @_;
|
| 92 |
|
$folder_path ||= $self->{base_folder};
|
|
116 |
my $self = shift;
|
|
117 |
my %params = validate(@_, {
|
|
118 |
folder => {
|
|
119 |
type => SCALAR | UNDEF,
|
|
120 |
optional => 1,
|
|
121 |
},
|
|
122 |
email_journal_params => {
|
|
123 |
type => HASHREF | UNDEF,
|
|
124 |
optional => 1,
|
|
125 |
},
|
|
126 |
});
|
|
127 |
my $folder_path = $params{folder} || $self->{base_folder};
|
| 93 |
128 |
|
| 94 |
|
my $folder_string = $self->get_folder_string_from_path($folder_path);
|
|
129 |
my $folder_string = $self->get_folder_string_from_path(folder_path => $folder_path);
|
| 95 |
130 |
my $email_import =
|
| 96 |
|
_update_emails_from_folder_strings($self, $folder_path, [$folder_string], $params);
|
|
131 |
$self->_update_emails_from_folder_strings(
|
|
132 |
base_folder_path => $folder_path,
|
|
133 |
folder_strings => [$folder_string],
|
|
134 |
email_journal_params => $params{email_journal_params},
|
|
135 |
);
|
| 97 |
136 |
|
| 98 |
137 |
return $email_import;
|
| 99 |
138 |
}
|
| 100 |
139 |
|
| 101 |
140 |
sub update_emails_from_subfolders {
|
| 102 |
|
my ($self, $base_folder_path, $params) = @_;
|
| 103 |
|
$base_folder_path ||= $self->{base_folder};
|
| 104 |
|
my $base_folder_string = $self->get_folder_string_from_path($base_folder_path);
|
|
141 |
my $self = shift;
|
|
142 |
my %params = validate(@_, {
|
|
143 |
base_folder => {
|
|
144 |
type => SCALAR,
|
|
145 |
optional => 1,
|
|
146 |
},
|
|
147 |
email_journal_params => {
|
|
148 |
type => HASHREF | UNDEF,
|
|
149 |
optional => 1,
|
|
150 |
},
|
|
151 |
});
|
|
152 |
my $base_folder_path = $params{base_folder} || $self->{base_folder};
|
| 105 |
153 |
|
|
154 |
my $base_folder_string = $self->get_folder_string_from_path(folder_path => $base_folder_path);
|
| 106 |
155 |
my @subfolder_strings = $self->{imap_client}->folders($base_folder_string)
|
| 107 |
156 |
or die "Could not get subfolders via IMAP: $@\n";
|
| 108 |
157 |
@subfolder_strings = grep { $_ ne $base_folder_string } @subfolder_strings;
|
| 109 |
158 |
|
| 110 |
159 |
my $email_import =
|
| 111 |
|
_update_emails_from_folder_strings($self, $base_folder_path, \@subfolder_strings, $params);
|
|
160 |
$self->_update_emails_from_folder_strings(
|
|
161 |
base_folder_path => $base_folder_path,
|
|
162 |
folder_strings => \@subfolder_strings,
|
|
163 |
email_journal_params => $params{email_journal_params},
|
|
164 |
);
|
| 112 |
165 |
|
| 113 |
166 |
return $email_import;
|
| 114 |
167 |
}
|
| 115 |
168 |
|
| 116 |
169 |
sub _update_emails_from_folder_strings {
|
| 117 |
|
my ($self, $base_folder_path, $folder_strings, $params) = @_;
|
|
170 |
my $self = shift;
|
|
171 |
my %params = validate(@_, {
|
|
172 |
base_folder_path => { type => SCALAR, },
|
|
173 |
folder_strings => { type => ARRAYREF, },
|
|
174 |
email_journal_params => {
|
|
175 |
type => HASHREF | UNDEF,
|
|
176 |
optional => 1,
|
|
177 |
},
|
|
178 |
});
|
| 118 |
179 |
|
| 119 |
180 |
my $dbh = SL::DB->client->dbh;
|
| 120 |
181 |
|
| 121 |
182 |
my $email_import;
|
| 122 |
183 |
SL::DB->client->with_transaction(sub {
|
| 123 |
|
foreach my $folder_string (@$folder_strings) {
|
|
184 |
foreach my $folder_string (@{$params{folder_strings}}) {
|
| 124 |
185 |
$self->{imap_client}->select($folder_string)
|
| 125 |
186 |
or die "Could not select IMAP folder '$folder_string': $@\n";
|
| 126 |
187 |
|
| ... | ... | |
| 148 |
209 |
|
| 149 |
210 |
next unless @new_msg_uids;
|
| 150 |
211 |
|
| 151 |
|
$email_import ||= $self->_create_email_import($base_folder_path)->save();
|
|
212 |
$email_import ||= $self->_create_email_import(folder_path => $params{base_folder_path})->save();
|
| 152 |
213 |
|
| 153 |
214 |
foreach my $new_uid (@new_msg_uids) {
|
| 154 |
215 |
my $new_email_string = $self->{imap_client}->message_string($new_uid);
|
| 155 |
216 |
my $email = Email::MIME->new($new_email_string);
|
| 156 |
217 |
my $email_journal = $self->_create_email_journal(
|
| 157 |
|
$email, $email_import, $new_uid, $folder_string, $folder_uidvalidity, $params->{email_journal}
|
|
218 |
email => $email,
|
|
219 |
email_import => $email_import,
|
|
220 |
uid => $new_uid,
|
|
221 |
folder_string => $folder_string,
|
|
222 |
folder_uidvalidity => $folder_uidvalidity,
|
|
223 |
email_journal_params => $params{email_journal_params},
|
| 158 |
224 |
);
|
| 159 |
225 |
$email_journal->save();
|
| 160 |
226 |
}
|
| ... | ... | |
| 165 |
231 |
}
|
| 166 |
232 |
|
| 167 |
233 |
sub _create_email_import {
|
| 168 |
|
my ($self, $folder_path) = @_;
|
|
234 |
my $self = shift;
|
|
235 |
my %params = validate(@_, {
|
|
236 |
folder_path => { type => SCALAR, },
|
|
237 |
});
|
| 169 |
238 |
my $email_import = SL::DB::EmailImport->new(
|
| 170 |
239 |
host_name => $self->{hostname},
|
| 171 |
240 |
user_name => $self->{username},
|
| 172 |
|
folder => $folder_path,
|
|
241 |
folder => $params{folder_path},
|
| 173 |
242 |
);
|
| 174 |
243 |
return $email_import;
|
| 175 |
244 |
}
|
| 176 |
245 |
|
| 177 |
246 |
sub _create_email_journal {
|
| 178 |
|
my ($self, $email, $email_import, $uid, $folder_string, $folder_uidvalidity, $params) = @_;
|
|
247 |
my $self = shift;
|
|
248 |
my %params = validate(@_, {
|
|
249 |
email => { isa => 'Email::MIME', },
|
|
250 |
email_import => { isa => 'SL::DB::EmailImport', },
|
|
251 |
uid => { type => SCALAR, },
|
|
252 |
folder_string => { type => SCALAR, },
|
|
253 |
folder_uidvalidity => { type => SCALAR, },
|
|
254 |
email_journal_params => { type => HASHREF | UNDEF, optional => 1},
|
|
255 |
});
|
| 179 |
256 |
|
|
257 |
my $email = $params{email};
|
| 180 |
258 |
if ($email->content_type) { # decode header
|
| 181 |
259 |
my $charset = $email->content_type =~ /charset="(.+)"/ ? $1 : undef;
|
| 182 |
260 |
if ($charset) {
|
| ... | ... | |
| 187 |
265 |
|
| 188 |
266 |
my $text_part;
|
| 189 |
267 |
my %text_parts;
|
| 190 |
|
_find_text_parts(\%text_parts, $email->parts);
|
|
268 |
my @parts = $email->parts;
|
|
269 |
_find_text_parts(
|
|
270 |
text_parts => \%text_parts,
|
|
271 |
parts => \@parts,
|
|
272 |
);
|
| 191 |
273 |
my @accepted_text_content_types = ('text/html', 'text/plain', '');
|
| 192 |
274 |
$text_part ||= $text_parts{$_} for @accepted_text_content_types;
|
| 193 |
275 |
confess "can't find body text in email" unless $text_part;
|
| ... | ... | |
| 199 |
281 |
my $header_string = join "\r\n",
|
| 200 |
282 |
(map { $_ . ': ' . $header_map{$_} } keys %header_map);
|
| 201 |
283 |
|
| 202 |
|
my $date = $self->_parse_date($email->header_str('Date'));
|
|
284 |
my $date = _parse_date($email->header_str('Date'));
|
| 203 |
285 |
|
| 204 |
286 |
my $recipients = $email->header_str('To');
|
| 205 |
287 |
$recipients .= ', ' . $email->header_str('Cc') if ($email->header_str('Cc'));
|
| ... | ... | |
| 222 |
304 |
});
|
| 223 |
305 |
|
| 224 |
306 |
my $email_journal = SL::DB::EmailJournal->new(
|
| 225 |
|
email_import_id => $email_import->id,
|
| 226 |
|
folder => $folder_string,
|
| 227 |
|
folder_uidvalidity => $folder_uidvalidity,
|
| 228 |
|
uid => $uid,
|
|
307 |
email_import_id => $params{email_import}->id,
|
|
308 |
folder => $params{folder_string},
|
|
309 |
folder_uidvalidity => $params{folder_uidvalidity},
|
|
310 |
uid => $params{uid},
|
| 229 |
311 |
status => 'imported',
|
| 230 |
312 |
extended_status => '',
|
| 231 |
313 |
from => $email->header_str('From') || '',
|
| ... | ... | |
| 235 |
317 |
body => $body_text,
|
| 236 |
318 |
headers => $header_string,
|
| 237 |
319 |
attachments => \@attachments,
|
| 238 |
|
%$params,
|
|
320 |
%{$params{email_journal_params}},
|
| 239 |
321 |
);
|
| 240 |
322 |
|
| 241 |
323 |
return $email_journal;
|
| 242 |
324 |
}
|
| 243 |
325 |
|
|
326 |
sub _find_text_parts {
|
|
327 |
my %params = validate(@_,{
|
|
328 |
text_parts => {type => HASHREF,},
|
|
329 |
parts => {
|
|
330 |
type => ARRAYREF,
|
|
331 |
callbacks => {
|
|
332 |
"contains only 'Email::MIME'" => sub {
|
|
333 |
!scalar grep {ref $_ ne 'Email::MIME'} @{$_[0]}
|
|
334 |
},
|
|
335 |
},
|
|
336 |
},
|
|
337 |
});
|
|
338 |
for my $part (@{$params{parts}}) {
|
|
339 |
my $content_type = _cleanup_content_type($part->content_type);
|
|
340 |
if ($content_type =~ m!^text/! or $content_type eq '') {
|
|
341 |
$params{text_parts}->{$content_type} ||= $part;
|
|
342 |
}
|
|
343 |
my @subparts = $part->subparts;
|
|
344 |
if (scalar @subparts) {
|
|
345 |
_find_text_parts(
|
|
346 |
text_parts => $params{text_parts},
|
|
347 |
parts => \@subparts,
|
|
348 |
);
|
|
349 |
}
|
|
350 |
}
|
|
351 |
};
|
|
352 |
|
| 244 |
353 |
sub _cleanup_content_type {
|
| 245 |
354 |
my ($content_type) = @_;
|
| 246 |
355 |
$content_type =~ s/\A\s+//; # Remove whitespaces at begin
|
| ... | ... | |
| 249 |
358 |
return $content_type;
|
| 250 |
359 |
};
|
| 251 |
360 |
|
| 252 |
|
sub _find_text_parts {
|
| 253 |
|
my ($text_parts, @parts) = @_;
|
| 254 |
|
for my $part (@parts) {
|
| 255 |
|
my $content_type = _cleanup_content_type($part->content_type);
|
| 256 |
|
if ($content_type =~ m!^text/! or $content_type eq '') {
|
| 257 |
|
$text_parts->{$content_type} ||= $part;
|
| 258 |
|
}
|
| 259 |
|
_find_text_parts($text_parts, $part->subparts);
|
| 260 |
|
}
|
| 261 |
|
};
|
| 262 |
|
|
| 263 |
361 |
sub _parse_date {
|
| 264 |
|
my ($self, $date) = @_;
|
|
362 |
my ($date) = @_;
|
| 265 |
363 |
return '' unless $date;
|
| 266 |
364 |
my $parse_date = $date;
|
| 267 |
365 |
# replace whitespaces with single space
|
| ... | ... | |
| 282 |
380 |
}
|
| 283 |
381 |
|
| 284 |
382 |
sub update_email_files_for_record {
|
| 285 |
|
my ($self, $record) = @_;
|
| 286 |
|
|
| 287 |
|
my $folder_string = $self->_get_folder_string_for_record($record);
|
|
383 |
my $self = shift;
|
|
384 |
my %params = validate(@_,{
|
|
385 |
record => {
|
|
386 |
isa => [qw(SL::DB::Order)],
|
|
387 |
can => ['id', 'type'],
|
|
388 |
},
|
|
389 |
});
|
|
390 |
my $record = $params{record};
|
|
391 |
my $folder_string = $self->_get_folder_string_for_record(record => $record);
|
| 288 |
392 |
return unless $self->{imap_client}->exists($folder_string);
|
| 289 |
393 |
$self->{imap_client}->select($folder_string)
|
| 290 |
394 |
or die "Could not select IMAP folder '$folder_string': $@\n";
|
| ... | ... | |
| 333 |
437 |
sub update_email_subfolders_and_files_for_records {
|
| 334 |
438 |
my ($self) = @_;
|
| 335 |
439 |
my $base_folder_path = $self->{base_folder};
|
| 336 |
|
my $base_folder_string = $self->get_folder_string_from_path($base_folder_path);
|
|
440 |
my $base_folder_string = $self->get_folder_string_from_path(folder_path => $base_folder_path);
|
| 337 |
441 |
|
| 338 |
442 |
my $folder_strings = $self->{imap_client}->folders($base_folder_string)
|
| 339 |
443 |
or die "Could not get folders via IMAP: $@\n";
|
| ... | ... | |
| 341 |
445 |
|
| 342 |
446 |
# Store the emails to the records
|
| 343 |
447 |
foreach my $subfolder_string (@subfolder_strings) {
|
| 344 |
|
my $ilike_folder_path = $self->get_ilike_folder_path_from_string($subfolder_string);
|
|
448 |
my $ilike_folder_path = $self->get_ilike_folder_path_from_string(folder_string => $subfolder_string);
|
| 345 |
449 |
my (
|
| 346 |
450 |
$ilike_record_folder_path, # is greedily matched
|
| 347 |
451 |
$ilike_customer_number, # no spaces allowed
|
| ... | ... | |
| 353 |
457 |
my $record_type = $self->{record_folder_to_type}->{$record_folder};
|
| 354 |
458 |
next unless $record_type;
|
| 355 |
459 |
|
| 356 |
|
# TODO make it generic for all records
|
| 357 |
|
my $is_quotation = $record_type eq 'sales_quotation' ? 1 : 0;
|
| 358 |
|
my $number_field = $is_quotation ? 'quonumber' : 'ordnumber';
|
|
460 |
my $number_field = SL::DB::Order::TypeData->can('get3')->(
|
|
461 |
$record_type, 'properties', 'nr_key');
|
| 359 |
462 |
my $record = SL::DB::Manager::Order->get_first(
|
| 360 |
463 |
query => [
|
| 361 |
464 |
and => [
|
| 362 |
|
vendor_id => undef,
|
| 363 |
|
quotation => $is_quotation,
|
|
465 |
record_type => $record_type,
|
| 364 |
466 |
$number_field => { ilike => $ilike_record_number },
|
| 365 |
467 |
],
|
| 366 |
468 |
]);
|
| 367 |
469 |
next unless $record;
|
| 368 |
|
$self->update_email_files_for_record($record);
|
|
470 |
$self->update_email_files_for_record(record => $record);
|
| 369 |
471 |
}
|
| 370 |
472 |
|
| 371 |
473 |
return \@subfolder_strings;
|
| 372 |
474 |
}
|
| 373 |
475 |
|
| 374 |
476 |
sub create_folder {
|
| 375 |
|
my ($self, $folder_name) = @_;
|
| 376 |
|
return if $self->{imap_client}->exists($folder_name);
|
| 377 |
|
$self->{imap_client}->create($folder_name)
|
| 378 |
|
or die "Could not create IMAP folder '$folder_name': $@\n";
|
| 379 |
|
$self->{imap_client}->subscribe($folder_name)
|
| 380 |
|
or die "Could not subscribe to IMAP folder '$folder_name': $@\n";
|
|
477 |
my $self = shift;
|
|
478 |
my %params = validate(@_, {
|
|
479 |
folder_string => {type => SCALAR},
|
|
480 |
});
|
|
481 |
my $folder_string = $params{folder_string};
|
|
482 |
return if $self->{imap_client}->exists($folder_string);
|
|
483 |
$self->{imap_client}->create($folder_string)
|
|
484 |
or die "Could not create IMAP folder '$folder_string': $@\n";
|
|
485 |
$self->{imap_client}->subscribe($folder_string)
|
|
486 |
or die "Could not subscribe to IMAP folder '$folder_string': $@\n";
|
| 381 |
487 |
return;
|
| 382 |
488 |
}
|
| 383 |
489 |
|
| 384 |
490 |
sub get_folder_string_from_path {
|
| 385 |
|
my ($self, $folder_path) = @_;
|
|
491 |
my $self = shift;
|
|
492 |
my %params = validate(@_, {
|
|
493 |
folder_path => {type => SCALAR},
|
|
494 |
});
|
|
495 |
my $folder_path = $params{folder_path};
|
| 386 |
496 |
my $separator = $self->{imap_client}->separator();
|
| 387 |
497 |
if ($separator ne '/') {
|
| 388 |
498 |
my $replace_sep = $separator ne '_' ? '_' : '-';
|
| ... | ... | |
| 394 |
504 |
}
|
| 395 |
505 |
|
| 396 |
506 |
sub get_ilike_folder_path_from_string {
|
| 397 |
|
my ($self, $folder_string) = @_;
|
|
507 |
my $self = shift;
|
|
508 |
my %params = validate(@_, {
|
|
509 |
folder_string => {type => SCALAR},
|
|
510 |
});
|
|
511 |
my $folder_string = $params{folder_string};
|
| 398 |
512 |
my $separator = $self->{imap_client}->separator();
|
| 399 |
513 |
my $folder_path = decode('IMAP-UTF-7', $folder_string);
|
| 400 |
514 |
$folder_path =~ s|\Q${separator}|/|g; # \Q -> escape special chars
|
| ... | ... | |
| 403 |
517 |
}
|
| 404 |
518 |
|
| 405 |
519 |
sub create_folder_for_record {
|
| 406 |
|
my ($self, $record) = @_;
|
| 407 |
|
my $folder_string = $self->_get_folder_string_for_record($record);
|
| 408 |
|
$self->create_folder($folder_string);
|
|
520 |
my $self = shift;
|
|
521 |
my %params = validate(@_,{
|
|
522 |
record => {
|
|
523 |
isa => [qw(SL::DB::Order)],
|
|
524 |
},
|
|
525 |
});
|
|
526 |
my $record = $params{record};
|
|
527 |
my $folder_string = $self->_get_folder_string_for_record(record => $record);
|
|
528 |
$self->create_folder(folder_string => $folder_string);
|
| 409 |
529 |
return;
|
| 410 |
530 |
}
|
| 411 |
531 |
|
| 412 |
532 |
sub clean_up_imported_emails_from_folder {
|
| 413 |
|
my ($self, $folder_path) = @_;
|
| 414 |
|
$folder_path ||= $self->{base_folder};
|
| 415 |
|
|
| 416 |
|
my $folder_string = $self->get_folder_string_from_path($folder_path);
|
|
533 |
my $self = shift;
|
|
534 |
my %params = validate(@_, {
|
|
535 |
folder_path => {type => SCALAR},
|
|
536 |
});
|
|
537 |
my $folder_path = $params{folder_path};
|
|
538 |
my $folder_string = $self->get_folder_string_from_path(folder_path => $folder_path);
|
| 417 |
539 |
$self->_clean_up_imported_emails_from_folder_strings([$folder_string]);
|
| 418 |
540 |
}
|
| 419 |
541 |
|
| 420 |
542 |
|
| 421 |
543 |
sub _clean_up_imported_emails_from_folder_strings {
|
| 422 |
|
my ($self, $folder_strings) = @_;
|
|
544 |
my $self = shift;
|
|
545 |
my %params = validate(@_, {
|
|
546 |
folder_strings => {type => ARRAYREF},
|
|
547 |
});
|
|
548 |
my $folder_strings = $params{folder_strings};
|
| 423 |
549 |
my $dbh = SL::DB->client->dbh;
|
| 424 |
550 |
|
| 425 |
551 |
foreach my $folder_string (@$folder_strings) {
|
| ... | ... | |
| 456 |
582 |
}
|
| 457 |
583 |
|
| 458 |
584 |
sub clean_up_record_subfolders {
|
| 459 |
|
my ($self, $active_records) = @_;
|
|
585 |
my $self = shift;
|
|
586 |
my %params = validate(@_, {
|
|
587 |
active_records => {type => ARRAYREF},
|
|
588 |
});
|
|
589 |
my $active_records = $params{active_records};
|
| 460 |
590 |
|
| 461 |
591 |
my $subfolder_strings =
|
| 462 |
592 |
$self->update_email_subfolders_and_files_for_records();
|
| 463 |
593 |
|
| 464 |
|
my @active_folder_strings = map { $self->_get_folder_string_for_record($_) }
|
|
594 |
my @active_folder_strings = map { $self->_get_folder_string_for_record(record => $_) }
|
| 465 |
595 |
@$active_records;
|
| 466 |
596 |
|
| 467 |
597 |
my %keep_folder = map { $_ => 1 } @active_folder_strings;
|
| ... | ... | |
| 474 |
604 |
}
|
| 475 |
605 |
|
| 476 |
606 |
sub _get_folder_string_for_record {
|
| 477 |
|
my ($self, $record) = @_;
|
|
607 |
my $self = shift;
|
|
608 |
my %params = validate(@_, {
|
|
609 |
record => {
|
|
610 |
isa => [qw(SL::DB::Order)],
|
|
611 |
can => ['record_type', 'customervendor', 'number'],
|
|
612 |
},
|
|
613 |
});
|
|
614 |
my $record = $params{record};
|
| 478 |
615 |
|
| 479 |
616 |
my $customer_vendor = $record->customervendor;
|
| 480 |
617 |
|
| ... | ... | |
| 490 |
627 |
my $record_folder_path =
|
| 491 |
628 |
$self->{base_folder} . '/' .
|
| 492 |
629 |
$string_parts{cv_number} . ' ' . $string_parts{cv_name} . '/' .
|
| 493 |
|
$self->{record_type_to_folder}->{$record->type} . '/' .
|
|
630 |
$self->{record_type_to_folder}->{$record->record_type} . '/' .
|
| 494 |
631 |
$string_parts{record_number};
|
| 495 |
|
my $folder_string = $self->get_folder_string_from_path($record_folder_path);
|
|
632 |
my $folder_string = $self->get_folder_string_from_path(folder_path => $record_folder_path);
|
| 496 |
633 |
return $folder_string;
|
| 497 |
634 |
}
|
| 498 |
635 |
|
| ... | ... | |
| 553 |
690 |
use SL::IMAPClient;
|
| 554 |
691 |
|
| 555 |
692 |
# uses the config in config/kivitendo.conf
|
| 556 |
|
my $imap_client = SL::IMAPClient->new();
|
|
693 |
my $imap_client = SL::IMAPClient->new(%{$::lx_office_conf{imap_client}});
|
| 557 |
694 |
|
| 558 |
|
# can also be used with a custom config, overriding the global config
|
|
695 |
# can also be used with a custom config
|
| 559 |
696 |
my %config = (
|
| 560 |
697 |
enabled => 1,
|
| 561 |
698 |
hostname => 'imap.example.com',
|
| ... | ... | |
| 574 |
711 |
|
| 575 |
712 |
# update emails for record
|
| 576 |
713 |
# fetches all emails from the IMAP server and saves them as attachments
|
| 577 |
|
$imap_client->update_email_files_for_record($record);
|
|
714 |
$imap_client->update_email_files_for_record(record => $record);
|
| 578 |
715 |
|
| 579 |
716 |
=head1 OVERVIEW
|
| 580 |
717 |
|
| ... | ... | |
| 603 |
740 |
|
| 604 |
741 |
=item C<new>
|
| 605 |
742 |
|
| 606 |
|
Creates a new SL::IMAPClient object. If no config is passed, the config
|
| 607 |
|
from config/kivitendo.conf is used. If a config is passed, the global
|
| 608 |
|
config is overridden.
|
|
743 |
Creates a new SL::IMAPClient object with the given config.
|
| 609 |
744 |
|
| 610 |
745 |
=item C<DESTROY>
|
| 611 |
746 |
|
| ... | ... | |
| 654 |
789 |
on unix filesystem. The folder string is the path on the IMAP server.
|
| 655 |
790 |
The folder string is encoded in IMAP-UTF-7. It can happend that
|
| 656 |
791 |
C<get_folder_string_from_path> and C<get_ilike_folder_path_from_string>
|
| 657 |
|
don't cancel each other out. This is because the IMAP server can has a
|
| 658 |
|
different Ieparator than the unix filesystem. The changes are made so that a
|
|
792 |
don't cancel each other out. This is because the IMAP server can have a
|
|
793 |
different separator than the unix filesystem. The changes are made so that a
|
| 659 |
794 |
ILIKE query on the database works.
|
| 660 |
795 |
|
| 661 |
796 |
=item C<create_folder_for_record>
|
IMAPClient: validiere Parameter bei der Übergabe