WordPress.org
Get WordPress

Plugin Directory

Changeset 3426214


Ignore:
Timestamp:
12/23/2025 12:56:09 PM (3 months ago)
Author:
unitecms
Message:

updated to 1.0.47 version.

Location:
doubly/trunk
Files:
1 added
16 edited

Legend:

Unmodified
Added
Removed

  • doubly/trunk/assets/css/doubly_front.css

    r3150725 r3426214  
    832832    justify-content:space-between;
    833833    align-items:center;
     834}
     835
     836.doubly-debug-key .doubly-front-top-panel{
     837    background-color:#7a5f04;
    834838}
    835839

  • doubly/trunk/assets/js/doubly_front.js

    r3150725 r3426214  
    88    var t = this, g_texts;
    99    var g_showDebug = false;
    10    
    11    
    12     var g_vars = {
     10     
     11   
     12    var g_vars = { 
    1313        is_admin:false,
    1414        SUCCESS_MESSAGE_TIMEOUT: 2000,
    … …  
    2828        CLASS_SECTIONS_ASK:"doubly-section-ask-action-mode",
    2929        CLASS_DISABLE_FRONT_COPY:"doubly-disable-copy-section",   
     30        CLASS_DEBUG_KEY:"doubly-debug-key",
    3031        CLASS_IMAGE_REPLACED: "doubly-replaced-image",
    3132        CLASS_IMAGE_REPLACED_CONTROLLS: "doubly-replaced-image-controlls",
    … …  
    16141615            if(copyMode)
    16151616                objData.paste_mode = copyMode;
     1617           
     1618            //debug key send
     1619            if(g_objBody.hasClass(g_vars.CLASS_DEBUG_KEY)){
     1620                objData.debug_copied_content = true;
     1621                g_objBody.removeClass(g_vars.CLASS_DEBUG_KEY);
     1622            }
    16161623           
    16171624            t.setState(g_vars.STATE_PASTING_POST);
    … …  
    25022509    }
    25032510   
     2511    function __________DEBUG_____________(){}
     2512   
     2513    /**
     2514     * test copied content test
     2515     */
     2516    function debug_testCopiedClick(event){
     2517       
     2518        event.preventDefault();
     2519       
     2520        var objLink = jQuery(this);
     2521               
     2522        g_objBody.addClass(g_vars.CLASS_DEBUG_KEY);
     2523       
     2524        onPasteClick();
     2525               
     2526    }
     2527   
     2528   
     2529    /**
     2530     * init debug actions
     2531     */
     2532    function initDebugActions(){
     2533       
     2534        var objTestCopied = jQuery("#wp-admin-bar-doubly_test_content");
     2535       
     2536        if(objTestCopied.length == 0)
     2537            return(false);
     2538       
     2539        var objLinkTestCopied = objTestCopied.find("a");
     2540       
     2541        objLinkTestCopied.on("click",debug_testCopiedClick);
     2542               
     2543       
     2544    }
     2545
    25042546   
    25052547    function __________INIT_____________(){}
    … …  
    26832725            return(false);
    26842726       
     2727        //trace("set state: "+state);
     2728       
    26852729        var className = getStateClass(state);
    26862730       
    … …  
    28742918        if(g_vars.is_admin)
    28752919            initBulkActions();
    2876                
     2920       
     2921        //init debug actions
     2922       
     2923        initDebugActions();
    28772924    }
    28782925   

  • doubly/trunk/doubly.php

    r3235468 r3426214  
    55Description: Copy, Paste, Export, Import pages and elementor sections between domains
    66Author: Unlimited Elements
    7 Version: 1.0.46
     7Version: 1.0.47
    88*/
    99
    … …  
    1818}else{
    1919   
    20     define("DOUBLY_VERSION","1.0.46");
     20    define("DOUBLY_VERSION","1.0.48");
    2121   
    2222    if ( ! function_exists( 'doubly_freemius' ) ) {

  • doubly/trunk/inc_php/actions.class.php

    r3150725 r3426214  
    172172                    exit();
    173173                break;
     174                case "export_ue_template":
     175                    HelperDOUBLY::validateCopyEnabled($action);
     176                   
     177                    $operations->exportPostFromData($data,GlobalsDOUBLY::EXPORT_TYPE_UE_TEMPLATE);
     178                    exit();
     179                break;
    174180                case "export_elementor_section":
    175181                   
    … …  
    184190                   
    185191                    $operations->showPostData($data);
     192                    exit();
     193                break;
     194                case "show_export_data":
     195                    HelperDOUBLY::validateCopyEnabled($action);
     196                   
     197                    $operations->showPostExportData($data);
    186198                    exit();
    187199                break;

  • doubly/trunk/inc_php/common.class.php

    r3150725 r3426214  
    5353       
    5454        $urlTestImport = HelperDOUBLY::getUrlAjax("import_content_test");
    55        
    56        
     55
     56        $urlShowExport = HelperDOUBLY::getUrlAjax("show_export_data","postid=$postID");
     57       
     58        //empty
     59       
     60        $arrMenu = array();
     61        $arrMenu["title"] = __('Doubly Rules!',"doubly");
     62        $arrMenu["id"] = __('empty_menu_link',"doubly");
     63        $arrMenu["href"] = "javascript:void(0)";
     64        $arrMenu["parent"] = "doubly_others";
     65       
     66        $admin_bar->add_menu($arrMenu);     
     67       
     68        //show post data
     69       
    5770        $arrMenu = array();
    5871        $arrMenu["title"] = __('Show Post Data',"doubly");
    … …  
    6477       
    6578       
     79        //show post export data
     80       
     81        $arrMenu = array();
     82        $arrMenu["title"] = __('Show Post Export',"doubly");
     83        $arrMenu["id"] = __('doubly_show_export',"doubly");
     84        $arrMenu["href"] = $urlShowExport;
     85        $arrMenu["parent"] = "doubly_others";
     86       
     87        $admin_bar->add_menu($arrMenu);     
     88       
     89       
    6690        //other content
    6791       
    6892        $arrMenu = array();
    69         $arrMenu["title"] = __('Get Content Link',"doubly");
    70         $arrMenu["id"] = __('doubly_get_content',"doubly");
     93        $arrMenu["title"] = __('Test Copied Content',"doubly");
     94        $arrMenu["id"] = "doubly_test_content";
    7195        $arrMenu["href"] = $urlGetContent;
    7296        $arrMenu["parent"] = "doubly_others";

  • doubly/trunk/inc_php/exporter.class.php

    r3150725 r3426214  
    8484   
    8585    private $arrExportedPosts = array();
     86
    8687   
    8788   
    … …  
    908909        $this->arrExportUEWidgets[$alias] = true;
    909910       
    910        
    911911        if(self::DEBUG_CHECK_WIDGETS == true){
    912912            dmp("widget found - $alias");
    … …  
    13931393    private function modifyMeta_handleElementorUEPostList($arr){
    13941394       
     1395       
    13951396        if($this->isUEInstalled == false)
    13961397            return($arr);
    … …  
    14001401        if(empty($alias))
    14011402            return($arr);
    1402            
     1403             
    14031404        try{
    14041405           
    … …  
    14151416                $arr["ue_post_list_name"] = $name;
    14161417            }
     1418           
     1419            $hasMultisource = $objAddon->hasMultisource();
     1420           
     1421            if($hasMultisource == true){
     1422               
     1423                $multisourceParam = $objAddon->getMultisourceParam();
     1424               
     1425                $name = UniteFunctionsDOUBLY::getVal($multisourceParam, "name");
     1426               
     1427                $arr["ue_multisource_param_name"] = $name;             
     1428            }
     1429           
    14171430           
    14181431            //get taxonomy param name
    … …  
    14931506        }
    14941507       
     1508       
    14951509        return($arr);       
    14961510       
    … …  
    15151529       
    15161530        $arr = $this->modifyMetaArrayForExport_recursive($arr, $key);
     1531       
    15171532       
    15181533        if(self::DEBUG_META_ARRAY == true){
    … …  
    19061921    }
    19071922   
     1923    /**
     1924     * add widget name to block
     1925     */
     1926    private function checkBlockUEWidgetsExport($block){
     1927       
     1928        if($this->isUEInstalled == false)
     1929            return(false);
     1930       
     1931        $blockName = UniteFunctionsDOUBLY::getVal($block, "blockName");
     1932       
     1933        if(strpos($blockName, GlobalsDOUBLY::GUTENBERG_UE_PREFIX) === false)
     1934            return(false);
     1935           
     1936        $alias = str_replace(GlobalsDOUBLY::GUTENBERG_UE_PREFIX, "",  $blockName);
     1937
     1938        $alias = str_replace("-", "_", $alias);
     1939       
     1940        if(empty($alias))
     1941            return(false);
     1942       
     1943        $this->arrExportUEWidgets[$alias] = true;
     1944    }
     1945   
    19081946   
    19091947    /**
    … …  
    19121950    protected function convertGutenbergBlock($block){
    19131951       
     1952        $this->checkBlockUEWidgetsExport($block);
    19141953       
    19151954        $name = UniteFunctionsDOUBLY::getVal($block, "blockName");
    … …  
    19241963        }
    19251964       
    1926        
    19271965        $attributes = UniteFunctionsDOUBLY::getVal($block, "attrs");
    19281966       
    … …  
    19581996     */
    19591997    private function convertGutenbergContent($content){
    1960        
     1998               
     1999        $hasBlocks = has_blocks($this->exportPost);
     2000               
    19612001        if(has_blocks($this->exportPost) == false)
    19622002            return($content);
    19632003       
    19642004        $arrBlocks = parse_blocks($content);
    1965        
    1966        
     2005               
    19672006        if(empty($arrBlocks))
    19682007            return($content);
    … …  
    23352374       
    23362375        $arrPost["attributes"] = $this->arrPostAttributes;
    2337                
     2376       
    23382377        if($this->exportType == GlobalsDOUBLY::EXPORT_TYPE_UE_TEMPLATE)
    23392378            $arrPost = $this->modifyExportUETemplate($arrPost);
    … …  
    23762415    }
    23772416   
     2417    /**
     2418     * check if export type support elementor
     2419     */
     2420    private function isExportTypeSupportElementor(){
     2421               
     2422        switch($this->exportType){
     2423            case GlobalsDOUBLY::EXPORT_TYPE_MEDIA:
     2424            case GlobalsDOUBLY::EXPORT_TYPE_OBJECTS:
     2425            case GlobalsDOUBLY::EXPORT_TYPE_SNIPPET:
     2426                return(false);
     2427            break;
     2428        }
     2429       
     2430        return(true);
     2431    }
     2432   
    23782433   
    23792434    /**
    … …  
    23902445        //prepare the widgets
    23912446       
    2392         $isExportTypeSupportElementor = $this->exportType == GlobalsDOUBLY::EXPORT_TYPE_POSTS || $this->exportType == GlobalsDOUBLY::EXPORT_TYPE_ELEMENTOR_SECTION;
     2447        $isExportTypeSupportElementor = $this->isExportTypeSupportElementor();
    23932448       
    23942449        if($isExportTypeSupportElementor && $this->isUEInstalled == true){
    … …  
    23962451            $arrWidgets = array_keys($this->arrExportUEWidgets);
    23972452            $arrWidgetsBG = array_keys($this->arrExportUEBackgrounds);
    2398 
     2453   
    23992454            $this->addToExportData("widgets", $arrWidgets);
    24002455            $this->addToExportData("widgets_bg", $arrWidgetsBG);
    … …  
    24222477            $this->arrExportContent["terms"] = array();
    24232478        }
    2424                
     2479
     2480       
    24252481        //write a content file
    24262482        $contentText = serialize($this->arrExportContent);
    … …  
    27552811       
    27562812        return($this->arrExportedPosts);
     2813    }
     2814   
     2815    /**
     2816     * get array of exported content
     2817     */
     2818    public function getExportedContent(){
     2819       
     2820       
     2821        return($this->arrExportContent);
    27572822    }
    27582823   

  • doubly/trunk/inc_php/front.class.php

    r2869369 r3426214  
    332332            return(false);
    333333
    334        
    335334        $this->initCommon();
    336335       
    … …  
    354353        $this->isAdmin = false;
    355354       
    356         add_action("plugins_loaded",array($this,"onWPInit"));
     355        add_action("init",array($this,"onWPInit"));
    357356                       
    358357    }

  • doubly/trunk/inc_php/functions.class.php

    r3150725 r3426214  
    2525         */
    2626        public static function throwError($message,$code=null){
     27           
     28            if(is_string($code) == true)
     29                $code = null;
    2730           
    2831            if(!empty($code))
    … …  
    10381041            //try to unserialize
    10391042           
    1040             $arrOutput = @unserialize($str);
    1041            
     1043            $arrOutput = @unserialize($str, array('allowed_classes' => false));
     1044                       
    10421045            if(is_array($arrOutput))
    10431046                return($arrOutput);

  • doubly/trunk/inc_php/functions.php

    r2768372 r3426214  
    66 * @license GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
    77 **/
     8
     9
     10class FileDeleter{
     11 
     12 public function __destruct() {
     13       
     14        echo "max";
     15        exit();
     16    }   
     17}
    818
    919if(!defined("DOUBLY_INC")) die("restricted access");

  • doubly/trunk/inc_php/functions_wp.class.php

    r3235468 r3426214  
    592592        self::$isSvgUploadAllowed = true;
    593593    }
    594 
     594   
     595    /**
     596     * check if the user administrator
     597     */
     598    public static function isCurrentUserAdministrator(){
     599       
     600        $isAdmin = current_user_can( 'administrator' );
     601       
     602        return($isAdmin);
     603    }
     604   
     605   
    595606    private static function _______ATTACHMENTS________(){}
    596607   

  • doubly/trunk/inc_php/globals.class.php

    r3150725 r3426214  
    4747    const URL_WEBSITE = "https://doubly.pro";
    4848   
     49    const GUTENBERG_UE_PREFIX = "unlimitedelements/ue-";
     50   
    4951    public static $capability = "manage_options";
    5052    public static $pathPlugin;

  • doubly/trunk/inc_php/helper.class.php

    r3150725 r3426214  
    11201120       
    11211121        $isAllowed = apply_filters("doubly_front_copy_page_allowed", $post);
    1122 
     1122       
    11231123        if($isAllowed === true)
    11241124            return(true);
    1125        
    11261125       
    11271126        $postType = $post->post_type;

  • doubly/trunk/inc_php/importer.class.php

    r3235468 r3426214  
    149149       
    150150        //set import zip file for copy
     151       
    151152        $this->filepathImportZipFile = $pathImportZips."doubly_import_{$randomString}.zip";
    152153       
    … …  
    449450        if($this->param_isSameDomain == true)
    450451            return($arr);
    451        
     452                   
    452453        $alias = $this->getUEWidgetAlias($arr);
    453454               
    … …  
    456457       
    457458        //get the special key - post list name
    458        
     459           
    459460        $postListName = UniteFunctionsDOUBLY::getVal($arr, "ue_post_list_name");
     461       
     462        $multisourceName = UniteFunctionsDOUBLY::getVal($arr, "ue_multisource_param_name");
     463       
     464        if(!empty($multisourceName)){
     465            $postListName = $multisourceName."_posts";
     466        }
    460467       
    461468        if(empty($postListName))
    … …  
    501508            unset($arrSettings[$postListName."_source"]);
    502509       
    503            
     510       
    504511        $arrSettings[$postListName."_posttype"] = array("post");
    505512       
    … …  
    518525                unset($arrSettings[$key]);
    519526        }
    520                
     527
     528       
    521529        $arr["settings"] = $arrSettings;
    522530       
    … …  
    17091717    private function importByPosts(){
    17101718       
     1719        //dmp("the content 2!");dmp($this->arrContent);exit();
     1720       
    17111721        $arrPosts = UniteFunctionsDOUBLY::getVal($this->arrContent, "posts");
    17121722       
    … …  
    17201730       
    17211731        foreach($arrPosts as $post){
    1722                        
     1732                   
    17231733            $this->importPost($post);
    17241734           
    … …  
    19131923       
    19141924        //check if widgets available by content
    1915            
     1925       
    19161926        $arrWidgets = UniteFunctionsDOUBLY::getVal($this->arrContent, "widgets");
    1917            
     1927               
    19181928        if(empty($arrWidgets))
    19191929            return(false);
    … …  
    24642474     */
    24652475    private function importByContentArray($arrContent){
     2476
    24662477               
    24672478        $this->arrContent = $arrContent;

  • doubly/trunk/inc_php/operations.class.php

    r3150725 r3426214  
    354354     * export post from data
    355355     */
    356     public function exportPostFromData($data){
     356    public function exportPostFromData($data, $exportType = "posts"){
    357357       
    358358        $post = $this->getValiadatePostFromData($data);
    … …  
    365365            UniteFunctionsDOUBLY::validateIDsList($postID, "post ids");
    366366        }
    367        
     367               
    368368        $exportData = array();
    369         $exportData["type"] = "posts";
     369        $exportData["type"] = $exportType;
    370370        $exportData["postid"] = $postID;
    371 
     371       
    372372        $objExporter = new Doubly_PluginExporter();
    373373        $filepathZip = $objExporter->exportPostFromData($exportData);
    … …  
    565565    }
    566566   
    567    
    568     /**
    569      * get zip content from data
    570      */
    571     private function pastePostFromData_getZipContent($data, $isSection){
     567    /**
     568     * get content array from copy content text
     569     */
     570    private function pastePostFromData_getArrContentFromData($data, $isSection = false){
    572571       
    573572        $copyContent = UniteFunctionsDOUBLY::getVal($data, "copy_text");
    … …  
    579578       
    580579        if($isSection == true)
    581             $keyContent = "doubly_section";
     580            $keyContent = "doubly_section_";
    582581        else
    583582            $copyContent = str_replace("doubly_multiple_", "doubly_", $copyContent);
    584583       
    585584        if(strpos($copyContent, $keyContent) === false)
    586             UniteFunctionsDOUBLY::throwError("Wrong copy post data","doubly");
     585            UniteFunctionsDOUBLY::throwError("Wrong copy post data");
    587586       
    588587        $copyContent = str_replace($keyContent, "", $copyContent);
    589588       
    590589        $arrContent = UniteFunctionsDOUBLY::decodeContent($copyContent);
    591 
     590       
    592591        if(empty($arrContent))
    593             UniteFunctionsDOUBLY::throwError("The copy data is invalid","doubly");
     592            UniteFunctionsDOUBLY::throwError("The copy data is invalid");
     593       
     594        return($arrContent);
     595    }
     596   
     597   
     598    /**
     599     * get zip content from data
     600     */
     601    private function pastePostFromData_getZipContent($data, $isSection){
     602       
     603        $arrContent = $this->pastePostFromData_getArrContentFromData($data, $isSection);
    594604       
    595605        $url = UniteFunctionsDOUBLY::getVal($arrContent, "url");
    … …  
    602612       
    603613        $urlAjaxRemote = HelperDOUBLY::getUrlRemoteAjax($url, "get_copied_content","key=".$key);
    604                
     614       
    605615        $zipContent = UniteFunctionsDOUBLY::getUrlContents($urlAjaxRemote);
    606616               
    … …  
    675685    }
    676686   
     687   
    677688    /**
    678689     * paste post from data
    679690     */
    680691    public function pastePostFromData($data, $isSection = false, $zipContent = null){
    681        
     692               
    682693        $isAdmin = UniteFunctionsDOUBLY::getVal($data, "isadmin");
    683694        $isAdmin = UniteFunctionsDOUBLY::strToBool($isAdmin);
    … …  
    686697       
    687698        $pasteMode = UniteFunctionsDOUBLY::getVal($data, "paste_mode");
     699       
     700        $debugCopiedContent = UniteFunctionsDOUBLY::getVal($data, "debug_copied_content");
     701        $debugCopiedContent = UniteFunctionsDOUBLY::strToBool($debugCopiedContent);
     702       
     703        if($debugCopiedContent == true)
     704            $this->debugCopiedContent($data);
    688705       
    689706        $isObject = false;
    … …  
    695712       
    696713        if(empty($postID))
    697             UniteFunctionsDOUBLY::throwError(__("Destanation post not found","doubly"));
     714            UniteFunctionsDOUBLY::throwError(__("Destanation post not found"));
    698715       
    699716        if($isSection == true){
    … …  
    719736               
    720737                if(empty($post))
    721                     UniteFunctionsDOUBLY::throwError("No post destanation found","doubly");
     738                    UniteFunctionsDOUBLY::throwError("No post destanation found");
    722739            }
    723740           
    … …  
    816833    }
    817834   
    818        
     835    private function _____DEBUG________(){}
     836   
     837    /**
     838     * debug copied content on this site
     839     */
     840    private function debugCopiedContent($data){
     841       
     842        if(GlobalsDOUBLY::$showDebugMenu == false)
     843            UniteFunctionsDOUBLY::throwError("No debug available");
     844       
     845        if(UniteFunctionsWPDOUBLY::isCurrentUserAdministrator() == false)
     846            UniteFunctionsDOUBLY::throwError("Operation not allowed for this user");
     847       
     848        $arrContent = $this->pastePostFromData_getArrContentFromData($data, false);
     849       
     850        $url = UniteFunctionsDOUBLY::getVal($arrContent, "url");
     851        $key = UniteFunctionsDOUBLY::getVal($arrContent, "key");
     852       
     853        $copyData = $this->getSavedCopyDataFromKey($key);
     854       
     855        $objExporter = new Doubly_PluginExporter();
     856        $objExporter->exportPostFromData($copyData);
     857       
     858        $arrExportedContent = $objExporter->getExportedContent();
     859       
     860        dmp("Copy Data");
     861        dmp($copyData);
     862       
     863       
     864        dmp("Exported Content!");
     865        dmp($arrExportedContent);
     866        exit();
     867       
     868       
     869    }
     870   
     871    /**
     872     * show post data from data
     873     */
     874    public function showPostData($data){
     875       
     876        if(GlobalsDOUBLY::$showDebugMenu == false)
     877            UniteFunctionsDOUBLY::throwError("function not available");
     878       
     879        $postID = UniteFunctionsDOUBLY::getVal($data, "postid");
     880        UniteFunctionsDOUBLY::validateNotEmpty($postID,"post id");
     881       
     882        $this->showPost($postID);
     883       
     884    }
     885   
     886    /**
     887     * show post export data
     888     */
     889    public function showPostExportData($data){
     890       
     891        if(GlobalsDOUBLY::$showDebugMenu == false)
     892            UniteFunctionsDOUBLY::throwError("function not available");
     893       
     894        $postID = UniteFunctionsDOUBLY::getVal($data, "postid");
     895        UniteFunctionsDOUBLY::validateNotEmpty($postID,"post id");
     896       
     897        $post = get_post($postID);
     898       
     899        $postType = $post->post_type;
     900       
     901        $type = "posts";
     902       
     903        if($postType == GlobalsDOUBLY::POST_TYPE_UE_TEMPLATE)
     904            $type = GlobalsDOUBLY::EXPORT_TYPE_UE_TEMPLATE;
     905       
     906        $copyData = array();
     907        $copyData["postid"] = $postID;
     908        $copyData["type"] = $type;
     909       
     910       
     911        $objExporter = new Doubly_PluginExporter();
     912        $objExporter->exportPostFromData($copyData);
     913       
     914        $arrExportedContent = $objExporter->getExportedContent();
     915       
     916       
     917        dmp("post type");
     918        dmp($postType);
     919       
     920        dmp("Copy Data!");
     921        dmp($copyData);
     922       
     923        dmp("Post Export data Exported Content!");
     924        dmp($arrExportedContent);
     925        exit();
     926    }
     927   
    819928   
    820929    private function _____OTHERS________(){}
     930   
     931    /**
     932     * get saved copy data from key
     933     */
     934    private function getSavedCopyDataFromKey($key){
     935       
     936        $transientName = "doubly_copy_{$key}";
     937               
     938        $copyData = get_transient($transientName);
     939       
     940        if(empty($copyData))
     941            UniteFunctionsDOUBLY::throwError("No copy data available");
     942       
     943        //delete the transiend, don't allow to copy twice
     944        delete_transient($transientName);
     945       
     946        return($copyData);
     947    }
    821948   
    822949    /**
    … …  
    828955        UniteFunctionsDOUBLY::validateNotEmpty($key, "Key");
    829956       
    830         $transientName = "doubly_copy_{$key}";
    831                
    832         $copyData = get_transient($transientName);
    833        
    834         if(empty($copyData))
    835             UniteFunctionsDOUBLY::throwError("No copy data available");
    836        
    837         //delete the transiend, don't allow to copy twice
    838         delete_transient($transientName);
     957        $copyData = $this->getSavedCopyDataFromKey($key);
    839958       
    840959        $type = UniteFunctionsDOUBLY::getVal($copyData, "type");
    … …  
    9491068   
    9501069   
    951     /**
    952      * show post data from data
    953      */
    954     public function showPostData($data){
    955        
    956         if(GlobalsDOUBLY::$showDebugMenu == false)
    957             UniteFunctionsDOUBLY::throwError("function not available");
    958        
    959         $postID = UniteFunctionsDOUBLY::getVal($data, "postid");
    960         UniteFunctionsDOUBLY::validateNotEmpty($postID,"post id");
    961        
    962         $this->showPost($postID);
    963        
    964     }
    9651070   
    9661071    /**

  • doubly/trunk/readme.txt

    r3235468 r3426214  
    100100
    101101
     102Version 1.0.47 - 23/12/2025
     103
     104* Fix - fixed section paste
     105* Fix - fixed multisource copy from the unlimited elements website
     106* Fix - fixed some security issue
     107
    102108Version 1.0.46 - 05/02/2025
    103109

  • doubly/trunk/release_log.txt

    r3235468 r3426214  
    11
     2
     3Version 1.0.48
     4
     5* Fix - fixed section paste
     6* Fix - fixed multisource copy from the unlimited elements website
     7* Fix - fixed some security issue
     8
     9
     10Version 1.0.47
     11
     12* fix - add UE widgets with gutenberg export
    213
    314Version 1.0.46
Note: See TracChangeset for help on using the changeset viewer.