Logo Search packages:      
Sourcecode: gallery2 version File versions  Download package

ConfirmImport.inc

<?php
/*
 * $RCSfile: ConfirmImport.inc,v $
 *
 * Gallery - a web based photo album viewer and editor
 * Copyright (C) 2000-2005 Bharat Mediratta
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA  02110-1301, USA.
 */
/**
 * @version $Revision: 1.131 $ $Date: 2005/09/10 06:43:07 $
 * @package Migrate
 * @subpackage UserInterface
 * @author Jesse Mullan <jmullan@visi.com>
 */

GalleryCoreApi::relativeRequireOnce('modules/migrate/classes/G1MigrateMap.class');

/**
 * @package Migrate
 * @subpackage UserInterface
 */
00035 class ConfirmImportController extends GalleryController {
    /**
     * @see GalleryController::handleRequest()
     */
00039     function handleRequest($form) {
      global $gallery;

      /* Verify that active user is an admin */
      $ret = GalleryCoreApi::assertUserIsSiteAdministrator();
      if ($ret->isError()) {
          return array($ret->wrap(__FILE__, __LINE__), null);
      }

      $albumsPath = GalleryUtilities::getRequestVariables('albumsPath');

      /* build framework for error and status arrays */
      $error = array();
      $status = array();
      if (!isset($form['sourceEncoding'])) {
          $form['sourceEncoding'] = 'UTF-8';
      }

      if (isset($form['action']['cancel'])) {
          $redirect['view'] = 'core.SiteAdmin';
          $redirect['subView'] = 'migrate.SelectGallery';
      } else if (isset($form['action']['import'])) {
          $templateAdapter =& $gallery->getTemplateAdapter();
          $templateAdapter->registerTrailerCallback(
            array($this, 'performImport'), array($form, $albumsPath));
          $results['delegate']['view'] = 'core.ProgressBar';
      }

      if (!empty($redirect)) {
          $results['redirect'] = $redirect;
      } else if (empty($results['delegate'])) {
          $results['delegate']['view'] = 'core.SiteAdmin';
          $results['delegate']['subView'] = 'migrate.ConfirmImport';
      }
      $results['status'] = $status;
      $results['error'] = $error;

      return array(GalleryStatus::success(), $results);
    }

    /**
     * Actually perform the import
     *
     * @param array the form variables
     * @param string the albums path
     * @return object GalleryStatus a status code
     */
00086     function performImport($form, $albumsPath) {
      global $gallery;
      $storage = $gallery->getStorage();
      $templateAdapter =& $gallery->getTemplateAdapter();

      $platform = $gallery->getPlatform();
      $slash = $platform->getDirectorySeparator();

      $finishedAlbums = $albumPosition = $hiddenAlbums = array();

      $status = array('userImportFailure' => array(),
                  'userImportSuccess' => array(),
                  'albumImportFailure' => array(),
                  'albumImportSuccess' => array(),
                  'urlRedirect' => isset($form['urlRedirect']));

      list ($ret, $moduleStatusList) = GalleryCoreApi::fetchPluginStatus('module');
      if ($ret->isError()) {
          return $ret->wrap(__FILE__, __LINE__);
      }
      if (!empty($moduleStatusList['comment']['active'])) {
          $importComments = true;
      } else {
          $importComments = false;
      }

      if (!empty($form['customFields'])) {
          list ($ret, $customFieldInterface) =
            GalleryCoreApi::newFactoryInstance('CustomFieldInterface_1_0');
          if ($ret->isError()) {
            return $ret->wrap(__FILE__, __LINE__);
          }
          if (!isset($customFieldInterface)) {
            return GalleryStatus::error(ERROR_MISSING_OBJECT, __FILE__, __LINE__);
          }
          $skipCustomItemFields = array();
          if (!empty($form['skipCustomItemFields'])) {
            foreach (array('title', 'summary', 'description') as $field) {
                if ($form['set'][$field] == 'custom') {
                  $skipCustomItemFields[] = $form['customfield'][$field];
                }
            }
          }
      }

      /*
       * owner => core.all (which also gives comment.all)
       *
       * canRead => core.view,core.viewResizes
       * canViewFullImages => core.viewSource
       * canViewComments =>
       * comment.view
       * canAddComments => comment.add
       * canChangeText => core.edit
       * canAddTo => core.addDataItem
       * canWrite => core.edit
       * canDeleteFrom => core.delete
       * canCreateSubAlbum => core.addAlbumItem
       *
       */

      $permissionTranslation = array('canRead' => array('core.view',
                                            'core.viewResizes'
                                            ),
                               'canViewFullImages' => array('core.viewSource'),
                               'canChangeText' => array('core.edit'),
                               'canAddTo' => array('core.addDataItem'),
                               'canWrite' => array('core.edit'),
                               'canDeleteFrom' => array('core.delete'),
                               'canCreateSubAlbum' => array('core.addAlbumItem')
                               );
      if ($importComments) {
          $permissionTranslation['canAddComments'] = array('comment.add');
          $permissionTranslation['canViewComments'] = array('comment.view');
      } else {
          $permissionTranslation['canAddComments'] = array();
          $permissionTranslation['canViewComments'] = array();
      }

      /* Get GroupIds for "everybody" and "all users" */
      list ($ret, $everybodyGroupId) =
          GalleryCoreApi::getPluginParameter('module', 'core', 'id.everybodyGroup');
      if ($ret->isError()) {
          return $ret->wrap(__FILE__, __LINE__);
      }
      list ($ret, $allUsersGroupId) =
          GalleryCoreApi::getPluginParameter('module', 'core', 'id.allUserGroup');
      if ($ret->isError()) {
          return $ret->wrap(__FILE__, __LINE__);
      }
      list ($ret, $adminUsersGroupId) =
          GalleryCoreApi::getPluginParameter('module', 'core', 'id.adminGroup');
      if ($ret->isError()) {
          return $ret->wrap(__FILE__, __LINE__);
      }
      list ($ret, $guestUserId) =
          GalleryCoreApi::getPluginParameter('module', 'core', 'id.anonymousUser');
      if ($ret->isError()) {
          return $ret->wrap(__FILE__, __LINE__);
      }

      list($ret, $module) = GalleryCoreApi::loadPlugin('module', 'migrate');
      if ($ret->isError()) {
          return $ret->wrap(__FILE__, __LINE__);
      }
      $importUsersMessage = $module->translate('Importing Users');
      $importPhotosMessage = $module->translate('Importing Photos');

      $sourceEncoding = $form['sourceEncoding'];

      list ($ret, $markupType) =
          GalleryCoreApi::getPluginParameter('module', 'core', 'misc.markup');
      if ($ret->isError()) {
          return $ret->wrap(__FILE__, __LINE__);
      }

      $itemsCreated = array();

      /* Get list of userids in advance */
      GalleryCoreApi::relativeRequireOnce('modules/migrate/classes/Gallery1DataParser.class');
      list($ret, $albumList) = Gallery1DataParser::getAlbumList($albumsPath);
      if ($ret->isError()) {
          return $ret->wrap(__FILE__, __LINE__);
      }

      list ($ret, $uidMap) = Gallery1DataParser::getUserUids($albumsPath);
      if ($ret->isError()) {
          return $ret->wrap(__FILE__, __LINE__);
      }

      /* If no users were selected, create an empty array to avoid later php warnings */
      if (!isset($form['migrateUser'])) {
          $form['migrateUser'] = array();
      }

      /* go through the list of chosen users */
      $totalUsersToImport = count($form['migrateUser']);
      $numberOfUsersImported = 0;
      foreach (array_keys($form['migrateUser']) as $uid) {
          $gallery->guaranteeTimeLimit(30);

          /* convert from uid to username */
          list ($ret, $fields) =
            Gallery1DataParser::getUserFieldsByUid($albumsPath, $uid);
          if ($ret->isError()) {
            return $ret->wrap(__FILE__, __LINE__);
          }
          $userName = GalleryCoreApi::convertToUtf8($fields['username'], $sourceEncoding);
          if (empty($totalUsersToImport)) {
            $totalUsersToImport = 1;
          }
          $ret = $templateAdapter->updateProgressBar(
            $importUsersMessage, $userName, $numberOfUsersImported / $totalUsersToImport);
          if ($ret->isError()) {
            return $ret->wrap(__FILE__, __LINE__);
          }

          /* Go ahead and create the user instance */
          list ($ret, $user) =
            GalleryCoreApi::newFactoryInstance('GalleryEntity', 'GalleryUser');
          if ($ret->isError()) {
            return $ret->wrap(__FILE__, __LINE__);
          }

          /* Verify that the user was created successfully */
          if (!isset($user)) {
            return GalleryStatus::error(ERROR_MISSING_OBJECT, __FILE__, __LINE__);
          }

          /*
           * Turn the instance into a real boy/girl
           * This is where the user is actually created, everything
           * before this was simply building the framework.
           */
          $ret = $user->create($userName);
          /* Was there an error? */
          if ($ret->isError()) {
            /*
             * ERROR_COLLISION is when you try to create something that
             * already exists.
             */
            if (!($ret->getErrorCode() & ERROR_COLLISION)) {
                return $ret->wrap(__FILE__, __LINE__);
            }
            /* Other errors are apparently okay.  Note them and continue */
            $status['userImportFailure'][$userName] = 1;
          } else {
            /*
             * Apparently the creation was successful.  Now we can start
             * setting the various metadata associated with the user
             */
            $user->setEmail($fields['email']);
            $user->setHashedPassword($fields['password']);
            $fullName = GalleryCoreApi::convertToUtf8(
                trim($fields['fullname']), $sourceEncoding);
            $fullName = (!empty($fullName)) ? $fullName : $userName;
            $user->setFullName($fullName);

            /*
             * $fields['canCreateAlbums'] if they have that perm, give them
             * "core.addAlbumItem" permission on the root album
             */
            /* Save this user to the database */
            $ret = $user->save();
            if ($ret->isError()) {
                return $ret->wrap(__FILE__, __LINE__);
            }
            if (isset($fields['isAdmin']) && $fields['isAdmin']) {
                /* Add her to the admin group */
                $ret = GalleryCoreApi::addUserToGroup($user->getId(), $adminUsersGroupId);
                if ($ret->isError()) {
                  return $ret->wrap(__FILE__, __LINE__);
                }
            }

            /* Set a positive note for later.  Hooray! */
            $status['userImportSuccess'][$userName] = 1;
            $user = null;
          }
          $uid = null;
          $numberOfUsersImported++;
      }

      $ret = $templateAdapter->updateProgressBar($importUsersMessage, '', 1);
      if ($ret->isError()) {
          return $ret->wrap(__FILE__, __LINE__);
      }

      /* Checkpoint to ensure users are saved to the DB in case of a later failure */
      $ret = $storage->checkPoint();
      if ($ret->isError()) {
          return $ret->wrap(__FILE__, __LINE__);
      }

      $templateAdapter->resetProgressBarStats();

      /*
       * Import Any Selected Albums
       *
       * First initialize the $form['sourceAlbums'] array to avoid php warnings
       */
      if (!isset($form['sourceAlbums'])) {
          $form['sourceAlbums'] = array();
      }
      foreach ($form['sourceAlbums'] as $key => $value) {
          /* See comment for same loop below in ConfirmImportView */
          unset($form['sourceAlbums'][$key]);
          $form['sourceAlbums'][urldecode($key)] = $value;
      }

      /*
       * Check to see if the user selected a destination.  If not,
       * default to the root album of the new gallery install.
       */
      if (!isset($form['destinationAlbumID'])) {
          list ($ret, $rootId) =
            GalleryCoreApi::getPluginParameter('module', 'core', 'id.rootAlbum');
          if ($ret->isError()) {
            return $ret->wrap(__FILE__, __LINE__);
          }
          $form['destinationAlbumID'] = $rootId;
      }
      /* Convert the form variable into a local temporary variable */
      $destinationAlbumID = $form['destinationAlbumID'];
      /* Go through the list of selected gallery1 albums to import */

      $totalItemsToImport = 0;
      $albumfields = $albumHighlight = array();
      foreach (array_keys ($form['sourceAlbums']) as $sourceAlbumName) {
          /*
           * attempt to load the metadata from the selected album into a
           * local cache for later manipulation
           */
          if (!in_array($sourceAlbumName, array_keys($albumList))) {
            return GalleryStatus::error(ERROR_BAD_PARAMETER, __FILE__, __LINE__);
          }
          list ($ret, $albumfields[$sourceAlbumName]) =
            Gallery1DataParser::loadAlbumFields($albumsPath . $sourceAlbumName);
          if ($ret->isError()) {
            return $ret->wrap(__FILE__, __LINE__);
          }

          list ($ret, $photos) = Gallery1DataParser::getPhotos($albumsPath . $sourceAlbumName);
          if ($ret->isError()) {
            return $ret->wrap(__FILE__, __LINE__);
          }
          $totalItemsToImport += 1 + count($photos);
      }

      /*
       * Go through the array of albums' metadata one album at a time.
       * We limit the number of passes through this list to n^2 times to
       * avoid an infinite loop.  This allows us to make sure that we add
       * parent albums first by taking albums out of the list as they are
       * handled.
       */
      $i = $numberOfItemsImported = 0;
      while ($albumfields && $i < count($form['sourceAlbums'])^2 && !connection_aborted()) {
          $gallery->guaranteeTimeLimit(30);
          $album = array_shift($albumfields);

          /*
           * if the album's parent is not in the list of sourcealbums,
           * load it into the targeted G2 top album as set in $destinationAlbumID
           */
          $targetAlbumID = $newAlbumInstanceId = $isHiddenAlbum = false;
          if (!in_array($album['parentAlbumName'], array_keys($form['sourceAlbums']))) {
            $targetAlbumID = $destinationAlbumID;
            if ($album['parentAlbumName'] != '.root') {
                /* load parent album to check if this album is hidden */
                list ($ret, $parentPhotos) =
                  Gallery1DataParser::getPhotos($albumsPath . $album['parentAlbumName']);
                if ($ret->isError()) {
                  return $ret->wrap(__FILE__, __LINE__);
                }
                foreach($parentPhotos as $parentAlbumItem) {
                  if (isset($parentAlbumItem->isAlbumName) &&
                        $parentAlbumItem->isAlbumName == $album['name']) {
                      $isHiddenAlbum =
                        isset($parentAlbumItem->hidden) && $parentAlbumItem->hidden;
                      break;
                  }
                }
            }
          } else if (in_array($album['parentAlbumName'], array_keys($finishedAlbums))){
            /* if the album's parent has already been imported, import it into the parent */
            $targetAlbumID = $finishedAlbums[$album['parentAlbumName']];
            $isHiddenAlbum = isset($hiddenAlbums[$album['name']]);
          } else {
            $albumfields[$album['name']] = $album;
            $album = null;
          }

          if ($targetAlbumID && $album) {
            /* We definitely need notices before each album */
            $ret = $templateAdapter->updateProgressBar($importPhotosMessage,
                $album['name'], $numberOfItemsImported / $totalItemsToImport);
            if ($ret->isError()) {
                return $ret->wrap(__FILE__, __LINE__);
            }
            list($ret, $parent) = GalleryCoreApi::loadEntitiesById($targetAlbumID);
            if ($ret->isError()) {
                return $ret->wrap(__FILE__, __LINE__);
            }
            list($ret, $parentPath) = $parent->fetchPath();
            if ($ret->isError()) {
                return $ret->wrap(__FILE__, __LINE__);
            }

            $desiredname = $platform->legalizePathComponent($album['name']);
            $k = 0;
            $invalidName = true;
            while($invalidName) {
                list ($ret, $existingAlbumId) =
                  GalleryCoreApi::fetchChildIdByPathComponent($targetAlbumID, $desiredname);
                if ($ret->isError()) {
                  if (!$ret->getErrorCode() & ERROR_MISSING_OBJECT) {
                      return $ret->wrap(__FILE__, __LINE__);
                  } else {
                      $invalidName = false;
                  }
                } else {
                  $desiredname = $album['name'] . '_' . $k++;
                }
            }

            if ($targetAlbumID) {
                /* Make sure we have permission to edit the target item */
                $ret = GalleryCoreApi::assertHasItemPermission($targetAlbumID,
                                                   'core.addAlbumItem');
                if ($ret->isError()) {
                  return $ret->wrap(__FILE__, __LINE__);
                }

                /* Try to load targeted parent */
                list ($ret, $targetAlbumObject) =
                  GalleryCoreApi::loadEntitiesById($targetAlbumID);
                if ($ret->isError()) {
                  return $ret->wrap(__FILE__, __LINE__);
                }

                /* Get a lock on said parent */
                list ($ret, $importLockIds[]) =
                  GalleryCoreApi::acquireReadLock($targetAlbumObject->getId());
                if ($ret->isError()) {
                  return $ret->wrap(__FILE__, __LINE__);
                }

                /* If everything is good so far, we create a new instance to be our new album */
                if (!empty($desiredname) && $platform->isLegalPathComponent($desiredname)) {
                  list ($ret, $newAlbumInstance) =
                      GalleryCoreApi::newFactoryInstance('GalleryEntity', 'GalleryAlbumItem');
                  if ($ret->isError()) {
                      GalleryCoreApi::releaseLocks($importLockIds);
                      return $ret->wrap(__FILE__, __LINE__);
                  }
                  if (!isset($newAlbumInstance)) {
                      GalleryCoreApi::releaseLocks($importLockIds);
                      return GalleryStatus::error(ERROR_MISSING_OBJECT, __FILE__, __LINE__);
                  }
                  /* this is where the album is actually created */
                  $ret = $newAlbumInstance->create($targetAlbumID, $desiredname);
                  if ($ret->isError()) {
                      GalleryCoreApi::releaseLocks($importLockIds);
                      return $ret->wrap(__FILE__, __LINE__);
                  }

                  if (isset($form['urlRedirect'])) {
                      $ret = $this->createG1ToG2Mapping(
                        $newAlbumInstance->getId(), $album['name']);
                      if ($ret->isError()) {
                        GalleryCoreApi::releaseLocks($importLockIds);
                        return $ret->wrap(__FILE__, __LINE__);
                      }
                  }

                  $newAlbumInstanceId = $newAlbumInstance->getId();
                  $sourceData = array('title' => null, 'summary' => null);
                  /* load up the album with metadata from the old album */
                  if (isset($album['title'])) {
                      $sourceData['title'] =
                        $this->convertHtml($markupType, $album['title'], $sourceEncoding);
                      $newAlbumInstance->setTitle($sourceData['title']);
                  }
                  if (isset($album['summary'])) {
                      $newAlbumInstance->setDescription($this->convertHtml(
                        $markupType, $album['summary'], $sourceEncoding));
                  }
                  $newAlbumInstance->setKeywords('');
                  if (isset($album['description'])) {
                      $sourceData['summary'] = $this->convertHtml(
                        $markupType, $album['description'], $sourceEncoding);
                      $newAlbumInstance->setSummary($sourceData['summary']);
                  }
                  // $newAlbumInstance->settheme
                  if (isset($album['last_mod_time']) && $album['last_mod_time']) {
                      if (isset($album['clicks_date']) && $album['clicks_date'] > 0 &&
                        $album['clicks_date']<$album['last_mod_time']){
                        $newAlbumInstance->setCreationTimestamp($album['clicks_date']);
                        $newAlbumInstance->setOriginationTimestamp($album['clicks_date']);
                      } else {
                        $newAlbumInstance->setCreationTimestamp($album['last_mod_time']);
                        $newAlbumInstance->setOriginationTimestamp($album['last_mod_time']);
                      }
                  }
                  if (isset($album['clicks_date']) && $album['clicks_date']>0) {
                      $newAlbumInstance->setviewedSinceTimestamp($album['clicks_date']);
                  }

                  /* $newAlbumInstance->setorderBy */
                  /* $newAlbumInstance->setorderDirection */

                  /* Set album owner */
                  if (isset($album['owner'])) {
                      $validUID = Gallery1DataParser::isValidUid($albumsPath,
                                                       $album['owner']);
                      if ($validUID) {
                        list($ret, $albumUserFields) =
                            Gallery1DataParser::getUserFieldsByUid($albumsPath,
                                                         $album['owner']);
                        if ($ret->isError()) {
                            return $ret->wrap(__FILE__, __LINE__);
                        }
                        list($ret, $owner) =
                            GalleryCoreApi::fetchUserByUsername(
                              GalleryCoreApi::convertToUtf8(
                                  $albumUserFields['username'], $sourceEncoding));
                        if ($ret->isError()) {
                            if ($ret->getErrorCode() & ERROR_MISSING_OBJECT) {
                              $owner = $gallery->getActiveUser();
                            } else {
                              return $ret->wrap(__FILE__, __LINE__);
                            }
                        }
                        $newAlbumInstance->setOwnerId($owner->getId());
                      }
                  }
                  /* Save the new album */
                  $ret = $newAlbumInstance->save();
                  if ($ret->isError()) {
                      GalleryCoreApi::releaseLocks($importLockIds);
                      return $ret->wrap(__FILE__, __LINE__);
                  }
                  $numberOfItemsImported++;

                  $ret = $this->checkTruncation($newAlbumInstance, $sourceData);
                  if ($ret->isError()) {
                      GalleryCoreApi::releaseLocks($importLockIds);
                      return $ret->wrap(__FILE__, __LINE__);
                  }

                  /* Create custom fields */
                  if (isset($customFieldInterface) && !empty($album['extra_fields'])) {
                      /* Skip these metadata type fields: */
                      $extraFields = array_diff($album['extra_fields'],
                        array('Upload Date', 'Capture Date', 'Dimensions', 'EXIF'),
                        $skipCustomItemFields);
                      if (!empty($extraFields)) {
                        foreach ($extraFields as $i => $field) {
                            $extraFields[$i] =
                              $this->convertHtml('html', $field, $sourceEncoding);
                        }
                        list ($ret) = $customFieldInterface->createCustomFields(
                                         $extraFields, $newAlbumInstance->getId());
                        if ($ret->isError()) {
                            return $ret->wrap(__FILE__, __LINE__);
                        }
                      }
                  }

                  $itemsCreated[] = $newAlbumInstance->getId();

                  /* Set order weight */
                  if (isset($albumPosition[$album['name']])) {
                      $weight = $albumPosition[$album['name']];
                  } else {
                      list ($ret, $weight) = GalleryCoreApi::fetchExtremeChildWeight(
                        $targetAlbumID, HIGHER_WEIGHT);
                      if ($ret->isError()) {
                        GalleryCoreApi::releaseLocks($importLockIds);
                        return $ret->wrap(__FILE__, __LINE__);
                      }
                      $weight += 1000;
                  }
                  $ret = GalleryCoreApi::setItemOrderWeight(
                      $newAlbumInstance->getId(), $weight);
                  if ($ret->isError()) {
                      GalleryCoreApi::releaseLocks($importLockIds);
                      return $ret->wrap(__FILE__, __LINE__);
                  }

                  /* album permissions */
                  $ret = GalleryCoreApi::removeItemPermissions($newAlbumInstance->getId());
                  if ($ret->isError()) {
                      GalleryCoreApi::releaseLocks($importLockIds);
                      return $ret->wrap(__FILE__, __LINE__);
                  }
                  if ($adminUsersGroupId) {
                      $ret = GalleryCoreApi::addGroupPermission($newAlbumInstance->getId(),
                                                      $adminUsersGroupId,
                                                      'core.all',
                                                      false);
                      if ($ret->isError()) {
                        return $ret->wrap(__FILE__, __LINE__);
                      }
                  }

                  /* Set album owner permissions */
                  $validUID = Gallery1DataParser::isValidUid($albumsPath, $album['owner']);
                  if ($validUID) {
                      list($ret, $albumUserFields) = Gallery1DataParser::getUserFieldsByUid(
                        $albumsPath, $album['owner']);
                      if ($ret->isError()) {
                      GalleryCoreApi::releaseLocks($importLockIds);
                        return $ret->wrap(__FILE__, __LINE__);
                      }
                      list($ret, $owner) = GalleryCoreApi::fetchUserByUsername(
                        GalleryCoreApi::convertToUtf8(
                            $albumUserFields['username'], $sourceEncoding));
                      if ($ret->isError()) {
                        if ($ret->getErrorCode() & ERROR_MISSING_OBJECT) {
                            $owner = $gallery->getActiveUser();
                        } else {
                            GalleryCoreApi::releaseLocks($importLockIds);
                            return $ret->wrap(__FILE__, __LINE__);
                        }
                      }
                      $ret = GalleryCoreApi::addUserPermission($newAlbumInstance->getId(),
                                                     $owner->getId(),
                                                     'core.all',
                                                     true);
                      if ($ret->isError()) {
                        GalleryCoreApi::releaseLocks($importLockIds);
                        return $ret->wrap(__FILE__, __LINE__);
                      }
                  }

                  if (isset($album['perms'])) {
                      foreach($album['perms'] as $tmpperm => $tmpusers) {
                        foreach($permissionTranslation[$tmpperm] as $tmpTranslatedPerm) {
                            if ($isHiddenAlbum && $tmpTranslatedPerm == 'core.view') {
                              /* Omit view permission for hidden albums */
                              continue;
                            }
                            foreach(array_keys($tmpusers) as $tmpuser) {
                              switch ($tmpuser) {
                              case 'Logged In':
                                  if ($allUsersGroupId) {
                                    $ret = GalleryCoreApi::addGroupPermission(
                                        $newAlbumInstance->getId(),
                                        $allUsersGroupId,
                                        $tmpTranslatedPerm,
                                        false);
                                    if ($ret->isError()) {
                                        GalleryCoreApi::releaseLocks($importLockIds);
                                        return $ret->wrap(__FILE__, __LINE__);
                                    }
                                  }
                                  break;
                              case 'everybody':
                                  if ($everybodyGroupId) {
                                    $ret = GalleryCoreApi::addGroupPermission(
                                        $newAlbumInstance->getId(),
                                        $everybodyGroupId,
                                        $tmpTranslatedPerm,
                                        false);
                                    if ($ret->isError()) {
                                        GalleryCoreApi::releaseLocks($importLockIds);
                                        return $ret->wrap(__FILE__, __LINE__);
                                    }
                                  }
                                  break;
                              case 'Nobody':
                                  break;
                              case 'admin':
                                  break;
                              default:
                                  $validPermUID = Gallery1DataParser::isValidUid(
                                    $albumsPath, $tmpuser);
                                  if ($validPermUID) {
                                    list($ret, $permsUserFields) =
                                        Gallery1DataParser::getUserFieldsByUid(
                                          $albumsPath, $tmpuser);
                                    if ($ret->isError()) {
                                        GalleryCoreApi::releaseLocks($importLockIds);
                                        return $ret->wrap(__FILE__, __LINE__);
                                    }
                                    $permUsername = $permsUserFields['username'];
                                    list($ret, $permUser) =
                                        GalleryCoreApi::fetchUserByUsername(
                                          GalleryCoreApi::convertToUtf8(
                                              $permUsername, $sourceEncoding));
                                    if ($ret->isError() &&
                                          !($ret->getErrorCode() & ERROR_MISSING_OBJECT)) {
                                        GalleryCoreApi::releaseLocks($importLockIds);
                                        return $ret->wrap(__FILE__, __LINE__);
                                    }
                                    if ($permUser) {
                                        $ret = GalleryCoreApi::addUserPermission(
                                          $newAlbumInstance->getId(),
                                          $permUser->getId(),
                                          $tmpTranslatedPerm,
                                          false);
                                        if ($ret->isError()) {
                                          GalleryCoreApi::releaseLocks($importLockIds);
                                          return $ret->wrap(__FILE__, __LINE__);
                                        }
                                    }
                                  }
                              }
                            }
                        }
                      }
                  }

                  /* Click counts must be set after the item is first saved */
                  if (isset($album['clicks'])) {
                      $ret = GalleryCoreApi::setItemViewCount(
                        $newAlbumInstanceId, $album['clicks']);
                      if ($ret->isError()) {
                        GalleryCoreApi::releaseLocks($importLockIds);
                        return $ret->wrap(__FILE__, __LINE__);
                      }
                  }

                  /* Delete existing derivative preferences */
                  $ret =
                      GalleryCoreApi::removeDerivativePreferencesForItem($newAlbumInstanceId);
                  if ($ret->isError()) {
                      GalleryCoreApi::releaseLocks($importLockIds);
                      return $ret->wrap(__FILE__, __LINE__);
                  }

                  /* Add the thumbnail size back in */
                  if (isset($album['thumb_size'])) {
                      $ret = GalleryCoreApi::addDerivativePreference(
                        0, $newAlbumInstanceId, DERIVATIVE_TYPE_IMAGE_THUMBNAIL,
                        'thumbnail|' . $album['thumb_size']);
                  }
                  if ($ret->isError()) {
                      GalleryCoreApi::releaseLocks($importLockIds);
                      return $ret->wrap(__FILE__, __LINE__);
                  }

                  if (isset($album['resize_size']) && $album['resize_size'] > 0) {
                      $ret = GalleryCoreApi::addDerivativePreference(
                        1, $newAlbumInstanceId, DERIVATIVE_TYPE_IMAGE_RESIZE,
                        'scale|' . $album['resize_size']);
                      if ($ret->isError()) {
                        GalleryCoreApi::releaseLocks($importLockIds);
                        return $ret->wrap(__FILE__, __LINE__);
                      }
                  }

                  list ($ret, $themeId) = GalleryCoreApi::fetchThemeId($newAlbumInstance);
                  if ($ret->isError()) {
                      GalleryCoreApi::releaseLocks($importLockIds);
                      return $ret->wrap(__FILE__, __LINE__);
                  }
                  list ($ret, $theme) = GalleryCoreApi::loadPlugin('theme', $themeId);
                  if ($ret->isError()) {
                      GalleryCoreApi::releaseLocks($importLockIds);
                      return $ret->wrap(__FILE__, __LINE__);
                  }
                  list ($ret, $settings) = $theme->getSettings($newAlbumInstanceId);
                  if ($ret->isError()) {
                      GalleryCoreApi::releaseLocks($importLockIds);
                      return $ret->wrap(__FILE__, __LINE__);
                  }

                  $ret = $theme->setParameter('rows', $album['rows'], $newAlbumInstanceId);
                  if ($ret->isError()) {
                      GalleryCoreApi::releaseLocks($importLockIds);
                      return $ret->wrap(__FILE__, __LINE__);
                  }

                  $ret = $theme->setParameter('columns', $album['cols'], $newAlbumInstanceId);
                  if ($ret->isError()) {
                      GalleryCoreApi::releaseLocks($importLockIds);
                      return $ret->wrap(__FILE__, __LINE__);
                  }

                  if (isset($newAlbumInstanceId)) {
                      $finishedAlbums[$album['name']] = $newAlbumInstanceId;
                      $status['albumImportSuccess'][$album['name']] = $newAlbumInstanceId;
                  } else {
                      GalleryCoreApi::releaseLocks($importLockIds);
                      return $ret->wrap(__FILE__, __LINE__);
                  }
                }
                /*
                 * we can let the parent album (and anything else that we might
                 * have tied up) be edited by others now
                 */
                $ret = GalleryCoreApi::releaseLocks($importLockIds);
                if ($ret->isError()) {
                  return $ret->wrap(__FILE__, __LINE__);
                } else {
                  $importLockIds = array();
                }

                unset($photos);
                list ($ret, $photos) =
                  Gallery1DataParser::getPhotos($albumsPath . $album['name']);
                if ($ret->isError()) {
                  return $ret->wrap(__FILE__, __LINE__);
                }
                if (!isset($photos)) {
                  $photos = array();
                }

                $albumHighlight[$newAlbumInstanceId] = false;
                list ($ret, $item) = GalleryCoreApi::loadEntitiesById($newAlbumInstanceId);
                if ($ret->isError()) {
                  return $ret->wrap(__FILE__, __LINE__);
                }

                list ($ret, $importLockIds[]) =
                  GalleryCoreApi::acquireReadLock($item->getId());
                if ($ret->isError()) {
                  return $ret->wrap(__FILE__, __LINE__);
                }
                list ($ret, $thumbnailTable) =
                  GalleryCoreApi::fetchThumbnailsByItemIds(array($item->getId()));
                if ($ret->isError()) {
                  GalleryCoreApi::releaseLocks($importLockIds);
                  return $ret->wrap(__FILE__, __LINE__);
                }
                $albumNeedsThumbnail = empty($thumbnailTable) ? true : false;

                foreach($photos as $j => $importAlbumItem) {
                  $gallery->guaranteeTimeLimit(30);
                  if (isset($importAlbumItem->isAlbumName) && $importAlbumItem->isAlbumName) {
                      if ($importAlbumItem->highlight == 1) {
                        $albumHighlight[$newAlbumInstanceId] =
                            $importAlbumItem->isAlbumName;
                      }
                      list ($ret, $weight) = GalleryCoreApi::fetchExtremeChildWeight(
                        $newAlbumInstanceId, HIGHER_WEIGHT);
                      if ($ret->isError()) {
                        GalleryCoreApi::releaseLocks($importLockIds);
                        return $ret->wrap(__FILE__, __LINE__);
                      }
                      $albumPosition[$importAlbumItem->isAlbumName] = $weight + 100 + $j;
                      if (isset($importAlbumItem->hidden) && $importAlbumItem->hidden) {
                        $hiddenAlbums[$importAlbumItem->isAlbumName] = true;
                      }
                      $importAlbumItem = null;
                  } else {
                      $dir = $albumsPath . $album['name'] . $slash;
                      $filename = $importAlbumItem->image->name . '.' .
                        $importAlbumItem->image->type;
                      $filepath = $dir . $filename;

                      $ret = $templateAdapter->updateProgressBar(
                        $importPhotosMessage, $album['name'] . ' ' . $filename,
                        $numberOfItemsImported / $totalItemsToImport);
                      if ($ret->isError()) {
                        GalleryCoreApi::releaseLocks($importLockIds);
                        return $ret->wrap(__FILE__, __LINE__);
                      }

                      list ($base, $extension) =
                        GalleryUtilities::getFileNameComponents($filename);
                      list ($ret, $mimeType) =
                        GalleryCoreApi::convertExtensionToMime($extension);
                      if ($ret->isError()) {
                        GalleryCoreApi::releaseLocks($importLockIds);
                        return $ret->wrap(__FILE__, __LINE__);
                      }

                      $convertedCaption = $this->convertHtml(
                        $markupType, $importAlbumItem->caption, $sourceEncoding);

                      $data = array('title' => '', 'summary' => '', 'description' => '');
                      foreach (array_keys($data) as $field) {
                        switch ($form['set'][$field]) {
                        case 'filename':
                            $data[$field] = $base;
                            break;
                        case 'caption':
                            $data[$field] = $convertedCaption;
                            break;
                        case 'custom':
                            $customField = $form['customfield'][$field];
                            if (isset($importAlbumItem->extraFields[$customField])) {
                              $data[$field] = $this->convertHtml(
                                  $markupType, $importAlbumItem->extraFields[$customField],
                                  $sourceEncoding);
                            } else if ($field == 'description' &&
                                     isset($form['set']['defaultDescription'])) {
                              $data[$field] = $data['summary'];
                            }
                        }
                      }

                      list ($ret, $newItem) = GalleryCoreApi::addItemToAlbum(
                        $filepath, $filename, $data['title'], $data['summary'],
                        $data['description'], $mimeType, $item->getId());
                      if ($ret->isError()) {
                        GalleryCoreApi::releaseLocks($importLockIds);
                        return $ret->wrap(__FILE__, __LINE__);
                      }
                      $itemsCreated[] = $newItem->getId();
                      $numberOfItemsImported++;

                      $ret = $this->checkTruncation($newItem, $data);
                      if ($ret->isError()) {
                        GalleryCoreApi::releaseLocks($importLockIds);
                        return $ret->wrap(__FILE__, __LINE__);
                      }

                      if (isset($form['urlRedirect'])) {
                        $ret = $this->createG1ToG2Mapping(
                            $newItem->getId(), $album['name'],
                            $importAlbumItem->image->name);
                        if ($ret->isError()) {
                            GalleryCoreApi::releaseLocks($importLockIds);
                            return $ret->wrap(__FILE__, __LINE__);
                        }
                      }
                      $itemLockIds = array();
                      list ($ret, $itemLockIds[]) =
                        GalleryCoreApi::acquireWriteLock($newItem->getId());
                      if ($ret->isError()) {
                        GalleryCoreApi::releaseLocks($importLockIds);
                        return $ret->wrap(__FILE__, __LINE__);
                      }

                      $newItem->setKeywords(GalleryCoreApi::convertToUtf8(
                                          $importAlbumItem->keywords, $sourceEncoding));

                      if (isset($importAlbumItem->uploadDate)){
                        $newItem->setCreationTimestamp($importAlbumItem->uploadDate);
                      }
                      if (isset($importAlbumItem->itemCaptureDate)){
                        /* Before 1.4.5-cvs-b106 this was an associative array */
                        if (is_array($importAlbumItem->itemCaptureDate)) {
                            $newItem->setOriginationTimestamp(
                              mktime($importAlbumItem->itemCaptureDate['hours'],
                                     $importAlbumItem->itemCaptureDate['minutes'],
                                     $importAlbumItem->itemCaptureDate['seconds'],
                                     $importAlbumItem->itemCaptureDate['mon'],
                                     $importAlbumItem->itemCaptureDate['mday'],
                                     $importAlbumItem->itemCaptureDate['year']));
                        } else {
                            $newItem->setOriginationTimestamp(
                              $importAlbumItem->itemCaptureDate);
                        }
                      } else if (isset($importAlbumItem->uploadDate)){
                        $newItem->setOriginationTimestamp($importAlbumItem->uploadDate);
                      }
                      if (isset($album['clicks_date']) && $album['clicks_date']>0) {
                        $newItem->setviewedSinceTimestamp($album['clicks_date']);
                      }
                      if (isset($importAlbumItem->clicks) && $importAlbumItem->clicks > 0) {
                        $ret = GalleryCoreApi::setItemViewCount(
                            $newItem->getId(), $importAlbumItem->clicks);
                        if ($ret->isError()) {
                            GalleryCoreApi::releaseLocks($importLockIds);
                            return $ret->wrap(__FILE__, __LINE__);
                        }
                      }
                      if (isset($importAlbumItem->image->thumb_x) &&
                        isset($importAlbumItem->image->thumb_y) &&
                        isset($importAlbumItem->image->thumb_width) &&
                        isset($importAlbumItem->image->thumb_height) &&
                        $importAlbumItem->image->thumb_width > 0 &&
                        $importAlbumItem->image->thumb_height > 0){

                        /* Load the thumbnail */
                        $thumbnails = array();
                        list ($ret, $thumbnails) = GalleryCoreApi::fetchThumbnailsByItemIds(
                            array($newItem->getId()));
                        if ($ret->isError()) {
                            GalleryCoreApi::releaseLocks($importLockIds);
                            return $ret->wrap(__FILE__, __LINE__);
                        }

                        if (!empty($thumbnails)) {
                            $thumbnail = $thumbnails[$newItem->getId()];

                            list ($ret, $lock) =
                              GalleryCoreApi::acquireWriteLock($thumbnail->getId());
                            if ($ret->isError()) {
                              GalleryCoreApi::releaseLocks($importLockIds);
                              return $ret->wrap(__FILE__, __LINE__);
                            }

                            list ($ret, $thumbnail) = $thumbnail->refresh();
                            if ($ret->isError()) {
                              GalleryCoreApi::releaseLocks($importLockIds);
                              GalleryCoreApi::releaseLocks($lock);
                              return $ret->wrap(__FILE__, __LINE__);
                            }

                            $width = $importAlbumItem->image->raw_width;
                            $height = $importAlbumItem->image->raw_height;
                            $xPerc = GalleryUtilities::roundToString(
                              $importAlbumItem->image->thumb_x * 100 / $width, 3);
                            $yPerc = GalleryUtilities::roundToString(
                              $importAlbumItem->image->thumb_y * 100 / $height, 3);
                            $widthPerc = GalleryUtilities::roundToString(
                              $importAlbumItem->image->thumb_width * 100 / $width, 3);
                            $heightPerc = GalleryUtilities::roundToString(
                              $importAlbumItem->image->thumb_height * 100 / $height, 3);
                            list ($ret, $operations) =
                              GalleryCoreApi::mergeDerivativeOperations(
                                  $thumbnail->getDerivativeOperations(),
                                  sprintf('crop|%s,%s,%s,%s',
                                        $xPerc, $yPerc,
                                        $widthPerc, $heightPerc),
                                  true);
                            if ($ret->isError()) {
                              GalleryCoreApi::releaseLocks($importLockIds);
                              GalleryCoreApi::releaseLocks($lock);
                              return $ret->wrap(__FILE__, __LINE__);
                            }
                            $thumbnail->setDerivativeOperations($operations);

                            $thumbnail->setWidth(0);
                            $thumbnail->setHeight(0);

                            $ret = $thumbnail->save();
                            if ($ret->isError()) {
                              GalleryCoreApi::releaseLocks($importLockIds);
                              return $ret->wrap(__FILE__, __LINE__);
                            }
                            $ret = GalleryCoreApi::releaseLocks($lock);
                            if ($ret->isError()) {
                              GalleryCoreApi::releaseLocks($importLockIds);
                              return $ret->wrap(__FILE__, __LINE__);
                            }

                            /*
                             * Changing the crop size causes our
                             * derivative dimensions to change,
                             * which affects all our dependent
                             * derivatives also.
                             */
                            $ret = GalleryCoreApi::invalidateDerivativeDimensionsBySourceIds(
                              array($thumbnail->getId()));
                            if ($ret->isError()) {
                              GalleryCoreApi::releaseLocks($importLockIds);
                              return $ret->wrap(__FILE__, __LINE__);
                            }
                        }
                      }

                      $validItemUID = false;
                      $itemUID = false;
                      $defaultToAlbumUID = true;
                      if (isset($importAlbumItem->owner)) {
                        if (!strcmp('everybody', $importAlbumItem->owner)
                            || !strcmp('nobody', $importAlbumItem->owner)
                            ) {
                            $defaultToAlbumUID = false;
                            $newItem->setownerId($guestUserId);
                        } else if (strcmp('logged-in', $importAlbumItem->owner)) {
                            $validItemUID = Gallery1DataParser::isValidUid(
                              $albumsPath, $importAlbumItem->owner);
                            if ($validItemUID) {
                              $defaultToAlbumUID = false;
                              $itemUID = $importAlbumItem->owner;
                            }
                        }
                      }
                      if ($defaultToAlbumUID) {
                        $validItemUID =
                            Gallery1DataParser::isValidUid($albumsPath, $album['owner']);
                        if ($validItemUID) {
                            $itemUID = $album['owner'];
                        }
                      }
                      if ($validItemUID && $itemUID) {
                        list($ret, $albumItemUserFields) =
                            Gallery1DataParser::getUserFieldsByUid(
                              $albumsPath, $itemUID);
                        if ($ret->isError()) {
                            GalleryCoreApi::releaseLocks($importLockIds);
                            return $ret->wrap(__FILE__, __LINE__);
                        }
                        list($ret, $itemOwner) = GalleryCoreApi::fetchUserByUsername(
                            GalleryCoreApi::convertToUtf8(
                              $albumItemUserFields['username'], $sourceEncoding));
                        if ($ret->isError() &&
                              !($ret->getErrorCode() & ERROR_MISSING_OBJECT)) {
                            GalleryCoreApi::releaseLocks($importLockIds);
                            return $ret->wrap(__FILE__, __LINE__);
                        }
                        if ($itemOwner) {
                            $newItem->setownerId($itemOwner->getId());
                        }
                      }

                      $ret = $newItem->save();
                      if ($ret->isError()) {
                        GalleryCoreApi::releaseLocks($importLockIds);
                        return $ret->wrap(__FILE__, __LINE__);
                      }

                      if (isset($importAlbumItem->hidden) && $importAlbumItem->hidden) {
                        /* remove view permission for hidden item */
                        list ($ret, $itemPermissions) =
                            GalleryCoreApi::fetchAllPermissionsForItem($newItem->getId());
                        if ($ret->isError()) {
                            GalleryCoreApi::releaseLocks($importLockIds);
                            return $ret->wrap(__FILE__, __LINE__);
                        }
                        foreach ($itemPermissions as $itemPermission) {
                            if ($itemPermission['permission'] == 'core.view' &&
                                  $itemPermission['userId'] != $newItem->getOwnerId() &&
                                  $itemPermission['groupId'] != $adminUsersGroupId) {
                              if ($itemPermission['userId'] > 0) {
                                  $ret = GalleryCoreApi::removeUserPermission(
                                    $newItem->getId(), $itemPermission['userId'],
                                    'core.view', false);
                                  if ($ret->isError()) {
                                    GalleryCoreApi::releaseLocks($importLockIds);
                                    return $ret->wrap(__FILE__, __LINE__);
                                  }
                              } else {
                                  $ret = GalleryCoreApi::removeGroupPermission(
                                    $newItem->getId(), $itemPermission['groupId'],
                                    'core.view', false);
                                  if ($ret->isError()) {
                                    GalleryCoreApi::releaseLocks($importLockIds);
                                    return $ret->wrap(__FILE__, __LINE__);
                                  }
                              }
                            }
                        }
                      }

                      /* Set custom field values */
                      if (isset($customFieldInterface) &&
                            !empty($importAlbumItem->extraFields)) {
                        $extraFields = array();
                        foreach ($importAlbumItem->extraFields as $key => $value) {
                            if (in_array($key, $skipCustomItemFields)) {
                              continue;
                            }
                            $key = $this->convertHtml('html', $key, $sourceEncoding);
                            $extraFields[$key] = $this->convertHtml($markupType, $value,
                                                          $sourceEncoding);
                        }
                        if (!empty($extraFields)) {
                            $ret = $customFieldInterface->setCustomFieldValues(
                                      $newItem->getId(), $extraFields);
                            if ($ret->isError()) {
                              return $ret->wrap(__FILE__, __LINE__);
                            }
                        }
                      }

                      if ($importComments && isset($importAlbumItem->comments) &&
                        count($importAlbumItem->comments)>0) {
                        foreach ($importAlbumItem->comments as
                               $importCommentId => $importComment) {
                            if (strcmp($importComment->UID, 'everybody')) {
                              $validCommentUid = Gallery1DataParser::isValidUid(
                                  $albumsPath, $album['owner']);
                              if ($validCommentUid){
                                  list($ret, $commentG1User) =
                                    Gallery1DataParser::getUserFieldsByUid(
                                        $albumsPath, $album['owner']);
                                  if ($ret->isError()) {
                                    GalleryCoreApi::releaseLocks($importLockIds);
                                    return $ret->wrap(__FILE__, __LINE__);
                                  }
                                  list($ret, $commentG2User) =
                                    GalleryCoreApi::fetchUserByUsername(
                                        GalleryCoreApi::convertToUtf8(
                                          $commentG1User['username'],
                                          $sourceEncoding));
                                  if ($ret->isError()) {
                                    if (!($ret->getErrorCode() & ERROR_MISSING_OBJECT)) {
                                        GalleryCoreApi::releaseLocks($importLockIds);
                                        return $ret->wrap(__FILE__, __LINE__);
                                    } else {
                                        $commenterId = $guestUserId;
                                    }
                                  } else {
                                    $commenterId = $commentG2User->getId();
                                  }
                              }
                            } else {
                              $commenterId = $guestUserId;
                            }

                            /* Add the comment */
                            list ($ret, $comment) = GalleryCoreApi::newFactoryInstance(
                              'GalleryEntity', 'GalleryComment');
                            if ($ret->isError()) {
                              GalleryCoreApi::releaseLocks($importLockIds);
                              return $ret->wrap(__FILE__, __LINE__);
                            }

                            if (!isset($comment)) {
                              GalleryCoreApi::releaseLocks($importLockIds);
                              return GalleryStatus::error(
                                  ERROR_MISSING_OBJECT, __FILE__, __LINE__);
                            }

                            $ret = $comment->create($newItem->getId());
                            if ($ret->isError()) {
                              GalleryCoreApi::releaseLocks($importLockIds);
                              return $ret->wrap(__FILE__, __LINE__);
                            }

                            $comment->setCommenterId($commenterId);
                            $comment->setHost(empty($importComment->IPNumber) ?
                                          'unknown' :
                                          $importComment->IPNumber);
                            if ($commenterId == $guestUserId) {
                              $comment->setSubject($importComment->name);
                            } else {
                              $comment->setSubject('');
                            }
                            $comment->setComment(
                              ConfirmImportController::convertHtml(
                                  $markupType, $importComment->commentText,
                                  $sourceEncoding));
                            $comment->setDate($importComment->datePosted);

                            $ret = $comment->save();
                            if ($ret->isError()) {
                              GalleryCoreApi::releaseLocks($importLockIds);
                              return $ret->wrap(__FILE__, __LINE__);
                            }
                        }
                      }
                      $ret = GalleryCoreApi::releaseLocks($itemLockIds);
                      if ($ret->isError()) {
                        return $ret->wrap(__FILE__, __LINE__);
                      } else {
                        $itemLockIds = array();
                      }
                      $status['addFromLocalServer'][] = array('fileName' => $filename,
                                                    'id' => $newItem->getId());
                      if (($albumNeedsThumbnail || $importAlbumItem->highlight == 1)) {
                        $toolkit = null;

                        list ($ret, $toolkit, $outputMimeType) =
                            GalleryCoreApi::getToolkitByOperation(
                              $newItem->getMimeType(), 'thumbnail');
                        if ($ret->isError()) {
                            return $ret->wrap(__FILE__, __LINE__);
                        }

                        if (isset($toolkit)) {
                            list ($ret, $success) = GalleryCoreApi::setThumbnailFromItem(
                              $item->getId(), $newItem->getId());
                            if ($ret->isError()) {
                              return $ret->wrap(__FILE__, __LINE__);
                            }
                            $albumNeedsThumbnail = false;
                        }
                      }
                  }
                }
            }
            $ret = $templateAdapter->updateProgressBar($importPhotosMessage,
                $album['name'], $numberOfItemsImported / $totalItemsToImport);
            if ($ret->isError()) {
                return $ret->wrap(__FILE__, __LINE__);
            }
            $album = null;
            /* $i keeps track of how many passes we make over the data */
            $i++;
          }
      }

      /* Checkpoint to ensure items are saved to the DB in case of a later failure */
      $ret = $storage->checkPoint();
      if ($ret->isError()) {
          return $ret->wrap(__FILE__, __LINE__);
      }

      //$albumHighlight[$newAlbumInstanceId]=$importAlbumItem->isAlbumName;
      //$finishedAlbums[$album['name']] = $newAlbumInstanceId;
      foreach ($albumHighlight as $highlightRecipientId => $nameOfAlbumToHighlight) {
          if (isset($finishedAlbums[$nameOfAlbumToHighlight]) &&
            $finishedAlbums[$nameOfAlbumToHighlight]) {
            list ($ret, $item) = GalleryCoreApi::loadEntitiesById($highlightRecipientId);
            if ($ret->isError()) {
                return $ret->wrap(__FILE__, __LINE__);
            }
            list ($ret, $importLockIds[]) = GalleryCoreApi::acquireReadLock($item->getId());
            if ($ret->isError()) {
                return $ret->wrap(__FILE__, __LINE__);
            }
            list ($ret, $success) = GalleryCoreApi::setThumbnailFromItem(
                $item->getId(), $finishedAlbums[$nameOfAlbumToHighlight]);
            if ($ret->isError()) {
                GalleryCoreApi::releaseLocks($importLockIds);
                return $ret->wrap(__FILE__, __LINE__);
            }
          }
      }

      if (isset($importLockIds)) {
          $ret = GalleryCoreApi::releaseLocks($importLockIds);
          if ($ret->isError()) {
            return $ret->wrap(__FILE__, __LINE__);
          } else {
            $importLockIds = array();
          }
      }

      /* Checkpoint to ensure highlights are saved to the DB in case of a later failure */
      $ret = $storage->checkPoint();
      if ($ret->isError()) {
          return $ret->wrap(__FILE__, __LINE__);
      }

      $templateAdapter->resetProgressBarStats();

      if (!empty($form['generateThumbnails']) && !connection_aborted()) {
          /*
           * Get the thumbnails for all of the items we created, in 20 item
           * increments so that we don't consume too much memory.
           *
           * Note: this destroys the $itemsCreated array!
           */
          $createThumbsMessage = $module->translate('Creating thumbnails');
          $itemsCreatedCount = count($itemsCreated);
          $thumbsCreated = 0;
          while (!empty($itemsCreated)) {
            $chunk = array_splice($itemsCreated, 0, 20);
            list ($ret, $thumbTable) = GalleryCoreApi::fetchThumbnailsByItemIds($chunk);
            if ($ret->isError()) {
                return $ret->wrap(__FILE__, __LINE__);
            }

            foreach ($thumbTable as $thumbnail) {
                list ($ret, $newThumbnail, $wasRebuilt) =
                  GalleryCoreApi::rebuildDerivativeCacheIfNotCurrent($thumbnail->getId());
                if ($ret->isError()) {
                  return $ret->wrap(__FILE__, __LINE__);
                }

                $thumbsCreated++;
                $ret = $templateAdapter->updateProgressBar(
                  $createThumbsMessage,
                  $module->translate(array('text' => 'Thumbnail %d of %d',
                                     'arg1' => $thumbsCreated,
                                     'arg2' => $itemsCreatedCount)),
                  $thumbsCreated / $itemsCreatedCount);
                if ($ret->isError()) {
                  return $ret->wrap(__FILE__, __LINE__);
                }
            }
            GalleryDataCache::reset();
          }
      }

      /* Checkpoint to ensure thumbnails are saved to the DB in case of a later failure */
      $ret = $storage->checkPoint();
      if ($ret->isError()) {
          return $ret->wrap(__FILE__, __LINE__);
      }

      $session =& $gallery->getSession();

      $redirect['view'] = 'core.SiteAdmin';
      $redirect['subView'] = 'migrate.ImportResults';
      $redirect['statusId'] = $session->putStatus($status);

      $urlGenerator =& $gallery->getUrlGenerator();
      $templateAdapter->completeProgressBar($urlGenerator->generateUrl($redirect));

      return GalleryStatus::success();
    }

    /**
     * Convert html according to given markup type
     * @param string markup type (none, bbcode, html)
     * @param string input string
     * @return string
     */
01407     function convertHtml($markupType, $item, $sourceEncoding='UTF-8') {
      $item = GalleryCoreApi::convertToUtf8($item, $sourceEncoding);
      switch ($markupType) {
      case 'bbcode':
          $item = ConfirmImportController::convertHtmlToBbcode($item);
          break;

      case 'html':
          break;

      case 'none':
      default:
          $item = strip_tags($item);
      }
      GalleryUtilities::sanitizeInputValues($item, false);
      return $item;
    }

    /**
     * Converts HTML to BBCode
     *
     * @param string $item item to convert
     * @return string
     */
01431     function convertHtmlToBbcode($item) {
      static $patterns, $match, $replace;
      if (!isset($patterns)) {
          $patterns = array(
            '#<br\s*(/?)>#i' => "\n",
            '#<(/?)(b|strong)>#i' => '[$1b]',
            '#<(/?)(i|em)>#i' => '[$1i]',
            '#<(/?)ul>#i' => '[$1list]',
            '#<li>#i' => '[*]',
            '#</li>#i' => '',
            '#<img[^>]*\s+src\s*=\s*["\']{0,1}([^\s"\'>]+)["\']{0,1}[^>]*>#is' => '[img]$1[/img]',
            '#<a[^>]*\s+href\s*=\s*["\']{0,1}([^\s"\'>]+)["\']{0,1}[^>]*>\s*(.*?)\s*</a>#is' =>
                                                            '[url=$1]$2[/url]',
          );
          $match = array_keys($patterns);
          $replace = array_values($patterns);
      }

      $item = preg_replace($match, $replace, $item);
      return strip_tags($item);
    }

    /**
     * Create the G1->G2 map entries so that Gallery1 links
     * can be redirected to Gallery2 links.
     * @param int item id
     * @param string G1 album name
     * @param string (optional) G1 item name
     * @return object GalleryStatus a status code
     * @author Joseph Elwell <jelwell@yahoo.com>
     */
01462     function createG1ToG2Mapping($itemId, $g1AlbumName, $g1ItemName=null) {
      $ret = G1MigrateMap::addMapEntry(
            array('itemId' => $itemId, 'g1album' => $g1AlbumName, 'g1item' => $g1ItemName) );
      if ($ret->isError()) {
          return $ret->wrap(__FILE__, __LINE__);
      }
      return GalleryStatus::success();
    }

    /**
     * Print message if any fields were truncated on imported item.
     */
01474     function checkTruncation(&$item, $sourceData) {
      global $gallery;
      static $titleMessage, $summaryMessage, $setMessage, $truncatedMessage;
      if (!isset($titleMessage)) {
          list ($ret, $module) = GalleryCoreApi::loadPlugin('module', 'migrate');
          if ($ret->isError()) {
            return $ret->wrap(__FILE__, __LINE__);
          }
          $titleMessage = $module->translate('%sTitle%s was truncated for %sitem %d%s.');
          $summaryMessage = $module->translate('%sSummary%s was truncated for %sitem %d%s.');
          $setMessage = $module->translate('Set:');
          $truncatedMessage = $module->translate('Truncated:');
      }

      $data = array($item->getTitle(), $sourceData['title'], $titleMessage,
                  $item->getSummary(), $sourceData['summary'], $summaryMessage);
      while (!empty($data)) {
          list ($value, $source, $message) = array_splice($data, 0, 3);
          if ($value != $source) {
            if (!isset($urlGenerator)) {
                $urlGenerator =& $gallery->getUrlGenerator();
            }
            printf("<div class=\"gbBlock\">$message<br/>" .
               "<b>$setMessage</b> %s<br/><b>$truncatedMessage</b> %s</div>",
               '<b>', '</b>',
               '<a href="' . $urlGenerator->generateUrl(
                  array('view' => 'core.ItemAdmin', 'subView' => 'core.ItemEdit',
                        'itemId' => $item->getId(), 'editPlugin' => 'ItemEditItem')) . '">',
               $item->getId(),
               '</a>',
               $value,
               substr($source, strlen($value)));
          }
      }

      return GalleryStatus::success();
    }
}


/**
 * @package Migrate
 * @subpackage UserInterface
 */
01518 class ConfirmImportView extends GalleryView {

    /**
     * @see GalleryView::loadTemplate
     */
01523     function loadTemplate(&$template, &$form) {
      global $gallery;
      $platform = $gallery->getPlatform();
      $illegalAlbumNames = $existingAlbums = $titles = array();
      $albumValidOwner = $albumOwnerUserName = $albumOwnerUid = $albumfields = array();
      if (!isset($form['sourceAlbums'])) {
          $form['sourceAlbums'] = array();
      }
      if (!isset($form['sourceEncoding'])) {
          $form['sourceEncoding'] = 'ISO-8859-1';
      }
      $albumsPath = GalleryUtilities::getRequestVariables('albumsPath');
      $destinationAlbumID = $form['destinationAlbumID'];
      list ($ret, $uids) = Gallery1DataParser::getUserUids($albumsPath);
      if ($ret->isError()) {
          return array($ret->wrap(__FILE__, __LINE__), null);
      }
      list ($ret, $albums) = Gallery1DataParser::getAlbumList($albumsPath);
      if ($ret->isError()) {
          return array($ret->wrap(__FILE__, __LINE__), null);
      }
      list ($ret, $targetAlbum) = GalleryCoreApi::loadEntitiesById($destinationAlbumID);
      if ($ret->isError()) {
          return array($ret->wrap(__FILE__, __LINE__), null);
      }
      foreach ($form['sourceAlbums'] as $key => $value) {
          /*
           * We shouldn't really need to encode album names, but we may pass non UTF-8
           * characters in the form data, so we urlencode these values to avoid mangling
           * by some browsers.
           */
          $form['sourceAlbums'][$key] = urldecode($value);
      }
      foreach ($form['sourceAlbums'] as $sourceAlbumName) {
          if (!in_array($sourceAlbumName, array_keys($albums))) {
            return array(GalleryStatus::error(ERROR_BAD_PARAMETER, __FILE__, __LINE__), null);
          }
          list ($ret, $albumfields[$sourceAlbumName]) =
            Gallery1DataParser::loadAlbumFields($albumsPath . $sourceAlbumName);
          if ($ret->isError()) {
            return array($ret->wrap(__FILE__, __LINE__), null);
          }
      }
      $i = 0;
      while ($albumfields) {
          $existingAlbumId = false;
          $album = array_shift($albumfields);
          $albumName = $album['name'];
          if (!in_array($album['parentAlbumName'], $form['sourceAlbums'])) {
            list ($ret, $existingAlbumId) =
                GalleryCoreApi::fetchChildIdByPathComponent($destinationAlbumID, $albumName);
          }
          if ($ret->isError()) {
            if (!$ret->getErrorCode() & ERROR_MISSING_OBJECT) {
                return array($ret->wrap(__FILE__, __LINE__), null);
            }
            $existingAlbums[$albumName] = false;
          } else {
            $existingAlbums[$albumName] = $existingAlbumId;
          }
          $titles[$albumName] =
            GalleryCoreApi::convertToUtf8($album['title'], $form['sourceEncoding']);

          if (!$platform->isLegalPathComponent($albumName)){
            $illegalAlbumNames[$albumName] = $platform->legalizePathComponent($albumName);
          } else {
            $illegalAlbumNames[$albumName] = false;
          }

          $validUid = Gallery1DataParser::isValidUid($albumsPath, $album['owner']);
          if ($validUid) {
            list($ret, $testUser) = Gallery1DataParser::getUserFieldsByUid($albumsPath,
                                                             $album['owner']);
            if ($ret->isError()) {
                return array($ret->wrap(__FILE__, __LINE__), null);
            }
            $albumOwnerUserName[$albumName] = $testUser['username'];
            $albumOwnerUid[$albumName] = $album['owner'];
            list($ret, $owner) = GalleryCoreApi::fetchUserByUsername(
                GalleryCoreApi::convertToUtf8($testUser['username'], $form['sourceEncoding']));
            if ($ret->isError() && !($ret->getErrorCode() & ERROR_MISSING_OBJECT)) {
                return array($ret->wrap(__FILE__, __LINE__), null);
            }
            if (isset($form['migrateUser'][$album['owner']])) {
                $importingOwner = true;
            } else {
                $importingOwner = false;
            }
            if ($owner || $importingOwner) {
                $albumValidOwner[$albumName] = true;
            } else {
                $albumValidOwner[$albumName] = false;
            }
          } else {
            $albumValidOwner[$albumName] = true;
            $albumOwnerUserName[$albumName] = 'admin';
            $albumOwnerUid[$albumName] = null;
          }
          $i++;
      }

      $ConfirmImport = array();
      $ConfirmImport['uids'] = $uids;
      $ConfirmImport['albums'] = $albums;
      $ConfirmImport['albumsPath'] = $albumsPath;
      $ConfirmImport['existingAlbums'] = $existingAlbums;
      $ConfirmImport['illegalAlbumNames'] = $illegalAlbumNames;
      $ConfirmImport['destinationAlbumID'] = $destinationAlbumID;
      $ConfirmImport['albumValidOwner'] = $albumValidOwner;
      $ConfirmImport['albumOwnerUserName'] = $albumOwnerUserName;
      $ConfirmImport['albumOwnerUid'] = $albumOwnerUid;
      $ConfirmImport['targetAlbum'] = $targetAlbum->getMemberData();
      $ConfirmImport['titles'] = $titles;
      $template->setVariable('controller', 'migrate.ConfirmImport');
      $template->setVariable('ConfirmImport', $ConfirmImport);
      return array(GalleryStatus::success(),
                 array('body' => 'modules/migrate/templates/ConfirmImport.tpl'));
    }
}
?>

Generated by  Doxygen 1.6.0   Back to index