How to ensure that every page of WeChat Mini Program is logged in

const app = getApp()
Page({
  data: {
    logs: []
  },
  onLoad() {
    app.commonLogin(()=>{
        // Process page request })
  }
})

/**
   * Process merge parameters */
  handlePageParamMerge(arg) {
    let numargs = arg.length; // Get the value of the passed parameter.
    let data = {}
    let page = {}
    for (let ix in arg) {
      let item = arg[ix]
      if (item.data && typeof (item.data) === 'object') {
        data = Object.assign(data, item.data)
      }
      if (item.methods && typeof (item.methods) === 'object') {
        page = Object.assign(page, item.methods)
      } else {
        page = Object.assign(page, item)
      }
    }
    page.data = data
    return page
  }

  /***
   * Merge page methods and data, compatible with {data:{}, methods:{}} or {data:{}, a:{}, b:{}}
   */
  mergePage() {
    return this.handlePageParamMerge(arguments)
  }

  /**
   * Processing component parameter merging */
  handleCompParamMerge(arg) {
    let numargs = arg.length; // Get the value of the passed parameter.
    let data = {}
    let options = {}
    let properties = {}
    let methods = {}
    let comp = {}
    for (let ix in arg) {
      let item = arg[ix]
      // Merge the initial data of the component if (item.data && typeof (item.data) === 'object') {
        data = Object.assign(data, item.data)
      }
      // Merge component property lists if (item.properties && typeof (item.properties) === 'object') {
        properties = Object.assign(properties, item.properties)
      }
      // List of methods for combined components if (item.methods && typeof (item.methods) === 'object') {
        methods = Object.assign(methods, item.methods)
      }
      if (item.options && typeof (item.options) === 'object') {
        options = Object.assign(options, item.options)
      }
      comp = Object.assign(comp, item)
    }
    comp.data = data
    comp.options = options
    comp.properties = properties
    comp.methods = methods
    return comp
  }

  /**
   * Component mixin {properties: {}, options: {}, data:{}, methods: {}}
   */
  mergeComponent() {
    return this.handleCompParamMerge(arguments)
  }

  /***
   * Synthesize a page with watch */
  newPage() {
    let options = this.handlePageParamMerge(arguments)
    let that = this
    let app = getApp()

    //Add global click login judgment if (!options.publicCheckLogin){
      options.publicCheckLogin = function (e) {
        let pages = getCurrentPages()
        let page = pages[pages.length - 1]
        let dataset = e.currentTarget.dataset
        let callback = null

        //Get callback method if (dataset.callback && typeof (page[dataset.callback]) === "function"){
          callback = page[dataset.callback]
        }
        // console.log('callback>>', callback, app.isRegister())
        //Judge whether to log in if (callback && app.isRegister()){
          callback(e)
        }
        else{
          wx.navigateTo({
            url: '/pages/login/login'
          })
        }
      }
    }

    const { onLoad } = options
    options.onLoad = function (arg) {
      options.watch && that.setWatcher(this)
      onLoad && onLoad.call(this, arg)
    }

    const { onShow } = options
    options.onShow = function (arg) {
      if (options.data.noAutoLogin || app.isRegister()) {
        onShow && onShow.call(this, arg)
        //Page embedding app.ga({})
      }
      else {
        wx.navigateTo({
          url: '/pages/login/login'
        })
      }
    }

    return Page(options)
  }

  /**
   * Synthesize components with watches, etc. */
  newComponent() {
    let options = this.handleCompParamMerge(arguments)
    let that = this
    const { ready } = options
    options.ready = function (arg) {
      options.watch && that.setWatcher(this)
      ready && ready.call(this, arg)
    }
    return Component(options)
  }

  /**
    * Set up the listener */
  setWatcher(page) {
    let data = page.data;
    let watch = page.watch;
    Object.keys(watch).forEach(v => {
      let key = v.split('.'); // Split the attributes in watch into an array with '.' let nowData = data; // Assign data to nowData
      for (let i = 0; i < key.length - 1; i++) { // Traverse the elements of the key array, except the last one!
        nowData = nowData[key[i]]; // Point nowData to its key attribute object}

      let lastKey = key[key.length - 1];
      // Assume key==='my.name', nowData===data['my']===data.my, lastKey==='name'
      let watchFun = watch[v].handler || watch[v]; // Compatible with both with and without handlers let deep = watch[v].deep; // If deep is not set, it is undefine
      this.observe(nowData, lastKey, watchFun, deep, page); //Monitor the lastKey of the nowData object
    })
  }

  /**
   * Monitor attributes and execute monitoring functions */
  observe(obj, key, watchFun, deep, page) {
    var val = obj[key];
    // Check if deep is true and val cannot be empty and typeof val==='object' (changes in values ​​in the array also require deep monitoring)
    if (deep && val != null && typeof val === 'object') {
      Object.keys(val).forEach(childKey => { // Traverse each key under the val object
        this.observe(val, childKey, watchFun, deep, page); // recursively call the monitoring function})
    }
    var that = this;
    Object.defineProperty(obj, key, {
      configurable: true,
      enumerable: true,
      set: function (value) {
        if (val === value) {
          return
        }
        // Call with the page object, change the this pointer in the function so that this.data can access the property value in data watchFun.call(page, value, val); // value is the new value, val is the old value val = value;
        if (deep) { // If it is deep monitoring, re-listen to the object in order to monitor its properties.
          that.observe(obj, key, watchFun, deep, page);
        }
      },
      get: function () {
        return val;
      }
    })
  }

app.tool.newPage({
  data: {
    // noAutoLogin: false
  },
  onShow: function () {
    //Write the page request logic here}
}