File "unitecreator_layout.class.php"
Full path: /home/kosmetik/public_html/wp-content/plugins/unlimited-elements-for-elementor/inc_php/layouts/unitecreator_layout.class.php
File
size: 54.19 B
MIME-type: text/x-php
Charset: utf-8
Download Open Edit Advanced Editor Back
<?php
defined('UNLIMITED_ELEMENTS_INC') or die('Restricted access');
class UniteCreatorLayoutWork extends UniteElementsBaseUC
{
protected $id;
protected $title, $name, $data, $gridData, $ordering, $gridDataFull, $record, $params, $arrAddonNames;
protected static $arrCacheAddons = array();
protected $addonType = null, $arrAllOptionsCache = null;
protected $extraParams = array();
protected $objShapes, $layoutType, $isTemplate = false, $objLayouts;
protected $objLayoutType;
const KEY_SETTINGS_ADDDATA = "uc_settings_adddata";
const EXPORT_CAT_TYPE_PREFIX = "uc_addontype_";
const FIELDS_LAYOUTS = "title,ordering,layout_data,catid,name,layout_type,parent_id,relate_id,params";
const LAYOUTS_GLOBAL_SETTINGS_OPTION = "unitecreator_layouts_general_settings";
public function __construct()
{
$this->objShapes = new UniteShapeManagerUC();
$this->objLayouts = new UniteCreatorLayouts();
parent::__construct();
}
public function setLayoutType($type)
{
$this->layoutType = $type;
$this->objLayoutType = UniteCreatorAddonType::getAddonTypeObject($type, true);
$this->isTemplate = $this->objLayoutType->isTemplate;
}
public function validateInited()
{
if (empty($this->id)) {
UniteFunctionsUC::throwError("The layout is not inited");
}
}
public function isInited()
{
if (!empty($this->id)) {
return true;
}
return false;
}
private function validateTitle($title)
{
UniteFunctionsUC::validateNotEmpty($title, "Title");
}
private function validateNameNotExists($name, $layoutType)
{
$isExists = $this->isLayoutExistsByName($name, $layoutType);
if ($isExists == true) {
UniteFunctionsUC::throwError("The layout with name: {$name} already exists");
}
}
private function validateName($name)
{
$fieldName = $this->objLayoutType->textSingle . esc_html__(" Name", "unlimited-elements-for-elementor");
UniteFunctionsUC::validateNotEmpty($name, $fieldName);
UniteFunctionsUC::validateUrlAlias($name, $fieldName);
$this->validateNameNotExists($name, $this->layoutType);
}
private function validateLayoutNotExistsByTitle($title, $layoutType)
{
$isExists = $this->isLayoutExistsByTitle($title, $layoutType);
if ($isExists == true) {
UniteFunctionsUC::throwError("The layout with title: {$title} already exists");
}
}
private function a_________STATIC_FUNCTIONS________()
{
}
public static function getGridGlobalStoredValues()
{
$arrValues = UniteProviderFunctionsUC::getOption(self::LAYOUTS_GLOBAL_SETTINGS_OPTION, array());
return $arrValues;
}
public static function getGlobalSettingsObject($includeGlobalOptions = true)
{
$filepathSettings = GlobalsUC::$pathSettings . "layouts_global_settings.xml";
$objSettings = new UniteCreatorSettings();
$objSettings->loadXMLFile($filepathSettings);
if ($includeGlobalOptions == true) {
$arrValues = self::getGridGlobalStoredValues();
if (!empty($arrValues)) {
$objSettings->setStoredValues($arrValues);
}
}
return $objSettings;
}
public static function getLayoutGlobalSettingsValues()
{
$objSettings = self::getGlobalSettingsObject(true);
$arrValues = $objSettings->getArrValues();
return $arrValues;
}
public static function getGridSettingsObject()
{
$filepathSettings = GlobalsUC::$pathSettings . "layouts_grid_settings.xml";
$objSettings = new UniteCreatorSettings();
$objSettings->loadXMLFile($filepathSettings);
return $objSettings;
}
public function getPageParamsSettingsObject()
{
switch ($this->objLayoutType->paramsSettingsType) {
case UniteCreatorAddonType_Layout::LAYOUT_PARAMS_TYPE_SCREENSHOT:
$filepathSettings = GlobalsUC::$pathSettings . "layout_grid_settings_screenshot.xml";
break;
default:
UniteFunctionsUC::throwError("Wrong page params type: " . $this->objLayoutType->paramsSettingsType);
break;
}
$objSettings = new UniteCreatorSettings();
$objSettings->loadXMLFile($filepathSettings);
$objSettings = UniteProviderFunctionsUC::applyFilters(UniteCreatorFilters::FILTER_LAYOUT_PROPERTIES_SETTINGS, $objSettings);
$objSettings->setStoredValues($this->params);
return $objSettings;
}
public function getPageParamsValuesWithDefaults()
{
$this->validateInited();
$paramsType = $this->objLayoutType->paramsSettingsType;
if (empty($paramsType)) {
return $this->params;
}
$objSettings = $this->getPageParamsSettingsObject();
$arrValues = $objSettings->getArrValues();
if (is_array($this->params)) {
$arrValues = array_merge($arrValues, $this->params);
}
return $arrValues;
}
public static function updateLayoutGlobalSettingsFromData($data)
{
$arrValues = UniteFunctionsUC::getVal($data, "settings_values");
UniteProviderFunctionsUC::updateOption(self::LAYOUTS_GLOBAL_SETTINGS_OPTION, $arrValues);
}
public function initByName($name, $type)
{
$objType = UniteCreatorAddonType::getAddonTypeObject($type, true);
$name = $this->db->escape($name);
$sqlAddonType = $this->db->getSqlAddonType($type, "layout_type");
$where = "name='{$name}' and {$sqlAddonType}";
try {
$record = $this->db->fetchSingle(GlobalsUC::$table_layouts, $where);
} catch (Exception $e) {
UniteFunctionsUC::throwError("Layout with name: {$name} not found");
}
UniteFunctionsUC::validateNotEmpty($record, "layout record");
$this->initByRecord($record);
}
public function initByID($id)
{
$id = (int) $id;
if (empty($id)) {
UniteFunctionsUC::throwError("Empty layout ID");
}
$options = array();
$options["tableName"] = GlobalsUC::$table_layouts;
$options["where"] = "id=" . $id;
$options["errorEmpty"] = "layout with id: {$id} not found";
$record = $this->db->fetchSingle($options);
$this->id = $id;
$this->initByRecord($record);
}
private function a____________GET_OPTIONS_____________()
{
}
public static function getGridGlobalOptions()
{
$settings = self::getGlobalSettingsObject();
$arrValues = $settings->getArrValues();
return $arrValues;
}
public static function getGridSettingsOptions($arrInitValues = array())
{
$objSettings = self::getGridSettingsObject();
if (!empty($arrInitValues)) {
$objSettings->setStoredValues($arrInitValues);
}
$arrValues = $objSettings->getArrValues();
return $arrValues;
}
public static function getGridDefaultOptions()
{
$objGlobalSettings = self::getGlobalSettingsObject(false);
$arrValuesGrid = self::getGridSettingsOptions();
$arrValuesGlobal = $objGlobalSettings->getArrValues();
$arrMerged = array_merge($arrValuesGlobal, $arrValuesGrid);
return $arrMerged;
}
public function getAllGridOptions()
{
$this->validateInited();
if (!empty($this->arrAllOptionsCache)) {
return $this->arrAllOptionsCache;
}
$globalOptions = self::getGridGlobalOptions();
$layoutOptions = UniteFunctionsUC::getVal($this->gridData, "options", array());
if (empty($layoutOptions) || is_array($layoutOptions) == false) {
$layoutOptions = array();
}
$allOptions = array_merge($globalOptions, $layoutOptions);
$this->arrAllOptionsCache = $allOptions;
return $allOptions;
}
public function getExtraParams()
{
return $this->extraParams;
}
private function a______________DATA_RELATED_______________()
{
}
protected function modifyInitLayoutData($gridData)
{
if (empty($gridData)) {
return $gridData;
}
$rows = UniteFunctionsUC::getVal($gridData, "rows");
if (empty($rows)) {
return $gridData;
}
foreach ($rows as $keyRow => $row) {
$cols = UniteFunctionsUC::getVal($row, "cols");
if (empty($cols)) {
continue;
}
$arrContainer = array();
$arrContainer["cols"] = $cols;
$row["containers"] = array($arrContainer);
unset($row["cols"]);
$gridData["rows"][$keyRow] = $row;
}
return $gridData;
}
protected function generateName($title = "", $layoutType = null, $baseName = null)
{
if (empty($title)) {
$title = $this->title;
}
UniteFunctionsUC::validateNotEmpty($title);
if (empty($layoutType)) {
$this->objLayouts->validateLayoutType($this->layoutType);
$layoutType = $this->layoutType;
}
$alias = HelperUC::convertTitleToAlias($title);
if (!empty($baseName)) {
$alias = $baseName . "-" . $alias;
}
$isExists = $this->isLayoutExistsByName($alias, $layoutType);
if ($isExists == true) {
$alias .= "-" . UniteFunctionsUC::getRandomString(5);
}
return $alias;
}
public function initByRecord($record)
{
$this->title = UniteFunctionsUC::getVal($record, "title");
$this->name = UniteFunctionsUC::getVal($record, "name");
if (empty($this->id)) {
$this->id = UniteFunctionsUC::getVal($record, "id");
}
$this->ordering = UniteFunctionsUC::getVal($record, "ordering");
$this->layoutType = UniteFunctionsUC::getVal($record, "layout_type");
if (empty($this->name)) {
$this->name = $this->generateName(null, $this->layoutType);
}
$this->objLayoutType = UniteCreatorAddonType::getAddonTypeObject($this->layoutType, true);
$this->isTemplate = $this->objLayoutType->isTemplate;
$data = UniteFunctionsUC::getVal($record, "layout_data");
$data = UniteFunctionsUC::maybeUnserialize($data);
$this->record = $record;
$this->data = $data;
$params = UniteFunctionsUC::getVal($record, "params");
if (!empty($params)) {
$this->params = UniteFunctionsUC::jsonDecode($params);
}
if (empty($this->params)) {
$this->params = array();
}
$gridData = UniteFunctionsUC::getVal($data, "grid_data");
$gridData = $this->modifyInitLayoutData($gridData);
$this->gridData = $gridData;
}
private function getAddonObject($name, $addontype = null)
{
if (empty($addontype)) {
$addontype = $this->addonType;
}
$cacheName = $name;
if (!empty($addontype)) {
$cacheName = $name . "_" . $addontype;
}
if (isset(self::$arrCacheAddons[$cacheName])) {
return self::$arrCacheAddons[$cacheName];
}
try {
$addon = new UniteCreatorAddon();
if (empty($addontype)) {
$addon->initByName($name);
} else {
$addon->initByAlias($name, $addontype);
}
self::$arrCacheAddons[$cacheName] = $addon;
return $addon;
} catch (Exception $e) {
return null;
}
}
private function getAddonExtraData($name, $addon = null, $addontype = "")
{
if (empty($addon)) {
$addon = $this->getAddonObject($name, $addontype);
}
if (empty($addon)) {
return null;
}
$arrExtraData = array();
$arrExtraData["id"] = $addon->getID();
$arrExtraData["title"] = $addon->getTitle();
$arrExtraData["url_icon"] = $addon->getUrlIcon();
$arrExtraData["admin_labels"] = $addon->getAdminLabels();
return $arrExtraData;
}
private function modifyAddonDataForEditor($addonData)
{
try {
$objAddons = new UniteCreatorAddons();
$objAddon = $objAddons->prepareAddonByData($addonData);
$arrConfig = $objAddon->getProcessedMainParamsValues(UniteCreatorParamsProcessor::PROCESS_TYPE_CONFIG);
$origConfig = UniteFunctionsUC::getVal($addonData, "config");
if (empty($origConfig)) {
$origConfig = array();
}
$addonData["config"] = array_merge($origConfig, $arrConfig);
if ($objAddon->isHasItems()) {
$arrItems = $objAddon->getProcessedItemsData(UniteCreatorParamsProcessor::PROCESS_TYPE_CONFIG, false);
$addonData["items"] = $arrItems;
}
return $addonData;
} catch (Exception $e) {
return $addonData;
}
}
protected function createGridDataFull_modifySettingsImage($settings, $key)
{
$value = UniteFunctionsUC::getVal($settings, $key);
if (empty($value)) {
return $settings;
}
if (is_numeric($value) == false) {
return $settings;
}
$urlImage = UniteProviderFunctionsUC::getImageUrlFromImageID($value);
if (empty($urlImage)) {
return $settings;
}
$settings[$key] = $urlImage;
$settings[$key . "_imageid"] = $value;
return $settings;
}
private function createGridDataFull_modifySettingsShapes($settings)
{
if (empty($settings)) {
return $settings;
}
$arr = array("top", "bottom");
foreach ($arr as $pos) {
if (array_key_exists("enable_shape_devider_{$pos}", $settings) == false) {
continue;
}
if ($settings["enable_shape_devider_{$pos}"] === true) {
continue;
}
unset($settings["enable_shape_devider_{$pos}"]);
foreach ($settings as $key => $value) {
if (strpos($key, "shape_devider_{$pos}_") === 0) {
unset($settings[$key]);
}
}
}
return $settings;
}
protected function createGridDataFull_modifySettingsBGAddons($settings, $addParams)
{
$settingsKey = "bg_addon_single";
$bgAddonName = UniteFunctionsUC::getVal($settings, $settingsKey);
if (empty($bgAddonName)) {
return $settings;
}
$addonData = UniteFunctionsUC::getVal($settings, $settingsKey . "_data");
if (empty($addonData)) {
$addonData = array();
$addonData["name"] = $bgAddonName;
$addonData["addontype"] = GlobalsUC::ADDON_TYPE_BGADDON;
}
$addonData = $this->createGridDataFull_modifyAddonData($addonData, $addParams);
$settings[$settingsKey . "_data"] = $addonData;
return $settings;
}
protected function createGridDataFull_modifySettings($settings, $name, $addParams = null)
{
$settings = $this->createGridDataFull_modifySettingsImage($settings, "bg_image_url");
$settings = $this->createGridDataFull_modifySettingsShapes($settings);
$settings = $this->createGridDataFull_modifySettingsBGAddons($settings, $addParams);
return $settings;
}
private function createGridDataFull_modifyAddonData($addonData, $addParams = null)
{
if (empty($addonData)) {
return $addonData;
}
$addonData = $this->modifyAddonDataForEditor($addonData);
$addonName = UniteFunctionsUC::getVal($addonData, "name");
$addonType = UniteFunctionsUC::getVal($addonData, "addontype");
if (empty($addonName)) {
return $addonData;
}
$addonExtraData = $this->getAddonExtraData($addonName, null, $addonType);
if (empty($addonExtraData)) {
$addonExtraData = array();
$addonExtraData["missing"] = true;
}
$addonData["extra"] = $addonExtraData;
$isAddContent = UniteFunctionsUC::getVal($addParams, "add_addon_content");
$isAddContent = UniteFunctionsUC::strToBool($isAddContent);
if ($isAddContent == true) {
$addons = new UniteCreatorAddons();
$addonData["output"] = $addons->getLayoutAddonOutputData($addonData);
}
return $addonData;
}
private function createGridDataFull($addAddonContent = false)
{
if (!empty($this->gridDataFull)) {
return $this->gridDataFull;
}
$addParams = array();
$addParams["add_addon_content"] = $addAddonContent;
$this->gridDataFull = $this->mapModifyLayoutDataAddons($this->gridData, "createGridDataFull_modifyAddonData", $addParams);
$this->gridDataFull = $this->mapModifyLayoutDataSettings($this->gridDataFull, array($this, "createGridDataFull_modifySettings"), $addParams);
return $this->gridDataFull;
}
public function modifyAddonDataForSave($data)
{
$name = UniteFunctionsUC::getVal($data, "name");
$addonType = UniteFunctionsUC::getVal($data, "addontype");
try {
unset($data["url_icon"]);
unset($data["title"]);
unset($data["extra"]);
unset($data["output"]);
$config = UniteFunctionsUC::getVal($data, "config");
$items = UniteFunctionsUC::getVal($data, "items");
$addon = new UniteCreatorAddon();
if (empty($addonType)) {
$addon->initByName($name);
} else {
$addon->initByAlias($name, $addonType);
}
$addon->setParamsValues($config);
if (!empty($items)) {
$addon->setArrItems($items);
}
if (!empty($config)) {
$arrImages = $addon->getProcessedMainParamsImages();
if (!empty($arrImages)) {
$arrImages = $addon->modifyDataConvertToUrlAssets($arrImages);
$data["config"] = array_merge($config, $arrImages);
}
}
if (!empty($items) && is_array($items)) {
$arrItemsImages = $addon->getProcessedItemsData(UniteCreatorParamsProcessor::PROCESS_TYPE_SAVE, false, "uc_image");
foreach ($arrItemsImages as $key => $itemImage) {
$itemImage = $addon->modifyDataConvertToUrlAssets($itemImage);
if (!empty($itemImage)) {
$items[$key] = array_merge($items[$key], $itemImage);
}
}
$data["items"] = $items;
}
} catch (Exception $e) {
return $data;
}
return $data;
}
private function prepareDataForSave($gridData)
{
$data = array();
if (is_string($gridData)) {
$gridData = UniteFunctionsUC::decodeContent($gridData);
$gridData = $this->modifyGridDataForSave($gridData);
$data["grid_data"] = $gridData;
} else {
$data["grid_data"] = $gridData;
}
$data = serialize($data);
return $data;
}
private function a______MAPPING_______()
{
}
private function mapModifyLayoutDataSettings_columns($parent, $modifyFunc, $addParams = null)
{
$cols = UniteFunctionsUC::getVal($parent, "cols");
if (empty($cols)) {
return $parent;
}
foreach ($cols as $colIndex => $col) {
$colSettings = UniteFunctionsUC::getVal($col, "settings");
if (!empty($colSettings)) {
$parent["cols"][$colIndex]["settings"] = call_user_func($modifyFunc, $colSettings, "col", $addParams);
}
$addonData = UniteFunctionsUC::getVal($col, "addon_data");
if (empty($addonData)) {
continue;
}
foreach ($addonData as $addonIndex => $addon) {
$addonOptions = UniteFunctionsUC::getVal($addon, "options");
if (empty($addonOptions)) {
continue;
}
$parent["cols"][$colIndex]["addon_data"][$addonIndex]["options"] = call_user_func($modifyFunc, $addonOptions, "addon", $addParams);
}
}
return $parent;
}
private function checkSettingsAddData($arrElement, $keyOptions)
{
return $arrElement;
}
public function mapModifyLayoutDataSettings($arrData, $modifyFunc, $addParams = null)
{
$gridSettings = UniteFunctionsUC::getVal($arrData, "options");
if (!empty($gridSettings)) {
$arrData["options"] = call_user_func($modifyFunc, $gridSettings, "grid", $addParams);
}
$rows = UniteFunctionsUC::getVal($arrData, "rows");
if (empty($rows)) {
return false;
}
foreach ($rows as $rowIndex => $row) {
$rowSettings = UniteFunctionsUC::getVal($row, "settings");
if (!empty($rowSettings)) {
$arrData["rows"][$rowIndex]["settings"] = call_user_func($modifyFunc, $rowSettings, "row", $addParams);
}
$arrContainers = UniteFunctionsUC::getVal($row, "containers");
if (!empty($arrContainers)) {
foreach ($arrContainers as $containerIndex => $container) {
$containerSettings = UniteFunctionsUC::getVal($container, "settings");
if (!empty($containerSettings)) {
$arrContainer = $arrData["rows"][$rowIndex]["containers"][$containerIndex];
$arrContainer["settings"] = call_user_func($modifyFunc, $containerSettings, "container", $addParams);
$arrData["rows"][$rowIndex]["containers"][$containerIndex] = $arrContainer;
}
$arrData["rows"][$rowIndex]["containers"][$containerIndex] = $this->mapModifyLayoutDataSettings_columns($container, $modifyFunc, $addParams);
}
} else {
$arrData["rows"][$rowIndex] = $this->mapModifyLayoutDataSettings_columns($row, $modifyFunc, $addParams);
}
}
return $arrData;
}
private function mapModifyLayoutDataAddons_columns($arrParent, $modifyFunc, $addParams = null)
{
$cols = UniteFunctionsUC::getVal($arrParent, "cols");
if (empty($cols)) {
return $arrParent;
}
foreach ($cols as $keyCol => $col) {
$addonData = UniteFunctionsUC::getVal($col, "addon_data");
if (isset($addonData["config"])) {
$addonData = array($addonData);
}
if (empty($addonData)) {
$addonData = array();
}
foreach ($addonData as $keyAddon => $addon) {
if (is_array($modifyFunc)) {
$addon = call_user_func($modifyFunc, $addon);
} else {
$addon = call_user_func(array($this, $modifyFunc), $addon, $addParams);
}
if (!empty($addon)) {
$addonData[$keyAddon] = $addon;
} else {
unset($addonData[$keyAddon]);
}
}
$col["addon_data"] = $addonData;
$cols[$keyCol] = $col;
}
$arrParent["cols"] = $cols;
return $arrParent;
}
public function mapModifyLayoutDataAddons($arrData, $modifyFunc, $addParams = null)
{
$rows = UniteFunctionsUC::getVal($arrData, "rows");
if (empty($rows)) {
return $arrData;
}
foreach ($rows as $keyRow => $row) {
$containers = UniteFunctionsUC::getVal($row, "containers");
if (!empty($containers)) {
foreach ($containers as $keyContainer => $container) {
$row["containers"][$keyContainer] = $this->mapModifyLayoutDataAddons_columns($container, $modifyFunc, $addParams);
}
} else {
$row = $this->mapModifyLayoutDataAddons_columns($row, $modifyFunc, $addParams);
}
$rows[$keyRow] = $row;
}
$arrData["rows"] = $rows;
return $arrData;
}
public function mapModifyLayoutDataAll($arrData, $modifyFunc)
{
if (is_array($arrData)) {
$arrData = call_user_func($modifyFunc, $arrData);
foreach ($arrData as $index => $item) {
if (is_array($item)) {
$item = call_user_func($modifyFunc, $item);
$arrData[$index] = $this->mapModifyLayoutDataAll($item, $modifyFunc);
}
}
}
return $arrData;
}
public function modifyParams($modifyFunc)
{
$this->params = call_user_func($modifyFunc, $this->params);
}
private function a_____________EXTERNAL_GETTERS____________()
{
}
public function getGridDataForEditor($addAddonContent = false)
{
$this->validateInited();
try {
if (empty($this->gridDataFull)) {
$this->createGridDataFull($addAddonContent);
}
} catch (Exception $e) {
HelperHtmlUC::outputException($e);
return $this->gridData;
}
return $this->gridDataFull;
}
public function getRowsFront()
{
$this->validateInited();
$rows = UniteFunctionsUC::getVal($this->gridData, "rows");
if (empty($rows)) {
$rows = array();
}
return $rows;
}
public function getGridOptionsDiff()
{
$defaultOptions = self::getGridDefaultOptions();
$allOptions = $this->getAllGridOptions();
$arrDiffOptions = UniteFunctionsUC::getDiffArrItems($allOptions, $defaultOptions);
return $arrDiffOptions;
}
public function getTitle($specialChars = false)
{
if ($specialChars == true) {
return htmlspecialchars($this->title);
} else {
return $this->title;
}
}
public function getName()
{
$this->validateInited();
return $this->name;
}
public function getDescription($specialChars = false)
{
$this->validateInited();
$description = UniteFunctionsUC::getVal($this->params, "description");
if ($specialChars == true) {
$description = htmlspecialchars($description);
}
return $description;
}
public function getIcon()
{
$this->validateInited();
$icon = UniteFunctionsUC::getVal($this->params, "page_icon");
return $icon;
}
public function getPreviewImage($getThumb = false)
{
$this->validateInited();
$params = $this->getPageParamsValuesWithDefaults();
$arrImageKeys = array("preview_image", "custom_preview_image", "page_image");
foreach ($arrImageKeys as $key) {
$urlPreview = UniteFunctionsUC::getVal($params, $key);
$urlPreview = trim($urlPreview);
if (empty($urlPreview)) {
continue;
}
if (is_numeric($urlPreview)) {
$urlPreview = UniteProviderFunctionsUC::getImageUrlFromImageID($urlPreview);
}
$urlPreview = HelperUC::URLtoFull($urlPreview);
return $urlPreview;
}
return $urlPreview;
}
public function getPreviewImageFilepath()
{
$urlPreview = $this->getPreviewImage();
if (empty($urlPreview)) {
return null;
}
$pathImage = HelperUC::urlToPath($urlPreview);
if (empty($pathImage)) {
return null;
}
return $pathImage;
}
public function getID()
{
$this->validateInited();
return $this->id;
}
public function getParentID()
{
dmp("getParentID - function for override");
exit;
}
public function getLayoutType()
{
return $this->layoutType;
}
public function getObjLayoutType()
{
if (!empty($this->objLayoutType)) {
return $this->objLayoutType;
}
if ($this->isInited() == true) {
UniteFunctionsUC::throwError("The layout type should be inited");
}
$this->objLayoutType = UniteCreatorAddonType::getAddonTypeObject(GlobalsUC::ADDON_TYPE_REGULAR_LAYOUT, true);
return $this->objLayoutType;
}
public function getCatNameForExport()
{
$arrCat = $this->getCategory();
$catName = UniteFunctionsUC::getVal($arrCat, "name");
if (empty($catName)) {
return false;
}
$objLayoutType = $this->getObjLayoutType();
$typeName = $objLayoutType->typeNameDistinct;
$prefix = "";
if ($typeName != GlobalsUC::ADDON_TYPE_REGULAR_LAYOUT) {
$prefix = self::EXPORT_CAT_TYPE_PREFIX . $typeName . "___";
}
if (!empty($prefix)) {
$catName = $prefix . $catName;
}
return $catName;
}
public function getCategory()
{
$this->validateInited();
$category_info = array("layoutid" => $this->getID());
$objCats = new UniteCreatorCategories();
$catID = UniteFunctionsUC::getVal($this->record, "catid");
if (empty($catID)) {
$category_info["name"] = "Uncategorized";
$category_info["id"] = 0;
} else {
$cat = $objCats->getCat($catID);
$category_info["name"] = $cat["title"];
$category_info["id"] = $cat["id"];
}
return $category_info;
}
public function getCategoryName()
{
$objCat = $this->getCategory();
$catName = $objCat["name"];
return $catName;
}
public function getRecord()
{
return $this->record;
}
public function getShortcode($shortcodeName = "")
{
$title = $this->getTitle(true);
$id = $this->id;
if (empty($shortcodeName)) {
$shortcodeName = GlobalsUC::$layoutShortcodeName;
}
$shortcode = $shortcodeName . " id={$id} title=\"{$title}\"";
$shortcode = UniteProviderFunctionsUC::wrapShortcode($shortcode);
return $shortcode;
}
public function getAddonType()
{
return $this->addonType;
}
public function getRawLayoutData()
{
$this->validateInited();
$strLayoutData = $this->record["layout_data"];
return $strLayoutData;
}
public function getShortData()
{
$this->validateInited();
$data = array();
$data["title"] = $this->getTitle();
$data["name"] = $this->getName();
$data["description"] = $this->getDescription();
$data["url_icon"] = $this->getIcon();
$data["preview"] = $this->getPreviewImage();
$data["id"] = $this->getID();
$data["is_active"] = true;
return $data;
}
protected function isLayoutExistsByTitle($title, $layoutType)
{
$title = $this->db->escape($title);
$sqlType = $this->db->getSqlAddonType($layoutType, "layout_type");
$response = $this->db->fetch(GlobalsUC::$table_layouts, "title='{$title}' and {$sqlType}");
$isExists = !empty($response);
return $isExists;
}
protected function isLayoutExistsByName($name, $layoutType)
{
$title = $this->db->escape($name);
$sqlType = $this->db->getSqlAddonType($layoutType, "layout_type");
$where = "name='{$name}' and {$sqlType}";
if (!empty($this->id)) {
$where .= " and id <> " . $this->id;
}
$response = $this->db->fetch(GlobalsUC::$table_layouts, $where);
$isExists = !empty($response);
return $isExists;
}
public function getNewLayoutTitle()
{
$titleBase = $this->objLayoutType->textSingle;
$counter = 1;
do {
$title = $titleBase . $counter;
$found = $this->isLayoutExistsByTitle($title, $this->layoutType);
$counter++;
} while ($found == true);
return $title;
}
private function collectAddonSpecialAddons_params($paramsShapes, $config, $addonType)
{
foreach ($paramsShapes as $param) {
$paramName = UniteFunctionsUC::getVal($param, "name");
$shapeName = UniteFunctionsUC::getVal($config, $paramName);
if (empty($shapeName)) {
continue;
}
$shapeAddonName = $shapeName . "_" . $addonType;
$this->arrAddonNames[$shapeAddonName] = null;
}
}
private function getParamsShapesFromAddon($objAddon, $isItems = false)
{
if ($isItems == false) {
$paramsShapes = $objAddon->getParams(UniteCreatorDialogParam::PARAM_SHAPE);
} else {
$paramsShapes = $objAddon->getParamsItems(UniteCreatorDialogParam::PARAM_SHAPE);
}
if (empty($paramsShapes)) {
$paramsShapes = array();
}
if ($isItems == false) {
$paramsAddonPickers = $objAddon->getParams(UniteCreatorDialogParam::PARAM_ADDONPICKER);
} else {
$paramsAddonPickers = $objAddon->getParamsItems(UniteCreatorDialogParam::PARAM_ADDONPICKER);
}
if (empty($paramsAddonPickers)) {
return $paramsShapes;
}
foreach ($paramsAddonPickers as $param) {
$addonType = UniteFunctionsUC::getVal($param, "addon_type");
if ($addonType == GlobalsUC::ADDON_TYPE_SHAPES) {
$paramsShapes[] = $param;
}
}
return $paramsShapes;
}
private function collectAddonSpecialAddons($addonName, $addonData)
{
$objAddon = new UniteCreatorAddon();
$objAddon->initByName($addonName);
$paramsShapes = $this->getParamsShapesFromAddon($objAddon);
if (!empty($paramsShapes)) {
$config = UniteFunctionsUC::getVal($addonData, "config");
$this->collectAddonSpecialAddons_params($paramsShapes, $config, GlobalsUC::ADDON_TYPE_SHAPES);
}
$hasItems = $objAddon->isHasItems();
if ($hasItems == false) {
return false;
}
$paramsItemsShapes = $this->getParamsShapesFromAddon($objAddon);
if (empty($paramsItemsShapes)) {
return false;
}
$arrItems = UniteFunctionsUC::getVal($addonData, "items");
if (empty($arrItems) || is_array($arrItems) == false) {
return false;
}
foreach ($arrItems as $item) {
$this->collectAddonSpecialAddons_params($paramsItemsShapes, $item, GlobalsUC::ADDON_TYPE_SHAPES);
}
}
private function modifyAddons_collectAddonNames($addonData)
{
$name = UniteFunctionsUC::getVal($addonData, "name");
$this->arrAddonNames[$name] = null;
$this->collectAddonSpecialAddons($name, $addonData);
return null;
}
public function getRowSettingsCombined($row)
{
$settings = UniteFunctionsUC::getVal($row, "settings");
$allOptions = $this->getAllGridOptions();
if (empty($allOptions)) {
return $settings;
}
if (empty($settings)) {
return $allOptions;
}
foreach ($settings as $key => $value) {
if ($value !== "") {
continue;
}
$globalValue = UniteFunctionsUC::getVal($allOptions, $key);
if ($globalValue !== "") {
$settings[$key] = $globalValue;
}
}
foreach ($allOptions as $key => $value) {
$localValue = UniteFunctionsUC::getVal($settings, $key);
if ($localValue !== "") {
$value = $localValue;
}
$settings[$key] = $value;
}
return $settings;
}
public function getInfoText()
{
$textEmpty = esc_html__("empty layout", "unlimited-elements-for-elementor");
if (empty($this->id)) {
return $textEmpty;
}
$rows = UniteFunctionsUC::getVal($this->gridData, "rows");
if (empty($rows)) {
return $textEmpty;
}
if (is_array($rows) == false) {
return $textEmpty;
}
$numRows = count($rows);
$text = esc_html__("layout with", "unlimited-elements-for-elementor") . " " . $numRows . " " . __("sections", "unlimited-elements-for-elementor");
return $text;
}
public function getRows()
{
$this->validateInited();
$rows = UniteFunctionsUC::getVal($this->gridData, "rows");
if (empty($rows)) {
$rows = array();
}
return $rows;
}
public function getParams()
{
return $this->params;
}
public function getParam($paramName)
{
$value = UniteFunctionsUC::getVal($this->params, $paramName);
return $value;
}
public function getUrlEditPost()
{
dmp("getUrlEditPost function for override");
exit;
}
public function getUrlViewPost()
{
dmp("getUrlViewPost function for override");
exit;
}
private function a_______________EXPORT_RELATED_____________()
{
}
public function modifyLayoutElementsSettings($modifyFunc)
{
$this->validateInited();
if (is_array($modifyFunc) == false) {
UniteFunctionsUC::throwError("Wrong modify func");
}
$this->gridData = $this->mapModifyLayoutDataSettings($this->gridData, $modifyFunc);
}
public function modifyGridDataAddons($modifyFunc)
{
$this->validateInited();
if (is_array($modifyFunc) == false) {
UniteFunctionsUC::throwError("Wrong modify func");
}
$this->gridData = $this->mapModifyLayoutDataAddons($this->gridData, $modifyFunc);
}
private function getBGAddonNameFromSettings($settings)
{
$enableBackground = UniteFunctionsUC::getVal($settings, "bg_enable");
$enableBackground = UniteFunctionsUC::strToBool($enableBackground);
if ($enableBackground == false) {
return null;
}
$bgAddonKey = "bg_addon_single";
$bgAddonEnableKey = $bgAddonKey . "_enable";
$enableBGAddon = UniteFunctionsUC::getVal($settings, $bgAddonEnableKey);
$enableBGAddon = UniteFunctionsUC::strToBool($enableBGAddon);
if ($enableBGAddon == false) {
return null;
}
$bgAddonName = UniteFunctionsUC::getVal($settings, $bgAddonKey);
if (empty($bgAddonName)) {
return null;
}
return $bgAddonName;
}
public function modifySettings_collectSpecialAddonNames($settings, $elementType)
{
$nameTop = $this->objShapes->getShapeDividerNameFromSettings($settings, "top");
if (!empty($nameTop)) {
$this->arrAddonNames[$nameTop . "_" . GlobalsUC::ADDON_TYPE_SHAPE_DEVIDER] = GlobalsUC::ADDON_TYPE_SHAPE_DEVIDER;
}
$nameBottom = $this->objShapes->getShapeDividerNameFromSettings($settings, "bottom");
if (!empty($nameBottom)) {
$this->arrAddonNames[$nameBottom . "_" . GlobalsUC::ADDON_TYPE_SHAPE_DEVIDER] = GlobalsUC::ADDON_TYPE_SHAPE_DEVIDER;
}
$bgAddonName = $this->getBGAddonNameFromSettings($settings);
if (!empty($bgAddonName)) {
$this->arrAddonNames[$bgAddonName] = GlobalsUC::ADDON_TYPE_BGADDON;
}
}
private function getErrorMessagePrefix()
{
$title = $this->getTitle(true);
$prefix = esc_html__("Error in ", "unlimited-elements-for-elementor") . $title . " :";
return $prefix;
}
public function getArrAddons()
{
$this->validateInited();
$this->arrAddonNames = array();
$this->mapModifyLayoutDataAddons($this->gridData, "modifyAddons_collectAddonNames");
$this->mapModifyLayoutDataSettings($this->gridData, array($this, "modifySettings_collectSpecialAddonNames"));
$arrAddons = array();
foreach ($this->arrAddonNames as $name => $type) {
try {
$objAddon = new UniteCreatorAddon();
switch ($type) {
case GlobalsUC::ADDON_TYPE_BGADDON:
$objAddon->initByAlias($name, $type);
break;
default:
$objAddon->initByMixed($name, $this->addonType);
break;
}
$arrAddons[] = $objAddon;
} catch (Exception $e) {
if ($type != GlobalsUC::ADDON_TYPE_SHAPE_DEVIDER) {
$message = $this->getErrorMessagePrefix();
$message .= $e->getMessage();
dmp($message);
UniteFunctionsUC::throwError($message);
}
}
}
return $arrAddons;
}
public function cleanLayoutDataBeforeExport($arrData)
{
if (is_array($arrData) == false) {
return $arrData;
}
$arrDataNew = array();
foreach ($arrData as $key => $item) {
if (strpos($key, "_unite_selected_text") !== false) {
continue;
}
$arrDataNew[$key] = $item;
}
return $arrDataNew;
}
public function cleanLayoutSettingsBeforeExport()
{
$cleanFunc = array($this, "cleanLayoutDataBeforeExport");
$this->gridData = $this->mapModifyLayoutDataAll($this->gridData, $cleanFunc);
$this->modifyParams($cleanFunc);
}
public function getRecordForExport()
{
$this->validateInited();
$record = array();
$record["title"] = $this->title;
$record["name"] = $this->name;
$record["type"] = $this->layoutType;
$catName = $this->getCategoryName();
if (!empty($catName)) {
$record["catname"] = $catName;
}
$gridData = $this->modifyGridDataForSave($this->gridData);
$record["params"] = $this->modifyParamsForSave($this->params);
$this->data["grid_data"] = $gridData;
$layoutData = serialize($this->data);
$record["layout_data"] = $layoutData;
return $record;
}
private function a________________MODIFY_FOR_SAVE____________()
{
}
public function modifyGridDataForSave_containers($gridData)
{
$arrRows = UniteFunctionsUC::getVal($gridData, "rows");
if (empty($arrRows)) {
return $gridData;
}
foreach ($arrRows as $index => $row) {
$arrContainers = UniteFunctionsUC::getVal($row, "containers");
if (empty($arrContainers)) {
continue;
}
if (count($arrContainers) > 1) {
continue;
}
$container = $arrContainers[0];
$settings = UniteFunctionsUC::getVal($container, "settings");
if (!empty($settings)) {
continue;
}
$cols = UniteFunctionsUC::getVal($container, "cols");
$row["cols"] = $cols;
unset($row["containers"]);
$arrRows[$index] = $row;
}
$gridData["rows"] = $arrRows;
return $gridData;
}
public function modifyLayoutDataForSave($arrSettings, $type)
{
if (isset($arrSettings["bg_image_url_url"])) {
unset($arrSettings["bg_image_url_url"]);
}
$bgAddonSingleData = UniteFunctionsUC::getVal($arrSettings, "bg_addon_single_data");
if (!empty($bgAddonSingleData)) {
$arrSettings["bg_addon_single_data"] = $this->modifyAddonDataForSave($bgAddonSingleData);
}
return $arrSettings;
}
public function modifyGridDataForSave($gridData)
{
$gridData = $this->mapModifyLayoutDataSettings($gridData, array($this, "modifyLayoutDataForSave"));
$gridData = $this->mapModifyLayoutDataAddons($gridData, "modifyAddonDataForSave");
$gridData = $this->modifyGridDataForSave_containers($gridData);
return $gridData;
}
protected function modifyParamsImagesForSave($params, $arrImageNames)
{
foreach ($arrImageNames as $name) {
$unsetName = $name . "_url";
if (isset($params[$unsetName])) {
unset($params[$unsetName]);
}
}
return $params;
}
public function modifyParamsForSave($params)
{
$arrImagesNames = array("preview_image", "custom_preview_image", "page_image");
$params = $this->modifyParamsImagesForSave($params, $arrImagesNames);
return $params;
}
private function a_____________EXTERNAL_SETTERS_____________()
{
}
public function createLayoutInDB($arrInsert, $arrParams = array())
{
$objLayouts = new UniteCreatorLayouts();
$maxOrder = $objLayouts->getMaxOrder();
$arrInsert["ordering"] = $maxOrder + 1;
if (!isset($arrInsert["catid"])) {
$arrInsert["catid"] = '0';
}
if (!isset($arrInsert["parent_id"])) {
$arrInsert["parent_id"] = '0';
}
if (!isset($arrInsert["relate_id"])) {
$arrInsert["relate_id"] = '0';
}
if (!isset($arrInsert["params"])) {
$arrInsert["params"] = '';
}
$id = $this->db->insert(GlobalsUC::$table_layouts, $arrInsert);
return $id;
}
protected function getNewLayoutName($title, $importParams)
{
$name = $this->generateName($title);
return $name;
}
public function createSmall($title, $name, $description, $catID, $importParams = array())
{
$arrInsert = array();
$this->validateTitle($title);
$this->objLayouts->validateLayoutType($this->layoutType);
$name = $this->getNewLayoutName($title, $importParams);
$name = HelperUC::convertTitleToAlias($name);
$this->validateName($name);
if (!is_numeric($catID)) {
$catID = 0;
}
if (empty($catID)) {
$catID = 0;
}
$arrInsert["title"] = $title;
$arrInsert["layout_type"] = $this->layoutType;
$arrInsert["name"] = $name;
$arrInsert["catid"] = $catID;
$arrParams = array();
$description = $this->db->escape($description);
$arrParams["description"] = $description;
$arrInsert["params"] = json_encode($arrParams);
$isNameExists = $this->isLayoutExistsByName($name, $this->layoutType);
if ($isNameExists == true) {
$objLayoutExisting = new UniteCreatorLayout();
$objLayoutExisting->initByName($name, $this->layoutType);
$objLayoutExisting->updateLayoutInDB($arrInsert);
$this->id = $objLayoutExisting->getID();
$this->initByID($this->id);
} else {
$this->id = $this->createLayoutInDB($arrInsert, $importParams);
$this->initByID($this->id);
}
return $this->id;
}
public function create($data)
{
$title = UniteFunctionsUC::getVal($data, "title");
unset($data["title"]);
unset($data["layoutid"]);
UniteFunctionsUC::validateNotEmpty($title, HelperUC::getText("layout_title"));
$layoutType = UniteFunctionsUC::getVal($data, "layout_type");
$objLayoutType = UniteCreatorAddonType::getAddonTypeObject($layoutType, true);
$this->objLayoutType = $objLayoutType;
$pageName = UniteFunctionsUC::getVal($data, "name");
if (!empty($pageName)) {
$pageName = HelperUC::convertTitleToAlias($pageName);
$isExists = $this->isLayoutExistsByName($pageName, $layoutType);
if ($isExists) {
$pageName = null;
}
}
if (empty($pageName)) {
$pageName = $this->generateName($title);
}
$arrInsert = array();
$arrInsert["title"] = $title;
$arrInsert["name"] = $pageName;
$gridData = UniteFunctionsUC::getVal($data, "grid_data");
$arrInsert["layout_data"] = $this->prepareDataForSave($gridData);
$params = UniteFunctionsUC::getVal($data, "params");
if (!empty($params)) {
$arrInsert["params"] = json_encode($params);
}
$catID = UniteFunctionsUC::getVal($data, "catid");
if (!empty($catID)) {
$objCategories = new UniteCreatorCategories();
$objCategories->validateCatExist($catID);
$arrInsert["catid"] = $catID;
}
if ($objLayoutType->allowDuplicateTitle == false) {
$this->validateLayoutNotExistsByTitle($title, $layoutType);
}
if (!empty($layoutType)) {
$arrInsert["layout_type"] = $layoutType;
}
$id = $this->createLayoutInDB($arrInsert);
$arrResponse = array();
$arrResponse["id"] = $id;
$arrResponse["name"] = $pageName;
return $arrResponse;
}
public function updateLayoutInDB($arrUpdate)
{
$this->validateInited();
unset($arrUpdate["import_title"]);
if (isset($arrUpdate["name"])) {
$this->validateName($arrUpdate["name"]);
}
$where = "id={$this->id}";
$this->db->update(GlobalsUC::$table_layouts, $arrUpdate, $where);
}
public function updateCategory($catID)
{
$this->validateInited();
$catID = (int) $catID;
$arrUpdate = array();
$arrUpdate['catid'] = $catID;
$this->updateLayoutInDB($arrUpdate);
}
public function updateTitle($title, $name = null)
{
$this->validateInited();
$this->validateTitle($title);
$arrUpdate = array();
$arrUpdate["title"] = $title;
if ($name !== null) {
$this->validateName($name);
$arrUpdate["name"] = $name;
}
$this->updateLayoutInDB($arrUpdate);
}
public function updateInternalParamsInDB()
{
$jsonParams = json_encode($this->params);
$arrUpdate = array();
$arrUpdate["params"] = $jsonParams;
$this->updateLayoutInDB($arrUpdate);
}
public function updateParam($paramName, $paramValue)
{
$this->validateInited();
$this->params[$paramName] = $paramValue;
$this->updateInternalParamsInDB();
}
public function updateParams($arrParams, $isRewrite = false)
{
$this->validateInited();
if (empty($arrParams)) {
return false;
}
if (is_array($arrParams) == false) {
return false;
}
if ($isRewrite == true) {
$this->params = $arrParams;
} else {
$this->params = array_merge($this->params, $arrParams);
}
$this->updateInternalParamsInDB();
}
public function update($data)
{
$this->validateInited();
$title = UniteFunctionsUC::getVal($data, "title");
$this->validateTitle($title);
$gridData = UniteFunctionsUC::getVal($data, "grid_data");
$arrUpdate = array();
$arrUpdate["title"] = $title;
$arrUpdate["layout_data"] = $this->prepareDataForSave($gridData);
if (isset($data["name"])) {
$pageName = $data["name"];
$arrUpdate["name"] = $pageName;
}
$this->updateLayoutInDB($arrUpdate);
$params = UniteFunctionsUC::getVal($data, "params");
if (!empty($params)) {
$this->updateParams($params);
}
}
public function updateGridData($gridData = null)
{
if ($gridData !== null) {
if (is_string($gridData)) {
$gridData = UniteFunctionsUC::decodeContent($gridData);
}
$this->gridData = $gridData;
}
$arrUpdate = array();
$arrUpdate["layout_data"] = $this->prepareDataForSave($this->gridData);
$this->updateLayoutInDB($arrUpdate);
}
public function delete()
{
$this->validateInited();
$this->db->delete(GlobalsUC::$table_layouts, "id=" . $this->id);
}
protected function getDuplicateTitle()
{
$objLayouts = new UniteCreatorLayouts();
$suffixTitle = " - copy";
$title = $this->getTitle();
$newTitle = $title . $suffixTitle;
$isExists = $objLayouts->isLayoutExistsByTitle($newTitle, $this->layoutType);
$num = 1;
$limit = 1;
while ($isExists == true && $limit < 10) {
$limit++;
$num++;
$suffixTitle = " - copy" . $num;
$newTitle = $title . $suffixTitle;
$isExists = $objLayouts->isLayoutExistsByTitle($newTitle, $this->layoutType);
}
return $newTitle;
}
public function duplicate()
{
$this->validateInited();
$newTitle = $this->getDuplicateTitle();
$newName = $this->generateName($newTitle);
$layouts = new UniteCreatorLayouts();
$layouts->shiftOrder($this->ordering, $this->layoutType);
$newOrder = $this->ordering + 1;
$sqlSelect = "select " . self::FIELDS_LAYOUTS . " from " . GlobalsUC::$table_layouts . " where id={$this->id}";
$sqlInsert = "insert into " . GlobalsUC::$table_layouts . " (" . self::FIELDS_LAYOUTS . ") ({$sqlSelect})";
$this->db->runSql($sqlInsert);
$lastID = $this->db->getLastInsertID();
UniteFunctionsUC::validateNotEmpty($lastID);
$arrUpdate = array();
$arrUpdate["title"] = $newTitle;
$arrUpdate["name"] = $newName;
$arrUpdate["ordering"] = $newOrder;
$this->db->update(GlobalsUC::$table_layouts, $arrUpdate, array("id" => $lastID));
return $lastID;
}
private function a________________CREATE_CONTENT____________()
{
}
public function getArrNewRow($arrAddonContent = array())
{
$row = array();
$containers = array();
$column = array();
$addon = array();
$column["size"] = "1_1";
$arrAddons = array();
if (!empty($arrAddonContent)) {
$arrAddons[] = $arrAddonContent;
}
$column["addon_data"] = $arrAddons;
$containers["cols"] = array($column);
$row["containers"] = array($containers);
return $row;
}
public function setRows($arrRows)
{
$this->validateInited();
if (empty($this->gridData)) {
$this->gridData = array();
}
$this->gridData["rows"] = $arrRows;
}
public function addRow($arrAddonContent = array())
{
$this->validateInited();
if (empty($this->gridData)) {
$this->gridData = array();
}
$arrRows = $this->getRows();
$arrRows[] = $this->getArrNewRow($arrAddonContent);
$this->setRows($arrRows);
}
public function addRowWithHtmlAddon($arrAddonContent)
{
$this->addRow($arrAddonContent);
}
}