SPO Modern Site> Can I inherit a page template created on the root website on its secondary websites?

I created a news article and registered it as a template on a modern communication site. Is there an option to reuse the template when creating news on subsites? All the indicators on this are appreciated. Thnaks

web hosting – Create a Master Page for a website

I am new to site hosting and I was going to create a small site on which I would train, hosted on my Raspberry Pi 3 B +. I've done a few SharePoint admin tasks, I know their form of master pages and I wanted to know how it was possible to create a "template" site.

Personally, I do not want to have to copy / paste the navigation, the footer, etc. on every page every time I make a change. Is there a way to use a model located at the root of the site and to "supplement" certain parts of the body? I do not know much about ASP.NET, but I guess it does not work well with the Debian OS.

multisite – The visited page is still cached – The Cache-Control header does not work

I try to solve a problem that torments me and I can not understand the problem.

I continue to encounter a problem in which, if an offline visitor visits my site and displays a page before logging in, the same page displays a cached version once you are logged in, if you return. Basically, woocommerce customers appear disconnected only when you return to this page.

I use the following configuration:

Woocommerce – Caching with Autoptimize & Edge with a Cloudflare Agent.

I have disabled caching of pages for users logged in through the setting defined in Autoptimize and implemented the following code in my function file:

// ----------------------------------------
// DISABLE AUTO-OPTIMIZE FOR ALL LOGGED-IN USERS
add_filter('autoptimize_filter_noptimize','really_bail_loggedin',10,0);
function really_bail_loggedin() {
    if ( ! is_user_logged_in() ) {
        return true;
    } else {
        return false;
    }
}

I have also implemented the following action to try to ensure the revalidation of the cache:

// ----------------------------------------
// ADD CACHE HEADERS
function add_header_xua() {
    if ( is_user_logged_in() ) { 
        header("Cache-Control: no-cache, must-revalidate"); 
        header("Pragma: no-cache"); 
        header("Expires: Sat, 26 Jul 1997 05:00:00 GMT");
    }
}
add_action( 'send_headers', 'add_header_xua' );

Despite this, the problem persists and any page visited before the connection appears to be cached.

I have bypassed all caching with Cloudflare using page rules and I only use the working script below:

// IMPORTANT: Either A Key/Value Namespace must be bound to this worker script
// using the variable name EDGE_CACHE. or the API parameters below should be
// configured. KV is recommended if possible since it can purge just the HTML
// instead of the full cache.

// API settings if KV isn't being used
const CLOUDFLARE_API = {
  email: "emailobscured@gmail.com", // From https://dash.cloudflare.com/profile
  key: "keyobscured",   // Global API Key from https://dash.cloudflare.com/profile
  zone: "zoneobscured"   // "Zone ID" from the API section of the dashboard overview page https://dash.cloudflare.com/
};

// Default cookie prefixes for bypass
const DEFAULT_BYPASS_COOKIES = (
  "wp-",
  "wordpress",
  "comment_",
  "woocommerce_"
);

/**
 * Main worker entry point. 
 */
addEventListener("fetch", event => {
  const request = event.request;
  let upstreamCache = request.headers.get('x-HTML-Edge-Cache');

  // Only process requests if KV store is set up and there is no
  // HTML edge cache in front of this worker (only the outermost cache
  // should handle HTML caching in case there are varying levels of support).
  let configured = false;
  if (typeof EDGE_CACHE !== 'undefined') {
    configured = true;
  } else if (CLOUDFLARE_API.email.length && CLOUDFLARE_API.key.length && CLOUDFLARE_API.zone.length) {
    configured = true;
  }

  // Bypass processing of image requests (for everything except Firefox which doesn't use image/*)
  const accept = request.headers.get('Accept');
  let isImage = false;
  if (accept && (accept.indexOf('image/*') !== -1)) {
    isImage = true;
  }

  if (configured && !isImage && upstreamCache === null) {
    event.passThroughOnException();
    event.respondWith(processRequest(request, event));
  }
});

/**
 * Process every request coming through to add the edge-cache header,
 * watch for purge responses and possibly cache HTML GET requests.
 * 
 * @param {Request} originalRequest - Original request
 * @param {Event} event - Original event (for additional async waiting)
 */
async function processRequest(originalRequest, event) {
  let cfCacheStatus = null;
  const accept = originalRequest.headers.get('Accept');
  const isHTML = (accept && accept.indexOf('text/html') >= 0);
  let {response, cacheVer, status, bypassCache} = await getCachedResponse(originalRequest);

  if (response === null) {
    // Clone the request, add the edge-cache header and send it through.
    let request = new Request(originalRequest);
    request.headers.set('x-HTML-Edge-Cache', 'supports=cache|purgeall|bypass-cookies');
    response = await fetch(request);

    if (response) {
      const options = getResponseOptions(response);
      if (options && options.purge) {
        await purgeCache(cacheVer, event);
        status += ', Purged';
      }
      bypassCache = bypassCache || shouldBypassEdgeCache(request, response);
      if ((!options || options.cache) && isHTML &&
          originalRequest.method === 'GET' && response.status === 200 &&
          !bypassCache) {
        status += await cacheResponse(cacheVer, originalRequest, response, event);
      }
    }
  } else {
    // If the origin didn't send the control header we will send the cached response but update
    // the cached copy asynchronously (stale-while-revalidate). This commonly happens with
    // a server-side disk cache that serves the HTML directly from disk.
    cfCacheStatus = 'HIT';
    if (originalRequest.method === 'GET' && response.status === 200 && isHTML) {
      bypassCache = bypassCache || shouldBypassEdgeCache(originalRequest, response);
      if (!bypassCache) {
        const options = getResponseOptions(response);
        if (!options) {
          status += ', Refreshed';
          event.waitUntil(updateCache(originalRequest, cacheVer, event));
        }
      }
    }
  }

  if (response && status !== null && originalRequest.method === 'GET' && response.status === 200 && isHTML) {
    response = new Response(response.body, response);
    response.headers.set('x-HTML-Edge-Cache-Status', status);
    if (cacheVer !== null) {
      response.headers.set('x-HTML-Edge-Cache-Version', cacheVer.toString());
    }
    if (cfCacheStatus) {
      response.headers.set('CF-Cache-Status', cfCacheStatus);
    }
  }

  return response;
}

/**
 * Determine if the cache should be bypassed for the given request/response pair.
 * Specifically, if the request includes a cookie that the response flags for bypass.
 * Can be used on cache lookups to determine if the request needs to go to the origin and
 * origin responses to determine if they should be written to cache.
 * @param {Request} request - Request
 * @param {Response} response - Response
 * @returns {bool} true if the cache should be bypassed
 */
function shouldBypassEdgeCache(request, response) {
  let bypassCache = false;

  if (request && response) {
    const options = getResponseOptions(response);
    const cookieHeader = request.headers.get('cookie');
    let bypassCookies = DEFAULT_BYPASS_COOKIES;
    if (options) {
      bypassCookies = options.bypassCookies;
    }
    if (cookieHeader && cookieHeader.length && bypassCookies.length) {
      const cookies = cookieHeader.split(';');
      for (let cookie of cookies) {
        // See if the cookie starts with any of the logged-in user prefixes
        for (let prefix of bypassCookies) {
          if (cookie.trim().startsWith(prefix)) {
            bypassCache = true;
            break;
          }
        }
        if (bypassCache) {
          break;
        }
      }
    }
  }

  return bypassCache;
}

const CACHE_HEADERS = ('Cache-Control', 'Expires', 'Pragma');

/**
 * Check for cached HTML GET requests.
 * 
 * @param {Request} request - Original request
 */
async function getCachedResponse(request) {
  let response = null;
  let cacheVer = null;
  let bypassCache = false;
  let status = 'Miss';

  // Only check for HTML GET requests (saves on reading from KV unnecessarily)
  // and not when there are cache-control headers on the request (refresh)
  const accept = request.headers.get('Accept');
  const cacheControl = request.headers.get('Cache-Control');
  let noCache = false;
  if (cacheControl && cacheControl.indexOf('no-cache') !== -1) {
    noCache = true;
    status = 'Bypass for Reload';
  }
  if (!noCache && request.method === 'GET' && accept && accept.indexOf('text/html') >= 0) {
    // Build the versioned URL for checking the cache
    cacheVer = await GetCurrentCacheVersion(cacheVer);
    const cacheKeyRequest = GenerateCacheRequest(request, cacheVer);

    // See if there is a request match in the cache
    try {
      let cache = caches.default;
      let cachedResponse = await cache.match(cacheKeyRequest);
      if (cachedResponse) {
        // Copy Response object so that we can edit headers.
        cachedResponse = new Response(cachedResponse.body, cachedResponse);

        // Check to see if the response needs to be bypassed because of a cookie
        bypassCache = shouldBypassEdgeCache(request, cachedResponse);

        // Copy the original cache headers back and clean up any control headers
        if (bypassCache) {
          status = 'Bypass Cookie';
        } else {
          status = 'Hit';
          cachedResponse.headers.delete('Cache-Control');
          cachedResponse.headers.delete('x-HTML-Edge-Cache-Status');
          for (header of CACHE_HEADERS) {
            let value = cachedResponse.headers.get('x-HTML-Edge-Cache-Header-' + header);
            if (value) {
              cachedResponse.headers.delete('x-HTML-Edge-Cache-Header-' + header);
              cachedResponse.headers.set(header, value);
            }
          }
          response = cachedResponse;
        }
      } else {
        status = 'Miss';
      }
    } catch (err) {
      // Send the exception back in the response header for debugging
      status = "Cache Read Exception: " + err.message;
    }
  }

  return {response, cacheVer, status, bypassCache};
}

/**
 * Asynchronously purge the HTML cache.
 * @param {Int} cacheVer - Current cache version (if retrieved)
 * @param {Event} event - Original event
 */
async function purgeCache(cacheVer, event) {
  if (typeof EDGE_CACHE !== 'undefined') {
    // Purge the KV cache by bumping the version number
    cacheVer = await GetCurrentCacheVersion(cacheVer);
    cacheVer++;
    event.waitUntil(EDGE_CACHE.put('html_cache_version', cacheVer.toString()));
  } else {
    // Purge everything using the API
    const url = "https://api.cloudflare.com/client/v4/zones/" + CLOUDFLARE_API.zone + "/purge_cache";
    event.waitUntil(fetch(url,{
      method: 'POST',
      headers: {'X-Auth-Email': CLOUDFLARE_API.email,
                'X-Auth-Key': CLOUDFLARE_API.key,
                'Content-Type': 'application/json'},
      body: JSON.stringify({purge_everything: true})
    }));
  }
}

/**
 * Update the cached copy of the given page
 * @param {Request} originalRequest - Original Request
 * @param {String} cacheVer - Cache Version
 * @param {EVent} event - Original event
 */
async function updateCache(originalRequest, cacheVer, event) {
  // Clone the request, add the edge-cache header and send it through.
  let request = new Request(originalRequest);
  request.headers.set('x-HTML-Edge-Cache', 'supports=cache|purgeall|bypass-cookies');
  response = await fetch(request);

  if (response) {
    status = ': Fetched';
    const options = getResponseOptions(response);
    if (options && options.purge) {
      await purgeCache(cacheVer, event);
    }
    let bypassCache = shouldBypassEdgeCache(request, response);
    if ((!options || options.cache) && !bypassCache) {
      await cacheResponse(cacheVer, originalRequest, response, event);
    }
  }
}

/**
 * Cache the returned content (but only if it was a successful GET request)
 * 
 * @param {Int} cacheVer - Current cache version (if already retrieved)
 * @param {Request} request - Original Request
 * @param {Response} originalResponse - Response to (maybe) cache
 * @param {Event} event - Original event
 * @returns {bool} true if the response was cached
 */
async function cacheResponse(cacheVer, request, originalResponse, event) {
  let status = "";
  const accept = request.headers.get('Accept');
  if (request.method === 'GET' && originalResponse.status === 200 && accept && accept.indexOf('text/html') >= 0) {
    cacheVer = await GetCurrentCacheVersion(cacheVer);
    const cacheKeyRequest = GenerateCacheRequest(request, cacheVer);

    try {
      // Move the cache headers out of the way so the response can actually be cached.
      // First clone the response so there is a parallel body stream and then
      // create a new response object based on the clone that we can edit.
      let cache = caches.default;
      let clonedResponse = originalResponse.clone();
      let response = new Response(clonedResponse.body, clonedResponse);
      for (header of CACHE_HEADERS) {
        let value = response.headers.get(header);
        if (value) {
          response.headers.delete(header);
          response.headers.set('x-HTML-Edge-Cache-Header-' + header, value);
        }
      }
      response.headers.delete('Set-Cookie');
      response.headers.set('Cache-Control', 'public; max-age=315360000');
      event.waitUntil(cache.put(cacheKeyRequest, response));
      status = ", Cached";
    } catch (err) {
      // status = ", Cache Write Exception: " + err.message;
    }
  }
  return status;
}

/******************************************************************************
 * Utility Functions
 *****************************************************************************/

/**
 * Parse the commands from the x-HTML-Edge-Cache response header.
 * @param {Response} response - HTTP response from the origin.
 * @returns {*} Parsed commands
 */
function getResponseOptions(response) {
  let options = null;
  let header = response.headers.get('x-HTML-Edge-Cache');
  if (header) {
    options = {
      purge: false,
      cache: false,
      bypassCookies: ()
    };
    let commands = header.split(',');
    for (let command of commands) {
      if (command.trim() === 'purgeall') {
        options.purge = true;
      } else if (command.trim() === 'cache') {
        options.cache = true;
      } else if (command.trim().startsWith('bypass-cookies')) {
        let separator = command.indexOf('=');
        if (separator >= 0) {
          let cookies = command.substr(separator + 1).split('|');
          for (let cookie of cookies) {
            cookie = cookie.trim();
            if (cookie.length) {
              options.bypassCookies.push(cookie);
            }
          }
        }
      }
    }
  }

  return options;
}

/**
 * Retrieve the current cache version from KV
 * @param {Int} cacheVer - Current cache version value if set.
 * @returns {Int} The current cache version.
 */
async function GetCurrentCacheVersion(cacheVer) {
  if (cacheVer === null) {
    if (typeof EDGE_CACHE !== 'undefined') {
      cacheVer = await EDGE_CACHE.get('html_cache_version');
      if (cacheVer === null) {
        // Uninitialized - first time through, initialize KV with a value
        // Blocking but should only happen immediately after worker activation.
        cacheVer = 0;
        await EDGE_CACHE.put('html_cache_version', cacheVer.toString());
      } else {
        cacheVer = parseInt(cacheVer);
      }
    } else {
      cacheVer = -1;
    }
  }
  return cacheVer;
}

/**
 * Generate the versioned Request object to use for cache operations.
 * @param {Request} request - Base request
 * @param {Int} cacheVer - Current Cache version (must be set)
 * @returns {Request} Versioned request object
 */
function GenerateCacheRequest(request, cacheVer) {
  let cacheUrl = request.url;
  if (cacheUrl.indexOf('?') >= 0) {
    cacheUrl += '&';
  } else {
    cacheUrl += '?';
  }
  cacheUrl += 'cf_edge_cache_ver=' + cacheVer;
  return new Request(cacheUrl);
}

Is there anything I miss? What's going on? Is it right in front of my eyes?

How to display the developed folder on another page?

I'm trying to display the extended folder list on another page in ionic 3 in the same way as the split pane, but I do not use the ionic split pane.
Please, help me

javascript – How to send an action on the same page? other than with php

For example, I have an index.html page.

 


I want to click on the send button to access the "modal-body modal-body-step-2" section. Any suggestions on how to do it?

Magento2 displays the label on the product page if the price is with or without tax

In the EU you have to go on the label if the price is incl. or excl. tax in the shop. If you run different stores in which you have both settings, this can be done with different custom translation strings that are specific to the store view.
Magento has the information, whether a price is TTC or excl, but the question is how to code it. In Magento1, I solved it with the following code, but until now, I do not know how to do it with Magento2:

getStore()
           );?>
   
    __('Incl. Tax') ?> 

    __('Excl. Tax') ?> 

Ideas? Thank you so much!

next.js – Routing or dynamic URL mapping on the server side without page information? – stack overflow

I have problems with server-side URL mapping.
On the client side, I am able to route easily using


     
        

{item}

This gives me the result as follows.
A flawless stay
When the user clicks on the link but the rendered page is a search. I capture the term and retrieve the results.
A flawless stay


// if term = 'something/hello/hi' and the page rendered is search.js
// and url in browser looks like this on client side routing.
    https://www.example.com/something/hello/hi

A flawless stay
The problem occurs when I refresh the 404 error code. The server-side rendering fails and it does not know that it should be mapped to the search page and after the domain, everything needs to be treated as a search term or query.
A flawless stay
I've tried several different ways, like redirection in _App getInitialProps, but it does not work?
I've also tried to redirect from the _Error page but that did not work either.
I tried to create a file [term].js in Pages directory, but it did not work either.
A flawless stay
I do not want to go with the custom server solution.

Is there another way to do it? Maybe something like a generic page can check some static data of possible terms and redirect to a search page.

mysql – Correct data in the database, but not in the web page

I have Indian languages ​​in my database. When I check them via phpmyadmin, they are perfectly represented. But on my site, I can only see ?????.

SHOW VARIABLES LIKE '%char%'

results

+--------------------------------------+----------------------------+
| Variable_name                        | Value                      |
+--------------------------------------+----------------------------+
| character_set_client                 | utf8                       |
| character_set_connection             | utf8                       |
| character_set_database               | latin1                     |
| character_set_filesystem             | binary                     |
| character_set_results                | utf8                       |
| character_set_server                 | latin1                     |
| character_set_system                 | utf8                       |
| character_sets_dir                   | /usr/share/mysql/charsets/ |
| validate_password_special_char_count | 1                          |
+--------------------------------------+----------------------------+

I also have REST APIs for the application. I receive no response because json_encode is having trouble coding this data.

I have recently moved all my data to a new server. I have been facing this problem ever since. Days spent trying to understand that.

Get PHP data in JavaScript to set the position of each message on the home page

I've created a custom message type called project, which works well. Each project has several custom fields, including a set of x and y values ​​that indicate where the project should appear on the cover page (see Code Style section below: I know it does not work, but I'm showing what I want to do in pseudo-code).

I could display the value x as and as defined by the advanced custom field documentation. However, how can I get the x and y values ​​from PHP to JavaScript, so that I can use them to define left and top value of the div that indicates where they should be on the first page?

Since there are many projects and I get different sets of xs and ys in a loop, I'm thinking of writing all x and y values ​​to an external JSON file, and then loading them again with JavaScript. Is this an option considering the structure of WordPress? Or is there a better option to get these pairs of x and y values ​​from PHP to JavaScript?

 "project"
    );

    $projects = new WP_Query($args);
    $data = file_get_contents("projects.json");
       $projects = json_decode($data, true);

    while($projects->have_posts()){
        $projects->the_post();
?>

    
        

On Facebook, I can not share the message of my page on my personal page. Is it correct?

Sharing Facebook from my own page worked like this article. However, I do not have the option "On your own schedule" anymore. I can only share my pages, an event or a group, as shown in the following image.

enter the description of the image here

Is it possible to work around this change? Or is it a bug?