319 lines
11 KiB
PHP
319 lines
11 KiB
PHP
<?php
|
|
/**
|
|
* The model file of bugfree version 1 convert of ZenTaoPMS.
|
|
*
|
|
* @copyright Copyright 2009-2015 禅道软件（青岛）有限公司(ZenTao Software (Qingdao) Co., Ltd. www.cnezsoft.com)
|
|
* @license ZPL(http://zpl.pub/page/zplv12.html) or AGPL(https://www.gnu.org/licenses/agpl-3.0.en.html)
|
|
* @author Chunsheng Wang <chunsheng@cnezsoft.com>
|
|
* @package convert
|
|
* @version $Id: bugfree1.php 5028 2013-07-06 02:59:41Z wyd621@gmail.com $
|
|
* @link http://www.zentao.net
|
|
*/
|
|
class bugfree1ConvertModel extends bugfreeConvertModel
|
|
{
|
|
/**
|
|
* Execute the convert.
|
|
*
|
|
* @access public
|
|
* @return array
|
|
*/
|
|
public function execute()
|
|
{
|
|
$this->clear();
|
|
$this->convertGroup();
|
|
$result['users'] = $this->convertUser();
|
|
$result['executions'] = $this->convertExecution();
|
|
$result['modules'] = $this->convertModule();
|
|
$result['bugs'] = $this->convertBug();
|
|
$result['actions'] = $this->convertAction();
|
|
$result['files'] = $this->convertFile();
|
|
$this->dao->dbh($this->dbh);
|
|
$this->loadModel('tree')->fixModulePath();
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Convert groups.
|
|
*
|
|
* @access public
|
|
* @return void
|
|
*/
|
|
public function convertGroup()
|
|
{
|
|
$groups = $this->dao->dbh($this->sourceDBH)
|
|
->select("groupID AS id, groupName AS name, groupUser AS users")
|
|
->from('BugGroup')
|
|
->fetchAll('id');
|
|
foreach($groups as $groupID => $group)
|
|
{
|
|
/* Explode into array. */
|
|
$groupUsers = explode(',', $group->users);
|
|
unset($group->id);
|
|
unset($group->users);
|
|
|
|
/* Insert the group. */
|
|
$this->dao->dbh($this->dbh)->insert(TABLE_GROUP)->data($group)->exec();
|
|
$zentaoGroupID = $this->dao->lastInsertId();
|
|
|
|
/* Insert account. */
|
|
foreach($groupUsers as $account)
|
|
{
|
|
if(empty($account)) continue;
|
|
$this->dao->dbh($this->dbh)->insert(TABLE_USERGROUP)->set('`group`')->eq($zentaoGroupID)->set('account')->eq($account)->exec();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convert user.
|
|
*
|
|
* @access public
|
|
* @return int converted user count
|
|
*/
|
|
public function convertUser()
|
|
{
|
|
/* Get users exist in the system. */
|
|
$activeUsers = $this->dao
|
|
->dbh($this->sourceDBH)
|
|
->select("username AS account, userpassword AS password, realname, email")
|
|
->from('BugUser')
|
|
->orderBy('userID ASC')
|
|
->fetchAll('account');
|
|
|
|
/* Get users in histories. */
|
|
$allUsers = $this->dao->select("distinct(username) AS account")->from('BugHistory')->fetchPairs();
|
|
|
|
/* Merge them. */
|
|
foreach($allUsers as $key => $account)
|
|
{
|
|
if(isset($activeUsers[$account]))
|
|
{
|
|
$allUsers[$key] = $activeUsers[$account];
|
|
}
|
|
else
|
|
{
|
|
$allUsers[$key] = array('account' => $account, 'realname' => $account, 'deleted' => '1');
|
|
}
|
|
}
|
|
foreach($activeUsers as $account => $user) if(!isset($allUsers[$account])) $allUsers[$account] = $user;
|
|
|
|
/* Insert into zentao. */
|
|
$convertCount = 0;
|
|
foreach($allUsers as $account => $user)
|
|
{
|
|
if(!$this->dao->dbh($this->dbh)->findByAccount($account)->from(TABLE_USER)->fetch('account'))
|
|
{
|
|
$this->dao->dbh($this->dbh)->insert(TABLE_USER)->data($user)->exec();
|
|
$convertCount ++;
|
|
}
|
|
else
|
|
{
|
|
self::$info['users'][] = sprintf($this->lang->convert->errorUserExists, $account);
|
|
}
|
|
}
|
|
return $convertCount;
|
|
}
|
|
|
|
/**
|
|
* Convert execution in bugfree to product in zentao.
|
|
*
|
|
* @access public
|
|
* @return int converted execution count
|
|
*/
|
|
public function convertExecution()
|
|
{
|
|
$executions = $this->dao->dbh($this->sourceDBH)->select("executionID AS id, executionName AS name")->from('Bugexecution')->fetchAll('id');
|
|
foreach($executions as $executionID => $execution)
|
|
{
|
|
unset($execution->id);
|
|
$this->dao->dbh($this->dbh)->insert(TABLE_PRODUCT)->data($execution)->exec();
|
|
$this->map['product'][$executionID] = $this->dao->lastInsertID();
|
|
}
|
|
return count($executions);
|
|
}
|
|
|
|
/**
|
|
* Convert modules.
|
|
*
|
|
* @access public
|
|
* @return int converted modules count
|
|
*/
|
|
public function convertModule()
|
|
{
|
|
$this->map['module'][0] = 0;
|
|
$modules = $this->dao
|
|
->dbh($this->sourceDBH)
|
|
->select(
|
|
'moduleID AS id,
|
|
executionID AS root,
|
|
moduleName AS name,
|
|
moduleGrade AS grade,
|
|
parentID AS parent,
|
|
"bug" AS type')
|
|
->from('BugModule')
|
|
->orderBy('id ASC')
|
|
->fetchAll('id');
|
|
foreach($modules as $moduleID => $module)
|
|
{
|
|
$module->root = $this->map['product'][$module->root];
|
|
unset($module->id);
|
|
$this->dao->dbh($this->dbh)->insert(TABLE_MODULE)->data($module)->exec();
|
|
$this->map['module'][$moduleID] = $this->dao->lastInsertID();
|
|
}
|
|
|
|
/* Update parents. */
|
|
foreach($modules as $oldModuleID => $module)
|
|
{
|
|
$newModuleID = $this->map['module'][$oldModuleID];
|
|
$newParentID = $this->map['module'][$module->parent];
|
|
$this->dao->dbh($this->dbh)->update(TABLE_MODULE)->set('parent')->eq($newParentID)->where('id')->eq($newModuleID)->exec();
|
|
}
|
|
return count($modules);
|
|
}
|
|
|
|
/**
|
|
* Convert bugs.
|
|
*
|
|
* @access public
|
|
* @return int converted bugs count.
|
|
*/
|
|
public function convertBug()
|
|
{
|
|
$bugs = $this->dao
|
|
->dbh($this->sourceDBH)
|
|
->select('
|
|
bugID AS id,
|
|
executionID AS product,
|
|
moduleID AS module,
|
|
bugTitle AS title,
|
|
bugSeverity AS severity,
|
|
bugType AS type,
|
|
bugOS AS os,
|
|
bugStatus AS status,
|
|
mailto,
|
|
openedBy, openedDate, openedBuild,
|
|
assignedTo, assignedDate,
|
|
resolvedBy, resolution, resolvedBuild, resolvedDate,
|
|
closedBy, closedDate,
|
|
lastEditedBy, lastEditedDate,
|
|
linkID as duplicateBug
|
|
')
|
|
->from('BugInfo')
|
|
->orderBy('bugID')
|
|
->fetchAll('id');
|
|
foreach($bugs as $bugID => $bug)
|
|
{
|
|
/* Adjust some fields of bug. */
|
|
$bugID = (int)$bugID;
|
|
unset($bug->id);
|
|
if($bug->assignedTo == 'Closed') $bug->assignedTo = 'closed';
|
|
$bug->type = strtolower($bug->type);
|
|
$bug->os = strtolower($bug->os);
|
|
$bug->browser = 'all';
|
|
$bug->resolution = str_replace(' ','', strtolower($bug->resolution));
|
|
$bug->product = $this->map['product'][$bug->product];
|
|
$bug->module = $this->map['module'][$bug->module];
|
|
$this->dao->dbh($this->dbh)->insert(TABLE_BUG)->data($bug)->exec();
|
|
$this->map['bug'][$bugID] = $this->dao->lastInsertID();
|
|
}
|
|
|
|
/* Update duplicated bugs. */
|
|
foreach($this->map['bug'] as $oldBugID => $newBugID)
|
|
{
|
|
$this->dao->dbh($this->dbh)->update(TABLE_BUG)->set('duplicateBug')->eq($newBugID)->where('duplicateBug')->eq($oldBugID)->exec();
|
|
}
|
|
return count($bugs);
|
|
}
|
|
|
|
/**
|
|
* Convert actions.
|
|
*
|
|
* @access public
|
|
* @return int converted actions count.
|
|
*/
|
|
public function convertAction()
|
|
{
|
|
$actions = $this->dao
|
|
->dbh($this->sourceDBH)
|
|
->select("
|
|
'bug' AS objectType,
|
|
bugID AS objectID,
|
|
userName AS actor,
|
|
action,
|
|
fullInfo AS comment,
|
|
actionDate AS date")
|
|
->from('BugHistory')
|
|
->orderBy('bugID, historyID')
|
|
->fetchGroup('objectID');
|
|
$convertCount = 0;
|
|
foreach($actions as $bugID => $bugActions)
|
|
{
|
|
/* Get the related bugID. */
|
|
$bugID = (int)$bugID;
|
|
$zentaoBugID = $this->map['bug'][$bugID];
|
|
|
|
/* Process actions. */
|
|
foreach($bugActions as $key => $action)
|
|
{
|
|
$action->objectID = $zentaoBugID;
|
|
if($key == 0)
|
|
{
|
|
$this->dao->dbh($this->dbh)->update(TABLE_BUG)->set('steps')->eq(nl2br($action->comment))->where('id')->eq($zentaoBugID)->exec();
|
|
$action->comment = '';
|
|
}
|
|
$this->dao->dbh($this->dbh)->insert(TABLE_ACTION)->data($action)->exec();
|
|
$convertCount ++;
|
|
}
|
|
}
|
|
return $convertCount;
|
|
}
|
|
|
|
/**
|
|
* Convert files.
|
|
*
|
|
* @access public
|
|
* @return int converted files count.
|
|
*/
|
|
public function convertFile()
|
|
{
|
|
$this->setPath();
|
|
$files = $this->dao->dbh($this->sourceDBH)
|
|
->select("
|
|
fileName AS pathname,
|
|
fileTitle AS title,
|
|
fileType AS extension,
|
|
fileSize AS size,
|
|
'bug' AS objectType,
|
|
bugID AS objectID,
|
|
addUser AS addedBy,
|
|
addDate AS addedDate
|
|
")
|
|
->from('BugFile')
|
|
->orderBy('fileID')
|
|
->fetchAll();
|
|
foreach($files as $file)
|
|
{
|
|
$file->objectID = $this->map['bug'][(int)$file->objectID];
|
|
if(strpos($file->size, 'KB')) $file->size = (int)(str_replace('KB', '', $file->size) * 1024);
|
|
if(strpos($file->size, 'MB')) $file->size = (int)(str_replace('MB', '', $file->size) * 1024 * 1024);
|
|
$this->dao->dbh($this->dbh)->insert(TABLE_FILE)->data($file)->exec();
|
|
|
|
/* Copy files. */
|
|
$soureFile = $this->filePath . $file->pathname;
|
|
if(!file_exists($soureFile))
|
|
{
|
|
self::$info['files'][] = sprintf($this->lang->convert->errorFileNotExits, $soureFile);
|
|
continue;
|
|
}
|
|
$targetFile = $this->app->getAppRoot() . "www/data/upload/{$this->app->company->id}/" . $file->pathname;
|
|
$targetPath = dirname($targetFile);
|
|
if(!is_dir($targetPath)) mkdir($targetPath, 0777, true);
|
|
if(!copy($soureFile, $targetFile))
|
|
{
|
|
self::$info['files'][] = sprintf($this->lang->convert->errorCopyFailed, $targetFile);
|
|
}
|
|
}
|
|
return count($files);
|
|
}
|
|
}
|