public void RefreshGalleryStoreTheme_TakesThemeWithActualVersion_DoesNotDownloadsFreshTheme()
{
var extensionMetadata = new ExtensionMetadata {
Id = "expectedId_test", Version = "version_test"
};
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.GetSavedExtensionType(extensionMetadata.Id))
.ReturnsAsync(ExtensionType.Default);
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.GetStoredTheme(extensionMetadata.Id))
.ReturnsAsync(new VSCodeTheme {
Version = extensionMetadata.Version
});
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.DownloadFreshTheme(extensionMetadata))
.ReturnsAsync(new VSCodeTheme());
var mockRefreshService = _mock.Create <ThemeStoreRefreshService>();
mockRefreshService.RefreshGalleryStoreTheme(extensionMetadata).Wait();
_mock.Mock <IThemeStoreRefresher>()
.Verify(x => x.GetSavedExtensionType(extensionMetadata.Id), Times.Once);
_mock.Mock <IThemeStoreRefresher>()
.Verify(x => x.GetStoredTheme(extensionMetadata.Id), Times.Once);
_mock.Mock <IThemeStoreRefresher>()
.Verify(x => x.DownloadFreshTheme(extensionMetadata), Times.Never);
}
private async Task RefreshExtensionMetadata(ExtensionMetadata freshMetadata)
{
try
{
var extensionMetadata = await _metadataRepository
.GetExtensionMetadata(freshMetadata.Id);
if (extensionMetadata == null)
{
await CreateExtensionMetadata(freshMetadata);
}
else if (extensionMetadata.LastUpdated != freshMetadata.LastUpdated)
{
await UpdateExtensionMetadata(freshMetadata);
}
else
{
await UpdateGalleryStatistics(freshMetadata.Id, freshMetadata.Statistics);
}
}
catch (Exception ex)
{
Log.Error(ex, $"Error while refreshing extension metadata: '{freshMetadata.Id}'.");
}
}
public void RefreshGalleryStoreTheme_TakesNonDefaultTypeTheme_DoesNotRefreshTheme(
ExtensionType extensionType)
{
var extensionMetadata = new ExtensionMetadata {
Id = "expectedId_test"
};
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.GetSavedExtensionType(extensionMetadata.Id))
.ReturnsAsync(extensionType);
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.CreateTheme(It.IsAny <VSCodeTheme>()));
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.UpdateTheme(It.IsAny <VSCodeTheme>()));
var mockRefreshService = _mock.Create <ThemeStoreRefreshService>();
mockRefreshService.RefreshGalleryStoreTheme(extensionMetadata).Wait();
_mock.Mock <IThemeStoreRefresher>()
.Verify(x => x.GetSavedExtensionType(extensionMetadata.Id), Times.Once);
_mock.Mock <IThemeStoreRefresher>()
.Verify(x => x.CreateTheme(It.IsAny <VSCodeTheme>()), Times.Never);
_mock.Mock <IThemeStoreRefresher>()
.Verify(x => x.CreateTheme(It.IsAny <VSCodeTheme>()), Times.Never);
}
public void DownloadFreshTheme_ReturnsProperTheme()
{
var metadata = new ExtensionMetadata
{
Id = "espectedPublisher_test.espectedName_test",
PublisherName = "espectedPublisher_test",
Name = "espectedName_test",
Version = "espectedVersion_test"
};
var expectedTheme = new VSCodeTheme
{
Id = metadata.Id,
Version = metadata.Version
};
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes("")))
{
_mock.Mock <IVSAssetsClient>()
.Setup(x => x.GetVsixFileStream(metadata))
.ReturnsAsync(stream);
_mock.Mock <IVSExtensionHandler>()
.Setup(x => x.ProcessExtension(expectedTheme.Id, stream))
.ReturnsAsync(expectedTheme);
var mockRefresher = _mock.Create <ThemeStoreRefresher>();
var actualTheme = mockRefresher.DownloadFreshTheme(metadata).Result;
Assert.Equal(expectedTheme.Id, actualTheme.Id);
Assert.Equal(expectedTheme.Version, actualTheme.Version);
}
}
public static void InitializeMetadata(int Timestep, string eventLogName)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(PlugIn.ModelCore)
//Extension = new ExtensionMetadata()
{
Name = PlugIn.ExtensionName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
CreateDirectory(eventLogName);
PlugIn.eventsLog = new MetadataTable <EventsLog>(eventLogName);
//PlugIn.eventLog = new MetadataTable<EventsLog>("Harvest-event-log.csv");
//PlugIn.summaryLog = new MetadataTable<SummaryLog>("Harvest-summary-log.csv");
PlugIn.ModelCore.UI.WriteLine(" Generating event table...");
OutputMetadata tblOut_events = new OutputMetadata()
{
Type = OutputType.Table,
Name = "EventLog",
FilePath = PlugIn.eventsLog.FilePath,
Visualize = false,
};
tblOut_events.RetriveFields(typeof(EventsLog));
Extension.OutputMetadatas.Add(tblOut_events);
//---------------------------------------
// map outputs:
//---------------------------------------
//OutputMetadata mapOut_BiomassRemoved = new OutputMetadata()
//{
// Type = OutputType.Map,
// Name = "biomass removed",
// FilePath = @HarvestMapName,
// Map_DataType = MapDataType.Continuous,
// Map_Unit = FieldUnits.Mg_ha,
// Visualize = true,
//};
//Extension.OutputMetadatas.Add(mapOut_BiomassRemoved);
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public void RefreshGalleryStoreTheme_TakesFreshTheme_DownloadsAndUpdateIt()
{
const string expectedId = "expectedId_test";
var colorTheme = new Theme
{
TokenColors = new List <TokenColor> {
new TokenColor {
Name = "name_test"
}
}
};
var freshExtensionMetada = new ExtensionMetadata {
Id = expectedId, Version = "version2"
};
var oldTheme = new VSCodeTheme
{
Id = expectedId,
Version = "version1",
Themes = new List <Theme> {
colorTheme
}
};
var freshTheme = new VSCodeTheme
{
Id = expectedId,
Version = "version2",
Themes = new List <Theme> {
colorTheme
}
};
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.GetSavedExtensionType(freshExtensionMetada.Id))
.ReturnsAsync(ExtensionType.Default);
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.GetStoredTheme(freshExtensionMetada.Id))
.ReturnsAsync(oldTheme);
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.DownloadFreshTheme(freshExtensionMetada))
.ReturnsAsync(freshTheme);
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.CreateTheme(It.IsAny <VSCodeTheme>()));
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.UpdateTheme(freshTheme))
.Returns(Task.CompletedTask);
var mockRefreshService = _mock.Create <ThemeStoreRefreshService>();
mockRefreshService.RefreshGalleryStoreTheme(freshExtensionMetada).Wait();
_mock.Mock <IThemeStoreRefresher>()
.Verify(x => x.GetSavedExtensionType(freshExtensionMetada.Id), Times.Once);
_mock.Mock <IThemeStoreRefresher>()
.Verify(x => x.DownloadFreshTheme(freshExtensionMetada), Times.Once);
_mock.Mock <IThemeStoreRefresher>()
.Verify(x => x.CreateTheme(It.IsAny <VSCodeTheme>()), Times.Never);
_mock.Mock <IThemeStoreRefresher>()
.Verify(x => x.UpdateTheme(freshTheme), Times.Once);
}
public static void InitializeMetadata(int Timestep, string MapFileName, ICore mCore, string LogFileName)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime //,
//ProjectionFilePath = "Projection.?"
};
Extension = new ExtensionMetadata(mCore)
{
Name = PlugIn.ExtensionName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(LogFileName));
PlugIn.eventLog = new MetadataTable <EventsLog>(LogFileName);
OutputMetadata tblOut_events = new OutputMetadata()
{
Type = OutputType.Table,
Name = "WindLog",
FilePath = PlugIn.eventLog.FilePath,
Visualize = false,
};
tblOut_events.RetriveFields(typeof(EventsLog));
Extension.OutputMetadatas.Add(tblOut_events);
//---------------------------------------
// map outputs:
//---------------------------------------
OutputMetadata mapOut_Severity = new OutputMetadata()
{
Type = OutputType.Map,
Name = "severity",
FilePath = @MapFileName,
Map_DataType = MapDataType.Ordinal,
Map_Unit = FieldUnits.Severity_Rank,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_Severity);
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public JSExtension(ExtensionMetadata metadata)
{
Metadata = metadata;
foreach (var v in metadata.LoadingResources)
{
Resources.Add(v);
}
AssemblyName = metadata.Name;
}
public static void InitializeMetadata(int timestep, ICore mCore)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = Climate.ModelCore.CellArea,
TimeMin = Climate.ModelCore.StartTime,
TimeMax = Climate.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(mCore)
{
Name = "Climate-Library",
TimeInterval = timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
Climate.PdsiLog = new MetadataTable <PDSI_Log>("Climate-PDSI-log.csv");
Climate.MonthlyLog = new MetadataTable <MonthlyLog>("Climate-monthly-log.csv");
OutputMetadata tblOut_monthly = new OutputMetadata()
{
Type = OutputType.Table,
Name = "MonthlyLog",
FilePath = Climate.MonthlyLog.FilePath,
Visualize = true,
};
tblOut_monthly.RetriveFields(typeof(MonthlyLog));
Extension.OutputMetadatas.Add(tblOut_monthly);
OutputMetadata tblOut_pdsi = new OutputMetadata()
{
Type = OutputType.Table,
Name = "PDSILog",
FilePath = Climate.PdsiLog.FilePath,
Visualize = false,
};
tblOut_pdsi.RetriveFields(typeof(PDSI_Log));
Extension.OutputMetadatas.Add(tblOut_pdsi);
//---------------------------------------
// map outputs:
//---------------------------------------
// NONE
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int Timestep, string MapFileName, IEnumerable <IModelDefinition> modelDefs, ICore mCore, string LogFileName)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime //,
//ProjectionFilePath = "Projection.?"
};
Extension = new ExtensionMetadata(mCore)
{
Name = PlugIn.PlugInName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
/*
* //---------------------------------------
* // table outputs:
* //---------------------------------------
* PlugIn.habitatLog = new MetadataTable<SpeciesHabitatLog>(LogFileName);
* OutputMetadata tblOut_events = new OutputMetadata()
* {
* Type = OutputType.Table,
* Name = "SppHabitatLog",
* FilePath = PlugIn.habitatLog.FilePath,
* Visualize = true,
* };
* tblOut_events.RetriveFields(typeof(SpeciesHabitatLog));
* Extension.OutputMetadatas.Add(tblOut_events);
*/
//---------------------------------------
// map outputs:
//---------------------------------------
foreach (ModelDefinition sppModel in modelDefs)
{
OutputMetadata mapOut_Birds = new OutputMetadata()
{
Type = OutputType.Map,
Name = sppModel.Name,
FilePath = @MapFileName,
Map_DataType = MapDataType.Continuous,
//Map_Unit = FieldUnits.Severity_Rank,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_Birds);
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public async Task <VSCodeTheme> DownloadFreshTheme(ExtensionMetadata metadata)
{
VSCodeTheme freshTheme;
using (var stream = await _assetsClient.GetVsixFileStream(metadata))
{
freshTheme = await _extensionHandler.ProcessExtension(metadata.Id, stream);
}
return(freshTheme);
}
public void FromJson_JObjectWithValidVersion_ReturnsCorrectResult()
{
var expextedDate = DateTime.Parse("2019-01-01T00:00:00.0Z", CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal);
var result = ExtensionMetadata.FromJson(JObject.Parse(ValidJson));
Assert.Equal("1.0.0", result.Version);
Assert.Equal(expextedDate, result.LastUpdated);
Assert.Equal("iconDefault_test", result.IconDefault);
Assert.Equal("iconSmall_test", result.IconSmall);
Assert.Equal("fallbackAssetUri_test/Microsoft.VisualStudio.Services.VSIXPackage", result.AssetUri);
}
public static void InitializeMetadata(string speciesNameTemplate, IEnumerable <ISpecies> selectedSpecies)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(PlugIn.ModelCore)
//Extension = new ExtensionMetadata()
{
Name = PlugIn.ExtensionName,
TimeInterval = PlugIn.ModelCore.CurrentTime,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// map outputs:
//---------------------------------------
foreach (ISpecies species in selectedSpecies)
{
OutputMetadata mapOut_max = new OutputMetadata()
{
Type = OutputType.Map,
Name = "max_age_" + species.Name,
FilePath = MapNameTemplates.ReplaceTemplateVars(speciesNameTemplate, species.Name, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_max);
}
OutputMetadata mapOut_max_all = new OutputMetadata()
{
Type = OutputType.Map,
Name = "AllSppMaxAge",
FilePath = MapNameTemplates.ReplaceTemplateVars(speciesNameTemplate, "AllSppMaxAge", PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_max_all);
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public void FromJson_JObjectWithoutPublisher_ThrowsJsonException()
{
const string json = @"{
'extensionName': 'extensionName_test'
}";
var ex = Assert.Throws <JsonException>(() =>
ExtensionMetadata.FromJson(JObject.Parse(json)));
Assert.Equal("Property 'publisher' does not exist on JObject.", ex.Message);
}
public void FromJson_JObjectWithValidBaseProperties_ReturnsCorrectResult()
{
var result = ExtensionMetadata.FromJson(JObject.Parse(ValidJson));
Assert.Equal("publisherName_test.extensionName_test", result.Id);
Assert.Equal("extensionName_test", result.Name);
Assert.Equal("displayName_test", result.DisplayName);
Assert.Equal("shortDescription_test", result.Description);
Assert.Equal("publisherName_test", result.PublisherName);
Assert.Equal("publisherDisplayName_test", result.PublisherDisplayName);
}
public static void InitializeMetadata(int Timestep)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(PlugIn.ModelCore)
//Extension = new ExtensionMetadata()
{
Name = PlugIn.ExtensionName,
TimeInterval = Timestep, //change this to PlugIn.TimeStep for other extensions
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// map outputs:
//---------------------------------------
//OutputMetadata mapOut_BiomassRemoved = new OutputMetadata()
//{
// Type = OutputType.Map,
// Name = "biomass removed",
// FilePath = @HarvestMapName,
// Map_DataType = MapDataType.Continuous,
// Map_Unit = FieldUnits.Mg_ha,
// Visualize = true,
//};
//Extension.OutputMetadatas.Add(mapOut_BiomassRemoved);
foreach (ISpecies species in PlugIn.speciesToMap)
{
foreach (AgeClass age in PlugIn.ages[species.Name])
{
OutputMetadata mapOut_Species = new OutputMetadata()
{
Type = OutputType.Map,
Name = species.Name,
FilePath = PlugIn.MakeSpeciesMapName(species.Name, age.Name),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_Species);
}
}
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public void FromJson_JObjectWithValidStatistics_ReturnsCorrectResult()
{
var result = ExtensionMetadata.FromJson(JObject.Parse(ValidJson));
Assert.Equal(101, result.Statistics.InstallCount);
Assert.Equal(203, result.Statistics.Downloads);
Assert.Equal(4.77469158172607, result.Statistics.AverageRating);
Assert.Equal(4.7635946102485, result.Statistics.WeightedRating);
Assert.Equal(103, result.Statistics.RatingCount);
Assert.Equal(0.0134154704538845, result.Statistics.TrendingDaily);
Assert.Equal(3.56943172567113, result.Statistics.TrendingWeekly);
Assert.Equal(39.7426646124054, result.Statistics.TrendingMonthly);
}
private async Task UpdateExtensionMetadata(ExtensionMetadata extensionInfo)
{
var result = await _metadataRepository.Update(extensionInfo);
if (result)
{
Log.Information($"Successfully updated '{extensionInfo.Id}'.");
}
else
{
Log.Warning($"Update unsuccessful '{extensionInfo.Id}'.");
}
}
public static void InitializeMetadata(string MapFileTemplate, IEnumerable <IMapDefinition> maps)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(PlugIn.ModelCore)
//Extension = new ExtensionMetadata()
{
Name = PlugIn.ExtensionName,
TimeInterval = PlugIn.ModelCore.CurrentTime, //change this to PlugIn.TimeStep for other extensions
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// map outputs:
//---------------------------------------
//OutputMetadata mapOut_BiomassRemoved = new OutputMetadata()
//{
// Type = OutputType.Map,
// Name = "biomass removed",
// FilePath = @HarvestMapName,
// Map_DataType = MapDataType.Continuous,
// Map_Unit = FieldUnits.Mg_ha,
// Visualize = true,
//};
//Extension.OutputMetadatas.Add(mapOut_BiomassRemoved);
foreach (IMapDefinition map in maps)
{
OutputMetadata mapOut_bioReclass = new OutputMetadata()
{
Type = OutputType.Map,
Name = map.Name,
FilePath = MapFileNames.ReplaceTemplateVars(MapFileTemplate, map.Name, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_bioReclass);
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int Timestep, string SpeciesMapFileName, IEnumerable <ISuitabilityParameters> suitabilityParams, ICore mCore)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime //,
//ProjectionFilePath = "Projection.?"
};
Extension = new ExtensionMetadata(mCore)
{
Name = PlugIn.PlugInName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
// NONE
//---------------------------------------
// map outputs:
//---------------------------------------
foreach (SuitabilityParameters habitatModel in suitabilityParams)
{
string sppMapPath = MapFileNames.ReplaceTemplateVars(SpeciesMapFileName, habitatModel.HabitatName);
OutputMetadata mapOut_LocalHabitat = new OutputMetadata()
{
Type = OutputType.Map,
Name = ("Local Habitat Map: " + habitatModel.HabitatName),
//sppModel.Name,
FilePath = @sppMapPath,
Map_DataType = MapDataType.Continuous,
Map_Unit = "Habitat Class",
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_LocalHabitat);
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public void RefreshGalleryStoreTheme_TakesNewNeedAttentionExtension_UpdatesExtensionTypeMetadata_And_DoesNotRefreshExtension()
{
const string expectedId = "expectedId_test";
const string expectedVersion = "version1";
var newExtensionMetadata = new ExtensionMetadata {
Id = expectedId, Version = expectedVersion
};
var newTheme = new VSCodeTheme
{
Id = expectedId,
Version = expectedVersion,
Themes = new List <Theme> {
new Theme()
}
};
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.GetSavedExtensionType(newExtensionMetadata.Id))
.ReturnsAsync(ExtensionType.Default);
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.GetStoredTheme(newExtensionMetadata.Id))
.ReturnsAsync(() => null);
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.DownloadFreshTheme(newExtensionMetadata))
.ReturnsAsync(newTheme);
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.CheckAndUpdateFreshExtensionType(newTheme))
.ReturnsAsync(ExtensionType.NeedAttention);
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.CreateTheme(It.IsAny <VSCodeTheme>()));
_mock.Mock <IThemeStoreRefresher>()
.Setup(x => x.UpdateTheme(It.IsAny <VSCodeTheme>()));
var mockRefreshService = _mock.Create <ThemeStoreRefreshService>();
mockRefreshService.RefreshGalleryStoreTheme(newExtensionMetadata).Wait();
_mock.Mock <IThemeStoreRefresher>()
.Verify(x => x.GetSavedExtensionType(newExtensionMetadata.Id), Times.Once);
_mock.Mock <IThemeStoreRefresher>()
.Verify(x => x.DownloadFreshTheme(newExtensionMetadata), Times.Once);
_mock.Mock <IThemeStoreRefresher>()
.Verify(x => x.CheckAndUpdateFreshExtensionType(newTheme), Times.Once);
_mock.Mock <IThemeStoreRefresher>()
.Verify(x => x.CreateTheme(It.IsAny <VSCodeTheme>()), Times.Never);
_mock.Mock <IThemeStoreRefresher>()
.Verify(x => x.UpdateTheme(It.IsAny <VSCodeTheme>()), Times.Never);
}
public static void InitializeMetadata()
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(PlugIn.ModelCore)
//Extension = new ExtensionMetadata()
{
Name = PlugIn.ExtensionName,
TimeInterval = PlugIn.Parameters.Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// Table output:
//---------------------------------------
CreateDirectory("Forest Roads Construction Log.csv");
PlugIn.roadConstructionLog = new MetadataTable <RoadLog>("Forest Roads Construction Log.csv");
PlugIn.ModelCore.UI.WriteLine(" Generating event table...");
OutputMetadata tblOut_constructionLog = new OutputMetadata()
{
Type = OutputType.Table,
Name = "Forest Roads Construction Log.csv",
FilePath = "./",
Visualize = true,
};
tblOut_constructionLog.RetriveFields(typeof(RoadLog));
Extension.OutputMetadatas.Add(tblOut_constructionLog);
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int Timestep, string summaryLogName, bool makeTable)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = EcoregionData.ModelCore.CellArea,
TimeMin = EcoregionData.ModelCore.StartTime,
TimeMax = EcoregionData.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(EcoregionData.ModelCore)
{
Name = Names.ExtensionName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
if (makeTable)
{
CreateDirectory(summaryLogName);
SiteVars.summaryLogMortality = new MetadataTable <SummaryLogMortality>(summaryLogName);
EcoregionData.ModelCore.UI.WriteLine(" Generating summary table...");
OutputMetadata tblOut_summary = new OutputMetadata()
{
Type = OutputType.Table,
Name = "SummaryLog",
FilePath = SiteVars.summaryLogMortality.FilePath,
Visualize = true,
};
tblOut_summary.RetriveFields(typeof(SummaryLogMortality));
Extension.OutputMetadatas.Add(tblOut_summary);
}
}
private ExtensionResource CreateExtensionResource(
ExtensionMetadata metadata,
IEnumerable <Theme> storedThemes)
{
var result = _mapper.Map <ExtensionMetadata, ExtensionResource>(metadata);
result.Themes = storedThemes
.Select(theme =>
{
var themeResource = _mapper.Map <Theme, ThemeResource>(theme);
themeResource.TokenColors = theme.TokenColors
.Select(tc => _mapper.Map <TokenColor, TokenColorResource>(tc))
.ToList();
themeResource.Colors = new Dictionary <string, string>(
theme.Colors
.FindAll(c => !string.IsNullOrWhiteSpace(c.Value))
.Select(c => KeyValuePair.Create(c.PropertyName, c.Value)));
return(themeResource);
})
.ToList();
return(result);
}
public static void InitializeMetadata(string summaryLogFileName)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(PlugIn.ModelCore)
{
Name = PlugIn.ExtensionName,
TimeInterval = PlugIn.ModelCore.CurrentTime, //change this to PlugIn.TimeStep for other extensions
ScenarioReplicationMetadata = scenRep
};
CreateDirectory(summaryLogFileName);
PlugIn.summaryLog = new MetadataTable <SummaryLog>(summaryLogFileName);
PlugIn.ModelCore.UI.WriteLine(" Generating summary table...");
OutputMetadata tblOut_summary = new OutputMetadata()
{
Type = OutputType.Table,
Name = "SummaryLog",
FilePath = PlugIn.summaryLog.FilePath,
Visualize = true,
};
tblOut_summary.RetriveFields(typeof(SummaryLog));
Extension.OutputMetadatas.Add(tblOut_summary);
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
/// <summary>
/// Returns list of extensions the user has access to (see
/// http://msdn.microsoft.com/en-us/library/windowsazure/XXXXX.aspx
/// for more information)
/// </summary>
/// <param name='cancellationToken'>
/// Cancellation token.
/// </param>
/// <returns>
/// Result containing list of extensions the user has access to.
/// </returns>
public async Task <ExtensionMetadataListResult> ListAsync(CancellationToken cancellationToken)
{
// Validate
// Tracing
bool shouldTrace = TracingAdapter.IsEnabled;
string invocationId = null;
if (shouldTrace)
{
invocationId = TracingAdapter.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
TracingAdapter.Enter(invocationId, this, "ListAsync", tracingParameters);
}
// Construct URL
string url = "";
url = url + "/extensionsMetadata";
List <string> queryParameters = new List <string>();
queryParameters.Add("api-version=" + Uri.EscapeDataString(this.Client.ApiVersion));
if (queryParameters.Count > 0)
{
url = url + "?" + string.Join("&", queryParameters);
}
string baseUrl = this.Client.BaseUri.AbsoluteUri;
// Trim '/' character from the end of baseUrl and beginning of url.
if (baseUrl[baseUrl.Length - 1] == '/')
{
baseUrl = baseUrl.Substring(0, baseUrl.Length - 1);
}
if (url[0] == '/')
{
url = url.Substring(1);
}
url = baseUrl + "/" + url;
url = url.Replace(" ", "%20");
// Create HTTP transport objects
HttpRequestMessage httpRequest = null;
try
{
httpRequest = new HttpRequestMessage();
httpRequest.Method = HttpMethod.Get;
httpRequest.RequestUri = new Uri(url);
// Set Headers
// Set Credentials
cancellationToken.ThrowIfCancellationRequested();
await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
// Send Request
HttpResponseMessage httpResponse = null;
try
{
if (shouldTrace)
{
TracingAdapter.SendRequest(invocationId, httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
if (shouldTrace)
{
TracingAdapter.ReceiveResponse(invocationId, httpResponse);
}
HttpStatusCode statusCode = httpResponse.StatusCode;
if (statusCode != HttpStatusCode.OK)
{
cancellationToken.ThrowIfCancellationRequested();
CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
if (shouldTrace)
{
TracingAdapter.Error(invocationId, ex);
}
throw ex;
}
// Create Result
ExtensionMetadataListResult result = null;
// Deserialize Response
if (statusCode == HttpStatusCode.OK)
{
cancellationToken.ThrowIfCancellationRequested();
string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
result = new ExtensionMetadataListResult();
JToken responseDoc = null;
if (string.IsNullOrEmpty(responseContent) == false)
{
responseDoc = JToken.Parse(responseContent);
}
if (responseDoc != null && responseDoc.Type != JTokenType.Null)
{
JToken valueArray = responseDoc["value"];
if (valueArray != null && valueArray.Type != JTokenType.Null)
{
foreach (JToken valueValue in ((JArray)valueArray))
{
ExtensionMetadata extensionMetadataInstance = new ExtensionMetadata();
result.ExtensionsMetadata.Add(extensionMetadataInstance);
JToken namespaceValue = valueValue["namespace"];
if (namespaceValue != null && namespaceValue.Type != JTokenType.Null)
{
string namespaceInstance = ((string)namespaceValue);
extensionMetadataInstance.Namespace = namespaceInstance;
}
JToken locationValue = valueValue["location"];
if (locationValue != null && locationValue.Type != JTokenType.Null)
{
string locationInstance = ((string)locationValue);
extensionMetadataInstance.Location = locationInstance;
}
JToken nameValue = valueValue["name"];
if (nameValue != null && nameValue.Type != JTokenType.Null)
{
string nameInstance = ((string)nameValue);
extensionMetadataInstance.Name = nameInstance;
}
JToken endpointUriValue = valueValue["endpointUri"];
if (endpointUriValue != null && endpointUriValue.Type != JTokenType.Null)
{
string endpointUriInstance = ((string)endpointUriValue);
extensionMetadataInstance.EndpointUri = endpointUriInstance;
}
}
}
}
}
result.StatusCode = statusCode;
if (shouldTrace)
{
TracingAdapter.Exit(invocationId, result);
}
return(result);
}
finally
{
if (httpResponse != null)
{
httpResponse.Dispose();
}
}
}
finally
{
if (httpRequest != null)
{
httpRequest.Dispose();
}
}
}
public static void InitializeMetadata(int timestep, ICore mCore)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = Climate.ModelCore.CellArea,
TimeMin = Climate.ModelCore.StartTime,
TimeMax = Climate.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(mCore)
{
Name = "Climate-Library",
TimeInterval = timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
//Climate.PdsiLog = new MetadataTable<PDSI_Log>("Climate-PDSI-log.csv");
Climate.SpinupInputLog = new MetadataTable <InputLog>("Climate-spinup-input-log.csv");
Climate.FutureInputLog = new MetadataTable <InputLog>("Climate-future-input-log.csv");
Climate.AnnualLog = new MetadataTable <AnnualLog>("Climate-annual-log.csv");
OutputMetadata tblOut_spinupInput = new OutputMetadata()
{
Type = OutputType.Table,
Name = "Spinup-Input-Log",
FilePath = Climate.SpinupInputLog.FilePath,
Visualize = false,
};
tblOut_spinupInput.RetriveFields(typeof(InputLog));
Extension.OutputMetadatas.Add(tblOut_spinupInput);
OutputMetadata tblOut_futureInput = new OutputMetadata()
{
Type = OutputType.Table,
Name = "Future-Input-Log",
FilePath = Climate.FutureInputLog.FilePath,
Visualize = false,
};
tblOut_futureInput.RetriveFields(typeof(InputLog));
Extension.OutputMetadatas.Add(tblOut_futureInput);
OutputMetadata tblOut_annual = new OutputMetadata()
{
Type = OutputType.Table,
Name = "Annual-Log",
FilePath = Climate.AnnualLog.FilePath,
Visualize = false,
};
tblOut_annual.RetriveFields(typeof(AnnualLog));
Extension.OutputMetadatas.Add(tblOut_annual);
//---------------------------------------
// map outputs:
//---------------------------------------
// NONE
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(
int Timestep,
string mapNameTemplate,
string pctConiferMapNameTemplate,
string pctDeadFirMapNameTemplate
)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(PlugIn.ModelCore)
//Extension = new ExtensionMetadata()
{
Name = PlugIn.ExtensionName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// map outputs:
//---------------------------------------
//OutputMetadata mapOut_BiomassRemoved = new OutputMetadata()
//{
// Type = OutputType.Map,
// Name = "biomass removed",
// FilePath = @HarvestMapName,
// Map_DataType = MapDataType.Continuous,
// Map_Unit = FieldUnits.Mg_ha,
// Visualize = true,
//};
//Extension.OutputMetadatas.Add(mapOut_BiomassRemoved);
OutputMetadata mapOut_Fuel = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Fuel Map",
FilePath = MapNames.ReplaceTemplateVars(mapNameTemplate, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
};
OutputMetadata mapOut_Confir = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Conifer Map",
FilePath = MapNames.ReplaceTemplateVars(pctConiferMapNameTemplate, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
};
OutputMetadata mapOut_Dead = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Dead Fir Map",
FilePath = MapNames.ReplaceTemplateVars(pctDeadFirMapNameTemplate, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_Fuel);
Extension.OutputMetadatas.Add(mapOut_Confir);
Extension.OutputMetadatas.Add(mapOut_Dead);
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public ExtensionMetadataParser(ExtensionMetadata extensionMetadata) => _extensionMetadata = extensionMetadata;
public static void InitializeMetadata(string speciesAgeMap, string siteAgeMap, string siteSpeciesMap, Dictionary <string, IEnumerable <ISpecies> > ageStatSpecies, List <string> siteAgeStats, List <string> siteSppStats)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(PlugIn.ModelCore)
//Extension = new ExtensionMetadata()
{
Name = PlugIn.ExtensionName,
TimeInterval = PlugIn.ModelCore.CurrentTime,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// map outputs:
//---------------------------------------
//OutputMetadata mapOut_BiomassRemoved = new OutputMetadata()
//{
// Type = OutputType.Map,
// Name = "biomass removed",
// FilePath = @HarvestMapName,
// Map_DataType = MapDataType.Continuous,
// Map_Unit = FieldUnits.Mg_ha,
// Visualize = true,
//};
//Extension.OutputMetadatas.Add(mapOut_BiomassRemoved);
foreach (KeyValuePair <string, IEnumerable <ISpecies> > sppAgeStatIter in ageStatSpecies)
{
CohortUtils.SpeciesCohortStatDelegate species_stat_func;
switch (sppAgeStatIter.Key)
{
case "MAX":
species_stat_func = new CohortUtils.SpeciesCohortStatDelegate(CohortUtils.GetMaxAge);
break;
case "MIN":
species_stat_func = new CohortUtils.SpeciesCohortStatDelegate(CohortUtils.GetMinAge);
break;
case "MED":
species_stat_func = new CohortUtils.SpeciesCohortStatDelegate(CohortUtils.GetMedianAge);
break;
case "AVG":
species_stat_func = new CohortUtils.SpeciesCohortStatDelegate(CohortUtils.GetAvgAge);
break;
case "SD":
species_stat_func = new CohortUtils.SpeciesCohortStatDelegate(CohortUtils.GetStdDevAge);
break;
default:
//this shouldn't ever occur
System.Console.WriteLine("Unhandled statistic: {0}, using MaxAge Instead", sppAgeStatIter.Key);
species_stat_func = new CohortUtils.SpeciesCohortStatDelegate(CohortUtils.GetMaxAge);
break;
}
foreach (ISpecies species in sppAgeStatIter.Value)
{
OutputMetadata mapOut_age_stats = new OutputMetadata()
{
Type = OutputType.Map,
Name = species.Name + "_age_stats_map",
FilePath = SpeciesMapNames.ReplaceTemplateVars(speciesAgeMap, species.Name, sppAgeStatIter.Key, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_age_stats);
}
}
foreach (string ageStatIter in siteAgeStats)
{
CohortUtils.SiteCohortStatDelegate site_stat_func;
switch (ageStatIter)
{
case "MAX":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetMaxAge);
break;
case "MIN":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetMinAge);
break;
case "MED":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetMedianAge);
break;
case "AVG":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetAvgAge);
break;
case "SD":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetStdDevAge);
break;
case "COUNT":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetCohortCount);
break;
case "RICH":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetAgeRichness);
break;
case "EVEN":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetAgeEvenness);
break;
default:
System.Console.WriteLine("Unhandled statistic: {0}, using MaxAge Instead", ageStatIter);
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetMaxAge);
break;
}
OutputMetadata mapOut_site_age_stats = new OutputMetadata()
{
Type = OutputType.Map,
Name = ageStatIter + "_age_stats_map",
FilePath = SiteMapNames.ReplaceTemplateVars(siteAgeMap, ageStatIter, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_site_age_stats);
}
foreach (string sppStatIter in siteSppStats)
{
CohortUtils.SiteCohortStatDelegate site_stat_func;
switch (sppStatIter)
{
case "RICH":
//FIXME
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetSppRichness);
break;
//add in richness
default:
System.Console.WriteLine("Unhandled statistic: {0}, using Species Richness Instead", sppStatIter);
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetSppRichness);
break;
}
OutputMetadata mapOut_site_species_stats = new OutputMetadata()
{
Type = OutputType.Map,
Name = sppStatIter + "_age_stats_map",
FilePath = SiteMapNames.ReplaceTemplateVars(siteSpeciesMap, sppStatIter, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_site_species_stats);
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
