private async Task TryRemoveHiddenDependenciesAsync(SavedTemplateViewModel savedTemplate)
{
foreach (var identity in savedTemplate.Dependencies)
{
var dependency = Features.FirstOrDefault(f => f.Identity == identity.Identity);
if (dependency == null)
{
dependency = Pages.FirstOrDefault(p => p.Identity == identity.Identity);
}
if (dependency != null)
{
// If the template is not hidden we can not remove it because it could be added in wizard
if (dependency.IsHidden)
{
// Look if there are another saved template that depends on it.
// For example, if it's added two different chart pages, when remove the first one SampleDataService can not be removed, but if no saved templates use SampleDataService, it can be removed.
if (!Features.Any(sf => sf.Dependencies.Any(d => d.Identity == dependency.Identity)) || Pages.Any(p => p.Dependencies.Any(d => d.Identity == dependency.Identity)))
{
await RemoveAsync(dependency);
}
}
}
}
}
private async Task <IEnumerable <SavedTemplateViewModel> > RemoveAsync(SavedTemplateViewModel savedTemplate)
{
// Look if is there any templates that depends on item
var dependencies = GetSavedTemplateDependencies(savedTemplate);
if (!dependencies.Any())
{
var group = GetGroup(savedTemplate.TemplateType);
if (group.Items.Contains(savedTemplate))
{
group.Remove(savedTemplate);
}
if (savedTemplate.HasErrors)
{
await NotificationsControl.CleanErrorNotificationsAsync(ErrorCategory.NamingValidation);
WizardStatus.Current.HasValidationErrors = false;
}
var template = MainViewModel.Instance.GetTemplate(savedTemplate.Template);
template?.DecreaseSelection();
await TryRemoveHiddenDependenciesAsync(savedTemplate);
UpdateHasItemsAddedByUser();
BuildLicenses();
CheckForMissingVersions();
AppHealth.Current.Telemetry.TrackEditSummaryItemAsync(EditItemActionEnum.Remove).FireAndForget();
}
return(dependencies);
}
public async Task DeleteSavedTemplateAsync(SavedTemplateViewModel template)
{
var group = GetGroup(template.TemplateType);
if (template.IsReadOnly)
{
await ShowReadOnlyNotificationAsync(template.Name);
return;
}
int newIndex = group.Items.IndexOf(template) - 1;
newIndex = newIndex >= 0 ? newIndex : 0;
var dependencies = await RemoveAsync(template);
if (dependencies != null && dependencies.Any())
{
await ShowDependencyNotificationAsync(template.Name, dependencies.Select(t => t.Name));
}
else if (group.Items.Any())
{
newIndex = newIndex < group.Items.Count ? newIndex : group.Items.Count - 1;
group.SelectedItem = group.Items.ElementAt(newIndex);
group.SelectedItem.IsFocused = true;
}
}
private async Task <SavedTemplateViewModel> RemoveAsync(SavedTemplateViewModel savedTemplate)
{
// Look if is there any templates that depends on item
var dependency = GetSavedTemplateDependency(savedTemplate);
if (dependency == null)
{
if (Pages.Contains(savedTemplate))
{
Pages.Remove(savedTemplate);
}
else if (Features.Contains(savedTemplate))
{
Features.Remove(savedTemplate);
}
if (savedTemplate.HasErrors)
{
await NotificationsControl.Instance.CleanErrorNotificationsAsync(ErrorCategory.NamingValidation);
}
RaiseCollectionChanged(savedTemplate.TemplateType);
var template = MainViewModel.Instance.GetTemplate(savedTemplate.Template);
template?.DecreaseSelection();
await TryRemoveHiddenDependenciesAsync(savedTemplate);
UpdateHasItemsAddedByUser();
BuildLicenses();
AppHealth.Current.Telemetry.TrackEditSummaryItemAsync(EditItemActionEnum.Remove).FireAndForget();
}
return(dependency);
}
public async Task RemoveTemplateAsync(SavedTemplateViewModel savedTemplate)
{
var dependency = await RemoveAsync(savedTemplate);
if (dependency != null)
{
var message = string.Format(StringRes.NotificationRemoveError_Dependency, savedTemplate.Name, dependency.Name);
var notification = Notification.Warning(message, Category.RemoveTemplateValidation);
await NotificationsControl.Instance.AddNotificationAsync(notification);
}
}
private SavedTemplateViewModel GetSavedTemplateDependency(SavedTemplateViewModel savedTemplate)
{
SavedTemplateViewModel dependencyItem = null;
dependencyItem = Pages.FirstOrDefault(p => p.Dependencies.Any(d => d.Identity == savedTemplate.Identity));
if (dependencyItem == null)
{
dependencyItem = Features.FirstOrDefault(f => f.Dependencies.Any(d => d.Identity == savedTemplate.Identity));
}
return(dependencyItem);
}
public async Task AddAsync(TemplateOrigin templateOrigin, TemplateInfoViewModel template, string layoutName = null, bool isReadOnly = false)
{
if (template.IsGroupExclusiveSelection)
{
var collection = GetCollection(template.TemplateType);
var exclusiveSelectionAddedTemplates = collection.Where(f => f.Group == template.Group).ToList();
foreach (var exclusiveFeature in exclusiveSelectionAddedTemplates)
{
await RemoveAsync(exclusiveFeature);
}
}
foreach (var dependency in template.Template.Dependencies)
{
var dependencyTemplate = MainViewModel.Instance.GetTemplate(dependency);
if (dependencyTemplate == null)
{
// Case of hidden templates, it's not found on templat lists
dependencyTemplate = new TemplateInfoViewModel(dependency, _platform, _projectTypeName, _frameworkName);
}
await AddAsync(templateOrigin, dependencyTemplate);
}
template.IncreaseSelection();
var savedTemplate = new SavedTemplateViewModel(template, templateOrigin, isReadOnly);
var focus = false;
if (!IsTemplateAdded(template) || template.MultipleInstance)
{
if (!string.IsNullOrEmpty(layoutName))
{
savedTemplate.SetName(layoutName, true);
}
else
{
savedTemplate.SetName(ValidationService.InferTemplateName(template.Name, template.ItemNameEditable, template.ItemNameEditable), true);
if (savedTemplate.ItemNameEditable)
{
focus = true;
}
}
AddToGroup(template.TemplateType, savedTemplate);
UpdateHasItemsAddedByUser();
BuildLicenses();
if (focus)
{
savedTemplate.IsTextSelected = true;
}
}
}
public void Add(TemplateOrigin templateOrigin, TemplateInfoViewModel template, string layoutName = null)
{
var dependencies = GenComposer.GetAllDependencies(template.Template, _frameworkName);
foreach (var dependency in dependencies)
{
var dependencyTemplate = MainViewModel.Instance.GetTemplate(dependency);
if (dependencyTemplate == null)
{
// Case of hidden templates, it's not found on templat lists
dependencyTemplate = new TemplateInfoViewModel(dependency, _frameworkName);
}
Add(TemplateOrigin.Dependency, dependencyTemplate);
}
template.IncreaseSelection();
var savedTemplate = new SavedTemplateViewModel(template, templateOrigin);
var focus = false;
if (!IsTemplateAdded(template) || template.MultipleInstance)
{
if (!string.IsNullOrEmpty(layoutName))
{
savedTemplate.Name = layoutName;
}
else
{
savedTemplate.Name = ValidationService.InferTemplateName(template.Name, template.ItemNameEditable, template.ItemNameEditable);
if (savedTemplate.ItemNameEditable)
{
focus = true;
}
}
AddToCollection(GetCollection(template.TemplateType), savedTemplate);
RaiseCollectionChanged(template.TemplateType);
UpdateHasItemsAddedByUser();
BuildLicenses();
if (focus)
{
savedTemplate.Focus();
}
}
}
private void AddToGroup(TemplateType templateType, SavedTemplateViewModel savedTemplate)
{
Func <SavedTemplateViewModel, bool> genGroupEqual = (SavedTemplateViewModel st) => st.GenGroup == savedTemplate.GenGroup;
Func <SavedTemplateViewModel, bool> genGroupPrevious = (SavedTemplateViewModel st) => st.GenGroup < savedTemplate.GenGroup;
int index = 0;
var group = GetGroup(templateType);
if (group.Items.Any(genGroupEqual))
{
index = group.Items.IndexOf(group.Items.Last(genGroupEqual)) + 1;
}
else if (group.Items.Any())
{
index = group.Items.IndexOf(group.Items.Last(genGroupPrevious)) + 1;
}
group.Insert(index, savedTemplate);
}
private IEnumerable <SavedTemplateViewModel> GetSavedTemplateDependencies(SavedTemplateViewModel savedTemplate)
{
return(AllTemplates.Where(p => p.Dependencies
.Any(d => d.Identity == savedTemplate.Identity)));
}
public async Task AddAsync(TemplateOrigin templateOrigin, TemplateInfoViewModel template, string layoutName = null, bool isReadOnly = false)
{
if (template.Exclusions.Count() > 0)
{
var exlusionsTemplateNames = AllTemplates.Where(t => template.Exclusions.Select(e => e.Identity).Contains(t.Identity)).Select(t => t.Template.Name).Distinct();
if (exlusionsTemplateNames.Count() > 0)
{
await ShowAddTemplateExclusionsNotificationAsync(template.Name, exlusionsTemplateNames);
return;
}
}
if (template.Requirements.Count() > 0)
{
if (!AllTemplates.Any(t => template.Requirements.Select(r => r.Identity).Contains(t.Identity)))
{
await ShowAddTemplateWithRequirementNotificationAsync(template.Name, template.Requirements.Select(r => r.Name));
return;
}
}
if (template.IsGroupExclusiveSelection)
{
var collection = GetCollection(template.TemplateType);
var exclusiveSelectionAddedTemplates = collection.Where(f => f.Group == template.Group).ToList();
foreach (var exclusiveFeature in exclusiveSelectionAddedTemplates)
{
await RemoveAsync(exclusiveFeature);
}
}
foreach (var dependency in template.Template.Dependencies)
{
var dependencyTemplate = MainViewModel.Instance.GetTemplate(dependency);
if (dependencyTemplate == null)
{
// Case of hidden templates, it's not found on templat lists
dependencyTemplate = new TemplateInfoViewModel(dependency, _platform, _projectTypeName, _frameworkName);
}
await AddAsync(templateOrigin, dependencyTemplate);
}
template.IncreaseSelection();
var savedTemplate = new SavedTemplateViewModel(template, templateOrigin, isReadOnly);
var focus = false;
if (!IsTemplateAdded(template) || template.MultipleInstance)
{
if (!string.IsNullOrEmpty(layoutName))
{
savedTemplate.SetName(layoutName, true);
}
else
{
if (template.ItemNameEditable)
{
savedTemplate.SetName(ValidationService.InferTemplateName(template.Name));
focus = true;
}
else
{
savedTemplate.SetName(template.Template.DefaultName);
}
}
AddToGroup(template.TemplateType, savedTemplate);
UpdateHasItemsAddedByUser();
BuildLicenses();
CheckForMissingVersions();
if (focus)
{
savedTemplate.IsTextSelected = true;
}
}
}
private void AddToCollection(ObservableCollection <SavedTemplateViewModel> collection, SavedTemplateViewModel savedTemplate)
{
Func <SavedTemplateViewModel, bool> genGroupEqual = (SavedTemplateViewModel st) => st.GenGroup == savedTemplate.GenGroup;
Func <SavedTemplateViewModel, bool> genGroupPrevious = (SavedTemplateViewModel st) => st.GenGroup < savedTemplate.GenGroup;
int index = 0;
if (collection.Any(genGroupEqual))
{
index = collection.IndexOf(collection.Last(genGroupEqual)) + 1;
}
else if (collection.Any())
{
index = collection.IndexOf(collection.Last(genGroupPrevious)) + 1;
}
collection.Insert(index, savedTemplate);
}
