public function postIndex()
{
$block = Block::find(Request::input('block_id'));
if (($repeaterId = Request::input('repeater_id')) && $block && $block->type == 'repeater') {
return $block->setPageId(Request::input('page_id'))->getTypeObject()->edit($repeaterId, true);
}
return 0;
}
/**
* Should only be called after save
* By default, updates search text and publishes a new page version
* @return static
*/
public function publish()
{
if ($this->_block->getPageId() && $this->_isSaved) {
$searchText = $this->_block->search_weight > 0 ? $this->generateSearchText($this->_contentSaved) : '';
$this->_block->publishContent($searchText);
}
return $this;
}
public function postIndex()
{
// update blocks
AdminLog::new_log('Updated Site-wide Content');
$versionId = PageVersion::add_new(0)->version_id;
Block::submit(0, $versionId);
$this->addAlert('success', 'Site-wide Content Updated');
return \redirect()->route('coaster.admin.blocks');
}
public function getEdit($groupId)
{
$group = PageGroup::preload($groupId);
if ($group->exists) {
$templateSelectOptions = [0 => '-- No default --'] + Theme::get_template_list($group->default_template);
$blockList = Block::idToLabelArray();
$this->layoutData['content'] = View::make('coaster::pages.groups.edit', ['group' => $group, 'defaultTemplate' => $group->default_template, 'templateSelectOptions' => $templateSelectOptions, 'blockList' => $blockList]);
}
}
/**
* @param int $blockId
* @param int $pageId
* @return \CoasterCms\Libraries\Blocks\Gallery
* @throws \Exception
*/
protected function _getGalleryBlock($pageId, $blockId)
{
$galleryBlock = Block::preload($blockId)->setPageId($pageId)->getTypeObject();
if (is_a($galleryBlock, Gallery::class)) {
return $galleryBlock;
} else {
throw new \Exception('Not a gallery block!');
}
}
public static function getRepeaterBlocks($blockId)
{
$repeaterBlocks = [];
$blockRepeater = static::preload($blockId);
if ($blockRepeater->exists) {
foreach (explode(",", $blockRepeater->blocks) as $repeaterBlockId) {
$repeaterBlocks[$repeaterBlockId] = Block::preload($repeaterBlockId);
}
}
return $repeaterBlocks;
}
public static function blocks_of_type($type)
{
$numb_type = array();
$block_ids = Block::getBlockIdsOfType($type);
if (!empty($block_ids)) {
$sw = ThemeBlock::whereIn('block_id', $block_ids)->where('show_in_pages', '=', 1)->count();
$templates = TemplateBlock::whereIn('block_id', $block_ids)->groupBy('template_id')->get(array('template_id', DB::raw('count(*) as type')));
foreach ($templates as $template) {
$numb_type[$template->template_id] = $sw + $template->type;
}
}
return $numb_type;
}
public static function updateAllSearchData()
{
self::truncate();
$pageLanguages = PageLang::all();
foreach ($pageLanguages as $pageLang) {
static::updateText(strip_tags($pageLang->name), 0, $pageLang->page_id, $pageLang->language_id);
$pageBlocks = Block::getDataForVersion(new PageBlock(), $pageLang->live_version, ['language_id' => $pageLang->language_id, 'page_id' => $pageLang->page_id]);
foreach ($pageBlocks as $pageBlock) {
$block = Block::preloadClone($pageBlock->block_id)->setPageId($pageBlock->page_id);
$searchText = $block->search_weight > 0 ? $block->getTypeObject()->generateSearchText($pageBlock->content) : '';
static::updateText($searchText, $pageBlock->block_id, $pageBlock->page_id, $pageBlock->language_id);
}
}
}
public static function getView($type)
{
$typeParts = explode('.', $type);
$typeExtension = '.' . (count($typeParts) > 1 ? implode('.', array_slice($typeParts, 1)) : 'main');
$typeClassName = Block::getBlockClass($typeParts[0]);
$typeClasses = array_merge([$typeClassName], class_parents($typeClassName));
foreach ($typeClasses as $typeClass) {
$blockTypeView = Block::getBlockType($typeClass) . $typeExtension;
$blockTypeView = strtolower($blockTypeView);
$locations = ['coaster.blocks.', 'coaster::blocks.'];
foreach ($locations as $location) {
if (View::exists($location . $blockTypeView)) {
return $location . $blockTypeView;
}
}
}
return null;
}
public static function loadRepeaterData($repeaterId, $version = 0, $randomOrder = false)
{
$repeaterRowsById = [];
if ($rowIds = PageBlockRepeaterRows::getRowIds($repeaterId)) {
$repeaterRowsData = Block::getDataForVersion(new static(), $version, ['row_key' => array_keys($rowIds)]) ?: [];
foreach ($repeaterRowsData as $repeaterRowData) {
$repeaterRowId = $rowIds[$repeaterRowData->row_key];
if (!isset($repeaterRowsById[$repeaterRowId])) {
$repeaterRowsById[$repeaterRowId] = [];
}
$repeaterRowsById[$repeaterRowId][$repeaterRowData->block_id] = $repeaterRowData->content;
}
if ($randomOrder === false) {
uasort($repeaterRowsById, ['self', '_order']);
} else {
shuffle($repeaterRowsById);
$repeaterRowsById = array_slice($repeaterRowsById, 0, $randomOrder);
}
}
return $repeaterRowsById;
}
public static function _pageImportData($theme)
{
$importPath = $themePath = base_path() . '/resources/views/themes/' . $theme->theme . '/import/';
if (is_dir($importPath)) {
// wipe data
DB::table((new Page())->getTable())->truncate();
DB::table((new PageLang())->getTable())->truncate();
DB::table((new PageVersion())->getTable())->truncate();
DB::table((new PagePublishRequests())->getTable())->truncate();
DB::table((new PageGroup())->getTable())->truncate();
DB::table((new PageGroupAttribute())->getTable())->truncate();
DB::table((new PageGroupPage())->getTable())->truncate();
DB::table((new Menu())->getTable())->truncate();
DB::table((new MenuItem())->getTable())->truncate();
DB::table((new PageBlockDefault())->getTable())->truncate();
DB::table((new PageBlock())->getTable())->truncate();
DB::table((new PageBlockRepeaterData())->getTable())->truncate();
DB::table((new PageBlockRepeaterRows())->getTable())->truncate();
$templateIds = [];
$templates = Template::where('theme_id', '=', $theme->id)->get();
foreach ($templates as $template) {
$templateIds[$template->template] = $template->id;
}
$blockIds = [];
$blocks = Block::all();
foreach ($blocks as $block) {
$blockIds[$block->name] = $block->id;
}
$pagesCsv = $importPath . 'pages.csv';
$groupsCsv = $importPath . 'pages/groups.csv';
$groupAttributesCsv = $importPath . 'pages/group_attributes.csv';
$menusCsv = $importPath . 'pages/menus.csv';
$menuItemsCsv = $importPath . 'pages/menu_items.csv';
$pageBlocksCsv = $importPath . 'pages/page_blocks.csv';
$repeaterBlocksCsv = $importPath . 'pages/repeater_blocks.csv';
// checks
$error = 'pages data not imported, invalid columns in: ';
if (!($pagesFileHandle = Csv::check($pagesCsv, 14))) {
if (file_exists($pagesCsv)) {
throw new \Exception($error . $pagesCsv);
}
}
if (!($groupsHandle = Csv::check($groupsCsv, 5))) {
if (file_exists($groupsCsv)) {
throw new \Exception($error . $groupsCsv);
}
}
if (!($groupAttributesHandle = Csv::check($groupAttributesCsv, 6))) {
if (file_exists($groupAttributesCsv)) {
throw new \Exception($error . $groupAttributesCsv);
}
}
if (!($menusHandle = Csv::check($menusCsv, 3))) {
if (file_exists($menusCsv)) {
throw new \Exception($error . $menusCsv);
}
}
if (!($menuItemsCsvHandle = Csv::check($menuItemsCsv, 5))) {
if (file_exists($menuItemsCsv)) {
throw new \Exception($error . $menuItemsCsv);
}
}
if (!($pageBlocksCsvHandle = Csv::check($pageBlocksCsv, 3))) {
if (file_exists($pageBlocksCsv)) {
throw new \Exception($error . $pageBlocksCsv);
}
}
if (!($repeaterBlocksCsvHandle = Csv::check($repeaterBlocksCsv, 4))) {
if (file_exists($repeaterBlocksCsv)) {
throw new \Exception($error . $repeaterBlocksCsv);
}
}
// add pages
if ($pagesFileHandle) {
$row = 0;
while (($data = fgetcsv($pagesFileHandle)) !== false) {
if ($row++ == 0 && $data[0] == 'Page Id') {
continue;
}
list($pageId, $pageName, $pageUrl, $templateName, $parentId, $defaultChildTemplateName, $order, $link, $live, $sitemap, $groupContainer, $groupContainerUrlPriority, $canonicalParentPageId, $groupIds) = $data;
$newPage = new Page();
$newPage->id = $pageId;
$newPage->template = !empty($templateIds[$templateName]) ? $templateIds[$templateName] : 0;
$newPage->parent = $parentId ?: 0;
$newPage->child_template = !empty($templateIds[$defaultChildTemplateName]) ? $templateIds[$defaultChildTemplateName] : 0;
$newPage->order = $order;
$newPage->link = $link;
$newPage->live = $live;
$newPage->sitemap = $sitemap;
$newPage->group_container = $groupContainer ?: 0;
$newPage->group_container_url_priority = $groupContainerUrlPriority ?: 0;
$newPage->canonical_parent = $canonicalParentPageId ?: 0;
$newPage->save();
$newPageLang = new PageLang();
$newPageLang->page_id = $pageId;
$newPageLang->language_id = Language::current();
$newPageLang->name = $pageName;
$newPageLang->url = $pageUrl;
$newPageLang->live_version = 1;
$newPageLang->save();
PageVersion::add_new($pageId);
$groupIds = trim($groupIds);
$groupIds = $groupIds ? explode(',', $groupIds) : [];
foreach ($groupIds as $groupId) {
$newPageGroupPage = new PageGroupPage();
$newPageGroupPage->page_id = $pageId;
$newPageGroupPage->group_id = $groupId;
$newPageGroupPage->save();
}
}
}
// add page groups
if ($groupsHandle) {
$row = 0;
while (($data = fgetcsv($groupsHandle)) !== false) {
if ($row++ == 0 && $data[0] == 'Group Id') {
continue;
}
list($groupId, $groupName, $itemName, $defaultContainerPageId, $defaultTemplate) = $data;
$newGroup = new PageGroup();
$newGroup->id = $groupId;
$newGroup->name = $groupName;
$newGroup->item_name = $itemName;
$newGroup->url_priority = $defaultContainerPageId;
$newGroup->default_template = !empty($templateIds[$defaultTemplate]) ? $templateIds[$defaultTemplate] : 0;
$newGroup->save();
}
}
if ($groupAttributesHandle) {
$row = 0;
while (($data = fgetcsv($groupAttributesHandle)) !== false) {
if ($row++ == 0 && $data[0] == 'Attribute Id') {
continue;
}
list($attributeId, $groupId, $blockName, $orderPriority, $orderDir, $filerByBlockName) = $data;
$newGroupAttribute = new PageGroupAttribute();
$newGroupAttribute->id = $attributeId;
$newGroupAttribute->group_id = $groupId;
$newGroupAttribute->item_block_id = !empty($blockIds[$blockName]) ? $blockIds[$blockName] : 0;
$newGroupAttribute->item_block_order_priority = $orderPriority;
$newGroupAttribute->item_block_order_dir = $orderDir == 'desc' ? $orderDir : 'asc';
$newGroupAttribute->filter_by_block_id = !empty($blockIds[$filerByBlockName]) ? $blockIds[$filerByBlockName] : 0;
$newGroupAttribute->save();
}
}
// add menus
if ($menusHandle) {
$menuIds = [];
$row = 0;
while (($data = fgetcsv($menusHandle)) !== false) {
if ($row++ == 0 && $data[0] == 'Menu Identifier') {
continue;
}
list($name, $label, $maxSublevel) = $data;
$newMenu = new Menu();
$newMenu->label = $label;
$newMenu->name = $name;
$newMenu->max_sublevel = $maxSublevel;
$newMenu->save();
$menuIds[$name] = $newMenu->id;
}
}
if ($menuItemsCsvHandle) {
$row = 0;
while (($data = fgetcsv($menuItemsCsvHandle)) !== false) {
if ($row++ == 0 && $data[0] == 'Menu Identifier') {
continue;
}
list($menuIdentifier, $pageId, $order, $subLevels, $customName) = $data;
if (!empty($menuIds[$menuIdentifier])) {
$newMenuItem = new MenuItem();
$newMenuItem->menu_id = $menuIds[$menuIdentifier];
$newMenuItem->page_id = $pageId;
$newMenuItem->order = $order;
$newMenuItem->sub_levels = $subLevels;
$newMenuItem->custom_name = $customName;
$newMenuItem->save();
}
}
}
// add page content
if ($pageBlocksCsvHandle) {
$row = 0;
while (($data = fgetcsv($pageBlocksCsvHandle)) !== false) {
if ($row++ == 0 && $data[0] == 'Page Id') {
continue;
}
list($pageId, $blockName, $content) = $data;
if (!empty($blockIds[$blockName])) {
if ($pageId) {
$newPageBlock = new PageBlock();
$newPageBlock->page_id = $pageId;
} else {
$newPageBlock = new PageBlockDefault();
}
$newPageBlock->block_id = $blockIds[$blockName];
$newPageBlock->version = 1;
$newPageBlock->content = $content;
$newPageBlock->save();
}
}
}
if ($repeaterBlocksCsvHandle) {
$row = 0;
$existingRepeaterRowKeys = [];
while (($data = fgetcsv($repeaterBlocksCsvHandle)) !== false) {
if ($row++ == 0 && $data[0] == 'Repeater Id') {
continue;
}
list($repeaterId, $repeaterRowId, $blockName, $content) = $data;
if (!empty($blockIds[$blockName])) {
if ($decodedContent = json_decode($content)) {
if (!is_string($decodedContent)) {
$content = serialize($decodedContent);
}
}
if (!isset($existingRepeaterRowKeys[$repeaterId . '-' . $repeaterRowId])) {
$newRepeaterRow = new PageBlockRepeaterRows();
$newRepeaterRow->repeater_id = $repeaterId;
$newRepeaterRow->row_id = $repeaterRowId;
$newRepeaterRow->save();
$existingRepeaterRowKeys[$repeaterId . '-' . $repeaterRowId] = $newRepeaterRow->id;
$newRepeaterData = new PageBlockRepeaterData();
$newRepeaterData->row_key = $existingRepeaterRowKeys[$repeaterId . '-' . $repeaterRowId];
$newRepeaterData->block_id = 0;
$newRepeaterData->version = 1;
$newRepeaterData->content = $repeaterRowId;
$newRepeaterData->save();
}
$newRepeaterData = new PageBlockRepeaterData();
$newRepeaterData->row_key = $existingRepeaterRowKeys[$repeaterId . '-' . $repeaterRowId];
$newRepeaterData->block_id = $blockIds[$blockName];
$newRepeaterData->version = 1;
$newRepeaterData->content = $content;
$newRepeaterData->save();
}
}
}
PageSearchData::updateAllSearchData();
}
}
/**
* @param string $name
* @param array $arguments
* @return mixed|string
* @throws PageBuilderException
*/
public function __call($name, $arguments)
{
if (strpos($name, 'block_') === 0) {
$validTypes = Block::getBlockClasses();
$blockType = strtolower(substr($name, 6));
if (!empty($validTypes[$blockType])) {
$blockName = $arguments[0];
if (!isset($this->blockSettings[$blockName])) {
$this->blockSettings[$blockName] = [];
}
if (!isset($this->blockSettings[$blockName]['type'])) {
$this->blockSettings[$blockName]['type'] = $blockType;
}
}
}
try {
return parent::__call($name, $arguments);
} catch (PageBuilderException $e) {
$error = $e->getMessage() . ' (themes.' . $this->theme . '.templates.' . $this->template;
$error .= $this->categoryView ? ' ' . $this->categoryView : $this->categoryView;
$error .= $this->repeaterView ? ' ' . $this->repeaterView : $this->repeaterView;
$error .= ')';
$this->errors[] = $error;
throw new PageBuilderException($error);
}
}
public function getCsv($pageId = 0, $blockId = 0)
{
$block_data = Block::getBlockOnPage($blockId, $pageId);
if (empty($block_data) || $block_data->type != 'form') {
\abort('404', 'Form not found on page');
} else {
$csv = array();
$columns = array();
$column = 2;
$row = 1;
$submissions = FormSubmission::where('form_block_id', '=', $blockId)->orderBy('id', 'desc')->get();
if (!$submissions->isEmpty()) {
foreach ($submissions as $submission) {
$csv[$row] = array();
$csv[$row][0] = $submission->created_at;
$csv[$row][1] = !empty($submission->from_page_id) ? Path::getFullName($submission->from_page_id) : '-';
$form_data = @unserialize($submission->content);
if (!empty($form_data)) {
foreach ($form_data as $k => $v) {
if (!isset($columns[$k])) {
$columns[$k] = $column;
$column++;
}
if (is_array($v)) {
$v = implode(", ", $v);
}
$csv[$row][$columns[$k]] = $v;
}
} else {
preg_match_all('/\\"(.*?)\\";s:\\d*:\\"(.*?)\\";/si', $submission->content, $matches);
foreach ($matches[1] as $k => $field_key) {
if (!isset($columns[$field_key])) {
$columns[$field_key] = $column;
$column++;
}
$csv[$row][$columns[$field_key]] = $matches[2][$k];
}
}
$row++;
}
// add row titles
$csv[0][0] = 'Date/Time';
$csv[0][1] = 'Page';
foreach ($columns as $name => $col) {
$csv[0][$col] = ucwords($name);
}
$numb_columns = count($columns);
foreach ($csv as $row_id => $csv_row) {
for ($i = 0; $i < $numb_columns; $i++) {
if (!isset($csv_row[$i])) {
$csv[$row_id][$i] = '';
}
}
ksort($csv[$row_id]);
}
ksort($csv);
$block_data = Block::find($blockId);
header("Content-type: text/csv");
header("Content-Disposition: attachment; filename=" . $block_data->name . ".csv");
header("Pragma: no-cache");
header("Expires: 0");
$output = fopen("php://output", "w");
foreach ($csv as $csv_row) {
fputcsv($output, $csv_row);
// here you can change delimiter/enclosure
}
fclose($output);
}
exit;
}
}
public function getIndex()
{
$database_structure = $this->_db_messages();
$search_data = PageSearchData::orderBy('updated_at', 'asc')->first();
if (!empty($search_data)) {
$last_indexed_search = DateTimeHelper::display($search_data->updated_at);
} else {
$last_indexed_search = false;
}
$update = Auth::action('system.update');
if ($update) {
$settings = Setting::where('hidden', '=', '0')->orWhere('editable', '=', 1)->get();
} else {
$settings = Setting::where('hidden', '=', '0')->get();
}
foreach ($settings as $k => $setting) {
if (!$update) {
$settings[$k]->editable = 0;
}
$note = '';
switch ($setting->name) {
case 'frontend.language':
$custom = new \stdClass();
$custom->selected = $setting->value;
$custom->options = Language::selectArray();
break;
case 'frontend.theme':
$custom = new \stdClass();
$custom->selected = $setting->value;
$custom->options = Theme::selectArray();
break;
case 'admin.default_template':
$custom = new \stdClass();
$custom->selected = $setting->value;
$custom->options = Theme::get_template_list($setting->value);
break;
case 'frontend.language_fallback':
case 'frontend.strong_tags':
case 'admin.advanced_permissions':
case 'admin.publishing':
$custom = new \stdClass();
$custom->selected = $setting->value;
$custom->options = [1 => 'On', 0 => 'Off'];
break;
case 'admin.title_block':
$custom = new \stdClass();
$custom->selected = $setting->value;
$custom->options = Block::nameToNameArray();
break;
case 'site.pages':
$total_pages = Page::get_total();
$note = 'set to 0 for no limit - currently ' . $total_pages . ' normal pages in use';
break;
case 'site.groups':
$total_pages = Page::get_total(true);
$note = 'set to 0 for no limit on group pages - currently ' . $total_pages . ' pages in use';
break;
case 'site.secure_folders':
$note = 'list of comma separated folders, will copy files to secure folders and vice versa on update';
break;
default:
$custom = null;
}
if (empty($custom)) {
$settings[$k]->value = $setting->value;
} else {
$settings[$k]->value = $custom;
}
$settings[$k]->note = !empty($note) ? $note : null;
$settings[$k]->name = str_replace('.', $this->dot_replace, $setting->name);
}
$upgrade = new \stdClass();
$upgrade->from = config('coaster::site.version');
$upgrade->to = Setting::latestTag();
$upgrade->required = version_compare(config('coaster::site.version'), Setting::latestTag(), '<');
$this->layoutData['content'] = View::make('coaster::pages.system', array('database_structure' => $database_structure, 'last_indexed_search' => $last_indexed_search, 'site_details' => $settings, 'can_index_search' => Auth::action('system.search'), 'can_validate' => Auth::action('system.validate-db'), 'can_upgrade' => Auth::action('system.upgrade'), 'upgrade' => $upgrade));
}
/**
* Load page block data for all live versions of a block across all pages
* @param int $blockId
* @param bool $reload
* @return PageBlock[]
*/
public static function livePageBlocksForBlock($blockId, $reload = false)
{
if ($reload) {
static::_preloadClear('liveBlocks');
}
if (!static::_preloadIsset('liveBlocks', $blockId)) {
$pageBlocks = Block::getDataForVersion(new static(), -1, ['block_id' => $blockId, 'language_id' => Language::current()]);
static::_preload($pageBlocks, 'liveBlocks', [['block_id']], null, true);
}
return static::_preloadGet('liveBlocks', $blockId) ?: [];
}
private function _typeList()
{
$selectArray = [];
foreach (Block::getBlockClasses() as $blockName => $blockClass) {
$selectArray[$blockName] = $blockName;
}
return $selectArray;
}
/**
* Filter by container block content (filtered by group container content - pageId)
* @param int $pageId
* @param bool $checkLive
* @param bool $sort
* @return array
*/
public function itemPageIdsFiltered($pageId, $checkLive = false, $sort = false)
{
$filterType = $checkLive ? 'all' : 'live';
$sortedSuffix = '-sorted';
$sorted = $sort ? $sortedSuffix : '';
self::$groupPagesFiltered[$this->id] = empty(self::$groupPagesFiltered[$this->id]) ? [] : self::$groupPagesFiltered[$this->id];
if (!array_key_exists($filterType . $sorted, self::$groupPagesFiltered[$this->id])) {
if ($pageIds = $this->itemPageIds($checkLive, $sort)) {
foreach ($this->blockFilters() as $blockFilter) {
// get data to filter by
$filterByBlock = Block::preload($blockFilter->filter_by_block_id);
$filterByContent = PageBlock::preloadPageBlockLanguage($pageId, $blockFilter->filter_by_block_id, -1, 'block_id')->content;
if ($filterByBlock->type == 'selectmultiple') {
$filterByContentArr = unserialize($filterByContent);
$filterByContentArr = is_array($filterByContentArr) ? $filterByContentArr : [];
} else {
$filterByContentArr = [$filterByContent];
}
$filterByContentArr = array_filter($filterByContentArr, function ($filterByContentEl) {
return !is_null($filterByContentEl);
});
if (!empty($filterByContentArr)) {
// get block data for block to filter on
$blockType = Block::preload($blockFilter->item_block_id)->getTypeObject();
// run filter with filterBy content
$filteredPageIds = [];
foreach ($pageIds as $groupPageId) {
foreach ($filterByContentArr as $filterByContentEl) {
$groupPageBlockContent = PageBlock::preloadPageBlockLanguage($groupPageId, $blockFilter->item_block_id, -1)->content;
if ($blockType->filter($groupPageBlockContent, $filterByContentEl, '=')) {
$filteredPageIds[] = $groupPageId;
break;
}
}
}
$pageIds = $filteredPageIds;
}
}
}
self::$groupPagesFiltered[$this->id][$filterType . $sorted] = $pageIds;
}
return self::$groupPagesFiltered[$this->id][$filterType . $sorted];
}
/**
* Add new repeater row with passed block contents onto end of repeater rows (or create repeater and set as first row)
* @param array $repeaterBlockContents
*/
public function insertRow($repeaterBlockContents)
{
if (!($repeaterId = $this->_block->getContent())) {
$repeaterId = PageBlockRepeaterRows::nextFreeRepeaterId();
$this->save($repeaterId);
$currentRepeaterRows = [];
} else {
$currentRepeaterRows = PageBlockRepeaterData::loadRepeaterData($repeaterId);
}
$repeaterRowId = PageBlockRepeaterRows::nextFreeRepeaterRowId($repeaterId);
if (!array_key_exists(0, $repeaterBlockContents)) {
if (!empty($currentRepeaterRows)) {
$rowOrders = array_map(function ($row) {
return !empty($row[0]) ? $row[0] : 0;
}, $currentRepeaterRows);
$repeaterBlockContents[0] = max($rowOrders) + 1;
} else {
$repeaterBlockContents[0] = 1;
}
}
foreach ($repeaterBlockContents as $blockName => $content) {
$block = Block::preloadClone($blockName);
if ($block->exists || $blockName == 0) {
$block->id = $blockName === 0 ? 0 : $block->id;
$block->setVersionId($this->_block->getVersionId())->setRepeaterData($repeaterId, $repeaterRowId)->setPageId($this->_block->getPageId())->getTypeObject()->save($content);
}
}
}
<?php
$action = false;
$galleryBlocks = \CoasterCms\Models\Block::where('type', '=', 'gallery')->get();
if (!$galleryBlocks->isEmpty()) {
$galleryStorage = public_path() . '/uploads/system/gallery/';
foreach ($galleryBlocks as $galleryBlock) {
$oldGalleryDir = $galleryStorage . $galleryBlock->id;
$newGalleryDir = $galleryStorage . $galleryBlock->name;
if (is_dir($oldGalleryDir)) {
$action = true;
\CoasterCms\Helpers\Cms\File\Directory::copy($oldGalleryDir, $newGalleryDir);
\CoasterCms\Helpers\Cms\File\Directory::remove($oldGalleryDir);
}
}
}
if ($action) {
echo "Coaster Framework: Moved gallery files so they are stored by block name\n";
}
/**
* @param string $blockName
* @param array $options
* @return mixed|string
*/
public function block($blockName, $options = [])
{
// force query available if block details changed in current request
$block = Block::preloadClone($blockName, isset($options['force_query']));
$pageId = !empty($options['page_id']) ? Path::unParsePageId($options['page_id']) : $this->pageId();
$usingGlobalContent = false;
$blockData = null;
if (($customBlockData = $this->_getCustomBlockData($blockName)) !== null) {
// load custom block data for (is also used for repeater content)
$blockData = $customBlockData;
} elseif ($block->exists) {
// load block data
$globalBlockData = PageBlockDefault::preload($block->id);
$pageBlockData = PageBlock::preloadPageBlock($pageId, $block->id, $this->pageVersion($pageId));
// get languages
$loadForLanguages = [Language::current()];
if (config('coaster::frontend.language_fallback') == 1 && !in_array(config('coaster::frontend.language'), $loadForLanguages)) {
$loadForLanguages[] = config('coaster::frontend.language');
}
// run through languages until block data found
foreach ($loadForLanguages as $language) {
if (!empty($pageBlockData[$language])) {
// if custom page block for selected language exists
$blockData = $pageBlockData[$language]->content;
} elseif (!empty($globalBlockData[$language])) {
// if default block for selected language exists
$blockData = $globalBlockData[$language]->content;
$usingGlobalContent = true;
break;
}
}
// return raw data
if (isset($options['raw']) && $options['raw']) {
return $blockData;
}
} else {
return 'block not found';
}
// set version that data has been grabbed for (0 = latest)
if (empty($options['version'])) {
$options['version'] = $usingGlobalContent ? 0 : $this->pageVersion($pageId);
}
// pass block details and data to display class
return $block->setPageId($pageId)->setVersionId($options['version'])->getTypeObject()->display($blockData, $options);
}
public static function saveBlock($block, $blockData)
{
if (isset(self::$_fileBlocks[$block])) {
$blockData['category_id'] = !empty($blockData['category_id']) ? $blockData['category_id'] : 0;
if (!empty(self::$_allBlocks[$block])) {
$existingBlock = self::$_allBlocks[$block];
if ($existingBlock->type != $blockData['type'] || $existingBlock->label != $blockData['label'] || $existingBlock->category_id != $blockData['category_id']) {
$existingBlock->category_id = $blockData['category_id'];
$existingBlock->type = $blockData['type'];
$existingBlock->label = $blockData['label'];
$existingBlock->order = self::$_fileBlocks[$block]['order'];
$existingBlock->save();
}
} else {
$newBlock = new Block();
$newBlock->category_id = $blockData['category_id'];
$newBlock->name = $block;
$newBlock->type = $blockData['type'];
$newBlock->note = !empty($blockData['note']) ? $blockData['note'] : '';
$newBlock->label = $blockData['label'];
$newBlock->order = self::$_fileBlocks[$block]['order'];
$newBlock->save();
self::$_allBlocks[$block] = $newBlock;
}
}
if (!empty(self::$_selectBlocks[$block])) {
BlockSelectOption::import(self::$_allBlocks[$block]->id, self::$_selectBlocks[$block]);
}
}
/**
* @return \Symfony\Component\HttpFoundation\Response
*/
public function generatePage()
{
// update scheduled versions
PageVersionSchedule::checkPageVersionIds();
$pageLoader = ['class' => PageLoader::class, 'args' => []];
$pageBuilder = ['class' => PageBuilderInstance::class, 'args' => []];
// try to load cms page for current request
event(new InitializePageBuilder($pageLoader, $pageBuilder));
PageBuilder::setClass($pageBuilder['class'], $pageBuilder['args'], $pageLoader['class'], $pageLoader['args']);
try {
// check for forced redirects
$redirect = PageRedirect::uriHasRedirect();
if (!empty($redirect) && $redirect->force == 1) {
throw new CmsPageException('forced redirect', 0, null, redirect($redirect->to, $redirect->type));
}
// check for unforced redirects
if (PageBuilder::getData('is404') && !empty($redirect)) {
throw new CmsPageException('redirect', 0, null, redirect($redirect->to, $redirect->type));
}
// 404, no cms page for current request
if (PageBuilder::getData('is404')) {
throw new Exception('cms page not found', 404);
}
// 404, hidden page
if (!PageBuilder::getData('previewVersion') && !PageBuilder::getData('isLive')) {
throw new Exception('cms page not live', 404);
}
// check for form submissions
if (!empty($_POST)) {
$formData = PageBuilder::getData('externalTemplate') ? Request::input(config('coaster::frontend.external_form_input')) : Request::all();
if (!empty($formData['block_id']) && empty($formData['coaster_check'])) {
// honeypot option
if (!($block = Block::find($formData['block_id']))) {
throw new Exception('no block handler for this form data', 500);
} else {
$pageId = !empty($formData['page_id']) ? $formData['page_id'] : 0;
unset($formData['_token']);
unset($formData['block_id']);
unset($formData['page_id']);
unset($formData['coaster_check']);
if ($formSubmitResponse = $block->setPageId($pageId)->setVersionId(PageBuilder::pageLiveVersionId())->getTypeObject()->submission($formData)) {
throw new CmsPageException('form submission response', 0, null, $formSubmitResponse);
}
}
}
}
// load page with template
$templatePath = PageBuilder::templatePath();
event(new LoadPageTemplate($templatePath));
if (View::exists($templatePath)) {
$this->_setHeader('Content-Type', PageBuilder::getData('contentType'));
$this->responseContent = View::make($templatePath)->render();
} else {
throw new Exception('cms page found with non existent template - ' . $templatePath, 500);
}
// if declared as a search page, must have search block
if (Search::searchBlockRequired() && !Search::searchBlockExists()) {
throw new Exception('cms page found without search function', 404);
}
} catch (CmsPageException $e) {
$this->responseContent = $e->getAlternateResponse();
} catch (Exception $e) {
$this->_setErrorContent($e);
}
$response = $this->_createResponse();
event(new LoadedPageResponse($response));
// if response content is html, run modifications
if (!empty($response->headers->get('content-type')) && stripos($response->headers->get('content-type'), 'html') !== false) {
$domDocument = new DOMDocument();
$domDocument->loadHTML($response->getContent());
$domDocument->addMetaTag('generator', 'Coaster CMS ' . config('coaster::site.version'));
if (config('coaster::frontend.strong_tags') == 1) {
$keywords = explode(", ", str_replace(" and ", ", ", PageBuilder::block('meta_keywords')));
$domDocument->addStrongTags($keywords);
}
// save page content
if (PageBuilder::getData('externalTemplate')) {
$domDocument->appendInputFieldNames(config('coaster::frontend.external_form_input'));
$response->setContent($this->responseContent = $domDocument->saveBodyHMTL());
} else {
$response->setContent($domDocument->saveHTML($domDocument));
}
}
return $response;
}
/**
* @return Collection
*/
protected static function _preloadCollection()
{
return Block::getDataForVersion(new static(), 0);
}
public function createPost($data)
{
$pageLang = PageLang::where('name', '=', $data->title->rendered)->first();
$uporc = 'updated';
if (empty($pageLang)) {
$uporc = 'created';
$page = new Page();
$pageLang = new PageLang();
} else {
$page = Page::find($pageLang->page_id);
$comments = $this->getComments($data, $page);
$latestVersion = PageVersion::latest_version($page->id, true);
if (!empty($latestVersion)) {
$latestVersion->publish();
}
if (!empty($data->yoast)) {
$this->getMetas($data->yoast, $data, $page->id);
}
$res = new \stdClass();
$res->message = 'Post ' . $uporc . ': ' . $pageLang->name;
$res->oldLink = $data->link;
$res->newLink = Path::getFullUrl($page->id);
$res->categories = 'UPDATE RUN';
$res->tags = 'UPDATE RUN';
return $res;
}
$page->live = 2;
$page->live_start = $this->carbonDate($data->date)->format("Y-m-d H:i:s");
$page->created_at = $this->carbonDate($data->date);
$page->updated_at = $this->carbonDate($data->modified);
$page->parent = $this->groupPage->id;
$page->template = $this->group->default_template;
$page->save();
$page->groups()->sync([$this->group->id]);
$comments = $this->getComments($data, $page);
$categories = $this->getCategory($data->_embedded->{"wp:term"}, $page->id);
// Page Lang
$pageLang->live_version = 0;
$pageLang->page_id = $page->id;
$pageLang->language_id = Language::current();
$pageLang->name = $data->title->rendered;
$pageLang->url = str_slug($pageLang->name);
$pageLang->save();
$tags = $this->syncTags($page, $data->_embedded->{"wp:term"});
$date_block = Block::where('name', '=', 'post_date')->first();
if (!empty($date_block)) {
$date_block->setPageId($page->id)->getTypeObject()->save($this->carbonDate($data->date)->format("Y-m-d H:i:s"));
}
$title_block = Block::where('name', '=', config('coaster::admin.title_block'))->first();
if (!empty($title_block)) {
$title_block->setPageId($page->id)->getTypeObject()->save($pageLang->name);
}
$content_block = Block::where('name', '=', 'content')->first();
if (!empty($content_block)) {
$content_block->setPageId($page->id)->getTypeObject()->save($this->processContent($data->content->rendered));
}
$leadText_block = Block::where('name', '=', 'lead_text')->first();
if (!empty($leadText_block)) {
$leadText_block->setPageId($page->id)->getTypeObject()->save($data->excerpt->rendered);
}
$latestVersion = PageVersion::latest_version($page->id, true);
if (!empty($latestVersion)) {
$latestVersion->publish();
}
if (!empty($data->yoast)) {
$this->getMetas($data->yoast, $data, $page->id);
}
$res = new \stdClass();
$res->message = 'Post ' . $uporc . ': ' . $pageLang->name;
$res->oldLink = $data->link;
$res->newLink = Path::getFullUrl($page->id);
$res->categories = $categories;
$res->tags = $tags;
return $res;
}
public function postEdit($pageId)
{
$existingPage = Page::find($pageId);
if (!$existingPage) {
return 'Page not found';
}
$publish = false;
$publishing = (bool) config('coaster::admin.publishing');
$canPublish = Auth::action('pages.version-publish', ['page_id' => $pageId]);
if ($publishing && $existingPage->link == 0) {
// check if publish
if (Request::input('publish') != '' && $canPublish) {
$publish = true;
// check if there were requests to publish the version being edited
$overwriting_page_version = PageVersion::where('version_id', '=', Request::input('versionFrom'))->where('page_id', '=', $pageId)->first();
$requests = PagePublishRequests::where('page_version_id', '=', $overwriting_page_version->id)->where('status', '=', 'awaiting')->get();
if (!$requests->isEmpty()) {
foreach ($requests as $request) {
$request->status = 'approved';
$request->mod_id = Auth::user()->id;
$request->save();
}
}
}
} elseif (!$publishing || $existingPage->link == 1 && $canPublish) {
$publish = true;
}
$page_info = Request::input('page_info') ?: [];
$page_info_lang = Request::input('page_info_lang') ?: [];
$page_groups = Request::input('page_groups') ?: [];
$page_info_other = Request::input('page_info_other') ?: [];
// run if duplicate button was hit
if (Request::input('duplicate') == 1) {
if ($existingPage->canDuplicate()) {
if ($duplicatePage = $existingPage->saveDuplicateFromPostData($page_info, $page_info_lang, $page_groups, $page_info_other)) {
Repeater::setDuplicate();
Block::submit($duplicatePage->id, 1, $publish);
return \redirect()->route('coaster.admin.pages.edit', ['pageId' => $duplicatePage->id]);
} else {
$this->addAlert('danger', 'Duplication failed');
return $this->getEdit($pageId);
}
} else {
return abort(403, 'Action not permitted');
}
}
$version = PageVersion::add_new($pageId);
// save page info
if ($existingPage->savePostData($version, $page_info, $page_info_lang, $page_groups, $page_info_other)) {
AdminLog::new_log('Updated page \'' . $existingPage->pageLang()->name . '\' (Page ID ' . $existingPage->id . ')');
} else {
$this->addAlert('warning', '"Page Info" not updated (check tab for errors)');
}
// update blocks
Block::submit($pageId, $version->version_id, $publish);
$this->addAlert('success', 'Page Content Updated');
if ($publish) {
if (Request::input('publish_request') != '') {
PagePublishRequests::add($pageId, $version->version_id, Request::input('request_note'));
}
$version->publish();
}
// display page edit form
return $this->getEdit($pageId, $version->version_id);
}
/**
* Saves page data
* @param PageVersion $pageVersion
* @param array $pagePost
* @param array $pageLangPost
* @param array $pageGroupsPost
* @param array $pageInfoOther
* @return bool
*/
public function savePostData($pageVersion, $pagePost, $pageLangPost, $pageGroupsPost, $pageInfoOther = [])
{
/*
* Post data fixes
*/
foreach ($pagePost as $k => $pagePostField) {
if (is_array($pagePostField) && array_key_exists('exists', $pagePostField)) {
$pagePost[$k] = array_key_exists('select', $pagePostField) ? $pagePostField['select'] : 0;
}
}
if (array_key_exists('live_start', $pagePost)) {
$pagePost['live_start'] = DateTimeHelper::jQueryToMysql($pagePost['live_start']) ?: null;
}
if (array_key_exists('live_end', $pagePost)) {
$pagePost['live_end'] = DateTimeHelper::jQueryToMysql($pagePost['live_end']) ?: null;
}
foreach ($pageInfoOther as $k => $pageInfoOtherField) {
if (is_array($pageInfoOtherField) && array_key_exists('exists', $pageInfoOtherField) && array_key_exists('select', $pageInfoOtherField)) {
$pageInfoOther[$k] = $pageInfoOtherField['select'];
}
}
/*
* Overwrite default/existing data with posted data
*/
$pageDefaults = array_merge(['template' => 0, 'parent' => 0, 'child_template' => 0, 'order' => 0, 'group_container' => 0, 'group_container_url_priority' => 0, 'canonical_parent' => 0, 'link' => 0, 'live' => 0, 'sitemap' => 1, 'live_start' => null, 'live_end' => null], $this->getAttributes());
foreach ($pageDefaults as $pageAttribute => $pageDefault) {
$this->{$pageAttribute} = $pageDefault;
switch ($pageAttribute) {
case 'template':
$pageVersion->{$pageAttribute} = $pagePost[$pageAttribute];
break;
default:
$this->{$pageAttribute} = array_key_exists($pageAttribute, $pagePost) ? $pagePost[$pageAttribute] : $this->{$pageAttribute};
}
}
if (!$this->pageCurrentLang) {
$this->setRelation('pageCurrentLang', ($d = $this->pageDefaultLang) ? $d->replicate() : new PageLang());
unset($this->pageCurrentLang->language_id);
}
$pageLang = $this->pageLang();
$pageLangDefaults = array_merge(['language_id' => Language::current(), 'url' => '', 'name' => '', 'live_version' => 1], $pageLang->getAttributes());
foreach ($pageLangDefaults as $pageLangAttribute => $pageLangDefault) {
$pageLang->{$pageLangAttribute} = array_key_exists($pageLangAttribute, $pageLangPost) ? $pageLangPost[$pageLangAttribute] : $pageLangDefault;
}
/*
* Check page parent exists if set and page limit is not hit
*/
$parent = static::find($this->parent);
if ($this->parent > 0 && !$parent) {
return false;
}
if (!$this->id && !$this->link && static::at_limit($this->parent == -1)) {
return false;
}
/*
* Check page name/url set and does not conflict
*/
$pageLang->url = trim($pageLang->url);
if (!$this->link) {
$pageLang->url = strtolower(str_replace(['/', ' '], '-', $pageLang->url));
if (preg_match('#^[-]+$#', $pageLang->url)) {
$pageLang->url = '';
}
if ($pageLang->url == '' && !$this->parent) {
$pageLang->url = '/';
}
$siblings = [];
foreach ($pageGroupsPost as $pageGroupId => $checkedVal) {
$pageGroup = PageGroup::preload($pageGroupId);
$siblings = array_merge($pageGroup->exists ? $pageGroup->itemPageIds() : [], $siblings);
}
if ($this->parent >= 0) {
$siblings = array_merge(static::getChildPageIds($this->parent), $siblings);
}
$siblings = array_unique($siblings);
}
if (!$pageLang->name) {
FormMessage::add('page_info_lang[name]', 'page name required');
}
if (!$pageLang->url) {
FormMessage::add('page_info_lang[url]', 'page url required');
}
if (!empty($siblings)) {
$same_level = PageLang::where('url', '=', $pageLang->url)->whereIn('page_id', $siblings);
$same_level = $this->id ? $same_level->where('page_id', '!=', $this->id) : $same_level;
if (!$same_level->get()->isEmpty()) {
FormMessage::add('page_info_lang[url]', 'url in use by another page!');
$pageLang->url = '';
}
}
if (!$pageLang->name || !$pageLang->url) {
return false;
}
/*
* If adding a page as a group container, create container / check exists
*/
if ($this->group_container == -1) {
$groupContainer = new PageGroup();
$groupContainer->name = $pageLang->name;
$groupContainer->item_name = 'Page';
$groupContainer->default_template = 0;
$groupContainer->save();
$this->group_container = $groupContainer->id;
} elseif ($this->group_container) {
$groupContainer = PageGroup::preload($this->group_container);
if (!$groupContainer->exists || $pageDefaults['group_container'] != $this->group_container && !$groupContainer->canEditItems()) {
$this->group_container = 0;
}
}
/*
* Check if page info can be updated (based on publishing auth action, or allowed if new page)
*/
$authPageIdCheck = $this->id ?: ($this->parent > 0 ? $this->parent : 0);
$canPublish = config('coaster::admin.publishing') > 0 && Auth::action('pages.version-publish', ['page_id' => $authPageIdCheck]) || config('coaster::admin.publishing') == 0 && Auth::action('pages.edit', ['page_id' => $authPageIdCheck]);
$canPublish = $canPublish || isset($groupContainer) && (config('coaster::admin.publishing') > 0 && $groupContainer->canPublishItems() || config('coaster::admin.publishing') == 0 && $groupContainer->canEditItems());
$willPublish = !$this->id || $canPublish;
/*
* Check and save page changes
*/
if ($willPublish) {
// if new page set as last ordered page
if ($this->parent >= 0 && !$this->id) {
$lastSibling = static::where('parent', '=', $this->parent)->orderBy('order', 'desc')->first();
$this->order = $lastSibling ? $lastSibling->order + 1 : 1;
}
// if new page publish template
$this->template = $this->id ? $this->template : $pageVersion->template;
// if link remove live template
$this->template = $this->link ? 0 : $this->template;
// set page live between but no dates set set as hidden, or if can't publish set as hidden
$this->live = $this->live == 2 && is_null($this->live_end) && is_null($this->live_start) ? 0 : $this->live;
$this->live = $canPublish ? $this->live : 0;
// save page data
$this->save();
$pageLang->page_id = $this->id;
$pageLang->save();
}
$pageVersion->page_id = $this->id;
$pageVersion->save();
/*
* Update title block to the page name is new page
*/
if (!$this->id && ($titleBlock = Block::where('name', '=', config('coaster::admin.title_block'))->first())) {
$titleBlock->setVersionId($pageVersion->version_id)->setPageId($this->id)->getTypeObject()->save($pageLang->name);
PageSearchData::updateText(strip_tags($pageLang->name), 0, $this->id);
}
/*
* Save Page Groups
*/
$currentGroupIds = $this->groupIds();
$newGroupIds = array_keys($pageGroupsPost);
PageGroupPage::where('page_id', '=', $this->id)->whereIn('group_id', array_diff($currentGroupIds, $newGroupIds))->delete();
foreach (array_diff($newGroupIds, $currentGroupIds) as $addGroupId) {
$this->groups()->attach($addGroupId);
}
/*
* Save other page info
*/
if ($willPublish && Auth::action('menus')) {
MenuItem::set_page_menus($this->id, array_key_exists('menus', $pageInfoOther) ? $pageInfoOther['menus'] : []);
}
if ($canPublish && array_key_exists('beacons', $pageInfoOther) && Auth::action('themes.beacons-update')) {
BlockBeacon::updatePage($this->id, $pageInfoOther['beacons']);
}
return true;
}
