An elegant way to handle WeChat applet authorization login

//Get request encapsulation (jump page judgment)
//Global variables can be obtained through the global function getApp. Global data can be set in app.js in the root directory. let app=getApp();
const myGet = (url, data)=>{
 return new Promise((resolve, reject)=>{
 wx.request({
  url: `${app.globalData.HTTP}${url}`,
  data:data,
  method:"GET",
  //This authorization is the value containing openid and session_key information header: { 'authorization': app.globalData.authorization}, //Get the user information in the global variable and put it into the request header success:(res)=>{
  if (res.data.code == 409) {
   //409 means the user is not logged in, so it is forced to jump to the written login page wx.navigateTo({
   url: '../login/login'
   })
  } else{
   resolve(res.data);
  }
  },
  fail:(res)=>{
  reject();
  }
 })
 })
}
//post request encapsulation (jump page judgment)
const myPost = (url, data) => {
 return new Promise((resolve, reject) => {
 wx.request({
  url: `${app.globalData.HTTP}${url}`,
  data: data,
  method: "POST",
  header: { 'authorization': app.globalData.authorization},
  success: (res) => {
  if (res.data.code == 409){
   wx.navigateTo({
   url: '../login/login'
   })
  }else{
   resolve(res.data);
  }
  
  },
  fail: (res) => {
  reject();
  }
 })
 })
}
module.exports = {
 myGet,
 myPost,
}

//app.js
App({
 onLaunch: function() {
 //Here you can write some code that needs to be executed for project initialization according to the actual needs of the project},
 globalData: {
 HTTP: "https://shop.yamecent.com/",
 //After we obtain the openid and session_key, we will store them in the authorization of the applet memory, so that the data will not be lost unless the applet authorization is deleted: wx.getStorageSync('authorization') || "", //Get the authorization stored in the applet memory
 }
})

const myRequest = require('./myRequest.js');
const app = getApp();
const HTTP = app.globalData.HTTP;
//WeChat login interface to obtain code encapsulation const myLogin=()=>{
 return new Promise((resolve, reject)=>{
 wx.login({
  success:(res)=>{
  resolve(res.code);
  },
  fail:(res)=>{
  reject(res.errMsg);
  console.log("WeChat login and code acquisition failed");
  }
 })
 })
}
//Get openid and session_key interface encapsulation const getUserMsg=(myUrl,myData)=>{
 return new Promise((resolve,reject)=>{
 wx.request({
  url: myUrl,
  method: "POST",
  data: myData,
  success:(res)=>{
  if(res.data.code==500){
   //Get failed wx.showToast({
   title: res.data.msg,
   icon: 'none',
   duration: 2000,
   mask:true,
   })
   resolve(500); //Return 500 if failed   
  }else{
   resolve(res.data.data);
  }  
  },
  fail:(res)=>{
  reject(res.data.msg);
  console.log("Failed to obtain openid and session_key interfaces");  
  }
 })
 })
}

//Encapsulate storage (Note: the storage process here is asynchronous)
const mySetStorage=(key,val)=>{
 return new Promise((resolve, reject) => {
 wx.setStorage({
  key: key,
  data: val,
  success: () => {
  resolve(true);
  },
  fail: () => {
  reject(false);
  }
 })
 }) 
}

//Encapsulate storage const myGetStorage=(key)=>{
 return new Promise((resolve,reject)=>{
 wx.getStorage({
  key: 'key',
  success: (res)=>{
  resolve(res.data);
  },
  fail:()=>{
  reject("Failed to obtain storage");
  }
 })
 })
}


//Authorization method encapsulation //sendData is the user information obtained through the authorization button. Here it is passed as a parameter to the background to save the user's information //cb is the function to be executed after the authorization login is successful. The specific function depends on the project requirements and may not be required const myAuthorize = (sendData,cb="") => {
 async function accredit() {
 wx.showLoading({
  title: 'Certification in progress',
  mask:true
 })
 let code = await myLogin(); //WeChat login to get code interface sendData.code=code;
 let author = await getUserMsg(`${HTTP}auth`, sendData); //Get the background openid sesstion_key interface wx.hideLoading();
 if(author==500){
  return;
 }
 await mySetStorage("authorization", author.Authorization); //Save to memory, enter the applet to get and store in app.globalData app.globalData.authorization = author.Authorization;
 typeof cb == "function" && cb(author); //Login status parameters needed for callback //Other business logic can be added here, such as the number of shopping carts of tabbar users, etc. wx.showToast({
  title: 'Successful Authorization',
  icon: 'success',
  duration: 2000,
  mask: true
 });    

 
 }
 accredit();
}

module.exports = {
 myAuthorize,
 mySetStorage,
 myGetStorage
}

<button class='btn' open-type="getUserInfo" bindgetuserinfo='gotoLogin'>Log in now</button>

// pages/login/login.js
const myRequest = require('../../common/script/myRequest.js');
const login = require('../../common/script/login.js');
const app = getApp();
const HTTP = app.globalData.HTTP;
Page({

 /**
 * Initial data of the page */
 data: {
 
 },
 gotoLogin: function (e) {
 let sendOjb={};//Used to store user informationif (e.detail.errMsg == "getUserInfo:ok"){
  sendOjb = { avatar: e.detail.userInfo.avatarUrl,
     nickname: e.detail.userInfo.nickName, 
     sex: e.detail.userInfo.gender,
     province: e.detail.userInfo.province, 
     city: e.detail.userInfo.city}; 
  login.myAuthorize(sendOjb,()=>{
  wx.navigateBack(); //Return to the previous page after success, or write some other logic according to project requirements}) 
 }else{
  
 }
 },
 /**
 * Life cycle function--listen for page loading*/
 onLoad: function (options) {

 },
})