Beispiel #1
0
        public async Task When_fetching_images_the_progress_is_being_updated_and_images_downloaded()
        {
            // Arrange
            var placemark = new MooiPlacemark();
            var group     = new MooiCluster {
                Placemarks = { placemark }
            };
            var document = new MooiDocument {
                Sections = { new MooiSection {
                                 Clusters =  { group}
                             } }
            };
            var tempPath       = "temp-path";
            var overviewBytes  = new byte[] { 0x22 };
            var thumbnailBytes = new byte[] { 0x44 };

            _resourceNameMock.Setup(x => x.CreateFileNameForOverviewMap(group)).Returns("overview-path");
            _resourceNameMock.Setup(x => x.CreateFileNameForPlacemarkThumbnail(placemark)).Returns("thumb-path");
            _hereMock.Setup(x => x.FetchOverviewMap(group))
            .Returns(Task.FromResult(overviewBytes));
            _hereMock.Setup(x => x.FetchThumbnail(placemark))
            .Returns(Task.FromResult(thumbnailBytes));

            // Act
            await _fetcher.Object.FetchMapImages(document, tempPath, _progressMock.Object);

            // Verify
            _fileMock.Verify(x => x.WriteBytesAsync(tempPath + @"\overview-path", overviewBytes));
            _fileMock.Verify(x => x.WriteBytesAsync(tempPath + @"\thumb-path", thumbnailBytes));
            _progressMock.Verify(x => x.ReportFetchImagesCount(1 + 1), Times.Once);
            _progressMock.Verify(x => x.ReportFetchImageProcessed(), Times.Exactly(2));
        }
Beispiel #2
0
        public void ExtendPlacemarkWithVenueData(MooiPlacemark placemark)
        {
            if (placemark.AttachedVenues == null)
            {
                return;
            }

            foreach (var venue in placemark.AttachedVenues)
            {
                switch (venue.SourceType)
                {
                case VenueSource.Here:
                    break;

                case VenueSource.Foursquare:
                    var fsq = venue as FoursquareVenue;
                    if (fsq == null)
                    {
                        continue;
                    }
                    placemark.Images.AddRange(fsq.PhotoUrls.Take(MAX_PHOTOS_TO_PICK_FROM_VENUE));
                    break;

                case VenueSource.Undefined:
                default:
                    throw new ArgumentOutOfRangeException();
                }
            }
        }
Beispiel #3
0
        public async Task <byte[]> FetchThumbnail(MooiPlacemark placemark)
        {
            if (placemark.Type == PlacemarkType.Route)
            {
                throw new NotSupportedException("Routes are not supported");
            }

            var url = $"c={_formatter.FormatCoordinates(null, placemark)}&z={THUMBNAIL_MAP_ZOOM}&ppi=320&w=600&h=390";

            return(await DownloadData(IMAGES_MAPVIEW_URL, url));
        }
Beispiel #4
0
        public void When_creating_model_the_discovered_places_are_appended_correctly()
        {
            // Arrange
            var kmlDocument = new KmlDocument {
                Folders =
                {
                    new KmlFolder(new List <KmlPlacemark> {
                        new KmlPlacemark()
                    })
                }
            };
            var venue = new DummyVenue {
                Title = "venue", IconUrl = new Uri("http://url"), Coordinate = new GeoCoordinate(1, 2)
            };
            var discoveredPlaces = new List <DiscoveredPlace> {
                new DiscoveredPlace {
                    Venue = new DummyVenue(), AttachedToPlacemark = kmlDocument.Folders[0].Placemarks[0]
                },
                new DiscoveredPlace {
                    Venue = venue
                }
            };
            var placemarkExplored = new MooiPlacemark {
                Name        = venue.Title,
                IconPath    = venue.IconUrl.ToString(),
                Coordinates = new [] { venue.Coordinate }
            };

            _mooiGroupFactoryMock.Setup(x => x.CreateList(kmlDocument.Folders[0], discoveredPlaces, string.Empty))
            .Returns(new List <MooiCluster>());
            _mooiGroupFactoryMock.Setup(x => x.CreateList(It.Is <KmlFolder>(f => f.Name == Resources.Kml_Folder_Explored),
                                                          discoveredPlaces, string.Empty))
            .Returns((KmlFolder folder, List <DiscoveredPlace> dps, string path) => new List <MooiCluster> {
                new MooiCluster {
                    Placemarks =
                    {
                        placemarkExplored
                    }
                }
            });

            // Act
            var result = _factory.Create(kmlDocument, discoveredPlaces, string.Empty);

            // Verify
            var sectionWithExploredPlacemarks = result.Sections[1];

            Assert.AreEqual(kmlDocument.Folders[0].Name, result.Sections[0].Name);
            Assert.AreEqual(Resources.Kml_Folder_Explored, sectionWithExploredPlacemarks.Name);
            Assert.AreEqual(1, sectionWithExploredPlacemarks.Clusters.Count);
            Assert.AreEqual(1, sectionWithExploredPlacemarks.Clusters[0].Placemarks.Count);
            Assert.AreEqual(placemarkExplored, sectionWithExploredPlacemarks.Clusters[0].Placemarks[0]);
        }
        public void Only_supported_venue_types_are_processed()
        {
            // Arrange
            var placemark = new MooiPlacemark {
                AttachedVenues = Enum.GetValues(typeof(VenueSource)).Cast <VenueSource>()
                                 .Where(x => x != VenueSource.Undefined)
                                 .Select(x => (VenueBase) new DummyVenue(x))
                                 .ToArray()
            };

            // Act
            _factory.Object.ExtendPlacemarkWithVenueData(placemark);
        }
Beispiel #6
0
        public async Task When_fetching_placemark_thumbnail_the_parameters_passed_correctly()
        {
            // Arrange
            var placemark = new MooiPlacemark {
                Coordinates = new [] { new GeoCoordinate(1.11, 2.22) }
            };
            var bytesToMatch = SetupWebClient(uri => uri.AbsoluteUri.StartsWith(HereAdapter.IMAGES_MAPVIEW_URL),
                                              p => p.Contains("1.11,2.22") && p.Contains("z=18"));

            // Act
            var bytes = await _here.Object.FetchThumbnail(placemark);

            // Verify
            CollectionAssert.AreEqual(bytesToMatch, bytes);
        }
        private async Task FetchPlacemarkMapImage(MooiPlacemark placemark, string tempPath)
        {
            if (placemark.Type == PlacemarkType.Point)
            {
                var imageBytes = await _hereAdapter.FetchThumbnail(placemark);

                if (imageBytes == null)
                {
                    _logger.Warn($"Was unable to download thumbnail map image for '{placemark.Id}'");
                    return;
                }
                var filePath = Path.Combine(tempPath, _resourceName.CreateFileNameForPlacemarkThumbnail(placemark));
                await _file.WriteBytesAsync(filePath, imageBytes);

                _logger.Info($"A thumbnail map image for '{placemark.Id}' has been successfully downloaded");
            }
        }
Beispiel #8
0
        private MooiPlacemarkDto CreatePlacemark(MooiPlacemark placemark)
        {
            var pm = new MooiPlacemarkDto {
                Id                = placemark.Id,
                Index             = placemark.Cluster.Placemarks.IndexOf(placemark) + 1,
                Name              = placemark.Name,
                Description       = placemark.Description,
                Images            = placemark.Images.ToArray(),
                Coordinates       = placemark.Coordinates.Select(ConvertCoordinateToString).ToArray(),
                AttachedVenues    = placemark.AttachedVenues.Select(x => _venueConverters[x.SourceType](x)).ToArray(),
                IconPath          = placemark.IconPathIsOnWeb ? placemark.IconPath : ConvertToLocalFileUrl(placemark.IconPath),
                ThumbnailFilePath = ConvertToLocalFileUrl(placemark.ThumbnailMapFilePath),
                IsShape           = placemark.IsShape,
                Distance          = placemark.Distance
            };

            return(pm);
        }
Beispiel #9
0
        public MooiPlacemark Create(KmlPlacemark kmlPlacemark, IEnumerable <VenueBase> venues, string reportTempPath)
        {
            var descriptionAndImages = ExtractImagesFromContent(kmlPlacemark.Description);
            var description          = FilterContent(descriptionAndImages.filteredContent);

            var placemark = new MooiPlacemark
            {
                Name           = kmlPlacemark.Name,
                Description    = description,
                AttachedVenues = venues?.ToArray(),
                Coordinates    = kmlPlacemark.Coordinates,
                IconPath       = kmlPlacemark.IconPath
            };

            if (descriptionAndImages.images != null)
            {
                placemark.Images.AddRange(descriptionAndImages.images);
            }

            if (placemark.IconPath != null && !placemark.IconPathIsOnWeb)
            {
                placemark.IconPath = Path.Combine(reportTempPath, placemark.IconPath);
            }

            placemark.ThumbnailMapFilePath = Path.Combine(reportTempPath,
                                                          _resourceName.CreateFileNameForPlacemarkThumbnail(placemark));
            placemark.IsShape = _kmlCalculator.PlacemarkIsShape(placemark);

            if (placemark.IsShape)
            {
                var distanceInMeters = _kmlCalculator.CalculateRouteDistanceInMeters(placemark);
                placemark.Distance = _formatter.FormatDistance(distanceInMeters);
            }

            ExtendPlacemarkWithVenueData(placemark);

            return(placemark);
        }
Beispiel #10
0
        public void Trim_out_coordinates_when_too_much_passed_within_route()
        {
            // Arrange
            var routePlacemarkToInclude = new MooiPlacemark {
                Coordinates = Enumerable.Range(1, HereAdapter.TOO_MUCH_OF_COORDINATE_POINTS * 3)
                              .Select(x => new GeoCoordinate(x * 0.001, x * 0.001)).ToArray()
            };
            var placemarkShouldBeExcluded = new MooiPlacemark {
                Coordinates = new[] { new GeoCoordinate(1, 1) }
            };
            var group = new MooiCluster {
                Placemarks =
                {
                    routePlacemarkToInclude,
                    placemarkShouldBeExcluded
                }
            };

            // Act
            var result = _here.Object.GetAndTrimRouteCoordinates(group);

            // Verify
            Assert.AreEqual(HereAdapter.TOO_MUCH_OF_COORDINATE_POINTS, result.Coordinates.Length);
        }
Beispiel #11
0
 public string CreateFileNameForPlacemarkThumbnail(MooiPlacemark placemark)
 {
     return($"{placemark.Id}.jpg");
 }
Beispiel #12
0
 private void AppendPlacemarkToCluster(MooiPlacemark placemark, MooiCluster cluster)
 {
     placemark.Cluster = cluster;
     cluster.Placemarks.Add(placemark);
 }