前言

微信方便了人与人之间的交流，让亲人能感受到千里之外家人亲情的温暖，也让爱人们之间的问候更加方便。女人在感情里一直都是比男人要更加敏感的。

她们的“第六感”可能比福尔摩斯探案的时候还精准。所以如果当一个女人在微信上问你“你在哪儿”的时候，如果你回答的不好，有可能就会被这个女人抓住你的“把柄”。

即使你没有和异性在暧昧，但你没有及时回复她的微信，也会让她生气。女人有的时候找你可能是真的想你了，但有的时候她可能只是想“查岗”，看看你在哪里，和谁在一起。

所以如果在微信上，一个女人问“你在哪儿”时，你不可以随便回答，更不能不回答。而情商高的男人则会直接发送自己的行动轨迹，方便Ta查岗。

实现效果

小程序二维码

运动路径

时间段筛选

查看他人运动轨迹

共享轨迹

查看轨迹

注意事项

1. 授权定位信息的时必须选择“在使用小程序期间和离开小程序后”。

2. 关闭小程序还可以获取到定位信息，清理微信后台运行后就获取不到了，需要重新打开小程序。
3. 首页授权时不小心点错了怎么办？

核心代码

开启小程序后台获取定位

  /**
   * @desc 开启小程序进入前后台时均接收位置消息
   */
  startLocationUpdateBackground() {
    wx.startLocationUpdateBackground({
      success: res => {
        wx.offLocationChange()
        wx.onLocationChange(_locationChangeFn)
        that.initData()
      },
      fail: err => {
        console.log(err)
        wx.showToast({
          icon: "none",
          title: "请前往个人中心,定位管理开启位置授权后重启小程序",
          duration: 5000
        })
      }
    })
  },

位置变化回调

/**
 * @desc 位置变化回调函数
 */
async function _locationChangeFn(res) {
  const { latitude, longitude } = res;
  if (that.data.enableMapCenter) {
    that.setData({
      latitude,
      longitude
    })
  }
  if (lastLocation.latitude) {
    // 计算与上次定位距离
    const distance_M = getDistance(lastLocation.latitude, lastLocation.longitude, latitude, longitude)
    if (distance_M > 30) {
      // 更新上次位置
      lastLocation = {
        latitude: latitude,
        longitude: longitude
      }
      await AddTrack({ latitude: latitude, longitude: longitude })
    }
    else {
      console.log('移动距离小于30米')
    }
  }
  else {
    // 首次获取位置，赋值给lastLocation
    lastLocation = {
      latitude: latitude,
      longitude: longitude
    }
    // 精度达到小数点10位以上才能录入（过滤掉开发工具获取到的定位信息）
    const precision = latitude.toString().split(".")[1].length
    if (precision > 10) {
      await AddTrack({ latitude: latitude, longitude: longitude })
    }
    else {
      console.log("定位精度不足：", precision)
    }
  }
}

云开发相关

云数据库数据结构

用户表member

关系表relationship

轨迹表track

前端数据库操作

用户表member

/**
 * @desc 用户表
 */
const app = getApp()
const db = wx.cloud.database()
const _ = db.command
const $ = _.aggregate

const tMember = db.collection('member')
const dayjs = require('../libs/day')

/**
 * @desc 获取用户信息
 * @param refresh 强制刷新标志位
 */
async function initMember(refresh = 0) {
  if (app.globalData.member && !refresh) {
    return app.globalData.member
  } else {
    const {
      data
    } = await tMember
      .where({
        _openid: '{openid}'
      })
      .get()

    const member = data[0] ? data[0] : ""
    app.globalData.member = member
    return member
  }
}

/**
 * @desc  更新用户信息
 * @param id 用户id
 * @param data 更新数据
 */
async function updateMember(id, data) {
  data._updateTime = db.serverDate()
  const {
    stats
  } = await tMember
    .doc(id)
    .update({
      data: data
    })
  if (stats.updated) {
    app.globalData.member = {
      ...app.globalData.member,
      ...data
    }
  }
  return stats.updated
}

/**
 * @desc 新增用户
 */
async function addMember(data) {
  data._ts = dayjs().valueOf()
  data._createTime = db.serverDate()
  data._updateTime = db.serverDate()
  const {
    _id
  } = await tMember.add({
    data: data
  })
  data._id = _id
  // 生成 member 全局变量
  app.globalData.member = data
  return _id
}
/**
 * @desc 根据条件获取列表
 */
async function getMemberList(filter = {}, _skip = 0, _limit = 20) {
  const { data } = await tMember
    .where(filter)
    .skip(_skip)
    .limit(_limit)
    .get()
  return data
}


module.exports = {
  InitMember: initMember, // 获取用户信息
  UpdateMember: updateMember, //更新用户及简历信息
  AddMember: addMember, // 新增用户
  GetMemberList: getMemberList,//根据条件获取列表
}

关系表relationship

/**
 * @desc 关系表
 */
const app = getApp()
const db = wx.cloud.database()
const _ = db.command
const $ = _.aggregate

const tRelationship = db.collection('relationship')
const dayjs = require('../libs/day')

/**
 * @desc 新增关系
 */
async function addRelationship(data) {
  data._ts = dayjs().valueOf()
  data._createTime = db.serverDate()
  data._updateTime = db.serverDate()
  const {
    _id
  } = await tRelationship.add({
    data: data
  })
  data._id = _id
  return _id
}
/**
 * @desc 查询关系（我分享的）
 * @param skip 起始位置
 */
async function getMyShare(skip = 0) {
  const {
    data
  } = await tRelationship
    .where({
      share_openid: '{openid}'
    })
    .skip(skip)
    .get()
  return data
}
/**
 * @desc 查询关系(Ta分享的)
 */
async function getTaShare() {
  const { result } = await wx.cloud.callFunction({
    name: 'relationship',
    data: {
      action: 'TaShare',
    }
  })
  return result ? result.list : []
}
/**
 * @desc 判断是否已经建立关系了
 */
async function judgeRelationship(share_oepnid,) {
  const {
    data
  } = await tRelationship
    .where(_.and([
      {
        share_openid: share_oepnid
      },
      {
        _openid: '{openid}'
      }
    ]))
    .get()
  return data
}
/**
 * @desc 删除关系
 */
async function cancleRelationship(id) {
  const { stats } = await tRelationship
    .doc(id)
    .remove()
  return stats
}
module.exports = {
  AddRelationship: addRelationship,
  GetMyShare: getMyShare,
  GetTaShare: getTaShare,
  JudgeRelationship: judgeRelationship,
  CancleRelationship:cancleRelationship
}

轨迹表track

/**
 * @desc 轨迹表
 */
const app = getApp()
const db = wx.cloud.database()
const _ = db.command
const $ = _.aggregate

const tTrack = db.collection('track')
const dayjs = require('../libs/day')

/**
 * @desc 新增轨迹
 */
async function addTrack(data) {
  data._ts = dayjs().valueOf()
  data._createTime = db.serverDate()
  data._updateTime = db.serverDate()
  const {
    _id
  } = await tTrack.add({
    data: data
  })
  data._id = _id
  return _id
}
/**
 * @desc 监听定位信息
 * @param onChange 成功回调
 * @param onError 失败回调
 * @param openid
 * @param startTime 开始时间戳（默认当前时间前2小时）
 * @param endTime 结束时间戳（默认没有）
 */
async function watchTrack(onChange, onError, openid = '{openid}', startTime = dayjs().subtract(2, 'hour').valueOf(), endTime) {
  // 构建条件
  let filter = {
    _openid: openid,
    _ts: _.gt(startTime)
  }
  if (endTime) {
    filter._ts = _.gt(startTime).and(_.lt(endTime))
  }
  const watcher = await tTrack
    .where(filter)
    .orderBy('_ts', 'desc')
    .watch({
      onChange: onChange,
      onError: onError
    })
  return watcher
}
module.exports = {
  AddTrack: addTrack,
  WatchTrack: watchTrack
}

云函数

关系表relationship

// 云函数入口文件
const cloud = require('wx-server-sdk')

cloud.init()

// 云函数入口函数
exports.main = async (event, context) => {
  const wxContext = cloud.getWXContext()
  // 请求者openid
  const _openid = wxContext.OPENID
  switch (event.action) {
    case 'TaShare': return getTaShare(_openid);
  }
}
/**
 * @desc 查询Ta分享的关系
 */
async function getTaShare(openid) {
  const db = cloud.database()
  const TaShare = await db.collection('relationship')
    .aggregate()
    .match({
      _openid: openid
    })
    .lookup({
      from: 'member',
      localField: 'share_openid',
      foreignField: '_openid',
      as: 'share_member',
    })
    .project({
      _id: 1,
      _openid: 1,
      _ts: 1,
      share_member: 1
    })
    .end()
  return TaShare
}

最后

😉 如果你觉得本文对你有所帮助 请留个赞 😉