425 lines
13 KiB
PHP
425 lines
13 KiB
PHP
<?php
|
|
/**
|
|
* @copyright Copyright (c) 2018 Julius Härtl <jus@bitgrid.net>
|
|
*
|
|
* @author Julius Härtl <jus@bitgrid.net>
|
|
*
|
|
* @license GNU AGPL version 3 or any later version
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as
|
|
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
namespace OCA\Deck\Command;
|
|
|
|
use JsonSchema\Validator;
|
|
use OCA\Deck\Db\AssignmentMapper;
|
|
use OCA\Deck\Db\Board;
|
|
use OCA\Deck\Db\BoardMapper;
|
|
use OCA\Deck\Db\Card;
|
|
use OCA\Deck\Db\CardMapper;
|
|
use OCA\Deck\Db\Stack;
|
|
use OCA\Deck\Db\StackMapper;
|
|
use OCA\Deck\Service\BoardService;
|
|
use OCA\Deck\Service\LabelService;
|
|
use OCA\Deck\Service\PermissionService;
|
|
use OCA\Deck\Service\StackService;
|
|
use OCP\AppFramework\Db\DoesNotExistException;
|
|
use OCP\AppFramework\Db\MultipleObjectsReturnedException;
|
|
use OCP\IGroupManager;
|
|
use OCP\IUserManager;
|
|
use OCP\IUserSession;
|
|
use Symfony\Component\Console\Command\Command;
|
|
use Symfony\Component\Console\Input\InputArgument;
|
|
use Symfony\Component\Console\Input\InputInterface;
|
|
use Symfony\Component\Console\Input\InputOption;
|
|
use Symfony\Component\Console\Output\OutputInterface;
|
|
use Symfony\Component\Console\Question\ChoiceQuestion;
|
|
use Symfony\Component\Console\Question\Question;
|
|
|
|
class BoardImport extends Command {
|
|
/** @var BoardService */
|
|
private $boardService;
|
|
// protected $cardMapper;
|
|
/** @var LabelService */
|
|
private $labelService;
|
|
/** @var StackMapper */
|
|
private $stackMapper;
|
|
/** @var CardMapper */
|
|
private $cardMapper;
|
|
/** @var IUserManager */
|
|
private $userManager;
|
|
// /** @var IGroupManager */
|
|
// private $groupManager;
|
|
// private $assignedUsersMapper;
|
|
private $allowedSystems = ['trello'];
|
|
/** @var Board */
|
|
private $board;
|
|
|
|
public function __construct(
|
|
// BoardMapper $boardMapper,
|
|
BoardService $boardService,
|
|
LabelService $labelService,
|
|
StackMapper $stackMapper,
|
|
CardMapper $cardMapper,
|
|
// IUserSession $userSession,
|
|
// StackMapper $stackMapper,
|
|
// CardMapper $cardMapper,
|
|
// AssignmentMapper $assignedUsersMapper,
|
|
IUserManager $userManager
|
|
// IGroupManager $groupManager
|
|
) {
|
|
parent::__construct();
|
|
|
|
// $this->cardMapper = $cardMapper;
|
|
$this->boardService = $boardService;
|
|
$this->labelService = $labelService;
|
|
$this->stackMapper = $stackMapper;
|
|
$this->cardMapper = $cardMapper;
|
|
|
|
// $this->userSession = $userSession;
|
|
// $this->stackMapper = $stackMapper;
|
|
// $this->assignedUsersMapper = $assignedUsersMapper;
|
|
// $this->boardMapper = $boardMapper;
|
|
|
|
$this->userManager = $userManager;
|
|
// $this->groupManager = $groupManager;
|
|
}
|
|
|
|
protected function configure() {
|
|
$this
|
|
->setName('deck:import')
|
|
->setDescription('Import data')
|
|
->addOption(
|
|
'system',
|
|
null,
|
|
InputOption::VALUE_REQUIRED,
|
|
'Source system for import. Available options: trello.',
|
|
'trello'
|
|
)
|
|
->addOption(
|
|
'setting',
|
|
null,
|
|
InputOption::VALUE_REQUIRED,
|
|
'Configuration json file.',
|
|
'config.json'
|
|
)
|
|
->addOption(
|
|
'data',
|
|
null,
|
|
InputOption::VALUE_REQUIRED,
|
|
'Data file to import.',
|
|
'data.json'
|
|
)
|
|
;
|
|
}
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
protected function interact(InputInterface $input, OutputInterface $output)
|
|
{
|
|
$this->validateSystem($input, $output);
|
|
$this->validateData($input, $output);
|
|
$this->validateSettings($input, $output);
|
|
$this->validateUsers();
|
|
$this->validateOwner();
|
|
}
|
|
|
|
public function validateData(InputInterface $input, OutputInterface $output) {
|
|
$filename = $input->getOption('data');
|
|
if (!is_file($filename)) {
|
|
$helper = $this->getHelper('question');
|
|
$question = new Question(
|
|
'Please inform a valid data json file: ',
|
|
'data.json'
|
|
);
|
|
$question->setValidator(function ($answer) {
|
|
if (!is_file($answer)) {
|
|
throw new \RuntimeException(
|
|
'Data file not found'
|
|
);
|
|
}
|
|
return $answer;
|
|
});
|
|
$data = $helper->ask($input, $output, $question);
|
|
$input->setOption('data', $data);
|
|
}
|
|
$this->data = json_decode(file_get_contents($filename));
|
|
if (!$this->data) {
|
|
$output->writeln('<error>Is not a json file: ' . $filename . '</error>');
|
|
$this->validateData($input, $output);
|
|
}
|
|
if (!$this->data) {
|
|
$this->data = json_decode(file_get_contents($filename));
|
|
}
|
|
}
|
|
|
|
private function validateOwner() {
|
|
$this->settings->owner = $this->userManager->get($this->settings->owner);
|
|
if (!$this->settings->owner) {
|
|
throw new \LogicException('Owner "' . $this->settings->owner . '" not found on Nextcloud. Check setting json.');
|
|
}
|
|
}
|
|
|
|
private function validateUsers() {
|
|
if (empty($this->settings->uidRelation)) {
|
|
return;
|
|
}
|
|
foreach ($this->settings->uidRelation as $trelloUid => $nextcloudUid) {
|
|
$user = array_filter($this->data->members, fn($u) => $u->username === $trelloUid);
|
|
if (!$user) {
|
|
throw new \LogicException('Trello user ' . $trelloUid . ' not found in property "members" of json data');
|
|
}
|
|
if (!is_string($nextcloudUid)) {
|
|
throw new \LogicException('User on setting uidRelation must be a string');
|
|
}
|
|
$this->settings->uidRelation->$trelloUid = $this->userManager->get($nextcloudUid);
|
|
if (!$this->settings->uidRelation->$trelloUid) {
|
|
throw new \LogicException('User on setting uidRelation not found: ' . $nextcloudUid);
|
|
}
|
|
}
|
|
}
|
|
|
|
private function validateSystem(InputInterface $input, OutputInterface $output) {
|
|
if (in_array($input->getOption('system'), $this->allowedSystems)) {
|
|
return;
|
|
}
|
|
$helper = $this->getHelper('question');
|
|
$question = new ChoiceQuestion(
|
|
'Please inform a source system',
|
|
$this->allowedSystems,
|
|
0
|
|
);
|
|
$question->setErrorMessage('System %s is invalid.');
|
|
$system = $helper->ask($input, $output, $question);
|
|
$input->setOption('system', $system);
|
|
}
|
|
|
|
private function validateSettings(InputInterface $input, OutputInterface $output) {
|
|
if (!is_file($input->getOption('setting'))) {
|
|
$helper = $this->getHelper('question');
|
|
$question = new Question(
|
|
'Please inform a valid setting json file: ',
|
|
'config.json'
|
|
);
|
|
$question->setValidator(function ($answer) {
|
|
if (!is_file($answer)) {
|
|
throw new \RuntimeException(
|
|
'Setting file not found'
|
|
);
|
|
}
|
|
return $answer;
|
|
});
|
|
$setting = $helper->ask($input, $output, $question);
|
|
$input->setOption('setting', $setting);
|
|
}
|
|
|
|
$this->settings = json_decode(file_get_contents($input->getOption('setting')));
|
|
$validator = new Validator();
|
|
$validator->validate(
|
|
$this->settings,
|
|
(object)['$ref' => 'file://' . realpath(__DIR__ . '/fixtures/setting-schema.json')]
|
|
);
|
|
if (!$validator->isValid()) {
|
|
$output->writeln('<error>Invalid setting file</error>');
|
|
$output->writeln(array_map(fn($v) => $v['message'], $validator->getErrors()));
|
|
$output->writeln('Valid schema:');
|
|
$output->writeln(print_r(file_get_contents(__DIR__ . '/fixtures/setting-schema.json'), true));
|
|
$input->setOption('setting', null);
|
|
$this->validateSettings($input, $output);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param InputInterface $input
|
|
* @param OutputInterface $output
|
|
* @return void
|
|
* @throws DoesNotExistException
|
|
* @throws MultipleObjectsReturnedException
|
|
* @throws \ReflectionException
|
|
*/
|
|
protected function execute(InputInterface $input, OutputInterface $output) {
|
|
// $this->boardService->setUserId($this->settings->owner->getUID());
|
|
$this->setUserId($this->settings->owner->getUID());
|
|
// $this->userSession->setUser($this->settings->owner);
|
|
$this->importBoard();
|
|
$this->importLabels();
|
|
$this->importStacks();
|
|
$this->importCards();
|
|
// $boards = $this->boardService->findAll();
|
|
|
|
// $data = [];
|
|
// foreach ($boards as $board) {
|
|
// $fullBoard = $this->boardMapper->find($board->getId(), true, true);
|
|
// $data[$board->getId()] = (array)$fullBoard->jsonSerialize();
|
|
// $stacks = $this->stackMapper->findAll($board->getId());
|
|
// foreach ($stacks as $stack) {
|
|
// $data[$board->getId()]['stacks'][] = (array)$stack->jsonSerialize();
|
|
// $cards = $this->cardMapper->findAllByStack($stack->getId());
|
|
// foreach ($cards as $card) {
|
|
// $fullCard = $this->cardMapper->find($card->getId());
|
|
// $assignedUsers = $this->assignedUsersMapper->findAll($card->getId());
|
|
// $fullCard->setAssignedUsers($assignedUsers);
|
|
// $data[$board->getId()]['stacks'][$stack->getId()]['cards'][] = (array)$fullCard->jsonSerialize();
|
|
// }
|
|
// }
|
|
// }
|
|
// $output->writeln(json_encode($data, JSON_PRETTY_PRINT));
|
|
return self::SUCCESS;
|
|
}
|
|
|
|
private function checklistItem($item) {
|
|
if (($item->state == 'incomplete')) {
|
|
$string_start = '- [ ]';
|
|
} else {
|
|
$string_start = '- [x]';
|
|
}
|
|
$check_item_string = $string_start . ' ' . $item->name . "\n";
|
|
return $check_item_string;
|
|
}
|
|
|
|
function formulateChecklistText($checklist) {
|
|
$checklist_string = "\n\n## {$checklist->name}\n";
|
|
foreach ($checklist->checkItems as $item) {
|
|
$checklist_item_string = $this->checklistItem($item);
|
|
$checklist_string = $checklist_string . "\n" . $checklist_item_string;
|
|
}
|
|
return $checklist_string;
|
|
}
|
|
|
|
private function importCards() {
|
|
# Save checklist content into a dictionary (_should_ work even if a card has multiple checklists
|
|
foreach ($this->data->checklists as $checklist) {
|
|
$checklists[$checklist->idCard][$checklist->id] = $this->formulateChecklistText($checklist);
|
|
}
|
|
$this->data->checklists = $checklists;
|
|
|
|
foreach ($this->data->cards as $trelloCard) {
|
|
# Check whether a card is archived, if true, skipping to the next card
|
|
if ($trelloCard->closed) {
|
|
continue;
|
|
}
|
|
if ((count($trelloCard->idChecklists) !== 0)) {
|
|
foreach ($this->data->checklists[$trelloCard->id] as $checklist) {
|
|
$trelloCard->desc .= "\n" . $checklist;
|
|
}
|
|
}
|
|
|
|
$card = new Card();
|
|
$card->setTitle($trelloCard->name);
|
|
$card->setStackId($this->stacks[$trelloCard->idList]);
|
|
$card->setType('plain');
|
|
$card->setOrder($trelloCard->idShort);
|
|
$card->setOwner($this->settings->owner->getUID());
|
|
$card->setDescription($trelloCard->desc);
|
|
if ($trelloCard->due) {
|
|
$duedate = \DateTime::createFromFormat('Y-m-d\TH:i:s.000\Z', $trelloCard->due)
|
|
->format('Y-m-d H:i:s');
|
|
$card->setDuedate($duedate);
|
|
}
|
|
$card = $this->cardMapper->insert($card);
|
|
|
|
$this->associateCardToLabels($card->getId(), $trelloCard);
|
|
}
|
|
}
|
|
|
|
public function associateCardToLabels($cardId, $card) {
|
|
foreach ($card->labels as $label) {
|
|
$this->cardMapper->assignLabel(
|
|
$cardId,
|
|
$this->labels[$label->id]->getId()
|
|
);
|
|
}
|
|
}
|
|
|
|
private function importStacks() {
|
|
$this->stacks = [];
|
|
foreach ($this->data->lists as $order => $list) {
|
|
if ($list->closed) {
|
|
continue;
|
|
}
|
|
$stack = new Stack();
|
|
$stack->setTitle($list->name);
|
|
$stack->setBoardId($this->board->getId());
|
|
$stack->setOrder($order + 1);
|
|
$stack = $this->stackMapper->insert($stack);
|
|
$this->stacks[$list->id] = $stack;
|
|
}
|
|
}
|
|
|
|
private function translateColor($color) {
|
|
switch ($color) {
|
|
case 'red':
|
|
return 'ff0000';
|
|
case 'yellow':
|
|
return 'ffff00';
|
|
case 'orange':
|
|
return 'ff6600';
|
|
case 'green':
|
|
return '00ff00';
|
|
case 'purple':
|
|
return '9900ff';
|
|
case 'blue':
|
|
return '0000ff';
|
|
case 'sky':
|
|
return '00ccff';
|
|
case 'lime':
|
|
return '00ff99';
|
|
case 'pink':
|
|
return 'ff66cc';
|
|
case 'black':
|
|
return '000000';
|
|
default:
|
|
return 'ffffff';
|
|
}
|
|
}
|
|
|
|
private function importBoard() {
|
|
$this->board = $this->boardService->create(
|
|
$this->data->name,
|
|
$this->settings->owner->getUID(),
|
|
$this->settings->color
|
|
);
|
|
// $this->boardService->find($this->board->getId());
|
|
}
|
|
|
|
public function importLabels() {
|
|
$this->labels = [];
|
|
foreach ($this->data->labels as $label) {
|
|
if (empty($label->name)) {
|
|
$labelTitle = 'Unnamed ' . $label->color . ' label';
|
|
} else {
|
|
$labelTitle = $label->name;
|
|
}
|
|
$newLabel = $this->labelService->create(
|
|
$labelTitle,
|
|
$this->translateColor($label->color),
|
|
$this->board->getId()
|
|
);
|
|
$this->labels[$label->id] = $newLabel;
|
|
}
|
|
}
|
|
|
|
private function setUserId() {
|
|
$propertyPermissionService = new \ReflectionProperty($this->labelService, 'permissionService');
|
|
$propertyPermissionService->setAccessible(true);
|
|
$permissionService = $propertyPermissionService->getValue($this->labelService);
|
|
|
|
$propertyUserId = new \ReflectionProperty($permissionService, 'userId');
|
|
$propertyUserId->setAccessible(true);
|
|
$propertyUserId->setValue($permissionService, $this->settings->owner->getUID());
|
|
}
|
|
}
|