source: OpenPNE3/branches/fukamachi/db-convert-from-2.x/lib/task/openpneUpgradeFrom2Task.class.php @ 12837

<?php

/**
 * This file is part of the OpenPNE package.
 * (c) OpenPNE Project (http://www.openpne.jp/)
 *
 * For the full copyright and license information, please view the LICENSE
 * file and the NOTICE file that were distributed with this source code.
 */

class openpneUpgradeFrom2Task extends sfDoctrineBaseTask
{
  private $dsn3                 = '';
  private $dsn2                 = '';
  private $username             = '';
  private $password             = '';
  private $encryptKey           = '';
  private $date                 = '0000-00-00 00:00:00';
  private $mapCategoryIds       = array();
  private $birthdayProfileId    = null;
  private $validatorFile        = null;
  private $unreadDiaryIds       = array();

  private $memoryBuf            = 0;

  protected function configure()
  {
    $this->namespace        = 'openpne';
    $this->name             = 'upgrade-from-2';
    $this->briefDescription = 'Upgrade from OpenPNE 2.x';
    $this->detailedDescription = <<<EOF
The [openpne:upgrade-from-2|INFO] task does things.
Call it with:

  [php symfony openpne:upgrade-from-2|INFO]
EOF;
  }

  protected function execute($arguments = array(), $options = array())
  {
    ini_set('memory_limit', '512M');

    // install needed plugins
    $pluginInstall = new opPluginInstallTask($this->dispatcher, $this->formatter);
    $pluginInstall->run(array('opDiaryPlugin'), array('--stability=beta'));
    $pluginInstall->run(array('opCommunityTopicPlugin'), array('--stability=beta'));
    //$pluginInstall->run(array('opMessagePlugin'), array('--stability=beta'));
    //$pluginInstall->run(array('opAshiatoPlugin'), array('--stability=beta'));

    // install OpenPNE3
    $openpneInstall = new openpneInstallTask($this->dispatcher, $this->formatter);
    $openpneInstall->run();

    // ask OpenPNE2 database
    while (
      !($dbname2 = $this->ask('Type old (OpenPNE2) database name'))
    );

    // ask encrypt key used in OpenPNE2
    while (
      !($this->encryptKey = $this->ask('Type encrypt key used in OpenPNE2 (under 56 bytes)'))
      || (strlen($this->encryptKey) > 56)
    );

    // get database configuration
    $file = sfConfig::get('sf_config_dir').'/databases.yml';
    $config = array();
    if (file_exists($file))
    {
      $config = sfYaml::load($file);
    }
    $this->dsn3 = $config['all']['doctrine']['param']['dsn'];
    $this->dsn2 = preg_replace('/dbname=[^ ;]+/', 'dbname='.$dbname2, $this->dsn3);
    $this->username = $config['all']['doctrine']['param']['username'];
    $this->password = $config['all']['doctrine']['param']['password'];

    // create temporary directory
    $tmpdir = sfConfig::get('sf_cache_dir').'/models_tmp';
    $this->getFilesystem()->mkdirs($tmpdir);

    // configure Doctrine
    $manager = Doctrine_Manager::getInstance();
    $manager->setAttribute(Doctrine::ATTR_QUERY_CLASS, 'Doctrine_Query');

    // generate OpenPNE2 models
    $this->connectTo2();
    Doctrine::generateModelsFromDb($tmpdir, array('OpenPNE2'), array('generateBaseClasses' => false, 'baseClassName' => 'sfDoctrineRecord'));
    $this->connectTo3();

    // generate OpenPNE3 models
    $this->generateTemporaryBaseModels($tmpdir, $this->getBaseModels());

    // load temporary models
    Doctrine::loadModels($tmpdir, Doctrine::MODEL_LOADING_AGGRESSIVE);

    $this->date = date('Y-m-d H:i:s');

    // clear db records
    $tables = array('Blacklist', /*'File', 'FileBin',*/ 'CommunityCategory', 'Community', 'CommunityConfig', 'CommunityMember', 'Member', 'MemberConfig', 'MemberImage', 'Profile', 'ProfileTranslation', 'ProfileOption', 'ProfileOptionTranslation', 'MemberProfile', 'MemberRelationship', 'CommunityTopic', 'CommunityEvent', 'Diary', 'DiaryImage', 'DiaryComment', 'DiaryCommentImage', 'DiaryCommentUnread', /*'Message', 'MessageSendList', 'DeletedMessage', 'MessageFile'*/);

    foreach ($tables as $table)
    {
      Doctrine::getTable($table)->createQuery()->delete()->execute();
    }

    // TODO:convert every tables
    print "converting AdminUser : ".memory_get_usage()."\n";
    $this->convertAdminUser();
    print "converting Blacklist : ".memory_get_usage()."\n";
    $this->convertBlacklist();
    //print "converting File and FileBin : ".memory_get_usage()."\n";
    //$this->convertFileAndFileBin();
    print "converting CommunityCategory : ".memory_get_usage()."\n";
    $this->convertCommunityCategory();
    print "converting Community and CommunityConfig : ".memory_get_usage()."\n";
    $this->convertCommunityAndCommunityConfig();
    print "converting Member : ".memory_get_usage()."\n";
    $this->convertMember();
    print "converting CommunityMember : ".memory_get_usage()."\n";
    $this->convertCommunityMember();
    print "converting MemberConfig : ".memory_get_usage()."\n";
    $this->convertMemberConfig();
    print "converting MemberImage : ".memory_get_usage()."\n";
    $this->convertMemberImage();
    print "converting Profile : ".memory_get_usage()."\n";
    $this->convertProfile();
    print "converting ProfileOption : ".memory_get_usage()."\n";
    $this->convertProfileOption();
    //print "converting MemberProfile : ".memory_get_usage()."\n";
    //$this->convertMemberProfile();
    print "converting MemberRelationship : ".memory_get_usage()."\n";
    $this->convertMemberRelationship();
    print "converting CommunityTopicAndComment : ".memory_get_usage()."\n";
    $this->convertCommunityTopicAndComment();
    print "converting CommunityEventAndComment : ".memory_get_usage()."\n";
    $this->convertCommunityEventAndComment();
    print "converting DiaryAndImage : ".memory_get_usage()."\n";
    $this->convertDiaryAndImage();
    print "converting DiaryCommentAndImage : ".memory_get_usage()."\n";
    $this->convertDiaryCommentAndImage();
    //print "converting MessageTables : ".memory_get_usage()."\n";
    //$this->convertMessageTables();

    // delete models' cache
    $this->clearCache();
  }

  /**
   * Convert Methods
   */
  protected function convertAdminUser()
  {
    $this->connectTo2();
    $cAdminUser = Doctrine::getTable('CAdminUser')->find(1);
    $this->connectTo3();
    $adminUser = Doctrine::getTable('AdminUser')->find(1);

    $this->update($adminUser, array(
      'username'   => $cAdminUser->getUsername(),
      'password'   => $cAdminUser->getPassword(),
      'created_at' => $this->date,
      'updated_at' => $this->date,
    ));
    $cAdminUser->free();
  }

  protected function convertBlacklist()
  {
    $this->connectTo2();
    $cBlacklists = Doctrine::getTable('CBlacklist')->findAll();
    $this->connectTo3();

    foreach ($cBlacklists as $cBlacklist)
    {
      $this->insertInto('Blacklist', array(
        'id'         => $cBlacklist->getCBlacklistId(),
        'uid'        => $cBlacklist->getEasyAccessId(),
        'memo'       => $cBlacklist->getInfo(),
        'created_at' => $this->date,
        'updated_at' => $this->date,
      ));
      $cBlacklist->free();
    }
  }

  protected function convertFileAndFileBin()
  {
    $this->connectTo3();

    $maxFileId = 0;

    $offset = 0;
    while ($cFiles = $this->getModelsIterator('CFile', 100, $offset))
    {
      foreach ($cFiles as $cFile)
      {
        $this->_createFile(array(
          'id'            => $cFile->getCFileId(),
          'name'          => $cFile->getFilename(),
          'original_name' => $cFile->getOriginalFilename(),
          'date'          => $cFile->getRDatetime(),
          'bin'           => $cFile->getBin(),
        ));

        if ($maxFileId < $cFile->getCFileId())
        {
          $maxFileId = $cFile->getCFileId();
        }

        $cFile->free();
      }
      $offset += 100;
    }

    $offset = 0;
    while ($cImages = $this->getModelsIterator('CImage', 100, $offset))
    {
      foreach ($cImages as $cImage)
      {
        $this->_createFile(array(
          'id'   => $maxFileId + $cImage->getCImageId(),
          'name' => $cImage->getFilename(),
          'date' => $cImage->getRDatetime(),
          'bin'  => $cImage->getBin(),
        ));

        $cImage->free();
      }
      $offset += 100;
    }
  }

  protected function _createFile($param = array())
  {
    // NOTICE: ignore if the file with same name had saved
    if ($this->getFileByName($param['name']))
    {
      return;
    }

    $paramFile = $param;
    unset($paramFile['bin']);
    $file = $this->insertInto('File', $paramFile, true);

    unset($param['name']);
    unset($param['original_name']);
    $fileBin = $this->insertInto('FileBin', $param, true);

    $file->setFileBin($fileBin);

    $tmpFilePath = sfConfig::get('sf_cache_dir').'/'.$file->getName();
    $fh = fopen($tmpFilePath, 'w');
    fwrite($fh, $param['bin']);
    fclose($fh);
    $tmpFile = $this->getValidatorFile()->clean(array('tmp_name' => $tmpFilePath));

    $file->setType($tmpFile->getType());

    $file->save();

    $file->free();
    $fileBin->free();
  }

  protected function convertCommunityCategory()
  {
    $this->connectTo2();
    $cCommuCategoryParents = Doctrine::getTable('CCommuCategoryParent')->createQuery()
      ->orderBy('sort_order')
      ->execute();
    $this->connectTo3();
    $treeCategory = Doctrine::getTable('CommunityCategory')->getTree();

    foreach ($cCommuCategoryParents as $cCategoryParent)
    {
      $categoryRoot = $this->insertInto('CommunityCategory', array(
        'tree_key' => $cCategoryParent->getCCommuCategoryParentId(),
        'name'     => $cCategoryParent->getName(),
        'sort_order' => $cCategoryParent->getSortOrder(),
      ), true);

      $treeCategory->createRoot($categoryRoot);

      $this->connectTo2();
      $cCategories = Doctrine::getTable('CCommuCategory')->createQuery()
        ->where('c_commu_category_parent_id = ?', $cCategoryParent->getCCommuCategoryParentId())
        ->orderBy('sort_order')
        ->execute();
      $this->connectTo3();

      foreach ($cCategories as $cCategory)
      {
        $category = new TempCommunityCategory();
        $category->setName($cCategory->getName());
        if (method_exists($cCategory, 'getIsCreateCommu'))
        {
          $category->setIsAllowMemberCommunity($cCategory->getIsCreateCommu());
        }
        $category->setSortOrder($cCategory->getSortOrder());
        $category->getNode()->insertAsLastChildOf($categoryRoot);

        $this->mapCategoryIds[$cCategory->getCCommuCategoryId()] = $category->getId();

        $cCategory->free();
        $category->free();
      }

      $categoryRoot->free();
      $cCategoryParent->free();
    }
  }

  protected function convertCommunityAndCommunityConfig()
  {
    $this->connectTo3();

    $offset = 0;
    while ($cCommus = $this->getModelsIterator('CCommu', 100, $offset, 'c_commu_id'))
    {
      foreach ($cCommus as $cCommu)
      {
        // NOTICE: ignore if already created same name community
        if ($this->isExist('Community', array('name' => $cCommu->getName())))
        {
          $cCommu->free();
          continue;
        }

        $param = array(
            'id'         => $cCommu->getCCommuId(),
            'name'       => $cCommu->getName(),
            'created_at' => $cCommu->getRDate(),
            'updated_at' => $cCommu->getUDatetime(),
            );
        if ($file = $this->getFileByName($cCommu->getImageFilename()))
        {
          $param['file_id'] = $file->getId();
          $file->free();
        }
        if (array_key_exists($cCommu->getCCommuCategoryId(), $this->mapCategoryIds))
        {
          $param['community_category_id'] = $this->mapCategoryIds[$cCommu->getCCommuCategoryId()];
        }
        $this->insertInto('Community', $param);

        // CommunityConfigs
        $param = array(
            'community_id' => $cCommu->getCCommuId(),
            'created_at'   => $this->date,
            'updated_at'   => $this->date,
            );

        $configs = array();
        $configs['description'] = $cCommu->getInfo();
        if (method_exists($cCommu, 'getIsOpen'))
        {
          $configs['public_flag'] = $cCommu->getIsOpen();
        }
        if (method_exists($cCommu, 'getIsTopic'))
        {
          $configs['topic_authority'] = $cCommu->getIsTopic();
        }

        $this->createConfigs('CommunityConfig', $param, $configs);

        $cCommu->free();
      }
      $offset += 100;
    }
  }

  protected function convertCommunityMember()
  {
    $this->connectTo3();

    $offset = 0;
    while ($cCommuMembers = $this->getModelsIterator('CCommuMember', 100, $offset))
    {
      foreach ($cCommuMembers as $cCommuMember)
      {
        // NOTICE: ignore if the community this member joins is not exist
        if (!$this->isExist('Community', array('id' => $cCommuMember->getCCommuId())))
        {
          $cCommuMember->free();
          continue;
        }

        $param = array(
            'id'           => $cCommuMember->getCCommuMemberId(),
            'community_id' => $cCommuMember->getCCommuId(),
            'member_id'    => $cCommuMember->getCMemberId(),
            'created_at'   => $cCommuMember->getRDatetime(),
            'updated_at'   => $cCommuMember->getRDatetime(),
            );
        $this->connectTo2();
        if (
            $this->isExist('CCommu', array(
                'c_commu_id' => $cCommuMember->getCCommuId(),
                'c_member_id_admin' => $cCommuMember->getCCommuMemberId()
                ))
           )
        {
          $param['position'] = 'admin';
        }
        $this->connectTo3();
        $this->insertInto('CommunityMember', $param);

        $cCommuMember->free();
      }
      $offset += 100;
    }
  }

  protected function convertMember()
  {
    $this->connectTo3();

    $offset = 0;
    while ($cMembers = $this->getModelsIterator('CMember', 100, $offset, 'c_member_id'))
    {
      foreach ($cMembers as $cMember)
      {
        $param = array(
            'id'         => $cMember->getCMemberId(),
            'name'       => $cMember->getNickname(),
            'created_at' => $cMember->getRDate(),
            'updated_at' => $cMember->getUDatetime(),
            'is_active'  => !$cMember->getIsLoginRejected(),
            );
        if ($cMember->getCMemberIdInvite() && Doctrine::getTable('Member')->find($cMember->getCMemberIdInvite()))
        {
          $param['invite_member_id'] = $cMember->getCMemberIdInvite();
        }

        $this->insertInto('Member', $param);
        $cMember->free();
      }
      $offset += 100;
    }
  }

  protected function convertMemberConfig()
  {
    $this->connectTo3();

    $offset = 0;
    while ($cMemberSecures = $this->getModelsIterator('CMemberSecure', 100, $offset))
    {
      foreach ($cMemberSecures as $cMemberSecure)
      {
        // NOTICE: ignore if the member isn't exist
        $this->connectTo2();
        if (!$this->isExist('CMember', array('c_member_id' => $cMemberSecure->getCMemberId())))
        {
          $cMemberSecure->free();
          continue;
        }
        $this->connectTo3();

        // common parameters
        $param = array(
            'member_id' => $cMemberSecure->getCMemberId(),
            'created_at' => $this->date,
            'updated_at' => $this->date,
            );

        // MemberConfig records
        $configs = array(
            'pc_address'     => $this->decrypt($cMemberSecure->getPcAddress()),
            'password'       => $cMemberSecure->getHashedPassword(),
            'mobile_address' => $cMemberSecure->getKtaiAddress(),
            'mobile_uid'     => $cMemberSecure->getEasyAccessId(),
            'lastLogin'      => $cMember->getAccessDate(),
            );

        $this->createConfigs('MemberConfig', $param, $configs);

        $cMemberSecure->free();
        $cMember->free();
      }
      $offset += 100;
    }
  }

  protected function convertMemberImage()
  {
    $this->connectTo3();

    $offset = 0;
    while ($cMembers = $this->getModelsIterator('CMember', 100, $offset))
    {
      foreach ($cMembers as $cMember)
      {
        for ($i = 1; $i <= 3; ++$i)
        {
          $getImageFilename = 'getImageFilename_'.$i;

          if ($file = $this->getFileByName($cMember->$getImageFilename()))
          {
            $this->insertInto('MemberImage', array(
              'member_id'      => $cMember->getCMemberId(),
              'file_id'        => $file->getId(),
              'image_filename' => $cMember->$getImageFilename(),
              'is_primary'     => $cMember->getImageFilename() === $cMember->$getImageFilename(),
              'created_at'     => $this->date,
              'updated_at'     => $this->date,
            ));
            $file->free();
          }
        }

        $cMember->free();
      }
      $offset += 100;
    }
  }

  protected function convertProfile()
  {
    $this->connectTo3();

    $offset = 0;
    while ($cProfiles = $this->getModelsIterator('CProfile', 100, $offset))
    {
      foreach ($cProfiles as $cProfile)
      {
        $this->insertInto('Profile', array(
              'id'                  => $cProfile->getCProfileId(),
              'name'                => $cProfile->getName(),
              'is_required'         => $cProfile->getIsRequired(),
              'is_edit_public_flag' => $cProfile->getPublicFlagEdit(),
              'default_public_flag' => $cProfile->getPublicFlagDefault(),
              'form_type'           => $cProfile->getFormType(),
              'value_type'          => $cProfile->getValType(),
              'is_disp_regist'      => $cProfile->getDispRegist(),
              'is_disp_config'      => $cProfile->getDispConfig(),
              'is_disp_search'      => $cProfile->getDispSearch(),
              'value_regexp'        => $cProfile->getValRegexp(),
              'value_min'           => $cProfile->getValMin(),
              'value_max'           => $cProfile->getValMax(),
              'sort_order'          => $cProfile->getSortOrder(),
              'created_at'          => $this->date,
              'updated_at'          => $this->date,
              ));

        $profileTranslation = Doctrine::getTable('Profile')->createQuery('p')
          ->leftJoin('p.Translation t WITH t.lang = "ja_JP"')
          ->where('p.id = ?', $cProfile->getCProfileId())
          ->fetchOne();

        $param = array(
            'caption' => $cProfile->getCaption(),
            'lang'    => 'ja_JP',
            );
        $param['info'] = $cProfile->getInfo();

        $this->update($profileTranslation, $param);

        $cProfile->free();
        $profileTranslation->free();
      }
      $offset += 100;
    }

    $this->insertInto('Profile', array(
      'name'                => 'birthday',
      'is_required'         => true,
      'is_edit_public_flag' => false,
      'default_public_flag' => true,
      'form_type'           => 'date',
      'value_type'          => 'string',
      'is_disp_regist'      => true,
      'is_disp_config'      => true,
      'is_disp_search'      => true,
      'value_min'           => '-100years',
      'value_max'           => 'now',
      'sort_order'          => 1,
      'created_at'          => $this->date,
      'updated_at'          => $this->date,
    ));

    $profileBirthdayTranslation = Doctrine::getTable('Profile')->createQuery('p')
      ->leftJoin('p.Translation t WITH t.lang = "ja_JP"')
      ->orderBy('id desc')
      ->fetchOne();

    $this->birthdayProfileId = $profileBirthdayTranslation->getId();

    $this->update($profileBirthdayTranslation, array(
      'caption' => '誕生日',
      'lang'    => 'ja_JP',
    ));
  }

  protected function convertProfileOption()
  {
    $this->connectTo2();
    $cProfileOptions = Doctrine::getTable('CProfileOption')->findAll();
    $this->connectTo3();

    $offset = 0;
    while ($cProfileOptions = $this->getModelsIterator('CProfileOption', 100, $offset))
    {
      foreach ($cProfileOptions as $cProfileOption)
      {
        $this->_createProfileOption(array(
              'id'         => $cProfileOption->getCProfileOptionId(),
              'profile_id' => $cProfileOption->getCProfileId(),
              'sort_order' => $cProfileOption->getSortOrder(),
              ), $cProfileOption->getValue());
        $cProfileOption->free();
      }
      $offset += 100;
    }

    $this->_createProfileOption(array(
          'profile_id' => $this->birthdayProfileId,
          'sort_order' => 0,
          ));
  }

  protected function _createProfileOption($param = array(), $translation = null)
  {
    $profileOption = $this->insertInto('ProfileOption', $param, true); 

    if (!is_null($translation))
    {
      $profileOptionTranslation = Doctrine::getTable('ProfileOption')->createQuery('p')
        ->leftJoin('p.Translation t WITH t.lang = "ja_JP"')
        ->where('p.id = ?', $profileOption->getId())
        ->fetchOne();

      $profileOptionTranslation->setValue($translation);
      $profileOptionTranslation->save();

      $profileOptionTranslation->free();
    }

    $profileOption->free();
  }

  protected function convertMemberProfile()
  {
    $this->connectTo3();
    $treeProfile = Doctrine::getTable('MemberProfile')->getTree();

    $offset = 0;
    while ($cMemberProfiles = $this->getModelsIterator('CMemberProfile', 100, $offset))
    {
      foreach ($cMemberProfiles as $cMemberProfile)
      {
        // NOTICE: ignore if the member isn't exist
        if (!$this->isExist('Member', array('id' => $cMemberProfile->getCMemberId())))
        {
          $cMemberProfile->free();
          continue;
        }

        $memberProfile = $this->_createAndGetMemberProfile(array(
          'member_id'         => $cMemberProfile->getCMemberId(),
          'profile_id'        => $cMemberProfile->getCProfileId(),
          'profile_option_id' => $cMemberProfile->getCProfileOptionId(),
          'value'             => $cMemberProfile->getValue(),
          'public_flag'       => $cMemberProfile->getPublicFlag(),
        ));

        if ($memberProfile)
        {
          $memberProfile->save();
          $memberProfile->free();
        }

        $cMemberProfile->free();
      }
      $offset += 100;
    }

    unset($cMemberProfiles);
    $this->connectTo2()->clear();
    $this->connectTo3()->clear();

    $offset = 0;
    while ($cMembers = $this->getModelsIterator('CMember', 100, $offset))
    {
      foreach ($cMembers as $cMember)
      {
        $birthdayRoot = $this->_createAndGetMemberProfile(array(
          'member_id'   => $cMember->getCMemberId(),
          'profile_id'  => $this->birthdayProfileId,
        ));

        $treeProfile->createRoot($birthdayRoot);

        $birthdayYear = $this->_createAndGetMemberProfile(array(
          'member_id'   => $cMember->getCMemberId(),
          'profile_id'  => $this->birthdayProfileId,
          'value'       => $cMember->getBirthYear(),
          'public_flag' => $cMember->getPublicFlagBirthYear(),
        ));
        $birthdayMonth = $this->_createAndGetMemberProfile(array(
          'member_id'    => $cMember->getCMemberId(),
          'profile_id'   => $this->birthdayProfileId,
          'value'        => $cMember->getBirthMonth(),
          'public_flag'  => $cMember->getPublicFlagBirthMonthDay(),
        ));
        $birthdayDay = $this->_createAndGetMemberProfile(array(
          'member_id'    => $cMember->getCMemberId(),
          'profile_id'   => $this->birthdayProfileId,
          'value'        => $cMember->getBirthDay(),
          'public_flag'  => $cMember->getPublicFlagBirthMonthDay(),
        ));

        $birthdayDay->getNode()->insertAsLastChildOf($birthdayRoot);
        $birthdayMonth->getNode()->insertAsLastChildOf($birthdayRoot);
        $birthdayYear->getNode()->insertAsLastChildOf($birthdayRoot);

        $birthdayYear->free();
        $birthdayMonth->free();
        $birthdayDay->free();
        $cMember->free();
        $birthdayRoot->free();
      }
      $offset += 100;
    }
  }

  protected function _createAndGetMemberProfile($param = array())
  {
    // NOTICE: ignore if c_member_profile.c_profile_id = 0
    if (!array_key_exists('profile_id', $param) || !$param['profile_id'])
    {
      return;
    }

    $param['created_at'] = $this->date;
    $param['updated_at'] = $this->date;

    return $this->insertInto('MemberProfile', $param, true);
  }

  protected function convertMemberRelationship()
  {
    $this->connectTo3();

    $offset = 0;
    while ($cFriends = $this->getModelsIterator('CFriend', 100, $offset))
    {
      foreach ($cFriends as $cFriend)
      {
        $this->_updateMemberRelationship(array(
              'member_id_from' => $cFriend->getCMemberIdFrom(),
              'member_id_to'   => $cFriend->getCMemberIdTo(),
              'datetime'       => $cFriend->getRDatetime(),
              'is_friend'      => true,
              ));
        $cFriend->free();
      }
      $offset += 100;
    }

    $offset = 0;
    while ($cFriendConfirms = $this->getModelsIterator('CFriendConfirm', 100, $offset))
    {
      foreach ($cFriendConfirms as $cFriendConfirm)
      {
        $this->_updateMemberRelationship(array(
              'member_id_from' => $cFriendConfirm->getCMemberIdFrom(),
              'member_id_to'   => $cFriendConfirm->getCMemberIdTo(),
              'datetime'       => $cFriendConfirm->getRDatetime(),
              'is_friend_pre'  => true,
              ));
        $cFriendConfirm->free();
      }
      $offset += 100;
    }

    $offset = 0;
    while ($cAccessBlocks = $this->getModelsIterator('CAccessBlock', 100, $offset))
    {
      foreach ($cAccessBlocks as $cAccessBlock)
      {
        $this->_updateMemberRelationship(array(
              'member_id_from'  => $cAccessBlock->getCMemberId(),
              'member_id_to'    => $cAccessBlock->getCMemberIdBlock(),
              'datetime'        => $cAccessBlock->getRDatetime(),
              'is_access_block' => true,
              ));
        $cAccessBlock->free();
      }
      $offset += 100;
    }
  }

  protected function _updateMemberRelationship($param = array())
  {
    // NOTICE: ignore if member_id_from is equal to member_id_to
    if ($param['member_id_from'] === $param['member_id_to'])
    {
      return;
    }

    $memberIds = array(
      'member_id_from' => $param['member_id_from'],
      'member_id_to'   => $param['member_id_to'],
    );
    if ($memberRelationship = $this->selectOne('MemberRelationship', $memberIds))
    {
      unset($param['member_id_from']);
      unset($param['member_id_to']);
      $this->update($memberRelationship, $param);
      $memberRelationship->free();
    }
    else
    {
      $this->insertInto('MemberRelationship', $param);
    }
  }

  protected function convertCommunityTopicAndComment()
  {
    $this->connectTo2();
    $cCommuTopics = Doctrine::getTable('CCommuTopic')->createQuery()
      ->where('event_flag = 0')
      ->execute();
    $this->connectTo3();

    foreach ($cCommuTopics as $cCommuTopic)
    {
      $param = array(
        'id'           => $cCommuTopic->getCCommuTopicId(),
        'community_id' => $cCommuTopic->getCCommuId(),
        'name'         => $cCommuTopic->getName(),
        'topic_updated_at' => $cCommuTopic->getUDatetime(),
        'created_at'   => $cCommuTopic->getRDatetime(),
        'updated_at'   => $cCommuTopic->getUDatetime(),
      );
      if (Doctrine::getTable('Member')->find($cCommuTopic->getCMemberId()))
      {
        $param['member_id'] = $cCommuTopic->getCMemberId();
      }

      $communityTopic = $this->insertInto('CommunityTopic', $param, true);

      $this->connectTo2();
      $comments = Doctrine::getTable('CCommuTopicComment')->createQuery()
        ->where('c_commu_topic_id = ?', $cCommuTopic->getCCommuTopicId())
        ->orderBy('number')
        ->execute();
      $this->connectTo3();

      foreach ($comments as $comment)
      {
        if (0 === $comment->getNumber())
        {
          $communityTopic->setBody($comment->getBody());
        }
        else
        {
          $this->insertInto('CommunityTopicComment', array(
            'community_topic_id' => $comment->getCCommuTopicId(),
            'member_id'          => $comment->getCMemberId(),
            'body'               => $comment->getBody(),
            'created_at'         => $comment->getRDatetime(),
            'updated_at'         => $comment->getRDatetime(),
          ));
        }
        $comment->free();
      }

      $communityTopic->save();
      $cCommuTopic->free();
      $communityTopic->free();
    }
  }

  protected function convertCommunityEventAndComment()
  {
    $this->connectTo2();
    $cCommuEvents = Doctrine::getTable('CCommuTopic')->createQuery()
      ->where('event_flag = 1')
      ->execute();
    $this->connectTo3();

    foreach ($cCommuEvents as $cCommuEvent)
    {
      $param = array(
        'id'           => $cCommuEvent->getCCommuTopicId(),
        'community_id' => $cCommuEvent->getCCommuId(),
        'name'         => $cCommuEvent->getName(),
        'event_updated_at' => $cCommuEvent->getUDatetime(),
        'open_date'    => $cCommuEvent->getOpenDate(),
        'open_date_comment' => $cCommuEvent->getOpenDateComment(),
        'application_deadline' => $cCommuEvent->getInvitePeriod(),
        'capacity'         => $cCommuEvent->getCapacity(),
        'created_at'       => $cCommuEvent->getRDatetime(),
        'updated_at'       => $cCommuEvent->getUDatetime(),
      );
      if (Doctrine::getTable('Member')->find($cCommuEvent->getCMemberId()))
      {
        $param['member_id'] = $cCommuEvent->getCMemberId();
      }

      $communityEvent = $this->insertInto('CommunityEvent', $param, true);

      $this->connectTo2();
      $comments = Doctrine::getTable('CCommuTopicComment')->createQuery()
        ->where('c_commu_topic_id = ?', $cCommuEvent->getCCommuTopicId())
        ->orderBy('number')
        ->execute();
      $this->connectTo3();

      foreach ($comments as $comment)
      {
        if (0 === $comment->getNumber())
        {
          $communityEvent->setBody($comment->getBody());
        }
        else
        {
          $this->insertInto('CommunityEventComment', array(
            'community_event_id' => $comment->getCCommuTopicId(),
            'member_id'          => $comment->getCMemberId(),
            'body'               => $comment->getBody(),
            'created_at'         => $comment->getRDatetime(),
            'updated_at'         => $comment->getRDatetime(),
          ));
        }
        $comment->free();
      }

      if ($cCommuEvent->getOpenPrefId())
      {
        $this->connectTo2();
        $pref = Doctrine::getTable('CProfilePref')->find($cCommuEvent->getOpenPrefId())->getPref();
        $this->connectTo3();
        if ($cCommuEvent->getOpenPrefComment())
        {
          $pref .= sprintf(' (%s)', $cCommuEvent->getOpenPrefComment());
        }
        $communityEvent->setArea($pref);
      }

      $communityEvent->save();
      $cCommuEvent->free();
      $communityEvent->free();
    }
  }

  protected function convertDiaryAndImage()
  {
    $this->connectTo3();

    $offset = 0;
    while ($cDiaries = $this->getModelsIterator('CDiary', 100, $offset))
    {
      foreach ($cDiaries as $cDiary)
      {
        $this->connectTo2();
        // NOTICE: ignore if the member isn't exist
        if (!$this->isExist('CMember', array('c_member_id' => $cDiary->getCMemberId())))
        {
          $cDiary->free();
          continue;
        }
        $this->connectTo3();

        $diary = $this->insertInto('Diary', array(
          'id'          => $cDiary->getCDiaryId(),
          'member_id'   => $cDiary->getCMemberId(),
          'title'       => $cDiary->getSubject(),
          'body'        => $cDiary->getBody(),
          'public_flag' => $cDiary->getPublicFlag(),
          'created_at'  => $cDiary->getPublicFlag(),
          'updated_at'  => $cDiary->getUDatetime(),
        ), true);

        for ($i = 1; $i <= 3; ++$i)
        {
          $getImageFilename = 'getImageFilename_'.$i;
          if ($file = $this->getFileByName($cDiary->$getImageFilename()))
          {
            $diary->setHasImages(true);
            $this->insertInto('DiaryImage', array(
              'diary_id' => $diary->getId(),
              'number'   => $i,
              'file_id'  => $file->getId(),
            ));
            $file->free();
          }
        }

        if (method_exists($diary, 'getIsChecked') && !$diary->getIsChecked())
        {
          array_push($this->unreadDiaryIds, $diary->getId());
        }

        $diary->save();
        $cDiary->free();
        $diary->free();
      }
      $offset += 100;
    }
  }

  protected function convertDiaryCommentAndImage()
  {
    $this->connectTo2();
    $cDiaryComments = Doctrine::getTable('CDiaryComment')->findAll();
    $this->connectTo3();

    $offset = 0;
    while ($cDiaryComments = $this->getModelsIterator('CDiaryComment', 100, $offset))
    {
      foreach ($cDiaryComments as $cDiaryComment)
      {
        // NOTICE: ignore if that's diary isn't exist
        if (!Doctrine::getTable('Diary')->find($cDiaryComment->getCDiaryId()))
        {
          continue;
        }

        // NOTICE: ignore if that's member isn't exist
        if (!Doctrine::getTable('Member')->find($cDiaryComment->getCMemberId()))
        {
          continue;
        }

        $this->insertInto('DiaryComment', array(
          'id'         => $cDiaryComment->getCDiaryCommentId(),
          'diary_id'   => $cDiaryComment->getCDiaryId(),
          'member_id'  => $cDiaryComment->getCMemberId(),
          'number'     => $cDiaryComment->getNumber(),
          'body'       => $cDiaryComment->getBody(),
          'created_at' => $cDiaryComment->getRDatetime(),
          'updated_at' => $cDiaryComment->getRDatetime(),
        ));

        for ($i = 1; $i <= 3; ++$i)
        {
          $getImageFilename = 'getImageFilename_'.$i;
          if ($file = $this->getFileByName($cDiaryComment->$getImageFilename()))
          {
            $this->insertInto('DiaryCommentImage', array(
              'diary_comment_id' => $cDiaryComment->getCDiaryCommentId(),
              'file_id'          => $file->getId(),
            ));
            $file->free();
          }
        }

        if (array_search($cDiaryComment->getCDiaryCommentId(), $this->unreadDiaryIds))
        {
          $this->insertInto('DiaryCommentUnread', array(
            'diary_id'  => $cDiaryComment->getCDiaryId(),
            'member_id' => $cDiaryComment->getCMemberId(),
          ));
        }

        $cDiaryComment->free();
      }
      $offset += 100;
    }
  }

  protected function convertMessageTables()
  {
    $this->connectTo3();

    $offset = 0;
    while ($cMessages = $this->getModelsIterator('CMessage', 100, $offset))
    {
      foreach ($cMessages as $cMessage)
      {
        $this->insertInto('Message', array(
          'id'                => $cMessage->getCMessageId(),
          'member_id'         => $cMessage->getCMemberIdFrom(),
          'subject'           => $cMessage->getSubject(),
          'body'              => $cMessage->getBody(),
          'is_deleted'        => $cMessage->getIsDeletedFrom(),
          'is_send'           => $cMessage->getIsSend(),
          'return_message_id' => $cMessage->getHensinmotoCMessageId(),
          'message_type_id'   => $cMessage->getIsSyoudaku() ? 2 : 1,
          'created_at'        => $cMessage->getRDatetime(),
          'updated_at'        => $cMessage->getRDatetime(),
        ));

        // create MessageSendList
        $messageSendList = $this->insertInto('MessageSendList', array(
          'member_id'  => $cMessage->getCMemberIdTo(),
          'message_id' => $cMessage->getCMessageId(),
          'is_read'    => $cMessage->getIsRead(),
          'is_deleted' => $cMessage->getIsDeletedTo(),
          'created_at' => $cMessage->getRDatetime(),
          'updated_at' => $cMessage->getRDatetime(),
        ), true);

        // create DeletedMessage
        if ($cMessage->getIsDeletedTo())
        {
          $this->insertInto('DeletedMessage', array(
            'member_id'            => $cMessage->getCMemberIdTo(),
            'message_id'           => $cMessage->getCMessageId(),
            'message_send_list_id' => $messageSendList->getId(),
            'is_deleted'           => $cMessage->getIsKanzenSakujoTo(),
            'datetime'             => $cMessage->getRDatetime(),
          ));
        }
        if ($cMessage->getIsDeletedFrom())
        {
          $this->insertInto('DeletedMessage', array(
            'member_id'            => $cMessage->getCMemberIdFrom(),
            'message_id'           => $cMessage->getCMessageId(),
            'message_send_list_id' => $messageSendList->getId(),
            'is_deleted'           => $cMessage->getIsKanzenSakujoFrom(),
            'datetime'             => $cMessage->getRDatetime(),
          ));
        }

        // create MessageFile
        $param = array(
          'message_id' => $cMessage->getCMessageId(),
          'created_at' => $this->date,
          'updated_at' => $this->date,
        );
        for ($i = 1; $i <= 3; ++$i)
        {
          $getImageFilename = 'getImageFilename_'.$i;
          if ($file = $this->getFileByName($cMessage->$getImageFilename()))
          {
            $this->insertInto('MessageFile', array_merge($param, array('file_id' => $file->getId())));
            $file->free();
          }
        }
        if ($file = $this->getFileByName($cMessage->getFilename()))
        {
          $this->insertInto('MessageFile', array_merge($param, array('file_id' => $file->getId())));
          $file->free();
        }

        $messageSendList->free();
      }

      foreach ($cMessages as $cMessage)
      {
        $message = Doctrine::getTable('Message')->find($cMessage->getCMessageId());
        $message->setThreadMessageId($this->_getThreadMessageId($cMessage->getCMessageId()));
        $message->save();
        $message->free();
        $cMessage->free();
      }
      $offset += 100;
    }
  }

  protected function _getThreadMessageId($messageId)
  {
    if (!$messageId)
    {
      return;
    }

    $message = Doctrine::getTable('Message')->find($messageId);
    $returnMessageId = $message->getReturnMessageId();
    $message->free();

    return $returnMessageId
      ? $this->_getThreadMessageId($returnMessageId)
      : $messageId;
  }

  /**
   * Functions
   */
  protected function clearCache()
  {
    $cc = new sfCacheClearTask($this->dispatcher, $this->formatter);
    $cc->run();
  }

  protected function connectTo3()
  {
    return Doctrine_Manager::connection(new PDO($this->dsn3, $this->username, $this->password), 'doctrine');
  }

  protected function connectTo2()
  {
    return Doctrine_Manager::connection(new PDO($this->dsn2, $this->username, $this->password), 'OpenPNE2');
  }

  protected function getFileByName($name = null)
  {
    if ($name)
    {
      return $this->selectOne('File', array('name' => $name));
    }
  }

  protected function getModelsIterator($table, $limit = 100, $offset = 0, $orderBy = null)
  {
    $this->connectTo2();
    $q = Doctrine::getTable($table)->createQuery()
      ->limit($limit)
      ->offset($offset);
    if (!is_null($orderBy))
    {
      $q->orderBy($orderBy);
    }
    $cModels = $q->execute();
    $this->connectTo3();

    return $cModels->count() ? $cModels : false;
  }

  protected function createConfigs($tableName, $param, $configs)
  {
    foreach ($configs as $name => $value)
    {
      if (!$value)
      {
        continue;
      }

      $this->insertInto($tableName, array_merge($param, array(
        'name'  => $name,
        'value' => $value,
      )));
    }
  }

  /**
   * Initialize
   */
  protected function getBaseModelsDirectories($dir)
  {
    if (!is_dir($dir) || '.' === basename($dir))
    {
      return;
    }
    elseif ('base' === basename($dir))
    {
      return array($dir);
    }
  
    $baseDirs = array();
    foreach (scandir($dir) as $file)
    {
      if (0 === strpos($file, '.'))
      {
        continue;
      }
      if ($base = $this->getBaseModelsDirectories($dir.'/'.$file))
      {
        $baseDirs = array_merge($baseDirs, $base);
      }
    }
  
    return $baseDirs;
  }

  protected function getBaseModels()
  {
    $baseDirs = $this->getBaseModelsDirectories(sfConfig::get('sf_lib_dir').'/model/doctrine');
    $baseModels = array();
    foreach ($baseDirs as $dir)
    {
      foreach (scandir($dir) as $file)
      {
        if (!is_dir($file) && 0 !== strpos($file, '.'))
        {
          array_push($baseModels, $dir.'/'.$file);
        }
      }
    }

    return $baseModels;
  }

  protected function generateTemporaryBaseModels($tmpdir, $baseModels = array())
  {
    foreach ($baseModels as $model)
    {
      $className = basename($model, '.class.php');
      $className = preg_replace('/^Base/', 'Temp', $className);
      $contents = file_get_contents($model);
      $contents
        = preg_replace(
          '/\nabstract class Base.+? extends opDoctrineRecord\n/',
          "\nclass ".$className." extends sfDoctrineRecord\n",
          $contents
        );

      $fp = fopen($tmpdir.'/'.$className.'.php', 'w');
      fwrite($fp, $contents);
      fclose($fp);
    }
  }

  /**
   * Utilities
   */
  protected function getValidatorFile()
  {
    if ($this->validatorFile === null)
    {
      $this->validatorFile = new sfValidatorFile();
    }

    return $this->validatorFile;
  }

  protected function makeCamelCase($string = '')
  {
    $camel = '';
    $words = explode('_', $string);
    $camel .= array_shift($words);
    foreach ($words as $word)
    {
      $camel .= ucfirst($word);
    }

    return $camel;
  }

  protected function decrypt($str)
  {
    if (!$str)
    {
      return '';
    }

    $str = base64_decode($str);
    $bf =& $this->get_crypt_blowfish();

    return rtrim($bf->decrypt($str));
  }

  // FIXME : Cannot use old blowfish library
  protected function &get_crypt_blowfish()
  {
    static $singleton;
    if (empty($singleton))
    {
      include_once 'Crypt/Blowfish.php';
      $singleton = new Crypt_Blowfish($this->encryptKey);
    }

    return $singleton;
  }

  protected function printMemoryUsage($msg = 'point')
  {
    $memory = memory_get_usage();
    $diff = $memory - $this->memoryBuf;
    printf(
      "%s: %d (%s)\n",
      $msg, $memory, $diff > 0 ? '+'.$diff : $diff
    );
    $this->memoryBuf = $memory;
  }

  /**
   * SQL like operations
   */
  protected function selectOne($tableName, $where = array())
  {
    $q = Doctrine::getTable($tableName)->createQuery();

    foreach ($where as $key => $value)
    {
      $q->andWhere($key.' = ?', $value);
    }

    return $q->fetchOne();
  }

  protected function isExist($tableName, $where = array())
  {
    return (boolean) $this->selectOne($tableName, $where);
  }

  protected function insertInto($tableName, $param = array(), $returnRecord = false)
  {
    $className = 'Temp'.$tableName;
    $record = new $className();

    return $this->update($record, $param, $returnRecord);
  }

  protected function update(&$record, $param = array(), $returnRecord = false)
  {
    foreach ($param as $field => $value)
    {
      $methodName = $this->makeCamelCase('set'.$field);
      $record->{$this->makeCamelCase('set'.$field)}($value);
    }

    if ($returnRecord)
    {
      return $record;
    }
    $record->save();
    $record->free();
  }
}