lib.php 102 KB
Newer Older
1
2
3
4
5
6
<?php
/**
 *
 * @package    mahara
 * @subpackage import-leap
 * @author     Catalyst IT Ltd
7
8
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL version 3 or later
 * @copyright  For copyright information on Mahara, please see the README file distributed with this software.
9
10
11
12
13
14
 *
 */

defined('INTERNAL') || die();

/**
Francois Marier's avatar
Francois Marier committed
15
 * Implements import of Leap2A files
16
17
18
19
20
21
22
23
24
25
 *
 * For more documentation, please see:
 * http://wiki.mahara.org/index.php?title=Developer_Area/Import%2F%2FExport/LEAP_Import
 */
class PluginImportLeap extends PluginImport {

    private $xml = null;
    private $namespaces = array();
    private $strategylisting = array();
    private $loadmapping = array();
26
    private $coreloadmapping = array();
27
28
29
30
    public $artefactids = array();
    public $viewids = array();
    public $collectionids = array();
    public $collectionviewentries = array();
31
    protected $filename;
32

33
34
    protected $persondataid = null;

35
36
    protected $loglevel = 0;
    protected $logtargets = LOG_TARGET_ERRORLOG;
37
    protected $logfile = '';
38
    protected $profile = false;
39
40
    protected $leap2anamespace = null;
    protected $leap2atypenamespace = null;
41
    protected $leap2acategories = null;
42
43
44
    // the version is stored with the full url since the url might change in
    // future versions (as it has between 2009-03 and 2010-07)
    protected $supportedleap2aversions = array('http://www.leapspecs.org/2010-07/2A/');
45
46
47
48
49
50
51
52

    private $snapshots = array();

    const LOG_LEVEL_STANDARD = 1;
    const LOG_LEVEL_VERBOSE  = 2;

    const NS_ATOM       = 'http://www.w3.org/2005/Atom';
    const NS_RDF        = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
53
54
55
56
    const NS_LEAP_200903       = 'http://wiki.cetis.ac.uk/2009-03/LEAP2A_predicates#';
    const NS_LEAPTYPE_200903   = 'http://wiki.cetis.ac.uk/2009-03/LEAP2A_types#';
    const NS_CATEGORIES_200903 = 'http://wiki.cetis.ac.uk/2009-03/LEAP2A_categories/';
    const NS_LEAP              = 'http://terms.leapspecs.org/';
57
    const NS_CATEGORIES        = 'http://wiki.leapspecs.org/2A/categories/';
58
59
60
    // NOTE: Even though this URL is no longer valid, it must not change because it is used as an identifier
    // in existing XML files.
    // (Correct current URL is https://wiki.mahara.org/wiki/Developer_Area/Import//Export/LEAP_Extensions# )
61
62
    const NS_MAHARA     = 'http://wiki.mahara.org/Developer_Area/Import%2F%2FExport/LEAP_Extensions#';

63
64
65
    const XHTML_DIV       = '<div xmlns="http://www.w3.org/1999/xhtml">';
    const XHTML_DIV_EMPTY = '<div xmlns="http://www.w3.org/1999/xhtml"/>';

Nigel McNie's avatar
Nigel McNie committed
66
    const STRATEGY_IMPORT_AS_VIEW = 1;
67
    const STRATEGY_IMPORT_AS_COLLECTION = 2;
Nigel McNie's avatar
Nigel McNie committed
68

69
70
71
72
73
74
75
76
77
78
79
80
81
82
    /**
     * Add the artefactmapping of an entry given by ID
     * @param string $entryid
     * @param string $artefactid
     */
    public function add_artefactmapping($entryid, $artefactid) {
        if (!isset($this->artefactids[$entryid])) {
            $this->artefactids[$entryid] = array();
        }
        if (!in_array($artefactid, $this->artefactids[$entryid])) {
            $this->artefactids[$entryid][] = $artefactid;
        }
    }

83
84
    public static function validate_transported_data(ImporterTransport $transport) {
        $importdata = $transport->files_info();
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
        if (!$file = self::find_file($importdata)) {
            throw new ImportException(null, 'Missing leap xml file');
        }
    }

    public static function find_file($importdata) {
        $path = $importdata['tempdir'] . 'extract/';
        if (!empty($importdata['manifestfile'])) {
            $files = array($importdata['manifestfile']);
        } else {
            $files = array('leap.xml', 'leap2.xml', 'leap2a.xml');
        }
        foreach ($files as $f) {
            if (file_exists($path . $f)) {
                return $path . $f;
            }
        }
102
103
104
105
106
107
108
109
110
    }

    public function get($field) {
        if ($field == 'xml') {
            return $this->xml;
        }
        return parent::get($field);
    }

111
112
113
114
115
    /**
     * Reads and parses the archive's "leap2a.xml" file
     * @throws ImportException
     */
    public function read_leap2a_xml_file() {
116
117
118
        $this->filename = self::find_file($this->get('importertransport')->files_info());
        $this->logfile = dirname($this->filename) . '/import.log';
        $this->trace('Loading import from ' . $this->filename);
119
120
121
122
123
124
        $this->snapshot('begin');

        $options =
            LIBXML_COMPACT |    // Reported to greatly speed XML parsing
            LIBXML_NONET        // Disable network access - security check
        ;
125
        libxml_before(false);
126
127
128
129
130
131
        require_once('file.php');
        if (!$this->xml = simplexml_load_string(
                preg_replace(xml_filter_regex(), '', file_get_contents($this->filename)),
                'SimpleXMLElement',
                $options
        )) {
132
            // TODO: bail out in a much nicer way...
133
            libxml_after();
134
135
            throw new ImportException($this, "FATAL: XML file is not well formed! Please consult Mahara's error log for more information");
        }
136
137
        libxml_after();

138
139
140
141
142
        $this->namespaces = array_flip($this->xml->getDocNamespaces());
        $this->registerXpathNamespaces($this->xml);
        $this->trace("Document loaded, entries: " . count($this->xml->entry));
        $this->snapshot('loaded XML');

143
        $this->detect_leap2a_namespace();
144
        $this->ensure_document_valid();
145
    }
146

147
148
149
150
151
152
    /**
     * Create the default load mapping, usingthe highest-ranked strategy for each item in
     * the leap2a XML file
     */
    private function build_default_load_mapping() {
        $this->read_leap2a_xml_file();
153
154
155
156
        $this->create_strategy_listing();
        $this->snapshot('created strategy listing');
        $this->strategy_listing_to_load_mapping();
        $this->snapshot('converted strategy listing to load mapping');
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
    }

    public function process($step = PluginImport::STEP_NON_INTERACTIVE) {
        db_begin();
        switch ($step) {
        case PluginImport::STEP_NON_INTERACTIVE:
            $this->build_default_load_mapping();
            $this->import_from_load_mapping();
            $this->snapshot('imported data based on load mapping');
            $this->import_completed();
            break;
        case PluginImport::STEP_INTERACTIVE_IMPORT_FORM:
            $this->build_default_load_mapping();
            $this->build_import_entry_requests();
            break;
        case PluginImport::STEP_INTERACTIVE_IMPORT_RESULT:
            // Load import requests from DB
            $this->load_import_entry_requests();
            // Import based on import requests
            $this->import_from_requests();
            $this->snapshot('imported data based on import requests');
            $this->import_completed();
            break;
        }
        db_commit();
    }

    /**
     * Builds import requests from load mapping and store them in DB for next steps
     */
    public function build_import_entry_requests() {
        $usedlist = $loadedentries = array();
        uasort($this->loadmapping, function ($a, $b) { return $a["score"] < $b["score"]; });
        // Find existing artefacts
        foreach ($this->loadmapping as $entryid => $strategydata) {
            if (in_array($entryid, $usedlist)) {
                continue;
            }
            if (isset($strategydata['other_required_entries'])) {
                foreach ($strategydata['other_required_entries'] as $otherentryid) {
                    if (in_array($otherentryid, $usedlist)) {
                        continue(2);
                    }
                }
            }
            $entry = $this->get_entry_by_id($entryid);
            $classname = 'LeapImport' . ucfirst($strategydata['artefactplugin']);
            call_static_method($classname, 'add_import_entry_request_using_strategy',
                            $entry, $this, $strategydata['strategy'], $strategydata['other_required_entries']);

            $usedlist[] = $entryid;
            if (isset($strategydata['other_required_entries'])) {
                foreach ($strategydata['other_required_entries'] as $otherentryid) {
                    $usedlist[] = $otherentryid;
                }
            }
            $loadedentries[] = $entryid;
        }
        // Find existing author's artefacts
        if (!is_array($this->data) || !array_key_exists('skippersondata', $this->data) || $this->data['skippersondata'] !== true) {
            foreach (plugins_installed('artefact') as $plugin) {
                $classname = 'LeapImport' . ucfirst($plugin->name);
                if (method_exists($classname, 'add_import_entry_request_author_data')) {
                    call_static_method($classname, 'add_import_entry_request_author_data', $this, $this->persondataid);
                }
            }
        }
        // Find existing views
        foreach ($this->coreloadmapping as $entryid => $strategydata) {
            if (in_array($entryid, $usedlist)) {
                continue;
            }
            if (isset($strategydata['other_required_entries'])) {
                foreach ($strategydata['other_required_entries'] as $otherentryid) {
                    if (in_array($otherentryid, $usedlist)) {
                        continue(2);
                    }
                }
            }

            $entry = $this->get_entry_by_id($entryid);
            $this->add_import_entry_request_using_strategy($entry, $strategydata['strategy'], $strategydata['other_required_entries']);

            $usedlist[] = $entryid;
            if (isset($strategydata['other_required_entries'])) {
                foreach ($strategydata['other_required_entries'] as $otherentryid) {
                    $usedlist[] = $otherentryid;
                }
            }

            $loadedentries[] = $entryid;
        }

    }

    /*
     * returns a list of import entries and their existing artefacts
     */
    public function build_import_entry_requests_form() {
        global $USER;

        $html = '<form name="ier" method="POST" action="">';
        $installedplugins = array_map(create_function('$a', 'return $a->name;'), plugins_installed('artefact'));
260
        $orderedimportplugins = array('internal', 'file', 'blog', 'resume', 'plans', 'annotation');
261
262
263
264
265
266
267
268
269
270
271
272
273
274
        foreach ($orderedimportplugins as $plugin) {
            if (!in_array($plugin, $installedplugins)) {
                continue;
            }
            if (safe_require('import', 'leap/' . $plugin, 'lib.php', 'require_once', true)) {
                $classname = 'LeapImport' . ucfirst($plugin);
                if (method_exists($classname, 'render_import_entry_requests')) {
                    safe_require('artefact', $plugin);
                    $html .= call_static_method($classname, 'render_import_entry_requests', $this);
                }
            }
        }
        // core render for views
        $html .= self::render_import_entry_requests();
275
276
277
278
279
        $html .=
            '<div class="submitcancel form-group">'.
            '<input type="hidden" value="' . DOIMPORT_ACT . '" name="action">
            <input type="submit" value="' . get_string('Import', 'import') . '" name="import_submit" id="import_submit" class="btn btn-primary submitcancel submit">
            <input type="submit" value="' . get_string('cancel') . '" name="cancel_import_submit" id="cancel_import_submit" class="btn-primary submitcancel cancel"></div>
280
281
282
283
284
285
286
287
288
289
        </form>';
        return $html;
    }

    /**
     * Call import method for plugins
     * @param $method    method name
     */
    public function call_import_method_plugins($method) {
        $installedplugins = array_map(create_function('$a', 'return $a->name;'), plugins_installed('artefact'));
290
        $orderedimportplugins = array('internal', 'file', 'blog', 'resume', 'plans', 'annotation', 'comment');
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
        foreach ($orderedimportplugins as $plugin) {
            if (!in_array($plugin, $installedplugins)) {
                continue;
            }
            if (safe_require('import', 'leap/' . $plugin, 'lib.php', 'require_once', true)) {
                $classname = 'LeapImport' . ucfirst($plugin);
                if (method_exists($classname, $method)) {
                    safe_require('artefact', $plugin);
                    call_static_method($classname, $method, $this);
                }
            }
        }
    }
    /*
     * do import from requests and returns the result
     */
    public function do_import_from_requests() {
        global $USER;

        db_begin();

        $this->read_leap2a_xml_file();
        // Allow each plugin imports its artefact from import entry requests
        $this->call_import_method_plugins('import_from_requests');
        $this->call_import_method_plugins('setup_relationships_from_requests');
        // Fix up any artefact references in the content of imported artefacts
        // TODO: restrict this to the ones that were imported right now
        if ($artefacts = get_records_array('artefact', 'owner', $this->get('usr'), '', 'id, title, description')) {
            foreach ($artefacts as $artefact) {
                $this->fix_artefact_references($artefact);
            }
        }
        // Now import views
        $this->import_from_requests();

        // Put views into collections

        // Keep track of which views have been placed in a collection, because
        // Mahara can't handle more one collection per view.
        $incollection = array();
        foreach ($this->collectionviewentries as $cid => $entryids) {
            $i = 0;
            foreach ($entryids as $entryid) {
                $viewid = self::get_viewid_imported_by_entryid($entryid);
                if ($viewid && !isset($incollection[$viewid])) {
                    insert_record('collection_view', (object) array(
                        'collection' => $cid,
                        'view' => $viewid,
                        'displayorder' => $i,
                    ));
                    $incollection[$viewid] = $cid;
                    $i++;
                }
            }
        }
346
        // Allow each artefact plugin to load relationships to views if they need to
347
        $this->call_import_method_plugins('setup_view_relationships_from_requests');
348
349
350
351

        // Allow each blocktype plugin to load relationships to views if they need to
        $this->rewrite_blockinstance_relationships();

352
        $this->import_completed();
353
        $this->delete_import_entry_requests();
354

355
        db_commit();
356
357
358
359

        $html = get_string('importsuccessfully', 'import');
        return $html;

360
361
    }

362
363
364
365
366
367
    /**
     * detect the leap2a namespace of the import document by looking for the 'version' element
     *
     *
     */
    private function detect_leap2a_namespace () {
368

369
        // check for the leap2a version used
370
371
372
373
374
375
376
377
378
379
380
        // disable xml warnings. The initial LEAP2A spec hasn't got the leap2
        // namespace so the following xpath expression triggers a warning
        // which we want to suppress.
        $oldvalue = libxml_use_internal_errors(true);
        $version = $this->xml->xpath('//leap2:version');
        libxml_use_internal_errors($oldvalue);

        // if there is no version string we assume the first version of the
        // LEAP2A spec which doesn't contain the version element
        if(!empty($version) && !in_array($version[0][0], $this->supportedleap2aversions)) {
            throw new ImportException($this, "FATAL: The version of the uploaded LEAP2A file is not supported by this Mahara version");
381
        }
382
383

        if($version) {
384
385
            $this->leap2anamespace = self::NS_LEAP;
            $this->leap2atypenamespace = self::NS_LEAP;
386
387
388
389
390
391
392
393
394
            // this is a workaround for a bug that was introduced during the
            // update to LEAP2A 2010-07. Exports between the update and this
            // bugfix will contain a wrong namespace. This workaround will
            // allow those exports to still import properly. (bug #673434)
            if (isset($this->namespaces['http://wiki.leapspecs.org/2A/categories'])) {
                $this->leap2acategories = 'http://wiki.leapspecs.org/2A/categories';
            } else {
                $this->leap2acategories = self::NS_CATEGORIES;
            }
395
396
397
        } else {
            $this->leap2anamespace = self::NS_LEAP_200903;
            $this->leap2atypenamespace = self::NS_LEAPTYPE_200903;
398
            $this->leap2acategories = self::NS_CATEGORIES_200903;
399
400
401
        }
    }

402
403
404
    private function ensure_document_valid() {
        // TODO: http://wiki.mahara.org/Developer_Area/Import%2f%2fExport/Import%3a_Implementation_Plan#beginning
        //
405
        // Do a bunch of checks that will ensure the feed is valid, and thus
406
407
408
409
410
        // allow future code to make assumptions that the feed is valid

        // Things to check:
        // - all content src="X": make sure the src actually exists
        // - feed has a <feed> element with an <author> and <entry>s
411
        // - feed element has correct namespaces (keep in mind we need to be
412
413
414
        // able to import raw ATOM feeds too)

        //throw new ImportException($this, "Import wasn't valid. TODO: error reporting");
415

416
        // Check all the namespaces we're gonna need are declared, and warn if
417
        // they're not there
418
419
420
421
422
423
        if($this->leap2anamespace == self::NS_LEAP) {
            $namespaces = array(self::NS_ATOM, self::NS_RDF, self::NS_LEAP, self::NS_CATEGORIES);
        } else {
            $namespaces = array(self::NS_ATOM, self::NS_RDF, self::NS_LEAP_200903, self::NS_LEAPTYPE_200903, self::NS_CATEGORIES_200903);
        }
        foreach ($namespaces as $ns) {
424
425
426
427
            if (!isset($this->namespaces[$ns])) {
                $this->trace("WARNING: Namespaces $ns wasn't declared - this will make importing data correctly difficult");
            }
        }
428
429
430
431
432
433
434
435
436
    }

    /**
     * http://wiki.mahara.org/Developer_Area/Import%2f%2fExport/Import%3a_Implementation_Plan#first_pass_-_get_scores_from_plugins_for_each_entry
     *
     * Each list of strategies for each entry should be sorted from highest to lowest score once this is done
     */
    private function create_strategy_listing() {
        $this->trace("-------------------------\ncreate_strategy_listing()");
437
438
439
440
441
442
        // Give all plugins a chance to perform setup tasks
        foreach (plugins_installed('artefact') as $plugin) {
            $plugin = $plugin->name;
            if (safe_require('import', 'leap/' . $plugin, 'lib.php', 'require_once', true)) {
                $classname = 'LeapImport' . ucfirst($plugin);
                if (method_exists($classname, 'setup')) {
443
                    safe_require('artefact', $plugin);
444
445
446
447
                    call_static_method($classname, 'setup', $this);
                }
            }
        }
448

449
        // First, try to establish whether there is an element representing the
450
451
452
453
454
455
456
457
458
        // author of the feed
        // TODO: also check this element has the right leaptype (person)
        if (is_null($this->persondataid)) {
            $author = $this->get('xml')->xpath('//a:feed/a:author[1]');
            $author = $author[0];
            if (isset($author->uri) && $this->get_entry_by_id((string)$author->uri)) {
                $this->persondataid = (string)$author->uri;
            }
            else {
459
                $persondata = $this->get('xml')->xpath('//a:feed/a:entry/a:category[('
460
                    . $this->curie_xpath('@scheme', $this->get_categories_namespace(), 'person_type#') . ') and @term="Self"]/../a:id');
461
462
463
464
465
466
                if (isset($persondata[0])) {
                    $this->persondataid = (string)$persondata[0][0];
                }
                else {
                    $this->persondataid = false;
                }
467
468
469
470
            }
        }

        // Generate strategy listing
471
472
473
474
475
        foreach ($this->xml->xpath('//a:feed/a:entry') as $entry) {
            $this->registerXpathNamespaces($entry);
            $entryid = (string)$entry->id;
            $this->trace(" * $entryid ({$entry->title})");

476
477
478
479
480
            if ($this->persondataid && $entryid == $this->persondataid) {
                // We don't offer this element to any plugin to be imported
                continue;
            }

481
            foreach (plugins_installed('artefact') as $plugin) {
482
                $plugin = $plugin->name;
483
484
                $classname = 'LeapImport' . ucfirst($plugin);
                if (class_exists($classname)) {
485
486
487
                    if (!is_subclass_of($classname, 'LeapImportArtefactPlugin')) {
                        throw new SystemException("Class $classname does not extend LeapImportArtefactPlugin as it should");
                    }
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
                    if (method_exists($classname, 'get_import_strategies_for_entry')) {
                        $strategies = call_static_method($classname, 'get_import_strategies_for_entry', $entry, $this);
                        $this->trace("   artefact.$plugin strategies: " . count($strategies));
                        if ($strategies) {
                            $this->trace($strategies, self::LOG_LEVEL_VERBOSE);
                            foreach ($strategies as $strategy) {
                                // Verify they're in valid form
                                if (!array_key_exists('strategy', $strategy)
                                    || !array_key_exists('score', $strategy)
                                    || !array_key_exists('other_required_entries', $strategy)) {
                                    throw new SystemException("$classname::get_import_strategies_for_entry returned a strategy missing "
                                        . "one or more of the strategy, score or other_required_entries keys");
                                }
                                $strategy['artefactplugin'] = $plugin;
                                $this->strategylisting[$entryid][] = $strategy;
Nigel McNie's avatar
Nigel McNie committed
503
                            }
504
505
506
507
508
                        }
                    }
                }
            }

Nigel McNie's avatar
Nigel McNie committed
509
510
511
512
513
514
515
516
517
518
            $strategies = $this->get_import_strategies_for_entry($entry);
            $this->trace("   core strategies: " . count($strategies));
            if ($strategies) {
                $this->trace($strategies, self::LOG_LEVEL_VERBOSE);
                foreach ($strategies as $strategy) {
                    $strategy['artefactplugin'] = null;
                    $this->strategylisting[$entryid][] = $strategy;
                }
            }

519
520
521
522
523
524
525
            if (!isset($this->strategylisting[$entryid])) {
                $this->trace(" ** Could not find any strategies for $entryid **");
                // TODO: we might need to expose this information later
                continue;
            }

            // Sort by score descending
526
            usort($this->strategylisting[$entryid], function ($a, $b) { return $a["score"] < $b["score"]; });
527
528
529
530
531
532
        }
        $this->trace('*** Strategy listing: ***');
        $this->trace($this->strategylisting);
    }

    /**
533
     * Converts a strategy listing into the "best" load mapping that can be
534
535
     * gleaned from the strategy listing.
     *
536
537
     * The best mapping is decided by sorting the strategy listing by score and
     * importing all entries on a first-met, first used basis. The algorithm is
538
539
540
541
542
543
544
     * described at:
     * http://wiki.mahara.org/Developer_Area/Import%2f%2fExport/Import%3a_Implementation_Plan#non-interactive_import
     */
    private function strategy_listing_to_load_mapping() {
        $this->trace("----------------------------------\nstrategy_listing_to_load_mapping()");
        $usedlist = array();

545
546
        // Each entry has its strategies sorted from best to worst score, then
        // we sort the entire list of entries by the best scores they have
547
548
549
550
551
        // available. This is so we get the "best" plan for importing
        uasort($this->strategylisting, array($this, 'strategy_listing_sort'));
        $this->trace('*** Sorted strategy listing ***', self::LOG_LEVEL_VERBOSE);
        $this->trace($this->strategylisting, self::LOG_LEVEL_VERBOSE);

552
553
554
        // We're only interested in the first listing really. It's the strategy
        // with the highest score for this entry. Most of the loop mechanics is
        // so that if we choose to import an entry that requires other entries,
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
        // we don't import those other entries separately as well.
        foreach($this->strategylisting as $entryid => $strategies) {
            foreach ($strategies as $strategydata) {
                $this->trace("entry: $entryid");
                if (in_array($entryid, $usedlist)) {
                    $this->trace(" * already in used list, skipped");
                    continue;
                }
                if (isset($strategydata['other_required_entries'])) {
                    foreach ($strategydata['other_required_entries'] as $otherentryid) {
                        if (in_array($otherentryid, $usedlist)) {
                            $this->trace(" * other required entry $otherentryid already in used list, skipped");
                            continue;
                        }
                    }
                }

                $this->trace(" * using strategy $strategydata[strategy] from plugin $strategydata[artefactplugin]");
573
574
575
576
577
578
                if ($strategydata['artefactplugin']) {
                    $this->loadmapping[$entryid] = $strategydata;
                }
                else {
                    $this->coreloadmapping[$entryid] = $strategydata;
                }
579
580
581
582
583
584
585
586
587
588

                $usedlist[] = $entryid;

                if (isset($strategydata['other_required_entries'])) {
                    foreach ($strategydata['other_required_entries'] as $otherentryid) {
                        $usedlist[] = $otherentryid;
                    }
                }

                // We've found how we're going to import this entry now
589
590
                // TODO: we should check the next strategy here and see if it
                // has the same score, if it does we should note that for later
591
592
593
594
                // for debugging purposes
                break;
            }
        }
595
        $this->trace("*** Plugin load mapping: ***");
596
        $this->trace($this->loadmapping);
597
598
        $this->trace("*** Core load mapping: ***");
        $this->trace($this->coreloadmapping);
599
600
601
    }

    private function strategy_listing_sort($a, $b) {
602
603
        // NOTE: the strategy listing should already have the strategies for
        // each entry sorted from highest to lowest score. If it doesn't, these
604
605
606
607
608
609
610
611
        // two sorts fix that, but this should never happen.
        //usort($a, create_function('$a, $b', 'return $a["score"] < $b["score"];'));
        //usort($b, create_function('$a, $b', 'return $a["score"] < $b["score"];'));
        return $a[0]['score'] < $b[0]['score'];
    }

    /**
     * Import entries using our load mapping. See:
612
     * https://wiki.mahara.org/index.php/Developer_Area/Import//Export/Import:_Implementation_Plan#second_pass:_load_all_entries_into_mahara_as_per_load_mapping
613
614
615
616
617
     */
    private function import_from_load_mapping() {
        $this->trace("--------------------------\nimport_from_load_mapping()");
        // TODO: do both usedlists as by key instead of by value for faster checks
        $usedlist = $loadedentries = array();
618
        uasort($this->loadmapping, function ($a, $b) { return $a["score"] < $b["score"]; });
619
620
621
622
623
624
625
626
627
628
629
630
631
632
        foreach ($this->loadmapping as $entryid => $strategydata) {
            if (in_array($entryid, $usedlist)) {
                $this->trace("WARNING: $entryid has already been imported as part of a previous entry");
                continue;
            }
            if (isset($strategydata['other_required_entries'])) {
                foreach ($strategydata['other_required_entries'] as $otherentryid) {
                    if (in_array($otherentryid, $usedlist)) {
                        $this->trace("WARNING: $entryid has already been imported as part of a previous entry");
                        continue(2);
                    }
                }
            }

633
634
635
636
637
638
639
640
641
            $this->trace("Importing $entryid using strategy $strategydata[strategy] of plugin $strategydata[artefactplugin]");
            safe_require('artefact', $strategydata['artefactplugin']);
            $entry = $this->get_entry_by_id($entryid);
            $classname = 'LeapImport' . ucfirst($strategydata['artefactplugin']);
            // TODO: this throws ImportException if it can't be imported, need
            // to decide if this exception can bubble up or whether it should
            // be caught here
            $artefactmapping = call_static_method($classname, 'import_using_strategy',
                $entry, $this, $strategydata['strategy'], $strategydata['other_required_entries']);
642
643
644
645
646

            if (!is_array($artefactmapping)) {
                throw new SystemException("import_from_load_mapping(): $classname::import_using_strategy has not return a list");
            }

647
            $this->artefactids = array_merge_recursive($this->artefactids, $artefactmapping);
648
649
650
651
652
653
654
655
656
657
658

            $usedlist[] = $entryid;
            if (isset($strategydata['other_required_entries'])) {
                foreach ($strategydata['other_required_entries'] as $otherentryid) {
                    $usedlist[] = $otherentryid;
                }
            }

            $loadedentries[] = $entryid;
        }

659
        // Give plugins a chance to import stuff about the feed author from the
660
        // persondata entry
661
        // TODO: this should return an artefact mapping so things can create
662
        // links to profile fields, but nothing actually needs it yet
663
        if (!is_array($this->data) || !array_key_exists('skippersondata', $this->data) || $this->data['skippersondata'] !== true) {
664
665
666
667
668
            foreach (plugins_installed('artefact') as $plugin) {
                $classname = 'LeapImport' . ucfirst($plugin->name);
                if (method_exists($classname, 'import_author_data')) {
                    call_static_method($classname, 'import_author_data', $this, $this->persondataid);
                }
669
            }
670
        }
671

672
        // Now all artefacts are loaded, allow each plugin to load
673
674
675
        // relationships for them if they need to
        foreach ($loadedentries as $entryid) {
            $strategydata = $this->loadmapping[$entryid];
676
677
            $classname = 'LeapImport' . ucfirst($strategydata['artefactplugin']);
            $entry = $this->get_entry_by_id($entryid);
678
            $maybeartefacts = call_static_method($classname, 'setup_relationships',
679
                $entry, $this, $strategydata['strategy'], $strategydata['other_required_entries']);
680
681
682
            if (is_array($maybeartefacts)) { // some might add new artefacts (eg files attached by relpath, rather than leap id)
                $this->artefactids = array_merge_recursive($this->artefactids, $maybeartefacts);
            }
683
684
        }

685
        // Fix up any artefact references in the content of imported artefacts
686
        // TODO: restrict this to the ones that were imported right now
687
688
689
690
691
692
        if ($artefacts = get_records_array('artefact', 'owner', $this->get('usr'), '', 'id, title, description')) {
            foreach ($artefacts as $artefact) {
                $this->fix_artefact_references($artefact);
            }
        }

693
694
695
696
697
698
699
700
701
702
703
704
705
        // Now import views
        foreach ($this->coreloadmapping as $entryid => $strategydata) {
            if (in_array($entryid, $usedlist)) {
                $this->trace("WARNING: $entryid has already been imported as part of a previous entry");
                continue;
            }
            if (isset($strategydata['other_required_entries'])) {
                foreach ($strategydata['other_required_entries'] as $otherentryid) {
                    if (in_array($otherentryid, $usedlist)) {
                        $this->trace("WARNING: $entryid has already been imported as part of a previous entry");
                        continue(2);
                    }
                }
Nigel McNie's avatar
Nigel McNie committed
706
            }
707
708
709
710
711
712
713
714
715
716
717
718
719

            $this->trace("Importing $entryid using the core");
            $entry = $this->get_entry_by_id($entryid);
            $this->import_using_strategy($entry, $strategydata['strategy'], $strategydata['other_required_entries']);

            $usedlist[] = $entryid;
            if (isset($strategydata['other_required_entries'])) {
                foreach ($strategydata['other_required_entries'] as $otherentryid) {
                    $usedlist[] = $otherentryid;
                }
            }

            $loadedentries[] = $entryid;
720
        }
721

722
        // Put views into collections
723
724
725
726
727

        // Keep track of which views have been placed in a collection, because
        // Mahara can't handle more one collection per view.
        $incollection = array();

728
729
730
        foreach ($this->collectionviewentries as $cid => $entryids) {
            $i = 0;
            foreach ($entryids as $entryid) {
731
732
                $viewid = self::get_viewid_imported_by_entryid($entryid);
                if ($viewid && !isset($incollection[$viewid])) {
733
734
735
736
737
738
                    $record = (object) array(
                        'collection' => $cid,
                        'view' => $viewid,
                        'displayorder' => $i,
                    );
                    insert_record('collection_view', $record);
739
                    $incollection[$viewid] = $cid;
740
741
742
743
744
                    $i++;
                }
            }
        }

745
746
747
748
749
750
751
752
753
754
        // Allow each plugin to load relationships to views if they need to
        foreach ($loadedentries as $entryid) {
            if (isset($this->loadmapping[$entryid])) {
                $strategydata = $this->loadmapping[$entryid];
                $classname = 'LeapImport' . ucfirst($strategydata['artefactplugin']);
                $entry = $this->get_entry_by_id($entryid);
                call_static_method($classname, 'setup_view_relationships',
                    $entry, $this, $strategydata['strategy'], $strategydata['other_required_entries']);
            }
        }
755
756
757

        // Allow each blocktype plugin to load relationships to views if they need to
        $this->rewrite_blockinstance_relationships();
758
759
    }

760
761
762
763
764
765
766
767
768
769
770
771
772
    public function entry_has_strategy($entryid, $strategyid, $artefactplugin=null) {
        if (isset($this->loadmapping[$entryid])) {
            if (empty($this->loadmapping[$entryid]['artefactplugin']) && !empty($artefactplugin)) {
                return false;
            }
            if ($this->loadmapping[$entryid]['artefactplugin'] != $artefactplugin) {
                return false;
            }
            return $this->loadmapping[$entryid]['strategy'] == $strategyid;
        }
        return false;
    }

773
    private function import_completed() {
774
775
776
777
778
779
780
        // Give all plugins a chance to perform final tasks
        foreach (plugins_installed('artefact') as $plugin) {
            $classname = 'LeapImport' . ucfirst($plugin->name);
            if (method_exists($classname, 'cleanup')) {
                call_static_method($classname, 'cleanup', $this);
            }
        }
781
782
783
        $this->trace("------------------\nimport_completed()");

        unset($this->loadmapping);
784
        unset($this->coreloadmapping);
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
        unset($this->strategylisting);
        unset($this->xpath);
        unset($this->dom);
        $this->snapshot('end');

        if ($this->profile) {
            $this->trace("k: abstime\ttime\tmemafter\tmemdiff");
            $firstdata = $lastdata = $this->snapshots['begin'];
            $i = 0;
            foreach ($this->snapshots as $identifier => $data) {
                $i++;
                $timetaken = $data['time'] - $lastdata['time'];
                $abstime   = $data['time'] - $firstdata['time'];
                $memoryafter = $data['ram'] / 1024;
                $memorygrowth = ($data['ram'] - $lastdata['ram']) / 1024;
                $this->trace(sprintf("$i: %.3f\t%.3f\t%.3fK\t%8.3fK", $abstime, $timetaken, $memoryafter, $memorygrowth));
                $lastdata = $data;
            }

            $i = 0;
            foreach (array_keys($this->snapshots) as $identifier) {
                $i++;
                $this->trace("$i = $identifier");
            }
            $this->trace("abstime = time after beginning step of import that this step completed\n"
                . "time = time taken to complete this step\n"
                . "memafter = script memory usage after this step\n"
                . "memdiff = difference in memory usage compared with the last step");
        }
    }

816
817
818
819
820
821
822
823
    /*
     * Delete all import entry requests
     */
    private function delete_import_entry_requests() {
        delete_records('import_entry_requests', 'importid', $this->get('importertransport')->get('importid'));
    }

        /**
824
825
     * Logs a message for debugging purposes
     *
826
     * The user can configure the amount of logging, and where it goes, by
827
828
829
830
831
832
833
834
835
836
     * setting the 'loglevel' and 'logtargets' fields.
     *
     * loglevel is one of {0, PluginImportLeap::LOG_LEVEL_STANDARD, PluginImportLeap::LOG_LEVEL_VERBOSE}
     * logtargets is one of the LOG_TARGET_* constants
     *
     * @param string $message The message to log
     * @param int    $level   The level at which to log this error
     */
    public function trace($message, $level=self::LOG_LEVEL_STANDARD) {
        if ($level <= $this->loglevel) {
837
            // Use our logging system temporarily, which provides us with
838
            // access to its nice features. We use log_message instead of
839
840
            // log_debug because that will retain the the line/file where
            // trace() was called, rather than saying all of the messages came
841
842
            // from trace() itself
            global $CFG;
843
            $oldtargets = $CFG->log_dbg_targets;
844
            $oldfile = isset($CFG->log_file) ? $CFG->log_file : null;
845
            $CFG->log_dbg_targets = $this->logtargets;
846
            $CFG->log_file = $this->logfile;
847
            $file = $line = $trace = null;
848
849
850
            log_message($message, LOG_LEVEL_DBG, true, true, $file, $line, $trace);
            $CFG->log_dbg_targets = $oldtargets;
            $CFG->log_file = $oldfile;
851
852
853
854
855
856
857
858
859
860
861
862
        }
    }

    private function snapshot($identifier) {
        if ($this->profile) {
            $this->snapshots[$identifier] = array(
                'time' => microtime(true),
                'ram'  => memory_get_usage(), // TODO: http://php.net/memory_get_usage suggests this isn't available everywhere
            );
        }
    }

Nigel McNie's avatar
Nigel McNie committed
863
    /**
864
     * Given an entry, should return a list of the possible ways that it could
Nigel McNie's avatar
Nigel McNie committed
865
866
     * be imported by the core.
     *
867
     * The core handles View importing, so this method looks for entries that
Nigel McNie's avatar
Nigel McNie committed
868
869
     * could be converted into Views.
     *
870
     * For more information about this method, see
Nigel McNie's avatar
Nigel McNie committed
871
872
873
874
875
     * {LeapImportArtefactPlugin::get_import_strategies_for_entry}
     *
     * @param SimpleXMLElement $entry
     */
    public function get_import_strategies_for_entry(SimpleXMLElement $entry) {
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
        if (self::is_rdf_type($entry, $this, 'selection')) {
            if (self::is_correct_category_scheme($entry, $this, 'selection_type', 'Webpage')) {
                return array(array(
                    'strategy' => self::STRATEGY_IMPORT_AS_VIEW,
                    'score'    => 100,
                    'other_required_entries' => array(),
                ));
            }
            if (self::is_correct_category_scheme($entry, $this, 'selection_type', 'Website')) {
                return array(array(
                    'strategy' => self::STRATEGY_IMPORT_AS_COLLECTION,
                    'score'    => 100,
                    'other_required_entries' => array(),
                ));
            }
Nigel McNie's avatar
Nigel McNie committed
891
892
893
894
        }
        return array();
    }

895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
    /**
     * Add import entry request for a view
     *
     * @param SimpleXMLElement $entry
     * @param  $strategy
     * @param array $otherentries
     * @return update DB table 'import_entry_requests'
     * @throws ImportException
     */
    public function add_import_entry_request_using_strategy(SimpleXMLElement $entry, $strategy, array $otherentries) {
        $importid = $this->get('importertransport')->get('importid');
        switch ($strategy) {
        case self::STRATEGY_IMPORT_AS_VIEW:
            require_once('view.php');

            if (!$this->add_import_entry_request_view($entry)) {
                // Not a Mahara view, just do basic import
                $this->trace('Not a Mahara view, doing basic import', self::LOG_LEVEL_VERBOSE);

                $viewdata = array(
                    'title'       => (string)$entry->title,
                    'description' => (string)$entry->summary,
                    'type'        => 'portfolio', // TODO
                    'layout'      => null, // TODO
                    'tags'        => self::get_entry_tags($entry),
                    'numrows'     => 1,
                    'ownerformat' => FORMAT_NAME_DISPLAYNAME, // TODO
                    'owner'       => $this->get('usr'),
                );
                if ($published = strtotime((string)$entry->published)) {
                    $viewdata['ctime'] = $published;
                }
                if ($updated = strtotime((string)$entry->updated)) {
                    $viewdata['mtime'] = $updated;
                }
                $viewdata['columns'][1][1] = array(
                    'type'   => 'textbox',
                    'title'  => '',
                    'column' => 1,
                    'order'  => 1,
                    'config' => array('text' => self::get_entry_content($entry, $this))
                );
                PluginImportLeap::add_import_entry_request($importid, (string)$entry->id, self::STRATEGY_IMPORT_AS_VIEW, 'core', array(
                    'owner'   => $this->get('usr'),
                    'type'    => 'view',
                    'content' => $viewdata
                ));
            }
            break;
        case self::STRATEGY_IMPORT_AS_COLLECTION:
            $collectiondata = array(
                'title'       => (string)$entry->title,
                'name'        => (string)$entry->title,
                'description' => (string)$entry->summary,
                'tags'        => self::get_entry_tags($entry),
                'owner'       => $this->get('usr'),
            );
            if ($published = strtotime((string)$entry->published)) {
                $collectiondata['ctime'] = $published;
            }
            if ($updated = strtotime((string)$entry->updated)) {
                $collectiondata['mtime'] = $updated;
            }

            PluginImportLeap::add_import_entry_request($importid, (string)$entry->id, self::STRATEGY_IMPORT_AS_COLLECTION, 'core', array(
                'owner'   => $this->get('usr'),
                'type'    => 'collection',
                'content' => $collectiondata
            ));
            break;
        default:
            throw new ImportException($this, 'TODO: get_string: unknown strategy chosen for importing entry');
        }
    }

    /**
     * Import Mahara views and collections from requests
     * @throws ImportException
     */
    public function import_from_requests() {
        $importid = $this->get('importertransport')->get('importid');
        if ($entry_requests = get_records_select_array('import_entry_requests', 'importid = ? AND plugin = ? AND decision = ?', array($importid, 'core', PluginImport::DECISION_ADDNEW))) {
            foreach ($entry_requests as $entry_request) {
                switch ($entry_request->strategy) {
                case self::STRATEGY_IMPORT_AS_VIEW:
                    require_once('view.php');
                    $this->import_view_from_request($entry_request);
                    break;
                case self::STRATEGY_IMPORT_AS_COLLECTION:
                    require_once('collection.php');
                    $collectiondata = unserialize($entry_request->entrycontent);
                    $collection = new Collection(0, $collectiondata);
                    $collection->commit();
                    $this->collectionids[$entry_request->entryid] = $collection->get('id');

                    // Remember entry ids that form part of this entry, and use them later
                    // to put views into collections.
                    $entry = $this->get_entry_by_id($entry_request->entryid);
                    foreach ($entry->link as $link) {
                        if ($this->curie_equals($link['rel'], '', 'has_part') && isset($link['href'])) {
                            $this->collectionviewentries[$collection->get('id')][] = (string) $link['href'];
                        }
                    }
                    break;
                default:
                    throw new ImportException($this, 'TODO: get_string: unknown strategy chosen for importing entry');