public void Should_return_true_if_Messages_contains_only_messages_with_Info_Severity()
{
var notification = new Notification();
var messageTest = new NotificationMessage(NotificationSeverity.Info, "");
notification.Add(messageTest);
Assert.IsTrue(notification.IsValid);
}
void INotificationChannel.Notify(NotificationMessage notificationMessage)
{
if (Observer != null)
notificationMessage.InvokePayload.Invoke(Observer);
if (Messages != null)
Messages.Add(notificationMessage);
}
public void get_message_with_substitutions()
{
var message = new NotificationMessage(NotificationMessageKeys.SUBSTITUTE_NAME_AND_AGE)
.AddSubstitution("Name", "Max")
.AddSubstitution("Age", "7");
message.GetMessage().ShouldEqual("Max is 7 years old");
}
public void Should_return_false_if_Messages_contains_only_messages_with_Warning_Severity()
{
var notification = new Notification();
var messageTest = new NotificationMessage(NotificationSeverity.Warning, "");
notification.Add(messageTest);
Assert.IsFalse(notification.IsValid);
}
public void Publish(NotificationMessage message)
{
Task.Delay(message.millis).ContinueWith((antecedent) => {
foreach (var connection in _subscribers){
Clients.Client(connection).notification(message.message);
}
});
}
public static ValidationStrategyResult Invalid(NotificationMessage message)
{
return new ValidationStrategyResult
{
IsValid = false,
Message = message
};
}
public void Should_return_the_formatted_value_that_was_passed_in_the_constructor_if_a_format_string_was_used()
{
const string format = "test {0} now {1}";
const int arg0 = 1;
const string arg1 = "help";
var message = new NotificationMessage(NotificationSeverity.Warning, format, arg0, arg1);
Assert.AreEqual(String.Format(format, arg0, arg1), message.Message);
}
private void HandleNotificationMessage(NotificationMessage message)
{
if (message == null) return;
if (message.Notification == UIMessageType.Common_CloseWindowEvent)
{
this.Close();
}
}
protected override void OnNotificationMessage(NotificationMessage message)
{
SendPacket(new Packet
{
Type = PacketType.Notification,
ActorId = message.ObserverId,
RequestId = message.NotificationId,
Message = message.InvokePayload,
});
}
public void equality_check_negative()
{
var token = StringToken.FromKeyString("Test", "1...2...3");
var v1 = TemplateValue.For("FirstName", "Joel");
var v2 = TemplateValue.For("LastName", "Arnold");
var message1 = new NotificationMessage(token, v1, v2);
var message2 = new NotificationMessage(token, v1);
message1.ShouldNotEqual(message2);
}
public void NotificationMessage_Equality()
{
var notificationMessage1 = new NotificationMessage("propertyName1", "errorMessage1");
var notificationMessage2 = new NotificationMessage("propertyName1", "errorMessage1");
var notificationMessage3 = new NotificationMessage("propertyName3", "errorMessage3");
Assert.AreEqual(notificationMessage1, notificationMessage2);
Assert.AreNotEqual(notificationMessage1, notificationMessage3);
Assert.IsTrue(notificationMessage1 == notificationMessage2);
Assert.IsTrue(notificationMessage1 != notificationMessage3);
}
public void Should_copy_the_NotificationMessages_from_the_source_if_the_destination_is_not_Notification_Null()
{
var source = new Notification();
var notification = new NotificationMessage(NotificationSeverity.Error, "");
source.Add(notification);
var destination = new Notification();
destination.Add(notification);
Assert.AreEqual(1, destination.Messages.Count());
Assert.AreEqual(notification, destination.Messages.First());
}
public void ProcessFeed()
{
try
{
_logger.Log("ProcessFeed() called...", LogCategory.Information);
using (var rss = new RssReader(ConfigurationManager.AppSettings["FeedUrl"]))
{
var items = rss.Execute().ToList();
var newNofication = new List<RssItem>();
if(items.Count <= 0)
return;
try
{
using (IDataContext dataContext = _dataContextFactory.Create(ConnectionType.Ip))
{
var notifications = dataContext.Query<NotificationMessage>().ToList();
newNofication.AddRange(notifications.Any()
? items.Where(rssItem => notifications.All(n => n.StartDate != rssItem.Date))
: items);
foreach (var rssNotification in newNofication)
{
var notification = new NotificationMessage
{
Text = rssNotification.Title,
Link = rssNotification.Link,
StartDate = rssNotification.Date,
EndDate = rssNotification.ExpireOn,
NotificationId = Guid.NewGuid()
};
dataContext.Add(notification);
}
}
}
catch (Exception ex)
{
LogException(ex);
}
}
}
catch (Exception ex)
{
LogException(ex);
}
}
public void prepend_property()
{
var message = new NotificationMessage(ValidationKeys.Required);
message.AddAccessor(ReflectionHelper.GetAccessor<ContactModel>(x => x.FirstName));
message.AddAccessor(ReflectionHelper.GetAccessor<ContactModel>(x => x.LastName));
var property = ReflectionHelper.GetAccessor<CompositeModel>(x => x.Contact);
var prepended = message.Prepend(property);
prepended.ShouldNotBeTheSameAs(message);
prepended.Accessors.Select(x => x.Name).ShouldHaveTheSameElementsAs("ContactFirstName", "ContactLastName");
prepended.StringToken.ShouldEqual(ValidationKeys.Required);
}
public void Validate(Accessor accessor, ValidationContext context)
{
var username = context.GetFieldValue<string>(accessor);
var userService = context.Service<IUserService>();
if (userService.ExistsByUsername(username))
{
var token = new ValidationKeys("Username {0} is already in use.".ToFormat(FIELD.AsTemplateField()));
var msg = new NotificationMessage(token);
msg.AddSubstitution(FIELD, username);
context.Notification.RegisterMessage(accessor, msg);
}
}
public void to_validation_error_if_multiple_accessors_match_a_message()
{
var notification = new Notification();
var token = StringToken.FromKeyString("test1", "test1");
var message = new NotificationMessage(token);
message.AddAccessor(ReflectionHelper.GetAccessor<EntityToValidate>(x => x.Something));
message.AddAccessor(ReflectionHelper.GetAccessor<EntityToValidate>(x => x.Else));
notification.RegisterMessage(message);
var errors = notification.ToValidationErrors();
errors.Length.ShouldEqual(2);
errors.Each(x => x.message.ShouldEqual("test1"));
errors.First().field.ShouldEqual("Something");
errors.Last().field.ShouldEqual("Else");
}
protected abstract Task Send(NotificationMessage model, T settings);
public void Notify(NotificationMessage message)
{
EmailManager.Current.SendEmail(message);
}
/// <summary>
/// Processes the response from a publish request.
/// </summary>
private void ProcessPublishResponse(
ResponseHeader responseHeader,
uint subscriptionId,
UInt32Collection availableSequenceNumbers,
bool moreNotifications,
NotificationMessage notificationMessage)
{
Subscription subscription = null;
// send notification that the server is alive.
OnKeepAlive(m_serverState, responseHeader.Timestamp);
// collect the current set if acknowledgements.
lock (SyncRoot)
{
// clear out acknowledgements for messages that the server does not have any more.
SubscriptionAcknowledgementCollection acknowledgementsToSend = new SubscriptionAcknowledgementCollection();
for (int ii = 0; ii < m_acknowledgementsToSend.Count; ii++)
{
SubscriptionAcknowledgement acknowledgement = m_acknowledgementsToSend[ii];
if (acknowledgement.SubscriptionId != subscriptionId)
{
acknowledgementsToSend.Add(acknowledgement);
}
else
{
if (availableSequenceNumbers == null || availableSequenceNumbers.Contains(acknowledgement.SequenceNumber))
{
acknowledgementsToSend.Add(acknowledgement);
}
}
}
// create an acknowledgement to be sent back to the server.
if (notificationMessage.NotificationData.Count > 0)
{
SubscriptionAcknowledgement acknowledgement = new SubscriptionAcknowledgement();
acknowledgement.SubscriptionId = subscriptionId;
acknowledgement.SequenceNumber = notificationMessage.SequenceNumber;
acknowledgementsToSend.Add(acknowledgement);
}
uint lastSentSequenceNumber = 0;
if (availableSequenceNumbers != null)
{
foreach (uint availableSequenceNumber in availableSequenceNumbers)
{
if (m_latestAcknowledgementsSent.ContainsKey(subscriptionId))
{
lastSentSequenceNumber = m_latestAcknowledgementsSent[subscriptionId];
// If the last sent sequence number is uint.Max do not display the warning; the counter rolled over
// If the last sent sequence number is greater or equal to the available sequence number (returned by the publish), a warning must be logged.
if (((lastSentSequenceNumber >= availableSequenceNumber) && (lastSentSequenceNumber != uint.MaxValue)) || (lastSentSequenceNumber == availableSequenceNumber) && (lastSentSequenceNumber == uint.MaxValue))
{
Utils.Trace("Received sequence number which was already acknowledged={0}", availableSequenceNumber);
}
}
}
}
if (m_latestAcknowledgementsSent.ContainsKey(subscriptionId))
{
lastSentSequenceNumber = m_latestAcknowledgementsSent[subscriptionId];
// If the last sent sequence number is uint.Max do not display the warning; the counter rolled over
// If the last sent sequence number is greater or equal to the notificationMessage's sequence number (returned by the publish), a warning must be logged.
if (((lastSentSequenceNumber >= notificationMessage.SequenceNumber) && (lastSentSequenceNumber != uint.MaxValue)) || (lastSentSequenceNumber == notificationMessage.SequenceNumber) && (lastSentSequenceNumber == uint.MaxValue))
{
Utils.Trace("Received sequence number which was already acknowledged={0}", notificationMessage.SequenceNumber);
}
}
if (availableSequenceNumbers != null)
{
foreach (var acknowledgement in acknowledgementsToSend)
{
if (acknowledgement.SubscriptionId == subscriptionId && !availableSequenceNumbers.Contains(acknowledgement.SequenceNumber))
{
Utils.Trace("Sequence number={0} was not received in the available sequence numbers.", acknowledgement.SequenceNumber);
}
}
}
m_acknowledgementsToSend = acknowledgementsToSend;
if (notificationMessage.IsEmpty)
{
Utils.Trace("Empty notification message received for SessionId {0} with PublishTime {1}", SessionId, notificationMessage.PublishTime.ToLocalTime());
}
// find the subscription.
foreach (Subscription current in m_subscriptions)
{
if (current.Id == subscriptionId)
{
subscription = current;
break;
}
}
}
// ignore messages with a subscription that has been deleted.
if (subscription != null)
{
// Validate publish time and reject old values.
if (notificationMessage.PublishTime.AddMilliseconds(subscription.CurrentPublishingInterval * subscription.CurrentLifetimeCount) < DateTime.UtcNow)
{
Utils.Trace("PublishTime {0} in publish response is too old for SubscriptionId {1}.", notificationMessage.PublishTime.ToLocalTime(), subscription.Id);
}
// Validate publish time and reject old values.
if (notificationMessage.PublishTime > DateTime.UtcNow.AddMilliseconds(subscription.CurrentPublishingInterval * subscription.CurrentLifetimeCount))
{
Utils.Trace("PublishTime {0} in publish response is newer than actual time for SubscriptionId {1}.", notificationMessage.PublishTime.ToLocalTime(), subscription.Id);
}
// update subscription cache.
subscription.SaveMessageInCache(
availableSequenceNumbers,
notificationMessage,
responseHeader.StringTable);
// raise the notification.
lock (m_eventLock)
{
NotificationEventArgs args = new NotificationEventArgs(subscription, notificationMessage, responseHeader.StringTable);
if (m_Publish != null)
{
ThreadPool.QueueUserWorkItem(OnRaisePublishNotification, args);
}
}
}
else
{
Utils.Trace("Received Publish Response for Unknown SubscriptionId={0}", subscriptionId);
}
}
protected override void ExecuteLogic()
{
// get the triggering record
var target = Target;
NotificationMessage message = null;
var isEnabled = CrmHelpers
.GetGenericConfig(Service, Context.OrganizationId).ToEntity <CommonConfiguration>()?
.NotificationsCentreEnabled == true;
if (!isEnabled)
{
return;
}
switch (target.LogicalName)
{
case Email.EntityLogicalName:
var email = target.ToEntity <Email>();
var body = email.Description;
// no message
if (string.IsNullOrEmpty(body))
{
return;
}
if (body.Contains("<html>"))
{
var doc = new XmlDocument();
doc.LoadXml(body);
body = doc.SelectSingleNode("body")?.InnerXml;
}
// html has no body to display
if (string.IsNullOrEmpty(body))
{
return;
}
var users = email.To
.Select(e => e.Party)
.Where(a => a.LogicalName == User.EntityLogicalName)
.Select(a =>
new NotificationMessageUser
{
User = a.Id
}).ToArray();
// no users to notify
if (!users.Any())
{
return;
}
message =
new NotificationMessage
{
Title = email.Subject,
Message = body,
RegardingTypeCode = Email.EntityTypeCode,
RegardingID = target.Id.ToString(),
MessageUsers = users,
NotificationSource = GlobalEnums.NotificationSource.Email
};
break;
case Task.EntityLogicalName:
var task = target.ToEntity <Task>();
message =
new NotificationMessage
{
Title = task.Subject,
Message = task.Description,
RegardingTypeCode = Task.EntityTypeCode,
RegardingID = target.Id.ToString()
};
var owner = task.Owner;
switch (owner.LogicalName)
{
case User.EntityLogicalName:
message.MessageUsers =
new[]
{
new NotificationMessageUser
{
User = owner.Id
}
};
break;
case Team.EntityLogicalName:
message.MessageTeams =
new[]
{
new NotificationMessageTeam
{
Team = owner.Id
}
};
break;
}
message.NotificationSource = GlobalEnums.NotificationSource.Task;
break;
}
if (message != null)
{
message.StatusReason = NotificationMessage.StatusReasonEnum.Open;
Service.Create(message);
}
}
private void ReplyToMessage(NotificationMessage msg)
{
Window win = null;
if (!(msg.Target is SendType))
{
return;
}
switch ((SendType)msg.Target)
{
case SendType.DoScrollHome:
{
this.sv.ScrollToHome();
return;
}
case SendType.ResetScroll:
{
this.ot.VerticalOffset = double.NaN;
this.ot.Time = System.DateTime.Now;
return;
}
case SendType.DoScrollLineDown:
{
if (this.ot.VerticalOffset != this.sv.ContentVerticalOffset)
{
this.sv.LineDown();
this.ot.VerticalOffset = this.sv.ContentVerticalOffset;
this.ot.Time = System.DateTime.Now;
}
else
{
if ((System.DateTime.Now - this.ot.Time) > System.TimeSpan.FromMilliseconds(500))
{
// page down
Messenger.Default.Send <NotificationMessage>(new NotificationMessage(this, SendType.DoScrollPageDown, "DoScroll"));
}
}
return;
}
case SendType.DoScrollLineUp:
{
if (this.ot.VerticalOffset != this.sv.ContentVerticalOffset)
{
this.sv.LineUp();
this.ot.VerticalOffset = this.sv.ContentVerticalOffset;
this.ot.Time = System.DateTime.Now;
}
else
{
if ((System.DateTime.Now - this.ot.Time) > System.TimeSpan.FromMilliseconds(500))
{
// page up
Messenger.Default.Send <NotificationMessage>(new NotificationMessage(this, SendType.DoScrollPageUp, "DoScroll"));
}
}
return;
}
case SendType.OpenAboutReq:
{
win = new AboutWindow();
break;
}
case SendType.OpenFileReq:
{
DoOpenFile();
return;
}
case SendType.OpenSettingsReq:
{
win = new SettingsWindow();
break;
}
case SendType.LoadFinished:
{
return;
}
case SendType.OpenPopup:
{
var transform = this.menuButton.TransformToVisual(this as FrameworkElement);
Point absolutePosition = transform.Transform(new Point(0, 0));
win = new PopupWindow();
win.Owner = this;
win.Icon = this.Icon;
win.Left = absolutePosition.X + this.menuButton.Width;
win.Top = absolutePosition.Y;
win.Show();
return;
}
case SendType.FocusListBox:
{
this.listBox1.Focus();
return;
}
case SendType.ShowMessage:
{
win = new MessageWindow();
break;
}
}
if (win != null)
{
win.Icon = this.Icon;
win.Owner = this;
win.ShowDialog();
}
}
private void OnSetDuplicatePath(NotificationMessage message)
{
DuplicateCheckDirectories.Add(message.Notification);
}
private void NotificationMessageReceived(NotificationMessage msg)
{
//If this is not the intended target
if (msg.Target != null && msg.Target != this)
{
return;
}
if (msg.Notification == "OpenFocusTree")
{
FocusGridModel container = msg.Sender as FocusGridModel;
if (TabsModelList.Contains(container))
{
return;
}
CheckForChanges(container);
TabsModelList.Add(container);
RaisePropertyChanged("TabsModelList");
}
if (msg.Notification == "OpenLocalisation")
{
LocalisationModel container = msg.Sender as LocalisationModel;
if (TabsModelList.Contains(container))
{
return;
}
CheckForChanges(container);
TabsModelList.Add(container);
RaisePropertyChanged("TabsModelList");
}
if (msg.Notification == "OpenEventList")
{
EventTabModel container = msg.Sender as EventTabModel;
if (TabsModelList.Contains(container))
{
return;
}
CheckForChanges(container);
TabsModelList.Add(container);
RaisePropertyChanged("TabsModelList");
}
if (msg.Notification == "OpenScriptList")
{
ScriptModel container = msg.Sender as ScriptModel;
if (TabsModelList.Contains(container))
{
return;
}
CheckForChanges(container);
TabsModelList.Add(container);
RaisePropertyChanged("TabsModelList");
}
if (msg.Notification == "SaveProject")
{
saveProject();
}
if (msg.Notification == "RefreshProjectViewer")
{
TabsModelList.Clear();
RaisePropertyChanged("TabsModelList");
}
if (msg.Notification == "SendDeleteItemSignal")
{
ObservableObject Model = null;
if (msg.Sender is FocusGridModel)
{
Model = TabsModelList.FirstOrDefault((m) => m is FocusGridModel &&
((FocusGridModel)m).UniqueID == ((FocusGridModel)msg.Sender).UniqueID);
}
else if (msg.Sender is LocalisationModel)
{
Model = TabsModelList.FirstOrDefault((m) => m is LocalisationModel &&
((LocalisationModel)m).UniqueID == ((LocalisationModel)msg.Sender).UniqueID);
}
else if (msg.Sender is EventTabModel)
{
Model = TabsModelList.FirstOrDefault((m) => m is EventTabModel &&
((EventTabModel)m).UniqueID == ((EventTabModel)msg.Sender).UniqueID);
}
else if (msg.Sender is ScriptModel)
{
Model = TabsModelList.FirstOrDefault((m) => m is ScriptModel &&
((ScriptModel)m).UniqueID == ((ScriptModel)msg.Sender).UniqueID);
}
TabsModelList.Remove(Model);
RaisePropertyChanged("TabsModelList");
}
if (msg.Target == this)
{
//Resend to the tutorial View model if this was the target
Messenger.Default.Send(new NotificationMessage(msg.Sender,
new ViewModelLocator().Tutorial, msg.Notification));
}
}
public void get_message_without_subsitutions()
{
var message = new NotificationMessage(NotificationMessageKeys.NO_SUBSTITUTION);
message.GetMessage().ShouldEqual(NotificationMessageKeys.NO_SUBSTITUTION.ToString());
}
private void SendNotification(NotificationMessage notification, string socketId)
{
var message = JsonConvert.SerializeObject(notification, JsonSettings.Setttings);
_sender.Send(socketId, message);
}
private void NotificationMessageReceived(NotificationMessage msg)
{
if (msg.Notification == "ShowGcodeEditor")
{
try
{
var type = msg.Sender.GetType();
IList items = (System.Collections.IList)msg.Sender;
var collection = items.Cast <GCode>();
ObservableCollection <GCode> gcodes = new ObservableCollection <GCode>(collection);
GcodeViewerWindow viewer = new GcodeViewerWindow(gcodes);
viewer.Owner = Application.Current.MainWindow;
viewer.Show();
}
catch (Exception exc)
{
}
}
else if (msg.Notification == "ResetCameraGcode")
{
try
{
// Helix.Wpf
//view2dGcode.Camera.Reset();
//view2dGcode.Camera.ZoomExtents(view2dGcode.Viewport, 1);
}
catch (Exception exc)
{
}
}
else if (msg.Notification == "ResetCameraGcode3d")
{
try
{
view3dGcode.Camera.Reset();
view3dGcode.Camera.ZoomExtents(view3dGcode, 1);
// Helix.Wpf
//view3dGcode.Camera.Reset();
//view3dGcode.Camera.ZoomExtents(view3dGcode.Viewport, 1);
}
catch (Exception exc)
{
}
}
else if (msg.Notification == "ResetCameraStl")
{
try
{
view3d.Camera.Reset();
view3d.Camera.ZoomExtents(view3d, 1);
// Helix.Wpf
//view3d.Camera.Reset();
//view3d.Camera.ZoomExtents(view3d.Viewport);
}
catch (Exception exc)
{
}
}
else if (msg.Notification == "ZoomToFitGcode")
{
try
{
view2dGcode.Camera.ZoomExtents(view2dGcode, 1);
// Helix.Wpf
//var type = msg.Sender.GetType();
//view2dGcode.Camera.ZoomExtents(view2dGcode.Viewport, 1);
}
catch (Exception exc)
{
}
}
else if (msg.Notification == "ZoomToFitStl")
{
try
{
var type = msg.Sender.GetType();
view3d.Camera.ZoomExtents(view3d, 1);
// Helix.Wpf
//.Camera.ZoomExtents(view3d.Viewport);
}
catch (Exception exc)
{
}
}
}
/// <summary>
/// This will load up the Email template and generate the HTML
/// </summary>
/// <param name="model"></param>
/// <param name="settings"></param>
/// <returns></returns>
public async Task SendAdHoc(NotificationMessage model, EmailNotificationSettings settings)
{
try
{
var email = new EmailBasicTemplate();
var customization = await CustomizationSettings.GetSettingsAsync();
var html = email.LoadTemplate(model.Subject, model.Message, null, customization.Logo);
var textBody = string.Empty;
model.Other.TryGetValue("PlainTextBody", out textBody);
var body = new BodyBuilder
{
HtmlBody = html,
TextBody = textBody
};
var message = new MimeMessage
{
Body = body.ToMessageBody(),
Subject = model.Subject
};
message.From.Add(new MailboxAddress(string.IsNullOrEmpty(settings.SenderName) ? settings.SenderAddress : settings.SenderName, settings.SenderAddress));
message.To.Add(new MailboxAddress(model.To, model.To));
using (var client = new SmtpClient())
{
if (settings.DisableCertificateChecking)
{
// Disable validation of the certificate associated with the SMTP service
// Helpful when the TLS certificate is not in the certificate store of the server
// Does carry the risk of man in the middle snooping
client.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => true;
}
if (settings.DisableTLS)
{
// Does not attempt to use either TLS or SSL
// Helpful when MailKit finds a TLS certificate, but it unable to use it
client.Connect(settings.Host, settings.Port, MailKit.Security.SecureSocketOptions.None);
}
else
{
client.Connect(settings.Host, settings.Port); // Let MailKit figure out the correct SecureSocketOptions.
}
// Note: since we don't have an OAuth2 token, disable
// the XOAUTH2 authentication mechanism.
client.AuthenticationMechanisms.Remove("XOAUTH2");
if (settings.Authentication)
{
client.Authenticate(settings.Username, settings.Password);
}
//Log.Info("sending message to {0} \r\n from: {1}\r\n Are we authenticated: {2}", message.To, message.From, client.IsAuthenticated);
await client.SendAsync(message);
await client.DisconnectAsync(true);
}
}
catch (Exception e)
{
//Log.Error(e);
throw new InvalidOperationException(e.Message);
}
}
protected override async Task Send(NotificationMessage model, EmailNotificationSettings settings)
{
await EmailProvider.Send(model, settings);
}
public void NotifyMe(NotificationMessage notificationMessage)
{
string notification = notificationMessage.Notification;
//do your work
}
internal unsafe ConnectEventArgs(AMDeviceNotificationCallbackInfo cbi)
{
this.message = cbi.msg;
this.device = cbi.dev;
}
private void CleanUpView(NotificationMessage message)
{
Messenger.Default.Unregister <NotificationMessage>(this);
}
private void NotifyUserMethod(NotificationMessage message)
{
//MessageBox.Show(message.Notification);
}
public ItemData(
Subscription subscription,
NotificationMessage notificationMessage)
{
Subscription = subscription;
NotificationMessage = notificationMessage;
}
protected override void OnNotificationMessage(NotificationMessage message)
{
}
private bool updateEntityFromUI()
{
try
{
grupa.Naziv = txtNaziv.Text.Trim();
grupa.EngNaziv = txtEngNaziv.Text.Trim();
if (!grupa.validate())
{
return(false);
}
GrupaDAO grupaDAO = DAOFactoryFactory.DAOFactory.GetGrupaDAO();
if (editMode)
{
if (grupa.Naziv != oldNaziv || grupa.EngNaziv != oldEngNaziv)
{
grupaDAO.MakePersistent(grupa);
NHibernateHelper.GetCurrentSession().Transaction.Commit();
oldNaziv = grupa.Naziv;
oldEngNaziv = grupa.EngNaziv;
}
}
else
{
grupaDAO.MakePersistent(grupa);
NHibernateHelper.GetCurrentSession().Transaction.Commit();
grupe.Add(grupa);
editMode = true;
oldNaziv = grupa.Naziv;
oldEngNaziv = grupa.EngNaziv;
}
return(true);
}
catch (InvalidPropertyException ex)
{
MessageDialogs.showMessage(ex.Message, this.Text);
setFocus(ex.InvalidProperty);
return(false);
}
catch (BusinessException ex)
{
if (ex.Notification != null)
{
NotificationMessage msg = ex.Notification.FirstMessage;
MessageDialogs.showMessage(msg.Message, this.Text);
setFocus(msg.FieldName);
}
else
{
MessageDialogs.showMessage(ex.Message, this.Text);
}
return(false);
}
catch (InfrastructureException ex)
{
MessageDialogs.showMessage(ex.Message, this.Text);
return(false);
}
catch (Exception ex)
{
MessageDialogs.showMessage(
Strings.getFullDatabaseAccessExceptionMessage(ex.Message), this.Text);
return(false);
}
}
private void NotifyMe(NotificationMessage message)
{
switch (message.Notification)
{
case nameof(UpdatePlacementView_ViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <UpdatePlacementView_ViewModel>();
break;
case nameof(UpdateCompanyDetailsView_ViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <UpdateCompanyDetailsView_ViewModel>();
break;
case nameof(CompanyDetailsView_ViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <CompanyDetailsView_ViewModel>();
break;
case nameof(AddSession_ViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <AddSession_ViewModel>();
break;
case nameof(IndividualCandidateDetailsView_ViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <IndividualCandidateDetailsView_ViewModel>();
break;
case nameof(SessionsView_ViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <SessionsView_ViewModel>();
break;
case nameof(OpeningsView_ViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <OpeningsView_ViewModel>();
break;
case nameof(CandidateView_ViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <CandidateView_ViewModel>();
break;
case nameof(CourseView_ViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <CourseView_ViewModel>();
break;
case nameof(CompaniesView_ViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <CompaniesView_ViewModel>();
break;
case nameof(PlacementsView_ViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <PlacementsView_ViewModel>();
break;
case nameof(AddCandidateViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <AddCandidateViewModel>();
break;
case nameof(AddCompanyViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <AddCompanyViewModel>();
break;
case nameof(AddCourseViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <AddCourseViewModel>();
break;
case nameof(AddOpeningViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <AddOpeningViewModel>();
break;
case nameof(CandidateQualifiedForOpeningViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <CandidateQualifiedForOpeningViewModel>();
break;
case nameof(SessionAttendanceView_ViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <SessionAttendanceView_ViewModel>();
break;
case nameof(UpdateCandidateview_ViewModel):
CurrentVM = CommonServiceLocator.ServiceLocator.Current.GetInstance <UpdateCandidateview_ViewModel>();
break;
}
}
public void Execute(NotificationMessage notificationMessage)
{
_taskbar.Flash();
}
public string PutNotificationMessage(NotificationMessageDisplay message)
{
try
{
var provider = _notificationContext.GetProviderByMethodKey(message.MethodKey);
var method = provider.GetNotificationGatewayMethodByKey(message.MethodKey);
var notificationMessage = new NotificationMessage(message.MethodKey, message.Name, message.FromAddress)
{
BodyTextIsFilePath
=
message
.BodyTextIsFilePath
};
method.SaveNotificationMessage(message.ToNotificationMessage(notificationMessage));
return notificationMessage.Key.ToString();
}
catch (Exception ex)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.InternalServerError, string.Format("{0}", ex.Message)));
}
}
protected override Task Send(NotificationMessage model, MobileNotificationSettings settings)
{
throw new NotImplementedException();
}
/// <summary>
/// Returns all available notifications.
/// </summary>
private NotificationMessage InnerPublish(
OperationContext context,
out UInt32Collection availableSequenceNumbers,
out bool moreNotifications)
{
// check session.
VerifySession(context);
// TraceState("PUBLISH");
// check if a keep alive should be sent if there is no data.
bool keepAliveIfNoData = (m_keepAliveCounter >= m_maxKeepAliveCount);
availableSequenceNumbers = new UInt32Collection();
moreNotifications = false;
if (m_lastSentMessage < m_sentMessages.Count)
{
// return the available sequence numbers.
for (int ii = 0; ii <= m_lastSentMessage && ii < m_sentMessages.Count; ii++)
{
availableSequenceNumbers.Add(m_sentMessages[ii].SequenceNumber);
}
moreNotifications = m_waitingForPublish = m_lastSentMessage < m_sentMessages.Count-1;
// TraceState("PUBLISH QUEUED MESSAGE");
return m_sentMessages[m_lastSentMessage++];
}
List<NotificationMessage> messages = new List<NotificationMessage>();
if (m_publishingEnabled)
{
DateTime start1 = DateTime.UtcNow;
// collect notifications to publish.
Queue<EventFieldList> events = new Queue<EventFieldList>();
Queue<MonitoredItemNotification> datachanges = new Queue<MonitoredItemNotification>();
Queue<DiagnosticInfo> datachangeDiagnostics = new Queue<DiagnosticInfo>();
// check for monitored items that are ready to publish.
LinkedListNode<IMonitoredItem> current = m_itemsToPublish.First;
while (current != null)
{
LinkedListNode<IMonitoredItem> next = current.Next;
IMonitoredItem monitoredItem = current.Value;
if ((monitoredItem.MonitoredItemType & MonitoredItemTypeMask.DataChange) != 0)
{
((IDataChangeMonitoredItem)monitoredItem).Publish(context, datachanges, datachangeDiagnostics);
}
else
{
((IEventMonitoredItem)monitoredItem).Publish(context, events);
}
// add back to list to check.
m_itemsToPublish.Remove(current);
m_itemsToCheck.AddLast(current);
// check there are enough notifications for a message.
if (m_maxNotificationsPerPublish > 0 && events.Count + datachanges.Count > m_maxNotificationsPerPublish)
{
// construct message.
int notificationCount;
int eventCount = events.Count;
int dataChangeCount = datachanges.Count;
NotificationMessage message = ConstructMessage(
events,
datachanges,
datachangeDiagnostics,
out notificationCount);
// add to list of messages to send.
messages.Add(message);
lock (m_diagnostics)
{
m_diagnostics.DataChangeNotificationsCount += (uint)(dataChangeCount - datachanges.Count);
m_diagnostics.EventNotificationsCount += (uint)(eventCount - events.Count);
m_diagnostics.NotificationsCount += (uint)notificationCount;
}
}
current = next;
}
// pubish the remaining notifications.
while (events.Count + datachanges.Count > 0)
{
// construct message.
int notificationCount;
int eventCount = events.Count;
int dataChangeCount = datachanges.Count;
NotificationMessage message = ConstructMessage(
events,
datachanges,
datachangeDiagnostics,
out notificationCount);
// add to list of messages to send.
messages.Add(message);
lock (m_diagnostics)
{
m_diagnostics.DataChangeNotificationsCount += (uint)(dataChangeCount - datachanges.Count);
m_diagnostics.EventNotificationsCount += (uint)(eventCount - events.Count);
m_diagnostics.NotificationsCount += (uint)notificationCount;
}
}
// check for missing notifications.
if (!keepAliveIfNoData && messages.Count == 0)
{
Utils.Trace(
(int)Utils.TraceMasks.Error,
"Oops! MonitoredItems queued but no notifications availabled.");
m_waitingForPublish = false;
return null;
}
DateTime end1 = DateTime.UtcNow;
double delta1 = ((double)(end1.Ticks-start1.Ticks))/TimeSpan.TicksPerMillisecond;
if (delta1 > 200)
{
TraceState(Utils.Format("PUBLISHING DELAY ({0}ms)", delta1));
}
}
if (messages.Count == 0)
{
// create a keep alive message.
NotificationMessage message = new NotificationMessage();
// use the sequence number for the next message.
message.SequenceNumber = (uint)m_sequenceNumber;
message.PublishTime = DateTime.UtcNow;
// return the available sequence numbers.
for (int ii = 0; ii <= m_lastSentMessage && ii < m_sentMessages.Count; ii++)
{
availableSequenceNumbers.Add(m_sentMessages[ii].SequenceNumber);
}
// TraceState("PUBLISH KEEPALIVE");
return message;
}
// have to drop unsent messages if out of queue space.
if (messages.Count > m_maxMessageCount)
{
Utils.Trace(
"WARNING: QUEUE OVERFLOW. Dropping {2} Messages. Increase MaxMessageQueueSize. SubId={0}, MaxMessageQueueSize={1}",
m_id,
m_maxMessageCount,
messages.Count - (int)m_maxMessageCount);
messages.RemoveRange(0, messages.Count - (int)m_maxMessageCount);
}
// remove old messages if queue is full.
if (m_sentMessages.Count > m_maxMessageCount - messages.Count)
{
lock (m_diagnostics)
{
m_diagnostics.UnacknowledgedMessageCount += (uint)messages.Count;
}
if (m_maxMessageCount <= messages.Count)
{
m_sentMessages.Clear();
}
else
{
m_sentMessages.RemoveRange(0, messages.Count);
}
}
// save new message
m_lastSentMessage = m_sentMessages.Count;
m_sentMessages.AddRange(messages);
// check if there are more notifications to send.
moreNotifications = m_waitingForPublish = messages.Count > 1;
// return the available sequence numbers.
for (int ii = 0; ii <= m_lastSentMessage && ii < m_sentMessages.Count; ii++)
{
availableSequenceNumbers.Add(m_sentMessages[ii].SequenceNumber);
}
// TraceState("PUBLISH NEW MESSAGE");
return m_sentMessages[m_lastSentMessage++];
}
public async Task <dynamic> SendAsync(NotificationMessage message, CancellationToken cancellationToken = default)
{
Check.NotNull(message, nameof(message));
Check.NotNull(message.Body, nameof(message.Body));
Check.NotNull(message.To, nameof(message.To));
Check.NotNull(message.From, nameof(message.From));
Check.NotNull(message.From.Name, nameof(message.From.Name));
Check.NotNull(message.From.Address, nameof(message.From.Address));
Check.NotNull(message.Subject, nameof(message.Subject));
//Invalid configuration set name<Não Responda>: only alphanumeric ASCII characters, '_', and '-' are allowed.
var mailRequest = new SendEmailRequest()
{
Destination = new Destination(),
Source = $"{message.From.Name} <{message.From.Address}>",
Message = new Message()
};
mailRequest.Message.Subject = new Content()
{
Charset = message.Subject.Charset.GetValueOrDefault(DefaultCharset),
Data = message.Subject.Content
};
mailRequest.Message.Body = new Body();
if (message.Body.IsHtml)
{
mailRequest.Message.Body.Html = new Content()
{
Charset = message.Body.Charset.GetValueOrDefault(DefaultCharset),
Data = message.Body.Content
};
}
else
{
mailRequest.Message.Body.Text = new Content()
{
Charset = message.Body.Charset.GetValueOrDefault(DefaultCharset),
Data = message.Body.Content
};
}
mailRequest.Destination.ToAddresses = message.To.Select(a => $"{a.Name} <{a.Address}>").ToList();
if (message.BccTo != null)
{
mailRequest.Destination.BccAddresses = message.BccTo.Select(a => $"{a.Name} <{a.Address}>").ToList();
}
if (message.CcTo != null)
{
mailRequest.Destination.CcAddresses = message.CcTo.Select(a => $"{a.Name} <{a.Address}>").ToList();
}
if (message.ReplyToAddresses != null)
{
mailRequest.ReplyToAddresses = message.ReplyToAddresses.Select(a => $"{a.Name} <{a.Address}>").ToList();
}
var policy = CreateDefaultRetryAsyncPolicy();
var response = await policy.ExecuteAsync(async() => await SimpleEmailClient.SendEmailAsync(mailRequest, cancellationToken));
return(response);
}
protected void SendNotificationMessage(string message)
{
var messageObj = new NotificationMessage(this, message);
Messenger.Default.Send(messageObj);
}
/// <summary>
/// This method is invoked from NotificationBridge for each new incoming UDP
/// Since there will be a new instance for each incoming request
/// thread-safety is not necessary.
/// </summary>
/// <param name="state"></param>
public override void DataReceived(Object state)
{
NotificationDispatcher NotificationDispatcher = NotificationBridge.Dispatcher;
NameValueCollection header = new NameValueCollection();
SerializationReader reader = new SerializationReader((Byte[])state);
String line = "";
do
{
try
{
line = (String)reader.ReadObject();
if (line == Environment.NewLine)
break;
Int32 ColonPos = line.IndexOf(':');
//String[] split = line.Split(new char[] { ':' });
//if (split.Length != 2)
if (ColonPos < 0)
throw new NotificationException_InvalidMulticastHeader("Invalid Header entry: " + line);
//header.Add(split[0].ToLower(), split[1].Trim());
header.Add(line.Substring(0, ColonPos).ToLower(), line.Substring(ColonPos + 1).Trim());
// Is sender the same Dispatcher? Than the message is already handled!
if (header["dispatcher"] != null && header["dispatcher"].Contains(NotificationDispatcher.Uuid))
return;
}
catch (NotificationException_InvalidMulticastHeader imh)
{
throw imh;
}
catch (Exception e)
{
throw new NotificationException_InvalidMulticastHeader("Header must ends with newline!", e);
}
} while (line != Environment.NewLine);
if (header["notificationtype"] == null)
throw new NotificationException_InvalidMulticastHeader("Header must contain a NotificationType!");
if (header["dispatcher"] == null)
throw new NotificationException_InvalidMulticastHeader("Header must contain the Dispatcher who sent this message!");
if (header["senderid"] == null)
throw new NotificationException_InvalidMulticastHeader("Header must contain the SenderID!");
// The Dispatcher should only recieve notifications from the restricted VFS (if RestrictedSenderID was defined)
if (NotificationDispatcher.RestrictedSenderID != String.Empty && NotificationDispatcher.RestrictedSenderID != header["senderid"])
return;
ANotificationType notificationType = NotificationBridge.Dispatcher.GetEmptyNotificationTypeFromFullBaseName(header["notificationtype"]);
NotificationMessage message = new NotificationMessage((Byte[])reader.ReadObject(), notificationType.GetEmptyArgumentInstance());
message.SenderInfo = new SenderInfo();
message.SenderInfo.Host = header["host"];
message.SenderInfo.DispatcherGuid = header["dispatcher"];
message.SenderInfo.SenderID = header["senderid"];
NotificationDispatcher.SendNotification(message, false);
}
/// <summary>
/// Invokes the Republish service.
/// </summary>
/// <param name="requestHeader">The request header.</param>
/// <param name="subscriptionId">The subscription id.</param>
/// <param name="retransmitSequenceNumber">The sequence number of a specific NotificationMessage to be republished.</param>
/// <param name="notificationMessage">The requested NotificationMessage.</param>
/// <returns>
/// Returns a <see cref="ResponseHeader"/> object
/// </returns>
public override ResponseHeader Republish(
RequestHeader requestHeader,
uint subscriptionId,
uint retransmitSequenceNumber,
out NotificationMessage notificationMessage)
{
OperationContext context = ValidateRequest(requestHeader, RequestType.Republish);
try
{
notificationMessage = ServerInternal.SubscriptionManager.Republish(
context,
subscriptionId,
retransmitSequenceNumber);
return CreateResponse(requestHeader, context.StringTable);
}
catch (ServiceResultException e)
{
lock (ServerInternal.DiagnosticsLock)
{
ServerInternal.ServerDiagnostics.RejectedRequestsCount++;
if (IsSecurityError(e.StatusCode))
{
ServerInternal.ServerDiagnostics.SecurityRejectedRequestsCount++;
}
}
throw TranslateException(context, e);
}
finally
{
OnRequestComplete(context);
}
}
/// <summary>
/// Creates a new instance.
/// </summary>
internal NotificationEventArgs(
Subscription subscription,
NotificationMessage notificationMessage,
IList<string> stringTable)
{
m_subscription = subscription;
m_notificationMessage = notificationMessage;
m_stringTable = stringTable;
}
internal unsafe ConnectEventArgs(AMDeviceNotificationCallbackInfo cbi)
{
this.message = cbi.msg;
this.device = cbi.dev;
}
/// <summary>
/// Updates the controls displaying the status of the subscription.
/// </summary>
private void UpdateStatus()
{
NotificationMessage message = null;
if (m_subscription != null)
{
message = m_subscription.LastNotification;
}
PublishingEnabledTB.Text = String.Empty;
if (m_subscription != null)
{
PublishingEnabledTB.Text = (m_subscription.CurrentPublishingEnabled)?"Enabled":"Disabled";
}
LastUpdateTimeTB.Text = String.Empty;
if (message != null)
{
LastUpdateTimeTB.Text = String.Format("{0:HH:mm:ss}", message.PublishTime.ToLocalTime());
}
LastMessageIdTB.Text = String.Empty;
if (message != null)
{
LastMessageIdTB.Text = String.Format("{0}", message.SequenceNumber);
}
// determine what window to show.
bool hasEvents = false;
bool hasDatachanges = false;
foreach (MonitoredItem monitoredItem in m_subscription.MonitoredItems)
{
if (monitoredItem.Filter is EventFilter)
{
hasEvents = true;
}
if (monitoredItem.NodeClass == NodeClass.Variable)
{
hasDatachanges = true;
}
}
// enable appropriate windows.
WindowEventsMI.Enabled = hasEvents;
WindowDataChangesMI.Enabled = hasDatachanges;
// show the datachange window if there are no event items.
if (hasDatachanges && !hasEvents)
{
WindowMI_Click(WindowDataChangesMI, null);
}
// show events window if there are no datachange items.
if (hasEvents && !hasDatachanges)
{
WindowMI_Click(WindowEventsMI, null);
}
}
private void NavigateToTab(NotificationMessage <short> notification)
{
CurrentPage = Children[notification.Content];
}
/// <summary>
/// Invokes the Publish service.
/// </summary>
/// <param name="requestHeader">The request header.</param>
/// <param name="subscriptionAcknowledgements">The list of acknowledgements for one or more Subscriptions.</param>
/// <param name="subscriptionId">The subscription identifier.</param>
/// <param name="availableSequenceNumbers">The available sequence numbers.</param>
/// <param name="moreNotifications">If set to <c>true</c> the number of Notifications that were ready to be sent could not be sent in a single response.</param>
/// <param name="notificationMessage">The NotificationMessage that contains the list of Notifications.</param>
/// <param name="results">The list of results for the acknowledgements.</param>
/// <param name="diagnosticInfos">The diagnostic information for the results.</param>
/// <returns>
/// Returns a <see cref="ResponseHeader"/> object
/// </returns>
public override ResponseHeader Publish(
RequestHeader requestHeader,
SubscriptionAcknowledgementCollection subscriptionAcknowledgements,
out uint subscriptionId,
out UInt32Collection availableSequenceNumbers,
out bool moreNotifications,
out NotificationMessage notificationMessage,
out StatusCodeCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
OperationContext context = ValidateRequest(requestHeader, RequestType.Publish);
try
{
/*
// check if there is an odd delay.
if (DateTime.UtcNow > requestHeader.Timestamp.AddMilliseconds(100))
{
Utils.Trace(
"WARNING. Unexpected delay receiving Publish request. Time={0:hh:mm:ss.fff}, ReceiveTime={1:hh:mm:ss.fff}",
DateTime.UtcNow,
requestHeader.Timestamp);
}
*/
Utils.Trace("PUBLISH #{0} RECIEVED. TIME={1:hh:hh:ss.fff}", requestHeader.RequestHandle, requestHeader.Timestamp);
notificationMessage = ServerInternal.SubscriptionManager.Publish(
context,
subscriptionAcknowledgements,
null,
out subscriptionId,
out availableSequenceNumbers,
out moreNotifications,
out results,
out diagnosticInfos);
/*
if (notificationMessage != null)
{
Utils.Trace(
"PublishResponse: SubId={0} SeqNo={1}, PublishTime={2:mm:ss.fff}, Time={3:mm:ss.fff}",
subscriptionId,
notificationMessage.SequenceNumber,
notificationMessage.PublishTime,
DateTime.UtcNow);
}
*/
return CreateResponse(requestHeader, context.StringTable);
}
catch (ServiceResultException e)
{
lock (ServerInternal.DiagnosticsLock)
{
ServerInternal.ServerDiagnostics.RejectedRequestsCount++;
if (IsSecurityError(e.StatusCode))
{
ServerInternal.ServerDiagnostics.SecurityRejectedRequestsCount++;
}
}
throw TranslateException(context, e);
}
finally
{
OnRequestComplete(context);
}
}
/// <summary>
/// Queue the notification.
/// Don't just send it directly.
/// </summary>
/// <param name="message"></param>
protected void Notify(NotificationMessage message)
{
_queue.Enqueue(message);
}
unsafe internal ConnectEventArgs(AMDeviceNotificationCallbackInfo cbi) {
message = cbi.msg;
device = cbi.dev;
}
public void should_return_the_message_icon_for_a_message_message()
{
sut = new NotificationMessage(_objectBase, MessageOrigin.Formula, _buildingBlock, NotificationType.Info);
imageShouldBe(ApplicationIcons.Info);
}
public virtual bool HasMessage(string fieldName, string message)
{
var expected = new NotificationMessage(fieldName, message);
return messages.Exists(actual => actual.Equals(expected));
}
private void HandleNotificationMessage(NotificationMessage <NotificationType> message)
{
MessageBox.Show(message.Notification, Title, MessageBoxButton.OK, NotificationTypeToImage(message.Content));
}
public async Task <IActionResult> Post([FromBody] NotificationMessage content)
{
await _customerService.Notify(content?.Message);
return(CreateResponseOnPost());
}
async Task ShowNotification(NotificationMessage message)
{
NotificationService.Notify(message);
await InvokeAsync(() => { StateHasChanged(); });
}
/// <summary>
/// Publishes a timeout status message.
/// </summary>
public NotificationMessage PublishTimeout()
{
NotificationMessage message = null;
lock (m_lock)
{
m_expired = true;
message = new NotificationMessage();
message.SequenceNumber = (uint)m_sequenceNumber;
message.PublishTime = DateTime.UtcNow;
Utils.IncrementIdentifier(ref m_sequenceNumber);
lock (m_diagnostics)
{
m_diagnostics.NextSequenceNumber = (uint)m_sequenceNumber;
}
StatusChangeNotification notification = new StatusChangeNotification();
notification.Status = StatusCodes.BadTimeout;
message.NotificationData.Add(new ExtensionObject(notification));
}
return message;
}
private void RenameCheckedElementsNotification(NotificationMessage <Mp3Tag> notificationMessage)
{
this.IterateCheckedMp3SongsAndDoAction(mp3SongViewModel => mp3SongViewModel.Rename(notificationMessage.Content));
}
/// <summary>
/// Construct a message from the queues.
/// </summary>
private NotificationMessage ConstructMessage(
Queue<EventFieldList> events,
Queue<MonitoredItemNotification> datachanges,
Queue<DiagnosticInfo> datachangeDiagnostics,
out int notificationCount)
{
notificationCount = 0;
NotificationMessage message = new NotificationMessage();
message.SequenceNumber = (uint)m_sequenceNumber;
message.PublishTime = DateTime.UtcNow;
Utils.IncrementIdentifier(ref m_sequenceNumber);
lock (m_diagnostics)
{
m_diagnostics.NextSequenceNumber = (uint)m_sequenceNumber;
}
// add events.
if (events.Count > 0 && notificationCount < m_maxNotificationsPerPublish)
{
EventNotificationList notification = new EventNotificationList();
while (events.Count > 0 && notificationCount < m_maxNotificationsPerPublish)
{
notification.Events.Add(events.Dequeue());
notificationCount++;
}
message.NotificationData.Add(new ExtensionObject(notification));
}
// add datachanges (space permitting).
if (datachanges.Count > 0 && notificationCount < m_maxNotificationsPerPublish)
{
bool diagnosticsExist = false;
DataChangeNotification notification = new DataChangeNotification();
notification.MonitoredItems = new MonitoredItemNotificationCollection(datachanges.Count);
notification.DiagnosticInfos = new DiagnosticInfoCollection(datachanges.Count);
while (datachanges.Count > 0 && notificationCount < m_maxNotificationsPerPublish)
{
MonitoredItemNotification datachange = datachanges.Dequeue();
notification.MonitoredItems.Add(datachange);
DiagnosticInfo diagnosticInfo = datachangeDiagnostics.Dequeue();
if (diagnosticInfo != null)
{
diagnosticsExist = true;
}
notification.DiagnosticInfos.Add(diagnosticInfo);
notificationCount++;
}
// clear diagnostics if not used.
if (!diagnosticsExist)
{
notification.DiagnosticInfos.Clear();
}
message.NotificationData.Add(new ExtensionObject(notification));
}
return message;
}
/// <summary>
/// Checks if the subscription is ready to publish and returns a notification message.
/// </summary>
public NotificationMessage Publish()
{
lock (m_lock)
{
long currentTime = DateTime.UtcNow.Ticks / TimeSpan.TicksPerMillisecond;
// check of it is time for a publish.
if (m_lastPublishTime + m_publishingInterval < currentTime)
{
ListOfMonitoredItemNotification notifications = new ListOfMonitoredItemNotification();
ListOfDiagnosticInfo diagnosticInfos = new ListOfDiagnosticInfo();
// check each monitored item for data changes to send.
foreach (MonitoredItem monitoredItem in m_monitoredItems.Values)
{
while (monitoredItem.Values.Count > 0)
{
MonitoredItemNotification notification = new MonitoredItemNotification();
notification.ClientHandle = monitoredItem.Parameters.ClientHandle;
notification.Value = monitoredItem.Values.Dequeue();
notifications.Add(notification);
diagnosticInfos.Add(monitoredItem.DiagnosticInfos.Dequeue());
}
}
// check if any notifications were found.
if (notifications.Count > 0)
{
// subscriptions can produce different types of notifications so the notification parameter
// is an extensible parameter. This means the object must be manually serialized and wrapped in
// an ExtensionObject which specifies the type of data contained in the Body. The complete
// UA SDK takes care this housekeeping and will serialize extensible parameters automatically.
DataChangeNotification body = new DataChangeNotification();
body.MonitoredItems = notifications;
body.DiagnosticInfos = diagnosticInfos;
ExtensionObject extension = new ExtensionObject(
new ExpandedNodeId(Objects.DataChangeNotification_Encoding_DefaultXml),
body);
// construct the message and assign a new sequence number.
NotificationMessage message = new NotificationMessage();
message.SequenceNumber = ++m_nextSequenceNumber;
message.PublishTime = DateTime.UtcNow;
message.NotificationData = new ListOfExtensionObject();
message.NotificationData.Add(extension);
m_lastPublishTime = currentTime;
m_nextKeepAliveTime = (long)(currentTime + m_publishingInterval * m_keepAliveCount);
return(message);
}
}
// check if it is time for a keep alive.
if (m_nextKeepAliveTime < currentTime)
{
NotificationMessage message = new NotificationMessage();
message.SequenceNumber = m_nextSequenceNumber;
message.PublishTime = DateTime.UtcNow;
message.NotificationData = new ListOfExtensionObject();
m_nextKeepAliveTime = (long)(currentTime + m_publishingInterval * m_keepAliveCount);
return(message);
}
return(null);
}
}
