示例#1
0
        public async Task <GeoResult> ResolveIpAsync(string ip, CancellationToken cancellationToken = new CancellationToken())
        {
            if (String.IsNullOrEmpty(ip) || (!ip.Contains(".") && !ip.Contains(":")))
            {
                return(null);
            }

            ip = ip.Trim();
            if (ip.IsPrivateNetwork())
            {
                return(null);
            }

            var cacheValue = await _localCache.GetAsync <GeoResult>(ip).AnyContext();

            if (cacheValue.HasValue)
            {
                return(cacheValue.Value);
            }

            GeoResult result   = null;
            var       database = await GetDatabaseAsync(cancellationToken).AnyContext();

            if (database == null)
            {
                return(null);
            }

            try {
                if (database.TryCity(ip, out var city) && city?.Location != null)
                {
                    result = new GeoResult {
                        Latitude  = city.Location.Latitude,
                        Longitude = city.Location.Longitude,
                        Country   = city.Country.IsoCode,
                        Level1    = city.MostSpecificSubdivision.IsoCode,
                        Locality  = city.City.Name
                    };
                }

                await _localCache.SetAsync(ip, result).AnyContext();

                return(result);
            } catch (Exception ex) {
                if (ex is GeoIP2Exception)
                {
                    if (_logger.IsEnabled(LogLevel.Trace))
                    {
                        _logger.LogTrace(ex, ex.Message);
                    }
                    await _localCache.SetAsync <GeoResult>(ip, null).AnyContext();
                }
                else if (_logger.IsEnabled(LogLevel.Error))
                {
                    _logger.LogError(ex, "Unable to resolve geo location for ip: {IP}", ip);
                }

                return(null);
            }
        }
示例#2
0
        private void fetch()
        {
            Response.Clear();
            SpotInfo sinfo = new SpotInfo();

            String key = Request["key"];

            sinfo.Address = key;
            Geocoder   geo    = new Geocoder();
            GeoResult  result = geo.GetGeoResult(sinfo);
            JsonObject jobj   = new JsonObject();

            if (GeoResultStatus.OK.Equals(result.Status))//@since 0.1.1
            {
                jobj.NameValuePair.Add(new JsonObject.nvpair()
                {
                    Name = "lat", Value = result.Results[0].Geometry.Location.Lat
                });
                jobj.NameValuePair.Add(new JsonObject.nvpair()
                {
                    Name = "lng", Value = result.Results[0].Geometry.Location.Lng
                });
            }
            AjaxResponse jresponse = new AjaxResponse();

            jresponse.Status  = "OK";
            jresponse.RawData = jobj;
            jresponse.Msg     = "lat, lng of " + key;
            Response.Write(jresponse.ToString());
            Response.ContentType = "application/json";
        }
示例#3
0
    public static bool TryParse(string input, out GeoResult result)
    {
        result = null;
        if (String.IsNullOrEmpty(input))
        {
            return(false);
        }

        string[] parts = input.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
        if (parts.Length != 2)
        {
            return(false);
        }

        if (!Double.TryParse(parts[0].Trim(), out double latitude) || Double.IsNaN(latitude) || Double.IsInfinity(latitude))
        {
            return(false);
        }

        if (!Double.TryParse(parts[1].Trim(), out double longitude) || Double.IsNaN(longitude) || Double.IsInfinity(longitude))
        {
            return(false);
        }

        result = new GeoResult {
            Latitude = latitude, Longitude = longitude
        };
        return(true);
    }
示例#4
0
        public void PostAndDeleteTests()
        {
            if (!_redisConnectionString.IsNotNullOrEmpty())
            {
                return;
            }
            var rest      = new Rest(_redisConnectionString);
            var testPath1 = "home:test1";
            var testPath2 = "home:test2";

            var testData = new GeoResult()
            {
                City = "London", Country_Code = "GB", Country_Name = "United Kingdom"
            };
            var testDataInStream = StringUtils.GenerateStreamFromString(testData.JsonSerialize());
            var result1          = rest.Post <GeoResult>(testPath1, testData);

            Assert.True(result1?.City == "London");
            Assert.True(rest.Delete <bool>(testPath1));

            var result2 = rest.Post <Stream>(testPath2, testDataInStream);

            Assert.True(result2?.Length > 0);
            Assert.True(rest.Delete <bool>(testPath2));
        }
示例#5
0
        public async System.Threading.Tasks.Task <ActionResult> CustomerLocationAsync(int id)
        {
            Customer customer = db.Customers.Find(id);
            GeoCoderToFindCustomerLocation geoCoderToFindCustomerLocation = new GeoCoderToFindCustomerLocation();
            var splitAddress = customer.StreetAddress.Split(new[] { ' ' }, 4);
            var finalAddress = string.Join("+", splitAddress);

            finalAddress += ",+" + customer.City + ",+" + customer.State;
            geoCoderToFindCustomerLocation.address = finalAddress;
            string              url      = "https://maps.googleapis.com/maps/api/geocode/json?address=" + geoCoderToFindCustomerLocation.address + "&key=" + PrivateKeys.key1;
            HttpClient          client   = new HttpClient();
            HttpResponseMessage response = await client.GetAsync(url);

            string jsonResult = await response.Content.ReadAsStringAsync();

            if (response.IsSuccessStatusCode)
            {
                GeoResult postManJSON = JsonConvert.DeserializeObject <GeoResult>(jsonResult);
                geoCoderToFindCustomerLocation.longit = postManJSON.results[0].geometry.location.lng;
                geoCoderToFindCustomerLocation.latit  = postManJSON.results[0].geometry.location.lat;
                geoCoderToFindCustomerLocation.fullNameAndAddressToPutOnMarker  = customer.FirstName + " " + customer.LastName;
                geoCoderToFindCustomerLocation.fullNameAndAddressToPutOnMarker += ", " + customer.StreetAddress + ", " + customer.City + ", " + customer.State + ", " + customer.ZipCode;
                return(View(geoCoderToFindCustomerLocation));
            }

            return(View());
        }
示例#6
0
        // PUT api/GeoResult/5
        public IHttpActionResult PutGeoResult(int id, GeoResult georesult)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != georesult.Id)
            {
                return(BadRequest());
            }

            db.Entry(georesult).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!GeoResultExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
示例#7
0
        public async Task <IActionResult> All()
        {
            var items = await UnitOfWork.Repository <GeoData>()
                        .GetListAsync();

            return(Ok(items.Select(obj => GeoResult.Create(obj))));
        }
示例#8
0
        public override async Task EventBatchProcessingAsync(ICollection <EventContext> contexts)
        {
            var geoGroups = contexts.GroupBy(c => c.Event.Geo);

            foreach (var group in geoGroups)
            {
                GeoResult result;
                if (GeoResult.TryParse(group.Key, out result) && result.IsValid())
                {
                    group.ForEach(c => UpdateGeoAndlocation(c.Event, result, false));
                    continue;
                }

                // The geo coordinates are all the same, set the location from the result of any of the ip addresses.
                if (!String.IsNullOrEmpty(group.Key))
                {
                    var ips = group.SelectMany(c => c.Event.GetIpAddresses()).Union(new[] { group.First().EventPostInfo?.IpAddress }).Distinct();
                    result = await GetGeoFromIpAddressesAsync(ips).AnyContext();

                    group.ForEach(c => UpdateGeoAndlocation(c.Event, result));
                    continue;
                }

                // Each event could be a different user;
                foreach (var context in group)
                {
                    var ips = context.Event.GetIpAddresses().Union(new[] { context.EventPostInfo?.IpAddress });
                    result = await GetGeoFromIpAddressesAsync(ips).AnyContext();

                    UpdateGeoAndlocation(context.Event, result);
                }
            }
        }
示例#9
0
        private void UpdateGeoAndLocation(PersistentEvent ev, GeoResult result, bool isValidLocation = true)
        {
            ev.Geo = result?.ToString();

            if (result != null && isValidLocation)
            {
                ev.SetLocation(result.ToLocation());
            }
            else
            {
                ev.Data.Remove(Event.KnownDataKeys.Location);
            }
        }
示例#10
0
        async Task <bool> GeoLocation(string location)
        {
            locationList.Clear();

            GeoResult result = await rest.GetGeoResult(location);

            if (result != null)
            {
                if (result.results.Count > 0)
                {
                    foreach (var item in result.results)
                    {
                        var cell = new TextCell()
                        {
                            Text = item.formatted_address,
                        };
                        cell.Tapped += (sender, e) => {
                            double lat = item.geometry.location.lat;
                            double lng = item.geometry.location.lng;
                            if (isHomeSelected)
                            {
                                parent.originPos = new Position(lat, lng);
                                parent.origin    = item.formatted_address;
                                parent.isHomeSet = 2;
                            }
                            else
                            {
                                parent.destinationPos   = new Position(lat, lng);
                                parent.destination      = item.formatted_address;
                                parent.isDestinationSet = 2;
                            }

                            Navigation.PopModalAsync();
                        };
                        locationList.Add(cell);
                    }
                    return(true);
                }
                else
                {
                    Debug.WriteLine("Could not get info of home address");
                    return(false);
                }
            }
            else
            {
                Debug.WriteLine("Geocoder returns no results");
                return(false);
            }
        }
示例#11
0
        public IHttpActionResult DeleteGeoResult(int id)
        {
            GeoResult georesult = db.GeoResults.Find(id);

            if (georesult == null)
            {
                return(NotFound());
            }

            db.GeoResults.Remove(georesult);
            db.SaveChanges();

            return(Ok(georesult));
        }
示例#12
0
        public IHttpActionResult PostGeoResult(GeoResult georesult)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            //Get user ID
            //------------------------------------
            var currentUserId   = User.Identity.GetUserId();
            var currentTeamName = manager.FindById(currentUserId).TeamName;

            //Set user information so we dont have to send it from javascript. Seems like a hacker could hack the guid being sent through ajax.
            //------------------------------------
            georesult.TeamName = currentTeamName;
            georesult.UserId   = currentUserId;

            georesult.Location = DbGeography.FromText("POINT(" + georesult.Longitude + "  " + georesult.Latitude + ")");

            //Get Current Week
            //------------------------------------
            var weekId = db.Week.First().Week_Id;

            //Get GeoMaster by week
            //----------------------
            var geoMasters = db.GeoMasters.Where(x => x.Week == weekId).FirstOrDefault();

            //Get distance between the posted users bullshit guess, and then the real answer
            //----------------------
            var distance = georesult.Location.Distance(geoMasters.Location);

            distance = distance * 0.000621371;
            decimal distaanceAway = (decimal)(distance);

            distaanceAway = Math.Round(distaanceAway, 3);


            //Add the distance to the geoResult model
            //----------------------
            georesult.DistanceAway = distaanceAway;


            db.GeoResults.Add(georesult);
            db.SaveChanges();

            return(CreatedAtRoute("DefaultApi", new { id = georesult.Id }, georesult));
        }
示例#13
0
        public async Task <IActionResult> Get(string id)
        {
            if (ObjectId.TryParse(id, out ObjectId oid))
            {
                var item = await UnitOfWork.Repository <GeoData>()
                           .GetByIdAsync(oid);

                if (item == null)
                {
                    return(NotFound(id));
                }

                return(Ok(GeoResult.Create(item)));
            }

            return(BadRequest());
        }
示例#14
0
        public async Task ReverseGeocodeLookup()
        {
            var service = GetService <IGeocodeService>();

            if (service is NullGeocodeService)
            {
                return;
            }

            Assert.True(GeoResult.TryParse(GREEN_BAY_COORDINATES, out var coordinates));
            var location = await service.ReverseGeocodeAsync(coordinates.Latitude.GetValueOrDefault(), coordinates.Longitude.GetValueOrDefault());

            Assert.Equal("US", location?.Country);
            Assert.Equal("WI", location?.Level1);
            Assert.Equal("Brown County", location?.Level2);
            Assert.Equal("Green Bay", location?.Locality);
        }
示例#15
0
    public static Location ToLocation(this GeoResult result)
    {
        if (result == null)
        {
            return(null);
        }

        if (String.IsNullOrEmpty(result.Country) && String.IsNullOrEmpty(result.Level1) && String.IsNullOrEmpty(result.Level2) && String.IsNullOrEmpty(result.Locality))
        {
            return(null);
        }

        return(new Location {
            Country = result.Country?.Trim(),
            Level1 = result.Level1?.Trim(),
            Level2 = result.Level2?.Trim(),
            Locality = result.Locality?.Trim()
        });
    }
示例#16
0
        public override async Task HandleItemAsync(WorkItemContext context)
        {
            var workItem = context.GetData <SetLocationFromGeoWorkItem>();

            GeoResult result;

            if (!GeoResult.TryParse(workItem.Geo, out result))
            {
                return;
            }

            var location = await _cacheClient.GetAsync <Location>(workItem.Geo, null).AnyContext();

            if (location == null)
            {
                try {
                    result = await _geocodeService.ReverseGeocodeAsync(result.Latitude.GetValueOrDefault(), result.Longitude.GetValueOrDefault()).AnyContext();

                    location = result.ToLocation();
                    await _metricsClient.CounterAsync(MetricNames.UsageGeocodingApi).AnyContext();
                } catch (Exception ex) {
                    Logger.Error().Exception(ex).Message($"Error occurred looking up reverse geocode: {workItem.Geo}").Write();
                }
            }

            if (location == null)
            {
                return;
            }

            await _cacheClient.SetAsync(workItem.Geo, location, TimeSpan.FromDays(3)).AnyContext();

            var ev = await _eventRepository.GetByIdAsync(workItem.EventId).AnyContext();

            if (ev == null)
            {
                return;
            }

            ev.SetLocation(location);
            await _eventRepository.SaveAsync(ev).AnyContext();
        }
示例#17
0
        // GET: Weather
        public ActionResult Index(string location, string dateTime)
        {
            ViewBag.Controller = "Weather";

            if (!User.Identity.IsAuthenticated)
            {
                return(this.RedirectToAction("Index", "Home", new { location = location, dateTime = dateTime }));
            }

            if (location != null)             // empty string is acceptable
            {
                TempDataDictionary data = TempData;
                TempData["geoReport"]     = APIHelper.GetGeoLocation(ref data, location, dateTime);
                TempData["weatherReport"] = APIHelper.GetWeatherForecast(ref data, TempData["geoReport"] as GeoReport);
                TempData = data;

                Query query = new Query()
                {
                    location = TempData["location"] as String,
                    dateTime = TempData["dateTime"] as String
                };
                GeoResult geoResult = new GeoResult()
                {
                    query   = query,
                    geoJson = TempData["geoJson"] as String
                };
                WeatherResult weatherResult = new WeatherResult()
                {
                    query       = query,
                    weatherJson = TempData["weatherJson"] as String
                };
                Session["query"]         = query;
                Session["geoResult"]     = geoResult;
                Session["weatherResult"] = weatherResult;
            }

            List <Query> pastQueries = db.queries.ToList();

            TempData["pastQueries"] = pastQueries;
            return(View(pastQueries));
        }
示例#18
0
        // GET: Weather/Details/5
        public ActionResult Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Query query = db.queries.Find(id);

            GeoResult     geoResult     = db.geoResults.First(g => g.query.Id == query.Id);
            WeatherResult weatherResult = db.weatherResults.First(w => w.query.Id == query.Id);

            string geoJson     = geoResult.geoJson;
            string weatherJson = weatherResult.weatherJson;

            TempData["geoReport"]     = JsonConvert.DeserializeObject <GeoReport>(geoJson);
            TempData["weatherReport"] = JsonConvert.DeserializeObject <WeatherReport>(weatherJson);

            Session["query"] = query;

            return(this.RedirectToAction("Index"));
        }
 public static GeoAddress[] ConvertGeoResultToAddresses(this GeoResult result)
 {
     if (result.Status == ResultStatus.OK)
     {
         return(result.Results
                .Where(r =>
                       r.Formatted_address.HasValue() &&
                       r.Geometry != null &&
                       r.Geometry.Location != null &&
                       r.Geometry.Location.Lng != 0 &&
                       r.Geometry.Location.Lat != 0 &&
                       (r.AddressComponentTypes.Any(type => type == AddressComponentType.Street_address) ||
                        (r.Types.Any(t => _otherTypesAllowed.Any(o => o.ToLower() == t.ToLower())))))
                .Select(ConvertGeoObjectToAddress)
                .ToArray());
     }
     else
     {
         return(new GeoAddress[0]);
     }
 }
示例#20
0
        public async Task <IActionResult> List()
        {
            var oid = GetUserId();

            if (oid.HasValue)
            {
                var items = await UnitOfWork.Repository <GeoData>()
                            .GetListAsync(o => o.UserId == oid.Value);

                if (items.Count() == 0)
                {
                    return(NotFound());
                }

                var result = items.Select(obj => GeoResult.Create(obj));

                return(Ok(result));
            }

            return(BadRequest());
        }
        public async Task <IActionResult> FilterPartnersByRating(MapView mapView, GeoResult geoResult)
        {
            ViewData["IdentityUserId"] = new SelectList(_context.Users, "Id", "Id");
            var userId               = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
            var viewerInDb           = _context.Partners.Where(m => m.IdentityUserId == userId).FirstOrDefault();
            var applicationDbContext = _context.Partners.Include(p => p.IdentityUser);

            mapView.partner = viewerInDb;
            var rating = _context.RateServices.Where(r => r.Rating > 1).First();
            var ds     = _context.DonateServices.Where(s => s.DonateServiceId == rating.DonateServiceId).First();
            //mapView.donateService = ds;
            var part = _context.Partners.Where(p => p.PartnerId == ds.PartnerId);

            //var coords = part.PartnerLat + "," + part.PartnerLong;

            //var coor = part.PartnerLat.First();
            //var coorLang = part.PartnerLong;

            //var part = _context.Partners.Where(p => p.PartnerId == ds.PartnerId);

            return(View(await part.ToListAsync()));
        }
示例#22
0
        public async Task <IActionResult> GetByLocation(double lon, double lat, double distance, string[] tag = null)
        {
            var oid = GetUserId();

            if (!oid.HasValue)
            {
                return(BadRequest());
            }

            var repository = UnitOfWork.GeoRepository <GeoData>();

            var items = await repository.GetByLocationAsync(oid.Value, lon, lat, distance, tag);

            if (items.Count() == 0)
            {
                return(NotFound());
            }

            var result = items.Select(obj => GeoResult.Create(obj));

            return(Ok(result));
        }
示例#23
0
        public override Task EventBatchProcessingAsync(ICollection <EventContext> contexts)
        {
            var geoGroups = contexts.GroupBy(c => c.Event.Geo);

            var tasks = new List <Task>();

            foreach (var group in geoGroups)
            {
                if (GeoResult.TryParse(group.Key, out var result) && result.IsValid())
                {
                    group.ForEach(c => UpdateGeoAndLocation(c.Event, result, false));
                    continue;
                }

                // The geo coordinates are all the same, set the location from the result of any of the ip addresses.
                if (!String.IsNullOrEmpty(group.Key))
                {
                    var ips = group.SelectMany(c => c.Event.GetIpAddresses()).Union(new[] { group.First().EventPostInfo?.IpAddress }).Distinct().ToList();
                    if (ips.Count > 0)
                    {
                        tasks.Add(UpdateGeoInformationAsync(group, ips));
                    }
                    continue;
                }

                // Each event in the group could be a different user;
                foreach (var context in group)
                {
                    var ips = context.Event.GetIpAddresses().Union(new[] { context.EventPostInfo?.IpAddress }).ToList();
                    if (ips.Count > 0)
                    {
                        tasks.Add(UpdateGeoInformationAsync(context, ips));
                    }
                }
            }

            return(Task.WhenAll(tasks));
        }
        public async System.Threading.Tasks.Task <ActionResult> CustomerLocationAsync(int id)
        {
            Customer        customer     = context.Customer.Find(id);
            GeoCoderAddress geoCoderInfo = new GeoCoderAddress();
            var             splitAddress = customer.StreetAddress.Split(new[] { ' ' }, 4);

            geoCoderInfo.address += splitAddress[0] + "+" + splitAddress[1] + "+" + splitAddress[2] + "+" + splitAddress[3] + ",+" + customer.City + ",+" + customer.State;
            string              url      = "https://maps.googleapis.com/maps/api/geocode/json?address=" + geoCoderInfo.address + "&key=" + PrivateKeys.key1;
            HttpClient          client   = new HttpClient();
            HttpResponseMessage response = await client.GetAsync(url);

            string jsonResult = await response.Content.ReadAsStringAsync();

            if (response.IsSuccessStatusCode)
            {
                GeoResult postManJSON = JsonConvert.DeserializeObject <GeoResult>(jsonResult);
                geoCoderInfo.latitudeValue  = postManJSON.results[0].geometry.location.lat;
                geoCoderInfo.longitudeValue = postManJSON.results[0].geometry.location.lng;
                return(View(geoCoderInfo));
            }

            return(View());
        }
示例#25
0
        public ActionResult Create()         //[Bind(Include = "Id,location")] Query query
        {
            Query         query         = Session["query"] as Query;
            GeoResult     geoResult     = Session["geoResult"] as GeoResult;
            WeatherResult weatherResult = Session["weatherResult"] as WeatherResult;

            if (query != null &&
                geoResult != null &&
                weatherResult != null &&
                ModelState.IsValid)
            {
                db.queries.Add(query);
                db.geoResults.Add(geoResult);
                db.weatherResults.Add(weatherResult);
                db.SaveChanges();
                Session.Remove("query");
                Session.Remove("geoResult");
                Session.Remove("weatherResult");
                TempData["errorMessage"] = "Data saved successfully.";
                return(this.RedirectToAction("Index", "Weather"));
            }
            TempData["errorMessage"] = "Could not save data.";
            return(this.RedirectToAction("Index", "Weather"));
        }
示例#26
0
        public async Task <IHttpActionResult> GetSubmitEvent(string projectId = null, int version = 2, string type = null, [UserAgent] string userAgent = null, [QueryStringParameters] IDictionary <string, string[]> parameters = null)
        {
            if (parameters == null || parameters.Count == 0)
            {
                return(StatusCode(HttpStatusCode.OK));
            }

            if (projectId == null)
            {
                projectId = Request.GetDefaultProjectId();
            }

            // must have a project id
            if (String.IsNullOrEmpty(projectId))
            {
                return(BadRequest("No project id specified and no default project was found."));
            }

            var project = await GetProjectAsync(projectId);

            if (project == null)
            {
                return(NotFound());
            }

            // TODO: We could save some overhead if we set the project in the overage handler...
            // Set the project for the configuration response filter.
            Request.SetProject(project);

            string contentEncoding = Request.Content.Headers.ContentEncoding.ToString();
            var    ev = new Event {
                Type = !String.IsNullOrEmpty(type) ? type : Event.KnownTypes.Log
            };

            string identity     = null;
            string identityName = null;

            var exclusions = project.Configuration.Settings.GetStringCollection(SettingsDictionary.KnownKeys.DataExclusions).ToList();

            foreach (var kvp in parameters.Where(p => !String.IsNullOrEmpty(p.Key) && !p.Value.All(String.IsNullOrEmpty)))
            {
                switch (kvp.Key.ToLower())
                {
                case "type":
                    ev.Type = kvp.Value.FirstOrDefault();
                    break;

                case "source":
                    ev.Source = kvp.Value.FirstOrDefault();
                    break;

                case "message":
                    ev.Message = kvp.Value.FirstOrDefault();
                    break;

                case "reference":
                    ev.ReferenceId = kvp.Value.FirstOrDefault();
                    break;

                case "date":
                    DateTimeOffset dtValue;
                    if (DateTimeOffset.TryParse(kvp.Value.FirstOrDefault(), out dtValue))
                    {
                        ev.Date = dtValue;
                    }
                    break;

                case "value":
                    decimal decValue;
                    if (Decimal.TryParse(kvp.Value.FirstOrDefault(), out decValue))
                    {
                        ev.Value = decValue;
                    }
                    break;

                case "geo":
                    GeoResult geo;
                    if (GeoResult.TryParse(kvp.Value.FirstOrDefault(), out geo))
                    {
                        ev.Geo = geo.ToString();
                    }
                    break;

                case "tags":
                    ev.Tags.AddRange(kvp.Value.SelectMany(t => t.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries)).Distinct());
                    break;

                case "identity":
                    identity = kvp.Value.FirstOrDefault();
                    break;

                case "identity.name":
                    identityName = kvp.Value.FirstOrDefault();
                    break;

                default:
                    if (kvp.Key.AnyWildcardMatches(exclusions, true))
                    {
                        continue;
                    }

                    if (kvp.Value.Length > 1)
                    {
                        ev.Data[kvp.Key] = kvp.Value;
                    }
                    else
                    {
                        ev.Data[kvp.Key] = kvp.Value.FirstOrDefault();
                    }

                    break;
                }
            }

            ev.SetUserIdentity(identity, identityName);

            try {
                await _eventPostQueue.EnqueueAsync(new EventPostInfo {
                    MediaType       = Request.Content.Headers.ContentType?.MediaType,
                    CharSet         = Request.Content.Headers.ContentType?.CharSet,
                    ProjectId       = projectId,
                    UserAgent       = userAgent,
                    ApiVersion      = version,
                    Data            = Encoding.UTF8.GetBytes(ev.ToJson(Formatting.None, _jsonSerializerSettings)),
                    ContentEncoding = contentEncoding,
                    IpAddress       = Request.GetClientIpAddress()
                }, _storage);
            } catch (Exception ex) {
                _logger.Error().Exception(ex)
                .Message("Error enqueuing event post.")
                .Project(projectId)
                .Identity(ExceptionlessUser?.EmailAddress)
                .Property("User", ExceptionlessUser)
                .SetActionContext(ActionContext)
                .WriteIf(projectId != Settings.Current.InternalProjectId);

                return(StatusCode(HttpStatusCode.InternalServerError));
            }

            return(StatusCode(HttpStatusCode.OK));
        }
        public BreatheKlerePage()
        {
            InitializeComponent();
            // MapTypes
            var mapTypeValues = new List <MapType>();

            rest = new RESTService();
            foreach (var mapType in Enum.GetValues(typeof(MapType)))
            {
                mapTypeValues.Add((MapType)mapType);
            }
            if (App.Current.Properties.ContainsKey("DID"))
            {
                DID = App.Current.Properties["DID"].ToString();
            }
            isFirstLaunch                           = true;
            map.MapType                             = mapTypeValues[0];
            map.MyLocationEnabled                   = true;
            map.IsTrafficEnabled                    = true;
            map.IsIndoorEnabled                     = false;
            map.UiSettings.CompassEnabled           = true;
            map.UiSettings.RotateGesturesEnabled    = true;
            map.UiSettings.MyLocationButtonEnabled  = true;
            map.UiSettings.IndoorLevelPickerEnabled = false;
            map.UiSettings.ScrollGesturesEnabled    = true;
            map.UiSettings.TiltGesturesEnabled      = false;
            map.UiSettings.ZoomControlsEnabled      = true;
            map.UiSettings.ZoomGesturesEnabled      = true;


            var entryGesture = new TapGestureRecognizer();

            entryGesture.Tapped += Home_Focused;
            entryAddress.GestureRecognizers.Add(entryGesture);

            var destinationGesture = new TapGestureRecognizer();

            destinationGesture.Tapped += Destination_Focused;
            destinationAddress.GestureRecognizers.Add(destinationGesture);

            startPin = new Pin
            {
                Type  = PinType.SavedPin,
                Label = "Start Point",
            };
            endPin = new Pin
            {
                Type  = PinType.Generic,
                Label = "End Point",
            };
            // Map Clicked

            map.MapClicked += async(sender, e) =>
            {
                if (mapMode == 2)
                {
                    destinationPos  = e.Point;
                    endPin.Position = e.Point;

                    GeoResult result = await rest.GetGeoResult(e.Point.Latitude.ToString() + ',' + e.Point.Longitude.ToString());

                    if (result != null)
                    {
                        destinationAddress.Text = result.results[0].formatted_address;
                        destination             = result.results[0].formatted_address;
                        endPin.Address          = result.results[0].formatted_address;
                    }
                    if (map.Pins.Contains(endPin))
                    {
                        map.Pins.Remove(endPin);
                    }
                    map.Pins.Add(endPin);
                    isDestinationSet = 2;
                    await CalculateRoute();
                }
                else if (mapMode == 1)
                {
                    originPos         = e.Point;
                    startPin.Position = e.Point;

                    GeoResult result = await rest.GetGeoResult(e.Point.Latitude.ToString() + ',' + e.Point.Longitude.ToString());

                    if (result != null)
                    {
                        origin            = result.results[0].formatted_address;
                        entryAddress.Text = result.results[0].formatted_address;
                        startPin.Address  = result.results[0].formatted_address;
                    }
                    if (map.Pins.Contains(startPin))
                    {
                        map.Pins.Remove(startPin);
                    }
                    map.Pins.Add(startPin);
                    isHomeSet = 2;
                }

                mapMode = 0;
            };
        }
        async protected override void OnAppearing()
        {
            base.OnAppearing();
            NavigationPage.SetHasNavigationBar(this, false);
            try
            {
                var status = await CrossPermissions.Current.CheckPermissionStatusAsync(Permission.Location);

                if (status != PermissionStatus.Granted)
                {
                    if (await CrossPermissions.Current.ShouldShowRequestPermissionRationaleAsync(Permission.Location))
                    {
                        await DisplayAlert("Need location", "Gunna need that location", "OK");
                    }

                    var results = await CrossPermissions.Current.RequestPermissionsAsync(Permission.Location);

                    //Best practice to always check that the key exists
                    if (results.ContainsKey(Permission.Location))
                    {
                        status = results[Permission.Location];
                    }
                }

                if (status == PermissionStatus.Granted)
                {
                    if (Utils.IsLocationAvailable() && isFirstLaunch)
                    {
                        originPos = await Utils.GetPosition();

                        currentPos = originPos.Latitude + "," + originPos.Longitude;
                        map.MoveToRegion(MapSpan.FromCenterAndRadius(originPos, Distance.FromMeters(5000)));
                        GeoResult result = await rest.GetGeoResult(currentPos);

                        if (result != null)
                        {
                            origin = result.results[0].formatted_address;
                        }
                        else
                        {
                            origin = currentPos;
                        }

                        isHomeSet = 2;
                    }
                }
                else
                {
                    await DisplayAlert("Location Denied", "Can not continue, try again.", "OK");
                }

                if (isFirstLaunch)
                {
                    isFirstLaunch = false;
                }
            }
            catch (Exception ex)
            {
                await DisplayAlert("Error", ex.Message, "OK");
            }

            //Setting up the locations
            if (isHomeSet > 0)
            {
                if (isHomeSet == 1)
                {
                    var result = await rest.GetGeoResult(origin);

                    if (result != null)
                    {
                        originPos = new Position(result.results[0].geometry.location.lat, result.results[0].geometry.location.lng);
                    }
                }

                entryAddress.Text = origin;
                startPin.Address  = origin;
                if (map.Pins.Contains(startPin))
                {
                    map.Pins.Remove(startPin);
                }

                startPin.Position = originPos;
                map.Pins.Add(startPin);
            }

            if (isDestinationSet > 0)
            {
                if (isDestinationSet == 1)
                {
                    var result = await rest.GetGeoResult(destination);

                    if (result != null)
                    {
                        destinationPos = new Position(result.results[0].geometry.location.lat, result.results[0].geometry.location.lng);
                    }
                }
                destinationAddress.Text = destination;
                endPin.Address          = destination;
                if (map.Pins.Contains(endPin))
                {
                    map.Pins.Remove(endPin);
                }
                endPin.Position = destinationPos;
                map.Pins.Add(endPin);
            }
            if (isHomeSet > 0 && isDestinationSet > 0)
            {
                await CalculateRoute();
            }
        }
示例#29
0
        /// <summary>
        ///     Search addresses for the specified name, latitude and longitude.
        /// </summary>
        /// <param name='name'>
        ///     Search criteria, address fragment. Cannot be null or empty
        /// </param>
        /// <param name='latitude'>
        ///     Latitude
        /// </param>
        /// <param name='longitude'>
        ///     Longitude
        /// </param>
        /// <param name="geoResult">
        ///
        /// </param>
        public Address[] Search(string name, double?latitude, double?longitude, string currentLanguage, GeoResult geoResult = null)
        {
            if (name.IsNullOrEmpty())
            {
                return(new Address[0]);
            }

            var geoCodingService = new Geocoding(_geocoder, _appSettings, _popularAddressProvider, _logger);

            var allResults = geoCodingService.Search(name, latitude, longitude, currentLanguage, geoResult);

            return(ProcessAddresses(name, allResults, latitude, longitude, currentLanguage, geoResult));
        }
示例#30
0
        private Address[] ProcessAddresses(string name, IEnumerable <Address> allResults, double?latitude, double?longitude, string currentLanguage, GeoResult geoResult = null)
        {
            IEnumerable <Address> addressesGeocode;
            IEnumerable <Address> addressesPlaces = new Address[0];

            // ReSharper disable CompareOfFloatsByEqualityOperator
            if (latitude.HasValue && longitude.HasValue && (latitude.Value != 0 || longitude.Value != 0))
            // ReSharper restore CompareOfFloatsByEqualityOperator
            {
                addressesGeocode = allResults
                                   .OrderBy(adrs => Position.CalculateDistance(adrs.Latitude, adrs.Longitude, latitude.Value, longitude.Value));
            }
            else
            {
                addressesGeocode = allResults;
            }

            var term = name.FirstOrDefault();
            int n;

            if (!int.TryParse(term + "", out n))
            {
                var nearbyService = new Places(_placeProvider, _appSettings, _popularAddressProvider);

                addressesPlaces = nearbyService.SearchPlaces(name, latitude, longitude, currentLanguage);
            }

            return(addressesGeocode
                   .Take(20)
                   .Concat(addressesPlaces.Take(20))
                   .OrderBy(p => AddressSortingHelper.GetRelevance(p, name, latitude, longitude))
                   .ToArray());
        }