// pages/advoad-city-search/advoad-message/electronic-fence/electronic-fence.js
|
const app = getApp()
|
const {
|
queryLocation,
|
areaMonitoringexport,
|
queryFirstLineDestinations
|
} = require('../../../../utils/ajax')
|
const amapFile = require('../../../../utils/amap-wx')
|
// 保留百度地图相关代码作为备用
|
const QQMapWX = require('../../../../utils/qqmap-wx-jssdk')
|
let qqmapsdk;
|
const ADVOAD_START_LOCATION_STORAGE_KEY = 'advoadStartSelectedLocation'
|
const ADVOAD_END_LOCATION_STORAGE_KEY = 'advoadEndSelectedLocation'
|
Page({
|
/**
|
* 页面的初始数据
|
*/
|
data: {
|
options: {}, //数据展示,
|
mapLocation: [], //地图电子围栏
|
longitude: "",
|
latitude: "",
|
abovadStartId: "",
|
where: "",
|
isCitys: false,
|
addressList: [],
|
userId: "",
|
startSiteId: "",
|
endSiteId: "",
|
startLocation: "加载中",
|
district: "",
|
type:0,
|
source: "",
|
stationWhere: "",
|
locatingCurrent: false,
|
hasTriedAutoLocate: false,
|
fenceList: []
|
},
|
|
/**
|
* 生命周期函数--监听页面加载
|
*/
|
onLoad: async function (options) {
|
console.log('qweqweqwe',options);
|
if (options) {
|
let where = options.where
|
this.setData({
|
where,
|
type:options.type,
|
source: options.source || "",
|
stationWhere: options.stationWhere || ""
|
})
|
if (where == 'startLocation') {
|
wx.setNavigationBarTitle({
|
title: "设置上车点"
|
})
|
this.setData({
|
options,
|
abovadStartId: options.abovadStartId,
|
startLocation1: options.abvoadStartLocation,
|
userId: options.abovadStartId,
|
startSiteId: options.abovadStartId || "",
|
endSiteId: options.abovadEndId || ""
|
})
|
let response = await this.handleDistrict()
|
console.log('/**/*/**/*',response);
|
const fenceList = this.getFenceListFromResponse(response)
|
console.log('+-89587877',fenceList);
|
if(fenceList.length > 0){
|
this.setData({
|
district: fenceList[0].district,
|
startLocation: fenceList[0].city
|
},()=>{
|
console.log('+++++',this.data);
|
})
|
}
|
let location = wx.getStorageSync('longitude') + ',' + wx.getStorageSync('latitude')
|
//获取起点电子围栏
|
|
this.getNearLocation(options.abvoadStartLocation,location,true)
|
if(this.data.district){
|
this.getNearLocation(this.data.district, location, true)
|
}
|
} else {
|
wx.setNavigationBarTitle({
|
title: "设置下车点"
|
})
|
this.setData({
|
options,
|
startLocation1: options.abvoadEndLocation,
|
abovadStartId: options.abovadEndId,
|
userId: options.abovadEndId,
|
startSiteId: options.abovadStartId || "",
|
endSiteId: options.abovadEndId || ""
|
})
|
let response = await this.handleDistrict()
|
console.log('/**/*/**/*',response);
|
const fenceList = this.getFenceListFromResponse(response)
|
console.log('+-89587877',fenceList);
|
if(fenceList.length > 0){
|
this.setData({
|
district: fenceList[0].district,
|
startLocation: fenceList[0].city
|
},()=>{
|
console.log('+++++',this.data);
|
})
|
}
|
|
const userLongitude = wx.getStorageSync('longitude')
|
const userLatitude = wx.getStorageSync('latitude')
|
let location = userLongitude + ',' + userLatitude
|
const normalizedFenceList = fenceList.map((item) => this.normalizeFenceItem(item))
|
const currentInFence = userLongitude && userLatitude
|
? normalizedFenceList.some((item) => {
|
const parsedFence = this.parseFenceCoordinate(item)
|
if(!parsedFence){
|
return false
|
}
|
if(parsedFence.mode == 'circle'){
|
const distance = this.getDistanceMeters(
|
Number(userLatitude),
|
Number(userLongitude),
|
parsedFence.centerLatitude,
|
parsedFence.centerLongitude
|
)
|
return distance <= Number(parsedFence.radius || 0)
|
}
|
return parsedFence.points && parsedFence.points.length >= 3
|
? this.isPointInPolygon(Number(userLatitude), Number(userLongitude), parsedFence.points)
|
: false
|
})
|
: false
|
if(!currentInFence){
|
location = this.getMainFenceLocation(normalizedFenceList) || location
|
}
|
//获取起点电子围栏
|
|
this.getNearLocation(options.abvoadEndLocation,location,true)
|
if(this.data.district){
|
this.getNearLocation(this.data.district, location, true)
|
}
|
}
|
}
|
//设置当前位置经纬度
|
|
},
|
createMarker(latitude, longitude){
|
return [{
|
id: 1,
|
latitude,
|
longitude,
|
iconPath: "/img/icon_location.png",
|
width: 26,
|
height: 35
|
}]
|
},
|
getAmapInstance(){
|
return new amapFile.AMapWX({
|
key: 'cea7923a93987b959ab1d2f8ab44d497'
|
})
|
},
|
reverseGeocode(latitude, longitude) {
|
const myAmapFun = this.getAmapInstance()
|
return new Promise((resolve, reject) => {
|
myAmapFun.getRegeo({
|
location: `${longitude},${latitude}`,
|
success: (res) => {
|
const regeocodeData = res[0].regeocodeData
|
resolve({
|
addressComponent: regeocodeData.addressComponent,
|
formattedAddress: regeocodeData.formatted_address
|
})
|
},
|
fail: reject
|
})
|
})
|
},
|
toRadians(deg){
|
return deg * Math.PI / 180
|
},
|
getDistanceMeters(lat1, lon1, lat2, lon2){
|
const earthRadius = 6378137
|
const dLat = this.toRadians(lat2 - lat1)
|
const dLon = this.toRadians(lon2 - lon1)
|
const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
|
Math.cos(this.toRadians(lat1)) * Math.cos(this.toRadians(lat2)) *
|
Math.sin(dLon / 2) * Math.sin(dLon / 2)
|
const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
|
return earthRadius * c
|
},
|
isPointInPolygon(latitude, longitude, points){
|
let inside = false
|
for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
|
const xi = Number(points[i].longitude)
|
const yi = Number(points[i].latitude)
|
const xj = Number(points[j].longitude)
|
const yj = Number(points[j].latitude)
|
const intersect = ((yi > latitude) !== (yj > latitude)) &&
|
(longitude < (xj - xi) * (latitude - yi) / ((yj - yi) || 0.0000001) + xi)
|
if (intersect) {
|
inside = !inside
|
}
|
}
|
return inside
|
},
|
isCurrentLocationInFence(latitude, longitude){
|
const circles = this.data.circles || []
|
const polygons = this.data.polygons || []
|
const inCircle = circles.some((circle) => {
|
const distance = this.getDistanceMeters(
|
latitude,
|
longitude,
|
Number(circle.latitude),
|
Number(circle.longitude)
|
)
|
return distance <= Number(circle.radius || 0)
|
})
|
if(inCircle){
|
return true
|
}
|
return polygons.some((polygon) => {
|
return polygon.points && polygon.points.length >= 3
|
? this.isPointInPolygon(latitude, longitude, polygon.points)
|
: false
|
})
|
},
|
getLocationStorageKey(where){
|
return where == 'startLocation'
|
? ADVOAD_START_LOCATION_STORAGE_KEY
|
: ADVOAD_END_LOCATION_STORAGE_KEY
|
},
|
saveSelectedLocation(where, siteId, siteName, locationName, locationInfo, extraData = {}){
|
wx.setStorageSync(this.getLocationStorageKey(where), {
|
siteId,
|
siteName,
|
locationName,
|
locationInfo,
|
...extraData
|
})
|
},
|
getDefaultText(currentText, defaultText){
|
if(currentText && currentText.indexOf('选择') !== -1 && currentText.indexOf('请') === -1){
|
return defaultText.replace('请', '')
|
}
|
return defaultText
|
},
|
getNearLocationKeyword(defaultKeyword){
|
const options = this.data.options || {}
|
if(this.data.where == 'endLocation'){
|
return options.abvoadEndLocation || this.data.startLocation1 || defaultKeyword
|
}
|
if(this.data.where == 'startLocation'){
|
return options.abvoadStartLocation || this.data.startLocation1 || defaultKeyword
|
}
|
return defaultKeyword
|
},
|
getFenceListFromResponse(response){
|
const data = response && response.data && response.data.data
|
if(Array.isArray(data)){
|
return data
|
}
|
if(data && typeof data === 'object'){
|
if(Array.isArray(data.records)){
|
return data.records
|
}
|
if(Array.isArray(data.list)){
|
return data.list
|
}
|
return [data]
|
}
|
if(data && Array.isArray(data.records)){
|
return data.records
|
}
|
if(data && Array.isArray(data.list)){
|
return data.list
|
}
|
return []
|
},
|
normalizeFenceItem(item){
|
const fenceInfo = item.fenceInfo || {}
|
const coordinate = item.coordinate || fenceInfo.coordinate || ''
|
const coordinateList = coordinate.split(';').filter(i => i)
|
const firstPoint = coordinateList[0] ? coordinateList[0].split(',') : []
|
const isCircleByCoordinate = coordinateList.length == 2 &&
|
firstPoint.length == 2 &&
|
!Number.isNaN(Number(firstPoint[0])) &&
|
!Number.isNaN(Number(firstPoint[1])) &&
|
!Number.isNaN(Number(coordinateList[1]))
|
const derivedFenceType = isCircleByCoordinate
|
? 1
|
: (coordinateList.length >= 3 ? 2 : Number(item.fenceType || fenceInfo.fenceType || item.type || 0))
|
const derivedDefaultPointLon = Number(item.defaultPointLon || fenceInfo.defaultPointLon || (firstPoint[0] || 0))
|
const derivedDefaultPointLat = Number(item.defaultPointLat || fenceInfo.defaultPointLat || (firstPoint[1] || 0))
|
return {
|
...item,
|
coordinate,
|
fenceType: derivedFenceType,
|
defaultPointLat: derivedDefaultPointLat,
|
defaultPointLon: derivedDefaultPointLon,
|
district: item.district || fenceInfo.district || '',
|
city: item.city || fenceInfo.city || '',
|
name: item.name || fenceInfo.name || ''
|
}
|
},
|
parseFenceCoordinate(fenceItem){
|
const coordinate = fenceItem.coordinate || ''
|
const coordinateList = coordinate.split(';').filter(i => i)
|
const firstPoint = coordinateList[0] ? coordinateList[0].split(',') : []
|
const isCircleByCoordinate = coordinateList.length == 2 &&
|
firstPoint.length == 2 &&
|
!Number.isNaN(Number(firstPoint[0])) &&
|
!Number.isNaN(Number(firstPoint[1])) &&
|
!Number.isNaN(Number(coordinateList[1]))
|
if((fenceItem.fenceType == 1 || isCircleByCoordinate) && coordinateList.length >= 2){
|
return {
|
mode: 'circle',
|
centerLongitude: Number(firstPoint[0]),
|
centerLatitude: Number(firstPoint[1]),
|
radius: Number(Number(coordinateList[1]).toFixed(5))
|
}
|
}
|
if(coordinateList.length >= 3){
|
return {
|
mode: 'polygon',
|
points: coordinateList.map((item) => {
|
return {
|
longitude: Number(item.split(',')[0]),
|
latitude: Number(item.split(',')[1])
|
}
|
})
|
}
|
}
|
return null
|
},
|
getMatchedFenceItemByLocation(latitude, longitude){
|
const fenceList = this.data.fenceList || []
|
for(let i = 0; i < fenceList.length; i++){
|
const fenceItem = fenceList[i]
|
const parsedFence = this.parseFenceCoordinate(fenceItem)
|
if(!parsedFence){
|
continue
|
}
|
if(parsedFence.mode == 'circle'){
|
const distance = this.getDistanceMeters(
|
latitude,
|
longitude,
|
parsedFence.centerLatitude,
|
parsedFence.centerLongitude
|
)
|
if(distance <= Number(parsedFence.radius || 0)){
|
return fenceItem
|
}
|
}else if(parsedFence.mode == 'polygon'){
|
if(this.isPointInPolygon(latitude, longitude, parsedFence.points)){
|
return fenceItem
|
}
|
}
|
}
|
return null
|
},
|
getMainFenceLocation(fenceList = []){
|
const mainFence = fenceList.find((item) => Number(item.isMain) == 1) || fenceList[0]
|
if(!mainFence){
|
return ''
|
}
|
const parsedMainFence = this.parseFenceCoordinate(mainFence)
|
const longitude = mainFence.defaultPointLon || (parsedMainFence && parsedMainFence.centerLongitude) || (parsedMainFence && parsedMainFence.points && parsedMainFence.points[0] && parsedMainFence.points[0].longitude)
|
const latitude = mainFence.defaultPointLat || (parsedMainFence && parsedMainFence.centerLatitude) || (parsedMainFence && parsedMainFence.points && parsedMainFence.points[0] && parsedMainFence.points[0].latitude)
|
if(!longitude || !latitude){
|
return ''
|
}
|
return `${longitude},${latitude}`
|
},
|
async fetchFenceData(){
|
if(this.data.where == 'endLocation'){
|
const startId = this.data.startSiteId
|
const endId = this.data.endSiteId || this.data.userId
|
if(!startId || !endId){
|
return {
|
data: {
|
code: 200,
|
data: []
|
}
|
}
|
}
|
// 原来根据终点站点ID获取围栏的方法先保留注释，改为按起终站点查询新的围栏
|
// return queryLocation(endId)
|
return queryFirstLineDestinations(startId, endId)
|
}
|
return queryLocation(this.data.userId)
|
},
|
handleStationSelectResult(self, startInfo, extraUpdates = {}){
|
let pages = getCurrentPages();
|
let targetPage = pages[pages.length - 3];
|
if(!targetPage){
|
app.showToastSuccess('页面信息获取失败',null,'none',1500)
|
return
|
}
|
const isStartStation = this.data.stationWhere == 'statrLocation'
|
const siteId = this.data.userId
|
const siteName = this.data.startLocation1 || self.name
|
this.saveSelectedLocation(this.data.where, siteId, siteName, self.name, startInfo, extraUpdates)
|
if(targetPage.route == 'pages/home/home'){
|
const homeUpdates = isStartStation
|
? {
|
abovadStartId: siteId,
|
abvoadStartLocation: self.name,
|
abovadEndId: null,
|
abvoadEndLocation: '请选择终点'
|
}
|
: {
|
abovadEndId: siteId,
|
abvoadEndLocation: self.name
|
}
|
targetPage.setData(homeUpdates,()=>{
|
wx.navigateBack({
|
delta:2
|
})
|
})
|
return
|
}
|
const updates = isStartStation
|
? {
|
abovadStartId: siteId,
|
abvoadStartLocation: siteName,
|
abvoadEndLocation: this.getDefaultText(targetPage.data.abvoadEndLocation, '请选择终点'),
|
abovadEndId: null,
|
startLocation: self.name,
|
startInfo,
|
endLocation: this.getDefaultText(targetPage.data.endLocation, '请选择下车点'),
|
endInfo: {},
|
lineDestinationId: ''
|
}
|
: {
|
abovadEndId: siteId,
|
abvoadEndLocation: siteName,
|
endLocation: self.name,
|
endInfo: startInfo,
|
lineDestinationId: extraUpdates.lineDestinationId || ''
|
}
|
targetPage.setData(updates,()=>{
|
wx.navigateBack({
|
delta:2
|
})
|
})
|
},
|
async confirmSelectedLocation(self, silentInvalid){
|
let {
|
abovadStartId,
|
where
|
} = this.data
|
let pages = getCurrentPages();
|
let prevPage = pages[pages.length - 2];
|
const locationArr = (self.location || '').split(',')
|
const currentLongitude = Number(locationArr[0])
|
const currentLatitude = Number(locationArr[1])
|
const hasFence = (this.data.circles && this.data.circles.length > 0) || (this.data.polygons && this.data.polygons.length > 0)
|
if(
|
hasFence &&
|
Number.isFinite(currentLatitude) &&
|
Number.isFinite(currentLongitude) &&
|
!this.isCurrentLocationInFence(currentLatitude, currentLongitude)
|
){
|
if(!silentInvalid){
|
app.showToastSuccess('该位置不在围栏范围内，请重新选择',null,'none',1500)
|
}
|
return false
|
}
|
if(where == 'endLocation'){
|
const firstLineValid = await this.queryEndLocationLineDestinations(silentInvalid)
|
if(!firstLineValid){
|
return false
|
}
|
}
|
let res = await areaMonitoringexport(self.adcode, self.location,abovadStartId)
|
let data = res.data
|
let startInfo = {
|
startLat : self.location.split(',')[1],
|
startLon : self.location.split(',')[0]
|
}
|
const matchedFenceItem = where == 'endLocation'
|
? this.getMatchedFenceItemByLocation(currentLatitude, currentLongitude)
|
: null
|
const lineDestinationId = matchedFenceItem ? (matchedFenceItem.id || matchedFenceItem.lineDestinationId || '') : ''
|
const extraUpdates = where == 'endLocation'
|
? { lineDestinationId }
|
: {}
|
if(data.code==200){
|
if(data.data==1){
|
if(this.data.source == 'stationSelect'){
|
this.handleStationSelectResult(self, startInfo, extraUpdates)
|
return true
|
}
|
this.saveSelectedLocation(
|
where,
|
abovadStartId,
|
this.data.startLocation1 || self.name,
|
self.name,
|
startInfo,
|
extraUpdates
|
)
|
if(where == "startLocation"){
|
prevPage.setData({
|
startLocation:self.name,
|
startInfo:startInfo,
|
lineDestinationId: ''
|
},()=>{
|
if(this.data.type!=1){
|
prevPage.queryOrderMoney()
|
}
|
wx.navigateBack({
|
delta:1
|
})
|
})
|
}else{
|
prevPage.setData({
|
endLocation:self.name,
|
endInfo:startInfo,
|
lineDestinationId
|
},()=>{
|
if(this.data.type!=1){
|
prevPage.queryOrderMoney()
|
}
|
wx.navigateBack({
|
delta:1
|
})
|
})
|
}
|
return true
|
}
|
if(!silentInvalid){
|
app.showToastSuccess('该位置不在有效范围内，请重新选择',null,'none',1500)
|
}
|
return false
|
}
|
app.showToastSuccess(data.msg,null,'none',1500)
|
return false
|
},
|
async queryEndLocationLineDestinations(silentInvalid){
|
const startId = this.data.startSiteId
|
const endId = this.data.endSiteId || this.data.userId
|
if(!startId || !endId){
|
return true
|
}
|
try{
|
const res = await queryFirstLineDestinations(startId, endId)
|
const data = res.data || {}
|
if(data.code == 200){
|
return true
|
}
|
if(!silentInvalid){
|
app.showToastSuccess(data.msg || '终点线路信息获取失败',null,'none',1500)
|
}
|
return false
|
}catch(error){
|
if(!silentInvalid){
|
app.showToastSuccess('终点线路信息获取失败',null,'none',1500)
|
}
|
return false
|
}
|
},
|
async getCurrentLocationInfo(updateMap){
|
if(this.data.locatingCurrent){
|
return null
|
}
|
this.setData({
|
locatingCurrent: true
|
})
|
try{
|
const locationRes = await new Promise((resolve, reject) => {
|
wx.getLocation({
|
type: 'gcj02',
|
success: resolve,
|
fail: reject
|
})
|
})
|
const latitude = locationRes.latitude
|
const longitude = locationRes.longitude
|
const regeoRes = await this.reverseGeocode(latitude, longitude)
|
const adcode = regeoRes.addressComponent.adcode || wx.getStorageSync('adcode')
|
const formattedAddress = regeoRes.formattedAddress || '当前位置'
|
const location = `${longitude},${latitude}`
|
if(updateMap){
|
const nearLocationKeyword =
|
formattedAddress ||
|
regeoRes.addressComponent.district ||
|
regeoRes.addressComponent.city ||
|
this.getNearLocationKeyword(formattedAddress)
|
this.setData({
|
longitude,
|
latitude,
|
startLocation: regeoRes.addressComponent.city || regeoRes.addressComponent.district || this.data.startLocation,
|
markers: this.createMarker(latitude, longitude)
|
})
|
this.getNearLocation(nearLocationKeyword, location, false)
|
}
|
return {
|
name: formattedAddress,
|
location,
|
adcode,
|
latitude,
|
longitude
|
}
|
}catch(error){
|
return null
|
}finally{
|
this.setData({
|
locatingCurrent: false
|
})
|
}
|
},
|
async tryAutoLocateCurrentPosition(){
|
if(this.data.where != 'startLocation'){
|
return
|
}
|
if(this.data.hasTriedAutoLocate){
|
return
|
}
|
this.setData({
|
hasTriedAutoLocate: true
|
})
|
const currentLocation = await this.getCurrentLocationInfo(true)
|
if(!currentLocation){
|
app.showToastSuccess('定位失败，请手动选择上车位置',null,'none',1500)
|
return
|
}
|
},
|
handleLocationButtonTap(){
|
this.getCurrentLocationInfo(true).then((currentLocation) => {
|
if(!currentLocation){
|
app.showToastSuccess('定位失败，请手动选择上车位置',null,'none',1500)
|
}
|
})
|
},
|
//cancelAddress
|
cancelAddress() {
|
wx.navigateBack({
|
delta: 1
|
})
|
},
|
//获取 poi
|
getNearLocation(inputValue, location, bloone) {
|
console.log('///////////',location);
|
// let myAmapFun = new amapFile.AMapWX({ key: '22f054fcf175ade2af008875bdd68242' });
|
var myAmapFun = new amapFile.AMapWX({
|
key: 'cea7923a93987b959ab1d2f8ab44d497'
|
});
|
myAmapFun.getInputtips({
|
keywords: inputValue,
|
location: location,
|
success: (res) => {
|
let arr = res.tips.filter(item=>{
|
return item.location.length>0
|
})
|
this.setData({
|
addressList: arr,
|
}, () => {
|
if (bloone || '') {
|
this.init()
|
}
|
})
|
}
|
})
|
},
|
// 用户滑动地图获取中心位置
|
regionchange(e){
|
// 地图发生变化的时候，获取中间点
|
if (e.type == 'end' && (e.causedBy == 'scale' || e.causedBy == 'drag')) {
|
this.mapCtx = wx.createMapContext("mapSelsect");
|
//获取中心坐标 api
|
this.mapCtx.getCenterLocation({
|
type: 'gcj02',
|
success: (res) => {
|
this.setData({
|
isCitys:false,
|
latitude:res.latitude,
|
longitude:res.longitude,
|
markers: this.createMarker(res.latitude, res.longitude),
|
})
|
this.getLocal (res.latitude,res.longitude)
|
}
|
})
|
}
|
},
|
//获取Value
|
getLocal(latitude, longitude) {
|
this.reverseGeocode(latitude, longitude).then((res) => {
|
const addressComponent = res.addressComponent;
|
const formattedAddress = res.formattedAddress;
|
this.setData({
|
startLocation: addressComponent.city || addressComponent.district
|
})
|
let location = longitude + ',' + latitude
|
const nearLocationKeyword =
|
formattedAddress ||
|
addressComponent.district ||
|
addressComponent.city ||
|
this.getNearLocationKeyword(formattedAddress)
|
this.getNearLocation(nearLocationKeyword, location, false)
|
}).catch(() => {
|
app.showToastSuccess('数据获取失败222222222222', null, 'none', 1500)
|
})
|
},
|
|
//点击从哪里上车
|
handelClickFrom() {
|
wx.navigateTo({
|
url: '/pages/getLocation/getLocation?where=' + 'advoad' + '&cityName=' + this.data.startLocation + '&advoadLocation=' + this.data.where + '&abovadStartId=' + this.data.abovadStartId + "&circles=" + JSON.stringify(this.data.circles) + '&polygons=' + JSON.stringify(this.data.polygons),
|
})
|
},
|
//点击poi 跳转到 确定页面
|
async handelClickLocationItem(e) {
|
let self = e.currentTarget.dataset.self
|
await this.confirmSelectedLocation(self)
|
},
|
|
handleDistrict() {
|
return this.fetchFenceData();
|
},
|
//异步操作
|
async init() {
|
try {
|
let res1 = await this.fetchFenceData()
|
let data = res1.data
|
let _circles = []
|
let _polygons = []
|
const fenceList = this.getFenceListFromResponse(res1).map((item) => this.normalizeFenceItem(item))
|
|
if(fenceList.length > 0){
|
this.setData({
|
fenceList,
|
district: fenceList[0].district || this.data.district,
|
startLocation: fenceList[0].city || this.data.startLocation
|
})
|
}else{
|
this.setData({
|
fenceList: []
|
})
|
}
|
if (data.code == 200) {
|
const mainFence = fenceList.find((item) => Number(item.isMain) == 1) || fenceList[0]
|
if (mainFence) {
|
const parsedMainFence = this.parseFenceCoordinate(mainFence)
|
const longitude = mainFence.defaultPointLon || (parsedMainFence && parsedMainFence.centerLongitude) || (parsedMainFence && parsedMainFence.points && parsedMainFence.points[0] && parsedMainFence.points[0].longitude)
|
const latitude = mainFence.defaultPointLat || (parsedMainFence && parsedMainFence.centerLatitude) || (parsedMainFence && parsedMainFence.points && parsedMainFence.points[0] && parsedMainFence.points[0].latitude)
|
if(longitude && latitude){
|
this.setData({
|
markers: this.createMarker(latitude, longitude),
|
longitude,
|
latitude
|
}, () => {
|
this.getLocal(latitude, longitude)
|
})
|
}
|
} else {
|
if(this.data.addressList[0] && this.data.addressList[0].location.length){
|
this.setData({
|
longitude: this.data.addressList[0].location.split(',')[0],
|
latitude: this.data.addressList[0].location.split(',')[1],
|
startLocation: this.data.startLocation1
|
})
|
}else if(this.data.addressList[1] && this.data.addressList[1].location.length){
|
this.setData({
|
longitude: this.data.addressList[1].location.split(',')[0],
|
latitude: this.data.addressList[1].location.split(',')[1],
|
startLocation: this.data.startLocation1
|
})
|
}
|
}
|
fenceList.forEach((x) => {
|
const parsedFence = this.parseFenceCoordinate(x)
|
if (!parsedFence) {
|
return
|
}
|
if (parsedFence.mode == 'circle') {
|
_circles.push({
|
latitude: parsedFence.centerLatitude,
|
longitude: parsedFence.centerLongitude,
|
color: '#7cb5ec88',
|
fillColor: '#7cb5ec88',
|
radius: parsedFence.radius,
|
strokeWidth: 1
|
})
|
} else if (parsedFence.mode == 'polygon') {
|
_polygons.push({
|
points: parsedFence.points,
|
fillColor: "#7cb5ec88",
|
strokeColor: "#7cb5ec88",
|
strokeWidth: 1,
|
zIndex: 1
|
})
|
}
|
})
|
this.setData({
|
circles: _circles,
|
polygons: _polygons
|
},()=>{
|
if(this.data.where == 'startLocation'){
|
this.tryAutoLocateCurrentPosition()
|
}
|
})
|
} else {
|
app.showToastSuccess(data.msg, null, 'none', 1500)
|
}
|
} catch (error) {
|
}
|
},
|
/**
|
* 生命周期函数--监听页面初次渲染完成
|
*/
|
onReady: function () {
|
|
},
|
|
/**
|
* 生命周期函数--监听页面显示
|
*/
|
onShow: function () {
|
|
},
|
|
/**
|
* 生命周期函数--监听页面隐藏
|
*/
|
onHide: function () {
|
|
},
|
|
/**
|
* 生命周期函数--监听页面卸载
|
*/
|
onUnload: function () {
|
|
},
|
|
/**
|
* 页面相关事件处理函数--监听用户下拉动作
|
*/
|
onPullDownRefresh: function () {
|
|
},
|
|
/**
|
* 页面上拉触底事件的处理函数
|
*/
|
onReachBottom: function () {
|
|
},
|
|
/**
|
* 用户点击右上角分享
|
*/
|
onShareAppMessage: function () {
|
|
}
|
})
|
