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 requirements = AllTemplates.Where(t => t.Template.Requirements.Select(r => r.TemplateId).Contains(template.Identity));
if (requirements != null && requirements.Any())
{
await ShowRemoveRequirementNotificationAsync(template.Name, requirements.Select(t => t.Name));
return;
}
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;
}
}
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;
}
}
}
public void RefreshTemplates()
{
Templates = new ObservableCollection <MailTemplateModel>(
(SelectedMailTemplateCategory != null) ? AllTemplates.Where(x => x.MailTemplateCategory == SelectedMailTemplateCategory.MailTemplateCategory) : AllTemplates);
}
