public static void Subscribe(User subscriber, Node target, NotificationFrequency frequency, string language, string sitePath, string siteUrl, bool isActive)
{
if (subscriber.Email == null)
throw new InvalidOperationException("Subscriber's email cannot be null.");
if (subscriber.Email.Length == 0)
throw new InvalidOperationException("Subscriber's email cannot be empty.");
var userName = subscriber.FullName;
if (String.IsNullOrEmpty(userName))
userName = subscriber.Username;
var subscription = new Subscription
{
UserEmail = subscriber.Email,
UserId = subscriber.Id,
UserPath = subscriber.Path,
UserName = userName,
ContentPath = target.Path,
Frequency = frequency,
Language = language,
IsActive = true,
SitePath = sitePath,
SiteUrl = siteUrl,
};
subscription.Save();
}
private static void Cleanup(NotificationFrequency freq, DateTime now)
{
switch (freq)
{
case NotificationFrequency.Immediately:
if (Configuration.DailyEnabled || Configuration.WeeklyEnabled || Configuration.MonthlyEnabled)
{
return;
}
break;
case NotificationFrequency.Daily:
if (Configuration.WeeklyEnabled || Configuration.MonthlyEnabled)
{
return;
}
break;
case NotificationFrequency.Weekly:
if (Configuration.MonthlyEnabled)
{
return;
}
break;
case NotificationFrequency.Monthly:
break;
default:
throw GetUnknownFrequencyException(freq);
}
Event.DeleteOldEvents(now);
}
internal static IEnumerable <Subscription> GetActiveSubscriptionsByFrequency(NotificationFrequency frequency)
{
using (var context = new DataHandler())
{
return(context.Subscriptions.Where(x => x.FrequencyId == (int)frequency && x.Active != 0).ToArray());
}
}
private static IEnumerable <Subscription> CollectEventsPerSubscription(NotificationFrequency freq, DateTime now)
{
var lastTime = now;
var subscriptions = Subscription.GetActiveSubscriptionsByFrequency(freq);
if (subscriptions.Count() == 0)
{
return(null);
}
var time = LastProcessTime.GetLastProcessTime(freq);
using (var context = new DataHandler())
{
var events = (time == DateTime.MinValue) ?
context.Events.Where(x => x.When <= lastTime) :
context.Events.Where(x => x.When > time && x.When <= lastTime);
foreach (var @event in events.OrderBy(x => x.When))
{
foreach (var subscription in subscriptions.Where(subscription => IsRelatedPath(@event.ContentPath, subscription.ContentPath) && HasPermission(subscription, @event)))
{
subscription.AddRelatedEvent(@event);
}
}
}
LastProcessTime.SetLastProcessTime(freq, lastTime);
return(subscriptions);
}
public List <User> GetEmailSubscribers(NotificationFrequency frequency)
{
using (var db = new CAMS_DatabaseEntities())
{
return(db.Users.Where(e => e.NotificationFrequency == frequency).ToList());
}
}
private static LastProcessTime GetDefaultInstance(NotificationFrequency freq, DateTime value)
{
var instance = new LastProcessTime();
SetValue(instance, freq, value);
return(instance);
}
public Notification(string title, string body, DateTime untilDate, NotificationFrequency frequencyToSend)
{
Title = title;
Body = body;
UntilDate = untilDate;
FrequencyToSend = frequencyToSend;
}
public static void Subscribe(User subscriber, Node target, NotificationFrequency frequency, string language, string sitePath, string siteUrl, bool isActive)
{
if (subscriber.Email == null)
{
throw new InvalidOperationException("Subscriber's email cannot be null.");
}
if (subscriber.Email.Length == 0)
{
throw new InvalidOperationException("Subscriber's email cannot be empty.");
}
var userName = subscriber.FullName;
if (String.IsNullOrEmpty(userName))
{
userName = subscriber.Username;
}
var subscription = new Subscription
{
UserEmail = subscriber.Email,
UserId = subscriber.Id,
UserPath = subscriber.Path,
UserName = userName,
ContentPath = target.Path,
Frequency = frequency,
Language = language,
IsActive = true,
SitePath = sitePath,
SiteUrl = siteUrl,
};
subscription.Save();
}
public Notification(string title, string body, DateTime untilDate, NotificationFrequency frequencyToSend, int reminderID)
{
Title = title;
Body = body;
UntilDate = untilDate;
FrequencyToSend = frequencyToSend;
ReminderID = reminderID;
}
public Notification(Reminder reminder, NotificationFrequency notificationFrequency = NotificationFrequency.DAILY)
{
Title = reminder.Title;
Body = reminder.Body;
UntilDate = reminder.ETA;
FrequencyToSend = notificationFrequency;
ReminderID = reminder.ID;
}
internal static DateTime GetLastProcessTime(NotificationFrequency freq)
{
using (var context = new DataHandler())
{
var existingEntry = context.LastProcessTimes.FirstOrDefault();
return((existingEntry == null) ? DateTime.MinValue : GetValue(existingEntry, freq));
}
}
private static string GetNotificationFrequencyText(NotificationFrequency frequency)
{
string result;
switch (frequency)
{
case NotificationFrequency.Minute:
result = "1 minute";
break;
case NotificationFrequency.FiveMinutes:
result = "5 minutes";
break;
case NotificationFrequency.TenMinutes:
result = "10 minutes";
break;
case NotificationFrequency.FifteenMinutes:
result = "15 minutes";
break;
case NotificationFrequency.ThirtyMinutes:
result = "30 minutes";
break;
case NotificationFrequency.OneHour:
result = "1 hour";
break;
case NotificationFrequency.TwoHours:
result = "2 hours";
break;
case NotificationFrequency.ThreeHours:
result = "3 hours";
break;
case NotificationFrequency.SixHours:
result = "6 hours";
break;
case NotificationFrequency.TwelveHours:
result = "12 hours";
break;
case NotificationFrequency.OneDay:
result = "1 day";
break;
default:
result = "Never";
break;
}
return(result);
}
//===========================================================================================================
public static void GenerateMessages(NotificationFrequency freq, DateTime now)
{
var subscriptions = CollectEventsPerSubscription(freq, now);
if (subscriptions != null)
{
GenerateMessages(subscriptions);
}
Cleanup(freq, now);
}
internal static DateTime GetNextTime(NotificationFrequency freq, DateTime now)
{
switch (freq)
{
case NotificationFrequency.Immediately: return now;
case NotificationFrequency.Daily: return GetNextDailyTimeWithoutOrigin(now);
case NotificationFrequency.Weekly: return GetNextWeeklyTimeWithoutOrigin(now);
case NotificationFrequency.Monthly: return GetNextMonthlyTimeWithoutOrigin(now);
default: throw NotificationHandler.GetUnknownFrequencyException(freq);
}
}
public ActionResult SetNofications(string frequency)
{
NotificationFrequency freq = NotificationFrequency.Never;
if (Enum.TryParse(frequency, out freq))
{
this.CurrentUser.NotificationFrequency = freq;
this.serviceUser.SaveChanges(this.CurrentUser);
}
return(RedirectToAction("Manage"));
}
private void OnNotificationFrequencyChanged()
{
if (_ignoreChanges)
{
return;
}
_taskService.RemoveService();
_taskService.CreateService(NotificationFrequency.GetMinutes());
_settingsService.NotificationFrequency = NotificationFrequency.GetMinutes();
}
public void StoreSettings(string phoneId, SettingsDTO settingsRequest)
{
Language language = languageRepository.GetLanguageByName(settingsRequest.LanguageCode);
if (language == null)
{
throw new HttpStatusCodeException(
HttpStatusCode.NotFound,
$"Language [{settingsRequest.LanguageCode}] doesn't exist");
}
NotificationFrequency notificationFrequency =
notificationFrequencyRepository.GetNotificationFrequencyByFrequency(settingsRequest.NotificationFrequency);
if (notificationFrequency == null)
{
throw new HttpStatusCodeException(
HttpStatusCode.NotFound,
$"Notification frequency [{settingsRequest.NotificationFrequency}] doesn't exist");
}
Entities.Models.Settings settings = settingsRepository.GetSettingsByPhoneId(phoneId);
if (settings != null)
{
settings.Language = language;
settings.DoesNotify = settingsRequest.DoesNotify;
settings.NotificationFrequency = notificationFrequency;
}
else
{
Entities.Models.Settings newSettings = new Entities.Models.Settings
{
Language = language,
DoesNotify = true,
NotificationFrequency = notificationFrequency
};
settingsRepository.Add(newSettings);
accountRepository.Add(new Account
{
PhoneIdentifier = phoneId,
Settings = newSettings,
PasswordHash = "",
Email = phoneId,
FirstName = "",
City = ""
});
}
theaterScheduleUnitOfWork.Save();
}
internal static DateTime GetNextTime(NotificationFrequency freq, DateTime now)
{
switch (freq)
{
case NotificationFrequency.Immediately: return(now);
case NotificationFrequency.Daily: return(GetNextDailyTimeWithoutOrigin(now));
case NotificationFrequency.Weekly: return(GetNextWeeklyTimeWithoutOrigin(now));
case NotificationFrequency.Monthly: return(GetNextMonthlyTimeWithoutOrigin(now));
default: throw NotificationHandler.GetUnknownFrequencyException(freq);
}
}
private static string GetFooterTemplate(MessageTemplate template, NotificationFrequency frequency)
{
switch (frequency)
{
case NotificationFrequency.Immediately: return(template.ImmediatelyFooter);
case NotificationFrequency.Daily: return(template.DailyFooter);
case NotificationFrequency.Weekly: return(template.WeeklyFooter);
case NotificationFrequency.Monthly: return(template.MonthlyFooter);
default: throw GetUnknownFrequencyException(frequency);
}
}
private static DateTime GetValue(LastProcessTime instance, NotificationFrequency freq)
{
DateTime?value = null;
switch (freq)
{
case NotificationFrequency.Immediately: value = instance.Immediately; break;
case NotificationFrequency.Daily: value = instance.Daily; break;
case NotificationFrequency.Weekly: value = instance.Weekly; break;
case NotificationFrequency.Monthly: value = instance.Monthly; break;
}
return(value.HasValue ? value.Value : DateTime.MinValue);
}
private static void SetValue(LastProcessTime instance, NotificationFrequency freq, DateTime value)
{
DateTime?dbValue = null;
if (value >= ContentRepository.Storage.Data.DataProvider.Current.DateTimeMinValue)
{
dbValue = value;
}
switch (freq)
{
case NotificationFrequency.Immediately: instance.Immediately = dbValue; break;
case NotificationFrequency.Daily: instance.Daily = dbValue; _nextDaily = null; break;
case NotificationFrequency.Weekly: instance.Weekly = dbValue; _nextWeekly = null; break;
case NotificationFrequency.Monthly: instance.Monthly = dbValue; _nextMonthly = null; break;
}
}
//===========================================================================================================
public static void GenerateMessages(NotificationFrequency freq, DateTime now)
{
if (Configuration.GroupNotificationsByUser)
{
var groupedSubscriptions = CollectEventsPerSubscriptionByUser(freq, now);
if (groupedSubscriptions != null)
{
GenerateMessages(groupedSubscriptions);
}
}
else
{
var subscriptions = CollectEventsPerSubscription(freq, now);
if (subscriptions != null)
{
GenerateMessages(subscriptions);
}
}
Cleanup(freq, now);
}
private void FindUsersAndNotifications(NotificationFrequency frequency)
{
NotificationsController controller = new NotificationsController();
foreach (var user in controller.GetEmailSubscribers(frequency))
{
NotificationViewModel notificationModel = new NotificationViewModel(user, controller);
List <Notification> notifications = notificationModel.Notifications;
if (notifications.Count > 0)
{
string msg = "<table>";
msg += "<tr> <td> מחלקה </td> <td> בניין </td> <td> כיתה </td> <td> עמדה </td> <td> פירוט התראה </td><th></th></tr> ";
foreach (var notification in notificationModel.Notifications)
{
msg += "<tr> <td>" + notification.DepartmentName + "</td> ";
msg += "<td>" + notification.Building + "</td> ";
msg += "<td>" + notification.RoomNumber + "</td> ";
msg += "<td>" + notification.ComputerName + "</td> ";
switch (notification.NotificationType)
{
case Constant.NotificationType.Disconnected:
msg += "<td> לא מחובר " + notification.Days + " ימים </td> ";
break;
case Constant.NotificationType.NotUsed:
msg += "<td> לא בשימוש " + notification.Days + " ימים </td> ";
break;
}
msg += "</tr>";
}
msg += "</table>";
SendEmail(msg, user);
}
}
}
internal static void SetLastProcessTime(NotificationFrequency freq, DateTime lastTime)
{
using (var context = new DataHandler())
{
var existingEntry = context.LastProcessTimes.FirstOrDefault();
if (existingEntry == null)
{
context.LastProcessTimes.InsertOnSubmit(GetDefaultInstance(freq, lastTime));
}
else
{
SetValue(existingEntry, freq, lastTime);
}
context.SubmitChanges();
}
switch (freq)
{
case NotificationFrequency.Daily: _nextDaily = null; break;
case NotificationFrequency.Weekly: _nextWeekly = null; break;
case NotificationFrequency.Monthly: _nextMonthly = null; break;
}
}
internal static void TimerTick(DateTime now, NotificationFrequency freq)
{
switch (freq)
{
case NotificationFrequency.Immediately: if (!Configuration.ImmediatelyEnabled)
{
return;
}
break;
case NotificationFrequency.Daily: if (!Configuration.DailyEnabled)
{
return;
}
break;
case NotificationFrequency.Weekly: if (!Configuration.WeeklyEnabled)
{
return;
}
break;
case NotificationFrequency.Monthly: if (!Configuration.MonthlyEnabled)
{
return;
}
break;
default: throw GetUnknownFrequencyException(freq);
}
if (now >= LastProcessTime.GetNextTime(freq, now))
{
GenerateMessages(freq, now);
}
}
internal static DateTime GetLastProcessTime(NotificationFrequency freq)
{
using (var context = new DataHandler())
{
var existingEntry = context.LastProcessTimes.FirstOrDefault();
return (existingEntry == null) ? DateTime.MinValue : GetValue(existingEntry, freq);
}
}
private static LastProcessTime GetDefaultInstance(NotificationFrequency freq, DateTime value)
{
var instance = new LastProcessTime();
SetValue(instance, freq, value);
return instance;
}
internal static Exception GetUnknownFrequencyException(NotificationFrequency freq)
{
return(new NotImplementedException("Unknown NotificationFrequency: " + freq));
}
private static void SetValue(LastProcessTime instance, NotificationFrequency freq, DateTime value)
{
DateTime? dbValue = null;
if (value >= SenseNet.ContentRepository.Storage.Data.DataProvider.Current.DateTimeMinValue)
dbValue = value;
switch (freq)
{
case NotificationFrequency.Immediately: instance.Immediately = dbValue; break;
case NotificationFrequency.Daily: instance.Daily = dbValue; _nextDaily = null; break;
case NotificationFrequency.Weekly: instance.Weekly = dbValue; _nextWeekly = null; break;
case NotificationFrequency.Monthly: instance.Monthly = dbValue; _nextMonthly = null; break;
}
}
private static void Cleanup(NotificationFrequency freq, DateTime now)
{
switch (freq)
{
case NotificationFrequency.Immediately:
if (Configuration.DailyEnabled || Configuration.WeeklyEnabled || Configuration.MonthlyEnabled)
return;
break;
case NotificationFrequency.Daily:
if (Configuration.WeeklyEnabled || Configuration.MonthlyEnabled)
return;
break;
case NotificationFrequency.Weekly:
if (Configuration.MonthlyEnabled)
return;
break;
case NotificationFrequency.Monthly:
break;
default:
throw GetUnknownFrequencyException(freq);
}
Event.DeleteOldEvents(now);
}
private static IEnumerable<Subscription> CollectEventsPerSubscription(NotificationFrequency freq, DateTime now)
{
var lastTime = now;
var subscriptions = Subscription.GetActiveSubscriptionsByFrequency(freq);
if (subscriptions.Count() == 0)
return null;
//var time = GetTimeLimit(freq);
var time = LastProcessTime.GetLastProcessTime(freq);
using (var context = new DataHandler())
{
var events = (time == DateTime.MinValue)?
context.Events.Where(x => x.When <= lastTime) :
context.Events.Where(x => x.When > time && x.When <= lastTime);
foreach (var @event in events.OrderBy(x => x.When))
foreach (var subscription in subscriptions)
if (IsRelatedPath(@event.ContentPath, subscription.ContentPath))
if (HasPermission(subscription, @event))
subscription.AddRelatedEvent(@event);
}
LastProcessTime.SetLastProcessTime(freq, lastTime);
return subscriptions;
}
//========================================================= Static part
public static void Subscribe(User subscriber, Node target, NotificationFrequency frequency, string language, string sitePath, string siteUrl)
{
Subscribe(subscriber, target, frequency, language, sitePath, siteUrl, true);
}
public static IEnumerable<Subscription> CollectEventsPerSubscription(NotificationFrequency freq, DateTime now)
{
var m = type.GetMethod("CollectEventsPerSubscription", BindingFlags.Static | BindingFlags.NonPublic);
var result = m.Invoke(null, new object[] { freq, now });
return (IEnumerable<Subscription>)result;
}
internal static Exception GetUnknownFrequencyException(NotificationFrequency freq)
{
return(new SnNotSupportedException("Unknown NotificationFrequency: " + freq));
}
internal static void TimerTick(DateTime now, NotificationFrequency freq)
{
switch (freq)
{
case NotificationFrequency.Immediately: if (!Configuration.ImmediatelyEnabled) return; break;
case NotificationFrequency.Daily: if (!Configuration.DailyEnabled) return; break;
case NotificationFrequency.Weekly: if (!Configuration.WeeklyEnabled) return; break;
case NotificationFrequency.Monthly: if (!Configuration.MonthlyEnabled) return; break;
default: throw GetUnknownFrequencyException(freq);
}
if (now >= LastProcessTime.GetNextTime(freq, now))
GenerateMessages(freq, now);
}
//===========================================================================================================
public static void GenerateMessages(NotificationFrequency freq, DateTime now)
{
var subscriptions = CollectEventsPerSubscription(freq, now);
if (subscriptions != null)
GenerateMessages(subscriptions);
Cleanup(freq, now);
}
internal static void SetLastProcessTime(NotificationFrequency freq, DateTime lastTime)
{
using (var context = new DataHandler())
{
var existingEntry = context.LastProcessTimes.FirstOrDefault();
if (existingEntry == null)
context.LastProcessTimes.InsertOnSubmit(GetDefaultInstance(freq, lastTime));
else
SetValue(existingEntry, freq, lastTime);
context.SubmitChanges();
}
switch (freq)
{
case NotificationFrequency.Daily: _nextDaily = null; break;
case NotificationFrequency.Weekly: _nextWeekly = null; break;
case NotificationFrequency.Monthly: _nextMonthly = null; break;
}
}
private static DateTime GetValue(LastProcessTime instance, NotificationFrequency freq)
{
DateTime? value = null;
switch (freq)
{
case NotificationFrequency.Immediately: value = instance.Immediately; break;
case NotificationFrequency.Daily: value = instance.Daily; break;
case NotificationFrequency.Weekly: value = instance.Weekly; break;
case NotificationFrequency.Monthly: value = instance.Monthly; break;
}
return value.HasValue ? value.Value : DateTime.MinValue;
}
private static Dictionary <int, List <Subscription> > CollectEventsPerSubscriptionByUser(NotificationFrequency freq, DateTime now)
{
var subscriptions = CollectEventsPerSubscription(freq, now);
if (subscriptions != null)
{
return((from sub in subscriptions
where sub != null
group sub by sub.UserId
into subs
select subs).ToDictionary(subs => subs.Key, subs => subs.ToList()));
}
return(null);
}
//========================================================= Static part
public static void Subscribe(User subscriber, Node target, NotificationFrequency frequency, string language, string sitePath, string siteUrl)
{
Subscribe(subscriber, target, frequency, language, sitePath, siteUrl, true);
}
internal static IEnumerable<Subscription> GetActiveSubscriptionsByFrequency(NotificationFrequency frequency)
{
using (var context = new DataHandler())
{
return context.Subscriptions.Where(x => x.FrequencyId == (int)frequency && x.Active != 0).ToArray();
}
}
internal static Exception GetUnknownFrequencyException(NotificationFrequency freq)
{
return new NotImplementedException("Unknown NotificationFrequency: " + freq);
}
