JezK

Edit File: unitecreator_exporter.class.php

<?php
/**
 * @package Unlimited Elements
 * @author unlimited-elements.com
 * @copyright (C) 2021 Unlimited Elements, All Rights Reserved.
 * @license GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
 * */
if ( ! defined( 'ABSPATH' ) ) exit;

class UniteCreatorExporter extends UniteCreatorExporterBase{

const MULTIPLE_FOLDERS_FILENAME = "multiple";
	const MUST_TYPE_FORCE_REGULAR = "force_regular_addon";

private $addon;

protected $objAddons;
	protected $pathExportAddons;
	protected $filenameAddon;
	protected $filepathAddonZip;
	protected $pathExportAddon;
	protected $pathExportAddonAssets;

//export categories

protected $pathExportCategories;
	protected $pathExportCategory;
	protected $pathExportCategoryAddons;

protected $filepathCategoryZip;
	protected $filenameCategoryZip;

//import
	private $isPathSingle = false;

private $pathImportAddon;
	private $pathImportAddonAssets;
	private $isImportedOnce = false;
	private $textLogShort = "";
	private $importedAddonType = "";
	private $mustAddonType = null;
	private $downloadFilenameEnding = null;
	private $catExportData = null;
	private $lastImportedAddonID;
	private $lastImportedCatID;
	private static $arrImportedAddons = array();

/**
	 * constructor
	 */
	public function __construct(){

parent::__construct();

$this->objAddons = new UniteCreatorAddons();
	}

/**
	 * validate that the addon exists
	 */
	private function validateInited(){

if(empty($this->addon))
			UniteFunctionsUC::throwError("export error: addon not inited");
	}

/**
	 * print all globals variables
	 */
	private function printVars(){

$vars = get_object_vars($this);

dmp($vars);
	}

/**
	 * init by addon
	 *
	 * @param $addon
	 */
	public function initByAddon(UniteCreatorAddon $addon){

$this->addon = $addon;
	}

private function a_________EXPORT_ADDON_______(){
	}

/**
	 * create export folder if not exists
	 */
	private function prepareExportFolders_addons(){

$this->prepareExportFolders_globalExport();

$this->pathExportAddons = $this->pathExport . "addons/";
		UniteFunctionsUC::mkdirValidate($this->pathExportAddons, "Export Addons");

//clear folder
		UniteFunctionsUC::deleteDir($this->pathExportAddons, false);

$this->pathExportAddon = $this->pathExportAddons . "addon_" . UniteFunctionsUC::getRandomString(10) . "/";
		$this->pathExportAddonAssets = $this->pathExportAddon . "assets/";

//create index.html
		UniteFunctionsUC::writeFile("", $this->pathExportAddons . "index.html");

UniteFunctionsUC::mkdirValidate($this->pathExportAddon, "Export Addon");

$addonName = $this->addon->getName();

$tempFilenameZip = $addonName . "_" . UniteFunctionsUC::getRandomString(10) . ".zip";

$this->filepathAddonZip = $this->pathExportAddons . $tempFilenameZip;
	}

/**
	 * modify includes in config that it will be saved in new way
	 */
	private function modifyConfig($config){

$includes = UniteFunctionsUC::getVal($config, "includes");

$arrJs = UniteFunctionsUC::getVal($includes, "js");
		$arrCss = UniteFunctionsUC::getVal($includes, "css");

$arrJs = HelperUC::arrUrlsToRelative($arrJs, true);
		$arrCss = HelperUC::arrUrlsToRelative($arrCss, true);

if(!empty($arrJs))
			$includes["js"] = $arrJs;

if(!empty($arrCss))
			$includes["css"] = $arrCss;

$config["includes"] = $includes;

//no export dynamic post ID
		unset($config["options"]["dynamic_post"]);

//modify params, exclude dynamic post
		$params = UniteFunctionsUC::getVal($config, "params");
		if(empty($params))
			$params = array();

foreach($params as $key => $param){
			$type = UniteFunctionsUC::getVal($param, "type");

switch($type){
				case UniteCreatorDialogParam::PARAM_POSTS_LIST:

//remove dynamic post example

unset($config["params"][$key]["post_example"]);
					unset($config["params"][$key]["post_example_text"]);

break;
			}
		}

return ($config);
	}

/**
	 * get xml from addon
	 */
	private function getJsonFromAddon(){

$arrAddon = array();

$addonType = $this->addon->getType();

$addonName = $this->addon->getName();
		$addonAlias = $this->addon->getAlias();

$catTitle = $this->addon->getCatTitle();
		//set alias and name by type
		if(!empty($addonType) && empty($addonAlias)){
			$addonAlias = $addonName;
			$addonName = $addonName . "_" . $addonType;
		}

if($this->mustAddonType == self::MUST_TYPE_FORCE_REGULAR){
			$addonType = "";
			if(!empty($addonAlias)){
				$addonName = $addonAlias;
				$addonAlias = "";
			}
		}

$arrAddon["addontype"] = $addonType;
		$arrAddon["cattitle"] = $catTitle;
		$arrAddon["name"] = $addonName;
		$arrAddon["alias"] = $addonAlias;

$arrAddon["title"] = $this->addon->getTitle();
		$arrAddon["description"] = $this->addon->getDescription();

$arrConfig = $this->addon->getConfig();
		$arrAddon["config"] = $this->modifyConfig($arrConfig);

$arrTemplates = $this->addon->getTemplates();

$arrTemplateNames = array();
		foreach($arrTemplates as $name => $content){
			if(!empty($content))
				$arrTemplateNames[] = $name;
		}

$arrAddon["templates"] = $arrTemplateNames;

$arrAddon = UniteProviderFunctionsUC::applyFilters(UniteCreatorFilters::FILTER_EXPORT_ADDON_DATA, $arrAddon);

$json = json_encode($arrAddon, JSON_PRETTY_PRINT);

return ($json);
	}

/**
	 * get json category from addon, or from set cat data
	 */
	protected function getJsonCategoryFromAddon(){

//get from global saved data (fro category addons)
		if(!empty($this->catExportData)){
			$jsonData = json_encode($this->catExportData);

return ($jsonData);
		}

//get from addon data
		$catID = $this->addon->getCatID();
		$addonType = $this->addon->getType();

$arrData = $this->getExportCatData($catID, $addonType);
		if(empty($arrData))
			return (null);

$jsonData = json_encode($arrData);

return ($jsonData);
	}

/**
	 * write file if not empty content
	 */
	private function writeFile($filename, $content){

$filepath = $this->pathExportAddon . $filename;
		if(!empty($content))
			UniteFunctionsUC::writeFile($content, $filepath);
	}

/**
	 * write export data
	 */
	private function createExportFiles(){

//write addon main file
		$strJson = $this->getJsonFromAddon();
		$this->writeFile("addon.json", $strJson);

//write category json file
		$strJsonCat = $this->getJsonCategoryFromAddon();
		if(!empty($strJsonCat))
			$this->writeFile("category.json", $strJsonCat);

//write template files
		$arrTemplates = $this->addon->getTemplates();

//write templates
		foreach($arrTemplates as $name => $content){
			$filename = $name . ".tpl";
			$this->writeFile($filename, $content);
		}

//write default data
		$defaultData = $this->addon->getDefaultData();
		$defaultData = $this->addon->modifyAddonDataConvertToUrlAssets($defaultData);

if(!empty($defaultData)){
			$defaultData = json_encode($defaultData, JSON_PRETTY_PRINT);
			$this->writeFile("default_data.json", $defaultData);
		}
	}

/**
	 * check if assets path is ready for export
	 */
	private function isPathAssetsReadyForExport($pathAssets){

$objAddonType = $this->addon->getObjAddonType();

$isUnderAssets = HelperUC::isPathUnderAssetsPath($pathAssets, $objAddonType);

if(!$isUnderAssets)
			return (false);

if(is_dir($pathAssets) == false)
			return (false);

$isPathAssets = HelperUC::isPathAssets($pathAssets, $objAddonType);
		if($isPathAssets == true)
			return (false);

return (true);
	}

/**
	 * copy addon assets
	 */
	private function copyAssets($imagesMode = 'all'){

$options = $this->addon->getOptions();
		$dirAssets = $this->addon->getOption("path_assets");

if(empty($dirAssets))
			return (false);

$pathAssets = $this->addon->getPathAssetsFull();

$isReady = $this->isPathAssetsReadyForExport($pathAssets);

if($isReady == false)
			return (false);

//make assets folder
		UniteFunctionsUC::mkdirValidate($this->pathExportAddonAssets, "assets folder");

$pathAssetsDest = $this->pathExportAddonAssets . $dirAssets . "/";

UniteFunctionsUC::mkdirValidate($pathAssetsDest, "assets dest folder: $dirAssets");

UniteFunctionsUC::copyDir($pathAssets, $pathAssetsDest);

//delete thumbs folders

$arrDirs = UniteFunctionsUC::getDirList($pathAssets);

foreach($arrDirs as $dir){
			switch($dir){
				case GlobalsUC::DIR_THUMBS_ELFINDER:
				case ".quarantine":
				case GlobalsUC::DIR_THUMBS:

$pathDirDelete = $pathAssetsDest . $dir . "/";

UniteFunctionsUC::deleteDir($pathDirDelete);
					
				break;
			}
		}
		switch($imagesMode) {
		case 'images-only':
			$fileList = UniteFunctionsUC::getFileList($pathAssets);
			foreach($fileList as $file) {
				$ext = strtolower(pathinfo($file, PATHINFO_EXTENSION) ?? '');
				switch($ext) {
				case 'jpeg':
				case 'jpg':
				case 'svg':
				case 'gif':
				case 'png':
					break;
				default:
					unlink($pathAssetsDest . $file);
				}
			}	
		break;
		case 'no-images':
			$fileList = UniteFunctionsUC::getFileList($pathAssets);
			foreach($fileList as $file) {
				$ext = strtolower(pathinfo($file, PATHINFO_EXTENSION) ?? '');
				switch($ext) {
					case 'jpeg':
					case 'jpg':
					case 'svg':
					case 'gif':
					case 'png':
						unlink($pathAssetsDest . $file);
					break;
				}
			}		
		break;
		}

}

/**
	 * make export zip file
	 */
	private function makeExportZipFile(){
		
		$zip = new UniteZipUC();
		$zip->makeZip($this->pathExportAddon, $this->filepathAddonZip);

if(file_exists($this->filepathAddonZip) == false)
			UniteFunctionsUC::throwError("zip file {$this->filepathAddonZip} could not be created");
	}

/**
	 * delete export addon folder
	 */
	private function deleteExportAddonFolder(){

if(!empty($this->pathExportAddon) && is_dir($this->pathExportAddon))
			UniteFunctionsUC::deleteDir($this->pathExportAddon);
	}

/**
	 * create category folder
	 */
	private function moveExportZipToFolder_createCategoryFolder($moveFolder){

$addonType = $this->addon->getType();
		$catTitle = $this->addon->getCatTitle();

$isSpecialType = HelperUC::isSpecialAddonType($addonType);
		if($isSpecialType == true)
			$catTitle = $addonType . "_" . $catTitle;

if(empty($catTitle))
			return ($moveFolder);

$moveFolder = $moveFolder . $catTitle . "/";

if(is_dir($moveFolder))
			return ($moveFolder);

//create the folder
		UniteFunctionsUC::mkdirValidate($moveFolder, $catTitle);

//write category file
		$addonType = $this->addon->getType();
		$catID = $this->addon->getCatID();
		$exportCatData = $this->getExportCatData($catID, $addonType);
		$this->createCategoryDataFile($exportCatData, $moveFolder);

return ($moveFolder);
	}

/**
	 * write to folder
	 */
	private function moveExportZipToFolder($moveFolder, $createCategoryFolder = false){

UniteFunctionsUC::validateDir($moveFolder);

/**
		 * create category folder if needed
		 */
		if($createCategoryFolder === true)
			$moveFolder = $this->moveExportZipToFolder_createCategoryFolder($moveFolder);

$addonAlias = $this->addon->getAlias();
		$addonName = $this->addon->getName();

if(isset($this->filenameAddon))
			$filename = $this->filenameAddon . ".zip";
		elseif($this->mustAddonType == self::MUST_TYPE_FORCE_REGULAR)
			$filename = $addonAlias . ".zip";
		else
			$filename = $addonName . ".zip";

$newFilepath = $moveFolder . $filename;

$success = UniteFunctionsUC::move($this->filepathAddonZip, $newFilepath);

if($success === false)
			UniteFunctionsUC::throwError("Can't move export zip:$filename to the export folder");
	}

/**
	 * download the zip file
	 */
	private function downloadFile(){

$addonName = $this->addon->getName();
		$filename = $addonName;

if(!empty($this->downloadFilenameEnding))
			$filename .= $this->downloadFilenameEnding;

$filename .= ".zip";

UniteFunctionsUC::downloadFile($this->filepathAddonZip, $filename);
	}

/**
	 * set addon filename
	 */
	public function setFilename($filename){

$this->filenameAddon = $filename;
	}

/**
	 * set download filename ending
	 */
	public function setDownloadFilenameEnding($ending){

$this->downloadFilenameEnding = $ending;
	}

/**
	 * export addon - create export file and send it to download.
	 */
	public function export($moveFolder = null, $createCategoryFolders = false, $catExportData = null){

$this->validateInited();

try{
			$this->catExportData = $catExportData;

$this->prepareExportFolders_addons();

$this->createExportFiles();

$this->copyAssets();

$this->makeExportZipFile();
			
			$this->deleteExportAddonFolder();
		
			if(!empty($moveFolder)){
				$this->moveExportZipToFolder($moveFolder, $createCategoryFolders);
				$this->deleteExportAddonFolder();
			}else{
				$this->downloadFile();
				exit();
			}
		}catch(Exception $e){
			$this->deleteExportAddonFolder();
			throw $e;
		}
	}
	
	/**
	 * export addon - create export file with no images and send save it in $moveFolder
	 */
	public function exportNoImages($moveFolder){

$this->validateInited();

try{

$this->catExportData = $catExportData;

$this->prepareExportFolders_addons();

$this->createExportFiles();

$imagesMode = 'no-images';
			$this->copyAssets($imagesMode);

$this->makeExportZipFile();
			$this->deleteExportAddonFolder();

if(!empty($moveFolder)){

$this->moveExportZipToFolder($moveFolder, $createCategoryFolders);

$this->deleteExportAddonFolder();
			}else{
				$this->downloadFile();
				exit();
			}
		}catch(Exception $e){
			$this->deleteExportAddonFolder();
			throw $e;
		}
	}
	
	/**
	 * export addon - create export file (images only) and send it to download.
	 */
	public function exportImagesOnly($moveFolder){

$this->validateInited();

try{

$this->catExportData = $catExportData;

$this->prepareExportFolders_addons();

// $this->createExportFiles();

$imagesMode = 'images-only';
			$this->copyAssets($imagesMode);

$this->makeExportZipFile();
			$this->deleteExportAddonFolder();

if(!empty($moveFolder)){

$this->moveExportZipToFolder($moveFolder, $createCategoryFolders);

$this->deleteExportAddonFolder();
			}else{
				$this->downloadFile();
				exit();
			}
		}catch(Exception $e){
			$this->deleteExportAddonFolder();
			throw $e;
		}

}

private function a_______EXPORT_CATEGORY______(){
	}

/**
	 * prepare export categories folders
	 */
	private function prepareExportFolders_categories($catTitle, $exportType = ""){

$this->prepareExportFolders_globalExport();

//delete cats folder only on first time create
		$clearCatsFolder = true;
		if(!empty($this->pathExportCategories))
			$clearCatsFolder = false;

//make folders
		$this->pathExportCategories = $this->pathExport . "categories/";
		UniteFunctionsUC::mkdirValidate($this->pathExportCategories, "Categories");

//clear folder
		if($clearCatsFolder == true)
			UniteFunctionsUC::deleteDir($this->pathExportCategories, false);

$this->pathExportCategory = $this->pathExportCategories . "category_" . UniteFunctionsUC::getRandomString(10) . "/";

UniteFunctionsUC::mkdirValidate($this->pathExportCategory, "Export Category");

//create index.html
		UniteFunctionsUC::writeFile("", $this->pathExportCategories . "index.html");

//create actual category folder
		if(!empty($catTitle))
			$this->prepareExportFolders_category($catTitle, $exportType);
	}

/**
	 * prepare category export folder and names
	 */
	private function prepareExportFolders_category($catTitle, $exportType = ""){

UniteFunctionsUC::validateNotEmpty($catTitle);

UniteFunctionsUC::validateNotEmpty($this->pathExportCategory);

$this->pathExportCategoryAddons = $this->pathExportCategory . $catTitle . "/";
		UniteFunctionsUC::mkdirValidate($this->pathExportCategoryAddons, "$catTitle category");

$this->prepareExportFolders_exportFilename($catTitle, $exportType);
	}

/**
	 * prepare export folders file path and filename
	 */
	private function prepareExportFolders_exportFilename($catTitle, $exportType = "", $addSuffix = true){

$suffix = "";

if($addSuffix == true){
			if(!empty($exportType))
				$suffix .= "_" . $exportType;
			$suffix .= "_widgets";
		}

$nameZip = $catTitle . $suffix;
		$nameZip = HelperUC::convertTitleToHandle($nameZip);

$this->filenameCategoryZip = $nameZip . ".zip";

$tempFilenameZip = $nameZip . "_" . UniteFunctionsUC::getRandomString(10) . ".zip";

$this->filepathCategoryZip = $this->pathExportCategories . $tempFilenameZip;
	}

/**
	 * create category addons zips
	 * put them in the category export folder
	 */
	private function createCategoryAddonsZips($arrAddons, $catExportData = null){

foreach($arrAddons as $addon){
			$objExport = new UniteCreatorExporter();
			$objExport->initByAddon($addon);

$objExport->setMustImportAddonType($this->mustAddonType);

$objExport->export($this->pathExportCategoryAddons, false, $catExportData);
		}
	}

/**
	 * make export zip file
	 */
	private function makeExportCategoryZipFile(){

$zip = new UniteZipUC();
		$zip->makeZip($this->pathExportCategory, $this->filepathCategoryZip);

if(file_exists($this->filepathCategoryZip) == false)
			UniteFunctionsUC::throwError("zip file {$this->filepathCategoryZip} could not be created");
	}

/**
	 * download the category zip file
	 */
	private function downloadCategoryFile(){

UniteFunctionsUC::downloadFile($this->filepathCategoryZip, $this->filenameCategoryZip);
	}

/**
	 * get addons array and cat title from catID
	 */
	private function exportCatAddons_getArrAddons($catID, $exportType){

$objCat = new UniteCreatorCategories();
		$arrCat = $objCat->getCat($catID);

if(empty($exportType))
			$exportType = UniteFunctionsUC::getVal($arrCat, "type");

$catTitle = UniteFunctionsUC::getVal($arrCat, "title");
		$catType = UniteFunctionsUC::getVal($arrCat, "type");

UniteFunctionsUC::validateNotEmpty($catTitle);

$objAddons = new UniteCreatorAddons();

$arrAddons = $objAddons->getCatAddons($catID, false, null, $exportType);

if(empty($arrAddons))
			UniteFunctionsUC::throwError("No addons found in category: $catTitle (id - $catID)");

//set addon types
		foreach($arrAddons as $addon){
			$addon->setType($exportType);
		}

$output = array();
		$output["title"] = $catTitle;
		$output["type"] = $catType;
		$output["addons"] = $arrAddons;

return ($output);
	}

/**
	 * export category data
	 */
	private function createCategoryDataFile($catExportData, $pathExport = null){

$jsonData = json_encode($catExportData);

if(empty($pathExport))
			$pathExport = $this->pathExportCategoryAddons;

UniteFunctionsUC::validateDir($pathExport, "export category data");

$filepathCategory = $pathExport . "category.json";
		UniteFunctionsUC::writeFile($jsonData, $filepathCategory);
	}

/**
	 * get category export data
	 */
	protected function getExportCatData($catID, $exportType){

if(empty($catID))
			return (null);

if(empty($exportType))
			$exportType = null;

$objCat = new UniteCreatorCategory();
		$objCat->initByID($catID);
		$catExportData = $objCat->getExportCatData($exportType);

return ($catExportData);
	}

/**
	 * export category addons
	 */
	public function exportCatAddons($catID, $exportType = null, $runFunc = null){

$output = $this->exportCatAddons_getArrAddons($catID, $exportType);
		$arrAddons = $output["addons"];

//get category data
		$catExportData = $this->getExportCatData($catID, $exportType);

$catTitle = $catExportData["title"];

try{
			$this->prepareExportFolders_categories($catTitle, $exportType);
			$this->createCategoryDataFile($catExportData);
			$this->createCategoryAddonsZips($arrAddons, $catExportData);

if($runFunc === null){
				$this->makeExportCategoryZipFile();
				$this->downloadCategoryFile();
				exit();
			}else{
				call_user_func(array($this, $runFunc));
			}
		}catch(Exception $e){
			throw $e;
		}
	}

private function a_______EXPORT_CATS______(){
	}

/**
	 * export multiple categories and their addons
	 */
	public function exportCatsAndAddons($arrCats, $exportType = "", $runFunc = null, $filename = ""){

UniteFunctionsUC::validateNotEmpty($arrCats);

if(is_numeric($arrCats))
			$arrCats = array($arrCats);

if(is_array($arrCats) == false)
			UniteFunctionsUC::throwError("export cats error: The categories should be array");

try{
			//create general export folder
			$this->prepareExportFolders_categories("");

foreach($arrCats as $catID){
				$output = $this->exportCatAddons_getArrAddons($catID, $exportType);

$arrAddons = $output["addons"];
				$catTitle = $output["title"];
				$catAddonType = $output["type"];

$catTitle = UniteProviderFunctionsUC::applyFilters(UniteCreatorFilters::FILTER_EXPORT_CAT_TITLE, $catTitle, $exportType, $catAddonType);

$this->prepareExportFolders_category($catTitle, $exportType);
				$this->createCategoryAddonsZips($arrAddons);

UniteProviderFunctionsUC::doAction("uc_export_category_addons", $catTitle);
			}

//create zip file
			if(empty($filename)){
				if(count($arrCats) == 1)
					$filename = $catTitle;
				else
					$filename = self::MULTIPLE_FOLDERS_FILENAME;
			}

UniteFunctionsUC::validateNotEmpty($filename, "export filename");

if($runFunc === null){
				$this->prepareExportFolders_exportFilename($filename, $exportType);

$this->makeExportCategoryZipFile();
				$this->downloadCategoryFile();
				exit();
			}else{
				call_user_func(array($this, $runFunc));
			}
		}catch(Exception $e){
			throw $e;
		}
	}

private function a_______IMPORT_ADDON_______(){
	}

/**
	 * validate that the temp file array
	 */
	private function validateArrTempFile($arrTempFile){

$filename = UniteFunctionsUC::getVal($arrTempFile, "name");
		UniteFunctionsUC::validateNotEmpty($filename, "addon file name");

$info = pathinfo($filename);
		$ext = UniteFunctionsUC::getVal($info, "extension");
		$ext = strtolower($ext);

if($ext != "zip")
			UniteFunctionsUC::throwError("Wrong import addon file type: {$filename}, should be zip type only.");
	}

/**
	 * prepare import addon folders
	 */
	private function prepareImportFolders(){

//prepare import folder
		$this->prepareImportFolders_globalImport();

if($this->isPathSingle == false){    //first path

$pathImportBase = $this->pathImport . "first/";
		}else{
			$pathImportBase = $this->pathImport . "single/";
		}

UniteFunctionsUC::mkdirValidate($pathImportBase, "import first");
		UniteFunctionsUC::deleteDir($pathImportBase, false);

//create index.html
		UniteFunctionsUC::writeFile("", $pathImportBase . "index.html");

self::$serial++;

$this->pathImportAddon = $pathImportBase . "addon_" . self::$serial . "_" . UniteFunctionsUC::getRandomString(10) . "/";
		$this->pathImportAddonAssets = $this->pathImportAddon . "assets/";

UniteFunctionsUC::mkdirValidate($this->pathImportAddon, "import addon");
	}

/**
	 * delete import addon folder
	 */
	private function deleteImportAddonFolder(){

if(!empty($this->pathImportAddon) && is_dir($this->pathImportAddon))
			UniteFunctionsUC::deleteDir($this->pathImportAddon);
	}

/**
	 * unpack import addon from temp file
	 */
	private function extractImportAddonFile($arrTempFile){

$filepath = UniteFunctionsUC::getVal($arrTempFile, "tmp_name");

$zip = new UniteZipUC();
		$extracted = $zip->extract($filepath, $this->pathImportAddon);

if($extracted == false)
			UniteFunctionsUC::throwError("The import addon zip didn't extracted");
	}

/**
	 * import templates
	 */
	private function importAddonData_addTemplates($arrImport, $addonData){

//prepare templates data
		$templateNames = UniteFunctionsUC::getVal($arrImport, "templates");

$arrTemplates = array();
		foreach($templateNames as $templateName){
			$filenameTemplate = $templateName . ".tpl";
			$filepathTemplate = $this->pathImportAddon . $filenameTemplate;
			if(is_file($filepathTemplate) == false)
				UniteFunctionsUC::throwError("Template {$filenameTemplate} not found!");

$templateContent = UniteFunctionsUC::fileGetContents($filepathTemplate);
			$arrTemplates[$templateName] = $templateContent;
		}

$addonData["templates"] = json_encode($arrTemplates);

return ($addonData);
	}

/**
	 * add test data
	 */
	private function importAddonData_addDefaultData($addonData){

$filenameTestData = "default_data.json";
		$filepathTestData = $this->pathImportAddon . $filenameTestData;

if(file_exists($filepathTestData) == false)
			return ($addonData);

$arrContent = UniteFunctionsUC::fileGetContents($filepathTestData);
		if(empty($arrContent))
			return ($addonData);

//check if the string is json (decode and encode again)
		$arrContent = UniteFunctionsUC::jsonDecode($arrContent);

if(is_array($arrContent) == false)
			return ($addonData);

//add the default data (test_slot2)

$jsonContent = json_encode($arrContent);

$addonData["test_slot2"] = $jsonContent;

return ($addonData);
	}

/**
	 * import addon data
	 */
	private function importAddonData($catID, $overwrite = true, $forceToCat = true){

$filenameAddon = "addon.json";
		$filepathData = $this->pathImportAddon . $filenameAddon;

if(is_file($filepathData) == false)
			UniteFunctionsUC::throwError("Addon import file: $filenameAddon don't found");

$contents = UniteFunctionsUC::fileGetContents($filepathData);

if(empty($contents))
			UniteFunctionsUC::throwError("Empty import file {$filenameAddon} contents");

$arrImport = @json_decode($contents, true);

if(empty($arrImport))
			UniteFunctionsUC::throwError("Wrong import file {$filenameAddon} content");

if(is_array($arrImport) == false)
			UniteFunctionsUC::throwError("Wrong addon import data, should be array");

$addonName = UniteFunctionsUC::getVal($arrImport, "name");
		$addonType = UniteFunctionsUC::getVal($arrImport, "addontype");
		$addonAlias = UniteFunctionsUC::getVal($arrImport, "alias");
		$catTitle = UniteFunctionsUC::getVal($arrImport, "cattitle");
		$addonTitle = UniteFunctionsUC::getVal($arrImport, "title");

$isSpecialAddonType = HelperUC::isSpecialAddonType($addonType);

//---- add log text ------

$logTitle = $addonTitle;
		if(empty($logTitle))
			$logTitle = $addonName;

$objAddonType = UniteCreatorAddonType::getAddonTypeObject($addonType);
		$txtSingle = $objAddonType->textSingle;
		if(empty($txtSingle))
			$txtSingle = "addon";

$txtSingle = strtolower($txtSingle);

$textLog = "$txtSingle $logTitle";

//if empty addon type - set by the given type
		if(empty($addonType) && !empty($this->mustAddonType)){
			$addonType = $this->mustAddonType;

if(empty($addonAlias))
				$addonAlias = $addonName;

$addonName = $addonName . "_" . $addonType;
		}

//check if the addon exists, if needed
		if($overwrite == false){
			$isExists = $this->objAddons->isAddonExistsByName($addonName);

if($isExists == true){
				$textLog .= " skipped";
				$this->addLog($textLog);

return (false);
			}
		}

$arrImport = apply_filters("uc_modify_addon_data_before_import", $arrImport);

//check if addon type match
		if(!empty($this->mustAddonType) && $this->mustAddonType != $addonType){
			$textLog .= " wrong addon type, skipped";
			$this->addLog($textLog);

return (false);
		}

//import other addon types to blox, like from vc
		if(empty($this->mustAddonType) && !empty($addonType) && $isSpecialAddonType == false){
			$addonType = "";
			$addonName = $addonAlias;
			$addonAlias = "";
		}

$objCategories = new UniteCreatorCategories();
		if($forceToCat == false){  //first addon category, then given category

if(!empty($catTitle)){
				$catID = $objCategories->getCreateCatByTitle($catTitle, $addonType);
			}
		}else{  //force to category - first given cat, then addon cat
			if(empty($catID))
				$catID = $objCategories->getCreateCatByTitle($catTitle, $addonType);
		}

if(empty($catID))
			$catID = 0;

//prepare data
		$addonData = array();
		$addonData["name"] = $addonName;
		$addonData["alias"] = $addonAlias;
		$addonData["addontype"] = $addonType;
		$addonData["title"] = UniteFunctionsUC::getVal($arrImport, "title");
		$addonData["description"] = UniteFunctionsUC::getVal($arrImport, "description");
		$addonData["catid"] = $catID;

$config = UniteFunctionsUC::getVal($arrImport, "config");
		if(is_array($config) == false)
			UniteFunctionsUC::throwError("Wrong addon config data");

$addonData["config"] = json_encode($config);
		$addonData["is_active"] = true;

//---- import templates ----

$addonData = $this->importAddonData_addTemplates($arrImport, $addonData);

// ------ import test data ----------

$addonData = $this->importAddonData_addDefaultData($addonData);

$objAddon = new UniteCreatorAddon();
		$isNewAdded = $objAddon->importAddonData($addonData);

$this->lastImportedAddonID = $objAddon->getID();
		$this->lastImportedCatID = $catID;

if($isNewAdded){
			$textLog .= " added";

//make the last imported addons list
			self::$arrImportedAddons[$addonName] = true;
		}else
			$textLog .= " overwritten";

$this->addLog($textLog);

//save added type
		$this->importedAddonType = $addonType;

return (true);
	}

/**
	 * copy import assets folder
	 */
	private function copyImportAssetsFolder(){

if(is_dir($this->pathImportAddonAssets) == false)
			return (false);

$pathAssets = GlobalsUC::$pathAssets;

if(!empty($this->importedAddonType)){
			$objAddonType = UniteCreatorAddonType::getAddonTypeObject($this->importedAddonType);
			$pathAssets = HelperUC::getAssetsPath($objAddonType);
		}

UniteFunctionsUC::copyDir($this->pathImportAddonAssets, $pathAssets);
	}

/**
	 * check if extracted addon single
	 */
	private function isExtractedAddonSingle(){

if($this->isPathSingle == true)
			return (true);

$filenameAddon = "addon.json";
		$filepathData = $this->pathImportAddon . $filenameAddon;

if(file_exists($filepathData))
			return (true);

return (false);
	}

/**
	 * set import single type
	 */
	public function setImportSingleAddon(){

$this->isPathSingle = true;
	}

/**
	 * set must import addon type, the addons will be imported to this type
	 */
	public function setMustImportAddonType($addonType){

if($addonType == GlobalsUC::ADDON_TYPE_REGULAR_ADDON)
			$this->mustAddonType = "";
		else
			$this->mustAddonType = $addonType;
	}

/**
	 * import addon
	 * tempFile can be array or filepath
	 */
	public function import($catID, $arrTempFile, $overwrite = true, $forceToCat = true){

if($this->isImportedOnce == true)
			UniteFunctionsUC::throwError("The import script can't run twice");

$this->isImportedOnce = true;

if(empty($catID) || is_numeric($catID) == false)
			$catID = 0;

//crate array from filepath
		if(getType($arrTempFile) == "string"){
			$filepath = $arrTempFile;
			$arrInfo = pathinfo($filepath);
			$filename = UniteFunctionsUC::getVal($arrInfo, "basename");

$arrTempFile = array();
			$arrTempFile["tmp_name"] = $filepath;
			$arrTempFile["name"] = $filename;
		}

$this->validateArrTempFile($arrTempFile);

try{
			$this->prepareImportFolders();

$this->extractImportAddonFile($arrTempFile);

$objAssets = new UniteCreatorAssets();
			
			$objAssets->deleteFilesInExtracted($this->pathImportAddon);
			
			$objAssets->validateAllowedFilesInExtracted($this->pathImportAddon);
			
			$isSingle = $this->isExtractedAddonSingle();
						
			if($isSingle == true){
				$isImported = $this->importAddonData($catID, $overwrite, $forceToCat);
		
				if($isImported == true)
					$this->copyImportAssetsFolder();
			}else{
				$this->importAddonsFromFolder($this->pathImportAddon, $catID, $overwrite, true, $forceToCat);
			}

$this->deleteImportAddonFolder();
		}catch(Exception $e){
			$this->deleteImportAddonFolder();

throw $e;
		}

$logText = $this->getLogText();
		
		if(empty($logText))
			$logText = __("No Widgets Imported","unlimited-elements-for-elementor");
		
		return ($logText);
	}

/**
	 * get imported addon type
	 */
	public function getImportedAddonType(){

return ($this->importedAddonType);
	}

/**
	 * get last imported addon id
	 */
	public function getImportedAddonID(){

return ($this->lastImportedAddonID);
	}

/**
	 * get last imported cat id
	 */
	public function getImportedCatID(){

return ($this->lastImportedCatID);
	}

/**
	 * get all imported addon names in this session
	 */
	public function getArrImportedAddonNames(){

return (self::$arrImportedAddons);
	}

private function a________BULK_IMPORT_________(){
	}

/**
	 * get array of category data from some path
	 */
	protected function getCatagoryDataFromPath($path){

$filepath = $path . "category.json";

if(file_exists($filepath) == false)
			return (null);

$contents = UniteFunctionsUC::fileGetContents($filepath);
		$arrData = UniteFunctionsUC::jsonDecode($contents);

if(empty($arrData))
			$arrData = null;

return ($arrData);
	}

/**
	 * get short log text (only from import addons from folder)
	 */
	public function getTextLogShort(){

return ($this->textLogShort);
	}

/**
	 * import all addons from folder
	 */
	public function importAddonsFromFolder($path, $catIDParam = 0, $overwrite = false, $forceSingle = false, $forceToCat = true){

if(is_dir($path) == false)
			return (false);

if($catIDParam == "all" || empty($catIDParam))
			$catIDParam = null;

$arrFiles = UniteFunctionsUC::getFileListTree($path, "zip");

//make files with paths list
		$arrFilesFull = array();
		$arrCats = array();

//create category from path if exists
		foreach($arrFiles as $file){
			$pathRelative = str_replace($path, "", $file);

$parentDir = dirname($pathRelative);
			if($parentDir == ".")
				$parentDir = "";

$info = pathinfo($pathRelative);

if(strlen($parentDir) < 3)
				$parentDir = "";

$item = array();
			$item["catname"] = $parentDir;
			$item["filepath"] = $file;

//get category data
			if(!empty($parentDir)){
				$pathCategory = $path . $parentDir . "/";

$catData = $this->getCatagoryDataFromPath($pathCategory);

$arrCats[$parentDir] = $catData;
			}

$arrFilesFull[] = $item;
		}

//create categories
		if(empty($catIDParam) || $forceToCat == false && !empty($arrCats)){
			$objCategories = new UniteCreatorCategories();

$addonType = $this->mustAddonType;
			if(empty($addonType))
				$addonType = "";

foreach($arrCats as $catname => $catData){
				$catAddonType = null;

//check category addon type
				if(!empty($catData)){
					$catAddonType = UniteFunctionsUC::getVal($catData, "type");

$isSpecialAddonType = HelperUC::isSpecialAddonType($catAddonType);

//validate addon type
					if($isSpecialAddonType == false && $catAddonType != $addonType)
						UniteFunctionsUC::throwError("Wrong category addon type: " . $addonType);

$catname = UniteFunctionsUC::getVal($catData, "title");
					UniteFunctionsUC::validateNotEmpty($catname, "category title from category.json");
				}

if(empty($catAddonType))
					$catAddonType = $addonType;

$catID = $objCategories->getCreateCatByTitle($catname, $catAddonType, $catData);

//modify cat name for special addon types
				if($isSpecialAddonType)
					$catname = $catAddonType . "_" . $catname;

$arrCats[$catname] = $catID;
			}
		}

try{
			//update category type on the way
			$isAddonTypeUpdated = false;
			$addonType = "";

foreach($arrFilesFull as $item){
				$catName = $item["catname"];
				$filepath = $item["filepath"];

if(file_exists($filepath) == false)
					continue;

$catID = UniteFunctionsUC::getVal($arrCats, $catName);
				if(empty($catID) || $forceToCat == true && !empty($catIDParam))
					$catID = $catIDParam;

if(empty($catID))
					$catID = 0;

$objImporter = new UniteCreatorExporter();
				$objImporter->setMustImportAddonType($this->mustAddonType);

if($forceSingle == true)
					$objImporter->setImportSingleAddon();

$logText = $objImporter->import($catID, $filepath, $overwrite, true);

//update category type if not updated
				if($isAddonTypeUpdated == false){
					$addonType = $objImporter->getImportedAddonType();

if(!empty($addonType) && !empty($catID)){
						$objCats = new UniteCreatorCategories();
						$objCats->updateType($catID, $addonType);

$isAddonTypeUpdated = true;
					}
				}

$this->addLog($logText);
			}

$logText = $this->getLogText();

//create categories short text
			$textCats = "";
			if(!empty($arrCats)){
				$arrCatNames = array_keys($arrCats);
				$this->textLogShort = "Installed " . implode(",", $arrCatNames);
				$numCats = count($arrCatNames);

if($numCats == 1)
					$this->textLogShort .= " bundle";
				else
					$this->textLogShort .= " bundles";
			}else{
				$numAddons = count($arrFilesFull);
				$this->textLogShort = "Installed " . $numAddons . " addons";
			}

return ($logText);
		}catch(Exception $e){
			$message = $e->getMessage();

$this->addLog("error: $message");

throw $e;
		}
	}

}