IEnumerable<LogEventProperty> ConstructPositionalProperties(MessageTemplate messageTemplate, object[] messageTemplateParameters)
{
var pcount = 0;
var pmax = -1;
List<Tuple<int, PropertyToken>> positionalsInTemplate = null;
foreach (var propertyToken in messageTemplate.Tokens.OfType<PropertyToken>())
{
int position;
if (!propertyToken.TryGetPositionalValue(out position))
return ConstructNamedProperties(messageTemplate, messageTemplateParameters);
++pcount;
pmax = Math.Max(pmax, position);
positionalsInTemplate = positionalsInTemplate ?? new List<Tuple<int, PropertyToken>>(messageTemplateParameters.Length);
positionalsInTemplate.Add(Tuple.Create(position, propertyToken));
}
if (pcount != messageTemplateParameters.Length || pmax != pcount - 1)
SelfLog.WriteLine("Positional properties in {0} do not line up with parameters.", this);
if (positionalsInTemplate == null)
return NoProperties;
return positionalsInTemplate
.Where(p => p.Item1 < messageTemplateParameters.Length)
.Select(p => ConstructProperty(p.Item2, messageTemplateParameters[p.Item1]));
}
public ActionResult delete(int id)
{
MessageTemplateRepository m_rep = new MessageTemplateRepository();
MessageTemplate m = new MessageTemplate();
//GET Committee
try
{
m = m_rep.getById(id);
}
catch (Exception exception)
{
//IF THERE IS A MESS UP, RETURN ERROR TO FRONT
TempData["flash"] = "Unable to retrieve message: " + exception.Message;
return RedirectToAction("Index");
}
//DELETE Committee
try
{
m_rep.delete(m);
TempData["flash"] = "Deleted message.";
return RedirectToAction("Index");
}
catch (Exception exception)
{
TempData["flash"] = "Unable to delete message: " + exception.Message;
return RedirectToAction("Index");
}
}
IEnumerable<LogEventProperty> ConstructNamedProperties(MessageTemplate messageTemplate, object[] messageTemplateParameters)
{
var mismatchWarningIssued = false;
var next = 0;
foreach (var propertyToken in messageTemplate.Tokens.OfType<PropertyToken>())
{
if (propertyToken.IsPositional && !mismatchWarningIssued)
{
mismatchWarningIssued = true;
SelfLog.WriteLine("Message template is malformed: {0}.", this);
}
if (next < messageTemplateParameters.Length)
{
var value = messageTemplateParameters[next];
yield return ConstructProperty(propertyToken, value);
}
else
{
if (!mismatchWarningIssued)
{
mismatchWarningIssued = true;
SelfLog.WriteLine("Message template has more parameters than provided: {0}.", this);
}
}
next++;
}
if (next > messageTemplateParameters.Length && !mismatchWarningIssued)
SelfLog.WriteLine("Too many parameters provided for message template: {0}.", this);
}
public static void UpdateTemplate(MessageTemplate template)
{
if (template != null)
{
new MessageTemplateDao().UpdateTemplate(template);
HiCache.Remove(string.Format("Message-{0}", template.MessageType.ToLower()));
}
}
public void PropertyInSubject()
{
var t = new MessageTemplate { Subject = "Subject {{A}}", Text = "Body" };
var properties = t.GetProperties();
Assert.AreEqual(1, properties.Count);
Assert.IsTrue(properties.ContainsKey("a"));
}
public ActionResult create()
{
//Generate new message object
MessageTemplate message = new MessageTemplate();
ViewData["edit"] = false;
ViewData["message"] = message;
return View();
}
public void SubjectAndBodyPreserved()
{
var t = new MessageTemplate { Subject = "Subject", Text = "Body" };
var properties = new Dictionary<string, object>();
var m = t.Merge(properties, new [] { "*****@*****.**" });
Assert.AreEqual(m.Subject, t.Subject, "Subject differs");
Assert.AreEqual(m.Text, t.Text, "Body differs");
}
public void SimpleMerge()
{
var t = new MessageTemplate { Subject = "Subject {{A}}", Text = "Body {{A}}" };
var properties = new Dictionary<string, object> { { "A", "B" } };
var m = t.Merge(properties, new[] { "*****@*****.**" });
Assert.AreEqual("Subject B", m.Subject, "Subject differs");
Assert.AreEqual("Body B", m.Text, "Body differs");
}
/// <summary>
/// Construct a new <seealso cref="LogEvent"/>.
/// </summary>
/// <param name="timestamp">The time at which the event occurred.</param>
/// <param name="level">The level of the event.</param>
/// <param name="exception">An exception associated with the event, or null.</param>
/// <param name="messageTemplate">The message template describing the event.</param>
/// <param name="properties">Properties associated with the event, including those presented in <paramref name="messageTemplate"/>.</param>
public LogEvent(DateTimeOffset timestamp, LogEventLevel level, Exception exception, MessageTemplate messageTemplate, IEnumerable<LogEventProperty> properties)
{
if (messageTemplate == null) throw new ArgumentNullException("messageTemplate");
if (properties == null) throw new ArgumentNullException("properties");
_timestamp = timestamp;
_level = level;
_exception = exception;
_messageTemplate = messageTemplate;
_properties = new Dictionary<string, LogEventProperty>();
foreach (var p in properties)
AddOrUpdateProperty(p);
}
internal static MailMessage GetEmailTemplate(MessageTemplate template, string emailTo)
{
if (((template == null) || !template.SendEmail) || string.IsNullOrEmpty(emailTo))
{
return null;
}
MailMessage message = new MailMessage {
IsBodyHtml = true,
Priority = MailPriority.High,
Body = template.EmailBody.Trim(),
Subject = template.EmailSubject.Trim()
};
message.To.Add(emailTo);
return message;
}
/// <summary>
/// Create properties based on an ordered list of provided values.
/// </summary>
/// <param name="messageTemplate">The template that the parameters apply to.</param>
/// <param name="messageTemplateParameters">Objects corresponding to the properties
/// represented in the message template.</param>
/// <returns>A list of properties; if the template is malformed then
/// this will be empty.</returns>
public IEnumerable<TemplateProperty> ConstructProperties(MessageTemplate messageTemplate, object[] messageTemplateParameters)
{
if (messageTemplateParameters == null || messageTemplateParameters.Length == 0)
{
if (messageTemplate.NamedProperties != null || messageTemplate.PositionalProperties != null)
SelfLog.WriteLine("Required properties not provided for: {0}", messageTemplate);
return NoProperties;
}
if (messageTemplate.PositionalProperties != null)
return ConstructPositionalProperties(messageTemplate, messageTemplateParameters);
return ConstructNamedProperties(messageTemplate, messageTemplateParameters);
}
public static Message CreateByTemplate(MessageTemplate template, Guid sender
, Guid recipient, string[] subjectParams, string[] bodyParams)
{
Message msg = new Message
{
SenderId = sender,
RecipientId = recipient,
Unread = true,
CreateDate = DateTime.Now
};
var t = Dictionaries.Instance.GetMessageTemplate(template);
msg.Body = StringUtils.Format(TypeConverter.ToString(t[MessageTemplateFields.Body]), bodyParams);
msg.BodyRu = StringUtils.Format(TypeConverter.ToString(t[MessageTemplateFields.BodyRu]), bodyParams);
return msg;
}
public ActionResult create(FormCollection collection)
{
//Generate new Committee object
MessageTemplateRepository message_template_rep = new MessageTemplateRepository();
MessageTemplate message = new MessageTemplate();
ViewData["edit"] = false;
ViewData["message"] = message;
try
{
return messageTemplateFormProcess(message, message_template_rep, collection);
}
catch (Exception exception)
{
//IF THERE IS A MESS UP, RETURN ERROR TO FRONT
TempData["flash"] = "Unable to create message template: " + exception.Message;
return RedirectToAction("create");
}
}
public void FileStrategyFinder()
{
var template = new MessageTemplate
{
Name = "fred",
CultureCode = "en",
From = "*****@*****.**",
FromName = "Test Name",
Subject = "Subject",
Text = "Hello world"
};
var strategy = new FilenameTemplateStrategy("App_Data/MailTemplates");
var repository = new FileMessageTemplateRepository(strategy);
var candidate = repository.Find("fred", new CultureInfo("en-US")) as MessageTemplate;
Check(template, candidate);
}
public override Field Parse(System.Xml.XmlElement templateElement, bool optional, ParsingContext context)
{
var messageTemplate = new MessageTemplate(getTemplateName(templateElement, context), ParseFields(templateElement, context));
ParseMore(templateElement, messageTemplate, context);
if (loadTemplateIdFromAuxId && templateElement.HasAttribute("id"))
{
try
{
int templateId = System.Int32.Parse(templateElement.GetAttribute("id"));
context.TemplateRegistry.Register(templateId, messageTemplate);
}
catch (System.FormatException)
{
context.TemplateRegistry.Define(messageTemplate);
}
}
else
context.TemplateRegistry.Define(messageTemplate);
return messageTemplate;
}
public void Merge()
{
var american = new CultureInfo("en-US");
var template = new MessageTemplate { Subject = "Subject {{A}}", Text = "Body {{A}}" };
var properties = new Dictionary<string, object> { { "A", "B" } };
// Arrange
var repository = new Mock<IMessageTemplateRepository>();
var dispatcher = new MessageTemplateMerger(repository.Object);
repository.Setup(x => x.Find("Test", american)).Returns(template);
// Act
var message = dispatcher.Merge("Test", american, properties, new[] { "*****@*****.**" });
// Assert
Assert.IsNotNull(message);
Assert.AreEqual("Subject B", message.Subject, "Subject differs");
Assert.AreEqual("Body B", message.Text, "Body differs");
repository.VerifyAll();
}
private void btnOk_Click(object sender, RoutedEventArgs e)
{
int duration;
int limitmins;
try
{
if (!int.TryParse(txtDuration.Text, out duration))
throw new Exception("Die angegebene Mindestanzeigedauer ist ungültig.");
if (duration < 0 || duration > 60)
throw new Exception("Die Mindestanzeigedauer muss zwischen 0 und 60 Sekunden liegen.");
if (txtMessage.Text.Length < 1)
throw new Exception("Die Nachricht darf nicht leer sein.");
if (!int.TryParse(txtDateLimitMinutes.Text, out limitmins))
throw new Exception("Der Wert für das Zeitlimit ist ungültig.");
List<User> users = (from u in selectedUsers where u.IsSelected == true select u.User as User).ToList();
if (users.Count < 1)
throw new Exception("Es wurden keine Benutzer ausgewählt.");
MessageTemplate tpl = new MessageTemplate();
tpl.Content = txtMessage.Text;
tpl.Duration = duration;
tpl.ForceLogout = chbxForceLogoff.IsChecked == true ? true : false;
if (limitmins > 0) tpl.DateLimit = DateTime.Now.AddMinutes(limitmins);
foreach (User u in users) tpl.Recipients.Add(u);
messages.Add(tpl.Create());
VisualMessageBox.Show("Die Nachricht wurde gespeichert.", "Nachricht erstellt");
txtMessage.Text = "";
foreach (UserSelection s in selectedUsers) s.IsSelected = false;
}
catch (Exception ex)
{
VisualMessageBox.Show(ex.Message, "Fehler");
}
}
IEnumerable<TemplateProperty> ConstructNamedProperties(MessageTemplate template, object[] messageTemplateParameters)
{
var namedProperties = template.NamedProperties;
if (namedProperties == null)
return Enumerable.Empty<TemplateProperty>();
var matchedRun = namedProperties.Length;
if (namedProperties.Length != messageTemplateParameters.Length)
{
matchedRun = Math.Min(namedProperties.Length, messageTemplateParameters.Length);
SelfLog.WriteLine("Named property count does not match parameter count: {0}", template);
}
var result = new TemplateProperty[matchedRun];
for (var i = 0; i < matchedRun; ++i)
{
var property = template.NamedProperties[i];
var value = messageTemplateParameters[i];
result[i] = ConstructProperty(property, value);
}
return result;
}
public abstract bool IsRegistered(MessageTemplate param1);
public bool BindMessageTemplate(string messageTemplate, object[] propertyValues, out MessageTemplate parsedTemplate, out IEnumerable <LogEventProperty> boundProperties)
{
throw new NotImplementedException();
}
public void TestTemplateExtension()
{
MessageTemplate logon = _loader.TemplateRegistry[new QName("Logon", SessionNs)];
Assert.IsTrue(logon.HasAttribute(new QName("reset", Scp11Ns)));
}
protected int SendNotification(MessageTemplate messageTemplate, EmailAccount emailAccount,
IEnumerable <Token> tokens,
string toEmailAddress,
string toName,
string replyTo = null,
string replyToName = null, ISavingsContract savingsContract = null)
{
#region Email routine
if (person.EmailDelivery.HasValue && person.EmailDelivery.Value &&
messageTemplate.SendEmail.HasValue && messageTemplate.SendEmail.Value)
{
var bcc = messageTemplate.BccEmailAddresses;
var subject = messageTemplate.Subject;
var body = messageTemplate.EmailBody;
// Replace subject and body tokens
var subjectReplaced = Tokenizer.Replace(subject, tokens, false);
var bodyReplaced = Tokenizer.Replace(body, tokens, true);
var email = new QueuedEmail()
{
Priority = 5,
From = emailAccount.Email,
FromName = emailAccount.DisplayName,
To = toEmailAddress,
ToName = toName,
CC = string.Empty,
SentTries = 0,
Bcc = bcc,
ReplyTo = replyTo,
ReplyToName = replyToName,
Subject = subjectReplaced,
Body = bodyReplaced,
CreatedOnUtc = DateTime.UtcNow,
EmailAccountId = emailAccount.Id
};
_queuedEmailService.Add(email);
//return email.Id;
}
#endregion
#region SMS routine
if (person.SmsDelivery.HasValue && person.SmsDelivery.Value &&
messageTemplate.SendSMS.HasValue && messageTemplate.SendSMS.Value)
{
var message = messageTemplate.Body;
var messageReplaced = Tokenizer.Replace(message, tokens, false);
var sms = new QueuedSMS()
{
From = Convert.ToString(ServicesProvider.GetInstance().GetGeneralSettings().GetSpecificParameter(OGeneralSettings.SMS_FROM_NUMBER)),
Recipient = person.PersonalPhone,
RecipientId = person.Id,
ContractId = savingsContract != null ? savingsContract.Id : 0,
Charged = false,
Message = messageReplaced,
SentTries = 0,
CreatedOnUtc = DateTime.UtcNow,
};
_queuedSMSService.Add(sms);
//return sms.Id;
}
#endregion
return(0);
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
uxMessagePlaceHolder.Controls.Clear();
uxValidationSummaryPlaceHolder.Controls.Clear();
uxValidationDenotePlaceHolder.Controls.Clear();
uxLanguageControlPlaceHolder.Controls.Clear();
uxButtonEventPlaceHolder.Controls.Clear();
uxTopContentBoxPlaceHolder.Controls.Clear();
uxContentPlaceHolder.Controls.Clear();
// Message.
ContentContainer container = new ContentContainer();
if (MessageTemplate != null)
{
MessageTemplate.InstantiateIn(container);
uxMessagePlaceHolder.Controls.Add(container);
}
else
{
uxMessagePlaceHolder.Controls.Add(new LiteralControl("No Message Defined"));
uxMessagePlaceHolder.Visible = false;
}
// Validation Summary
container = new ContentContainer();
if (ValidationSummaryTemplate != null)
{
ValidationSummaryTemplate.InstantiateIn(container);
uxValidationSummaryPlaceHolder.Controls.Add(container);
}
else
{
uxValidationSummaryPlaceHolder.Controls.Add(new LiteralControl("No Validation Summary Defined"));
uxValidationSummaryPanel.Visible = false;
}
// Validation Denotes
container = new ContentContainer();
if (ValidationDenotesTemplate != null)
{
ValidationDenotesTemplate.InstantiateIn(container);
uxValidationDenotePlaceHolder.Controls.Add(container);
}
else
{
uxValidationDenotePlaceHolder.Controls.Add(new LiteralControl("No Validation Denotes Defined"));
uxValidationDenotePanel.Visible = false;
}
container = new ContentContainer();
if (LanguageControlTemplate != null)
{
LanguageControlTemplate.InstantiateIn(container);
uxLanguageControlPlaceHolder.Controls.Add(container);
}
else
{
uxLanguageControlPlaceHolder.Controls.Add(new LiteralControl("No Language Control Defined"));
uxLanguageControlPanel.Visible = false;
}
container = new ContentContainer();
if (ButtonEventTemplate != null)
{
ButtonEventTemplate.InstantiateIn(container);
uxButtonEventPlaceHolder.Controls.Add(container);
}
else
{
uxButtonEventPlaceHolder.Controls.Add(container);
uxButtonEventPanel.Visible = false;
}
container = new ContentContainer();
if (TopContentBoxTemplate != null)
{
TopContentBoxTemplate.InstantiateIn(container);
uxTopContentBoxPlaceHolder.Controls.Add(container);
}
else
{
uxTopContentBoxPlaceHolder.Controls.Add(new LiteralControl("No TopContentBox Content Defined"));
uxTopContentBoxSet.Visible = false;
}
container = new ContentContainer();
if (ContentTemplate != null)
{
ContentTemplate.InstantiateIn(container);
uxContentPlaceHolder.Controls.Add(container);
}
else
{
uxContentPlaceHolder.Controls.Add(new LiteralControl("No Template Defined"));
uxContentPanel.Visible = false;
}
container = new ContentContainer();
if (PlainContentTemplate != null)
{
PlainContentTemplate.InstantiateIn(container);
uxPlainContentPlaceHolder.Controls.Add(container);
uxPlainContentPanel.Visible = true;
}
else
{
uxPlainContentPlaceHolder.Controls.Add(new LiteralControl("No Template Defined"));
uxPlainContentPanel.Visible = false;
}
}
static LogIncomingBehavior()
{
MessageTemplateParser templateParser = new();
messageTemplate = templateParser.Parse("Receive message {IncomingMessageType} {IncomingMessageId}.");
}
public static MessageTemplate ToEntity(this MessageTemplateModel model, MessageTemplate destination)
{
return(model.MapTo(destination));
}
public static MessageTemplateModel ToModel(this MessageTemplate entity)
{
return(entity.MapTo <MessageTemplate, MessageTemplateModel>());
}
/// <inheritdoc />
public async Task Add(MessageTemplate template)
{
template.ThrowIfNull(nameof(template));
logger.LogInformation($"Adding template named {template.Name} into collection");
await collection.InsertOneAsync(template);
}
public static void MessageTokensAdded <U>(this IEventPublisher eventPublisher, MessageTemplate message, IList <U> tokens)
{
eventPublisher.Publish(new MessageTokensAddedEvent <U>(message, tokens));
}
public static void MessageTokensAdded <U>(this IEventPublisher eventPublisher, MessageTemplate message, System.Collections.Generic.IList <U> tokens)
{
eventPublisher.Publish(new MessageTokensAddedEvent <U>(message, tokens));
}
public void Process(string messageTemplate, object[] messageTemplateParameters, out MessageTemplate parsedTemplate, out IEnumerable <LogEventProperty> properties)
{
parsedTemplate = _parser.Parse(messageTemplate);
properties = _propertyBinder.ConstructProperties(parsedTemplate, messageTemplateParameters);
}
public async Task EmitBatchAsync_inserts_events_to_database()
{
// Arrange
var db = Guid.NewGuid().ToString();
var settingsMoq = new Mock <ISejilSettings>();
settingsMoq.SetupGet(p => p.SqliteDbPath).Returns(db);
settingsMoq.SetupGet(p => p.PageSize).Returns(100);
var repository = new SejilRepository(new SejilSqlProvider(settingsMoq.Object), settingsMoq.Object);
var sink = new SejilSinkMock(settingsMoq.Object);
// Hello, {name}. Your # is {number}
var tokens = new List <MessageTemplateToken>
{
new TextToken("Hello, ", 0),
new PropertyToken("name", "{name}"),
new TextToken(". Your # is ", 13),
new PropertyToken("number", "{number}"),
};
var properties = new List <LogEventProperty>
{
new LogEventProperty("name", new ScalarValue("world")),
new LogEventProperty("number", new ScalarValue(null))
};
var messageTemplate = new MessageTemplate(tokens);
var timestamp1 = new DateTime(2017, 8, 3, 11, 44, 15, 542, DateTimeKind.Local);
var timestamp2 = new DateTime(2017, 9, 3, 11, 44, 15, 542, DateTimeKind.Local);
var events = new List <LogEvent>
{
new LogEvent(timestamp1, LogEventLevel.Information, null, messageTemplate, properties),
new LogEvent(timestamp2, LogEventLevel.Debug, new Exception("error"), messageTemplate, properties),
};
// Act
await sink.CallEmitBatchAsync(events);
// Assert
var logEvents = await repository.GetEventsPageAsync(1, null, null);
Assert.Equal(2, logEvents.Count());
var logEvent1 = logEvents.FirstOrDefault(p => p.Level == "Information");
Assert.Equal("Hello, \"world\". Your # is null", logEvent1.Message);
Assert.Equal("Hello, {name}. Your # is {number}", logEvent1.MessageTemplate);
Assert.Equal("Information", logEvent1.Level);
Assert.Equal(timestamp1, logEvent1.Timestamp);
Assert.Null(logEvent1.Exception);
Assert.Equal(2, logEvent1.Properties.Count());
Assert.Equal(logEvent1.Id, logEvent1.Properties.ElementAt(0).LogId);
Assert.Equal("name", logEvent1.Properties.ElementAt(0).Name);
Assert.Equal("world", logEvent1.Properties.ElementAt(0).Value);
Assert.Equal(logEvent1.Id, logEvent1.Properties.ElementAt(1).LogId);
Assert.Equal("number", logEvent1.Properties.ElementAt(1).Name);
Assert.Equal("null", logEvent1.Properties.ElementAt(1).Value);
var logEvent2 = logEvents.FirstOrDefault(p => p.Level == "Debug");
Assert.Equal("Hello, \"world\". Your # is null", logEvent2.Message);
Assert.Equal("Hello, {name}. Your # is {number}", logEvent2.MessageTemplate);
Assert.Equal("Debug", logEvent2.Level);
Assert.Equal(timestamp2, logEvent2.Timestamp);
Assert.Equal("System.Exception: error", logEvent2.Exception);
Assert.Equal(2, logEvent2.Properties.Count());
Assert.Equal(logEvent2.Id, logEvent2.Properties.ElementAt(0).LogId);
Assert.Equal("name", logEvent2.Properties.ElementAt(0).Name);
Assert.Equal("world", logEvent2.Properties.ElementAt(0).Value);
Assert.Equal(logEvent2.Id, logEvent2.Properties.ElementAt(1).LogId);
Assert.Equal("number", logEvent2.Properties.ElementAt(1).Name);
Assert.Equal("null", logEvent2.Properties.ElementAt(1).Value);
}
public static MessageTemplateView ConvertToMessageTemplateView(this MessageTemplate messageTemplate)
{
return(Mapper.Map <MessageTemplate, MessageTemplateView>(messageTemplate));
}
public MessageTemplate[] Load(XmlElement root)
{
var templateParser = new TemplateParser(_loadTemplateIdFromAuxId);
if (root != null)
{
if (root.LocalName.Equals("template"))
{
return new[] {(MessageTemplate) templateParser.Parse(root, _initialContext)};
}
if (root.LocalName.Equals("templates"))
{
var context = new ParsingContext(root, _initialContext);
XmlNodeList templateTags = root.GetElementsByTagName("template");
var templates = new MessageTemplate[templateTags.Count];
for (int i = 0; i < templateTags.Count; i++)
{
var templateTag = (XmlElement) templateTags.Item(i);
templates[i] = (MessageTemplate) templateParser.Parse(templateTag, context);
}
return templates;
}
_initialContext.ErrorHandler.OnError(
null, StaticError.InvalidXml, "Invalid root node {0}, 'template' or 'templates' expected.",
root.LocalName);
}
return new MessageTemplate[] {};
}
public StaticMessageTemplateReader(ILogEventReader inner, string messageTemplate)
{
_inner = inner ?? throw new ArgumentNullException(nameof(inner));
_messageTemplate = new MessageTemplateParser().Parse(messageTemplate);
}
public bool BindMessageTemplate(string messageTemplate, object[] propertyValues, out MessageTemplate parsedTemplate,
out IEnumerable <LogEventProperty> boundProperties)
{
return(logger.BindMessageTemplate(messageTemplate, propertyValues, out parsedTemplate, out boundProperties));
}
/// <summary>
/// Create properties based on an ordered list of provided values.
/// </summary>
/// <param name="messageTemplate">The template that the parameters apply to.</param>
/// <param name="messageTemplateParameters">Objects corresponding to the properties
/// represented in the message template.</param>
/// <returns>A list of properties; if the template is malformed then
/// this will be empty.</returns>
public IEnumerable <LogEventProperty> ConstructProperties(MessageTemplate messageTemplate, object[] messageTemplateParameters)
{
return(ConstructPositionalProperties(messageTemplate, messageTemplateParameters ?? NoParameters));
}
public LogEventPropertyMessageValue(MessageTemplate template, IReadOnlyDictionary <string, LogEventProperty> properties)
{
_template = template;
_properties = properties;
}
private void btnSend_Click(object sender, EventArgs e)
{
bool isValid = true;
reqEmail.Validate();
if (!reqEmail.IsValid)
{
isValid = false;
}
regexEmail.Validate();
if (!regexEmail.IsValid)
{
isValid = false;
}
reqToEmail.Validate();
if (!reqToEmail.IsValid)
{
isValid = false;
}
regexToEmail.Validate();
if (!regexToEmail.IsValid)
{
isValid = false;
}
if (isValid)
{
//string messageTemplate = MessageTemplate.GetMessage("EmailSubjectNotification");
//string url = WebUtils.ParseStringFromQueryString("u", string.Empty);
//StringBuilder message = new StringBuilder();
//message.Append(messageTemplate);
//message.Replace("{SiteName}", siteSettings.SiteName);
//message.Replace("{Name}", txtName.Text);
//message.Replace("{Email}", txtEmail.Text);
//message.Replace("{Link}", url);
//message.Replace("{Message}", txtMessage.Text);
//string fromAddress = siteSettings.DefaultEmailFromAddress;
EmailTemplate template = EmailTemplate.Get(siteSettings.SiteId, "EmailSubjectNotification", WorkingCulture.LanguageId);
string subjectEmail = template.Subject.Replace("{SiteName}", siteSettings.SiteName).Replace("{Subject}", txtSubject.Text.Trim());
string url = WebUtils.ParseStringFromQueryString("u", string.Empty);
StringBuilder message = new StringBuilder();
message.Append(template.HtmlBody);
message.Replace("{SiteName}", siteSettings.SiteName);
message.Replace("{Name}", txtName.Text);
message.Replace("{Email}", txtEmail.Text);
message.Replace("{Link}", url);
message.Replace("{Message}", txtMessage.Text);
string fromAddress = siteSettings.DefaultEmailFromAddress;
string fromAlias = template.FromName;
if (fromAlias.Length == 0)
{
fromAlias = siteSettings.DefaultFromEmailAlias;
}
string emailTo = (template.ToAddresses.Length > 0 ? ";" + template.ToAddresses : "");
string emailCc = template.CcAddresses;
string emailBcc = template.BccAddresses;
string emailReplyTo = (template.ReplyToAddress.Length > 0 ? ";" + template.ReplyToAddress : "");
SmtpSettings smtpSettings = SiteUtils.GetSmtpSettings();
try
{
//Email.SendEmail(
// smtpSettings,
// fromAddress,
// txtEmail.Text,
// txtToEmail.Text,
// string.Empty,
// string.Empty,
// "[" + siteSettings.SiteName + "]" + (this.txtSubject.Text.Trim() != "" ? (": " + this.txtSubject.Text.Trim()) : ""),
// message.ToString(),
// true,
// "Normal");
EmailMessageTask messageTask = new EmailMessageTask(smtpSettings);
messageTask.SiteGuid = siteSettings.SiteGuid;
messageTask.EmailFrom = fromAddress;
messageTask.EmailFromAlias = fromAlias;
messageTask.EmailReplyTo = txtEmail.Text.Trim() + emailReplyTo;
messageTask.EmailTo = txtToEmail.Text.Trim() + emailTo;
messageTask.EmailCc = emailCc;
messageTask.EmailBcc = emailBcc;
messageTask.UseHtml = true;
messageTask.Subject = subjectEmail;
messageTask.HtmlBody = message.ToString();
messageTask.QueueTask();
WebTaskManager.StartOrResumeTasks();
}
catch (Exception ex)
{
log.Error("Error sending email from address was " + fromAddress + " to address was " + txtToEmail.Text, ex);
}
this.lblMessage.Text = MessageTemplate.GetMessage("EmailSubjectThankYouMessage", NewsResources.EmailSubjectThankYouLabel);
this.pnlSend.Visible = false;
SetupScript();
}
}
public LogEventPropertyMessageValue(MessageTemplate template, IReadOnlyDictionary<string, LogEventProperty> properties)
{
_template = template;
_properties = properties;
}
/// <summary>
/// Maps the message template data.
/// </summary>
/// <param name="alertCollection">The alert collection.</param>
/// <returns>Message template data</returns>
private static MessageTemplate MapMessageTemplateData(AlertTypeCollection alertCollection)
{
var messageTemplateData = new MessageTemplate();
foreach (var messageTemplate in alertCollection)
{
messageTemplateData.Description = messageTemplate.Description;
messageTemplateData.Name = messageTemplate.Description;
}
return messageTemplateData;
}
/// <summary>
/// Get token groups of message template
/// </summary>
/// <param name="messageTemplate">Message template</param>
/// <returns>Collection of token group names</returns>
public static IEnumerable <string> GetTokenGroups(this MessageTemplate messageTemplate)
{
//groups depend on which tokens are added at the appropriate methods in IWorkflowMessageService
switch (messageTemplate.Name)
{
case MessageTemplateSystemNames.CustomerRegisteredNotification:
case MessageTemplateSystemNames.CustomerWelcomeMessage:
case MessageTemplateSystemNames.CustomerEmailValidationMessage:
case MessageTemplateSystemNames.CustomerEmailRevalidationMessage:
case MessageTemplateSystemNames.CustomerPasswordRecoveryMessage:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.CustomerTokens });
case MessageTemplateSystemNames.OrderPlacedVendorNotification:
case MessageTemplateSystemNames.OrderPlacedStoreOwnerNotification:
case MessageTemplateSystemNames.OrderPaidStoreOwnerNotification:
case MessageTemplateSystemNames.OrderPaidCustomerNotification:
case MessageTemplateSystemNames.OrderPaidVendorNotification:
case MessageTemplateSystemNames.OrderPlacedCustomerNotification:
case MessageTemplateSystemNames.OrderCompletedCustomerNotification:
case MessageTemplateSystemNames.OrderCancelledCustomerNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.OrderTokens, TokenGroupNames.CustomerTokens });
case MessageTemplateSystemNames.ShipmentSentCustomerNotification:
case MessageTemplateSystemNames.ShipmentDeliveredCustomerNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.ShipmentTokens, TokenGroupNames.OrderTokens, TokenGroupNames.CustomerTokens });
case MessageTemplateSystemNames.OrderRefundedStoreOwnerNotification:
case MessageTemplateSystemNames.OrderRefundedCustomerNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.OrderTokens, TokenGroupNames.RefundedOrderTokens, TokenGroupNames.CustomerTokens });
case MessageTemplateSystemNames.NewOrderNoteAddedCustomerNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.OrderNoteTokens, TokenGroupNames.OrderTokens, TokenGroupNames.CustomerTokens });
case MessageTemplateSystemNames.RecurringPaymentCancelledStoreOwnerNotification:
case MessageTemplateSystemNames.RecurringPaymentCancelledCustomerNotification:
case MessageTemplateSystemNames.RecurringPaymentFailedCustomerNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.OrderTokens, TokenGroupNames.CustomerTokens, TokenGroupNames.RecurringPaymentTokens });
case MessageTemplateSystemNames.NewsletterSubscriptionActivationMessage:
case MessageTemplateSystemNames.NewsletterSubscriptionDeactivationMessage:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.SubscriptionTokens });
case MessageTemplateSystemNames.EmailAFriendMessage:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.CustomerTokens, TokenGroupNames.ProductTokens, TokenGroupNames.EmailAFriendTokens });
case MessageTemplateSystemNames.WishlistToFriendMessage:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.CustomerTokens, TokenGroupNames.WishlistToFriendTokens });
case MessageTemplateSystemNames.NewReturnRequestStoreOwnerNotification:
case MessageTemplateSystemNames.NewReturnRequestCustomerNotification:
case MessageTemplateSystemNames.ReturnRequestStatusChangedCustomerNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.CustomerTokens, TokenGroupNames.ReturnRequestTokens });
case MessageTemplateSystemNames.NewForumTopicMessage:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.ForumTopicTokens, TokenGroupNames.ForumTokens, TokenGroupNames.CustomerTokens });
case MessageTemplateSystemNames.NewForumPostMessage:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.ForumPostTokens, TokenGroupNames.ForumTopicTokens, TokenGroupNames.ForumTokens, TokenGroupNames.CustomerTokens });
case MessageTemplateSystemNames.PrivateMessageNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.PrivateMessageTokens, TokenGroupNames.CustomerTokens });
case MessageTemplateSystemNames.NewVendorAccountApplyStoreOwnerNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.CustomerTokens, TokenGroupNames.VendorTokens });
case MessageTemplateSystemNames.VendorInformationChangeNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.VendorTokens });
case MessageTemplateSystemNames.GiftCardNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.GiftCardTokens });
case MessageTemplateSystemNames.ProductReviewNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.ProductReviewTokens, TokenGroupNames.CustomerTokens });
case MessageTemplateSystemNames.QuantityBelowStoreOwnerNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.ProductTokens });
case MessageTemplateSystemNames.QuantityBelowAttributeCombinationStoreOwnerNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.ProductTokens, TokenGroupNames.AttributeCombinationTokens });
case MessageTemplateSystemNames.NewVatSubmittedStoreOwnerNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.CustomerTokens, TokenGroupNames.VatValidation });
case MessageTemplateSystemNames.BlogCommentNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.BlogCommentTokens, TokenGroupNames.CustomerTokens });
case MessageTemplateSystemNames.NewsCommentNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.NewsCommentTokens, TokenGroupNames.CustomerTokens });
case MessageTemplateSystemNames.BackInStockNotification:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.CustomerTokens, TokenGroupNames.ProductBackInStockTokens });
case MessageTemplateSystemNames.ContactUsMessage:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.ContactUs });
case MessageTemplateSystemNames.ContactVendorMessage:
return(new[] { TokenGroupNames.StoreTokens, TokenGroupNames.ContactVendor });
default:
return(new string[] { });
}
}
/// <summary>
/// Maps the message template data from service.
/// </summary>
/// <param name="messageTemplate">The message template.</param>
/// <returns>Message Template data</returns>
private static Entities.AlertType MapMessageTemplateDataFromService(MessageTemplate messageTemplate)
{
if (messageTemplate != null)
{
return new Entities.AlertType
{
Description = messageTemplate.Description,
AlertTypeId = messageTemplate.MessageTemplateId,
ModifiedBy = messageTemplate.LastModifiedBy,
IsTemplate = true,
IsMessage = true
};
}
return null;
}
public abstract int GetId(MessageTemplate param1);
public void AddDynamicTemplateDefinition(MessageTemplate template)
{
_inStream.TemplateRegistry.Define(template);
_outStream.TemplateRegistry.Define(template);
}
public abstract void Register(int param1, MessageTemplate param2);
public bool BindMessageTemplate(string messageTemplate, object[] propertyValues, out MessageTemplate parsedTemplate, out IEnumerable <LogEventProperty> boundProperties)
{
parsedTemplate = new MessageTemplate(string.Empty, new List <MessageTemplateToken>());
boundProperties = new List <LogEventProperty>();
return(false);
}
/// <summary>
/// Saves a message template.
/// </summary>
/// <param name="template"></param>
public override void Save(MessageTemplate template)
{
repository.Save(template);
}
public void AddMessageHandler(MessageTemplate template, IMessageHandler handler)
{
_templateHandlers[template] = handler;
}
public LogIncomingMessageBehavior()
{
var templateParser = new MessageTemplateParser();
messageTemplate = templateParser.Parse("Receive message {MessageType} {MessageId}.");
}
public void RegisterTemplate(int templateId, MessageTemplate template)
{
_encoder.RegisterTemplate(templateId, template);
}
public void CanMergeWithAllNullParameters()
{
var t = new MessageTemplate();
var m = t.Merge(null, null, null, null);
Assert.IsNotNull(m);
}
private void btnPostComment_Click(object sender, EventArgs e)
{
if (!IsValidComment())
{
return;
}
if (news == null)
{
return;
}
//if (news.AllowCommentsForDays < 0)
//{
// WebUtils.SetupRedirect(this, Request.RawUrl);
// return;
//}
//DateTime endDate = news.StartDate.AddDays((double)news.AllowCommentsForDays);
//if ((endDate < DateTime.UtcNow) && (news.AllowCommentsForDays > 0)) { return; }
string attachFile1 = null;
string attachFile2 = null;
string attachmentsPath = NewsHelper.AttachmentsPath(siteSettings.SiteId, news.NewsID);
if (uplAttachFile1.UploadedFiles.Count > 0 || uplAttachFile2.UploadedFiles.Count > 0)
{
try
{
string fileSystemPath = Server.MapPath(attachmentsPath);
if (!Directory.Exists(fileSystemPath))
{
Directory.CreateDirectory(fileSystemPath);
}
}
catch (Exception ex)
{
}
}
if (uplAttachFile1.UploadedFiles.Count > 0)
{
if (SiteUtils.IsAllowedUploadBrowseFile(uplAttachFile1.UploadedFiles[0].GetExtension(), NewsConfiguration.JobApplyAttachFileExtensions))
{
attachFile1 = uplAttachFile1.UploadedFiles[0].FileName.ToCleanFileName(WebConfigSettings.ForceLowerCaseForUploadedFiles);
int i = 1;
while (File.Exists(VirtualPathUtility.Combine(attachmentsPath, attachFile1)))
{
attachFile1 = i.ToInvariantString() + attachFile1;
i += 1;
}
}
}
if (uplAttachFile2.UploadedFiles.Count > 0)
{
if (SiteUtils.IsAllowedUploadBrowseFile(uplAttachFile2.UploadedFiles[0].GetExtension(), NewsConfiguration.JobApplyAttachFileExtensions))
{
attachFile2 = uplAttachFile2.UploadedFiles[0].FileName.ToCleanFileName(WebConfigSettings.ForceLowerCaseForUploadedFiles);
int i = 1;
while (File.Exists(VirtualPathUtility.Combine(attachmentsPath, attachFile2)))
{
attachFile2 = i.ToInvariantString() + attachFile2;
i += 1;
}
}
}
News.AddNewsComment(
news.NewsID,
txtFullName.Text,
txtPosition.Text,
url,
txtMessage.Text,
txtAddress.Text,
txtEmail.Text,
txtPhone.Text,
attachFile1,
attachFile2,
DateTime.UtcNow);
if (!string.IsNullOrEmpty(attachFile1))
{
string newAttachmentsPath = VirtualPathUtility.Combine(attachmentsPath, attachFile1);
uplAttachFile1.UploadedFiles[0].SaveAs(Server.MapPath(newAttachmentsPath));
}
if (!string.IsNullOrEmpty(attachFile2))
{
string newAttachmentsPath = VirtualPathUtility.Combine(attachmentsPath, attachFile2);
uplAttachFile2.UploadedFiles[0].SaveAs(Server.MapPath(newAttachmentsPath));
}
try
{
StringBuilder message = new StringBuilder();
//message.Append(string.Format("<a target='_blank' href='{0}'>{1}</a>", url, url) + "<br /><br />");
if (!string.IsNullOrEmpty(txtPosition.Text.Trim()))
{
message.Append("<b>" + NewsResources.JobPositionLabel + ":</b> " + txtPosition.Text.Trim() + "<br />");
}
if (!string.IsNullOrEmpty(txtFullName.Text.Trim()))
{
message.Append("<b>" + NewsResources.JobFullNameLabel + ":</b> " + txtFullName.Text.Trim() + "<br />");
}
if (!string.IsNullOrEmpty(txtAddress.Text.Trim()))
{
message.Append("<b>" + NewsResources.JobAddressLabel + ":</b> " + txtAddress.Text.Trim() + "<br />");
}
if (!string.IsNullOrEmpty(txtEmail.Text.Trim()))
{
message.Append("<b>" + NewsResources.JobEmailLabel + ":</b> " + txtEmail.Text.Trim() + "<br />");
}
if (!string.IsNullOrEmpty(txtPhone.Text.Trim()))
{
message.Append("<b>" + NewsResources.JobPhoneLabel + ":</b> " + txtPhone.Text.Trim() + "<br />");
}
if (!string.IsNullOrEmpty(attachFile1))
{
string attachFile = string.Format("<a target='_blank' href='{0}'>{1}</a>", basePage.SiteRoot + Page.ResolveUrl(NewsHelper.AttachmentsPath(siteSettings.SiteId, newsId)) + attachFile1, attachFile1);
message.Append("<b>" + NewsResources.JobAttachFile1Label + ":</b> " + attachFile + "<br />");
}
if (!string.IsNullOrEmpty(attachFile2))
{
string attachFile = string.Format("<a target='_blank' href='{0}'>{1}</a>", basePage.SiteRoot + Page.ResolveUrl(NewsHelper.AttachmentsPath(siteSettings.SiteId, newsId)) + attachFile2, attachFile2);
message.Append("<b>" + NewsResources.JobAttachFile2Label + ":</b> " + attachFile + "<br />");
}
message.Append("<b>" + NewsResources.JobMessageLabel + ":</b><br />" + SiteUtils.ChangeRelativeUrlsToFullyQualifiedUrls(SiteUtils.GetNavigationSiteRoot(), WebUtils.GetSiteRoot(), txtMessage.Text));
message.Append("<br /><br />");
EmailTemplate template = EmailTemplate.Get(siteSettings.SiteId, "JobApplyNotification");
string fromAddress = siteSettings.DefaultEmailFromAddress;
string fromAlias = template.FromName;
if (fromAlias.Length == 0)
{
fromAlias = siteSettings.DefaultFromEmailAlias;
}
NewsHelper.SendCommentNotification(
SiteUtils.GetSmtpSettings(),
siteSettings.SiteGuid,
fromAddress,
fromAlias,
template.ToAddresses,
template.ReplyToAddress,
template.CcAddresses,
template.BccAddresses,
template.Subject,
template.HtmlBody,
siteSettings.SiteName,
message.ToString());
}
catch (Exception ex)
{
log.Error("Error sending email from address was " + siteSettings.DefaultEmailFromAddress + " to address was " + siteSettings.CompanyPublicEmail, ex);
}
lblMessage.Text = MessageTemplate.GetMessage("JobApplyThankYouMessage", NewsResources.JobApplyThankYouLabel);
pnlNewComment.Visible = false;
}
/// <summary>
/// Create a copy of message template with all depended data
/// </summary>
/// <param name="messageTemplate">Message template</param>
/// <returns>Message template copy</returns>
public virtual async Task <MessageTemplate> CopyMessageTemplateAsync(MessageTemplate messageTemplate)
{
if (messageTemplate == null)
{
throw new ArgumentNullException(nameof(messageTemplate));
}
var mtCopy = new MessageTemplate
{
Name = messageTemplate.Name,
BccEmailAddresses = messageTemplate.BccEmailAddresses,
Subject = messageTemplate.Subject,
Body = messageTemplate.Body,
IsActive = messageTemplate.IsActive,
AttachedDownloadId = messageTemplate.AttachedDownloadId,
EmailAccountId = messageTemplate.EmailAccountId,
LimitedToStores = messageTemplate.LimitedToStores,
DelayBeforeSend = messageTemplate.DelayBeforeSend,
DelayPeriod = messageTemplate.DelayPeriod
};
await InsertMessageTemplateAsync(mtCopy);
var languages = await _languageService.GetAllLanguagesAsync(true);
//localization
foreach (var lang in languages)
{
var bccEmailAddresses = await _localizationService.GetLocalizedAsync(messageTemplate, x => x.BccEmailAddresses, lang.Id, false, false);
if (!string.IsNullOrEmpty(bccEmailAddresses))
{
await _localizedEntityService.SaveLocalizedValueAsync(mtCopy, x => x.BccEmailAddresses, bccEmailAddresses, lang.Id);
}
var subject = await _localizationService.GetLocalizedAsync(messageTemplate, x => x.Subject, lang.Id, false, false);
if (!string.IsNullOrEmpty(subject))
{
await _localizedEntityService.SaveLocalizedValueAsync(mtCopy, x => x.Subject, subject, lang.Id);
}
var body = await _localizationService.GetLocalizedAsync(messageTemplate, x => x.Body, lang.Id, false, false);
if (!string.IsNullOrEmpty(body))
{
await _localizedEntityService.SaveLocalizedValueAsync(mtCopy, x => x.Body, body, lang.Id);
}
var emailAccountId = await _localizationService.GetLocalizedAsync(messageTemplate, x => x.EmailAccountId, lang.Id, false, false);
if (emailAccountId > 0)
{
await _localizedEntityService.SaveLocalizedValueAsync(mtCopy, x => x.EmailAccountId, emailAccountId, lang.Id);
}
}
//store mapping
var selectedStoreIds = await _storeMappingService.GetStoresIdsWithAccessAsync(messageTemplate);
foreach (var id in selectedStoreIds)
{
await _storeMappingService.InsertStoreMappingAsync(mtCopy, id);
}
return(mtCopy);
}
private void PrepareLastModelTree(MessageTemplate template)
{
ViewBag.LastModelTreeJson = template.LastModelTree;
ViewBag.LastModelTree = Services.Resolve <IMessageModelProvider>().GetLastModelTree(template);
}
public void Process(string messageTemplate, object[] messageTemplateParameters, out MessageTemplate parsedTemplate, out IEnumerable<LogEventProperty> properties)
{
parsedTemplate = _parser.Parse(messageTemplate);
properties = _propertyBinder.ConstructProperties(parsedTemplate, messageTemplateParameters);
}
/// <summary>
/// Inserts a message template
/// </summary>
/// <param name="messageTemplate">Message template</param>
public virtual async Task InsertMessageTemplateAsync(MessageTemplate messageTemplate)
{
await _messageTemplateRepository.InsertAsync(messageTemplate);
}
/// <summary>
/// Maps the message template data update.
/// </summary>
/// <param name="alertCollection">The alert collection.</param>
/// <returns>Message template data</returns>
private static MessageTemplate MapMessageTemplateDataUpdate(AlertTypeCollection alertCollection)
{
var messageTemplateData = new MessageTemplate();
foreach (var messageTemplate in alertCollection)
{
messageTemplateData.Description = messageTemplate.Description;
if (!string.IsNullOrEmpty(messageTemplate.AlertTypeId))
{
messageTemplateData.MessageTemplateId = messageTemplate.AlertTypeId;
messageTemplateData.LastModifiedBy = messageTemplate.ModifiedBy;
}
messageTemplateData.Name = messageTemplate.Description;
}
return messageTemplateData;
}
/// <summary>
/// Updates a message template
/// </summary>
/// <param name="messageTemplate">Message template</param>
public virtual async Task UpdateMessageTemplateAsync(MessageTemplate messageTemplate)
{
await _messageTemplateRepository.UpdateAsync(messageTemplate);
}
public LiterateConsoleSink(string outputTemplate, IFormatProvider formatProvider)
{
if (outputTemplate == null) throw new ArgumentNullException("outputTemplate");
_outputTemplate = new MessageTemplateParser().Parse(outputTemplate);
_formatProvider = formatProvider;
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
uxMessagePlaceHolder.Controls.Clear();
uxValidationSummaryPlaceHolder.Controls.Clear();
uxValidationDenotePlaceHolder.Controls.Clear();
uxLanguageControlPlaceHolder.Controls.Clear();
uxButtonEventPlaceHolder.Controls.Clear();
uxButtonCommandPlaceHolder.Controls.Clear();
uxButtonEventInnerBoxPlaceHolder.Controls.Clear();
uxTopContentBoxPlaceHolder.Controls.Clear();
uxFilterPlaceHolder.Controls.Clear();
uxSpecialFilterPlaceHolder.Controls.Clear();
uxPageNumberPlaceHolder.Controls.Clear();
uxGridPlaceHolder.Controls.Clear();
uxBottomContentBoxPlaceHolder.Controls.Clear();
uxContentPlaceHolder.Controls.Clear();
// Message.
ContentContainer container = new ContentContainer();
if (MessageTemplate != null)
{
MessageTemplate.InstantiateIn(container);
uxMessagePlaceHolder.Controls.Add(container);
uxMessagePlaceHolder.Visible = true;
}
else
{
uxMessagePlaceHolder.Controls.Add(new LiteralControl("No Message Defined"));
uxMessagePlaceHolder.Visible = false;
}
// Validation Summary
container = new ContentContainer();
if (ValidationSummaryTemplate != null)
{
ValidationSummaryTemplate.InstantiateIn(container);
uxValidationSummaryPlaceHolder.Controls.Add(container);
uxValidationSummaryPanel.Visible = true;
}
else
{
uxValidationSummaryPlaceHolder.Controls.Add(new LiteralControl("No Validation Summary Defined"));
uxValidationSummaryPanel.Visible = false;
}
// Validation Denotes
container = new ContentContainer();
if (ValidationDenotesTemplate != null)
{
ValidationDenotesTemplate.InstantiateIn(container);
uxValidationDenotePlaceHolder.Controls.Add(container);
uxValidationDenotePanel.Visible = true;
}
else
{
uxValidationDenotePlaceHolder.Controls.Add(new LiteralControl("No Validation Denotes Defined"));
uxValidationDenotePanel.Visible = false;
}
// If all message disapear message panel will not show.
if (!uxMessagePlaceHolder.Visible & !uxValidationSummaryPanel.Visible)
{
uxMessagePanel.Visible = false;
}
else
{
uxMessagePanel.Visible = true;
}
container = new ContentContainer();
if (LanguageControlTemplate != null)
{
LanguageControlTemplate.InstantiateIn(container);
uxLanguageControlPlaceHolder.Controls.Add(container);
uxLanguageControlPanel.Visible = true;
}
else
{
uxLanguageControlPlaceHolder.Controls.Add(new LiteralControl("No Language Control Defined"));
uxLanguageControlPanel.Visible = false;
}
// If don't have any language and message top panel will not show.
if (!uxFilterPanel.Visible & !uxLanguageControlPanel.Visible & !uxSpecialFilterPanel.Visible)
{
uxTopPagePanel.Visible = false;
}
else
{
uxTopPagePanel.Visible = true;
}
if (ButtonEventTemplate == null)
{
uxButtonEventPanel.Visible = false;
}
else
{
container = new ContentContainer();
ButtonEventTemplate.InstantiateIn(container);
uxButtonEventPlaceHolder.Controls.Add(container);
uxButtonEventPanel.Visible = true;
}
if (ButtonCommandTemplate == null)
{
uxButtonCommandPanel.Visible = false;
}
else
{
container = new ContentContainer();
ButtonCommandTemplate.InstantiateIn(container);
uxButtonCommandPlaceHolder.Controls.Add(container);
uxButtonCommandPanel.Visible = true;
}
if (ButtonEventInnerBoxTemplate == null)
{
uxButtonEventInnerBoxPanel.Visible = false;
}
else
{
container = new ContentContainer();
ButtonEventInnerBoxTemplate.InstantiateIn(container);
uxButtonEventInnerBoxPlaceHolder.Controls.Add(container);
uxButtonEventInnerBoxPanel.Visible = true;
}
container = new ContentContainer();
if (TopContentBoxTemplate != null)
{
TopContentBoxTemplate.InstantiateIn(container);
uxTopContentBoxPlaceHolder.Controls.Add(container);
uxTopContentBoxPanel.Visible = true;
}
else
{
uxTopContentBoxPlaceHolder.Controls.Add(new LiteralControl("No TopContentBox Content Defined"));
uxTopContentBoxPlaceHolder.Visible = false;
uxTopContentBoxPanel.Visible = false;
}
container = new ContentContainer();
if (ContentTemplate != null)
{
ContentTemplate.InstantiateIn(container);
uxContentPlaceHolder.Controls.Add(container);
uxContentPanel.Visible = true;
}
else
{
uxContentPlaceHolder.Controls.Add(new LiteralControl("No Template Defined"));
uxContentPanel.Visible = false;
}
container = new ContentContainer();
if (PlainContentTemplate != null)
{
PlainContentTemplate.InstantiateIn(container);
uxPlainContentPlaceHolder.Controls.Add(container);
uxPlainContentPanel.Visible = true;
}
else
{
uxPlainContentPlaceHolder.Controls.Add(new LiteralControl("No Template Defined"));
uxPlainContentPanel.Visible = false;
}
if (FilterTemplate == null)
{
uxFilterPanel.Visible = false;
}
else
{
container = new ContentContainer();
FilterTemplate.InstantiateIn(container);
uxFilterPlaceHolder.Controls.Add(container);
uxFilterPanel.Visible = true;
}
if (SpecialFilterTemplate == null)
{
uxSpecialFilterPanel.Visible = false;
}
else
{
container = new ContentContainer();
SpecialFilterTemplate.InstantiateIn(container);
uxSpecialFilterPlaceHolder.Controls.Add(container);
uxSpecialFilterPanel.Visible = true;
}
if (PageNumberTemplate == null)
{
uxPageNumberPanel.Visible = false;
}
else
{
container = new ContentContainer();
PageNumberTemplate.InstantiateIn(container);
uxPageNumberPlaceHolder.Controls.Add(container);
uxPageNumberPanel.Visible = true;
}
if (GridTemplate == null)
{
uxGridPanel.Visible = false;
}
else
{
container = new ContentContainer();
GridTemplate.InstantiateIn(container);
uxGridPlaceHolder.Controls.Add(container);
uxGridPanel.Visible = true;
}
if (uxGridPanel.Visible || uxPageNumberPanel.Visible || uxTopContentBoxPlaceHolder.Visible || uxButtonCommandPanel.Visible || uxButtonEventInnerBoxPanel.Visible)
{
uxTopContentBoxSet.Visible = true;
}
else
{
uxTopContentBoxSet.Visible = false;
}
if (BottomContentBoxTemplate == null)
{
uxBottomContentBoxPlaceHolder.Visible = false;
uxBottomContentBoxPanel.Visible = false;
}
else
{
container = new ContentContainer();
BottomContentBoxTemplate.InstantiateIn(container);
uxBottomContentBoxPlaceHolder.Controls.Add(container);
uxBottomContentBoxPlaceHolder.Visible = true;
}
if (HeaderMessageTemplate != null)
{
HeaderMessageTemplate.InstantiateIn(container);
uxHeaderMeassagePlaceHolder.Controls.Add(container);
uxHeaderMeassagePanel.Visible = true;
}
else
{
uxHeaderMeassagePlaceHolder.Controls.Add(new LiteralControl("No Template Defined"));
uxHeaderMeassagePanel.Visible = false;
}
}
