public NotificationEventArgs(string title, string content, NotificationTypes notificationType, Action callback) { Title = title; Content = content; NotificationType = notificationType; Callback = callback; }
public async Task <bool> ScheduleNotificationAsync(DateTime dateTime, NotificationTypes notificationType, string entity, string entityId) { try { Logger.Debug("Attempting to schedule native notification"); if ((await NativeNotificationService.ScheduleNotificationAsync( dateTime, notificationType, entity, entityId)) == false) { throw new Exception("Native exception could not be scheduled"); } Logger.Debug("Native notification service claims to have completed successfully."); SalesAppNotification notification = new SalesAppNotification { NotificationStatus = NotificationStatus.Scheduled, Entity = entity, EntityId = entityId, NotificationType = notificationType, NotificiationTime = dateTime }; return((await SaveAsync(notification)).SavedModel.Id != default(Guid)); } catch (Exception ex) { Logger.Error(ex); throw; } }
/// <summary> /// Main Application Logic /// </summary> /// <param name="args"></param> static void Main(string[] args) { // Do some really complex work here.. // when you get done.. let the user know via a notification.. // Ex: NotificationTypes notification = GetNotificationType(); switch (notification) { case NotificationTypes.Sms: SendSms(); break; case NotificationTypes.Email: SendEmail(); break; case NotificationTypes.Console: SendConsole(); break; } Console.ReadLine(); }
/// <summary> /// The GetNotificationTemplate method /// </summary> /// <param name="eventTypeId">The eventTypeId parameter</param> /// <param name="notifyType">The notifyType parameter</param> /// <returns>The AuthNet.PoC.EventModel.Entities.NotificationTemplate type object</returns> public NotificationTemplate GetNotificationTemplate(int eventTypeId, NotificationTypes notifyType) { NotificationTemplate notification = new NotificationTemplate(); string notificationstring = notifyType.ToString(); string name = string.Empty; string sqlquery = "SELECT * from EventType where EventTypeId = " + eventTypeId; using (IDataReader reader = ExecuteInlineQueryReader(sqlquery)) { while (reader.Read()) { name = reader[1].ToString(); break; } } sqlquery = "SELECT * from NotificationTemplate where EventType = '" + name + "' AND NotificationType = '" + notificationstring + "'"; using (IDataReader reader = ExecuteInlineQueryReader(sqlquery)) { while (reader.Read()) { notification.ID = int.Parse(reader[0].ToString()); notification.EventTypeID = eventTypeId; notification.NotificationType = notifyType; notification.GroupName = reader[3].ToString(); notification.TemplateName = reader[4].ToString(); break; } } return notification; }
internal void RaiseToastNotification(string title, string content, NotificationTypes notificationType, Action callback) { if (ToastNotification != null) { ToastNotification(this, new NotificationEventArgs(title, content, notificationType, callback)); } }
public static NotificationResult Send(NotificationTypes channel, IEnumerable <string> to, string message, string title) { try { // select operation switch (channel) { case NotificationTypes.CALL: return(SendCall(to, message)); case NotificationTypes.SMS: return(SendSms(to, message)); case NotificationTypes.EMAIL: return(SendEmail(to, message, title)); default: return(new NotificationResult(false, "Operação não suportada: " + channel)); } } catch (Exception e) { return(new NotificationResult(false, "NotificationResult.Send [" + channel + "] " + e.Message)); } }
public Notification(string subject, string message, string details, NotificationTypes notificationType) { this.Subject = subject; this.Message = message; this.Details = details; this.NotificationType = notificationType; }
public Notification(string t, NotificationTypes notificationtype, string remarks, string id) { Title = t; NotificationType = notificationtype; Remarks = remarks; UserId = id; }
/// <summary> /// Initializes a new instance of the notifier. /// </summary> /// <param name="notifyOptions"><see cref="NotificationTypes"/> that can be processed by the notifier.</param> public NotifierBase(NotificationTypes notifyOptions) { m_notifyOptions = notifyOptions; m_notifyTimeout = 30; m_persistSettings = true; m_settingsCategory = this.GetType().Name; }
private async Task <Result <SlimNotificationOptions> > TryGetDefaultOptions(NotificationTypes type, ApiCallerTypes userType) { var receiver = userType.ToReceiverType(); var options = await _context.DefaultNotificationOptions.SingleOrDefaultAsync(o => o.Type == type); if (options is null) { return(Result.Failure <SlimNotificationOptions>($"Cannot find notification options for the type '{type}'")); } var emailTemplateId = userType switch { ApiCallerTypes.Agent => options.AgentEmailTemplateId, ApiCallerTypes.Admin => options.AdminEmailTemplateId, ApiCallerTypes.PropertyOwner => options.PropertyOwnerEmailTemplateId, _ => throw new NotImplementedException("No email templates are defined for the specified API caller type") }; return(options.EnabledReceivers.HasFlag(receiver) ? new SlimNotificationOptions(enabledProtocols: options.EnabledProtocols, isMandatory: options.IsMandatory, enabledReceivers: options.EnabledReceivers, emailTemplateId: emailTemplateId) : Result.Failure <SlimNotificationOptions>($"Cannot find notification options for the type '{type}' and the receiver '{receiver}'")); }
public SqlDependencyEx( string connectionString, string databaseName, string tableName, string schemaName = "dbo", NotificationTypes listenerType = NotificationTypes.Insert | NotificationTypes.Update | NotificationTypes.Delete, bool receiveDetails = true, int identity = 1, List <string> fieldList = null) { this.ConnectionString = connectionString; this.DatabaseName = databaseName; this.TableName = tableName; this.SchemaName = schemaName; this.NotificaionTypes = listenerType; this.DetailsIncluded = receiveDetails; this.Identity = identity; if (fieldList != null) { this.FieldList = new List <string>(); foreach (var field in fieldList) { this.FieldList.Add(string.Format("''{0}''", field)); } } }
public async Task <Result> Send(DataWithCompanyInfo messageData, NotificationTypes notificationType) { return(await GetRecipients(notificationType) .Bind(GetNotificationOptions) .Bind(BuildSettings) .Tap(AddNotifications)); async Task <Result <Dictionary <int, string> > > GetRecipients(NotificationTypes notificationType) { var roles = await _context.AdministratorRoles.ToListAsync(); var roleIds = roles.Where(r => r.NotificationTypes?.Contains(notificationType) ?? false) .Select(r => r.Id) .ToList(); var recipients = new Dictionary <int, string>(); foreach (var roleId in roleIds) { var addedRecipients = await _context.Administrators.Where(a => a.AdministratorRoleIds.Contains(roleId)) .ToDictionaryAsync(a => a.Id, a => a.Email); recipients = recipients.Union(addedRecipients) .ToDictionary(r => r.Key, r => r.Value); } return(recipients); } async Task <Result <List <RecipientWithNotificationOptions> > > GetNotificationOptions(Dictionary <int, string> recipients) => await _notificationOptionsService.GetNotificationOptions(recipients, notificationType);
private async void OnSendNotification(NotificationTypes notificationType) { switch (notificationType) { case NotificationTypes.Email: await _pebble.NotificationMailAsync(Sender, Subject, Body); break; case NotificationTypes.SMS: await _pebble.NotificationSmsAsync(Sender, Body); break; case NotificationTypes.Facebook: await _pebble.NotificationFacebookAsync(Sender, Body); break; case NotificationTypes.Twitter: await _pebble.NotificationTwitterAsync(Sender, Body); break; } }
public bool RaiseToastNotification(string title, string content, NotificationTypes notificationType, Action callback) { bool notificationRaised = false; // Disabling resize handles temporarily prevents mouse capture by the non-client area around the main keyboard this.mainWindowManipulationService.DisableResize(); callback += () => this.mainWindowManipulationService.SetResizeState(); if (ToastNotification != null) { ToastNotification(this, new NotificationEventArgs(title, content, notificationType, callback)); notificationRaised = true; } else { if (notificationType == NotificationTypes.Error) { pendingErrorToastNotificationContent.AppendLine(content); } //Error raised before the ToastNotification is initialised. Call callback delegate to ensure everything continues. callback(); } return(notificationRaised); }
protected void SetNotification(string message, NotificationTypes type, string title = "") { TempData["Notification"] = new AlertNotificationModel() { Message = message, Title = title, Type = type }; }
/// <summary> /// Process a notification. /// </summary> /// <param name="subject">Subject matter for the notification.</param> /// <param name="message">Brief message for the notification.</param> /// <param name="details">Detailed message for the notification.</param> /// <param name="notificationType">One of the <see cref="NotificationTypes"/> values.</param> /// <returns>true if notification is processed successfully; otherwise false.</returns> public bool Notify(string subject, string message, string details, NotificationTypes notificationType) { if (!Enabled || (m_notifyThread != null && m_notifyThread.IsAlive)) { return(false); } // Start notification thread with appropriate parameters. m_notifyThread = new Thread(NotifyInternal); if ((notificationType & NotificationTypes.Alarm) == NotificationTypes.Alarm && (m_notifyOptions & NotificationTypes.Alarm) == NotificationTypes.Alarm) { // Alarm notifications are supported. m_notifyThread.Start(new object[] { new Action <string, string, string>(NotifyAlarm), subject, message, details }); } else if ((notificationType & NotificationTypes.Warning) == NotificationTypes.Warning && (m_notifyOptions & NotificationTypes.Warning) == NotificationTypes.Warning) { // Warning notifications are supported. m_notifyThread.Start(new object[] { new Action <string, string, string>(NotifyWarning), subject, message, details }); } else if ((notificationType & NotificationTypes.Information) == NotificationTypes.Information && (m_notifyOptions & NotificationTypes.Information) == NotificationTypes.Information) { // Information notifications are supported. m_notifyThread.Start(new object[] { new Action <string, string, string>(NotifyInformation), subject, message, details }); } else if ((notificationType & NotificationTypes.Heartbeat) == NotificationTypes.Heartbeat && (m_notifyOptions & NotificationTypes.Heartbeat) == NotificationTypes.Heartbeat) { // Heartbeat notifications are supported. m_notifyThread.Start(new object[] { new Action <string, string, string>(NotifyHeartbeat), subject, message, details }); } else { // Specified notification type is not supported. return(false); } if (m_notifyTimeout < 1) { // Wait indefinetely on the refresh. m_notifyThread.Join(Timeout.Infinite); } else { // Wait for the specified time on refresh. if (!m_notifyThread.Join(m_notifyTimeout * 1000)) { m_notifyThread.Abort(); return(false); } } return(true); }
private static string GetLevel(NotificationTypes type) { return(type switch { NotificationTypes.Information => Notification.Information, NotificationTypes.Warning => Notification.Warning, NotificationTypes.Error => Notification.Error, _ => throw new ArgumentException(nameof(type)), });
/// <summary> /// Create a client registration for a certain event type. /// </summary> /// <param name="clientUri"></param> /// <param name="eventType"></param> /// <param name="userName"></param> /// <param name="prox"></param> public void RegisterClient(Uri clientUri, NotificationTypes eventType, string userName, IClientNotification prox) { var reg = new Registration() { RegistrationUri = clientUri, EventType = eventType.ToString(), UserName = userName, clientProxy=prox }; var key = reg.CreateKey(); if (!Registrations.ContainsKey(key)) Registrations.Add(key, new List<Registration> { reg }); else if (Registrations[key].Find(rg => (rg.RegistrationUri.AbsolutePath == reg.RegistrationUri.AbsolutePath)) == null) Registrations[key].Add(reg); }
public Notification(string message, NotificationTypes notificationType, DateTime startDate, DateTime dueDate, string createdBy) { Message = message; NotificationType = notificationType; StartDate = startDate; if (Util.IsNotNullDate(dueDate)) DueDate = dueDate; CreatedBy = createdBy; }
/// <summary> /// Constructor with automatique Guid /// </summary> /// <param name="connectionString"></param> /// <param name="databaseName"></param> /// <param name="schemaName"></param> /// <param name="listenerType"></param> /// <param name="receiveDetails"></param> public SqlTableDependency( string connectionString, string schemaName = "dbo", NotificationTypes listenerType = NotificationTypes.Insert | NotificationTypes.Update | NotificationTypes.Delete, bool receiveDetails = true) : base(connectionString, schemaName, listenerType, receiveDetails) { }
public void ShowNotification(NotificationTypes notificationType, string message) { panNotification.CssClass = string.Format("notification {0} canhide", notificationType).ToLower(); litNotificationHeader.Text = notificationType.ToString().ToUpper() + ":"; litMessage.Text = message; panNotification.Style.Add("display", "block"); this.Visible = true; }
public Notification(string title, string time, NotificationTypes type, string description, string link, string sitelink) { this.title = title; this.time = time; this.type = type; this.description = description; this.link = link; this.sitelink = sitelink; }
private static NotificationTypes[] GetMembers(NotificationTypes value) { return (Enum.GetValues(typeof(NotificationTypes)) .Cast <int>() .Where(enumValue => enumValue != 0 && (enumValue & (int)value) == enumValue) .Cast <NotificationTypes>() .ToArray()); }
private NotificationsHelperBase GetHelper(NotificationTypes notificationType) { switch (notificationType) { case NotificationTypes.ProspectReminder: return(new ProspectsReminderNotificationsHelper(AppContext)); } throw new Exception("Notification helper for notification type '" + notificationType.ToString() + "' has not been implemented"); }
public async Task SetAllOverdueNotificationsViewed(NotificationTypes notificationTypes) { List <SalesAppNotification> overdueNotifications = await GetAllOverdueNotificationsAsync(notificationTypes); foreach (var overdueNotification in overdueNotifications) { await SetSingleNotificationViewed(overdueNotification); } }
private void SendFriendsNotification(string messageText, NotificationTypes notificationType) { var extraParams = new ExtraParams(); extraParams.AddNew(ExtraParamsList.save_to_history, "1"); extraParams.AddNew(ExtraParamsList.dialog_id, dialogId); extraParams.AddNew(ExtraParamsList.notification_type, ((int)notificationType).ToString()); quickbloxClient.ChatXmppClient.SendMessage(otherUserJid, messageText, extraParams, dialogId, null); }
private static NotificationContent GetContent(string title, string message, NotificationTypes notificationType) { var content = new NotificationContent(); content.Title = title; content.Message = message; content.Type = (NotificationType)notificationType; return(content); }
private static IList <LotView> GetLotViewsFromNotifications(LotQuery query, NotificationTypes notificationType, bool unReadOnly, string orderBy, bool desc, int pageIndex, int pageSize, out int recordCount) { IList <LotView> list = new List <LotView>(); foreach (NotificationswithLot lot in notificationWithLotGateway.GetNotificationswithLotsBy(query, notificationType, unReadOnly, orderBy, desc, pageIndex, pageSize, out recordCount)) { list.Add(GetLotViewByLotID(lot.LotID)); } return(list); }
public void Convert_ReturnsColor(NotificationTypes type, byte r, byte g, byte b) { var sut = new NotificationColorConverter(); var actual = sut.Convert(type, null, null, null) as SolidColorBrush; actual.Color.R.Should().Be(r); actual.Color.G.Should().Be(g); actual.Color.B.Should().Be(b); }
/// <summary> /// Constructor with automatique Guid /// </summary> /// <param name="connectionString"></param> /// <param name="databaseName"></param> /// <param name="schemaName"></param> /// <param name="listenerType"></param> /// <param name="receiveDetails"></param> protected ExtendedSqlDependency( string connectionString, string schemaName = "dbo", NotificationTypes listenerType = NotificationTypes.Insert | NotificationTypes.Update | NotificationTypes.Delete, bool receiveDetails = true) : this(connectionString, Guid.Empty, schemaName, listenerType, receiveDetails) { this.Identity = Guid.NewGuid(); }
private Task SendDetailedBookingNotification(AccommodationBookingInfo bookingInfo, string recipient, SlimAgentContext agent, NotificationTypes notificationType) { var details = bookingInfo.BookingDetails; var notificationData = CreateNotificationData(bookingInfo, details); return(_notificationService.Send(agent: agent, messageData: notificationData, notificationType: notificationType, email: recipient)); }
public SqlDependencyEx(SqlDependencyExOptions opts, NotificationTypes listenerType = NotificationTypes.Insert | NotificationTypes.Update | NotificationTypes.Delete, bool receiveDetails = true, int identity = 1) { ConnectionOptions = opts; ConnectionOptions.SchemaName = opts.SchemaName ?? "dbo"; Notifications = listenerType; DetailsIncluded = receiveDetails; Identity = identity; }
private IHandler GetHandler(NotificationTypes type) { if (type == NotificationTypes.EMAIL) { return(new EmailHandler()); } else { return(new TextHandler()); } }
/// <summary> /// Register a one-way channel information /// </summary> /// <param name="clientUri"></param> /// <param name="notificationType"></param> public void Register(string clientUri, NotificationTypes notificationType) { string userName = "******"; if ((OperationContext.Current != null) && (OperationContext.Current.ServiceSecurityContext != null) && (OperationContext.Current.ServiceSecurityContext.PrimaryIdentity != null)) { userName = OperationContext.Current.ServiceSecurityContext.PrimaryIdentity.Name; } MemoryRepository.Current.RegisterClient(new Uri(clientUri), notificationType, userName, null); }
public CascadeLevel(int orderNumber, NotificationTypes notificationTypes, Workplace responsible = null, int headLevel = 0, TimeSpan?delay = null) { Responsible = responsible; HeadLevel = headLevel; TriggeredAt = null; OrderNumber = orderNumber; NotificationTypes = notificationTypes; if (delay.HasValue) { DelayTicks = delay.Value.Ticks; } }
public static void Inform(string message, NotificationTypes notifType=NotificationTypes.Notice, bool isModal=false) { printMsg(notifType.ToString(), message); if(isModal) MessageBox.Show(message, notifType.ToString(), MessageBoxButtons.OK, MessageBoxIcon.Warning); if(notifType == NotificationTypes.FATAL) { MessageBox.Show(message + "\nL'application va maintenant s'arrêter de fonctionner.", "Erreur critique", MessageBoxButtons.OK, MessageBoxIcon.Error); Process.GetCurrentProcess().Kill(); } }
public Notification GetNotification(string notificationId, NotificationTypes notificationType) { switch (notificationType) { case NotificationTypes.FeedNotification: return NotificationsCollection.Collection.FindOneByIdAs<FeedNotification>(new ObjectId(notificationId)); case NotificationTypes.TimetableNotification: return NotificationsCollection.Collection.FindOneByIdAs<TimetableNotification>(new ObjectId(notificationId)); case NotificationTypes.MonitoredWebsitesNotification: return NotificationsCollection.Collection.FindOneByIdAs<MonitoredWebsiteNotification>(new ObjectId(notificationId)); } return null; }
/// <summary> /// Register a duplex callback channel /// </summary> /// <param name="notificationType"></param> public void RegisterCallback(NotificationTypes notificationType) { string userName = "******"; if ((OperationContext.Current != null) && (OperationContext.Current.ServiceSecurityContext != null) && (OperationContext.Current.ServiceSecurityContext.PrimaryIdentity != null)) { userName = OperationContext.Current.ServiceSecurityContext.PrimaryIdentity.Name; } // var dchf = new DuplexChannelFactory<IClientNotification>(OperationContext.Current.InstanceContext); // IClientNotification prox = dchf.CreateChannel(); IClientNotification prox = OperationContext.Current.GetCallbackChannel<IClientNotification>(); MemoryRepository.Current.RegisterClient(null , notificationType, userName, prox); }
private async void OnSendNotification( NotificationTypes notificationType ) { switch ( notificationType ) { case NotificationTypes.Email: await _pebble.NotificationMailAsync( Sender, Subject, Body ); break; case NotificationTypes.SMS: await _pebble.NotificationSmsAsync( Sender, Body ); break; case NotificationTypes.Facebook: await _pebble.NotificationFacebookAsync( Sender, Body ); break; case NotificationTypes.Twitter: await _pebble.NotificationTwitterAsync( Sender, Body ); break; } }
public SqlDependencyEx( string connectionString, string databaseName, string tableName, string schemaName = "dbo", NotificationTypes listenerType = NotificationTypes.Insert | NotificationTypes.Update | NotificationTypes.Delete, bool receiveDetails = true, int identity = 1, string identityName = "", ModalityTypes modality = ModalityTypes.Full) { ConnectionString = connectionString; DatabaseName = databaseName; TableName = tableName; SchemaName = schemaName; NotificaionTypes = listenerType; DetailsIncluded = receiveDetails; Identity = identity; IdentityName = identityName; ModalityType = modality; }
/// <summary> /// Initializes a new instance of the notifier. /// </summary> /// <param name="notifyOptions"><see cref="NotificationTypes"/> that can be processed by the notifier.</param> public NotifierBase(NotificationTypes notifyOptions) { m_notifyOptions = notifyOptions; m_notifyTimeout = 30; PersistSettings = true; }
/// <summary> /// This method returns Notification Template for specified eventID and Notification Type /// </summary> /// <param name="eventID">The eventID</param> /// <param name="notifyType">The Notification Type</param> /// <returns>The Notification Template</returns> public override NotificationTemplate GetNotificationTemplate(int eventID, NotificationTypes notifyType) { return Business.GetNotificationTemplateV2(eventID, notifyType); }
/// <summary> /// This method returns notification template for specified eventID and notification Type /// </summary> /// <param name="eventID">The eventID parameter</param> /// <param name="notifyType">The notification Type parameter</param> /// <returns>The Notification Template type object</returns> public virtual NotificationTemplate GetNotificationTemplate(int eventID, NotificationTypes notifyType) { return this.Business.GetNotificationTemplate(eventID, notifyType); }
public IDisposable ShowNotification( Guid pluginId, string title, string content, int duration, NotificationTypes notificationType, Action<object, EventArgs> imageClickAction ) { return ShowCustomBaloon( pluginId, GetDefaultContent( title, content ), duration, imageClickAction, notificationType ); }
/// <summary> /// Creates a notification by directly providing a UIElement. MAKE SURE THE UIELEMENT HAS BEEN CREATED BY THE APPLICATION'S MAIN THREAD. /// </summary> /// <param name="pluginId"></param> /// <param name="content"></param> /// <param name="duration"></param> /// <param name="notificationType"></param> /// <param name="imageClickAction"></param> /// <returns></returns> public IDisposable ShowNotification( Guid pluginId, UIElement content, int duration, NotificationTypes notificationType, Action<object, EventArgs> imageClickAction ) { return ShowCustomBaloon( pluginId, content, duration, imageClickAction, notificationType ); }
private void createSubscription(int subscriberId, int eventId, NotificationTypes nType) { EventType selectedEvent = new EventType() { ID = eventId }; NotificationEndpoint notificationEP; Subscription subscription = new Subscription() { SubscriberID = subscriberId, EventType = selectedEvent }; string emailEP; string smsEP; string webhookEP; if (nType == NotificationTypes.Email) { emailEP = txtBoxEmail.Text.Trim(); bool emailCheck = IsValidEmail(emailEP); if (!emailCheck) { MessageBox.Show("Invalid EmailID"); } else { if (string.Compare(emailEP, "") != 0) { notificationEP = new EmailNotificationSetting() { NotificationType = nType, EmailAddress = emailEP }; subscription.NotificationEndpoint = notificationEP; SubscriptionBusiness.Subscribe(subscription); } } } if (nType == NotificationTypes.SMS) { smsEP = txtBoxSMS.Text.Trim(); bool phoneCheck = isValidPhoneNumber(smsEP); if (!phoneCheck) { MessageBox.Show("Invalid Phone Number"); } else { if (string.Compare(smsEP, "") != 0) { notificationEP = new SmsNotificationSetting() { NotificationType = nType, PhoneNumber = smsEP }; subscription.NotificationEndpoint = notificationEP; SubscriptionBusiness.Subscribe(subscription); } } } if (nType == NotificationTypes.Webhook) { webhookEP = txtBoxWebhook.Text.Trim(); bool webhookCheck = Uri.IsWellFormedUriString(webhookEP, UriKind.RelativeOrAbsolute); bool webhookhttp = IsValidUrl(webhookEP); if (!webhookCheck || webhookhttp == false) { MessageBox.Show("Invalid URL"); } else { if (string.Compare(webhookEP, "") != 0) { notificationEP = new WebhookNotificationSetting() { NotificationType = nType, Url = webhookEP }; subscription.NotificationEndpoint = notificationEP; SubscriptionBusiness.Subscribe(subscription); } } } }
/// <summary> /// The GetNotificationTemplateV2 method /// </summary> /// <param name="eventTypeId">The eventTypeId parameter</param> /// <param name="notifyType">The notifyType parameter</param> /// <returns>returns true or false respectively</returns> public NotificationTemplate GetNotificationTemplateV2(int eventTypeId, NotificationTypes notifyType) { return this.notificationTemplateDAL.GetNotificationTemplate(eventTypeId, notifyType); }
/// <summary> /// The SubscriptionExistsV2 method /// </summary> /// <param name="merchantId">The merchantId parameter</param> /// <param name="eventTypeId">The eventTypeId parameter</param> /// <param name="ntype">The ntype parameter</param> /// <returns>returns true or false respectively</returns> public bool SubscriptionExistsV2(int merchantId, int eventTypeId, NotificationTypes ntype) { return this.subscriptionDAL.SubscriptionExists(merchantId, eventTypeId, ntype); }
/// <summary> /// Get a particular registration /// </summary> /// <param name="eventType"></param> /// <param name="userName"></param> /// <returns></returns> public Registration[] GetRegistrations(NotificationTypes eventType, string userName) { if (string.IsNullOrEmpty(userName)) userName = "******"; var q = from reglst in Registrations.Values from reg in reglst where ((reg.EventType == eventType.ToString()) && (reg.UserName == userName)) select reg; return q.ToArray(); }
/// <summary> /// Clear all registrations for an event type /// </summary> /// <param name="eventType"></param> public void ClearRegistrations(NotificationTypes? eventType) { if (eventType == null) Registrations = new Dictionary<string, List<Registration>>(); else if (Registrations.ContainsKey(eventType.ToString())) { Registrations[eventType.ToString()] = new List<Registration>(); } }
public Notification GetNotification(string notificationId, NotificationTypes notificationType) { return dal.GetNotification(notificationId, notificationType); }
public IDisposable ShowNotification( Guid pluginId, string title, string content, int duration, NotificationTypes notificationType ) { return ShowCustomBaloon( pluginId, GetDefaultContent( title, content ), duration, null, notificationType ); }
/// <summary> /// This method tells whether subscription exists or not /// </summary> /// <param name="merchantId">The merchantId parameter</param> /// <param name="eventId">The eventId parameter</param> /// <param name="ntype">The Notification Type parameter</param> /// <returns>The status of existence of subscription</returns> public virtual bool SubscriptionExists(int merchantId, int eventId, NotificationTypes ntype) { return this.Business.SubscriptionExists(merchantId, eventId, ntype); }
/// <summary> /// Create a client registration for a certain event type. /// </summary> /// <param name="clientUri"></param> /// <param name="eventType"></param> public void UnRegisterClient(Uri clientUri, NotificationTypes eventType) { var reg = new Registration() { RegistrationUri = clientUri, EventType = eventType.ToString() }; var key = reg.CreateKey(); if (Registrations.ContainsKey(key)) Registrations.Remove(key); }
/// <summary> /// This method tells whether Subscription Exists or not /// </summary> /// <param name="merchantId">The merchantId</param> /// <param name="eventId">The eventId</param> /// <param name="ntype">The Notification Type</param> /// <returns>The status of subscription existence</returns> public override bool SubscriptionExists(int merchantId, int eventId, NotificationTypes ntype) { return Business.SubscriptionExistsV2(merchantId, eventId, ntype); }
/// <summary> /// Get all the client registrations /// </summary> /// <param name="eventType"></param> /// <returns></returns> public Registration[] GetAllRegistrations(NotificationTypes eventType) { var q = from reglst in Registrations.Values from reg in reglst where reg.EventType == eventType.ToString() select reg; return q.ToArray(); }
/// <summary> /// Process a notification. /// </summary> /// <param name="subject">Subject matter for the notification.</param> /// <param name="message">Brief message for the notification.</param> /// <param name="details">Detailed message for the notification.</param> /// <param name="notificationType">One of the <see cref="NotificationTypes"/> values.</param> /// <returns>true if notification is processed successfully; otherwise false.</returns> public bool Notify(string subject, string message, string details, NotificationTypes notificationType) { if (!Enabled || (m_notifyThread != null && m_notifyThread.IsAlive)) return false; // Start notification thread with appropriate parameters. m_notifyThread = new Thread(NotifyInternal); if ((notificationType & NotificationTypes.Alarm) == NotificationTypes.Alarm && (m_notifyOptions & NotificationTypes.Alarm) == NotificationTypes.Alarm) // Alarm notifications are supported. m_notifyThread.Start(new object[] { new Action<string, string, string>(NotifyAlarm) , subject, message, details}); else if ((notificationType & NotificationTypes.Warning) == NotificationTypes.Warning && (m_notifyOptions & NotificationTypes.Warning) == NotificationTypes.Warning) // Warning notifications are supported. m_notifyThread.Start(new object[] { new Action<string, string, string>(NotifyWarning), subject, message, details }); else if ((notificationType & NotificationTypes.Information) == NotificationTypes.Information && (m_notifyOptions & NotificationTypes.Information) == NotificationTypes.Information) // Information notifications are supported. m_notifyThread.Start(new object[] { new Action<string, string, string>(NotifyInformation), subject, message, details }); else if ((notificationType & NotificationTypes.Heartbeat) == NotificationTypes.Heartbeat && (m_notifyOptions & NotificationTypes.Heartbeat) == NotificationTypes.Heartbeat) // Heartbeat notifications are supported. m_notifyThread.Start(new object[] { new Action<string, string, string>(NotifyHeartbeat), subject, message, details }); else // Specified notification type is not supported. return false; if (m_notifyTimeout < 1) { // Wait indefinetely on the refresh. m_notifyThread.Join(Timeout.Infinite); } else { // Wait for the specified time on refresh. if (!m_notifyThread.Join(m_notifyTimeout * 1000)) { m_notifyThread.Abort(); return false; } } return true; }
/// <summary> /// Loads saved notifier settings from the config file if the <see cref="Adapter.PersistSettings"/> property is set to true. /// </summary> /// <exception cref="ConfigurationErrorsException"><see cref="Adapter.SettingsCategory"/> has a value of null or empty string.</exception> public override void LoadSettings() { base.LoadSettings(); if (PersistSettings) { // Load settings from the specified category. ConfigurationFile config = ConfigurationFile.Current; CategorizedSettingsElementCollection settings = config.Settings[SettingsCategory]; settings.Add("Enabled", Enabled, "True if this notifier is enabled; otherwise False."); settings.Add("NotifyTimeout", m_notifyTimeout, "Number of seconds to wait for notification processing to complete."); settings.Add("NotifyOptions", m_notifyOptions, "Types of notifications (Information; Warning; Alarm; Heartbeat) to be processed by this notifier."); Enabled = settings["Enabled"].ValueAs(Enabled); NotifyTimeout = settings["NotifyTimeout"].ValueAs(m_notifyTimeout); NotifyOptions = settings["NotifyOptions"].ValueAs(m_notifyOptions); } }