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); }