GetImageMetadataAsync(CafEEFluxParameters parameters)
{
// TODO: Error checking
EEFluxRequest requestContent = getEEFluxRequest(parameters);
StringContent content =
new StringContent(JsonConvert.SerializeObject(requestContent));
Uri uri = new Uri(baseAddress, "landsat");
HttpResponseMessage response = await client.PostAsync(
uri.ToString(),
content);
if (response.IsSuccessStatusCode)
{
string result = response.Content.ReadAsStringAsync().Result;
Dictionary <int, EEFluxImageMetadata> imageMetadatas =
JsonConvert.DeserializeObject <Dictionary <int, EEFluxImageMetadata> >(result);
return(imageMetadatas);
}
else
{
return(new Dictionary <int, EEFluxImageMetadata>());
}
}
/// <summary>
/// Gets an image URL by sending an HTTP POST to {baseAddress}/{imageType}
/// </summary>
/// <param name="parameters">Required parameters to be set: StartDate, EndDate, ImageId, Latitude, Longitude</param>
/// <param name="imageId">ID of image</param>
/// <param name="imageType">Type of image to be requested (NDVI, Actual ET, etc)</param>
/// <returns></returns>
public async Task <Dictionary <EEFluxImageTypes, EEFluxImage> > GetImageUriAsync(
CafEEFluxParameters parameters,
string imageId,
EEFluxImageTypes imageType)
{
EEFluxRequest requestContent = getEEFluxRequest(
parameters,
imageId);
StringContent content =
new StringContent(JsonConvert.SerializeObject(requestContent));
Uri uri =
new Uri(baseAddress, this.imageTypeToUriMap[imageType]);
HttpResponseMessage response = await client.PostAsync(
uri.ToString(),
content);
if (response.IsSuccessStatusCode)
{
string result = response.Content.ReadAsStringAsync().Result;
Dictionary <EEFluxImageTypes, EEFluxImage> imageUris =
JsonConvert.DeserializeObject <
Dictionary <EEFluxImageTypes, EEFluxImage> >(result);
return(imageUris);
}
else
{
return(new Dictionary <EEFluxImageTypes, EEFluxImage>());
}
}
public async Task Integration_Valid_ReturnsExpected()
{
// ARRANGE
string b = Container.GetBaseAddress();
HttpClient c = Container.ResolveHttpClient();
var m = Container.ResolveImageTypeToUriMap();
IEEFluxClient <HttpResponseMessage> sut = new EEFluxClientWebApi(c, b, m);
CafEEFluxParameters p = getCafEEFluxParametersValid();
// ACT
Dictionary <int, EEFluxImageMetadata> imageMetas =
await sut.GetImageMetadataAsync(p);
Dictionary <EEFluxImageTypes, EEFluxImage> image =
await sut.GetImageUriAsync(
p,
imageMetas[0].ImageId,
EEFluxImageTypes.Ndvi);
Uri imageUrl = new Uri(image[EEFluxImageTypes.Ndvi].Url);
string fullPath = Path.GetFullPath(p.OutputDirectoryPath);
if (!Directory.Exists(fullPath))
{
Directory.CreateDirectory(fullPath);
}
// await sut.DownloadImageAsync(fullPath, imageUrl);
Task <HttpResponseMessage> download = sut.DownloadImageAsync(imageUrl);
var response = await download;
string filePath =
$"{p.OutputDirectoryPath}\\{response.Content.Headers.ContentDisposition.FileName}";
using (Stream readStream = await response.Content.ReadAsStreamAsync())
{
using (Stream writeStream = File.Open(
filePath,
FileMode.Create))
{
await readStream.CopyToAsync(writeStream);
}
}
// ASSERT
Assert.True(
File.Exists("Output/LE70440272015152EDC00_NDVI.zip"));
double expectedLength = new FileInfo("Assets/LE70440272015152EDC00_NDVI.zip").Length;
double actualLength = new FileInfo("Output/LE70440272015152EDC00_NDVI.zip").Length;
Assert.Equal(
expectedLength,
actualLength);
}
public async Task GetImages_FileExists_DoesNotDownload()
{
// ARRANGE
var p = Arranger.GetCafEEFluxParametersValid();
var parameters = new CafEEFluxParameters(
p.Latitude, p.Latitude,
p.StartDate, p.EndDate,
p.CloudinessThreshold, p.TierThreshold,
$"{Directory.GetCurrentDirectory()}\\Assets\\TestZipOnly",
new List <EEFluxImageTypes>()
{
EEFluxImageTypes.Ndvi
});
var u = Arranger.GetEEFluxResponseDownloadEtofValid();
var imageMeta =
new Dictionary <int, EEFluxImageMetadata>();
imageMeta.Add(
0,
Arranger.GetEEFluxImageMetadataAllValid()[0]);
Mock <IEEFluxClient <HttpResponseMessage> > e =
new Mock <IEEFluxClient <HttpResponseMessage> >();
e.Setup(x => x.GetImageMetadataAsync(parameters))
.Returns(Task.FromResult(imageMeta));
e.Setup(x => x.GetImageUriAsync(
It.IsAny <CafEEFluxParameters>(),
It.IsAny <string>(),
It.IsAny <EEFluxImageTypes>()))
.Returns(Task.FromResult(u));
var c = new CommandLineApplication();
var o = new Mock <IParseParameters <CommandOption> >();
o.Setup(x => x.Parse(
It.IsAny <IEnumerable <CommandOption> >()))
.Returns(parameters);
var sut = new Engine(e.Object, c, o.Object);
// ACT
int result = await sut.GetImages(parameters);
// ASSERT
e.Verify(x => x.GetImageUriAsync(
parameters,
It.IsAny <string>(),
It.IsAny <EEFluxImageTypes>()),
Times.Never);
}
/// <summary>
/// Converts CafEEFluxParameters to EEFluxRequest
/// </summary>
/// <param name="parameters">CafEEFluxParameters, expects StartDate, EndDate, ImageId, Latitude, Longitude</param>
/// <param name="imageId"></param>
/// <returns></returns>
private EEFluxRequest getEEFluxRequest(
CafEEFluxParameters parameters,
string imageId = "")
{
EEFluxRequest eefluxRequest = new EEFluxRequest()
{
Date =
$"{parameters.StartDate.ToString("yyyy-MM-dd")} to " +
$"{parameters.EndDate.ToString("yyyy-MM-dd")}",
ImageId = imageId,
Lat = parameters.Latitude,
Lon = parameters.Longitude
};
return(eefluxRequest);
}
public static CafEEFluxParameters GetCafEEFluxParametersValid()
{
CafEEFluxParameters parameters = new CafEEFluxParameters(
47.4395843855568,
-118.35367508232594,
new DateTime(2015, 06, 01),
new DateTime(2015, 06, 05),
30,
1,
"/Output/test.zip",
new List <EEFluxImageTypes>()
{
EEFluxImageTypes.Eta
});
return(parameters);
}
private CafEEFluxParameters getCafEEFluxParametersValid()
{
CafEEFluxParameters parameters = new CafEEFluxParameters(
47.4395843855568,
-118.35367508232594,
new DateTime(2015, 06, 01),
new DateTime(2015, 06, 05),
30,
1,
"Output",
new List <EEFluxImageTypes>()
{
EEFluxImageTypes.Eta
});
return(parameters);
}
public CafEEFluxParameters Parse(
IEnumerable <CommandOption> parameters)
{
var lat = parameters.SingleOrDefault(
o => o.LongName == "lat");
var lon = parameters.SingleOrDefault(
o => o.LongName == "lon");
var start = parameters.SingleOrDefault(
o => o.LongName == "startdate");
var end = parameters.SingleOrDefault(
o => o.LongName == "enddate");
var cloud = parameters.SingleOrDefault(
o => o.LongName == "cloudiness");
var tier = parameters.SingleOrDefault(
o => o.LongName == "tier");
var path = parameters.SingleOrDefault(
o => o.LongName == "writepath");
var images = parameters.SingleOrDefault(
o => o.LongName == "imagetypes");
var quiet = parameters.SingleOrDefault(
o => o.LongName == "quiet");
double latv = lat.HasValue()
? Convert.ToDouble(lat.Value())
: throw new ArgumentException();
double lonv = lon.HasValue()
? Convert.ToDouble(lon.Value())
: throw new ArgumentException();
DateTime startv = end.HasValue()
? DateTime.ParseExact(start.Value(), "yyyyMMdd", CultureInfo.InvariantCulture)
: throw new ArgumentException();
DateTime endv = end.HasValue()
? DateTime.ParseExact(end.Value(), "yyyyMMdd", CultureInfo.InvariantCulture)
: throw new ArgumentException();
double cloudv = cloud.HasValue()
? Convert.ToDouble(cloud.Value())
: 100;
int tierv = tier.HasValue()
? Convert.ToInt32(tier.Value())
: 1;
string pathv = path.HasValue()
? path.Value()
: Directory.GetCurrentDirectory();
List <EEFluxImageTypes> imagev = images.HasValue()
? parseImageTypes(images.Value())
: new List <EEFluxImageTypes>();
bool quietv = quiet.HasValue()
? Boolean.Parse(quiet.Value())
: true;
var p = new CafEEFluxParameters(
latv,
lonv,
startv,
endv,
cloudv,
tierv,
pathv,
imagev,
quietv);
return(p);
}
public async Task <int> GetImages(CafEEFluxParameters parameters)
{
Console.WriteLine("Getting images...");
Dictionary <int, EEFluxImageMetadata> imageMetas =
await client.GetImageMetadataAsync(parameters);
Console.WriteLine($"Found {imageMetas.Count} landsat images.");
// TODO: Filter by cloudiness, tier, landsat8
var imageMetasFiltered =
filterImages(
imageMetas,
parameters.CloudinessThreshold,
parameters.TierThreshold,
true);
Console.WriteLine($"After filtering, {imageMetasFiltered.Count} images remain");
if (imageMetasFiltered.Count == 0)
{
return(0);
}
string writeDirPath;
if (Path.IsPathRooted(parameters.OutputDirectoryPath))
{
writeDirPath = parameters.OutputDirectoryPath;
}
else
{
writeDirPath =
Path.GetFullPath(parameters.OutputDirectoryPath);
}
Console.WriteLine($"Images will be saved to: {writeDirPath}");
if (!parameters.IsQuietMode)
{
if (!Prompt.GetYesNo("Would you like to proceed?", true))
{
return(0);
}
}
Directory.CreateDirectory(writeDirPath);
foreach (EEFluxImageTypes type in parameters.ImageTypes)
{
Console.WriteLine($"Working on {type.ToString()}...");
// TODO: Move this to a new function to clean up code
foreach (var image in imageMetasFiltered)
{
string imageId = image.Value.ImageId;
// Check if image already downloaded
if (doesImageFileExist(
imageId,
type.ToString(),
writeDirPath))
{
Console.WriteLine($" File {imageId}_{type.ToString()} found, skipping download.");
continue;
}
Dictionary <EEFluxImageTypes, EEFluxImage> eeFluxImageUrl =
await client.GetImageUriAsync(
parameters,
imageId,
type);
if (eeFluxImageUrl.Count == 0)
{
Console.WriteLine($" Error getting URL, aborting.");
continue;
}
Uri imageUrl =
new Uri(eeFluxImageUrl[type].Url);
Console.WriteLine($" Downloading: {imageUrl}... ");
try
{
Task <HttpResponseMessage> download =
client.DownloadImageAsync(imageUrl);
while (!download.IsCompleted)
{
Thread.Sleep(5000);
Console.Write(".");
}
var response = await download;
if (response == null)
{
Console.WriteLine(" Error downloading and/or saving file");
continue;
}
string fileName =
response.Content.Headers.ContentDisposition.FileName;
string filePath =
$"{writeDirPath}\\" +
$"{fileName}";
Console.WriteLine($" Saving to: {filePath}... ");
using (Stream readStream =
await response.Content.ReadAsStreamAsync())
{
using (Stream writeStream = File.Open(
filePath,
FileMode.Create))
{
await readStream.CopyToAsync(writeStream);
}
}
}
catch (Exception e)
{
Console.WriteLine($" Error while downloading: {e.ToString()}");
continue;
}
}
}
return(0);
}
