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.");
}
}
