J1147
/
GpsCardGatewayPosition
Suivre 1
Ajouter aux favoris 0
Bifurcation 0
Code Tickets 0 Demandes d'ajout 0 Versions 0 Wiki Activité
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
13 Révisions
2 Branches
227KB
Branche: develop
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de 'develop'
${ noResults }
GpsCardGatewayPosition/GpsCardGatewayPosition.Service/Resolver/Property/WifiPlus2PositionResolver.cs

923 lignes
45KB
Brut Lien permanent Annotations Historique 

  1. using AutoMapper.Internal;

  2. using GpsCardGatewayPosition.Common;

  3. using GpsCardGatewayPosition.Common.Helper;

  4. using GpsCardGatewayPosition.Model.Config;

  5. using GpsCardGatewayPosition.Model.Context;

  6. using GpsCardGatewayPosition.Model.Enum;

  7. using GpsCardGatewayPosition.Model.IoT;

  8. using GpsCardGatewayPosition.Model.Templates;

  9. using GpsCardGatewayPosition.Service.Biz;

  10. using GpsCardGatewayPosition.Service.Biz.Health;

  11. using GpsCardGatewayPosition.Service.Biz.Location;

  12. using GpsCardGatewayPosition.Service.Biz.Location.Dto;

  13. using GpsCardGatewayPosition.Service.Biz.Location.Dto.Gaode;

  14. using GpsCardGatewayPosition.Service.Biz.Location.Dto.Wayz;

  15. using GpsCardGatewayPosition.Service.Biz.Pay;

  16. using GpsCardGatewayPosition.Service.Biz.Sos;

  17. using GpsCardGatewayPosition.Service.Cache;

  18. using GpsCardGatewayPosition.Service.MqProducer;

  19. using GpsCardGatewayPosition.Service.MqProducer.Model;

  20. using GpsCardGatewayPosition.Service.Resolver.Interface;

  21. using GpsCardGatewayPosition.Service.Resolver.Property.Dto;

  22. using Microsoft.Extensions.Logging;

  23. using Microsoft.Extensions.Options;

  24. using Newtonsoft.Json;

  25. using Newtonsoft.Json.Linq;

  26. using System;

  27. using System.Collections.Generic;

  28. using System.Linq;

  29. using System.Text;

  30. using System.Threading.Tasks;

  31. using TelpoDataService.Util.Entities.GpsCard;

  32. using TelpoDataService.Util.Entities.GpsLocationHistory;

  33. using static GpsCardGatewayPosition.Service.Biz.Location.Dto.Wayz.WayzRequest;

  34. 

  35. namespace GpsCardGatewayPosition.Service.Resolver.Property

  36. {

  37.     public class WifiPlus2PositionResolver : IPropertyResolver

  38.     {

  39.         private readonly ILogger<WifiPlus2PositionResolver> _logger;

  40.         private readonly WifiParamConfig _configWifiParam;

  41. 

  42.         private readonly DeviceCacheManager _deviceCacheMgr;

  43.         private readonly GaodeService _serviceGaode;

  44.         private readonly WayzService _serviceWayz;

  45. 

  46.         private readonly MqProcessLogic _serviceMqProcess;

  47.         private readonly GlobalService _serviceGlobal;

  48.         private readonly PayLogic _servicePay;

  49.         private readonly SosLogic _serviceSos;

  50.         private readonly HealthLogic _serviceHealth;

  51.         private readonly LocationLogic _serviceLocation;

  52. 

  53. 

  54.         private AsyncLocal<string> _messageId = new AsyncLocal<string>();

  55.         private AsyncLocal<PropertyModel> _package = new AsyncLocal<PropertyModel>();

  56.         private AsyncLocal<PropertyItemModel<List<EachWifiPlus2Model>>> _propertyValue = new AsyncLocal<PropertyItemModel<List<EachWifiPlus2Model>>>();

  57.         private AsyncLocal<PackageMsgModel> _packageMsgModel = new AsyncLocal<PackageMsgModel>();

  58. 

  59.         public WifiPlus2PositionResolver(ILogger<WifiPlus2PositionResolver> logger, IOptions<WifiParamConfig> optConfigWifiParam,

  60.             MqProcessLogic serviceMqProcess, GlobalService serviceGlobal, PayLogic servicePay, HealthLogic serviceHealth, LocationLogic serviceLocation,

  61.             WayzService serviceWayz, SosLogic serviceSos, GaodeService serviceGaode, DeviceCacheManager deviceCacheMgr

  62.             )

  63.         {

  64.             _serviceGlobal = serviceGlobal; 

  65.             _servicePay = servicePay;

  66.             _serviceHealth = serviceHealth;

  67.             _serviceLocation = serviceLocation;

  68.             _serviceSos = serviceSos;

  69.             _serviceMqProcess = serviceMqProcess;   

  70. 

  71.             _serviceGaode = serviceGaode;

  72.             _serviceWayz = serviceWayz;

  73.             _deviceCacheMgr = deviceCacheMgr;

  74.             _logger = logger;

  75.             _configWifiParam = optConfigWifiParam.Value;

  76.         }

  77. 

  78.         public void SetResolveInfo(PackageMsgModel msg)

  79.         {

  80.             _messageId.Value = msg.MessageId;

  81.             _package.Value = ((JToken)msg.TopicInfo).ToObject<PropertyModel>()!;

  82.             _propertyValue.Value = ((JToken)msg.DetailData).ToObject<PropertyItemModel<List<EachWifiPlus2Model>>>()!;

  83.         }

  84.         public override string ToString()

  85.         {

  86.             return $"{nameof(WifiPlus2PositionResolver)}[{_messageId.Value}]";

  87.         }

  88.         public async Task ExecuteMessageAsync()

  89.         {

  90.             var package = _package.Value;

  91.             var serialno = package?.DeviceName;  //设备序列号

  92.             var messageId = _messageId.Value;

  93.             var propertyValue = _propertyValue.Value;

  94. 

  95.             var device = await _deviceCacheMgr.GetDeviceBySerialNoAsync(messageId!, serialno!).ConfigureAwait(false);

  96.             if (device == null)

  97.             {

  98.                 _logger.LogError($"非法设备:{serialno}");

  99.                 return;

  100.             }

  101.             //var device = new GpsDevice()

  102.             //{

  103.             //    DeviceId = serialno,

  104.             //};

  105. 

  106. 

  107. 

  108.             DateTime now = DateTime.Now;

  109.             LocationType type = LocationType.LBS;

  110.             foreach (var item in propertyValue!.Value)

  111.             {

  112.                 try

  113.                 {

  114.                     var datetime = Utils.ConvertToLocalDateTime(item.Datetime);

  115.                     var mmac = item.Mmac;

  116.                     var macs = item.Macs;

  117.                     var imei = item.Imei;

  118.                     var smac = item.Smac;

  119.                     var imsi = item.Imsi;

  120.                     var nearbts = item.NearBts;

  121.                     var network = item.Network;

  122.                     var cdma = item.Cdma;

  123.                     var bts = item.Bts;

  124.                     var IDType = item.IdType;

  125.                     var IDNumber = item.IdNumber;

  126.                     var steps = SafeType.SafeInt(item.Steps);       //2分钟内的步数值增量

  127.                     bool isRedressed = false;

  128. 

  129.                     if (imei.Contains("unkonw") || bts.Length == 0) // || nearbts.Length == 0   //紧急修改，应急用

  130.                     {

  131.                         continue;

  132.                     }

  133. 

  134.                     string cityCode = null;

  135.                     string addr = null;

  136.                     string province = null;

  137.                     string city = null;

  138.                     string district = null;

  139.                     decimal olat = 0;

  140.                     decimal olng = 0;

  141.                     decimal baiduLat = 0;

  142.                     decimal baiduLng = 0;

  143.                     decimal gaodeLat = 0;

  144.                     decimal gaodeLng = 0;

  145.                     int radius = 0;

  146.                     decimal[] latLngWifi = new decimal[4];

  147.                     decimal[] latLngLbs = new decimal[4];

  148.                     string hashParam = Guid.NewGuid().ToString();

  149.                     //bool isBtsOnly = false;     //标识第二次主基站lbs查询

  150.                     //bool isBtsOnly = true;     //取消标识第二次主基站lbs查询

  151.                     var WayzFullAddress = string.Empty;

  152. 

  153.                     #region 定位解析

  154.                     //var wifiRequest = new GaodeWifiRequest

  155.                     //{

  156.                     //	//Imei = serialno,

  157.                     //	Macs = macs,

  158.                     //	Mmac = mmac

  159.                     //};

  160.                     //var joWifi = await _serviceGaode.GetGaodeWifiAddressAsync(serialno, wifiRequest).ConfigureAwait(false);

  161. 

  162.                     //var lbsRequest = new GaodeLbsRequest

  163.                     //{

  164.                     //	Bts = bts,

  165.                     //	Cdma = 0,

  166.                     //	//Imei = serialno,

  167.                     //	Imsi = imsi,

  168. 

  169.                     //                   // NearBts = nearbts,

  170.                     //                   // 2022/11/21

  171.                     //                   // 所有的基站定位都采用只使用主基站进行获取高德定位数据。不用nearbts的附近基站定位

  172.                     //                   NearBts = string.Empty,

  173.                     //	Smac = ""

  174.                     //};

  175.                     //var joLbs = await _serviceGaode.GetGaodeLbsAddressAsync(serialno, lbsRequest).ConfigureAwait(false);

  176. 

  177.                     #region 维智地图请求

  178.                     // wayz wifi

  179.                     var wifiWayzItems = new List<WayzRequest.WifiItem>();

  180.                     // 已经接入的wifi mmac:80:8f:1d:bf:45:b1,-70,

  181.                     if (mmac.Split(',').Length > 2)

  182.                     {

  183.                         wifiWayzItems.Add(new WifiItem

  184.                         {

  185.                             Connected = true,

  186.                             SignalStrength = Math.Abs(int.Parse(mmac.Split(',')[1])),

  187.                             MacAddress = mmac.Split(',')[0]

  188.                         });

  189.                     }

  190.                     // wifi 列表 macs:08:9b:4b:b7:b3:5d,-70,|20:6b:e7:7e:4d:30,-70,|8c:a6:df:74:33:15,-74,|74:7d:24:0f:ff:60,-74,|78:44:76:0a:3c:74,-75,|02:0e:5e:ad:5d:d1,-78,|10:a4:be:f6:12:bf,-78,

  191. 

  192.                     if (macs.Split('|').Length > 1)

  193.                     {

  194.                         macs.Split('|').ForAll(mac =>

  195.                         {

  196.                             wifiWayzItems.Add(new WifiItem

  197.                             {

  198.                                 Connected = false,

  199.                                 SignalStrength = Math.Abs(int.Parse(mac.Split(',')[1])),

  200.                                 MacAddress = mac.Split(',')[0]

  201.                             });

  202.                         });

  203.                     }

  204.                     var wifiWayzRequest = new WayzWifiRequest

  205.                     {

  206.                         Location = new LocationDetail

  207.                         {

  208.                             Wifis = wifiWayzItems

  209.                         },

  210.                         Asset = new AssetDevice

  211.                         {

  212.                             Id = serialno,

  213.                             ImeiMd5 = serialno,

  214.                             UniqueId = device.DeviceId

  215.                         }

  216.                     };

  217.                     //wifiWayzRequest.Timestamp = Utils.ConvertToSTimeStamp(Utils.ConvertToLocalDateTime(item.Datetime));

  218.                     //wifiWayzRequest.Asset.Id = serialno;

  219.                     ////wifiWayzRequest.Asset.ImeiMd5 = Convert.ToBase64String(MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(serialno)));

  220.                     //wifiWayzRequest.Asset.ImeiMd5 = serialno;

  221.                     //wifiWayzRequest.Asset.UniqueId = device.DeviceId;

  222.                     var joWayzWifi = await _serviceWayz.GetWayzWifiAddressAsync(serialno, wifiWayzRequest).ConfigureAwait(false);

  223. 

  224.                     // wayz lbs

  225.                     var cellularWayzItems = new List<CellularItem>();

  226.                     // 非cdma：格式为mcc,mnc,lac,cellid,signal。

  227.                     if (cdma == 0)

  228.                     {

  229.                         var mcc = bts.Split(',')[0];

  230.                         var mnc = bts.Split(',')[1];

  231.                         var lac = bts.Split(',')[2];

  232.                         var cellId = bts.Split(',')[3];

  233.                         cellularWayzItems.Add(new CellularItem

  234.                         {

  235.                             CellId = int.Parse(cellId),

  236.                             RadioType = network,

  237.                             MobileCountryCode = int.Parse(mcc),

  238.                             MobileNetworkCode = int.Parse(mnc),

  239.                             LocationAreaCode = int.Parse(lac),

  240.                         });

  241. 

  242.                     }

  243.                     // cdma：格式为sid,nid,bid,lon,lat,signal

  244.                     else

  245.                     {

  246.                         // sid

  247.                         var mnc = bts.Split(',')[0];

  248.                         // bid

  249.                         var cellId = bts.Split(',')[2];

  250.                         // nid

  251.                         var lac = bts.Split(',')[1];

  252. 

  253.                         cellularWayzItems.Add(new CellularItem

  254.                         {

  255.                             CellId = int.Parse(cellId),

  256.                             RadioType = network,

  257.                             //MobileCountryCode = int.Parse(mcc),

  258.                             MobileNetworkCode = int.Parse(mnc),

  259.                             LocationAreaCode = int.Parse(lac),

  260.                         });

  261. 

  262.                     }

  263. 

  264.                     var lbsWayzRequest = new WayzLbsRequest

  265.                     {

  266.                         Location = new LocationDetail

  267.                         {

  268.                             Cellulars = cellularWayzItems

  269.                         },

  270.                         Asset = new AssetDevice

  271.                         {

  272.                             Id = serialno,

  273.                             ImeiMd5 = serialno,

  274.                             UniqueId = device.DeviceId

  275.                         }

  276. 

  277.                     };

  278.                     //lbsWayzRequest.Timestamp = Utils.ConvertToSTimeStamp(Utils.ConvertToLocalDateTime(item.Datetime));

  279.                     //lbsWayzRequest.Asset.Id = serialno;

  280.                     ////lbsWayzRequest.Asset.ImeiMd5 = Convert.ToBase64String(MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(serialno)));

  281.                     //lbsWayzRequest.Asset.ImeiMd5 = serialno;

  282.                     //lbsWayzRequest.Asset.UniqueId = device.DeviceId;

  283.                     var joWayzLbs = await _serviceWayz.GetWayzLbsAddressAsync(serialno, lbsWayzRequest).ConfigureAwait(false);

  284. 

  285.                     #endregion

  286.                     // 只用通过主机站数据查询lbs

  287.                     //if (!joWayzLbs.Flag)

  288.                     //{

  289.                     //                   //通过主机站数据查询lbs

  290.                     //                   //lbsRequest = new GaodeLbsRequest

  291.                     //                   //{

  292.                     //                   //	Bts = bts,

  293.                     //                   //	Cdma = 0,

  294.                     //                   //	Imsi = imsi,

  295.                     //                   //	Smac = "",

  296.                     //                   //};

  297.                     //                   //joLbs = await _serviceGaode.GetGaodeLbsAddressAsync(serialno, lbsRequest).ConfigureAwait(false);

  298.                     //                   joWayzLbs =  await _serviceWayz.GetWayzLbsAddressAsync(serialno, lbsWayzRequest).ConfigureAwait(false);

  299.                     //                   isBtsOnly = true;

  300.                     //	WayzFullAddress = joWayzLbs.FullAddress;

  301. 

  302.                     //               }

  303. 

  304.                     if (joWayzLbs.Flag)

  305.                     {

  306.                         cityCode = joWayzLbs.AdCode;

  307.                         addr = joWayzLbs.Address;

  308.                         province = joWayzLbs.Province;

  309.                         city = joWayzLbs.City;

  310.                         district = joWayzLbs.District;

  311.                         radius = joWayzLbs.Accuracy;

  312. 

  313.                         //lbs对应经纬度

  314.                         latLngLbs = GeoConvert.ConvertGoogleBaiduLatLng(joWayzLbs.Lat, joWayzLbs.Lon);

  315.                         olat = joWayzLbs.Lat;

  316.                         olng = joWayzLbs.Lon;

  317.                         baiduLng = latLngLbs[3];

  318.                         baiduLat = latLngLbs[2];

  319.                         gaodeLng = latLngLbs[1];

  320.                         gaodeLat = latLngLbs[0];

  321.                         hashParam = joWayzLbs.HashParam;

  322.                         WayzFullAddress = joWayzLbs.FullAddress;

  323.                     }

  324. 

  325. 

  326.                     if (joWayzWifi.Flag)    //wifi定位比lbs精准，所以优先采用wifi定位

  327.                     {

  328.                         //wifi对应经纬度

  329.                         latLngWifi = GeoConvert.ConvertGoogleBaiduLatLng(joWayzWifi.Lat, joWayzWifi.Lon);

  330. 

  331.                         //计算wifi和lbs定位结果之间的直线距离

  332.                         //double distance_1st = 0, distance_2nd = 0;

  333.                         double distance_1st = 0;

  334.                         //var distance = distance_1st = joWayzLbs.Flag ? GeoUtils.GetDistance2((double)latLngWifi[1], (double)latLngWifi[0], (double)latLngLbs[1], (double)latLngLbs[0]) : 0;

  335.                         var distance = distance_1st = joWayzLbs.Flag ? GeoUtils.GetDistance2((double)joWayzWifi.Lon, (double)joWayzWifi.Lat, (double)joWayzLbs.Lon, (double)joWayzLbs.Lat) : 0;

  336.                         if (distance >= 1 * 10000)

  337.                         {

  338.                             _logger.LogWarning($"lbs漂移较大 [{joWayzLbs.AdCode}] [{joWayzLbs.Address}]");

  339. 

  340.                             //if (!isBtsOnly)

  341.                             //{

  342.                             //	////通过主机站数据查询lbs

  343.                             //	//lbsRequest = new GaodeLbsRequest

  344.                             //	//{

  345.                             //	//	Bts = bts,

  346.                             //	//	Cdma = 0,

  347.                             //	//	Imsi = imsi,

  348.                             //	//	Smac = "",

  349.                             //	//};

  350.                             //	//joLbs = await _serviceGaode.GetGaodeLbsAddressAsync(serialno, lbsRequest).ConfigureAwait(false);

  351.                             //                         joWayzLbs = await _serviceWayz.GetWayzLbsAddressAsync(serialno, lbsWayzRequest).ConfigureAwait(false);

  352.                             //                         //lbs对应经纬度

  353.                             //                         latLngLbs = GeoConvert.ConvertGoogleBaiduLatLng(joWayzLbs.Lat, joWayzLbs.Lon);

  354.                             //                         //计算wifi和lbs定位结果之间的直线距离

  355.                             //                         //distance = distance_2nd = joWayzLbs.Flag ? GeoUtils.GetDistance2((double)latLngWifi[1], (double)latLngWifi[0], (double)latLngLbs[1], (double)latLngLbs[0]) : 0;

  356.                             //                         distance = distance_2nd = joWayzLbs.Flag ? GeoUtils.GetDistance2((double)joWayzWifi.Lon, (double)joWayzWifi.Lat, (double)joWayzLbs.Lon, (double)joWayzLbs.Lat) : 0;

  357.                             //                         isBtsOnly = true;

  358.                             //                         WayzFullAddress = joWayzLbs.FullAddress;

  359.                             //                     }

  360.                         }

  361. 

  362.                         //2020/12/17山西设备（862622050677507） lbs直径距离大于1公里

  363.                         //讨论结果定为10公里

  364.                         if (distance < 1 * 10000)  //两种定位方式的直线距离小于10km，否则抛弃定位

  365.                         {

  366.                             //cityCode = joWifi.AdCode;

  367.                             //addr = joWifi.Address;

  368.                             //province = joWifi.Province;

  369.                             //city = joWifi.City;

  370.                             //district = joWifi.District;

  371.                             //radius = joWifi.Accuracy;

  372. 

  373.                             //olat = joWifi.Lat;

  374.                             //olng = joWifi.Lon;

  375.                             //baiduLng = latLngWifi[3];

  376.                             //baiduLat = latLngWifi[2];

  377.                             //gaodeLng = latLngWifi[1];

  378.                             //gaodeLat = latLngWifi[0];

  379. 

  380.                             //type = LocationType.WIFI;

  381.                             //hashParam = joWifi.HashParam;

  382. 

  383.                             #region  2022/11/11 增加判断wifi解析的地址是为空或null,就采用LBS的地址解析信息,否则用wifi解析的地址信息

  384.                             /**

  385.                              * 864002050460741 定位解析没有地址信息，入库也无法显示，需要切换LBS解析的处理。

  386.                              */

  387.                             // wifi解析的地址信息有效

  388.                             if (!string.IsNullOrEmpty(joWayzWifi.Address))

  389.                             {

  390.                                 cityCode = joWayzWifi.AdCode;

  391.                                 addr = joWayzWifi.Address;

  392.                                 province = joWayzWifi.Province;

  393.                                 city = joWayzWifi.City;

  394.                                 district = joWayzWifi.District;

  395.                                 radius = joWayzWifi.Accuracy;

  396. 

  397.                                 olat = joWayzWifi.Lat;

  398.                                 olng = joWayzWifi.Lon;

  399.                                 baiduLng = latLngWifi[3];

  400.                                 baiduLat = latLngWifi[2];

  401.                                 gaodeLng = latLngWifi[1];

  402.                                 gaodeLat = latLngWifi[0];

  403. 

  404.                                 type = LocationType.WIFI;

  405.                                 hashParam = joWayzWifi.HashParam;

  406.                                 WayzFullAddress = joWayzWifi.FullAddress;

  407.                             }

  408.                             // wifi解析的地址信息无效,采用LBS的地址信息

  409.                             else if (!string.IsNullOrEmpty(joWayzLbs.Address))

  410.                             {

  411.                                 cityCode = joWayzLbs.AdCode;

  412.                                 addr = joWayzLbs.Address;

  413.                                 province = joWayzLbs.Province;

  414.                                 city = joWayzLbs.City;

  415.                                 district = joWayzLbs.District;

  416.                                 radius = joWayzLbs.Accuracy;

  417. 

  418.                                 olat = joWayzLbs.Lat;

  419.                                 olng = joWayzLbs.Lon;

  420.                                 baiduLng = latLngLbs[3];

  421.                                 baiduLat = latLngLbs[2];

  422.                                 gaodeLng = latLngLbs[1];

  423.                                 gaodeLat = latLngLbs[0];

  424. 

  425.                                 type = LocationType.LBS;

  426.                                 hashParam = joWayzLbs.HashParam;

  427.                                 WayzFullAddress = joWayzLbs.FullAddress;

  428. 

  429.                             }

  430.                             // LBS和Wifi都不能解析地址，不入库

  431.                             else

  432.                             {

  433.                                 return;

  434.                             }

  435.                             #endregion

  436. 

  437.                         }

  438.                         //else

  439.                         //{

  440.                         //	//记录日志

  441.                         //	await _telpoFailureApiClient.AddAsync(new TelpoFailureOperator

  442.                         //	{

  443.                         //		Schema="GaodeLbsError",

  444.                         //		Table=messageId,

  445.                         //		EntityFullname=$"距离 1st={distance_1st}, 2nd={distance_2nd}",

  446.                         //		OperateType= DelayOperateTypeEnum.Insert,

  447.                         //		OperateTime= datetime,

  448.                         //		CreateTime =DateTime.Now,

  449.                         //		JsonData=JsonConvert.SerializeObject(item),

  450.                         //		State=1,

  451.                         //		ErrorMessage=joLbs.Address

  452.                         //	}, new RequestHeader { RequestId = messageId }).ConfigureAwait(false);

  453.                         //	continue;

  454.                         //}

  455.                     }

  456.                     // 维智不能解析定位调用高德和纠偏

  457.                     else

  458.                     {

  459.                         _logger.LogInformation($"维智服务不能解析wifi数据，将采用高德服务解析");

  460.                         var wifiGaodeRequest = new GaodeWifiRequest

  461.                         {

  462.                             //Imei = serialno,

  463.                             Macs = macs,

  464.                             Mmac = mmac

  465.                         };

  466.                         var joGaodeWifi = await _serviceGaode.GetGaodeWifiAddressAsync(serialno, wifiGaodeRequest);

  467.                         if (joGaodeWifi.Flag)

  468.                         {

  469.                             _logger.LogInformation($"高德服务解析解析wifi定位数据");

  470.                             cityCode = joGaodeWifi.AdCode;

  471.                             addr = joGaodeWifi.Address;

  472.                             province = joGaodeWifi.Province;

  473.                             city = joGaodeWifi.City;

  474.                             district = joGaodeWifi.District;

  475.                             radius = joGaodeWifi.Accuracy;

  476. 

  477.                             olat = joGaodeWifi.Lat;

  478.                             olng = joGaodeWifi.Lon;

  479. 

  480.                             latLngWifi = GeoConvert.ConvertGoogleBaiduLatLng(joGaodeWifi.Lat, joGaodeWifi.Lon);

  481. 

  482.                             baiduLng = latLngWifi[3];

  483.                             baiduLat = latLngWifi[2];

  484.                             gaodeLng = latLngWifi[1];

  485.                             gaodeLat = latLngWifi[0];

  486. 

  487.                             type = LocationType.WIFI;

  488.                             hashParam = joGaodeWifi.HashParam;

  489. 

  490.                             WayzFullAddress = string.Format("{0}|{1}", "_Gaode", joGaodeWifi.Address);

  491. 

  492.                             //调用维智纠偏

  493.                             //await _serviceWayz.WayzWifiCalbration(wifiWayzRequest);

  494.                             /** 高德wifi与维智LBS对比

  495.                             latLngWifi = GeoConvert.ConvertGoogleBaiduLatLng(joWayzWifi.Lat, joWayzWifi.Lon);

  496.                             double distance_1st = 0;

  497.                             //var distance = distance_1st = joWayzLbs.Flag ? GeoUtils.GetDistance2((double)latLngWifi[1], (double)latLngWifi[0], (double)latLngLbs[1], (double)latLngLbs[0]) : 0;

  498.                             var distance = distance_1st = joWayzLbs.Flag ? GeoUtils.GetDistance2((double)joGaodeWifi.Lon, (double)joGaodeWifi.Lat, (double)joWayzLbs.Lon, (double)joWayzLbs.Lat) : 0;

  499.                             if (distance >= 1 * 10000)

  500.                             {

  501.                                 _logger.LogWarning($"lbs漂移较大 [{joWayzLbs.AdCode}] [{joWayzLbs.Address}]");

  502.                             }

  503. 

  504.                             if (distance < 1 * 10000)

  505.                             {

  506.                                 cityCode = joGaodeWifi.AdCode;

  507.                                 addr = joGaodeWifi.Address;

  508.                                 province = joGaodeWifi.Province;

  509.                                 city = joGaodeWifi.City;

  510.                                 district = joGaodeWifi.District;

  511.                                 radius = joGaodeWifi.Accuracy;

  512. 

  513.                                 olat = joGaodeWifi.Lat;

  514.                                 olng = joGaodeWifi.Lon;

  515.                                 baiduLng = latLngWifi[3];

  516.                                 baiduLat = latLngWifi[2];

  517.                                 gaodeLng = latLngWifi[1];

  518.                                 gaodeLat = latLngWifi[0];

  519. 

  520.                                 type = LocationType.WIFI;

  521.                                 hashParam = joGaodeWifi.HashParam;

  522. 

  523.                                 WayzFullAddress = string.Format("{0}|{1}", "_Gaode", joGaodeWifi.Address);

  524.                             }

  525. 							*/

  526.                         }

  527.                         else

  528.                         {

  529.                             _logger.LogInformation($"维智服务和高德服务解析都不能解析wifi定位数据");

  530.                         }

  531. 

  532.                     }

  533. 

  534.                     //处理业务

  535.                     var positionStatus = await _deviceCacheMgr.GetPositionStatusCacheAsync(imei).ConfigureAwait(false);

  536.                     var eachParam = mmac.Split(',');

  537.                     var signal = Convert.ToInt32(eachParam[1]);  //主wifi信号强度值

  538. 

  539.                     if (positionStatus?.LastPosition != null)

  540.                     {

  541.                         if (!joWayzLbs.Flag && !joWayzWifi.Flag)

  542.                         {

  543.                             if (joWayzLbs.CanRetry || joWayzWifi.CanRetry)

  544.                             {

  545.                                await _serviceWayz.SendRealtimeLocationAsync(serialno, Utils.ConvertToLocalDateTime(propertyValue.Time), RealtimeLocationTypeFlag.All);

  546.                             }

  547.                             // 2022/11/29 高德解析不了地址，丢弃不入库，但写日志

  548.                             // isRedressed = true;

  549.                             _logger.LogInformation($"设备{serialno}，{nameof(WifiPlus2PositionResolver)} 解析不了地址，丢弃不入库，但写日志");

  550.                             return;

  551.                         }

  552.                         //2022/11/07 取消LBS覆盖操作（HW） 统一都按LBS定位处理，作为无效定位，不更新定位数据，只更新时间

  553.                         //2022/07/19新需求：少于步数增量阈值的lbs定位需要用上一次成功定位点的值替换，并入库

  554.                         // if (type == LocationType.LBS && steps < _configWifiParam.ThresholdSteps)

  555.                         //{

  556.                         //	isRedressed = true;

  557.                         //}

  558. 

  559.                         // 2022/11/29 高德解析不了地址，丢弃不入库，但写日志

  560.                         // 2022/11/11 可能存在不是 LBS和wifi都解析地址就使用缓存的数据

  561.                         //if (isRedressed)

  562.                         //{

  563.                         //	var pos = positionStatus.LastPosition;

  564.                         //	type = (LocationType)pos.LocationType;

  565.                         //	radius = pos.Radius;

  566.                         //	addr = pos.Address;

  567.                         //	baiduLat = pos.BaiduLat;

  568.                         //	baiduLng = pos.BaiduLon;

  569.                         //	olat = pos.OriginalLat;

  570.                         //	olng = pos.OriginalLon;

  571.                         //	gaodeLat = pos.GaodeLat;

  572.                         //	gaodeLng = pos.GaodeLon;

  573.                         //	province = pos.Province;

  574.                         //	city = pos.City;

  575.                         //	district = pos.District;

  576.                         //}

  577.                     }

  578. 

  579.                     ////******2022/04/24 领导决定不采用最后一次有效定位填充当前无效定位值

  580.                     //if (signal > -70)  //主wifi信号强度

  581.                     //{

  582. 

  583.                     //}

  584.                     //else if (type == LocationType.WIFI && radius > Consts.RadiusThreshold)

  585.                     //{

  586.                     //	var cachePosition = positionStatus?.LastPosition;

  587.                     //	if (cachePosition != null)

  588.                     //	{

  589.                     //		// 如果主mac信号强度小于-70,则进行距离判断

  590.                     //		// 计算当前wifi点和上一个可信点之间的直线距离

  591.                     //		var positionDistance = GeoUtils.GetDistance2((double)cachePosition.GaodeLon, (double)cachePosition.GaodeLat, (double)latLngWifi[1], (double)latLngWifi[0]);

  592.                     //		//换算步数之间的距离

  593.                     //		var movingDistance = Utils.GetMovingDistance(steps, _configWifiParam);

  594.                     //		//位置的确发生了变化的情况

  595.                     //		// positionDistance大于100米同时步数距离大于100米，其他情况都认为没有动

  596.                     //		if (positionDistance >= 100 && movingDistance >= 100)  //使用新点，用新点更新缓存，认为设备移动了

  597.                     //		{

  598. 

  599.                     //		}

  600.                     //		else //取上一个可信点，认为设备没有移动

  601.                     //		{

  602.                     //			addr = cachePosition.Address;

  603.                     //			olat = cachePosition.OriginalLat;

  604.                     //			olng = cachePosition.OriginalLon;

  605.                     //			baiduLng = cachePosition.BaiduLon;

  606.                     //			baiduLat = cachePosition.BaiduLat;

  607.                     //			gaodeLat = cachePosition.GaodeLat;

  608.                     //			gaodeLng = cachePosition.GaodeLon;

  609.                     //			cityCode = cachePosition.CityCode;

  610.                     //			radius = cachePosition.Radius;

  611.                     //		}

  612.                     //	}

  613.                     //}

  614. 

  615.                     #endregion

  616. 

  617.                     #region 保存历史轨迹

  618.                     var loc = new LocationInfo

  619.                     {

  620.                         LocationId = Guid.NewGuid().ToString("D"),

  621.                         Address = addr,

  622.                         BaiduLat = baiduLat,

  623.                         BaiduLng = baiduLng,

  624.                         OLat = olat,

  625.                         OLng = olng,

  626.                         GLat = gaodeLat,

  627.                         GLng = gaodeLng,

  628.                         Course = 0,

  629.                         DeviceId = device.DeviceId,

  630.                         DeviceStatus = radius.ToString(),

  631.                         IsStop = false,

  632.                         LastUpdate = Utils.ConvertToLocalDateTime(propertyValue.Time),    //LastUpdate = datetime,

  633.                         UtcDate = Utils.ConvertToUtcDateTime(propertyValue.Time),         //UtcDate = datetime.ToUniversalTime(),

  634.                         LocationType = (int)type,

  635.                         Remarks = cityCode,

  636.                         SerialNo = serialno,

  637.                         Speed = 0,

  638.                         Postcode = cityCode,

  639.                         IsRedressed = isRedressed,

  640.                         HashParam = hashParam,

  641.                         Province = province,

  642.                         City = city,

  643.                         District = district

  644.                     };

  645.                     loc.Remarks = string.Format("Wayz_WifiPlus2|{0}", WayzFullAddress);

  646. 

  647. 

  648.                     var requestPositionData = new object();

  649.                     if (loc.LocationType == 2)

  650.                     {

  651.                         var requestLbsPositionData = new RequestLocationInfo<WayzLbsRequest>

  652.                         {

  653.                             MapSource = 2,

  654.                             RequestLocationType = loc.LocationType,

  655.                             RequestData = lbsWayzRequest

  656.                         };

  657.                         requestPositionData = requestLbsPositionData;

  658.                     }

  659. 

  660.                     if (loc.LocationType == 3)

  661.                     {

  662.                         var requestWifiPositionData = new RequestLocationInfo<WayzWifiRequest>

  663.                         {

  664.                             MapSource = 2,

  665.                             RequestLocationType = loc.LocationType,

  666.                             RequestData = wifiWayzRequest

  667.                         };

  668.                         requestPositionData = requestWifiPositionData;

  669.                     }

  670. 

  671. 

  672. 

  673.                     // 2022/11/23 定位缓存需要增加步数字段实现前端“静止/行走”状态展示,增加了steps参数

  674.                     var result = await _serviceLocation.AddLocationAsync(messageId, loc, positionStatus, propertyValue.Time, cityCode, steps, requestPositionData).ConfigureAwait(false);

  675.                     if (!result.IsSuccess)

  676.                     {

  677.                         _logger.LogError($"{result.Message}");

  678.                         return;

  679.                     }

  680.                     #endregion

  681. 

  682.                     if (radius <= Consts.RadiusThreshold)   //新需求：有效定位才做围栏判断

  683.                     {

  684.                         #region 处理围栏

  685.                         //过滤历史定位

  686.                         //if (!result.IsHistoryLocation)

  687.                         //{

  688.                         //    _serviceLocation.ProcessGeofence(loc, messageId);

  689.                         //}

  690.                         //else

  691.                         //{

  692.                         //    _logger.LogInformation($"设备{serialno}，收到历史定位");

  693.                         //}

  694.                         #endregion

  695.                     }

  696. 

  697.                     #region 保存最后位置信息

  698.                     var context = "online=1";

  699.                     var deviceStatus = await _deviceCacheMgr.GetDeviceStatusBySerialNoAsync(messageId, serialno).ConfigureAwait(false);

  700.                     var statusContext = new DeviceStatus();

  701.                     if (deviceStatus != null)

  702.                     {

  703.                         statusContext.Deserlize(deviceStatus.DeviceStatus);

  704.                     }

  705.                     statusContext.Deserlize(context);

  706. 

  707.                     //重新构建设备状态数据

  708.                     deviceStatus = new GpsDeviceStatus

  709.                     {

  710.                         Address = addr,

  711.                         IsStop = (bool)loc.IsStop,

  712.                         BaiduLat = baiduLat,

  713.                         BaiduLng = baiduLng,

  714.                         Olat = olat,

  715.                         Olng = olng,

  716.                         Glat = gaodeLat,

  717.                         Glng = gaodeLng,

  718.                         Course = loc.Course,

  719.                         DeviceId = loc.DeviceId,

  720.                         DeviceStatus = statusContext.ToString(),

  721.                         DeviceUtcTime = loc.UtcDate,

  722.                         LastUpdate = loc.LastUpdate,

  723.                         LocationType = loc.LocationType,

  724.                         Remarks = loc.LocationId,

  725.                         Serialno = loc.SerialNo,

  726.                         //Speed = loc.Speed,

  727.                         Speed = SafeType.SafeInt(loc.DeviceStatus)

  728.                     };

  729. 

  730.                     var updateOper = await _serviceLocation.UpdateDeviceStatusAsync(messageId, deviceStatus).ConfigureAwait(false);

  731.                     if (!updateOper.IsSuccess)

  732.                     {

  733.                         _logger.LogError($"{updateOper.Message}");

  734.                         return;

  735.                     }

  736. 

  737.                     //THOMAS Kafka

  738.                     var positionData = new LocationDatas()

  739.                     {

  740.                         imei = loc.SerialNo,

  741.                         altitude = 0,

  742.                         address = loc.Address,

  743.                         baiduLatitude = loc.BaiduLat,

  744.                         baiduLongitude = loc.BaiduLng,

  745.                         gaodeLatitude = loc.GLat,

  746.                         gaodeLongitude = loc.GLng,

  747.                         originalLatitude = loc.OLat,

  748.                         originalLongitude = loc.OLng,

  749.                         locationType = loc.LocationType,

  750.                         postcode = loc.Postcode,

  751.                         hashParam = loc.HashParam,

  752.                         radius = radius,

  753.                         province = province,

  754.                         city = city,

  755.                         district = district

  756.                     };

  757.                     //await _serviceMqProcess.ProcessPositionAsync(messageId, positionData, loc.LastUpdate.Value.ToString("yyyy-MM-dd HH:mm:ss"), string.Join("|", wifiWayzItems.AsEnumerable().Select(i=>i.MacAddress)));

  758.                     await _serviceMqProcess.ProcessPositionAsync(messageId, positionData, loc.LastUpdate.Value.ToString("yyyy-MM-dd HH:mm:ss"), $"{mmac}|{macs}");

  759.                     #endregion

  760. 

  761.                     #region 更新Alarm

  762.                     if (IDType == (int)IdType.Sos && !string.IsNullOrWhiteSpace(IDNumber))

  763.                     {

  764.                         // THOMAS  Kafka

  765.                         //var SOSAlarm = new SoSTemplates()

  766.                         //{

  767.                         //	imei = serialno,

  768.                         //	sosId = IDNumber,

  769.                         //	address = loc.Address,

  770.                         //	info = "您的宝贝在求救",

  771.                         //	baiduLatitude = loc.BaiduLat,

  772.                         //	baiduLongitude = loc.BaiduLng,

  773.                         //	gaodeLatitude = loc.GLat,

  774.                         //	gaodeLongitude = loc.GLng,

  775.                         //	originalLatitude = loc.OLat,

  776.                         //	originalLongitude = loc.OLng,

  777.                         //};

  778.                         //_serviceMqProcess.ProcessAlarmSos(messageId, SOSAlarm, loc.LastUpdate.Value.ToString("yyyy-MM-dd HH:mm:ss"));

  779. 

  780.                         var sosId = IDNumber;

  781. 

  782.                         await _serviceSos.HandleSosAddressAsync(messageId, sosId, propertyValue.Time, () => new HisGpsAlarm

  783.                         {

  784.                             DeviceId = device.DeviceId,

  785.                             MessageId = sosId,

  786.                             Serialno = serialno,

  787.                             TypeId = (int)AlarmType.SosAlarm,

  788.                             CreateTime = DateTime.Now,

  789.                             DeviceUtcTime = Utils.ConvertToUtcDateTime(propertyValue.Time),

  790. 

  791.                             Olat = loc.OLat,

  792.                             Olng = loc.OLng,

  793.                             BaiduLat = loc.BaiduLat,

  794.                             BaiduLng = loc.BaiduLng,

  795.                             Glat = loc.GLat,

  796.                             Glng = loc.GLng

  797.                         },

  798.                         a =>

  799.                         {

  800.                             a.Olat = loc.OLat;

  801.                             a.Olng = loc.OLng;

  802.                             a.BaiduLat = loc.BaiduLat;

  803.                             a.BaiduLng = loc.BaiduLng;

  804.                             a.Glat = loc.GLat;

  805.                             a.Glng = loc.GLng;

  806.                             return a;

  807.                         },

  808.                         async () => {

  809.                             var SOSAlarm = new SoSTemplates()

  810.                             {

  811.                                 imei = serialno,

  812.                                 sosId = IDNumber,

  813.                                 address = loc.Address,

  814.                                 info = "您的宝贝在求救",

  815.                                 baiduLatitude = loc.BaiduLat,

  816.                                 baiduLongitude = loc.BaiduLng,

  817.                                 gaodeLatitude = loc.GLat,

  818.                                 gaodeLongitude = loc.GLng,

  819.                                 originalLatitude = loc.OLat,

  820.                                 originalLongitude = loc.OLng,

  821.                             };

  822.                             await _serviceMqProcess.ProcessAlarmSosAsync(messageId, SOSAlarm, loc.LastUpdate.Value.ToString("yyyy-MM-dd HH:mm:ss"));

  823.                         });

  824.                     }

  825.                     else if (IDType == (int)IdType.PayLog && !string.IsNullOrWhiteSpace(IDNumber))

  826.                     {

  827.                         var payId = IDNumber;

  828.                         var pay = await _servicePay.GetPayLogAsync(messageId, $"{serialno}-{payId}").ConfigureAwait(false);

  829. 

  830.                         if (pay == null)

  831.                         {

  832.                             pay = new GpsPayLog

  833.                             {

  834.                                 Serialno = serialno,

  835.                                 Payid = $"{serialno}-{payId}",

  836.                                 DeviceId = device.DeviceId,

  837. 

  838.                                 Olat = loc.OLat,

  839.                                 Olng = loc.OLng,

  840.                                 BaiduLat = loc.BaiduLat,

  841.                                 BaiduLng = loc.BaiduLng,

  842.                                 Glat = loc.GLat,

  843.                                 Glng = loc.GLng

  844.                             };

  845.                             await _servicePay.AddPayLogAsync(messageId, pay).ConfigureAwait(false);

  846.                         }

  847.                         else

  848.                         {

  849.                             pay.Olat = loc.OLat;

  850.                             pay.Olng = loc.OLng;

  851.                             pay.BaiduLat = loc.BaiduLat;

  852.                             pay.BaiduLng = loc.BaiduLng;

  853.                             pay.Glat = loc.GLat;

  854.                             pay.Glng = loc.GLng;

  855.                             await _servicePay.UpdatePayLogAsync(messageId, pay).ConfigureAwait(false);

  856.                         }

  857.                     }

  858.                     else if (IDType == (int)IdType.Temperature && !string.IsNullOrWhiteSpace(IDNumber))  //温度上报（带地址）

  859.                     {

  860.                         var tempId = IDNumber;

  861.                         //var hisTemp = await _serviceHealth.GetTemperatureAsync(messageId, $"{serialno}-{tempId}").ConfigureAwait(false);

  862. 

  863.                         //if (hisTemp == null)

  864.                         //{

  865.                         //	hisTemp = new HisGpsTemperature

  866.                         //	{

  867.                         //		Serialno = serialno,

  868.                         //		TemperatureId = $"{serialno}-{tempId}",

  869.                         //		TempId = tempId,

  870.                         //		Address = addr,

  871.                         //	};

  872.                         //	await _serviceHealth.AddTemperatureAsync(messageId, hisTemp).ConfigureAwait(false);

  873.                         //}

  874.                         //else

  875.                         //{

  876.                         //	hisTemp.Address = addr;

  877.                         //	await _serviceHealth.UpdateTemperatureAsync(messageId, hisTemp).ConfigureAwait(false);

  878.                         //}

  879. 

  880.                         //_serviceMqProcess.ProcessCommonInfo(messageId, DeviceInfoFlagType.Temperature, propertyValue.Time, propertyValue.Value, serialno);

  881. 

  882.                         await _serviceHealth.HandleTemperatureAddressAsync(messageId, $"{serialno}-{tempId}", () => new HisGpsTemperature

  883.                         {

  884.                             TemperatureId = $"{serialno}-{tempId}",

  885.                             Serialno = serialno,

  886.                             Address = addr,

  887.                             Province = province,

  888.                             City = city,

  889.                             District = district,

  890.                             LastUpdate = Utils.ConvertToLocalDateTime(propertyValue.Time),

  891.                             TempId = tempId

  892.                         },

  893.                         a =>

  894.                         {

  895.                             a.Address = addr;

  896.                             a.Province = province;

  897.                             a.City = city;

  898.                             a.District = district;

  899.                             return a;

  900.                         },

  901.                         //2022/11/10 增加 type 参数判断定位类型

  902.                         null,

  903.                         type

  904.                         );

  905.                     }

  906.                     #endregion

  907. 

  908.                     //推送数据到设备

  909.                     await _serviceGlobal.PushLocationDataAsync(serialno, olat, olng);

  910. 

  911.                 }

  912.                 catch (Exception ex)

  913.                 {

  914. 

  915.                     _logger.LogError($"ProcessWifiPlus2Info[异常], Item: {JsonConvert.SerializeObject(item)}\n {ex.Message}, {ex.StackTrace}");

  916.                 }

  917.             }

  918.         }

  919. 

  920. 

  921.     }

  922. }