1: <?php
  2: /**
  3:  * Login system task for automated upgrade tasks.
  4:  *
  5:  * Copyright 2009-2012 Horde LLC (http://www.horde.org/)
  6:  *
  7:  * See the enclosed file COPYING for license information (GPL). If you
  8:  * did not receive this file, see http://www.horde.org/licenses/gpl.
  9:  *
 10:  * @author   Michael Slusarz <slusarz@horde.org>
 11:  * @category Horde
 12:  * @license  http://www.horde.org/licenses/gpl GPL
 13:  * @package  IMP
 14:  */
 15: class IMP_LoginTasks_SystemTask_Upgrade extends Horde_Core_LoginTasks_SystemTask_Upgrade
 16: {
 17:     /**
 18:      */
 19:     protected $_app = 'imp';
 20: 
 21:     /**
 22:      */
 23:     protected $_versions = array(
 24:         '5.0'
 25:     );
 26: 
 27:     /**
 28:      */
 29:     protected function _upgrade($version)
 30:     {
 31:         switch ($version) {
 32:         case '5.0':
 33:             $this->_upgradeAbookPrefs();
 34:             $this->_upgradeComposePrefs();
 35:             $this->_upgradeDeleteAttachmentsMonthlyPrefs();
 36:             $this->_upgradeDeleteSentmailMonthlyPrefs();
 37:             $this->_upgradeForwardPrefs();
 38:             $this->_upgradeLoginTasksPrefs();
 39:             $this->_upgradeMsgDisplayPrefs();
 40:             $this->_upgradeNewmailPrefs();
 41:             $this->_upgradePurgeSentmailPrefs();
 42:             $this->_upgradePurgeSpamPrefs();
 43:             $this->_upgradePurgeTrashPrefs();
 44:             $this->_upgradeSortPrefs();
 45:             $this->_upgradeStationery();
 46:             $this->_upgradeVirtualFolders();
 47:             break;
 48:         }
 49:     }
 50: 
 51:     /**
 52:      * Upgrade to the new addressbook preferences.
 53:      */
 54:     protected function _upgradeAbookPrefs()
 55:     {
 56:         global $prefs;
 57: 
 58:         if (!$prefs->isDefault('search_sources')) {
 59:             $src = $prefs->getValue('search_sources');
 60:             if (!is_array(json_decode($src))) {
 61:                 $prefs->setValue('search_sources', json_encode(explode("\t", $src)));
 62:             }
 63:         }
 64: 
 65:         if (!$prefs->isDefault('search_fields')) {
 66:             $val = $prefs->getValue('search_fields');
 67:             if (!is_array(json_decode($val, true))) {
 68:                 $fields = array();
 69:                 foreach (explode("\n", $val) as $field) {
 70:                     $field = trim($field);
 71:                     if (!empty($field)) {
 72:                         $tmp = explode("\t", $field);
 73:                         if (count($tmp) > 1) {
 74:                             $source = array_splice($tmp, 0, 1);
 75:                             $fields[$source[0]] = $tmp;
 76:                         }
 77:                     }
 78:                 }
 79:                 $prefs->setValue('search_fields', json_encode($fields));
 80:             }
 81:         }
 82:     }
 83: 
 84:     /**
 85:      * Upgrade to the new compose preferences.
 86:      */
 87:     protected function _upgradeComposePrefs()
 88:     {
 89:         global $prefs;
 90: 
 91:         if ($prefs->isDefault('request_mdn') &&
 92:             ($val = $prefs->getValue('disposition_request_read'))) {
 93:             $prefs->setValue('request_mdn', $val);
 94:         }
 95:     }
 96: 
 97:     /**
 98:      * 'delete_attachments_monthly' no longer exists -> use
 99:      * 'delete_attachments_monthly_keep' instead.
100:      */
101:     protected function _upgradeDeleteAttachmentsMonthlyPrefs()
102:     {
103:         global $prefs;
104: 
105:         if (!$prefs->getValue('delete_attachments_monthly') &&
106:             ($prefs->getDefault('delete_attachments_monthly') !== null)) {
107:             $prefs->setValue('delete_attachments_monthly_keep', 0);
108:         }
109: 
110:         // Need to remove old pref or else there can be no way of determining
111:         // whether upgrade has previously occurred.
112:         $prefs->remove('delete_attachments_monthly');
113:     }
114: 
115:     /**
116:      * 'delete_sentmail_monthly' no longer exists -> use
117:      * 'delete_sentmail_monthly_keep' instead.
118:      */
119:     protected function _upgradeDeleteSentmailMonthlyPrefs()
120:     {
121:         global $prefs;
122: 
123:         if (!$prefs->getValue('delete_sentmail_monthly') &&
124:             ($prefs->getDefault('delete_sentmail_monthly') !== null)) {
125:             $prefs->setValue('delete_sentmail_monthly_keep', 0);
126:         }
127: 
128:         // Need to remove old pref or else there can be no way of determining
129:         // whether upgrade has previously occurred.
130:         $prefs->remove('delete_sentmail_monthly');
131:     }
132: 
133:     /**
134:      * Upgrade to the new forward preferences.
135:      */
136:     protected function _upgradeForwardPrefs()
137:     {
138:         global $prefs;
139: 
140:         if ($prefs->isDefault('forward_default')) {
141:             return;
142:         }
143: 
144:         switch ($prefs->getValue('forward_default')) {
145:         case 'forward_attachments':
146:             $prefs->setValue('forward_default', 'both');
147:             break;
148: 
149:         case 'forward_all':
150:             $prefs->setValue('forward_default', 'attach');
151:             break;
152: 
153:         case 'forward_body':
154:             $prefs->setValue('forward_default', 'body');
155:             break;
156: 
157:         case 'attach':
158:         case 'body':
159:         case 'both':
160:             // Ignore - already converted.
161:             break;
162: 
163:         default:
164:             $prefs->setValue('forward_default', 'attach');
165:             break;
166:         }
167:     }
168: 
169:     /**
170:      * Upgrade to the new login tasks preferences.
171:      */
172:     protected function _upgradeLoginTasksPrefs()
173:     {
174:         global $prefs;
175: 
176:         $replace = $prefs->getValue('html_image_replacement');
177:         if (!is_null($replace) && !$replace) {
178:             $prefs->setValue('image_replacement', 0);
179:         }
180: 
181:         $addrbook = $prefs->getValue('html_image_addrbook');
182:         if (!is_null($addrbook) && !$addrbook) {
183:             $prefs->setValue('image_addrbook', 0);
184:         }
185:     }
186: 
187:     /**
188:      * Upgrade to the new message display preferences.
189:      */
190:     protected function _upgradeMsgDisplayPrefs()
191:     {
192:         global $prefs;
193: 
194:         if (!$prefs->isDefault('initial_page')) {
195:             if ($prefs->getValue('initial_page') == 'folders.php') {
196:                 $prefs->setValue('initial_page', IMP::INITIAL_FOLDERS);
197:             } elseif (strpos($prefs->getValue('initial_page'), '**search_') === 0) {
198:                 /* No easy way to convert old virtual folder label to new
199:                  * label, so revert to default. */
200:                 $prefs->remove('initial_page');
201:             }
202:         }
203: 
204:         if ($prefs->isDefault('send_mdn') &&
205:             $prefs->getValue('disposition_send_mdn')) {
206:             $prefs->setValue('send_mdn', 1);
207:         }
208:     }
209: 
210:     /**
211:      * Upgrade to the new newmail preferences.
212:      */
213:     protected function _upgradeNewmailPrefs()
214:     {
215:         global $prefs;
216: 
217:         if ($prefs->isDefault('newmail_notify') &&
218:             $prefs->getValue('nav_popup')) {
219:             $prefs->setValue('newmail_notify', 1);
220:         }
221: 
222:         if ($prefs->getValue('newmail_notify') &&
223:             $prefs->isDefault('newmail_audio') &&
224:             ($nav_audio = $prefs->getValue('nav_audio'))) {
225:             $prefs->setValue('newmail_audio', $nav_audio);
226:         }
227:     }
228: 
229:     /**
230:      * 'purge_sentmail' no longer exists -> use 'purge_sentmail_interval'
231:      * instead.
232:      */
233:     protected function _upgradePurgeSentmailPrefs()
234:     {
235:         global $prefs;
236: 
237:         if (!$prefs->getValue('purge_sentmail') &&
238:             ($prefs->getDefault('purge_sentmail') !== null)) {
239:             $prefs->remove('purge_sentmail_interval');
240:         }
241: 
242:         // Need to remove old pref or else there can be no way of determining
243:         // whether upgrade has previously occurred.
244:         $prefs->remove('purge_sentmail');
245:     }
246: 
247:     /**
248:      * 'purge_spam' no longer exists -> use 'purge_spam_interval' instead.
249:      */
250:     protected function _upgradePurgeSpamPrefs()
251:     {
252:         global $prefs;
253: 
254:         if (!$prefs->getValue('purge_spam') &&
255:             ($prefs->getDefault('purge_spam') !== null)) {
256:             $prefs->remove('purge_spam_interval');
257:         }
258: 
259:         // Need to remove old pref or else there can be no way of determining
260:         // whether upgrade has previously occurred.
261:         $prefs->remove('purge_spam');
262:     }
263: 
264:     /**
265:      * 'purge_trash' no longer exists -> use 'purge_trash_interval' instead.
266:      */
267:     protected function _upgradePurgeTrashPrefs()
268:     {
269:         global $prefs;
270: 
271:         if (!$prefs->getValue('purge_trash') &&
272:             ($prefs->getDefault('purge_trash') !== null)) {
273:             $prefs->remove('purge_trash_interval');
274:         }
275: 
276:         // Need to remove old pref or else there can be no way of determining
277:         // whether upgrade has previously occurred.
278:         $prefs->remove('purge_trash');
279:     }
280: 
281:     /**
282:      * Check for old, non-existent sort values. See Bug #7296.
283:      */
284:     protected function _upgradeSortPrefs()
285:     {
286:         global $prefs;
287: 
288:         if (!$prefs->isDefault('sortpref')) {
289:             $update = false;
290:             $sortpref = @unserialize($prefs->getValue('sortpref'));
291:             foreach ($sortpref as $key => $val) {
292:                 $sb = $this->_newSortbyValue($val['b']);
293:                 if (!is_null($sb)) {
294:                     $sortpref[$key]['b'] = $sb;
295:                     $update = true;
296:                 }
297:             }
298: 
299:             if ($update) {
300:                 $prefs->setValue('sortpref', serialize($sortpref));
301:             }
302:         }
303: 
304:         if (!$prefs->isDefault('sortby')) {
305:             $sb = $this->_newSortbyValue($prefs->getValue('sortby'));
306:             if (!is_null($sb)) {
307:                 $prefs->setValue('sortby', $sb);
308:             }
309:         }
310:     }
311: 
312:     /**
313:      * Get the new sortby pref value.
314:      *
315:      * @param integer $sortby  The old value.
316:      *
317:      * @return integer  Null if no change or else the converted sort value.
318:      */
319:     protected function _newSortbyValue($sortby)
320:     {
321:         switch ($sortby) {
322:         case 1: // SORTARRIVAL
323:             /* Sortarrival was the same thing as sequence sort in IMP 4. */
324:             return Horde_Imap_Client::SORT_SEQUENCE;
325: 
326:         case 2: // SORTDATE
327:             return IMP::IMAP_SORT_DATE;
328: 
329:         case 161: // SORTTHREAD
330:             return Horde_Imap_Client::SORT_THREAD;
331:         }
332: 
333:         return null;
334:     }
335: 
336:     /**
337:      * Upgrade stationery preference.
338:      */
339:     protected function _upgradeStationery()
340:     {
341:         $upgrade_prefs = array(
342:             'stationery'
343:         );
344: 
345:         $GLOBALS['injector']->getInstance('Horde_Core_Prefs_Storage_Upgrade')->upgradeSerialized($GLOBALS['prefs'], $upgrade_prefs);
346:     }
347: 
348:     /**
349:      * Upgrade IMP 4 style virtual folders.
350:      */
351:     protected function _upgradeVirtualFolders()
352:     {
353:         global $prefs;
354: 
355:         $use_vinbox = $prefs->getValue('use_vinbox');
356:         $use_vtrash = $prefs->getValue('use_vtrash');
357: 
358:         $vfolders = $prefs->getValue('vfolder');
359:         if (!empty($vfolders)) {
360:             $vfolders = @unserialize($vfolders);
361:         }
362: 
363:         if (empty($vfolders) || !is_array($vfolders)) {
364:             return;
365:         }
366: 
367:         if ($prefs->isDefault('vfolder') || is_object(reset($vfolders))) {
368:             foreach ($vfolders as $val) {
369:                 if (!is_null($use_vinbox) &&
370:                     ($val instanceof IMP_Search_Vfolder_Vinbox)) {
371:                     $val->enabled = (bool)$use_vinbox;
372:                 } elseif (!is_null($use_vtrash) &&
373:                           ($val instanceof IMP_Search_Vfolder_Vtrash)) {
374:                     $val->enabled = (bool)$use_vtrash;
375:                     if ($use_vtrash) {
376:                         $prefs->setValue('trash_folder', strval($val));
377:                     }
378:                 }
379:             }
380:             $prefs->setValue('vfolder', serialize($vfolders));
381:             return;
382:         }
383: 
384:         $new_vfolders = array();
385:         if ($use_vinbox) {
386:             $new_vfolders[] = new IMP_Search_Vfolder_Vinbox();
387:         }
388:         if ($use_vtrash) {
389:             $vtrash = $new_vfolders[] = new IMP_Search_Vfolder_Vtrash();
390:             $prefs->setValue('trash_folder', strval($vtrash));
391:         }
392: 
393:         foreach ($vfolders as $id => $vfolder) {
394:             $ui = $vfolder['uiinfo'];
395: 
396:             $or_match = ($ui['match'] == 'or');
397: 
398:             /* BC: Convert old (IMP < 4.2.1) style w/separate flag entry to
399:              * new style where flags are part of the fields to query. */
400:             if (!empty($ui['flag'])) {
401:                 $lookup = array(
402:                     1 => 'seen',
403:                     2 => 'answered',
404:                     3 => 'flagged',
405:                     4 => 'deleted'
406:                 );
407: 
408:                 foreach ($ui['flag'] as $key => $val) {
409:                     if (($val == 0) || ($val == 1)) {
410:                         $ui['field'][] = (($val == 1) ? 'un' : '') . $lookup[$key];
411:                     }
412:                 }
413:             }
414: 
415:             foreach ($ui['field'] as $key => $val) {
416:                 $ob = new IMP_Search_Vfolder(array(
417:                     'enabled' => true,
418:                     'label' => $ui['vfolder_label'],
419:                     'mboxes' => $ui['folders']
420:                 ));
421: 
422:                 switch ($val) {
423:                 case 'from':
424:                 case 'cc':
425:                 case 'bcc':
426:                 case 'subject':
427:                     $ob->add(new IMP_Search_Element_Header(
428:                         $ui['text'][$key],
429:                         $val,
430:                         !empty($ui['text_not'][$key])
431:                     ));
432:                     break;
433: 
434:                 case 'to':
435:                     $ob->add(new IMP_Search_Element_Recipient(
436:                         $val,
437:                         !empty($ui['text_not'][$key])
438:                     ));
439:                     break;
440: 
441:                 case 'body':
442:                 case 'text':
443:                     $ob->add(new IMP_Search_Element_Text(
444:                         $ui['text'][$key],
445:                         ($val == 'body'),
446:                         !empty($ui['text_not'][$key])
447:                     ));
448:                     break;
449: 
450:                 case 'date_on':
451:                 case 'date_until':
452:                 case 'date_since':
453:                     if ($val == 'date_on') {
454:                         $type = IMP_Search_Element_Date::DATE_ON;
455:                     } elseif ($val == 'date_until') {
456:                         $type = IMP_Search_Element_Date::DATE_BEFORE;
457:                     } else {
458:                         $type = IMP_Search_Element_Date::DATE_SINCE;
459:                     }
460:                     $ob->add(new IMP_Search_Element_Date(
461:                         new DateTime($ui['date'][$key]['year'] . '-' . $ui['date'][$key]['month'] . '-' . $ui['date'][$key]['day']),
462:                         $type
463:                     ));
464:                     break;
465: 
466:                 case 'size_smaller':
467:                 case 'size_larger':
468:                     $ob->add(new IMP_Search_Element_Size(
469:                         $ui['text'][$key],
470:                         $val == 'size_larger'
471:                     ));
472:                     break;
473: 
474:                 case 'seen':
475:                 case 'unseen':
476:                 case 'answered':
477:                 case 'unanswered':
478:                 case 'flagged':
479:                 case 'unflagged':
480:                 case 'deleted':
481:                 case 'undeleted':
482:                     if (strpos($val, 'un') === false) {
483:                         $ob->add(new IMP_Search_Element_Flag(
484:                             $val,
485:                             true
486:                         ));
487:                     } else {
488:                         $ob->add(new IMP_Search_Element_Flag(
489:                             substr($val, 2),
490:                             false
491:                         ));
492:                     }
493:                     break;
494:                 }
495: 
496:                 if ($or_match) {
497:                     $ob->add(new IMP_Search_Element_Or());
498:                 }
499:             }
500: 
501:             $new_vfolders[] = $ob;
502:         }
503: 
504:         $GLOBALS['injector']->getInstance('IMP_Search')->setVFolders($new_vfolders);
505:     }
506: 
507: }
508: