J1147
/
GpsCardGatewayPosition
Sledovat 1
Oblíbit 0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 0 Wiki Aktivita
11 Revize
2 Větve
227KB
Strom: 6c5cc2e807
GpsCardGatewayPosition/GpsCardGatewayPosition.Service/Resolver/Property/WifiPositionResolver.cs

616 lines
26KB
Surový Blame Historie 

  1. using GpsCardGatewayPosition.Model.Config;

  2. using GpsCardGatewayPosition.Model.IoT;

  3. using GpsCardGatewayPosition.Service.Resolver.Interface;

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

  5. using Microsoft.Extensions.Logging;

  6. using Microsoft.Extensions.Options;

  7. using Newtonsoft.Json.Linq;

  8. using Newtonsoft.Json;

  9. using System;

  10. using System.Collections.Generic;

  11. using System.Linq;

  12. using System.Text;

  13. using System.Threading.Tasks;

  14. using GpsCardGatewayPosition.Service.Biz.Location;

  15. using GpsCardGatewayPosition.Service.Cache;

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

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

  18. using TelpoDataService.Util.Entities.GpsCard;

  19. using AutoMapper.Internal;

  20. using GpsCardGatewayPosition.Common.Helper;

  21. using GpsCardGatewayPosition.Common;

  22. using GpsCardGatewayPosition.Model.Enum;

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

  24. using GpsCardGatewayPosition.Service.MqProducer.Model;

  25. using GpsCardGatewayPosition.Model.Context;

  26. using GpsCardGatewayPosition.Service.MqProducer;

  27. using System.Data;

  28. using GpsCardGatewayPosition.Service.Biz.Health;

  29. using TelpoDataService.Util.Entities.GpsLocationHistory;

  30. using GpsCardGatewayPosition.Service.Biz.Pay;

  31. using GpsCardGatewayPosition.Service.Biz.Sos;

  32. using GpsCardGatewayPosition.Model.Templates;

  33. using GpsCardGatewayPosition.Service.Biz;

  34. 

  35. namespace GpsCardGatewayPosition.Service.Resolver.Property

  36. {

  37.     public class WifiPositionResolver : IPropertyResolver

  38.     {

  39.         private readonly ILogger<WifiPositionResolver> _logger;

  40.         private readonly WifiParamConfig _configWifiParam;

  41. 

  42.         private readonly DeviceCacheManager _deviceCacheMgr;

  43.         private readonly GaodeService _serviceGaode;

  44.         private readonly WayzService _serviceWayz;

  45.         private readonly LocationLogic _serviceLocation;

  46.         private readonly MqProcessLogic _serviceMqProcess;

  47.         private readonly HealthLogic _serviceHealth;

  48.         private readonly GlobalService _serviceGlobal;

  49.         private readonly PayLogic _servicePay;

  50.         private readonly SosLogic _serviceSos;

  51. 

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

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

  54.         private AsyncLocal<PropertyItemModel<WifiInfoModel>> _propertyValue = new AsyncLocal<PropertyItemModel<WifiInfoModel>>();

  55. 

  56.         public WifiPositionResolver(ILogger<WifiPositionResolver> logger, IOptions<WifiParamConfig> optWifiParamConfig, GlobalService serviceGlobal, PayLogic servicePay, HealthLogic serviceHealth, MqProcessLogic serviceMqProcess, 

  57.             WayzService serviceWayz, GaodeService serviceGaode, DeviceCacheManager deviceCacheMgr, SosLogic serviceSos, LocationLogic serviceLocation)

  58.         { 

  59.             _serviceGaode = serviceGaode;   

  60.             _serviceWayz = serviceWayz; 

  61.             _deviceCacheMgr = deviceCacheMgr;   

  62.             _serviceLocation = serviceLocation;

  63.             _serviceMqProcess = serviceMqProcess;

  64.             _serviceHealth = serviceHealth;

  65.             _servicePay= servicePay; 

  66.             _serviceSos = serviceSos;

  67.             _serviceGlobal = serviceGlobal;

  68.             _logger = logger;

  69.             _configWifiParam = optWifiParamConfig.Value;

  70. 

  71.         }

  72.         public void SetResolveInfo(PackageMsgModel msg)

  73.         {

  74.             _messageId.Value = msg.MessageId;

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

  76.             _propertyValue.Value = ((JToken)msg.DetailData).ToObject<PropertyItemModel<WifiInfoModel>>()!;

  77.             

  78.             /// throw new NotImplementedException();

  79.         }

  80.         public override string ToString()

  81.         {

  82.             return $"{nameof(WifiPositionResolver)}[{_messageId.Value}]";

  83.         }

  84. 

  85.         public async Task ExecuteMessageAsync()

  86.         {

  87. 

  88.             var package = _package.Value;

  89.             string serialno = package?.DeviceName!;  //设备序列号

  90.             var messageId = _messageId.Value!;

  91.             var propertyValue = _propertyValue.Value!;

  92. 

  93. 

  94.             int IDType = propertyValue!.Value.IDType;

  95.             string IDNumber = propertyValue.Value.IDNumber;

  96.             string mmac = propertyValue.Value.Mmac;

  97.             string macs = propertyValue.Value.macs;

  98. 

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

  100.             var signal = Convert.ToInt32(eachParam[1]);

  101. 

  102.             string cityCode = "";

  103.             string addr = "";

  104.             decimal olat = 0;

  105.             decimal olng = 0;

  106.             decimal baiduLat = 0;

  107.             decimal baiduLng = 0;

  108.             decimal gaodeLat = 0;

  109.             decimal gaodeLng = 0;

  110.             int radius = 0;

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

  112.             string province = null;

  113.             string city = null;

  114.             string district = null;

  115.             var fullAddress = string.Empty;

  116. 

  117.             //throw new NotImplementedException();

  118.             //以下时间段，wifi上报信息不过滤

  119.             var startOne = TimeSpan.Parse(_configWifiParam.StartOne);

  120.             var endOne = TimeSpan.Parse(_configWifiParam.EndOne);

  121.             var startTwo = TimeSpan.Parse(_configWifiParam.StartTwo);

  122.             var endTwo = TimeSpan.Parse(_configWifiParam.EndTwo);

  123. 

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

  125.             //if (device == null)

  126.             //{

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

  128.             //    return;

  129.             //}

  130.             var device = new GpsDevice()

  131.             {

  132.                 DeviceId = serialno,

  133.             };

  134. 

  135. 

  136. 

  137.             #region 定位解析

  138.             var request = new GaodeWifiRequest

  139.             {

  140.                 //Imei = serialno,

  141.                 Macs = macs,

  142.                 Mmac = mmac

  143.             };

  144.             #region wifi

  145.             var wifiItems = new List<WayzRequest.WifiItem>();

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

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

  148.             {

  149.                 wifiItems.Add(new WayzRequest.WifiItem

  150.                 {

  151.                     Connected = true,

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

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

  154.                 });

  155.             }

  156.             // 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,

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

  158.             {

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

  160.                 {

  161.                     wifiItems.Add(new WayzRequest.WifiItem

  162.                     {

  163.                         Connected = false,

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

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

  166.                     });

  167.                 });

  168.             }

  169.             #endregion

  170.             var wayzWifiRequest = new WayzWifiRequest

  171.             {

  172.                 Location = new WayzRequest.LocationDetail

  173.                 {

  174.                     Wifis = wifiItems

  175.                 },

  176.                 Asset = new WayzRequest.AssetDevice

  177.                 {

  178.                     Id = serialno,

  179.                     ImeiMd5 = serialno,

  180.                     UniqueId = device.DeviceId

  181.                 }

  182.             };

  183. 

  184.             var positionStatus = await _deviceCacheMgr.GetPositionStatusCacheAsync(serialno).ConfigureAwait(false);

  185.             //GetGaodePositionServiceResult gaodeResult = null;

  186.             GetWayzPositionServiceResult wayzServiceResult = null;

  187. 

  188.             var timeOfNow = DateTime.Now.TimeOfDay;

  189.             if ((timeOfNow >= startOne && timeOfNow <= endOne) ||

  190.                 (timeOfNow >= startTwo && timeOfNow <= endTwo))   //处于以下时间段，wifi信息不过滤

  191.             {

  192.                 //gaodeResult = await _serviceGaode.GetGaodeWifiAddressAsync(serialno, request).ConfigureAwait(false);

  193.                 wayzServiceResult = await _serviceWayz.GetWayzWifiAddressAsync(serialno, wayzWifiRequest).ConfigureAwait(false);

  194.                 //            if (!wayzServiceResult.Flag)

  195.                 //{

  196.                 //	if (wayzServiceResult.CanRetry) _serviceWayz.SendRealtimeLocationAsync(serialno, Utils.ConvertToLocalDateTime(propertyValue.Time), RealtimeLocationTypeFlag.All);

  197.                 //	return;

  198.                 //}

  199. 

  200. 

  201.                 if (wayzServiceResult.Flag)

  202.                 {

  203.                     province = wayzServiceResult.Province;

  204.                     city = wayzServiceResult.City;

  205.                     district = wayzServiceResult.District;

  206.                     addr = wayzServiceResult.Address;

  207.                     cityCode = wayzServiceResult.CityCode;

  208.                     hashParam = wayzServiceResult.HashParam;

  209.                     fullAddress = wayzServiceResult.FullAddress;

  210.                     olat = wayzServiceResult.Lat;

  211.                     olng = wayzServiceResult.Lon;

  212.                     radius = wayzServiceResult.Accuracy;

  213.                 }

  214.                 else

  215.                 {

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

  217.                     var wifiGaodeRequest = new GaodeWifiRequest()

  218.                     {

  219.                         Macs = macs,

  220.                         Mmac = mmac

  221.                     };

  222.                     var gaodeServiceResult = await _serviceGaode.GetGaodeWifiAddressAsync(serialno, wifiGaodeRequest);

  223.                     if (gaodeServiceResult.Flag)

  224.                     {

  225.                         province = gaodeServiceResult.Province;

  226.                         city = gaodeServiceResult.City;

  227.                         district = gaodeServiceResult.District;

  228.                         addr = gaodeServiceResult.Address;

  229.                         cityCode = gaodeServiceResult.AdCode;

  230.                         hashParam = gaodeServiceResult.HashParam;

  231.                         olat = gaodeServiceResult.Lat;

  232.                         olng = gaodeServiceResult.Lon;

  233.                         radius = gaodeServiceResult.Accuracy;

  234.                         fullAddress = string.Format("{0}|{1}", "_Gaode", gaodeServiceResult.Address);

  235. 

  236.                     }

  237.                     else

  238.                     {

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

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

  241.                         return;

  242.                     }

  243.                 }

  244. 

  245.                 decimal[] latLng = GeoConvert.ConvertGoogleBaiduLatLng(olat, olng);

  246. 

  247.                 baiduLng = latLng[3];

  248.                 baiduLat = latLng[2];

  249.                 gaodeLng = latLng[1];

  250.                 gaodeLat = latLng[0];

  251. 

  252.             }

  253.             else  //以上时间段之外，应用过滤逻辑

  254.             {

  255.                 var cachePosition = positionStatus?.LastPosition;

  256.                 if (signal > -70 || cachePosition == null)

  257.                 {

  258.                     //gaodeResult = await _serviceGaode.GetGaodeWifiAddressAsync(serialno, request).ConfigureAwait(false);

  259.                     wayzServiceResult = await _serviceWayz.GetWayzWifiAddressAsync(serialno, wayzWifiRequest).ConfigureAwait(false);

  260.                     //               if (!wayzServiceResult.Flag)

  261.                     //{

  262.                     //	if (wayzServiceResult.CanRetry) _serviceWayz.SendRealtimeLocationAsync(serialno, Utils.ConvertToLocalDateTime(propertyValue.Time), RealtimeLocationTypeFlag.All);

  263.                     //	return;

  264.                     //}

  265.                     if (wayzServiceResult.Flag)

  266.                     {

  267.                         province = wayzServiceResult.Province;

  268.                         city = wayzServiceResult.City;

  269.                         district = wayzServiceResult.District;

  270.                         addr = wayzServiceResult.Address;

  271.                         cityCode = wayzServiceResult.CityCode;

  272.                         hashParam = wayzServiceResult.HashParam;

  273.                         fullAddress = wayzServiceResult.FullAddress;

  274.                         olat = wayzServiceResult.Lat;

  275.                         olng = wayzServiceResult.Lon;

  276.                         radius = wayzServiceResult.Accuracy;

  277.                     }

  278.                     else

  279.                     {

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

  281.                         var wifiGaodeRequest = new GaodeWifiRequest()

  282.                         {

  283.                             Macs = macs,

  284.                             Mmac = mmac

  285.                         };

  286.                         var gaodeServiceResult = await _serviceGaode.GetGaodeWifiAddressAsync(serialno, wifiGaodeRequest);

  287.                         if (gaodeServiceResult.Flag)

  288.                         {

  289.                             province = gaodeServiceResult.Province;

  290.                             city = gaodeServiceResult.City;

  291.                             district = gaodeServiceResult.District;

  292.                             addr = gaodeServiceResult.Address;

  293.                             cityCode = gaodeServiceResult.AdCode;

  294.                             hashParam = gaodeServiceResult.HashParam;

  295.                             olat = gaodeServiceResult.Lat;

  296.                             olng = gaodeServiceResult.Lon;

  297.                             radius = gaodeServiceResult.Accuracy;

  298.                             fullAddress = string.Format("{0}|{1}", "_Gaode", gaodeServiceResult.Address);

  299. 

  300.                         }

  301.                         else

  302.                         {

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

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

  305.                             return;

  306.                         }

  307.                     }

  308. 

  309.                     decimal[] latLng = GeoConvert.ConvertGoogleBaiduLatLng(olat, olng);

  310. 

  311.                     baiduLng = latLng[3];

  312.                     baiduLat = latLng[2];

  313.                     gaodeLng = latLng[1];

  314.                     gaodeLat = latLng[0];

  315. 

  316. 

  317. 

  318. 

  319. 

  320.                 }

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

  322.                 //else

  323.                 //{

  324.                 //	addr = cachePosition.Address;

  325.                 //	olat = cachePosition.OriginalLat;

  326.                 //	olng = cachePosition.OriginalLon;

  327.                 //	baiduLng = cachePosition.BaiduLon;

  328.                 //	baiduLat = cachePosition.BaiduLat;

  329.                 //	gaodeLat = cachePosition.GaodeLat;

  330.                 //	gaodeLng = cachePosition.GaodeLon;

  331.                 //	cityCode = cachePosition.CityCode;

  332.                 //	radius = cachePosition.Radius;

  333.                 //}

  334.             }

  335. 

  336.             #endregion

  337. 

  338.             #region 保存历史轨迹

  339.             var loc = new LocationInfo

  340.             {

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

  342.                 Address = addr,

  343.                 BaiduLat = baiduLat,

  344.                 BaiduLng = baiduLng,

  345.                 OLat = olat,

  346.                 OLng = olng,

  347.                 GLat = gaodeLat,

  348.                 GLng = gaodeLng,

  349.                 Course = 0,

  350.                 DeviceId = device.DeviceId,

  351.                 DeviceStatus = radius.ToString(),

  352.                 IsStop = false,

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

  354.                 UtcDate = Utils.ConvertToUtcDateTime(propertyValue.Time),

  355.                 LocationType = Convert.ToInt32(LocationType.WIFI),

  356.                 Remarks = cityCode,

  357.                 SerialNo = serialno,

  358.                 Speed = 0,

  359.                 Postcode = cityCode,

  360.                 IsRedressed = false,

  361.                 HashParam = hashParam,

  362.                 Province = province,

  363.                 City = city,

  364.                 District = district

  365.             };

  366.             loc.Remarks = string.Format("Wayz_Wifi|{0}", fullAddress);

  367. 

  368.             if (string.IsNullOrWhiteSpace(loc.Address) || loc.GLng < 1 || loc.GLat < 1)

  369.             {

  370.                 //没有符合定位解析的消息，直接退出

  371.                 return;

  372.             }

  373.             var requestPositionData = new RequestLocationInfo<WayzWifiRequest>

  374.             {

  375.                 MapSource = 2,

  376.                 RequestLocationType = loc.LocationType,

  377.                 RequestData = wayzWifiRequest

  378.             };

  379.             //return;

  380.             var hisResult = await _serviceLocation.AddLocationAsync(messageId, loc, positionStatus, propertyValue.Time, cityCode, null, requestPositionData).ConfigureAwait(false);

  381.             if (!hisResult.IsSuccess)

  382.             {

  383.                 _logger.LogError($"{hisResult.Message}");

  384.                 return;

  385.             }

  386.             #endregion

  387. 

  388.             #region 处理围栏

  389.             //过滤历史定位消息

  390.             //if (!hisResult.IsHistoryLocation)

  391.             //{

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

  393.             //   await _serviceLocation.ProcessGeofenceAsync(loc, messageId);

  394.             //}

  395.             //else

  396.             //{

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

  398.             //}

  399.             #endregion

  400. 

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

  402.             var context = "online=1";

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

  404.             var statusContext = new DeviceStatus();

  405.             if (deviceStatus != null)

  406.             {

  407.                 statusContext.Deserlize(deviceStatus.DeviceStatus);

  408.             }

  409.             statusContext.Deserlize(context);

  410. 

  411.             //重新构造设备状态数据

  412.             deviceStatus = new GpsDeviceStatus

  413.             {

  414.                 Address = addr,

  415.                 IsStop = (bool)loc.IsStop,

  416.                 BaiduLat = baiduLat,

  417.                 BaiduLng = baiduLng,

  418.                 Olat = olat,

  419.                 Olng = olng,

  420.                 Glat = gaodeLat,

  421.                 Glng = gaodeLng,

  422.                 Course = loc.Course,

  423.                 DeviceId = loc.DeviceId,

  424.                 DeviceStatus = statusContext.ToString(),

  425.                 DeviceUtcTime = loc.UtcDate,

  426.                 LastUpdate = loc.LastUpdate,

  427.                 LocationType = loc.LocationType,

  428.                 Remarks = loc.LocationId,

  429.                 Serialno = loc.SerialNo,

  430.                 //Speed = loc.Speed,

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

  432.             };

  433. 

  434.             var result = await _serviceLocation.UpdateDeviceStatusAsync(messageId, deviceStatus).ConfigureAwait(false);

  435.             if (!result.IsSuccess)

  436.             {

  437.                 _logger.LogError($"[{_messageId}] {result.Message}");

  438.                 return;

  439.             }

  440. 

  441.             //THOMAS Kafka

  442.             var positionData = new LocationDatas()

  443.             {

  444.                 imei = loc.SerialNo,

  445.                 altitude = 0,

  446.                 address = loc.Address,

  447.                 baiduLatitude = loc.BaiduLat,

  448.                 baiduLongitude = loc.BaiduLng,

  449.                 gaodeLatitude = loc.GLat,

  450.                 gaodeLongitude = loc.GLng,

  451.                 originalLatitude = loc.OLat,

  452.                 originalLongitude = loc.OLng,

  453.                 locationType = loc.LocationType,

  454.                 postcode = loc.Postcode,

  455.                 hashParam = loc.HashParam,

  456.                 radius = radius,

  457.                 province = province,

  458.                 city = city,

  459.                 district = district

  460.             };

  461. 

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

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

  464. 

  465.             #endregion

  466. 

  467.             #region 更新Alarm

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

  469.             {

  470.                 // THOMAS Kafka

  471.                 //var SOSAlarm = new SoSTemplates()

  472.                 //{

  473.                 //	imei = serialno,

  474.                 //	sosId = IDNumber,

  475.                 //	address = loc.Address,

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

  477.                 //	baiduLatitude = loc.BaiduLat,

  478.                 //	baiduLongitude = loc.BaiduLng,

  479.                 //	gaodeLatitude = loc.GLat,

  480.                 //	gaodeLongitude = loc.GLng,

  481.                 //	originalLatitude = loc.OLat,

  482.                 //	originalLongitude = loc.OLng,

  483.                 //};

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

  485. 

  486.                 var sosId = IDNumber;

  487. 

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

  489.                 {

  490.                     DeviceId = device.DeviceId,

  491.                     MessageId = sosId,

  492.                     Serialno = serialno,

  493.                     CreateTime = DateTime.Now,

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

  495. 

  496.                     Olat = loc.OLat,

  497.                     Olng = loc.OLng,

  498.                     BaiduLat = loc.BaiduLat,

  499.                     BaiduLng = loc.BaiduLng,

  500.                     Glat = loc.GLat,

  501.                     Glng = loc.GLng

  502.                 },

  503.                 a =>

  504.                 {

  505.                     a.Olat = loc.OLat;

  506.                     a.Olng = loc.OLng;

  507.                     a.BaiduLat = loc.BaiduLat;

  508.                     a.BaiduLng = loc.BaiduLng;

  509.                     a.Glat = loc.GLat;

  510.                     a.Glng = loc.GLng;

  511.                     return a;

  512.                 },

  513.                 async () => {

  514.                     var SOSAlarm = new SoSTemplates()

  515.                     {

  516.                         imei = serialno,

  517.                         sosId = IDNumber,

  518.                         address = loc.Address,

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

  520.                         baiduLatitude = loc.BaiduLat,

  521.                         baiduLongitude = loc.BaiduLng,

  522.                         gaodeLatitude = loc.GLat,

  523.                         gaodeLongitude = loc.GLng,

  524.                         originalLatitude = loc.OLat,

  525.                         originalLongitude = loc.OLng,

  526.                     };

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

  528.                 });

  529.             }

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

  531.             {

  532.                 var payId = propertyValue.Value.IDNumber;

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

  534. 

  535.                 if (pay == null)

  536.                 {

  537.                     pay = new GpsPayLog

  538.                     {

  539.                         Serialno = serialno,

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

  541.                         DeviceId = device.DeviceId,

  542. 

  543.                         Olat = loc.OLat,

  544.                         Olng = loc.OLng,

  545.                         BaiduLat = loc.BaiduLat,

  546.                         BaiduLng = loc.BaiduLng,

  547.                         Glat = loc.GLat,

  548.                         Glng = loc.GLng

  549.                     };

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

  551.                 }

  552.                 else

  553.                 {

  554.                     pay.Olat = loc.OLat;

  555.                     pay.Olng = loc.OLng;

  556.                     pay.BaiduLat = loc.BaiduLat;

  557.                     pay.BaiduLng = loc.BaiduLng;

  558.                     pay.Glat = loc.GLat;

  559.                     pay.Glng = loc.GLng;

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

  561.                 }

  562.             }

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

  564.             {

  565.                 var tempId = propertyValue.Value.IDNumber;

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

  567. 

  568.                 //if (hisTemp == null)

  569.                 //{

  570.                 //	hisTemp = new HisGpsTemperature

  571.                 //	{

  572.                 //		Serialno = serialno,

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

  574.                 //		TempId = tempId,

  575. 

  576.                 //		Address = addr,

  577.                 //	};

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

  579.                 //}

  580.                 //else

  581.                 //{

  582.                 //	hisTemp.Address = addr;

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

  584.                 //}

  585. 

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

  587.                 {

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

  589.                     Serialno = serialno,

  590.                     Address = addr,

  591.                     Province = province,

  592.                     City = city,

  593.                     District = district,

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

  595.                     TempId = tempId

  596.                 },

  597.                 a =>

  598.                 {

  599.                     a.Address = addr;

  600.                     a.Province = province;

  601.                     a.City = city;

  602.                     a.District = district;

  603.                     return a;

  604.                 });

  605.             }

  606.             #endregion

  607. 

  608.             //推送数据到设备

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

  610. 

  611.         }

  612. 

  613. 

  614.     }

  615. }