private function addBlock($dir, array $options, $blockName)
{
$filename = sprintf('%s/blocks/%s.json', $dir, $blockName);
$block = BlockFactory::createBlock($options["type"]);
$block->setName($blockName);
$block->setSlotName($options["slot"]);
$blockClass = get_class($block);
$encodedBlock = $this->serializer->serialize($block, 'json');
$event = Dispatcher::dispatch(BlockEvents::BLOCK_ADDING, new BlockAddingEvent($this->serializer, $filename, $encodedBlock, $blockClass));
$blockContent = $event->getFileContent();
FilesystemTools::writeFile($filename, $blockContent);
Dispatcher::dispatch(BlockEvents::BLOCK_ADDED, new BlockAddedEvent($this->serializer, $filename, $encodedBlock, $blockClass));
return $blockContent;
}
/**
* Approves a contribution
*
* @param string $sourceDir
* @param array $options
* @param string $username
*
* @return array The approved block
*/
public function approve($sourceDir, array $options, $username)
{
$this->init($sourceDir, $options, $username);
$sourceFilename = sprintf('%s/blocks/%s.json', $this->contributorDir, $options['blockname']);
$targetFilename = sprintf('%s/blocks/%s.json', $this->productionDir, $options['blockname']);
Dispatcher::dispatch(BlockEvents::BLOCK_APPROVING, new BlockApprovingEvent($this->serializer, $sourceFilename, $targetFilename));
$blockValues = JsonTools::jsonDecode(FilesystemTools::readFile($sourceFilename));
$blockValues["history"] = array();
FilesystemTools::writeFile($targetFilename, json_encode($blockValues));
$slotDefinitionContribution = $this->getSlotDefinition($this->getContributorDir());
$this->saveSlotDefinition($this->productionDir, $slotDefinitionContribution);
Dispatcher::dispatch(BlockEvents::BLOCK_APPROVED, new BlockApprovedEvent($this->serializer, $sourceFilename, $targetFilename));
DataLogger::log(sprintf('Block "%s" has been approved on the "%s" slot on page "%s" for the "%s_%s" language', $options["blockname"], $options["slot"], $options["page"], $options["language"], $options["country"]));
return $blockValues;
}
private function writeSlots($template, array $slots, $repeat)
{
foreach ($slots as $slotName) {
$fileName = sprintf('%s/%s/%s.json', $this->themeDir, $template, $slotName);
$value = array("blocks" => array());
if (file_exists($fileName)) {
$slot = json_decode(FilesystemTools::readFile($fileName), true);
if ($slot["repeat"] == $repeat) {
continue;
}
$value["blocks"] = $slot["blocks"];
}
$value["repeat"] = $repeat;
FilesystemTools::writeFile($fileName, json_encode($value));
}
}
/**
* Edits the given block
*
* @param string $sourceDir
* @param array $options
* @param string $username
* @param array $values
*/
public function edit($sourceDir, array $options, $username, $values)
{
$this->resolveOptions($options);
$this->init($sourceDir, $options, $username);
$this->createContributorDir($sourceDir, $options, $username);
$filename = sprintf('%s/blocks/%s.json', $this->getDirInUse(), $options["blockname"]);
$currentBlock = $options["baseBlock"] = JsonTools::jsonDecode(FilesystemTools::readFile($filename));
$values = $this->parseChildren($values);
$block = JsonTools::join($currentBlock, $values);
$encodedBlock = json_encode($block);
$blockClass = BlockFactory::getBlockClass($block["type"]);
$event = Dispatcher::dispatch(BlockEvents::BLOCK_EDITING, new BlockEditingEvent($this->serializer, $filename, $encodedBlock, $blockClass));
$blockContent = $event->getFileContent();
FilesystemTools::writeFile($filename, $blockContent);
Dispatcher::dispatch(BlockEvents::BLOCK_EDITED, new BlockEditedEvent($this->serializer, $filename, $encodedBlock, $blockClass));
DataLogger::log(sprintf('Block "%s" has been edited on the "%s" slot on page "%s" for the "%s_%s" language', $options["blockname"], $options["slot"], $options["page"], $options["language"], $options["country"]));
}
/**
* Archives the given block
*
* @param string $sourceDir
* @param array $options
* @param string $username
* @param array $block
*/
public function archive($sourceDir, array $options, $username, $block)
{
$this->resolveOptions($options);
$block = json_decode($block, true);
$block["history"] = array();
$this->init($sourceDir, $options, $username);
$historyDirName = sprintf('%s/archive/%s', $this->getDirInUse(), $options["blockname"]);
$historyFileName = $historyDirName . '/history.json';
if (!is_dir($historyDirName)) {
mkdir($historyDirName);
}
$history = array();
if (file_exists($historyFileName)) {
$history = json_decode(file_get_contents($historyFileName), true);
}
$history = array_merge($history, array($block["history_name"] => $block));
FilesystemTools::writeFile($historyFileName, json_encode($history));
}
/**
* Implements the action to update the user information
* @param array $options
*
* @return \Symfony\Component\HttpFoundation\Response
*/
public function save(array $options)
{
$resolver = new OptionsResolver();
$this->configureOptions($resolver);
$this->options = $resolver->resolve($options);
$request = $this->options["request"];
$password = $request->get('password');
$user = $this->fetchUser($this->options['security'], $this->options['configuration_handler']);
$factory = $this->options['encoder_factory'];
$encoder = $factory->getEncoder($user);
$salt = base_convert(sha1(uniqid(mt_rand(), true)), 16, 36);
$password = $encoder->encodePassword($password, $salt);
$userName = "******";
$usersFile = $this->options['configuration_handler']->usersDir() . '/users.json';
$users = json_decode(FilesystemTools::readFile($usersFile), true);
$user = $users[$userName];
$user["password"] = $password;
$user["salt"] = $salt;
$users[$userName] = $user;
FilesystemTools::writeFile($usersFile, json_encode($users));
}
private function saveTemplateSlots(array $slots, $templateName)
{
foreach ($slots as $slot) {
$slotName = $slot->getSlotName();
$templateSlotFile = sprintf('%s/%s/%s.json', $this->themeDir, $templateName, $slotName);
if (!file_exists($templateSlotFile)) {
continue;
}
$templateSlotContent = json_decode(file_get_contents($templateSlotFile), true);
$blocks = array();
foreach ($slot->getProductionEntities() as $block) {
$blocks[] = json_decode($block, true);
}
$templateSlotContent["blocks"] = $blocks;
FilesystemTools::writeFile($templateSlotFile, json_encode($templateSlotContent));
}
}
private function saveQueueFile($message)
{
$queueDir = dirname($this->queueFile);
if (!is_dir($queueDir)) {
mkdir($queueDir);
}
$queue = array("error" => $message, "queue" => $this->queue["queue"]);
FilesystemTools::writeFile($this->queueFile, json_encode($queue));
}
/**
* Generate blocks for the current slot
* @param array $blocks
* @param string $blocksDir
* @param string $targetDir
*/
protected function generateBlocks(array $blocks, $blocksDir, $targetDir)
{
$c = 1;
$generatedBlocks = array();
foreach ($blocks as $block) {
$blockName = 'block' . $c;
$fileName = sprintf('%s/%s.json', $blocksDir, $blockName);
$generatedBlocks[] = $blockName;
$value = $block;
if (is_array($value)) {
$value = json_encode($block);
}
FilesystemTools::writeFile($fileName, $value);
$c++;
}
$slotDefinition = array('next' => $c, 'blocks' => $generatedBlocks, 'revision' => 1);
FilesystemTools::writeFile($targetDir . '/slot.json', json_encode($slotDefinition));
}
private function moveBlockToSameSlot($baseDir, array $options, $username)
{
$sourceDir = $this->init($baseDir, $options, $username)->getDirInUse();
$slotsFilename = sprintf('%s/slot.json', $sourceDir);
$slot = JsonTools::jsonDecode(FilesystemTools::readFile($slotsFilename), true);
$blocks = $slot["blocks"];
$key = array_search($options["blockname"], $blocks);
$blockName = $blocks[$key];
unset($blocks[$key]);
array_splice($blocks, $options["position"], 0, $blockName);
$slot["blocks"] = $blocks;
$encodedSlot = json_encode($slot);
$targetFile = sprintf('%s/blocks/%s.json', $sourceDir, $options["blockname"]);
$event = Dispatcher::dispatch(BlockEvents::BLOCK_MOVING_SAME_SLOT, new BlockMovingSameSlotEvent($this->serializer, $blocks, $options["position"], $targetFile, $encodedSlot));
$slotContent = $event->getFileContent();
FilesystemTools::writeFile($slotsFilename, $slotContent);
$block = FilesystemTools::readFile($targetFile);
Dispatcher::dispatch(BlockEvents::BLOCK_MOVED_SAME_SLOT, new BlockMovedSameSlotEvent($this->serializer, $blocks, $options["position"], $targetFile, $encodedSlot));
DataLogger::log(sprintf('Block "%s" has been moved to position "%s" on the slot "%s" on "%s" page for "%s_%s" language', $options["blockname"], $options["position"], $options["slot"], $options["page"], $options["language"], $options["country"]));
return $block;
}
/**
* Approves the page in production
* @param $pageName
* @param $languageName
*
* @return string The json seo content
*/
public function approve($pageName, $languageName)
{
$this->contributorDefined();
$baseDir = $this->pagesDir . '/' . $pageName . '/' . $languageName;
$sourceFile = $baseDir . '/' . $this->username . '.json';
$targetFile = $baseDir . '/seo.json';
if (!file_exists($targetFile)) {
throw new PageNotPublishedException('exception_page_not_published');
}
$values = json_decode(FilesystemTools::readFile($sourceFile), true);
if (!empty($values["current_permalink"])) {
$values["changed_permalinks"][] = $values["current_permalink"];
$values["current_permalink"] = "";
}
$encodedSeo = json_encode($values);
$event = Dispatcher::dispatch(PageEvents::PAGE_APPROVING, new PageApprovingEvent($sourceFile, $encodedSeo));
$encodedSeo = $event->getFileContent();
FilesystemTools::writeFile($sourceFile, $encodedSeo);
FilesystemTools::writeFile($targetFile, $encodedSeo);
Dispatcher::dispatch(PageEvents::PAGE_APPROVED, new PageApprovedEvent($sourceFile, $encodedSeo));
DataLogger::log(sprintf('Page SEO attributes "%s" for language "%s" were approved', $pageName, $languageName));
return $encodedSeo;
}
/**
* Edits the handled page
* @param array $values
*
* @return string The encoded page
*/
public function edit(array $values)
{
$currentName = $values["currentName"];
unset($values["currentName"]);
$pageDir = $this->pagesDir . '/' . $values["name"];
if (!is_dir($pageDir)) {
$pageDir = $this->pagesDir . '/' . $currentName;
}
$pageFile = $pageDir . '/' . $this->pageFile;
$currentValues = json_decode(FilesystemTools::readFile($pageFile), true);
if (array_key_exists("template", $values) && $currentValues["template"] != $values["template"]) {
Dispatcher::dispatch(PageCollectionEvents::TEMPLATE_CHANGED, new TemplateChangedEvent($currentValues["template"], $values["template"], $this->username));
}
$values = array_merge($currentValues, $values);
$values = $this->slugifyPageName($values);
$targetFolder = $this->pagesDir . '/' . $values["name"];
$encodedPage = json_encode($values);
$event = Dispatcher::dispatch(PageCollectionEvents::PAGE_COLLECTION_EDITING, new PageCollectionEditingEvent($pageFile, $encodedPage));
$encodedPage = $event->getFileContent();
FilesystemTools::writeFile($pageFile, $encodedPage);
if ($currentName != $values["name"]) {
rename($pageDir, $targetFolder);
}
Dispatcher::dispatch(PageCollectionEvents::PAGE_COLLECTION_EDITED, new PageCollectionEditedEvent($pageFile, $encodedPage));
DataLogger::log(sprintf('Page "%s" was successfully edited', $currentName));
return $encodedPage;
}
/**
* Saves the slot definition
*
* @param string $dir
* @param array $slot
*/
protected function saveSlotDefinition($dir, array $slot)
{
$slotsFilename = $this->getSlotDefinitionFile($dir);
FilesystemTools::writeFile($slotsFilename, json_encode($slot), $this->filesystem);
}