/// <summary>
/// (experimental)
/// Analyze a template to get the static analyzer results including variables and template references.
/// </summary>
/// <param name="templateName">Template name to be evaluated.</param>
/// <returns>Analyzer result.</returns>
public AnalyzerResult AnalyzeTemplate(string templateName)
{
CheckErrors();
var analyzer = new Analyzer(AllTemplates.ToList(), ExpressionParser);
return(analyzer.AnalyzeTemplate(templateName));
}
/// <summary>
/// Expand a template with given name and scope.
/// Return all possible responses instead of random one.
/// </summary>
/// <param name="templateName">Template name to be evaluated.</param>
/// <param name="scope">The state visible in the evaluation.</param>
/// <param name="opt">The evaluation option for current expander.</param>
/// <returns>Expand result.</returns>
public IList<object> ExpandTemplate(string templateName, object scope = null, EvaluationOptions opt = null)
{
CheckErrors();
var evalOpt = opt ?? LgOptions;
var expander = new Expander(AllTemplates.ToList(), ExpressionParser, evalOpt);
return expander.ExpandTemplate(templateName, scope);
}
/// <summary>
/// Expand a template with given name and scope.
/// Return all possible responses instead of random one.
/// </summary>
/// <param name="templateName">Template name to be evaluated.</param>
/// <param name="scope">The state visible in the evaluation.</param>
/// <returns>Expand result.</returns>
public IList <object> ExpandTemplate(string templateName, object scope = null)
{
CheckErrors();
var expander = new Expander(AllTemplates.ToList(), ExpressionParser, StrictMode);
return(expander.ExpandTemplate(templateName, scope));
}
private void DeleteTemplateCommandExecuted()
{
if (SelectedTemplate == null)
{
return;
}
RaisePropertyChanged("DisableParentWindow");
bool? dialogResult = null;
string confirmText = Properties.Resources.MESSAGE_ASK_BEFORE_DELETING_ITEM;
RadWindow.Confirm(confirmText, (sender, args) => { dialogResult = args.DialogResult; });
RaisePropertyChanged("EnableParentWindow");
if (dialogResult != true)
{
return;
}
_adminDataUnit.MailTemplatesRepository.Delete(_selectedTemplate.MailTemplate);
_adminDataUnit.SaveChanges();
AllTemplates.Remove(SelectedTemplate);
RefreshTemplates();
}
/// <inheritdoc />
public AllTemplates GetTemplatesPaged(PageInfo pageInfo)
{
IQueryable <MessageTemplate> templates = repository.GetAll();
int total = templates.Count();
if (total == 0 || pageInfo == null || pageInfo.PageSize == 0 && pageInfo.CurrentPage == 0)
{
logger.LogInformation("Returning default page");
return(new AllTemplates
{
TotalTemplates = total,
PageSize = total > 0 ? total : 10,
Templates = templates.AsEnumerable(),
CurrentPage = 1,
PagesCount = 1
});
}
AllTemplates result = new AllTemplates
{
TotalTemplates = total,
PageSize = pageInfo.PageSize,
CurrentPage = pageInfo.CurrentPage,
Templates = templates.Skip(--pageInfo.CurrentPage * pageInfo.PageSize)
.Take(pageInfo.PageSize)
.AsEnumerable()
};
ValidationResult validationResult = new AllTemplatesValidator().Validate(result);
return(validationResult.IsValid ? result : throw new ArgumentException(validationResult.GetAllErrors()));
}
private Func <IReadOnlyList <object>, object> GlobalTemplateFunction(string templateName)
=> (IReadOnlyList <object> args) =>
{
var evaluator = new Evaluator(AllTemplates.ToList(), ExpressionParser, LgOptions);
var newScope = evaluator.ConstructScope(templateName, args.ToList());
return(evaluator.EvaluateTemplate(templateName, newScope));
};
Category CreateCategory(TemplateCategory templateCategory)
{
Category item = new Category(templateCategory.DisplayName);
foreach (var subcategory in Sorted(templateCategory.Subcategories))
{
var subItem = CreateCategory(subcategory);
if (!subItem.IsEmpty)
{
item.Items.Add(subItem);
}
}
foreach (var template in templateCategory.Templates.OfType <ProjectTemplate>())
{
if (!template.IsVisible(SolutionFolder != null ? SolutionFolder.ParentSolution : null))
{
// Do not show solution template when added a new project to existing solution
continue;
}
TemplateItem templateItem = new TemplateItem(template);
AllTemplates.Add(templateItem);
item.Templates.Add(templateItem);
}
return(item);
}
/// <summary>
/// Expand a template with given name and scope.
/// Return all possible responses instead of random one.
/// </summary>
/// <param name="templateName">Template name to be evaluated.</param>
/// <param name="scope">The state visible in the evaluation.</param>
/// <returns>Expand result.</returns>
public IList <string> ExpandTemplate(string templateName, object scope = null)
{
CheckErrors();
var expander = new Expander(AllTemplates.ToList(), ExpressionEngine);
return(expander.EvaluateTemplate(templateName, new CustomizedMemory(scope)));
}
/// <summary>
/// Evaluate a template with given name and scope.
/// </summary>
/// <param name="templateName">Template name to be evaluated.</param>
/// <param name="scope">The state visible in the evaluation.</param>
/// <returns>Evaluate result.</returns>
public object Evaluate(string templateName, object scope = null)
{
CheckErrors();
var evaluator = new Evaluator(AllTemplates.ToList(), ExpressionParser, StrictMode);
return(evaluator.EvaluateTemplate(templateName, scope));
}
/// <summary>
/// Evaluate a template with given name and scope.
/// </summary>
/// <param name="templateName">Template name to be evaluated.</param>
/// <param name="scope">The state visible in the evaluation.</param>
/// <returns>Evaluate result.</returns>
public object EvaluateTemplate(string templateName, object scope = null)
{
CheckErrors();
var memory = SimpleObjectMemory.Wrap(scope);
var evaluator = new Evaluator(AllTemplates.ToList(), ExpressionEngine);
return(evaluator.EvaluateTemplate(templateName, new CustomizedMemory(memory)));
}
/// <summary>
/// Evaluate a template with given name and scope.
/// </summary>
/// <param name="templateName">Template name to be evaluated.</param>
/// <param name="scope">The state visible in the evaluation.</param>
/// <param name="opt">The EvaluationOptions in evaluating a template.</param>
/// <returns>Evaluate result.</returns>
public object Evaluate(string templateName, object scope = null, EvaluationOptions opt = null)
{
CheckErrors();
var evalOpt = opt != null?opt.Merge(LgOptions) : LgOptions;
var evaluator = new Evaluator(AllTemplates.ToList(), ExpressionParser, evalOpt);
return(evaluator.EvaluateTemplate(templateName, scope));
}
private void handleTemplateChanges(TemplateFormData data)
{
for (var i = 0; i < AllTemplates.Count; i++)
{
if (AllTemplates[i].TemplateName == data.TemplateName)
{
AllTemplates[i] = data;
return;
}
}
AllTemplates.Add(data);
}
/// <summary>
/// Evaluate a template with given name and scope.
/// </summary>
/// <param name="templateName">Template name to be evaluated.</param>
/// <param name="scope">The state visible in the evaluation.</param>
/// <param name="opt">The EvaluationOptions in evaluating a template.</param>
/// <returns>Evaluate result.</returns>
public object Evaluate(string templateName, object scope = null, EvaluationOptions opt = null)
{
CheckErrors();
var evalOpt = opt != null ? opt.Merge(LgOptions) : LgOptions;
var evaluator = new Evaluator(AllTemplates.ToList(), ExpressionParser, evalOpt);
var result = evaluator.EvaluateTemplate(templateName, scope);
if (evalOpt.LineBreakStyle == LGLineBreakStyle.Markdown && result is string str)
{
result = newLineRegex.Replace(str, "$1$1");
}
return result;
}
private Templates InjectToExpressionFunction()
{
var totalTempaltes = new List <Templates> {
this
}.Union(References);
foreach (var curTemplates in totalTempaltes)
{
var globalFuncs = curTemplates.GetGlobalFunctionTable(curTemplates.Options);
foreach (var templateName in globalFuncs)
{
if (curTemplates.Any(u => u.Name == templateName))
{
var prefix = string.IsNullOrWhiteSpace(curTemplates.Namespace) ? string.Empty : curTemplates.Namespace + ".";
var newGlobalName = prefix + templateName;
Expression.Functions.Add(newGlobalName, new ExpressionEvaluator(
newGlobalName,
(expression, state, options) =>
{
object result = null;
var evaluator = new Evaluator(AllTemplates.ToList(), ExpressionParser, LgOptions);
var(args, error) = FunctionUtils.EvaluateChildren(expression, state, options);
if (error == null)
{
var parameters = evaluator.TemplateMap[templateName].Parameters;
var newScope = parameters.Zip(args, (k, v) => new { k, v })
.ToDictionary(x => x.k, x => x.v);
var scope = new CustomizedMemory(state, new SimpleObjectMemory(newScope));
try
{
result = evaluator.EvaluateTemplate(templateName, scope);
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception err)
#pragma warning restore CA1031 // Do not catch general exception types
{
error = err.Message;
}
}
return(result, error);
},
ReturnType.Object));
}
}
}
return(this);
}
public void GetTemplatesPaged_By_Default_Should_Return_AllTemplatesModel()
{
// Arrange.
ITemplateManager manager = GetManager();
// Act.
AllTemplates result = manager.GetTemplatesPaged(null);
// Assert.
Assert.NotNull(result);
Assert.Equal(2, result.TotalTemplates);
Assert.Equal(2, result.Templates.Count());
Assert.Equal(2, result.PageSize);
Assert.Equal(1, result.PagesCount);
}
public BindableCodeTemplate Lookup(string name)
{
try
{
BindableCodeTemplate tmpl = AllTemplates.First <BindableCodeTemplate>(
t => t.Name == name);
return(tmpl);
}
catch (ArgumentNullException)
{
return(null);
}
catch (InvalidOperationException)
{
return(null);
}
}
public void GetTemplatesPaged_Should_Return_Empty_AllTemplatesModel()
{
// Arrange.
ITemplateManager manager = GetManager();
Templates.Clear();
// Act.
AllTemplates result = manager.GetTemplatesPaged(null);
// Assert.
Assert.NotNull(result);
Assert.Equal(0, result.TotalTemplates);
Assert.Empty(result.Templates);
Assert.Equal(10, result.PageSize);
Assert.Equal(1, result.PagesCount);
}
public void GetAll_Should_Return_Valid_Templates()
{
// Arrange.
var model = new AllTemplates();
var manager = new Mock <ITemplateManager>();
manager.Setup(m => m.GetTemplatesPaged(It.IsAny <PageInfo>()))
.Returns(model);
MessageTemplatesController controller = GetController(manager);
// Act.
ActionResult <AllTemplates> result = controller.GetAll(pageInfoRequest);
// Assert.
Assert.NotNull(result);
Assert.Equal(model, result.Value);
}
public void GetTemplatesPaged_Should_Return_Correct_AllTemplatesModel(int currentPage, int pageSize)
{
// Arrange.
ITemplateManager manager = GetManager();
var pageInfo = new PageInfo
{
CurrentPage = currentPage,
PageSize = pageSize
};
// Act.
AllTemplates result = manager.GetTemplatesPaged(pageInfo);
// Assert.
Assert.NotNull(result);
Assert.NotEmpty(result.Templates);
Assert.Equal(currentPage, result.CurrentPage);
Assert.Equal(pageSize, result.PageSize);
}
private async Task TryRemoveHiddenDependenciesAsync(SavedTemplateViewModel savedTemplate)
{
foreach (var identity in savedTemplate.Dependencies)
{
var dependency = AllTemplates.FirstOrDefault(f => f.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 (!AllTemplates.Any(sf => sf.Dependencies.Any(d => d.Identity == dependency.Identity)))
{
await RemoveAsync(dependency);
}
}
}
}
}
private void CreateNewTemplate(object param)
{
string templateName = (string)param;
if (string.IsNullOrWhiteSpace(templateName))
{
return;
}
foreach (var template in AllTemplates)
{
if (template.TemplateName == templateName)
{
return;
}
}
TemplateViewModel newTemplate = new TemplateViewModel((string)templateName, AllTypes[0]);
AllTemplates.Add(newTemplate);
SelectedTemplate = newTemplate;
}
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 void RefreshTemplates()
{
Templates = new ObservableCollection <MailTemplateModel>(
(SelectedMailTemplateCategory != null) ? AllTemplates.Where(x => x.MailTemplateCategory == SelectedMailTemplateCategory.MailTemplateCategory) : AllTemplates);
}
private CompoundProcessDTO selectUsedTemplateFor(CompoundProcess compoundProcess)
{
return(AllTemplates.First(x => x.TemplateName == compoundProcess.InternalName));
}
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;
}
}
}
