private void Update(NotificationSetting setting) { lock (CollisionLock) { DbConnection.UpdateAsync(setting); } }
public bool UpdateNotificationSetting(string id, NotificationSetting setting) { int index = FindIndexOfSettingId(id); Settings[index] = setting; return(true); }
private void Save(NotificationSetting setting) { lock (CollisionLock) { DbConnection.InsertAsync(setting); } }
public void AddUpdate(NotificationSetting setting) { int settingIndex = FindIndexOfSettingId(setting.ChannelId); Settings[settingIndex] = setting; Update(setting); }
private void ShowChatMessage(string username, string message, NotificationSetting notificationSetting) { var text = $"{username}: {message}"; if (notificationSetting.Text) { logger.Information(text); } if (notificationSetting.Speech) { if (Settings.BabelSettings.DynamicallySwitchLanguage) { SpeakBabel(username, message); } else { Speak(text); } } if (Settings.ConnectToPipeServer) { pipeMessages.Enqueue(text); } }
public void AddUpdate(StoredChannel item, NotificationSetting setting = null) { bool exists = Exists(item.ChannelId); if (!exists) { Channels.Add(item); if (setting == null) { setting = new NotificationSetting(item.ChannelId); Save(setting); } Settings.Add(setting); Save(item); } else { int index = FindIndexOfChannelId(item.ChannelId); Channels[index] = item; Update(item); if (setting != null) { int settingIndex = FindIndexOfSettingId(item.ChannelId); Settings[settingIndex] = setting; Update(setting); } } }
public JsonResult DeleteNotificationSetting(NotificationSetting notificationSetting) { var isSuccess = true; var message = string.Empty; const string url = "/NotificationSetting/Index"; permission = (RoleSubModuleItem)cacheProvider.Get(cacheKey) ?? roleSubModuleItemService.GetRoleSubModuleItemBySubModuleIdandRole(url, Helpers.UserSession.GetUserFromSession().RoleId); if (permission.DeleteOperation == true) { isSuccess = this.notificationSettingService.DeleteNotificationSetting(notificationSetting.Id); if (isSuccess) { message = "Notification setting deleted successfully!"; } else { message = "Notification setting can't be deleted!"; } } else {//TODO message = "You don't have permission to delete";; } return(Json(new { isSuccess = isSuccess, message = message }, JsonRequestBehavior.AllowGet)); }
public bool UpdateNotificationSetting(int id, bool email, bool sms) { var set = NotificationSetting.FirstOrDefault(x => x.Id == id); set.UpdateNotificationSetting(email, sms, set.NotificationOperationCode.CanEditEmail, set.NotificationOperationCode.CanEditSMS); EntityUpdated(); return(true); }
public void UpdateNotificationSetting(NotificationSetting notificationSetting) { Require.NotNull(notificationSetting, nameof(notificationSetting)); var session = _sessionProvider.GetCurrentSession(); session.Update(notificationSetting); }
void Handle_ItemTapped(object sender, Xamarin.Forms.ItemTappedEventArgs e) { StoredChannel item = (StoredChannel)e.Item; NotificationSetting settings = App.ChannelsDatastore.GetSetting(item.ChannelId); NotificationSettings notificationSettingsView = new NotificationSettings(settings); Navigation.PushModalAsync(notificationSettingsView); }
public ActionResult DeleteConfirmed(int id) { NotificationSetting notificationSetting = db.NotificationSettings.Find(id); db.NotificationSettings.Remove(notificationSetting); db.SaveChanges(); return(RedirectToAction("Index")); }
public NotificationSettings(NotificationSetting setting) { InitializeComponent(); BackgroundColor = Color.Transparent; this.BindingContext = viewModel = new NotificationSettingsViewModel(setting); SetupClicks(); }
public void AddNotificationSetting(UserNotificationSetting setting) { if (!NotificationSetting.Exists(x => x.NotificationCodeId == setting.NotificationCodeId)) { NotificationSetting.Add(setting); } EntityUpdated(); }
/// <summary> /// Initializes a new instance of the <see cref="UserSettings"/> class. /// </summary> /// <param name="id">The id.</param> /// <param name="feeds">The feeds.</param> /// <param name="notificationSettings">The notification settings.</param> /// <param name="notificationCheckIntervalInMinutes">The notification check interval in minutes.</param> /// <param name="articlesPerPage">The number of articles per page.</param> /// <exception cref="ArgumentNullException">feeds are null</exception> public UserSettings(Guid id, [NotNull] IReadOnlyCollection <Feed> feeds, NotificationSetting notificationSettings, int notificationCheckIntervalInMinutes, int articlesPerPage) { Id = id; Feeds = feeds ?? throw new ArgumentNullException(nameof(feeds)); NotificationSettings = notificationSettings; NotificationCheckIntervalInMinutes = notificationCheckIntervalInMinutes; ArticlesPerPage = articlesPerPage; }
public bool CanSend(UserNotification notification, NotificationSetting setting, User user, App app) { if (!app.AllowSms) { return(false); } return(!notification.Silent && !string.IsNullOrWhiteSpace(user.PhoneNumber)); }
public ActionResult Edit([Bind(Include = "SettingId,RemainderOnClaimOffer,OffersMyLocation,NewsUpdatesOffer,CashbackOffers,CashbackReferrals,CashbackEarnedByReferrer,AccountId")] NotificationSetting notificationSetting) { if (ModelState.IsValid) { db.Entry(notificationSetting).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } return(View(notificationSetting)); }
public Task SendAsync(UserNotification notification, NotificationSetting setting, User user, App app, bool isUpdate, CancellationToken ct = default) { var job = new MobilePushJob(notification, user); return(userNotificationQueue.ScheduleDelayedAsync( job.ScheduleKey, job, setting.DelayInSecondsOrZero, false, ct)); }
public IServiceResults<int> Edit(NotificationSetting model) { _notification.Attach(model); _uow.Entry(model).State = EntityState.Modified; var resultSave = _uow.SaveChanges(); return new ServiceResults<int> { IsSuccessfull = resultSave.ToBool(), Message = resultSave.ToMessage(BusinessMessage.Error), Result = model.NotificationSettingId }; }
public JsonResult CreateNotification(NotificationVM model) { try { if (!ModelState.IsValid) { return(Json(null)); } else { var NotificationExist = UnitOfWork.NotificationSettingBL.CheckExist(b => b.ReservationStatusId == model.ReservationStatusId && b.ActionStep == model.ActionStep); if (NotificationExist) { return(Json(new { success = false, Message = "Notification setting already exists" })); } var Notification = new NotificationSetting { ReservationStatusId = model.ReservationStatusId, ActionStep = model.ActionStep, }; if (model.IsDisable == null) { Notification.IsDisabled = true; } else { Notification.IsDisabled = model.IsDisable; } Notification.LnkNotificationJobTitle = model.JobTitleId.Where(r => r.HasValue).Select(r => new LnkNotificationJobTitle { JobTitleId = r.GetValueOrDefault() }).ToList(); UnitOfWork.NotificationSettingBL.Add(Notification); if (UnitOfWork.Complete() > 0) { return(Json(new { success = true, Message = "Notification setting added successfully" })); } else { return(Json(new { success = false, Message = "Failed to add notification setting" })); } } } catch (Exception) { return(Json(new { success = false, Message = "An error occured , please try again later" })); } }
public List <UserNotificationSetting> AddNotificationSettings(List <UserNotificationSetting> setting) { foreach (var item in setting) { if (!NotificationSetting.Exists(x => x.NotificationCodeId == item.NotificationCodeId)) { NotificationSetting.Add(item); } } EntityUpdated(); return(setting); }
public async Task SendAsync(UserNotification notification, NotificationSetting setting, User user, App app, bool isUpdate, CancellationToken ct = default) { try { await streamClient.SendAsync(notification); } catch (Exception ex) { log.LogError(ex, w => w .WriteProperty("action", "SendWeb") .WriteProperty("status", "Failed")); } }
public ActionResult SaveUserSettings([FromQuery] Guid settingsId, [FromQuery] int notificationCheckInterval, [FromQuery] NotificationSetting notificationSetting, [FromQuery] int articlesPerPage) { try { GetControllerInstance <IClipperUserAPI>().SaveUserSettings(settingsId, notificationCheckInterval, notificationSetting, articlesPerPage); return(Ok()); } catch (Exception error) { Console.WriteLine(error); return(BadRequest()); } }
public Task SendAsync(UserNotification notification, NotificationSetting setting, User user, App app, bool isUpdate, CancellationToken ct) { if (!isUpdate) { return(Task.CompletedTask); } var job = new WebhookJob(notification, app); return(userNotificationQueue.ScheduleDelayedAsync( job.ScheduleKey, job, 0, false, ct)); }
public bool Delete(string id) { StoredChannel channel = Get(id); Channels.Remove(channel); NotificationSetting setting = Settings.First(c => channel.ChannelId == id); Settings.Remove(setting); DeleteChannel(channel.ChannelId); DeleteSetting(channel.ChannelId); return(true); }
/// <summary> /// Converts a given <see cref="NotificationSetting"/> to the corresponding database value. /// </summary> /// <param name="toConvert">The <see cref="NotificationSetting"/> to convert.</param> /// <returns>The corresponding database value</returns> public static long ToDatabaseNotification(this NotificationSetting toConvert) { switch (toConvert) { case NotificationSetting.PdfPerMail: return(2); case NotificationSetting.LinkPerMail: return(1); default: return(0); } }
// GET: NotificationSettings/Delete/5 public ActionResult Delete(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } NotificationSetting notificationSetting = db.NotificationSettings.Find(id); if (notificationSetting == null) { return(HttpNotFound()); } return(View(notificationSetting)); }
private void ShowMessage(string text, NotificationSetting notificationSetting) { if (notificationSetting.Text) { logger.Information(text); } if (notificationSetting.Speech) { Speak(text); } if (Settings.ConnectToPipeServer) { pipeMessages.Enqueue(text); } }
private async Task SendNotification(Notification notification, NotificationSetting notificationSetting) { try { // send notification if (notificationSetting.ReceiveNotification && notification.ReceiverId.HasValue) { await _hubContext.Clients.User(notification.ReceiverId.Value.ToString()).SendNotification(notification); } } catch (Exception e) { await _loggingService.LogError(e, $"Could not send notification to receiver: {notification.ReceiverId}"); } }
public Task SendAsync(UserNotification notification, NotificationSetting setting, User user, App app, bool isUpdate, CancellationToken ct) { if (isUpdate) { return(Task.CompletedTask); } var job = new EmailJob(notification); return(userNotificationQueue.ScheduleDelayedAsync( job.ScheduleKey, job, setting.DelayInSecondsOrZero, false, ct)); }
private async Task <(UserNotification, HashSet <ICommunicationChannel>)> CreateUserNotificationAsync(UserEventMessage userEvent, User user, App app) { var notification = userNotificationFactory.Create(app, user, userEvent); if (notification == null) { throw new DomainException(Texts.Notification_NoSubject); } var targets = new HashSet <ICommunicationChannel>(); foreach (var channel in channels) { if (channel.IsSystem) { var preference = new NotificationSetting { Send = true }; if (channel.CanSend(notification, preference, user, app)) { notification.Settings[channel.Name] = preference; targets.Add(channel); } } else { if (notification.Settings.TryGetValue(channel.Name, out var preference) && preference.ShouldSend) { if (channel.CanSend(notification, preference, user, app)) { notification.Sending[channel.Name] = new ChannelSendInfo { LastUpdate = clock.GetCurrentInstant() }; targets.Add(channel); await userNotificationsStore.CollectAsync(notification, channel.Name, ProcessStatus.Attempt); } } } } return(notification, targets); }
private async Task SendMail(Notification notification, CancellationToken cancellationToken, NotificationSetting notificationSetting) { try { // send mail if (notificationSetting.ReceiveMail) { await _mediator.Send(new NotificationEmailRequest(notification), cancellationToken); } } catch (Exception e) { await _loggingService.LogError(e, $"Could not send mail to receiver: {notification.ReceiverId}"); } }
public virtual JsonResult Edit(NotificationSetting model) { return Json(_notificationSettingService.Edit(model)); }
/// <summary> /// Aktualisiert die Benachrichtigungseinstellungen für die angegebene Gruppe. /// </summary> /// <param name="groupId">Die Id der Gruppe, für die die Benachrichtigungseinstellungen geändert werden sollen.</param> /// <param name="newSetting">Die neu gewählte Einstellung.</param> /// <exception cref="ClientException">Wirft ClientException, wenn Änderung fehlschlägt.</exception> public void ChangeNotificationSettingsForGroup(int groupId, NotificationSetting newSetting) { // Frage Daten ab. Group group = GetGroup(groupId); if (group != null) { // Setze neue Einstellungen. group.GroupNotificationSetting = newSetting; // Speichere neue Einstellungen. UpdateGroup(group, true); } }
/// <summary> /// Aktualisiert die Benachrichtigungseinstellungen für die Anwendung. /// Diese Einstellungen bezüglich der Ankündigung von Nachrichten gelten grundsätzlich /// für die gesamte Anwendung. Es können jedoch für einzelne Kanäle und Gruppen spezifische /// Einstellungen vorgenommen werden, welche dann diese Einstellungen für die jeweilige Ressource überschreiben. /// </summary> /// <param name="newSetting">Die neu gewählte Option bezüglich Nachrichtenankündigung.</param> public void UpdateNotificationSettings(NotificationSetting newSetting) { // Hole die aktuellen Anwendungseinstellungen. AppSettings appSettings = GetApplicationSettings(); // Führe Aktualisierung aus. appSettings.MsgNotificationSetting = newSetting; try { Debug.WriteLine("Update notification settings. Set to new value {0}.", newSetting.ToString()); applicationSettingsDatabaseManager.UpdateApplicationSettings(appSettings); } catch(DatabaseException ex) { Debug.WriteLine("An error occurred during the notification settings update. The error message is {0}.", ex.Message); throw new ClientException(ErrorCodes.LocalDatabaseException, ex.Message); } // Lege neues AppSettings Objekt in den Cache. AppSettingsCache.GetInstance().CacheApplicationSettings(appSettings); }
/// <summary> /// Aktualisiert für den Kanal mit der übergebenen Id die Benachrichtigungseinstellungen. /// </summary> /// <param name="channelId">Die Id des Kanals, der aktualisiert werden soll.</param> /// <param name="newNotificationSetting">Die neue Benachrichtigungseinstellung für diesen Kanal.</param> /// <exception cref="ClientException">Wirft ClientException, wenn die Aktualisierung fehlschlägt.</exception> public void UpdateNotificationSettingsForChannel(int channelId, NotificationSetting newNotificationSetting) { try { Channel channel = channelDatabaseManager.GetChannel(channelId); if (channel == null) { Debug.WriteLine("No valid channel object could be retrieved from the given id."); return; } // Führe Aktualisierung aus. channel.AnnouncementNotificationSetting = newNotificationSetting; channelDatabaseManager.UpdateChannel(channel); } catch (DatabaseException ex) { Debug.WriteLine("DatabaseException with message {0} occurred.", ex.Message); // Abbilden auf ClientException. throw new ClientException(ErrorCodes.LocalDatabaseException, "Local database failure."); } }