public async void UpdateSnapshot_ShouldSaveDbContextChanges()
{
// Arrange
SetUp();
var payload = new LocationSnapshot
{
Id = 2,
LocationId = 1,
Longitude = 19,
Latitude = 51,
Altitude = 200
};
var snapshotInDb = new LocationSnapshot {
Id = 2
};
_context.LocationSnapshots.Returns(new List <LocationSnapshot> {
snapshotInDb
});
// Act
var sit = new LocationSnapshotDataService(_factory);
var result = await sit.UpdateSnapshotAsync(payload);
// Assert
_context.Received().SaveChanges();
Assert.Equal(payload.Longitude, result.Longitude);
Assert.Equal(payload.Latitude, result.Latitude);
Assert.Equal(payload.Altitude, result.Altitude);
}
private LocationSnapshot AddSnapshot(LocationSnapshot snapshotToAdd)
{
using (var context = _dataContextFactory.Create())
{
return(context.Add(snapshotToAdd));
}
}
public async Task <LocationSnapshot> AddSnapshotAsync(LocationSnapshot snapshotToAdd)
{
var snapshotsUrl = await GetSnapshotsUrl();
var result = await _webClient.PostAsync <LocationSnapshot, LocationSnapshot>(snapshotsUrl, snapshotToAdd);
return(result);
}
public async Task <LocationSnapshot> UpdateSnapshotAsync(LocationSnapshot snapshot)
{
var snapshotsUrl = await GetSnapshotsUrl();
snapshotsUrl = $"{snapshotsUrl}/{snapshot.Id}";
var result = await _webClient.PutAsync <LocationSnapshot, LocationSnapshot>(snapshotsUrl, snapshot);
return(result);
}
public async Task <WeatherData> GetWeatherDataForLocationAsync(LocationSnapshot locationSnapshot)
{
var appSettings = await _appSettingsProvider.GetAppSettingsAsync();
var uri = GetWeatherUri(locationSnapshot, appSettings);
var rawWeatherData = await _webClient.GetStringAsync(uri);
return(ParseWeatherData(rawWeatherData));
}
public async Task RemoveSnapshotContentAsync(LocationSnapshot snapshot)
{
_miniaturesCache.RemoveSnapshotMiniature(snapshot.Id);
var picturesUrl = await GetPicturesUrl();
picturesUrl = $"{picturesUrl}/{snapshot.PictureFileName}";
await _webClient.DeleteAsync <object>(picturesUrl);
}
private async Task <SnapshotMiniature> GetSnapshotMiniatureAsync(LocationSnapshot snapshot, StorageFile picture)
{
using (var thumbnail = await picture.GetThumbnailAsync(ThumbnailMode.ListView, 100, ThumbnailOptions.UseCurrentScale))
{
var bytes = await _bitmapConverter.GetBytesFromStream(thumbnail);
return(new SnapshotMiniature {
Snapshot = snapshot, Data = bytes
});
}
}
private string GetCoordinateValue(Func <double> selector, LocationSnapshot snapshot)
{
var coordinate = selector();
var result = coordinate == double.MinValue
? (DateTime.Now - snapshot.DateCreated).Minutes > 1
? "Geolocation data not available"
: "Loading geolocation data..."
: coordinate.ToString();
return(result);
}
private async Task <byte[]> GetSnapshotContentAsync(LocationSnapshot snapshot, bool isMiniature)
{
var picturesUrl = await GetPicturesUrl();
var queryString = isMiniature ? $"?isMiniature={isMiniature}" : string.Empty;
picturesUrl = $"{picturesUrl}/{snapshot.PictureFileName}{queryString}";
var result = await _webClient.GetStringAsync(picturesUrl);
var picture = Convert.FromBase64String(result);
return(picture);
}
public async Task <int> SaveSnapshotContentAsync(LocationSnapshot snapshot, byte[] data)
{
var cameraRollFolder = KnownFolders.CameraRoll;
var pictureFile = await cameraRollFolder.CreateFileAsync(snapshot.PictureFileName, CreationCollisionOption.ReplaceExisting);
await FileIO.WriteBytesAsync(pictureFile, data);
var miniature = await GetSnapshotMiniatureAsync(snapshot, pictureFile);
_miniaturesCache.AddSnapshotMiniature(miniature);
return(data.Length);
}
public async void AddSnapshot_ShouldAddToDbContext()
{
// Arrange
SetUp();
var toAdd = new LocationSnapshot {
Id = 2, LocationId = 1
};
// Act
var sit = new LocationSnapshotDataService(_factory);
await sit.AddSnapshotAsync(toAdd);
// Assert
_context.Received().Add(toAdd);
}
public async Task RemoveSnapshotContentAsync(LocationSnapshot snapshot)
{
_miniaturesCache.RemoveSnapshotMiniature(snapshot.Id);
try
{
var picturesFolder = KnownFolders.CameraRoll;
var pictureFile = await picturesFolder.GetFileAsync(snapshot.PictureFileName);
await pictureFile.DeleteAsync();
}
catch
{
// Picture does not exist in the specified location
}
}
private LocationSnapshot UpdateSnapshot(LocationSnapshot snapshot)
{
using (var context = _dataContextFactory.Create())
{
var snapshotToUpdate = context.LocationSnapshots
.First(_ => _.Id == snapshot.Id);
snapshotToUpdate.Longitude = snapshot.Longitude;
snapshotToUpdate.Latitude = snapshot.Latitude;
snapshotToUpdate.Altitude = snapshot.Altitude;
context.SaveChanges();
return(snapshotToUpdate);
}
}
public void ShowLocation(LocationSnapshot snapshot)
{
BasicGeoposition snapshotPosition = new BasicGeoposition {
Latitude = snapshot.Latitude, Longitude = snapshot.Longitude
};
Geopoint snapshotPoint = new Geopoint(snapshotPosition);
var snapshotIcon = new MapIcon
{
Location = snapshotPoint,
NormalizedAnchorPoint = new Point(0.5, 1.0),
ZIndex = 0
};
_mapControl.MapElements.Add(snapshotIcon);
_mapControl.Center = snapshotPoint;
_mapControl.ZoomLevel = 15;
}
public async Task <byte[]> GetSnapshotContentAsync(LocationSnapshot snapshot)
{
var picturesFolder = KnownFolders.CameraRoll;
try
{
var pictureFile = await picturesFolder.GetFileAsync(snapshot.PictureFileName);
var picture = await GetPictureAsync(pictureFile);
return(picture);
}
catch
{
// Picture does not exist in the specified location
return(new byte[0]);
}
}
public async void RemoveSnapshot_ShouldRemoveFromDbContext()
{
// Arrange
SetUp();
var snapshotInDb = new LocationSnapshot {
Id = 2
};
_context.LocationSnapshots.Returns(new List <LocationSnapshot> {
snapshotInDb
});
// Act
var sit = new LocationSnapshotDataService(_factory);
await sit.RemoveSnapshotAsync(2);
// Assert
_context.Received().Remove(snapshotInDb);
}
public async Task <int> SaveSnapshotContentAsync(LocationSnapshot snapshot, byte[] data)
{
var picturesUrl = await GetPicturesUrl();
dynamic payload = new ExpandoObject();
payload.pictureFile = Convert.ToBase64String(data);
payload.pictureFileName = snapshot.PictureFileName;
await _webClient.PostAsync <object, object>(picturesUrl, payload);
var miniatureBytes = await GetSnapshotContentAsync(snapshot, true);
_miniaturesCache.AddSnapshotMiniature(new SnapshotMiniature {
Snapshot = snapshot, Data = miniatureBytes
});
return(data.Length);
}
public async Task OnCaptureSnapshot()
{
IsBusy = true;
var pictureData = await _cameraService.CapturePhotoWithOrientationAsync();
var now = DateTime.Now.ToString("yyyyMMdd_HH_mm_ss");
var pictureFileName = $"LocationCapture_{now}.jpg";
var locationSnapshot = new LocationSnapshot
{
LocationId = GetLocationId(),
PictureFileName = pictureFileName,
Longitude = double.MinValue,
Latitude = double.MinValue,
Altitude = double.MinValue,
DateCreated = DateTime.Now
};
var newSnapshot = await _locationSnapshotDataService.AddSnapshotAsync(locationSnapshot);
await _pictureService.SaveSnapshotContentAsync(newSnapshot, pictureData);
IsBusy = false;
var locationDescriptor = await _locationService.GetCurrentLocationAsync();
if (!(await _locationSnapshotDataService.GetSnapshotsByIdsAsync(new[] { newSnapshot.Id })).Any())
{
return;
}
newSnapshot.Longitude = locationDescriptor.Longitude;
newSnapshot.Latitude = locationDescriptor.Latitude;
newSnapshot.Altitude = locationDescriptor.Altitude;
await _locationSnapshotDataService.UpdateSnapshotAsync(newSnapshot);
_eventAggregator.GetEvent <GeolocationReadyEvent>().Publish(locationDescriptor);
}
public async Task <LocationSnapshot> AddSnapshotAsync(LocationSnapshot snapshotToAdd)
{
var result = await Task.Factory.StartNew(() => AddSnapshot(snapshotToAdd));
return(result);
}
public async Task <LocationSnapshot> UpdateSnapshotAsync(LocationSnapshot snapshot)
{
var result = await Task.Factory.StartNew(() => UpdateSnapshot(snapshot));
return(result);
}
public async void OnCaptureSnapshot_ShouldSucceed()
{
// Arrange
SetUp();
var navParam = new SnapshotsViewNavParams
{
SnapshotsIdsource = new Location {
Id = 2
}
};
var locDescriptor = new LocationDescriptor
{
Longitude = 1,
Latitude = 2,
Altitude = 3
};
LocationSnapshot newSnapshot = null;
LocationDescriptor receivedLocDesc = null;
_locationSnapshotDataService.AddSnapshotAsync(Arg.Any <LocationSnapshot>())
.Returns(_ =>
{
var snapshot = _.Arg <LocationSnapshot>();
var tcs = new TaskCompletionSource <LocationSnapshot>();
tcs.SetResult(snapshot);
return(tcs.Task);
});
_pictureService.SaveSnapshotContentAsync(Arg.Any <LocationSnapshot>(), Arg.Any <byte[]>())
.Returns(_ =>
{
var tcs = new TaskCompletionSource <int>();
tcs.SetResult(0);
return(tcs.Task);
});
_locationService.GetCurrentLocationAsync()
.Returns(_ =>
{
var tcs = new TaskCompletionSource <LocationDescriptor>();
tcs.SetResult(locDescriptor);
return(tcs.Task);
});
_locationSnapshotDataService.GetSnapshotsByIdsAsync(Arg.Any <IEnumerable <int> >())
.Returns(_ =>
{
var tcs = new TaskCompletionSource <IEnumerable <LocationSnapshot> >();
tcs.SetResult(new List <LocationSnapshot> {
new LocationSnapshot()
});
return(tcs.Task);
});
_locationSnapshotDataService.AddSnapshotAsync(Arg.Any <LocationSnapshot>())
.Returns(_ =>
{
newSnapshot = _.Arg <LocationSnapshot>();
var tcs = new TaskCompletionSource <LocationSnapshot>();
tcs.SetResult(newSnapshot);
return(tcs.Task);
});
_eventAggregator.GetEvent <GeolocationReadyEvent>().Subscribe(_ => receivedLocDesc = _);
// Act
var sit = CreateViewModel();
sit.NavigationParam = navParam;
await sit.OnCaptureSnapshot();
// Assert
Assert.Equal(((Location)navParam.SnapshotsIdsource).Id, newSnapshot.LocationId);
Assert.True(newSnapshot.PictureFileName.StartsWith("LocationCapture_") &&
newSnapshot.PictureFileName.EndsWith(".jpg"));
Assert.Equal(locDescriptor.Longitude, newSnapshot.Longitude);
Assert.Equal(locDescriptor.Latitude, newSnapshot.Latitude);
Assert.Equal(locDescriptor.Altitude, newSnapshot.Altitude);
Assert.Equal(newSnapshot.PictureFileName.Substring(16, 17), newSnapshot.DateCreated.ToString("yyyyMMdd_HH_mm_ss"));
Assert.Equal(locDescriptor, receivedLocDesc);
}
private string GetWeatherUri(LocationSnapshot locationSnapshot, AppSettings appSettings) =>
string.Format(CultureInfo.InvariantCulture, "{0}?mode=xml&units=metric&type=accurate&lon={1}&lat={2}&APPID={3}", appSettings.WeatherApiUri, locationSnapshot.Longitude, locationSnapshot.Latitude, appSettings.WeatherApiKey);
public async Task <byte[]> GetSnapshotContentAsync(LocationSnapshot snapshot)
{
return(await GetSnapshotContentAsync(snapshot, false));
}
