/// <summary> /// CTOR of Compass. /// </summary> public Compass() { InitializeComponent(); MetadataModel.CreateModel(); this.vm = new MetadataViewModel(MetadataModel.Instance); this.DataContext = this.vm; }
/// <summary> /// Metadata page. /// </summary> /// <param name="uuid"></param> /// <param name="organization"></param> /// <param name="title"></param> /// <param name="orderby"></param> /// <returns>/metadata/{organization}/{title}/{uuid}</returns> public ActionResult Index(string uuid, string organization = null, string title = null, string orderby = "title") { MetadataViewModel model = null; //try //{ model = _metadataService.GetMetadataViewModelByUuid(uuid); model = Sort(model, orderby); //} //catch (InvalidOperationException exception) //{ // Log.Error("Metadata with uuid: " + uuid + " not found in Geonetwork.", exception); // //throw new Exception("Metadata with uuid: " + uuid + " not found in Geonetwork."); //} if (model == null) { Log.Error("Metadata with uuid: " + uuid + " not found."); return(new HttpNotFoundResult("Metadata with uuid: " + uuid + " not found in Geonetwork.")); } SeoUrl url = model.CreateSeoUrl(); if (!url.Matches(organization, title) && !string.IsNullOrWhiteSpace(organization)) { return(RedirectToActionPermanent("Index", new { organization = url.Organization, title = url.Title, uuid = uuid })); } return(View(model)); }
private void model_PropertyChanged(object sender, PropertyChangedEventArgs e) { MetadataViewModel model = sender as MetadataViewModel; DataGridRow changedRow = GetDataGridRowByDataContext(NodeMetadataDataGrid, model); if (e.PropertyName == "MetadataName") { bool nameChanged = HasNameChanged(model.MetadataName); if (nameChanged) { MarkChanged(model, changedRow, true); } else { MarkChanged(model, changedRow, false); } } else { if (IsEqualToOriginal(model)) { MarkChanged(model, changedRow, false); _changes[model.OriginalMetadataName.ToLower()] = false; } else { MarkChanged(model, changedRow, true); _changes[model.OriginalMetadataName.ToLower()] = true; } } }
private bool IsEqualToOriginal(MetadataViewModel metadata) { bool result = false; foreach (KeyValuePair <MetadataContext, MetadataViewModel> pair in _original) { MetadataContext context = pair.Key; MetadataViewModel model = pair.Value; if (context.NodeUid.Value == metadata.NodeUid && model.MetadataName == metadata.OriginalMetadataName) { if (context.DescriptorTypeUid.HasValue && context.DescriptorTypeUid.Value != metadata.DescriptorTypeUid) { continue; } if (context.RelationshipUid.HasValue && context.RelationshipUid.Value != metadata.RelationshipUid) { continue; } //the context is the same so compare the items if (model.Equals(metadata)) { return(true); } else { return(false); } } } return(result); }
public void delete_after_failed_delete() { // ARRANGE var metadata = new Metadata(new Uri("http://localhost/test/1"), true); _restClient.Setup(x => x.DeleteAsync(It.IsAny <Uri>())).Throws(new Exception("Foo")); var viewModel = new MetadataViewModel(metadata, _modifyResourceFactory, _exceptionFactory, _restClient.Object, _messageService.Object, SchedulerService); TestScheduler.AdvanceBy(TimeSpan.FromMilliseconds(100)); var deleted = 0; viewModel.Deleted.Subscribe(x => deleted++); // ACT viewModel.DeleteCommand.Execute(null); TestScheduler.AdvanceBy(TimeSpan.FromMilliseconds(100)); var result = new Mock <IRestResponse>(); var task = Task.FromResult(result.Object); _restClient.Setup(x => x.DeleteAsync(It.IsAny <Uri>())).Returns(() => task).Verifiable(); viewModel.DeleteCommand.Execute(null); TestScheduler.AdvanceBy(TimeSpan.FromMilliseconds(100)); // ASSERT Assert.That(deleted, Is.EqualTo(1)); _restClient.VerifyAll(); }
public async Task <MetadataViewModel> CreateMetaData(MetadataViewModel model) { database.Add(model); // Returned rescourse presumably with the newy-inserted id return(await Task.Run(() => model)); }
private void MapDatasetToMetadataViewModel(Dataset dataset, MetadataViewModel model, OpenMetadataEndpoint openMetadataEndpoint) { model.Title = dataset.title; DateTime modified; if (DateTime.TryParse(dataset.modified.ToString(), out modified)) { model.DateUpdated = modified; } DateTime issued; if (DateTime.TryParse(dataset.issued, out issued)) { model.DatePublished = issued; } model.ContactMetadata.Organization = !string.IsNullOrEmpty(openMetadataEndpoint.OrganizationName) ? openMetadataEndpoint.OrganizationName : dataset.publisher.name; model.ContactMetadata.Email = dataset.contactPoint.hasEmail.Replace("mailto:", ""); model.ContactMetadata.Name = dataset.contactPoint.fn; model.ContactPublisher.Organization = model.ContactMetadata.Organization; model.ContactPublisher.Email = model.ContactMetadata.Email; model.ContactPublisher.Name = model.ContactMetadata.Name; model.ContactOwner.Organization = model.ContactMetadata.Organization; model.ContactOwner.Email = model.ContactMetadata.Email; model.ContactOwner.Name = model.ContactMetadata.Name; model.Abstract = dataset.description; if (dataset.keyword != null && dataset.keyword.Length > 0) { model.KeywordsOther = dataset.keyword.ToList(); } model.DistributionsFormats = GetDistributionsFormats(dataset.distribution, model.ContactMetadata.Organization); if (string.IsNullOrEmpty(model.MaintenanceFrequency)) { model.MaintenanceFrequency = "unknown"; } var spatial = dataset.spatial.Split(','); if (spatial.Length == 4) { model.BoundingBoxWest = spatial[0]; model.BoundingBoxSouth = spatial[1]; model.BoundingBoxEast = spatial[2]; model.BoundingBoxNorth = spatial[3]; } model.AccessConstraints = "no restrictions"; }
private void ResetOriginals() { lock (_original) { _original.Clear(); foreach (MetadataContext context in NodeProxy.Metadata.Keys) { /* The 'Note' property has it's own editor panel intended for more text * The 'XPosition' and 'YPosition' are control via the map positioning * The 'Name' is the node text and editing is done via the node directly * The 'Created' and 'Modified' timestamps should not be able to be changed. * TODO: Decide if the CreatedBy and ModifiedBy properties should be editable. ***/ if (context.MetadataName != "Note" && context.MetadataName != "XPosition" && context.MetadataName != "YPosition" && context.MetadataName != "Name" && context.MetadataName != "Created" && context.MetadataName != "Modified" && context.MetadataName != "CollapseState" && context.MetadataName != "Visibility") { MetadataViewModel model = new MetadataViewModel(context, NodeProxy.Metadata[context]); if (!ContainsOriginal(context)) { _original.Add(context, model.Clone()); } } } } }
/// <summary> /// Initializes a new instance of the <see cref="MainWindow"/> class. /// </summary> public MainWindow() { InitializeComponent(); var locator = Application.Current.FindResource("Locator") as ViewModelLocator; this._settingsViewModel = locator.Settings; this._mainViewModel = locator.Main; this._h264SettingsViewModel = locator.H264Settings; this._metadataViewModel = locator.Metadata; this._recorderViewModel = locator.RecorderSettings; this._mainViewModel.FFmpegStarting += this.MainViewModelFFmpegStarting; this._mainViewModel.DispatchEvent += this.MainViewModelDispatchEvent; this._recorderViewModel.DispatchEvent += this.MainViewModelDispatchEvent; if (App.Args == null) { return; } if (App.Args.Contains("-debug")) { this.DebugCheckBox.Visibility = Visibility.Visible; } }
public MetadataWindow(MetadataViewModel viewModel) { ViewModel = viewModel; ViewModel.DialogCloseRequested += ViewModel_DialogCloseRequested; InitializeComponent(); }
public ActionResult CreateMetadataForLayers(string uuid, string wmsUrl, String[] selectedLayers, string[] keywords) { MetadataViewModel metadata = _metadataService.GetMetadataModel(uuid); WmsServiceViewModel serviceModel = _wmsServiceParser.GetLayers(wmsUrl); List <WmsLayerViewModel> createMetadataForLayers = new List <WmsLayerViewModel>(); if (selectedLayers != null) { foreach (var layer in serviceModel.Layers) { if (selectedLayers.Contains(layer.Name)) { createMetadataForLayers.Add(layer); } } } string username = GetUsername(); List <WmsLayerViewModel> newlyCreatedLayerMetadata = _metadataService.CreateMetadataForLayers(uuid, createMetadataForLayers, keywords, username); ServiceLayerViewModel model = new ServiceLayerViewModel { Metadata = metadata, Layers = newlyCreatedLayerMetadata, WmsUrl = wmsUrl, }; return(View("LayersCreated", model)); }
public ActionResult Index(string uuid, string wmsUrl) { if (string.IsNullOrWhiteSpace(uuid)) { return(HttpNotFound()); } MetadataViewModel metadata = _metadataService.GetMetadataModel(uuid); if (string.IsNullOrWhiteSpace(wmsUrl)) { wmsUrl = metadata.DistributionUrl; } WmsServiceViewModel serviceModel = null; try { serviceModel = _wmsServiceParser.GetLayers(wmsUrl); } catch (Exception e) { ViewBag.Message = "Feil ved henting av GetCapabilities: " + e.Message; } ServiceLayerViewModel model = new ServiceLayerViewModel { Metadata = metadata, Layers = serviceModel != null ? serviceModel.Layers : new List <WmsLayerViewModel>(), WmsUrl = wmsUrl, }; return(View(model)); }
public Dictionary <string, string> GetRegister(string registername, MetadataViewModel model) { string role = GetSecurityClaim("role"); MemoryCacher memCacher = new MemoryCacher(); var cache = memCacher.GetValue("registeritem-" + registername); List <RegisterItem> RegisterItems = new List <RegisterItem>(); if (cache != null) { RegisterItems = cache as List <RegisterItem>; } if (RegisterItems.Count < 1) { System.Net.WebClient c = new System.Net.WebClient(); c.Encoding = System.Text.Encoding.UTF8; var data = c.DownloadString(System.Web.Configuration.WebConfigurationManager.AppSettings["RegistryUrl"] + "api/register/" + registername); var response = Newtonsoft.Json.Linq.JObject.Parse(data); var items = response["containeditems"]; foreach (var item in items) { var id = item["id"].ToString(); var owner = item["owner"].ToString(); string organization = item["owner"].ToString(); var registerItem = new RegisterItem { Id = id, Label = item["label"].ToString(), Organization = organization }; if (!RegisterItems.Contains(registerItem)) { RegisterItems.Add(registerItem); } } var logLines = RegisterItems.Select(l => l.Id + ": " + l.Label); Log.Info(string.Format("Setting cache for registername: {0}, items: " + Environment.NewLine + " {1}", registername, string.Join(Environment.NewLine, logLines))); memCacher.Set("registeritem-" + registername, RegisterItems, new DateTimeOffset(DateTime.Now.AddYears(1))); } Dictionary <string, string> RegisterItemsForUser = new Dictionary <string, string>(); foreach (var item in RegisterItems) { if (!string.IsNullOrWhiteSpace(role) && role.Equals("nd.metadata_admin") || model.HasAccess(item.Organization)) { RegisterItemsForUser.Add(item.Id, item.Label); } } RegisterItemsForUser = RegisterItemsForUser.OrderBy(o => o.Value).ToDictionary(o => o.Key, o => o.Value); return(RegisterItemsForUser); }
public MainViewModel(PhotoService photoService, Viewport viewport, MusicLoader musicLoader) { this.photoService = photoService; this.viewport = viewport; this.musicLoader = musicLoader; Metadata = new MetadataViewModel(); }
private bool HasAccessToMetadata(MetadataViewModel model) { string organization = GetSecurityClaim("organization"); string role = GetSecurityClaim("role"); bool isAdmin = !string.IsNullOrWhiteSpace(role) && role.Equals("nd.metadata_admin"); return(isAdmin || model.HasAccess(organization)); }
public ActionResult Index(string uuid, string type = "default") { try { MetadataViewModel model = _metadataService.GetMetadataViewModelByUuid(uuid); if (model.Thumbnails != null && model.Thumbnails.Any()) { Thumbnail thumbnail = model.Thumbnails[0]; Thumbnail thumbnailSmall = null; Thumbnail thumbnailMedium = null; Thumbnail thumbnailLarge = null; foreach (var thumb in model.Thumbnails) { if (thumb.Type == "thumbnail" || thumb.Type == "miniatyrbilde") { thumbnailSmall = thumb; } else if (thumb.Type == "medium") { thumbnailMedium = thumb; } else if (thumb.Type == "large_thumbnail") { thumbnailLarge = thumb; } } if (thumbnailSmall != null && type != null && string.Equals(type, "small", StringComparison.InvariantCultureIgnoreCase)) { thumbnail = thumbnailSmall; } else if (thumbnailMedium != null && type != null && string.Equals(type, "medium", StringComparison.InvariantCultureIgnoreCase)) { thumbnail = thumbnailMedium; } else if (thumbnailSmall != null && type != null && string.Equals(type, "medium", StringComparison.InvariantCultureIgnoreCase)) { thumbnail = thumbnailSmall; } else if (thumbnailLarge != null && type != null && string.Equals(type, "large", StringComparison.InvariantCultureIgnoreCase)) { thumbnail = thumbnailLarge; } string url = thumbnail.URL; string mimeType = GetMimeTypeFromUrl(url); Stream stream = DownloadImage(url); return(new FileStreamResult(stream, mimeType)); } } catch (Exception exception) { Log.Error("Metadata with uuid: " + uuid + " not found in Geonetwork.", exception); } return(HttpNotFound()); }
public async Task <ActionResult> Edit(string uuid, bool displayLog = false, bool displayLogLatest = false, int limitNumberOfEntries = 50, string operation = "") { if (string.IsNullOrWhiteSpace(uuid)) { return(HttpNotFound()); } try { ViewBag.DisplayLog = displayLog; ViewBag.DisplayLogLatest = displayLogLatest; ViewBag.limitNumberOfEntries = limitNumberOfEntries; ViewBag.operation = operation; if (displayLogLatest) { ViewBag.LogEntries = await _metadataService.GetLogEntriesLatest(limitNumberOfEntries, operation); } else if (displayLog) { ViewBag.LogEntries = await _metadataService.GetLogEntries(uuid); } MetadataViewModel model = _metadataService.GetMetadataModel(uuid); string role = GetSecurityClaim("role"); if (!string.IsNullOrWhiteSpace(role) && role.Equals("nd.metadata_admin")) { model.ValidateAllRequirements = true; } if (HasAccessToMetadata(model)) { if (model.MetadataStandard == "ISO19115:Norsk versjon" && Request.QueryString["editor"] == null) { return(RedirectToAction("Edit", "SimpleMetadata", new { uuid = uuid })); } PrepareViewBagForEditing(model); if (Request.QueryString["metadatacreated"] == null) { TryValidateModel(model); ValidateModel(model); } return(View(model)); } else { TempData["failure"] = "Du har ikke tilgang til å redigere disse metadataene"; return(View("Error")); } } catch (Exception e) { //Log.Error("Error while getting metadata with uuid = " + uuid, e); throw new Exception("Error while getting metadata with uuid = " + uuid, e); //TempData["failure"] = "Feilmelding: " + e.Message; //return View("Error"); } }
/* ----------------------------------------------------------------- */ /// /// Set /// /// <summary> /// ViewModel に設定内容を反映させます。 /// </summary> /// /* ----------------------------------------------------------------- */ private void Set(MetadataViewModel vm, Metadata src) { vm.Title = src.Title; vm.Author = src.Author; vm.Subject = src.Subject; vm.Keywords = src.Keywords; vm.Creator = src.Creator; vm.Options = src.Options; }
public MetadataView() { _currentView = this; _vm = new MetadataViewModel(this); DataContext = _vm; InitializeComponent(); var mw = MainWindow.GetMainWindow(); mw.SelectedPrimaryItemValueChanged += Mw_SelectedPrimaryItemValueChanged; }
/// <summary> /// Method to get the metadata view model /// </summary> /// <param name="currentPage">The current page</param> /// <returns>Metadata view model</returns> public MetadataViewModel GetMetadata(IPublishedContent currentPage) { var model = new MetadataViewModel { AbsoluteUrl = currentPage.UrlAbsolute() }; Mapper.Map(currentPage, model); return(model); }
private void ValidateModel(MetadataViewModel model) { ViewBag.thumbnailMissingCSS = ""; var thumb = model.Thumbnails.Where(t => t.Type == "thumbnail" || t.Type == "miniatyrbilde"); if (thumb.Count() == 0) { ModelState.AddModelError("thumbnailMissing", UI.ImageRequired); ViewBag.thumbnailMissingCSS = "input-validation-error"; } }
private void SaveMetadataToCswServer(MetadataViewModel model) { try { _metadataService.SaveMetadataModel(model, GetUsername()); TempData["success"] = UI.Metadata_Edit_Saved_Success; } catch (Exception e) { Log.Error("Error while editing metadata with uuid = " + model.Uuid, e); TempData["failure"] = String.Format(UI.Metadata_Edit_Saved_Failure, e.Message); } }
private void EditMetadataButton_Click(object sender, RoutedEventArgs e) { MetadataViewModel selectedMetadata = NodeMetadataDataGrid.SelectedItem as MetadataViewModel; if (selectedMetadata != null) { EditMetadataDialog editMetadataDialog = new EditMetadataDialog(); editMetadataDialog.Closed += new EventHandler(EditMetadataDialog_Closed); editMetadataDialog.MetadataTypeUid = selectedMetadata.MetadataTypeUid; editMetadataDialog.Value = selectedMetadata.MetadataValue; editMetadataDialog.MetadataName = selectedMetadata.MetadataName; editMetadataDialog.Show(); } }
public PropertiesWindow() { InitializeComponent(); var loc = App.Current.FindResource("Locator") as ViewModelLocator; this._genSettings = loc.Settings; this._h264Settins = loc.H264Settings; this._recorderSettings = loc.RecorderSettings; this._metadataSettings = loc.Metadata; this._secureSettings = loc.Security; this.SetSecureData(); }
private void EditMetadataDialog_Closed(object sender, EventArgs e) { MetadataViewModel selectedMetadata = NodeMetadataDataGrid.SelectedItem as MetadataViewModel; EditMetadataDialog dialog = sender as EditMetadataDialog; if (dialog != null && dialog.DialogResult.Value == true) { selectedMetadata.MetadataValue = dialog.Value; selectedMetadata.MetadataTypeUid = dialog.MetadataTypeUid; if (!IsEqualToOriginal(selectedMetadata)) { _changes[selectedMetadata.OriginalMetadataName.ToLower()] = true; } } }
private void NodeMetadataDataGrid_SelectionChanged(object sender, SelectionChangedEventArgs e) { MetadataViewModel selectedMetadata = NodeMetadataDataGrid.SelectedItem as MetadataViewModel; if (selectedMetadata != null) { EditMetadataButton.IsEnabled = true; DeleteMetadataButton.IsEnabled = true; } else { EditMetadataButton.IsEnabled = false; DeleteMetadataButton.IsEnabled = false; } }
private void MarkChanged(MetadataViewModel model, DataGridRow changedRow, bool changed) { if (changed) { SaveButton.IsEnabled = true; changedRow.Foreground = new SolidColorBrush(Colors.Red); } else { if (!HasChanges) //checks if there are any other changes before resetting the Save button { SaveButton.IsEnabled = false; //if there are no other changes } changedRow.Foreground = new SolidColorBrush(Colors.Black); } }
private void SaveButton_Click(object sender, RoutedEventArgs e) { foreach (MetadataViewModel metadata in _metadata.Where(md => md.OriginalMetadataName != md.MetadataName)) { NodeProxy.RenameNodeMetadata(metadata.GetContext(), metadata.MetadataName); _metadataNames.Remove(metadata.OriginalMetadataName); _metadataNames.Add(metadata.MetadataName); metadata.UpdateName(); } if (HasChanges) { TypeManager typeManager = IoC.IoCContainer.GetInjectionInstance().GetInstance <TypeManager>(); IMetadataTypeProxy[] metaDataTypes = typeManager.GetAllMetadataTypes(); foreach (KeyValuePair <string, bool> changedMetadata in _changes.Where(changed => changed.Value == true)) { //only update the changed items try { MetadataViewModel metadata = _metadata.Single(m => m.MetadataName.ToLower() == changedMetadata.Key.ToLower()); if (metadata != null) { NodeProxy.SetNodeMetadata(metadata.GetContext(), metadata.MetadataValue, metaDataTypes.Single(md => md.Id == metadata.MetadataTypeUid)); } } catch (Exception) { //ignore any errors if the changed metadata isn't found } } _changes.Clear(); foreach (MetadataViewModel deletedItem in _deletedItems) { NodeProxy.DeleteNodeMetadata(deletedItem.GetContext()); } _deletedItems.Clear(); } SaveButton.IsEnabled = false; ResetOriginals(); ClearChangeIndicator(); }
public void modify() { // ARRANGE var metadata = new Metadata(new Uri("http://localhost/test/1"), true); var viewModel = new MetadataViewModel(metadata, _modifyResourceFactory, _exceptionFactory, _restClient.Object, _messageService.Object, SchedulerService); TestScheduler.AdvanceBy(TimeSpan.FromMilliseconds(100)); // ACT viewModel.ModifyCommand.Execute(null); TestScheduler.AdvanceBy(TimeSpan.FromMilliseconds(100)); // ASSERT _messageService.VerifyAll(); }
public ActionResult Delete(string uuid) { MetadataViewModel model = _metadataService.GetMetadataModel(uuid); string role = GetSecurityClaim("role"); if (HasAccessToMetadata(model)) { _metadataService.DeleteMetadata(model, GetUsername()); TempData["Message"] = "Metadata med uuid " + uuid + " ble slettet."; return(RedirectToAction("Index")); } else { return(new HttpUnauthorizedResult()); } }
private void LoadData() { _reader = new PackageReader(); _reader.Read(PathToFile); PackageViewModel = new PackageViewModel(_reader); MetadataViewModel = new MetadataViewModel(_reader); ManifestViewModel = new ManifestViewModel(_reader); RequiresViewModel = new RequiresViewModel(_reader); DefineViewModel = new DefineViewModel(_reader); SigningViewModel = new SigningViewModel(_reader); LicenseViewModel = new LicenseViewModel(_reader); CompatibilityPolicy = new CompatibilityPolicyViewModel(_reader); ApplicationRoleViewModel = new ApplicationRoleViewModel(_reader); AssemblyRoleViewModel = new AssemblyRoleViewModel(_reader); FilesViewModel = new FilesViewModel(_reader); //PackageCompositionViewModel = new PackageCompositionViewModel(_reader); //_allViewModels.Add(PackageViewModel); }
private void CreateModels(PackageReader reader) { string package = "package"; _packageViewModel = new PackageViewModel() { Name = reader.GetRulesPropertyValueByName(package, "name"), DisplayName = reader.GetRulesPropertyValueByName(package, "display-name"), Architecture = reader.GetRulesPropertyValueByName(package, "arch"), Feed = reader.GetRulesPropertyValueByName(package, "feed"), Location = reader.GetRulesPropertyValueByName(package, "location"), Publisher = reader.GetRulesPropertyValueByName(package, "publisher"), Version = reader.GetRulesPropertyValueByName(package, "version") }; string metadata = "metadata"; _metadataViewModel = new MetadataViewModel() { Summary = reader.GetRulesPropertyValueByName(metadata, "summary"), Description = reader.GetRulesPropertyValueByName(metadata, "description"), AuthorVersion = reader.GetRulesPropertyValueByName(metadata, "author-version"), BugTracker = reader.GetRulesPropertyValueByName(metadata, "bug-tracker"), Stability = reader.GetRulesPropertyValueByName(metadata, "stability"), Licenses = reader.GetRulesPropertyValueByName(metadata, "licenses"), }; //_requiresViewModel = new RequiresViewModel() //{ // RequiredPackages = new ObservableCollection<Package>() //}; _packageCompositionViewModel = new PackageCompositionViewModel() { Symlinks = reader.GetRulesPropertyValueByName("package-composition", "symlinks") }; _packageCompositionViewModel = new PackageCompositionViewModel() { Symlinks = reader.GetRulesPropertyValueByName("package-composition", "symlinks") }; _filesCollection = new ObservableCollection<FilesViewModel>(); foreach (string parameter in reader.ReadFilesParameters()) { ObservableCollection<string> collection = new ObservableCollection<string>(reader.GetFilesIncludeList(parameter)); FilesViewModel model = new FilesViewModel(parameter) { Root = reader.GetFilesRulesPropertyValueByParameterAndName(parameter,"root"), TrimPath = reader.GetFilesRulesPropertyValueByParameterAndName(parameter, "trim-path"), Include = collection }; _filesCollection.Add(model); } }