public async Task SendWelcomeEmail(WelcomeNotificationUserDto model)
{
var subject = "Verify your email one time to complete registration";
dynamic expando = new ExpandoObject();
expando.Subject = subject;
expando.Date = String.Format("{0:dddd, d MMMM yyyy}", DateTime.Now);
expando.FullName = model.FullName;
expando.Email = model.Email;
expando.UserName = model.UserName;
expando.Message = model.Message;
var messageBodyHTML = _templateManager.GetTemplate(NotificationTemplateConst.Welcome_Account_Registration, expando);
string emailTemplateFolder = Path.Combine(_webHostEnvironment.WebRootPath, Path.Combine("images", "email"));
List <string> attachmentList = new List <string>();
attachmentList.Add(Path.Combine(emailTemplateFolder, "logo.png"));
var emailDto = new EmailDto()
{
FromConst = NotificationFromConst.Info,
EmailTo = model.Email,
EmailSubject = subject,
EmailBody = messageBodyHTML,
AttachmentInBodyList = attachmentList,
//formFile = new FormFile(new StreamReader(,0,120,"akafsf","TestFile")
};
await _emailService.SendEmailAsync(emailDto);
}
private void parseToolStripMenuItem_Click(object sender, EventArgs e)
{
templateTree.Nodes.Clear();
Diagonstics.Clear();
try
{
foreach (INode node in provider
.GetTemplate(
"does not matter",
new TypeResolver(),
new NDjango.TypeResolver.ModelDescriptor(
new NDjango.TypeResolver.IDjangoType[]
{
new NDjango.TypeResolver.CLRTypeDjangoType("Standard", typeof(EmptyClass))
})
).Nodes)
{
Process(templateTree.Nodes, node);
}
}
catch (Exception ex)
{
Diagonstics.AppendText(
"Exception: " + ex.Message + "\n"
+ ex.StackTrace
);
}
}
/// <summary>
/// Gets a list of block names recursively from base template using ASTNode - BlockNameNode
/// </summary>
/// <param name="template">temporary template to parse or file path to that template</param>
/// <returns></returns>
public List <string> GetTemplateBlocks(string template)
{
var nodes = parser.GetTemplate(template, new NDjango.TypeResolver.DefaultTypeResolver()).Nodes;
List <string> blocks = new List <string>();
foreach (INode node in nodes)
{
if (node.NodeType == NodeType.BlockName)
{
break;
}
else
{
for (int i = 0; i < node.Nodes.Count; i++)
{
FindBlockNameNode(node.Nodes.Values.ElementAt(i));
}
}
}
if (blockNameNode != null)
{
var completion_provider = blockNameNode as ICompletionValuesProvider;
if (completion_provider != null)
{
blocks.AddRange(completion_provider.Values);
}
}
return(blocks);
}
private void tsmiCreateClrTrigger_Click(object sender, EventArgs e)
{
var tf = TemplateManagerFactory.Instance;
ITemplateManager man = tf.GetCodeTemplateManager();
Template t = man.GetTemplate("CS.CreateClrTriggerSnippet.cs");
insertTemplateCode(t);
}
private void tsmiCSharpAdoSnippet_Click(object sender, EventArgs e)
{
var tf = TemplateManagerFactory.Instance;
ITemplateManager man = tf.GetCodeTemplateManager();
Template t = man.GetTemplate("CS.AdoCodeSnippet.cs");
insertTemplateCode(t);
}
private void insertTemplate(string templateKey)
{
var tf = TemplateManagerFactory.Instance;
ITemplateManager man = tf.GetSqlTemplateManager(_lastConnection);
Template t = man.GetTemplate(templateKey);
insertTemplateCode(t);
}
public async Task GetTemplate_Should_Throw_Exception_On_Not_Existing_Template(string name)
{
// Arrange.
ITemplateManager manager = GetManager();
// Act.
var exception = await Assert.ThrowsAnyAsync <Exception>(() => manager.GetTemplate(name));
// Assert.
Assert.Equal($"Couldn't found template named {name}", exception.Message);
}
public void OpenTemplate(string templateKey, params string[] args)
{
if (closeCurrentFile())
{
var tf = TemplateManagerFactory.Instance;
ITemplateManager man = tf.GetSqlTemplateManager(_lastConnection);
Template t = man.GetTemplate(templateKey);
_view.txtEditor.Document.Text = string.Format(t.SqlTemplate, args);
}
}
public async Task GetTemplate_Should_Return_Template(string name)
{
// Arrange.
ITemplateManager manager = GetManager();
// Act.
MessageTemplate result = await manager.GetTemplate(name);
// Assert.
Assert.NotNull(result);
Assert.Equal(name, result.Name);
}
protected override void OnDragDrop(DragEventArgs drgevent)
{
string s = string.Empty;
var files = drgevent.Data.GetData("FileDrop") as string[];
if (files != null && files.Length >= 0)
{
StreamReader sr = File.OpenText(files[0]);
s = sr.ReadToEnd();
}
if (string.IsNullOrEmpty(s))
{
s = drgevent.Data.GetData(typeof(string)) as string;
}
if (string.IsNullOrEmpty(s))
{
var dtable = drgevent.Data.GetData(typeof(DraggableTable)) as DraggableTable;
/* 0
* 4 SHIFT
* 8 CTRL
* 12 CTRL+SHIFT
* 32 LALT
* 40 ALT GR
*
* */
if (drgevent.KeyState == 0)
{
s = dtable.Table.GetFullObjectName();
}
else if (drgevent.KeyState == 4)
{
TemplateManagerFactory fac = TemplateManagerFactory.Instance;
ITemplateManager manager = fac.GetSqlTemplateManager(dtable.Server.ServerConnection);
string query = manager.GetQuery("UI.OpenTable");
s = query;
}
else if (drgevent.KeyState == 8)
{
TemplateManagerFactory fac = TemplateManagerFactory.Instance;
ITemplateManager manager = fac.GetCodeTemplateManager();
Template template = manager.GetTemplate("CS.AdoCodeSnippet.cs");
s = template.SqlTemplate;
}
}
drgevent.Data.SetData(DataFormats.StringFormat, s);
base.OnDragDrop(drgevent);
}
private void ValidateSyntaxTree(ITemplateManager manager)
{
var template = manager.GetTemplate(Template, new TestTyperesolver(),
new TypeResolver.ModelDescriptor(new TypeResolver.IDjangoType[]
{
new TypeResolver.CLRTypeDjangoType("Standard", typeof(EmptyClass))
}));
//the same logic responsible for retriving nodes as in NodeProvider class (DjangoDesigner).
var nodes = GetNodes(template.Nodes.ToList().ConvertAll
(node => (INode)node)).FindAll(node =>
(node is ICompletionValuesProvider) ||
(node.NodeType == NodeType.ParsingContext) ||
(node.ErrorMessage.Message != ""));
var actualResult = nodes.ConvertAll(
node =>
{
var valueProvider = node as ICompletionValuesProvider;
var values =
valueProvider == null ?
new List <string>()
: valueProvider.Values;
var contextValues = new List <string>(values);
switch (node.NodeType)
{
case NodeType.ParsingContext:
contextValues.InsertRange(0, (node.Context.TagClosures));
return(new DesignerData(node.Position, node.Length, contextValues.ToArray(), node.ErrorMessage.Severity, node.ErrorMessage.Message));
case NodeType.Reference:
return(new DesignerData(node.Position, node.Length, GetModelValues(node.Context.Model, RecursionDepth).ToArray(), node.ErrorMessage.Severity, node.ErrorMessage.Message));
default:
return(new DesignerData(node.Position, node.Length, new List <string>(values).ToArray(), node.ErrorMessage.Severity, node.ErrorMessage.Message));
}
});
for (var i = 0; i < actualResult.Count; i++)
{
Assert.AreEqual(ResultForDesigner[i].Length, actualResult[i].Length, "Invalid Length");
Assert.AreEqual(ResultForDesigner[i].Position, actualResult[i].Position, "Invalid Position");
Assert.AreEqual(ResultForDesigner[i].ErrorMessage, actualResult[i].ErrorMessage, "Invalid ErrorMessage");
Assert.AreEqual(ResultForDesigner[i].Severity, actualResult[i].Severity, "Invalid Severity");
Assert.AreEqual(ResultForDesigner[i].Values, actualResult[i].Values, "Invalid Values Array " + i);
}
Assert.AreEqual(ResultForDesigner.Count(), actualResult.Count);
}
private void parseToolStripMenuItem_Click(object sender, EventArgs e)
{
templateTree.Nodes.Clear();
Diagonstics.Clear();
try
{
foreach (INode node in provider.GetTemplate("does not matter").Nodes)
{
Process(templateTree.Nodes, node);
}
}
catch (Exception ex)
{
Diagonstics.AppendText(
"Exception: " + ex.Message + "\n"
+ ex.StackTrace
);
}
}
public async Task AddTemplate_Should_Create_Template_In_Repository()
{
// Arrange.
ITemplateManager manager = GetManager();
var template = new MessageTemplate
{
Name = TestTemplateName,
Title = TestTemplateTitle,
Body = TestTemplateBody
};
// Act.
await manager.AddTemplate(template);
// Assert.
MessageTemplate created = await manager.GetTemplate(TestTemplateName);
Assert.NotNull(created);
Assert.Equal(template, created);
}
/// <inheritdoc />
public async Task <EmailMessage> CreateFromNotificationMessage(NotificationMessage <EmailNotificationMessage> notificationMessage)
{
try
{
logger.LogInformation("Start email message creation");
MessageTemplate template = await templateManager.GetTemplate(notificationMessage.Message.TemplateName);
logger.LogInformation(
"Information about received template from repository:" +
$"Name:{template.Name}, " +
$"Engine type :{template.EngineType}, " +
$"Parent template: {template.Parent}");
string emailBody = await emailBodyGenerator.GenerateEmailBody(template, notificationMessage.Message.Params);
return(CreateEmailMessage(template.Title, emailBody, notificationMessage));
}
catch (Exception e)
{
throw new EmailMessageCreationException(e.Message);
}
}
private void ValidateSyntaxTree(ITemplateManager manager)
{
var template = manager.GetTemplate(Template, new TestTyperesolver(),
new TypeResolver.ModelDescriptor(new TypeResolver.IDjangoType[]
{
new TypeResolver.CLRTypeDjangoType("Standard", typeof(EmptyClass))
}));
//the same logic responsible for retriving nodes as in NodeProvider class (DjangoDesigner).
var nodes = GetNodes(template.Nodes.ToList().ConvertAll
(node => (INode)node)).FindAll(node =>
(node is ICompletionValuesProvider)
|| (node.NodeType == NodeType.ParsingContext)
|| (node.ErrorMessage.Message != ""));
var actualResult = nodes.ConvertAll(
node =>
{
var valueProvider = node as ICompletionValuesProvider;
var values =
valueProvider == null ?
new List<string>()
: valueProvider.Values;
var contextValues = new List<string>(values);
switch (node.NodeType)
{
case NodeType.ParsingContext:
contextValues.InsertRange(0 ,(node.Context.TagClosures));
return new DesignerData(node.Position, node.Length, contextValues.ToArray(), node.ErrorMessage.Severity, node.ErrorMessage.Message);
case NodeType.Reference:
return new DesignerData(node.Position, node.Length, GetModelValues(node.Context.Model, RecursionDepth).ToArray(), node.ErrorMessage.Severity, node.ErrorMessage.Message);
default:
return new DesignerData(node.Position, node.Length, new List<string>(values).ToArray(), node.ErrorMessage.Severity, node.ErrorMessage.Message);
}
});
for (var i = 0; i < actualResult.Count; i++)
{
Assert.AreEqual(ResultForDesigner[i].Length, actualResult[i].Length, "Invalid Length");
Assert.AreEqual(ResultForDesigner[i].Position, actualResult[i].Position, "Invalid Position");
Assert.AreEqual(ResultForDesigner[i].ErrorMessage, actualResult[i].ErrorMessage, "Invalid ErrorMessage");
Assert.AreEqual(ResultForDesigner[i].Severity, actualResult[i].Severity, "Invalid Severity");
Assert.AreEqual(ResultForDesigner[i].Values, actualResult[i].Values, "Invalid Values Array " + i);
}
Assert.AreEqual(ResultForDesigner.Count(), actualResult.Count);
}
/// <summary>
/// Parses the template
/// </summary>
/// <param name="template">a reader with the template</param>
/// <returns>A list of the syntax nodes</returns>
public FSharpList <INodeImpl> ParseTemplate(string filename, ITypeResolver resolver)
{
return(parser.GetTemplate(filename, resolver).Nodes);
}
private void CompletionSet_TestBase(string content, CompletionContext context, int position, Type completion_set, string[] display_values, string[] insert_values, string[] builder_values)
{
var textBuffer = new Mock <ITextBuffer>();
// mock current snapshot - always return the content
var current_snapshot = new Mock <ITextSnapshot>();
current_snapshot.Setup <int>(s => s.Length).Returns(content.Length);
current_snapshot.Setup <char[]>(s => s.ToCharArray(It.IsAny <int>(), It.IsAny <int>())).Returns((int pos, int len) => content.ToCharArray(pos, len));
current_snapshot.Setup(s => s.GetText()).Returns(content);
current_snapshot.Setup(s => s.CreateTrackingSpan(It.IsAny <int>(), It.IsAny <int>(), SpanTrackingMode.EdgeInclusive))
.Returns((int start, int length, SpanTrackingMode tracking_mode) => new TrackingSpan(textBuffer.Object, start, length, tracking_mode));
current_snapshot.Setup <ITextBuffer>(s => s.TextBuffer).Returns(textBuffer.Object);
textBuffer.Setup <ITextSnapshot>(t => t.CurrentSnapshot).Returns(current_snapshot.Object);
// mock snapshot lines - test templates are all single line
var line = new Mock <ITextSnapshotLine>();
var extent = new SnapshotSpan(current_snapshot.Object, 0, current_snapshot.Object.Length);
line.Setup(l => l.LineNumber).Returns(0);
line.Setup(l => l.Snapshot).Returns(current_snapshot.Object);
line.Setup(l => l.Start).Returns(new SnapshotPoint(current_snapshot.Object, 0));
line.Setup(l => l.End).Returns(new SnapshotPoint(current_snapshot.Object, current_snapshot.Object.Length));
line.Setup(l => l.Extent).Returns(extent);
// build a list of lines into snapshot
var lines = new List <ITextSnapshotLine>();
lines.Add(line.Object);
current_snapshot.Setup(s => s.Lines).Returns(lines);
current_snapshot.Setup(s => s.LineCount).Returns(lines.Count);
current_snapshot.Setup(s => s.GetLineFromPosition(It.IsAny <int>())).Returns(line.Object);
Assert.IsInstanceOf <ITemplateManager>(parser);
// mock handler
var handler = new Mock <IProjectHandler>();
handler.Setup <ITextSnapshot>(h => h.GetSnapshot(It.IsAny <string>())).Returns((string t) => current_snapshot.Object);
handler.Setup <Microsoft.FSharp.Collections.FSharpList <INodeImpl> >(h => h.ParseTemplate(It.IsAny <string>(), (NDjango.TypeResolver.ITypeResolver)It.IsAny <TestTypeResolver>()))
.Returns((string t, NDjango.TypeResolver.ITypeResolver resolver)
=> parser.GetTemplate(t, resolver, new NDjango.TypeResolver.ModelDescriptor(new List <NDjango.TypeResolver.IDjangoType>())).Nodes);
var provider = new NodeProvider(handler.Object, "temp://" + content, new TestTypeResolver());
var parsing_completed = false;
provider.NodesChanged += delegate(SnapshotSpan span)
{
parsing_completed = true;
};
while (!parsing_completed)
{
System.Threading.Thread.Sleep(1);
}
var source = new Source(provider, textBuffer.Object);
// mock session properties
var session_properties = new Mock <PropertyCollection>().Object;
session_properties.AddProperty(typeof(CompletionContext), context);
// mock tracking point
var tracking_point = new Mock <ITrackingPoint>();
tracking_point.Setup <SnapshotPoint>(t => t.GetPoint(It.IsAny <ITextSnapshot>())).Returns((ITextSnapshot snapshot) => new SnapshotPoint(snapshot, position));
var session = new Mock <ICompletionSession>();
session.Setup <PropertyCollection>(s => s.Properties).Returns(session_properties);
session.Setup <ITrackingPoint>(s => s.GetTriggerPoint(It.IsAny <ITextBuffer>())).Returns(tracking_point.Object);
var completionSets = new List <CompletionSet>();
source.AugmentCompletionSession(session.Object, completionSets);
Assert.AreEqual(1, completionSets.Count);
var c = completionSets[0];
Assert.IsInstanceOf(completion_set, c);
Assert.AreEqual(display_values.Length, c.Completions.Count);
Assert.AreEqual(builder_values.Length, c.CompletionBuilders.Count);
for (int i = 0; i < display_values.Length; i++)
{
Assert.AreEqual(display_values[i], c.Completions[i].DisplayText);
}
for (int i = 0; i < insert_values.Length; i++)
{
Assert.AreEqual(insert_values[i], c.Completions[i].InsertionText);
}
for (int i = 0; i < builder_values.Length; i++)
{
Assert.AreEqual(builder_values[i], c.CompletionBuilders[i].DisplayText);
}
}
/// <summary>
/// Parses the template
/// </summary>
/// <param name="template">a reader with the template</param>
/// <returns>A list of the syntax nodes</returns>
public FSharpList <INodeImpl> ParseTemplate(string filename, NDjango.TypeResolver.ITypeResolver resolver)
{
return(parser.GetTemplate(filename, resolver, new NDjango.TypeResolver.ModelDescriptor(GetDefaultModel(filename))).Nodes);
}
private async Task <MessageTemplate> GetParentTemplate(MessageTemplate template)
{
return(!string.IsNullOrWhiteSpace(template.Parent) ? await templateManager.GetTemplate(template.Parent) : null);
}
