1: <?php
  2: /**
  3:  * Copyright 2009-2014 Horde LLC (http://www.horde.org/)
  4:  *
  5:  * See the enclosed file COPYING for license information (GPL). If you
  6:  * did not receive this file, see http://www.horde.org/licenses/gpl.
  7:  *
  8:  * @category  Horde
  9:  * @copyright 2009-2014 Horde LLC
 10:  * @license   http://www.horde.org/licenses/gpl GPL
 11:  * @package   IMP
 12:  */
 13: 
 14: /**
 15:  * Login system task for automated upgrade tasks.
 16:  *
 17:  * @author    Michael Slusarz <slusarz@horde.org>
 18:  * @category  Horde
 19:  * @copyright 2009-2014 Horde LLC
 20:  * @license   http://www.horde.org/licenses/gpl GPL
 21:  * @package   IMP
 22:  */
 23: class IMP_LoginTasks_SystemTask_Upgrade extends Horde_Core_LoginTasks_SystemTask_Upgrade
 24: {
 25:     /**
 26:      */
 27:     protected $_app = 'imp';
 28: 
 29:     /**
 30:      */
 31:     protected $_versions = array(
 32:         '5.0',
 33:         '6.0',
 34:         '6.1'
 35:     );
 36: 
 37:     /**
 38:      */
 39:     protected function _upgrade($version)
 40:     {
 41:         switch ($version) {
 42:         case '5.0':
 43:             $this->_upgradeAbookPrefs();
 44:             $this->_upgradeComposePrefs();
 45:             $this->_upgradeDeleteAttachmentsMonthlyPrefs();
 46:             $this->_upgradeDeleteSentmailMonthlyPrefs();
 47:             $this->_upgradeForwardPrefs();
 48:             $this->_upgradeLoginTasksPrefs();
 49:             $this->_upgradeMsgDisplayPrefs();
 50:             $this->_upgradeNewmailPrefs();
 51:             $this->_upgradePurgeSentmailPrefs();
 52:             $this->_upgradePurgeSpamPrefs();
 53:             $this->_upgradePurgeTrashPrefs();
 54:             $this->_upgradeSortPrefs();
 55:             $this->_upgradeStationery();
 56:             $this->_upgradeVirtualFolders();
 57:             break;
 58: 
 59:         case '6.0':
 60:             $this->_upgradeComposeCursor();
 61:             $this->_upgradeInnocentPrefs();
 62:             $this->_upgradeMailboxPrefs();
 63:             $this->_upgradeSaveAttachments();
 64:             $this->_upgradeStationeryToTemplates();
 65:             $this->_upgradeVirtualFolders6();
 66:             break;
 67: 
 68:         case '6.1':
 69:             $this->_upgradeComposePrefs61();
 70:             $this->_upgradeRequestMdn();
 71:             break;
 72:         }
 73:     }
 74: 
 75:     /**
 76:      * Upgrade to the new addressbook preferences.
 77:      */
 78:     protected function _upgradeAbookPrefs()
 79:     {
 80:         global $prefs;
 81: 
 82:         if (!$prefs->isDefault('search_sources')) {
 83:             $src = $prefs->getValue('search_sources');
 84:             if (!is_array(json_decode($src))) {
 85:                 $prefs->setValue('search_sources', json_encode(explode("\t", $src)));
 86:             }
 87:         }
 88: 
 89:         if (!$prefs->isDefault('search_fields')) {
 90:             $val = $prefs->getValue('search_fields');
 91:             if (!is_array(json_decode($val, true))) {
 92:                 $fields = array();
 93:                 foreach (explode("\n", $val) as $field) {
 94:                     $field = trim($field);
 95:                     if (!empty($field)) {
 96:                         $tmp = explode("\t", $field);
 97:                         if (count($tmp) > 1) {
 98:                             $source = array_splice($tmp, 0, 1);
 99:                             $fields[$source[0]] = $tmp;
100:                         }
101:                     }
102:                 }
103:                 $prefs->setValue('search_fields', json_encode($fields));
104:             }
105:         }
106:     }
107: 
108:     /**
109:      * Upgrade to the new compose preferences.
110:      */
111:     protected function _upgradeComposePrefs()
112:     {
113:         global $prefs;
114: 
115:         if ($prefs->isDefault('request_mdn') &&
116:             ($val = $prefs->getValue('disposition_request_read'))) {
117:             $prefs->setValue('request_mdn', $val);
118:         }
119:     }
120: 
121:     /**
122:      * 'delete_attachments_monthly' no longer exists -> use
123:      * 'delete_attachments_monthly_keep' instead.
124:      */
125:     protected function _upgradeDeleteAttachmentsMonthlyPrefs()
126:     {
127:         global $prefs;
128: 
129:         if (!$prefs->getValue('delete_attachments_monthly') &&
130:             ($prefs->getDefault('delete_attachments_monthly') !== null)) {
131:             $prefs->setValue('delete_attachments_monthly_keep', 0);
132:         }
133: 
134:         // Need to remove old pref or else there can be no way of determining
135:         // whether upgrade has previously occurred.
136:         $prefs->remove('delete_attachments_monthly');
137:     }
138: 
139:     /**
140:      * 'delete_sentmail_monthly' no longer exists -> use
141:      * 'delete_sentmail_monthly_keep' instead.
142:      */
143:     protected function _upgradeDeleteSentmailMonthlyPrefs()
144:     {
145:         global $prefs;
146: 
147:         if (!$prefs->getValue('delete_sentmail_monthly') &&
148:             ($prefs->getDefault('delete_sentmail_monthly') !== null)) {
149:             $prefs->setValue('delete_sentmail_monthly_keep', 0);
150:         }
151: 
152:         // Need to remove old pref or else there can be no way of determining
153:         // whether upgrade has previously occurred.
154:         $prefs->remove('delete_sentmail_monthly');
155:     }
156: 
157:     /**
158:      * Upgrade to the new forward preferences.
159:      */
160:     protected function _upgradeForwardPrefs()
161:     {
162:         global $prefs;
163: 
164:         if ($prefs->isDefault('forward_default')) {
165:             return;
166:         }
167: 
168:         switch ($prefs->getValue('forward_default')) {
169:         case 'forward_attachments':
170:             $prefs->setValue('forward_default', 'both');
171:             break;
172: 
173:         case 'forward_all':
174:             $prefs->setValue('forward_default', 'attach');
175:             break;
176: 
177:         case 'forward_body':
178:             $prefs->setValue('forward_default', 'body');
179:             break;
180: 
181:         case 'attach':
182:         case 'body':
183:         case 'both':
184:             // Ignore - already converted.
185:             break;
186: 
187:         default:
188:             $prefs->setValue('forward_default', 'attach');
189:             break;
190:         }
191:     }
192: 
193:     /**
194:      * Upgrade to the new login tasks preferences.
195:      */
196:     protected function _upgradeLoginTasksPrefs()
197:     {
198:         global $prefs;
199: 
200:         $replace = $prefs->getValue('html_image_replacement');
201:         if (!is_null($replace) && !$replace) {
202:             $prefs->setValue('image_replacement', 0);
203:         }
204: 
205:         $addrbook = $prefs->getValue('html_image_addrbook');
206:         if (!is_null($addrbook) && !$addrbook) {
207:             $prefs->setValue('image_addrbook', 0);
208:         }
209:     }
210: 
211:     /**
212:      * Upgrade to the new message display preferences.
213:      */
214:     protected function _upgradeMsgDisplayPrefs()
215:     {
216:         global $prefs;
217: 
218:         if (!$prefs->isDefault('initial_page')) {
219:             if ($prefs->getValue('initial_page') == 'folders.php') {
220:                 $prefs->setValue('initial_page', IMP::INITIAL_FOLDERS);
221:             } elseif (strpos($prefs->getValue('initial_page'), '**search_') === 0) {
222:                 /* No easy way to convert old virtual folder label to new
223:                  * label, so revert to default. */
224:                 $prefs->remove('initial_page');
225:             }
226:         }
227: 
228:         if ($prefs->isDefault('send_mdn') &&
229:             $prefs->getValue('disposition_send_mdn')) {
230:             $prefs->setValue('send_mdn', 1);
231:         }
232:     }
233: 
234:     /**
235:      * Upgrade to the new newmail preferences.
236:      */
237:     protected function _upgradeNewmailPrefs()
238:     {
239:         global $prefs;
240: 
241:         if ($prefs->isDefault('newmail_notify') &&
242:             $prefs->getValue('nav_popup')) {
243:             $prefs->setValue('newmail_notify', 1);
244:         }
245: 
246:         if ($prefs->getValue('newmail_notify') &&
247:             $prefs->isDefault('newmail_audio') &&
248:             ($nav_audio = $prefs->getValue('nav_audio'))) {
249:             $prefs->setValue('newmail_audio', $nav_audio);
250:         }
251:     }
252: 
253:     /**
254:      * 'purge_sentmail' no longer exists -> use 'purge_sentmail_interval'
255:      * instead.
256:      */
257:     protected function _upgradePurgeSentmailPrefs()
258:     {
259:         global $prefs;
260: 
261:         if (!$prefs->getValue('purge_sentmail') &&
262:             ($prefs->getDefault('purge_sentmail') !== null)) {
263:             $prefs->remove('purge_sentmail_interval');
264:         }
265: 
266:         // Need to remove old pref or else there can be no way of determining
267:         // whether upgrade has previously occurred.
268:         $prefs->remove('purge_sentmail');
269:     }
270: 
271:     /**
272:      * 'purge_spam' no longer exists -> use 'purge_spam_interval' instead.
273:      */
274:     protected function _upgradePurgeSpamPrefs()
275:     {
276:         global $prefs;
277: 
278:         if (!$prefs->getValue('purge_spam') &&
279:             ($prefs->getDefault('purge_spam') !== null)) {
280:             $prefs->remove('purge_spam_interval');
281:         }
282: 
283:         // Need to remove old pref or else there can be no way of determining
284:         // whether upgrade has previously occurred.
285:         $prefs->remove('purge_spam');
286:     }
287: 
288:     /**
289:      * 'purge_trash' no longer exists -> use 'purge_trash_interval' instead.
290:      */
291:     protected function _upgradePurgeTrashPrefs()
292:     {
293:         global $prefs;
294: 
295:         if (!$prefs->getValue('purge_trash') &&
296:             ($prefs->getDefault('purge_trash') !== null)) {
297:             $prefs->remove('purge_trash_interval');
298:         }
299: 
300:         // Need to remove old pref or else there can be no way of determining
301:         // whether upgrade has previously occurred.
302:         $prefs->remove('purge_trash');
303:     }
304: 
305:     /**
306:      * Check for old, non-existent sort values. See Bug #7296.
307:      */
308:     protected function _upgradeSortPrefs()
309:     {
310:         global $injector, $prefs;
311: 
312:         $sort_ob = $injector->getInstance('IMP_Prefs_Sort');
313:         $sort_ob->upgradePrefs();
314: 
315:         if (!$prefs->isDefault('sortby')) {
316:             $sb = $sort_ob->newSortbyValue($prefs->getValue('sortby'));
317:             if (!is_null($sb)) {
318:                 $prefs->setValue('sortby', $sb);
319:             }
320:         }
321:     }
322: 
323:     /**
324:      * Upgrade stationery preference.
325:      */
326:     protected function _upgradeStationery()
327:     {
328:         $upgrade_prefs = array(
329:             'stationery'
330:         );
331: 
332:         $GLOBALS['injector']->getInstance('Horde_Core_Prefs_Storage_Upgrade')->upgradeSerialized($GLOBALS['prefs'], $upgrade_prefs);
333:     }
334: 
335:     /**
336:      * Upgrade IMP 4 style virtual folders.
337:      */
338:     protected function _upgradeVirtualFolders()
339:     {
340:         global $prefs;
341: 
342:         $use_vinbox = $prefs->getValue('use_vinbox');
343:         $use_vtrash = $prefs->getValue('use_vtrash');
344: 
345:         $vfolders = $prefs->getValue('vfolder');
346:         if (!empty($vfolders)) {
347:             $vfolders = @unserialize($vfolders);
348:         }
349: 
350:         if (empty($vfolders) || !is_array($vfolders)) {
351:             return;
352:         }
353: 
354:         if ($prefs->isDefault('vfolder') || is_object(reset($vfolders))) {
355:             foreach ($vfolders as $val) {
356:                 if (!is_null($use_vinbox) &&
357:                     ($val instanceof IMP_Search_Vfolder_Vinbox)) {
358:                     $val->enabled = (bool)$use_vinbox;
359:                 } elseif (!is_null($use_vtrash) &&
360:                           ($val instanceof IMP_Search_Vfolder_Vtrash)) {
361:                     $val->enabled = (bool)$use_vtrash;
362:                     if ($use_vtrash) {
363:                         $prefs->setValue('trash_folder', strval($val));
364:                     }
365:                 }
366:             }
367:             $prefs->setValue('vfolder', serialize($vfolders));
368:             return;
369:         }
370: 
371:         $new_vfolders = array();
372:         if ($use_vinbox) {
373:             $new_vfolders[] = new IMP_Search_Vfolder_Vinbox();
374:         }
375:         if ($use_vtrash) {
376:             $vtrash = $new_vfolders[] = new IMP_Search_Vfolder_Vtrash();
377:             $prefs->setValue('trash_folder', strval($vtrash));
378:         }
379: 
380:         foreach ($vfolders as $vfolder) {
381:             $ui = $vfolder['uiinfo'];
382: 
383:             $or_match = ($ui['match'] == 'or');
384: 
385:             /* BC: Convert old (IMP < 4.2.1) style w/separate flag entry to
386:              * new style where flags are part of the fields to query. */
387:             if (!empty($ui['flag'])) {
388:                 $lookup = array(
389:                     1 => 'seen',
390:                     2 => 'answered',
391:                     3 => 'flagged',
392:                     4 => 'deleted'
393:                 );
394: 
395:                 foreach ($ui['flag'] as $key => $val) {
396:                     if (($val == 0) || ($val == 1)) {
397:                         $ui['field'][] = (($val == 1) ? 'un' : '') . $lookup[$key];
398:                     }
399:                 }
400:             }
401: 
402:             foreach ($ui['field'] as $key => $val) {
403:                 $ob = new IMP_Search_Vfolder(array(
404:                     'enabled' => true,
405:                     'label' => $ui['vfolder_label'],
406:                     'mboxes' => $ui['folders']
407:                 ));
408: 
409:                 switch ($val) {
410:                 case 'from':
411:                 case 'cc':
412:                 case 'bcc':
413:                 case 'subject':
414:                     $ob->add(new IMP_Search_Element_Header(
415:                         $ui['text'][$key],
416:                         $val,
417:                         !empty($ui['text_not'][$key])
418:                     ));
419:                     break;
420: 
421:                 case 'to':
422:                     $ob->add(new IMP_Search_Element_Recipient(
423:                         $val,
424:                         !empty($ui['text_not'][$key])
425:                     ));
426:                     break;
427: 
428:                 case 'body':
429:                 case 'text':
430:                     $ob->add(new IMP_Search_Element_Text(
431:                         $ui['text'][$key],
432:                         ($val == 'body'),
433:                         !empty($ui['text_not'][$key])
434:                     ));
435:                     break;
436: 
437:                 case 'date_on':
438:                 case 'date_until':
439:                 case 'date_since':
440:                     $d = new DateTime(
441:                         $ui['date'][$key]['year'] . '-' . $ui['date'][$key]['month'] . '-' . $ui['date'][$key]['day']
442:                     );
443: 
444:                     if ($val == 'date_on') {
445:                         $ob->add(new IMP_Search_Element_Daterange($d, $d));
446:                     } elseif ($val == 'date_until') {
447:                         $ob->add(new IMP_Search_Element_Daterange(null, $d));
448:                     } else {
449:                         $ob->add(new IMP_Search_Element_Daterange($d, null));
450:                     }
451:                     break;
452: 
453:                 case 'size_smaller':
454:                 case 'size_larger':
455:                     $ob->add(new IMP_Search_Element_Size(
456:                         $ui['text'][$key],
457:                         $val == 'size_larger'
458:                     ));
459:                     break;
460: 
461:                 case 'seen':
462:                 case 'unseen':
463:                 case 'answered':
464:                 case 'unanswered':
465:                 case 'flagged':
466:                 case 'unflagged':
467:                 case 'deleted':
468:                 case 'undeleted':
469:                     if (strpos($val, 'un') === false) {
470:                         $ob->add(new IMP_Search_Element_Flag(
471:                             $val,
472:                             true
473:                         ));
474:                     } else {
475:                         $ob->add(new IMP_Search_Element_Flag(
476:                             substr($val, 2),
477:                             false
478:                         ));
479:                     }
480:                     break;
481:                 }
482: 
483:                 if ($or_match) {
484:                     $ob->add(new IMP_Search_Element_Or());
485:                 }
486:             }
487: 
488:             $new_vfolders[] = $ob;
489:         }
490: 
491:         $GLOBALS['injector']->getInstance('IMP_Search')->setVFolders($new_vfolders);
492:     }
493: 
494:     /**
495:      * Upgrades the 'compose_cursor' preference (IMP 6).
496:      */
497:     protected function _upgradeComposeCursor()
498:     {
499:         global $prefs;
500: 
501:         if ($prefs->getValue('compose_cursor') == 'sig') {
502:             $prefs->setValue('compose_cursor', 'bottom');
503:         }
504:     }
505: 
506:     /**
507:      * Upgrades the 'move_ham_after_report' preference (IMP 6).
508:      */
509:     protected function _upgradeInnocentPrefs()
510:     {
511:         global $prefs;
512: 
513:         if (!$prefs->isDefault('move_ham_after_report')) {
514:             $prefs->setValue('move_innocent_after_report', $prefs->getValue('move_ham_after_report'));
515:         }
516:     }
517: 
518:     /**
519:      * As of IMP 6, special mailboxes are stored in UTF-8, not UTF7-IMAP.
520:      */
521:     protected function _upgradeMailboxPrefs()
522:     {
523:         global $injector, $prefs;
524: 
525:         $special_mboxes = array(
526:             'drafts_folder',
527:             'spam_folder',
528:             'trash_folder'
529:         );
530: 
531:         foreach ($special_mboxes as $val) {
532:             if (!$prefs->isDefault($val)) {
533:                 $old_pref = strval(IMP_Mailbox::getPref($val));
534:                 if (!Horde_Mime::is8bit($old_pref, 'UTF-8')) {
535:                     $mbox = IMP_Mailbox::get(Horde_String::convertCharset($old_pref, 'UTF7-IMAP', 'UTF-8'));
536:                     $prefs->setValue($val, $old_pref->$mbox->pref_to);
537:                 }
538:             }
539:         }
540: 
541:         $imp_identity = $injector->getInstance('IMP_Identity');
542: 
543:         foreach ($imp_identity->getAll('sent_mail_folder') as $key => $val) {
544:             if (!is_null($val) && !Horde_Mime::is8bit($val, 'UTF-8')) {
545:                 $mbox = IMP_Mailbox::get(Horde_String::convertCharset(strval($val), 'UTF7-IMAP', 'UTF-8'));
546:                 $imp_identity->setValue(IMP_Mailbox::MBOX_SENT, $mbox, $key);
547:             }
548:         }
549:     }
550: 
551:     /**
552:      * For IMP 6, upgrade deprecated save_attachments preferences.
553:      */
554:     protected function _upgradeSaveAttachments()
555:     {
556:         global $prefs;
557: 
558:         switch ($prefs->getValue('save_attachments')) {
559:         case 'prompt_no':
560:             $prefs->setValue('save_attachments', 'never');
561:             break;
562: 
563:         case 'prompt_yes':
564:             $prefs->setValue('save_attachments', 'always');
565:             break;
566:         }
567:     }
568: 
569:     /**
570:      * For IMP 6, upgrade stationery preference -> templates mailbox.
571:      */
572:     protected function _upgradeStationeryToTemplates()
573:     {
574:         global $injector, $prefs;
575: 
576:         $slist = @unserialize($prefs->getValue('stationery'));
577:         if (is_array($slist)) {
578:             /* Old entry format:
579:              * 'c' => (string) Content
580:              * 'n' => (string) Name
581:              * 't' => (string) Type */
582:             foreach ($slist as $val) {
583:                 $injector->getInstance('IMP_Factory_Compose')->create()->saveTemplate(
584:                     array('subject' => $val['n']),
585:                     $val['c']
586:                 );
587:             }
588:         }
589:     }
590: 
591:     /**
592:      * Upgrade IMP 5.0.x virtual folders.
593:      */
594:     protected function _upgradeVirtualFolders6()
595:     {
596:         $imp_search = $GLOBALS['injector']->getInstance('IMP_Search');
597:         $iterator = IMP_Search_IteratorFilter::create(
598:             IMP_Search_IteratorFilter::VFOLDER |
599:             IMP_Search_IteratorFilter::DISABLED
600:         );
601: 
602:         foreach ($iterator as $val) {
603:             $replace = false;
604:             $tmp = $val->query;
605: 
606:             foreach (array_keys($tmp) as $key2) {
607:                 if ($tmp[$key2] instanceof IMP_Search_Element_Date) {
608:                     $criteria = $tmp[$key2]->data;
609: 
610:                     switch ($criteria->t) {
611:                     case IMP_Search_Element_Date::DATE_ON:
612:                         $ob = new IMP_Search_Element_Daterange(
613:                             new DateTime('@' . $criteria->d),
614:                             new DateTime('@' . $criteria->d)
615:                         );
616:                         break;
617: 
618:                     case IMP_Search_Element_Date::DATE_BEFORE:
619:                         $ob = new IMP_Search_Element_Daterange(
620:                             null,
621:                             new DateTime('@' . $criteria->d)
622:                         );
623:                         break;
624: 
625:                     case IMP_Search_Element_Date::DATE_SINCE:
626:                         $ob = new IMP_Search_Element_Daterange(
627:                             new DateTime('@' . $criteria->d),
628:                             null
629:                         );
630:                         break;
631:                     }
632: 
633:                     $tmp[$key2] = $ob;
634:                     $replace = true;
635:                 }
636:             }
637: 
638:             if ($replace) {
639:                 $val->replace($tmp);
640:                 $imp_search[$val->id] = $val;
641:             }
642:         }
643:     }
644: 
645:     /**
646:      * IMP 6.1: Upgrade compose preferences.
647:      */
648:     protected function _upgradeComposePrefs61()
649:     {
650:         global $prefs;
651: 
652:         $prefs->remove('compose_bcc');
653:         $prefs->remove('compose_cc');
654:     }
655: 
656:     /**
657:      * IMP 6.1: Upgrade from removed 'ask' option for 'request_mdn' pref.
658:      */
659:     protected function _upgradeRequestMdn()
660:     {
661:         global $prefs;
662: 
663:         if ($prefs->getValue('request_mdn') == 'ask') {
664:             $prefs->remove('request_mdn');
665:         }
666:     }
667: 
668: }
669: 
670: /**
671:  * @internal
672:  */
673: class IMP_Search_Element_Date implements Serializable
674: {
675:     const DATE_ON = 1;
676:     const DATE_BEFORE = 2;
677:     const DATE_SINCE = 3;
678: 
679:     /* Data element:
680:      * d = (integer) UNIX timestamp.
681:      * t = (integer) Type: one of the self::DATE_* constants. */
682:     public $data;
683: 
684:     public function serialize()
685:     {
686:         return '';
687:     }
688: 
689:     public function unserialize($data)
690:     {
691:         $this->data = json_decode($data);
692:     }
693: 
694: }
695: