@conecli/cone-render 0.8.19 → 0.8.20-beta.2

package/dist/jumpEventReport/index.weapp.ts

@@ -1 +1 @@
-import Taro from '@tarojs/taro'
        console.log('京购商详页跳转：', this.jumpMiniPath.detail)
+import Taro from '@tarojs/taro';
  SECTION_HOME_TAB_TYPE,
  SECTION_HOME_TAB_NAME_TYPE,
  SHOP_MENU_ID_NAME,
  SHOP_MENU_ID_TYPE,
  
  jdJumpToShopHome(shopInfo: JumpEventReportInterFace.ShopIdsInfo = {}) {
    console.log('[降级H5] jdJumpToShopHome index.weapp');
    const currentShopInfo = {
      shopId: global.info.queryInfo.shopId,
      venderId: global.info.queryInfo.venderId,
    };
    const restParams =
      (shopInfo?.shopId && shopInfo.shopId !== currentShopInfo.shopId) ||
      (shopInfo?.venderId && shopInfo.venderId !== currentShopInfo.venderId)
        ? {}
        : currentShopInfo;
    const getInfo = Object.assign({}, restParams, shopInfo);
    this.jdJumpToShopBase(getInfo);
  }
  
  jdJumpToShopCategory(shopId, venderId, logEventInfo = {}) {
    console.log('[降级H5] jdJumpToShopCategory index.weapp');
    this.jdJumpToAppMiniProgram(this.jumpMiniPath.shopx, {
      shopId,
      venderId,
      tabActive: SHOP_MENU_ID_NAME[SHOP_MENU_ID_TYPE.CLASSIFY],
      logEventInfo,
    });
  }
  
  jdJumpToShopBase(shopInfo) {
    console.log('[降级H5] jdJumpToShopBase index.weapp');
    this.jdNavigateToNative(
      `${this.jumpMiniPath.shopx}?${objectToUrlEncode(this.getShopIdOrVenderIdParams(shopInfo))}`,
      {
        ...shopInfo,
      },
    );
  }
  
  jdJumpToShopLight(shopInfo) {
    this.jdNavigateToNative(
      `${this.jumpMiniPath.shopLight}?${objectToUrlEncode(
        this.getShopIdOrVenderIdParams(shopInfo),
      )}`,
      {
        ...shopInfo,
      },
    );
  }
  
  jdJumpToProduct(skuIds, logEventInfo) {
    skuIds = skuIds.toString().trim();
    const getSkuId = skuIds.indexOf(',') !== -1 ? skuIds.split(',')[0] : skuIds;
    if (global?.wxAppNavigatorInstance?.goto) {
      const getParams = {
        sku: getSkuId,
        sourceType: 'wx_shop',
      };
      this.jdNavigateToNative('none', logEventInfo, () => {
        global.wxAppNavigatorInstance.goto(this.jumpMiniPath.detail, getParams);
      });
    } else {
      this.jdNavigateToNative(`${this.jumpMiniPath.detail}?sku=${getSkuId}`, logEventInfo);
    }
  }
  
  jdJumpSkuInfoToProduct(skuInfo: any = {}, logEventInfo) {
    const { skuId, sourceType = 'wx_shop', skuImage } = skuInfo;
    if (skuId) {
      if (global?.wxAppNavigatorInstance?.goto) {
        const getParams = {
          sku: skuId,
          sourceType,
        };
        skuImage && (getParams['cover'] = skuImage);
        this.jdNavigateToNative('none', logEventInfo, () => {
          global.wxAppNavigatorInstance.goto(this.jumpMiniPath.detail, getParams);
        });
      } else {
        this.jdJumpToProduct(skuId, logEventInfo);
      }
    }
  }
  
  jdJumpToCoupon(nowUrlParams: JumpEventReportInterFace.CouponUrlParams, logInfo) {
    if (nowUrlParams.batchId && (nowUrlParams.bindType === 1 || nowUrlParams.bindType === 3)) {
      const couponUrlParams = {
        batch: nowUrlParams.batchId,
        kind: nowUrlParams.bindType,
        startTime: nowUrlParams.startTime,
        endTime: nowUrlParams.endTime,
        quangoufrom: 6,
      };
      this.jdNavigateToNative(
        `${this.jumpMiniPath.searchCoupon}?${objectToUrlEncode(couponUrlParams)}`,
        {
          ...logInfo,
        },
      );
    } else if (nowUrlParams.batchId && nowUrlParams.bindType !== 1 && nowUrlParams.bindType !== 3) {
      const couponUrlParams = {
        ...this.getShopIdOrVenderIdParams(global.info.queryInfo),
        sceneId: 1002,
      };
      this.jdNavigateToNative(`${this.jumpMiniPath.shop}?${objectToUrlEncode(couponUrlParams)}`, {
        ...logInfo,
      });
    }
  }
  
  jdJumpToJTCoupon(nowUrlParams: JumpEventReportInterFace.CouponUrlParams, logInfo) {
    const couponUrlParams = {
      batch: nowUrlParams.batchId,
      kind: nowUrlParams.bindType,
      startTime: nowUrlParams.startTime,
      endTime: nowUrlParams.endTime,
      quangoufrom: 6,
    };
    this.jdNavigateToNative(
      `${this.jumpMiniPath.searchCoupon}?${objectToUrlEncode(couponUrlParams)}`,
      {
        ...logInfo,
      },
    );
  }
  
  jdJumpToRankList(contentId: string | number, rankType = 10, logEventInfo) {
    const rankUrl = `${this.jumpWebUrl.rank}?contentId=${contentId}&sku=&rankType=${rankType}&fromName=dcpws&hideAd=1`;
    this.jdJumpToWeb(rankUrl, {
      contentId,
      ...logEventInfo,
    });
  }
  
  jdJumpToWeb(spUrl, logEventInfo) {
    this.jdNavigateToNative(`${this.jumpMiniPath.h5}?encode_url=${encodeURIComponent(spUrl)}`, {
      ...logEventInfo,
    });
  }
  
  weappRedirectToWeb(
    url: string,
    logEventInfo: JumpEventReportInterFace.OptEventLogParams = {},
    otherParam = {},
  ) {
    let paramStr = '';
    const getOtherParamKeysLength = Object.keys(otherParam).length;
    if (getOtherParamKeysLength > 0) {
      Object.keys(otherParam).forEach((key) => {
        const getValue = `${otherParam[key]}`.replace(/undefined/, '').replace(/null/, '');
        paramStr += `${key}=${getValue}&`;
      });
    }
    const encodeUrl = `/pages/h5/index?${paramStr}encode_url=${encodeURIComponent(url)}`;
    try {
      this.clickEventLog(logEventInfo);
    } catch (e) {
      console.log(e);
    }
    setTimeout(() => {
      Taro.redirectTo({ url: encodeUrl })
        .then((res) => {
          console.log('weappRedirectToWeb.success', res);
        })
        .catch((err) => {
          console.log('weappRedirectToWeb.fail', err);
        });
    }, 200);
  }
  
  jdJumpToLive(liveInfo, logEventInfo = {}) {
    if (liveInfo?.liveId) {
      if (liveInfo?.openWxappToLiveRoom) {
        this.jdNavigateToNative(
          `${this.jumpMiniPath.jdLive}?liveId=${liveInfo.liveId}&origin=473`,
          {
            logEventInfo,
          },
        );
      } else {
        this.jdJumpToWeb(
          `${this.jumpWebUrl.mLive}/${liveInfo.liveId}?origin=0&appid=jdgw`,
          logEventInfo,
        );
      }
    }
  }
  
  jdJumpToActivityPlace(spUrl, logEventInfo) {
    this.jdJumpToWeb(spUrl, logEventInfo);
  }
  
  jdJumpToShopFans(fansParams, logEventInfo) {
    this.jdNavigateToNative(`${this.jumpMiniPath.shopFans}?${objectToUrlEncode(fansParams)}`, {
      ...logEventInfo,
    });
  }
  
  jdJumpToShopDetail(shopInfo) {
    const getInfo = Object.assign(
      {},
      {
        shopId: global.info.queryInfo.shopId,
        venderId: global.info.queryInfo.venderId,
      },
      shopInfo,
    );
    const getShopInfo = this.getShopIdOrVenderIdParams(getInfo);
    this.jdJumpToWeb(`${this.jumpWebUrl.shopIntroduce}?${objectToUrlEncode(getShopInfo)}`, getInfo);
  }
  
  jdJumpToCouponSearchProductList(couponId, logEventInfo = {}) {
    this.jdNavigateToNative(`${this.jumpMiniPath.couponSearch}?batch=${couponId}`, logEventInfo);
  }
  
  jdJumpToShopActivity(shopInfo) {
    const { configDataValue, logEventInfo, projectId } = shopInfo;
    if (projectId && configDataValue) {
      this.jdJumpToWeb(
        `${this.jumpWebUrl.shopSecondActivity}/${configDataValue.data}.html`,
        logEventInfo,
      );
    }
  }
  
  _checkUrlIsProductAndGetSkuInfo(url) {
    let skuId = null;
    if (/\/\/item\.jd\.com\/(\d+)\.html/.test(url)) {
      const getSkuRes = url.match(/\/\/item\.jd\.com\/(\d+)\.html/);
      if (getSkuRes && getSkuRes[1]) {
        skuId = getSkuRes[1];
      }
    } else if (/\/\/item\.m\.jd.com\/product\/(\d+)\.html/.test(url)) {
      const getSkuRes2 = url.match(/\/\/item\.m\.jd\.com\/product\/(\d+)\.html/);
      if (getSkuRes2 && getSkuRes2[1]) {
        skuId = getSkuRes2[1];
      }
    }
    return skuId;
  }
  
  jdJumpConfigUrl(detail, logEventInfo = {}) {
    const { configDataType, configDataValue } = detail;
    switch (configDataType) {
      case LinkConfigType.CONFIG_TYPE_SKU_LIST:
        if (logEventInfo?.jsonParam?.logBaseInfo?.mInfo) {
          logEventInfo.jsonParam.logBaseInfo.mInfo.skuid = configDataValue.skuIds;
        }
        this.jdJumpToProduct(configDataValue.skuIds, logEventInfo);
        break;
      case LinkConfigType.CONFIG_TYPE_CATEGORY:
        if (this.isOpenJdAppUrl(configDataValue.clickUrl)) {
          const getShopSearchParams = this.jdOpenAppParams(configDataValue.clickUrl);
          getShopSearchParams &&
            this.jdJumpToShopSearch(
              Object.assign({}, getShopSearchParams, {
                logEventInfo,
              }),
            );
        } else {
          this.jdJumpToShopSearch(
            configDataValue['cid']
              ? Object.assign(
                  {},
                  {
                    shopId: global.info.queryInfo.shopId,
                    categoryId: configDataValue.cid,
                    ...configDataValue,
                    logEventInfo,
                  },
                )
              : {
                  shopId: global.info.queryInfo.shopId,
                  logEventInfo,
                },
          );
        }
        break;
      case LinkConfigType.CONFIG_TYPE_MEMBER:
        if (this.isOpenJdAppUrl(configDataValue.clickUrl)) {
          const getShopMemberParams = this.jdOpenAppParams(configDataValue.clickUrl);
          getShopMemberParams &&
            this.jdJumpToShopMember(
              Object.assign({}, getShopMemberParams, {
                logEventInfo,
              }),
            );
        } else {
          this.jdJumpToShopMember({
            shopId: global.info.queryInfo.shopId,
            venderId: configDataValue.shopDetail,
            logEventInfo,
          });
        }
        break;
      case LinkConfigType.CONFIG_TYPE_SHOP_ACTIVITY:
        if (this.isOpenJdAppUrl(configDataValue.clickUrl)) {
          const getShopActivityParams = this.jdOpenAppParams(configDataValue.clickUrl);
          if (getShopActivityParams && getShopActivityParams['des'] == 'jshopActivity') {
            this.jdJumpToShopActivity({
              projectId: configDataValue['projectId'],
              configDataValue,
              logEventInfo,
            });
          }
        } else if (configDataValue['projectId']) {
          this.jdJumpToShopActivity({
            projectId: configDataValue['projectId'],
            configDataValue,
            logEventInfo,
          });
        }
        break;
      case LinkConfigType.CONFIG_TYPE_CUSTOM_LINK:
      case LinkConfigType.CONFIG_TYPE_FINANCE_COUPON: {
        const _url = configDataValue.linkUrl;
        if (
          _url.indexOf('to=') === -1 &&
          _url.indexOf(`${domain.mshop.replace(/https?:/, '')}/?shopId=`) !== -1
        ) {
          const _shopId = _url.match(/\d+/g)[0];
          this.jdJumpToShopHome({
            shopId: `${_shopId}`,
            logEventInfo,
          });
        } else if (this.isOpenJdAppUrl(_url)) {
          const getOpenAppParams: any = this.jdOpenAppParams(_url);
          if (getOpenAppParams) {
            if (getOpenAppParams.jumpTab == 'allProduct') {
              this.jdJumpToTabAllProduct(
                global.info.queryInfo.shopId,
                global.info.queryInfo.venderId,
              );
            } else if (
              getOpenAppParams.des == 'productList' &&
              getOpenAppParams.from == 'couponBatch'
            ) {
              console.log('优惠券跳转至京购优惠券可用商品列表');
              this.jdJumpToCouponSearchProductList(getOpenAppParams?.couponId);
            } else if (getOpenAppParams.des == 'vapp') {
              this.jdJumpToWeb(
                `https://conecli.com/apps/mpshare/index.html?category=${
                  getOpenAppParams.category
                }&des=${getOpenAppParams.des}&vapptype=${
                  getOpenAppParams.vapptype
                }&appId=${getOpenAppParams.appId}&path=${
                  getOpenAppParams.path
                }&param=${encodeURI(JSON.stringify(getOpenAppParams.param))}`,
                logEventInfo,
              );
            } else {
              this.jdNavigateToNative(
                '',
                Object.assign({}, getOpenAppParams, {
                  logEventInfo,
                }),
              );
            }
          }
        } else {
          const getSkuId = this._checkUrlIsProductAndGetSkuInfo(_url);
          getSkuId
            ? this.jdJumpToProduct(getSkuId, logEventInfo)
            : this.jdJumpToWeb(_url, logEventInfo);
        }
        break;
      }
      case LinkConfigType.CONFIG_TYPE_JSHOP_DETAIL:
        this.jdJumpToShopDetail({
          venderId: global.info.queryInfo.venderId,
          shopId: global.info.queryInfo.shopId,
          logEventInfo,
        });
        break;
      case LinkConfigType.CONFIG_TYPE_SHOP_HOME:
        this.jdJumpToShopHome({
          ...configDataValue,
          logEventInfo,
        });
        break;
      case LinkConfigType.CONFIG_TYPE_CATEGORY_PAGE:
        this.jdJumpToShopCategory(global.info.queryInfo.shopId, global.info.queryInfo.venderId);
        break;
      case LinkConfigType.CONFIG_TYPE_ANCHOR_POINT:
        break;
      case LinkConfigType.CONFIG_TYPE_SHOPPING_GUIDE:
        if (this.isOpenJdAppUrl(configDataValue.clickUrl)) {
          const getShoppingGuideParams = this.jdOpenAppParams(configDataValue.clickUrl);
          getShoppingGuideParams &&
            this.jdJumpToShopActivity(
              Object.assign({}, getShoppingGuideParams, {
                logEventInfo,
              }),
            );
        }
        break;
      case LinkConfigType.CONFIG_TYPE_MINI_PROGRAM: {
        const linkUrl = decodeURIComponent(configDataValue?.linkUrl || '');
        const search = linkUrl.match(/\?.+/);
        if (search) {
          const miniQueryData: JumpEventReportInterFace.LinkMiniParams =
            parseQueryUrlString(linkUrl);
          try {
            miniQueryData.param = JSON.parse(<string>miniQueryData?.param);
          } catch (e) {
            console.warn('解析小程序 param 错误：', miniQueryData.param);
          }
          this.jdJumpToMiniProgram(miniQueryData);
        } else {
          console.warn('小程序地址错误：', linkUrl);
        }
        break;
      }
      default:
    }
  }
  
  jdJumpToTabAllProduct(shopId, venderId, logEventInfo = {}) {
    console.log('index.weapp.ts - jdJumpToTabAllProduct');
    if (typeof shopId === 'undefined') shopId = global.info.queryInfo.shopId;
    if (typeof venderId === 'undefined') venderId = global.info.queryInfo.venderId;
    this.jdJumpToAppMiniProgram(this.jumpMiniPath.shopx, {
      shopId,
      venderId,
      tabActive: SECTION_HOME_TAB_NAME_TYPE[SECTION_HOME_TAB_TYPE.HOME_PRODUCT],
      logEventInfo,
    });
  }
  
  jdJumpToTopTabBase(type, shopInfo = {}) {
    const getInfo = Object.assign(
      {},
      {
        shopId: global.info.queryInfo.shopId,
        venderId: global.info.queryInfo.venderId,
      },
      shopInfo,
    );
    console.log('小程序原生跳转 jdJumpToTopTabBase');
    const { shopId, venderId, ...logEventInfo } = getInfo;
    this.jdJumpToAppMiniProgram(this.jumpMiniPath.shopx, {
      shopId,
      venderId,
      tabActive: type,
      ...logEventInfo,
    });
  }
  
  jdJumpToSearch(shopId, suggestWord) {
    if (typeof shopId === 'undefined') shopId = global.info.queryInfo.shopId;
    this.jdJumpToAppMiniProgram(this.jumpMiniPath.shopSearch, {
      shopId,
    });
  }
  
  jdJumpToAppHome(params = {}) {
    this.jdJumpToAppMiniProgram(this.jumpMiniPath.jingGouHome, params);
  }
  
  jdJumpToThreePlatform(spUrl, logEventInfo) {
    this.jdJumpToWeb(spUrl, logEventInfo);
  }
  
  jdJumpToMiniProgram({ appId, path, param = {} }: JumpEventReportInterFace.LinkMiniParams) {
    const pageName = param['pageType'] || 'home';
    path = `pages/${pageName}/index`;
    if (appId === global.info.pageInfo?.appId) {
      Taro.navigateTo({
        url: `/${path}?${objectToUrlEncode(param)}`,
      }).catch((err) => {
        console.warn('跳转小程序页面错误：', err);
      });
    } else {
      console.log('一个小程序跳转到另一个小程序暂无此业务');
    }
  }
  
  jdJumpToAppMiniProgram(
    path: string,
    param = {},
    successBack?: functionType,
    failBack?: functionType,
  ) {
    this.jdNavigateToNative(path, param, successBack, failBack);
  }
  
  jdNavigateToNative(
    url: string,
    params: {
      logEventInfo?: object;
    } = {},
    successBack?: functionType,
    failBack?: functionType,
  ) {
    const { logEventInfo, ...otherParams } = params;
    const getEparam = logEventInfo || params;
    console.log(
      '[wxmin] index.weapp jdNavigateToNative params: ',
      params,
      'logEventInfo',
      logEventInfo,
      'otherParams',
      otherParams,
    );
    try {
      this.clickEventLog(getEparam);
    } catch (e) {
      console.log(e);
    }
    setTimeout(() => {
      const getValidOtherParamState = otherParams && Object.keys(otherParams).length > 0;
      const goToPath = `${url}${getValidOtherParamState ? '?' + objectToUrlEncode(otherParams) : ''}`;
      console.log('打印最终wxapp原生跳转地址path', goToPath);
      if (url === this.jumpMiniPath.jingGouHome) {
        Taro.switchTab({
          url: goToPath,
        })
          .then((res) => {
            typeof successBack === 'function' && successBack(res);
            console.log('navigateToWxapp.success', res);
          })
          .catch((err) => {
            typeof failBack === 'function' && failBack(err);
            console.log('navigateToWxapp.fail', err);
          });
      } else {
        if (url !== 'none') {
          Taro.navigateTo({
            url: goToPath,
          })
            .then((res) => {
              typeof successBack === 'function' && successBack(res);
              console.log('navigateToWxapp.success', res);
            })
            .catch((err) => {
              typeof failBack === 'function' && failBack(err);
              console.log('navigateToWxapp.fail', err);
            });
        } else {
          typeof successBack === 'function' && successBack(url);
        }
      }
    }, 200);
  }
  
  clickEventLog(opts: JumpEventReportInterFace.OptEventLogParams = {}, clickKey = 'click') {
    const { eventId, jsonParam, eventLevel = 3, skuId, ...otherParams } = opts;
    if (eventId && jsonParam) {
      if (/TerminatorNew_/.test(eventId + '')) {
        console.log('mini eventId==========', eventId);
      }
      const { etModelInfo, logBaseInfo } = jsonParam;
      let getJsonParam = {};
      if (etModelInfo && logBaseInfo) {
        getJsonParam = logBaseInfo;
      } else {
        if (Array.isArray(jsonParam)) {
          getJsonParam = jsonParam;
        } else {
          getJsonParam = Object.assign(
            {},
            {
              shopid: global.info.queryInfo?.shopId,
            },
            jsonParam,
          );
        }
      }
      if (
        clickKey === 'exposure' &&
        /^TerminatorNew/.test(eventId) &&
        !Array.isArray(getJsonParam)
      ) {
        getJsonParam = [getJsonParam];
      }
      const miniLogParams = {
        eid: eventId,
        elevel: eventLevel,
        eparam: JSON.stringify(getJsonParam),
        pageId: this.logPageId,
        pname: this.logPname, 
        pparam: JSON.stringify(this.routerInfo.params), 
        target: this.routerInfo.path, 
        event: this.nativeEvent, 
        ...otherParams,
      };
      if (clickKey === 'addToCart' && skuId) {
        miniLogParams['shoppingList'] = {
          [skuId]: 1,
        };
      }
      return new Promise((resolve) => {
        global.miniAppLogInstance && global.miniAppLogInstance[clickKey](miniLogParams);
        setTimeout(() => {
          resolve(true);
        }, 300);
      });
    } else {
      console.log('暂无埋点参数eventId和eventParam');
      return Promise.resolve(false);
    }
  }
  
  exposureEventLog(opts: JumpEventReportInterFace.OptEventLogParams = {}) {
    return this.clickEventLog(opts, 'exposure');
  }