alarm systems, types, central stations, RT#25994
[freeside.git] / FS / FS / contact.pm
1 package FS::contact;
2 use base qw( FS::Record );
3
4 use strict;
5 use FS::Record qw( qsearch qsearchs dbh );
6 use FS::prospect_main;
7 use FS::cust_main;
8 use FS::contact_class;
9 use FS::cust_location;
10 use FS::contact_phone;
11 use FS::contact_email;
12
13 =head1 NAME
14
15 FS::contact - Object methods for contact records
16
17 =head1 SYNOPSIS
18
19   use FS::contact;
20
21   $record = new FS::contact \%hash;
22   $record = new FS::contact { 'column' => 'value' };
23
24   $error = $record->insert;
25
26   $error = $new_record->replace($old_record);
27
28   $error = $record->delete;
29
30   $error = $record->check;
31
32 =head1 DESCRIPTION
33
34 An FS::contact object represents an example.  FS::contact inherits from
35 FS::Record.  The following fields are currently supported:
36
37 =over 4
38
39 =item contactnum
40
41 primary key
42
43 =item prospectnum
44
45 prospectnum
46
47 =item custnum
48
49 custnum
50
51 =item locationnum
52
53 locationnum
54
55 =item last
56
57 last
58
59 =item first
60
61 first
62
63 =item title
64
65 title
66
67 =item comment
68
69 comment
70
71 =item disabled
72
73 disabled
74
75
76 =back
77
78 =head1 METHODS
79
80 =over 4
81
82 =item new HASHREF
83
84 Creates a new example.  To add the example to the database, see L<"insert">.
85
86 Note that this stores the hash reference, not a distinct copy of the hash it
87 points to.  You can ask the object for a copy with the I<hash> method.
88
89 =cut
90
91 # the new method can be inherited from FS::Record, if a table method is defined
92
93 sub table { 'contact'; }
94
95 =item insert
96
97 Adds this record to the database.  If there is an error, returns the error,
98 otherwise returns false.
99
100 =cut
101
102 sub insert {
103   my $self = shift;
104
105   local $SIG{INT} = 'IGNORE';
106   local $SIG{QUIT} = 'IGNORE';
107   local $SIG{TERM} = 'IGNORE';
108   local $SIG{TSTP} = 'IGNORE';
109   local $SIG{PIPE} = 'IGNORE';
110
111   my $oldAutoCommit = $FS::UID::AutoCommit;
112   local $FS::UID::AutoCommit = 0;
113   my $dbh = dbh;
114
115   my $error = $self->SUPER::insert;
116   if ( $error ) {
117     $dbh->rollback if $oldAutoCommit;
118     return $error;
119   }
120
121   foreach my $pf ( grep { /^phonetypenum(\d+)$/ && $self->get($_) =~ /\S/ }
122                         keys %{ $self->hashref } ) {
123     $pf =~ /^phonetypenum(\d+)$/ or die "wtf (daily, the)";
124     my $phonetypenum = $1;
125
126     my $contact_phone = new FS::contact_phone {
127       'contactnum' => $self->contactnum,
128       'phonetypenum' => $phonetypenum,
129       _parse_phonestring( $self->get($pf) ),
130     };
131     $error = $contact_phone->insert;
132     if ( $error ) {
133       $dbh->rollback if $oldAutoCommit;
134       return $error;
135     }
136   }
137
138   if ( $self->get('emailaddress') =~ /\S/ ) {
139
140     foreach my $email ( split(/\s*,\s*/, $self->get('emailaddress') ) ) {
141  
142       my $contact_email = new FS::contact_email {
143         'contactnum'   => $self->contactnum,
144         'emailaddress' => $email,
145       };
146       $error = $contact_email->insert;
147       if ( $error ) {
148         $dbh->rollback if $oldAutoCommit;
149         return $error;
150       }
151
152     }
153
154   }
155
156   #unless ( $import || $skip_fuzzyfiles ) {
157     #warn "  queueing fuzzyfiles update\n"
158     #  if $DEBUG > 1;
159     $error = $self->queue_fuzzyfiles_update;
160     if ( $error ) {
161       $dbh->rollback if $oldAutoCommit;
162       return "updating fuzzy search cache: $error";
163     }
164   #}
165
166   $dbh->commit or die $dbh->errstr if $oldAutoCommit;
167
168   '';
169
170 }
171
172 =item delete
173
174 Delete this record from the database.
175
176 =cut
177
178 # the delete method can be inherited from FS::Record
179
180 sub delete {
181   my $self = shift;
182
183   local $SIG{HUP} = 'IGNORE';
184   local $SIG{INT} = 'IGNORE';
185   local $SIG{QUIT} = 'IGNORE';
186   local $SIG{TERM} = 'IGNORE';
187   local $SIG{TSTP} = 'IGNORE';
188   local $SIG{PIPE} = 'IGNORE';
189
190   my $oldAutoCommit = $FS::UID::AutoCommit;
191   local $FS::UID::AutoCommit = 0;
192   my $dbh = dbh;
193
194   foreach my $object ( $self->contact_phone, $self->contact_email ) {
195     my $error = $object->delete;
196     if ( $error ) {
197       $dbh->rollback if $oldAutoCommit;
198       return $error;
199     }
200   }
201
202   my $error = $self->SUPER::delete;
203   if ( $error ) {
204     $dbh->rollback if $oldAutoCommit;
205     return $error;
206   }
207
208   $dbh->commit or die $dbh->errstr if $oldAutoCommit;
209   '';
210
211 }
212
213 =item replace OLD_RECORD
214
215 Replaces the OLD_RECORD with this one in the database.  If there is an error,
216 returns the error, otherwise returns false.
217
218 =cut
219
220 sub replace {
221   my $self = shift;
222
223   local $SIG{INT} = 'IGNORE';
224   local $SIG{QUIT} = 'IGNORE';
225   local $SIG{TERM} = 'IGNORE';
226   local $SIG{TSTP} = 'IGNORE';
227   local $SIG{PIPE} = 'IGNORE';
228
229   my $oldAutoCommit = $FS::UID::AutoCommit;
230   local $FS::UID::AutoCommit = 0;
231   my $dbh = dbh;
232
233   my $error = $self->SUPER::replace(@_);
234   if ( $error ) {
235     $dbh->rollback if $oldAutoCommit;
236     return $error;
237   }
238
239   foreach my $pf ( grep { /^phonetypenum(\d+)$/ && $self->get($_) }
240                         keys %{ $self->hashref } ) {
241     $pf =~ /^phonetypenum(\d+)$/ or die "wtf (daily, the)";
242     my $phonetypenum = $1;
243
244     my %cp = ( 'contactnum'   => $self->contactnum,
245                'phonetypenum' => $phonetypenum,
246              );
247     my $contact_phone = qsearchs('contact_phone', \%cp)
248                         || new FS::contact_phone   \%cp;
249
250     my %cpd = _parse_phonestring( $self->get($pf) );
251     $contact_phone->set( $_ => $cpd{$_} ) foreach keys %cpd;
252
253     my $method = $contact_phone->contactphonenum ? 'replace' : 'insert';
254
255     $error = $contact_phone->$method;
256     if ( $error ) {
257       $dbh->rollback if $oldAutoCommit;
258       return $error;
259     }
260   }
261
262   if ( defined($self->get('emailaddress')) ) {
263
264     #ineffecient but whatever, how many email addresses can there be?
265
266     foreach my $contact_email ( $self->contact_email ) {
267       my $error = $contact_email->delete;
268       if ( $error ) {
269         $dbh->rollback if $oldAutoCommit;
270         return $error;
271       }
272     }
273
274     foreach my $email ( split(/\s*,\s*/, $self->get('emailaddress') ) ) {
275  
276       my $contact_email = new FS::contact_email {
277         'contactnum'   => $self->contactnum,
278         'emailaddress' => $email,
279       };
280       $error = $contact_email->insert;
281       if ( $error ) {
282         $dbh->rollback if $oldAutoCommit;
283         return $error;
284       }
285
286     }
287
288   }
289
290   #unless ( $import || $skip_fuzzyfiles ) {
291     #warn "  queueing fuzzyfiles update\n"
292     #  if $DEBUG > 1;
293     $error = $self->queue_fuzzyfiles_update;
294     if ( $error ) {
295       $dbh->rollback if $oldAutoCommit;
296       return "updating fuzzy search cache: $error";
297     }
298   #}
299
300   $dbh->commit or die $dbh->errstr if $oldAutoCommit;
301
302   '';
303
304 }
305
306 #i probably belong in contact_phone.pm
307 sub _parse_phonestring {
308   my $value = shift;
309
310   my($countrycode, $extension) = ('1', '');
311
312   #countrycode
313   if ( $value =~ s/^\s*\+\s*(\d+)// ) {
314     $countrycode = $1;
315   } else {
316     $value =~ s/^\s*1//;
317   }
318   #extension
319   if ( $value =~ s/\s*(ext|x)\s*(\d+)\s*$//i ) {
320      $extension = $2;
321   }
322
323   ( 'countrycode' => $countrycode,
324     'phonenum'    => $value,
325     'extension'   => $extension,
326   );
327 }
328
329 =item queue_fuzzyfiles_update
330
331 Used by insert & replace to update the fuzzy search cache
332
333 =cut
334
335 use FS::cust_main::Search;
336 sub queue_fuzzyfiles_update {
337   my $self = shift;
338
339   local $SIG{HUP} = 'IGNORE';
340   local $SIG{INT} = 'IGNORE';
341   local $SIG{QUIT} = 'IGNORE';
342   local $SIG{TERM} = 'IGNORE';
343   local $SIG{TSTP} = 'IGNORE';
344   local $SIG{PIPE} = 'IGNORE';
345
346   my $oldAutoCommit = $FS::UID::AutoCommit;
347   local $FS::UID::AutoCommit = 0;
348   my $dbh = dbh;
349
350   foreach my $field ( 'first', 'last' ) {
351     my $queue = new FS::queue { 
352       'job' => 'FS::cust_main::Search::append_fuzzyfiles_fuzzyfield'
353     };
354     my @args = "contact.$field", $self->get($field);
355     my $error = $queue->insert( @args );
356     if ( $error ) {
357       $dbh->rollback if $oldAutoCommit;
358       return "queueing job (transaction rolled back): $error";
359     }
360   }
361
362   $dbh->commit or die $dbh->errstr if $oldAutoCommit;
363   '';
364
365 }
366
367 =item check
368
369 Checks all fields to make sure this is a valid example.  If there is
370 an error, returns the error, otherwise returns false.  Called by the insert
371 and replace methods.
372
373 =cut
374
375 # the check method should currently be supplied - FS::Record contains some
376 # data checking routines
377
378 sub check {
379   my $self = shift;
380
381   my $error = 
382     $self->ut_numbern('contactnum')
383     || $self->ut_foreign_keyn('prospectnum', 'prospect_main', 'prospectnum')
384     || $self->ut_foreign_keyn('custnum',     'cust_main',     'custnum')
385     || $self->ut_foreign_keyn('locationnum', 'cust_location', 'locationnum')
386     || $self->ut_foreign_keyn('classnum',    'contact_class', 'classnum')
387     || $self->ut_namen('last')
388     || $self->ut_namen('first')
389     || $self->ut_textn('title')
390     || $self->ut_textn('comment')
391     || $self->ut_enum('disabled', [ '', 'Y' ])
392   ;
393   return $error if $error;
394
395   return "No prospect or customer!" unless $self->prospectnum || $self->custnum;
396   return "Prospect and customer!"       if $self->prospectnum && $self->custnum;
397
398   return "One of first name, last name, or title must have a value"
399     if ! grep $self->$_(), qw( first last title);
400
401   $self->SUPER::check;
402 }
403
404 sub line {
405   my $self = shift;
406   my $data = $self->first. ' '. $self->last;
407   $data .= ', '. $self->title
408     if $self->title;
409   $data .= ' ('. $self->comment. ')'
410     if $self->comment;
411   $data;
412 }
413
414 sub cust_location {
415   my $self = shift;
416   return '' unless $self->locationnum;
417   qsearchs('cust_location', { 'locationnum' => $self->locationnum } );
418 }
419
420 sub contact_class {
421   my $self = shift;
422   return '' unless $self->classnum;
423   qsearchs('contact_class', { 'classnum' => $self->classnum } );
424 }
425
426 sub contact_classname {
427   my $self = shift;
428   my $contact_class = $self->contact_class or return '';
429   $contact_class->classname;
430 }
431
432 sub contact_phone {
433   my $self = shift;
434   qsearch('contact_phone', { 'contactnum' => $self->contactnum } );
435 }
436
437 sub contact_email {
438   my $self = shift;
439   qsearch('contact_email', { 'contactnum' => $self->contactnum } );
440 }
441
442 sub cust_main {
443   my $self = shift;
444   qsearchs('cust_main', { 'custnum' => $self->custnum  } );
445 }
446
447 =back
448
449 =head1 BUGS
450
451 =head1 SEE ALSO
452
453 L<FS::Record>, schema.html from the base documentation.
454
455 =cut
456
457 1;
458