public static Schedule Parse(string s, bool handleCustomNames, bool normalize)
{
if (StringComparer.OrdinalIgnoreCase.Compare(s, ScheduleMode.Never.ToString()) == 0 || StringComparer.Ordinal.Compare(s, LocalizedDescriptionAttribute.FromEnum(typeof(ScheduleMode), ScheduleMode.Never)) == 0)
{
return(Schedule.Never);
}
if (StringComparer.OrdinalIgnoreCase.Compare(s, ScheduleMode.Always.ToString()) == 0 || StringComparer.Ordinal.Compare(s, LocalizedDescriptionAttribute.FromEnum(typeof(ScheduleMode), ScheduleMode.Always)) == 0)
{
return(Schedule.Always);
}
if (handleCustomNames && Schedule.customSchedules.ContainsKey(s))
{
return(Schedule.customSchedules[s]);
}
string[] array = s.Split(new char[]
{
','
});
if (array.Length == 1)
{
return(Schedule.CreateCustomSchedule(null, new ScheduleInterval[]
{
ScheduleInterval.Parse(s)
}));
}
ScheduleInterval[] array2 = new ScheduleInterval[array.Length];
for (int i = 0; i < array2.Length; i++)
{
array2[i] = ScheduleInterval.Parse(array[i].Trim());
}
return(new Schedule(array2, normalize));
}
protected virtual ScheduleIntervalViewModel GetScheduleIntervalViewModel(ScheduleInterval openingTime, CultureInfo cultureInfo)
{
var openingTimeFormat = GetOpeningTimeFormat(cultureInfo);
return(new ScheduleIntervalViewModel
{
BeginTime = string.Format(cultureInfo, openingTimeFormat, DateTime.Today.Add(openingTime.BeginingTime)),
EndTime = string.Format(cultureInfo, openingTimeFormat, DateTime.Today.Add(openingTime.EndingTime))
});
}
public bool Contains(ScheduleInterval item)
{
foreach (ScheduleInterval scheduleInterval in this.intervals)
{
if (scheduleInterval.Contains(item.StartTime) && (scheduleInterval.Contains(item.EndTime) || scheduleInterval.EndTime == item.EndTime))
{
return(true);
}
}
return(false);
}
protected void ValidateValues(object sender, EventArgs e)
{
// Validate unsubscription template
if (ValidationHelper.GetInteger(NewForm.GetFieldValue("NewsletterUnsubscriptionTemplateID"), 0) == 0)
{
ShowError(GetString("Newsletter_Edit.NoUnsubscriptionTemplateSelected"));
NewForm.StopProcessing = true;
}
// Validate subscription template
if (ValidationHelper.GetInteger(NewForm.GetFieldValue("NewsletterSubscriptionTemplateID"), 0) == 0)
{
ShowError(GetString("Newsletter_Edit.NoSubscriptionTemplateSelected"));
NewForm.StopProcessing = true;
}
// If Template based, validate template
if (GetUpperNewsletterType() == NewsletterType.TemplateBased && ValidationHelper.GetInteger(NewForm.GetFieldValue("NewsletterTemplateID"), 0) == 0)
{
ShowError(GetString("Newsletter_Edit.NoEmailTemplateSelected"));
NewForm.StopProcessing = true;
}
// If Dynamic, validate schedule interval and Source page URL
if (GetUpperNewsletterType() == NewsletterType.Dynamic)
{
if (ValidationHelper.GetString(NewForm.GetFieldValue("NewsletterDynamicURL"), string.Empty) == string.Empty)
{
// Source page URL can not be empty
ShowError(GetString("newsletter_edit.sourcepageurlempty"));
NewForm.StopProcessing = true;
}
if (chkSchedule.Checked)
{
if (!ScheduleInterval.CheckOneDayMinimum())
{
// Problem occurred while setting schedule interval for dynamic newsletter
ShowError(GetString("Newsletter_Edit.NoDaySelected"));
NewForm.StopProcessing = true;
}
if (SchedulingHelper.DecodeInterval(ScheduleInterval.ScheduleInterval).StartTime == DateTime.MinValue)
{
ShowError(GetString("Newsletter.IncorrectDate"));
NewForm.StopProcessing = true;
}
}
}
}
public static Schedule FromByteArray(byte[] bitmaps)
{
ScheduleInterval[] intervalsFromWeekBitmap = ScheduleInterval.GetIntervalsFromWeekBitmap(bitmaps);
ScheduleMode scheduleMode = Schedule.CalculateMode(intervalsFromWeekBitmap);
if (scheduleMode == ScheduleMode.Never)
{
return(Schedule.Never);
}
if (scheduleMode == ScheduleMode.Always)
{
return(Schedule.Always);
}
return(new Schedule(intervalsFromWeekBitmap, scheduleMode));
}
public void SE_ResourceStart()
{
ScheduleInterval.InHours(DateTime.UtcNow.Hour, 35, 1, () => {
try {
var gameTime = DateTime.Today.Add(NAPI.World.GetTime());
Logging.Log($"Time: {gameTime.ToString("hh:mm tt")} / {NAPI.World.GetWeather()}");
Logging.Log($" Players: {NAPI.Pools.GetAllPlayers().Count}");
Logging.Log($" Vehicles: {NAPI.Pools.GetAllVehicles().Count}");
Logging.Log($" Objects: {NAPI.Pools.GetAllObjects().Count}");
}
catch (Exception ex) {
Logging.Log($"Exception (Serverside.Main): {ex.Message}");
}
});
}
public static void ConvertScheduleToScheduleIntervalArray(ConvertEventArgs args)
{
ReadOnlyCollection <ScheduleInterval> readOnlyCollection = (args.Value == null) ? null : ((Schedule)args.Value).Intervals;
ScheduleInterval[] array;
if (readOnlyCollection == null)
{
array = new ScheduleInterval[0];
}
else
{
array = new ScheduleInterval[readOnlyCollection.Count];
readOnlyCollection.CopyTo(array, 0);
}
args.Value = array;
}
public bool Equals(Schedule schedule)
{
if (schedule == null)
{
return(false);
}
if (this.intervals.Length == schedule.intervals.Length)
{
IEnumerator <ScheduleInterval> enumerator = ((IList <ScheduleInterval>) this.intervals).GetEnumerator();
IEnumerator <ScheduleInterval> enumerator2 = ((IList <ScheduleInterval>)schedule.intervals).GetEnumerator();
while (enumerator.MoveNext())
{
enumerator2.MoveNext();
ScheduleInterval scheduleInterval = enumerator.Current;
if (scheduleInterval.CompareTo(enumerator2.Current) != 0)
{
return(false);
}
}
return(true);
}
return(false);
}
public void Add(object obj)
{
if (this.exclusiveInput == null)
{
throw new NotSupportedException("Add");
}
if (this.exclusiveInput != string.Empty)
{
throw new ArgumentException(DataStrings.ErrorInputOfScheduleMustExclusive(this.exclusiveInput));
}
ScheduleInterval scheduleInterval;
if (!(obj is ScheduleInterval))
{
if (obj is string)
{
if (this.changed)
{
scheduleInterval = ScheduleInterval.Parse((string)obj);
goto IL_DC;
}
try
{
scheduleInterval = ScheduleInterval.Parse((string)obj);
goto IL_DC;
}
catch (FormatException)
{
Schedule schedule = Schedule.Parse((string)obj);
this.exclusiveInput = (string)obj;
this.intervals = schedule.intervals;
this.mode = schedule.mode;
this.scheduleName = schedule.scheduleName;
this.changed = true;
return;
}
}
throw new ArgumentException(DataStrings.ErrorInvalidScheduleType(obj.GetType().ToString()));
}
scheduleInterval = (ScheduleInterval)obj;
IL_DC:
this.changed = true;
if (!(scheduleInterval.Length == TimeSpan.Zero))
{
if (this.intervals.Length == 0)
{
this.intervals = new ScheduleInterval[]
{
scheduleInterval
};
this.mode = ScheduleMode.ScheduledTimes;
return;
}
List <ScheduleInterval> list = new List <ScheduleInterval>(this.intervals.Length + 1);
int num = -1;
for (int i = 0; i < this.intervals.Length; i++)
{
bool flag = this.intervals[i].Contains(scheduleInterval.EndTime);
bool flag2 = scheduleInterval.Contains(this.intervals[i].EndTime);
if (flag && flag2)
{
this.intervals = Schedule.Always.intervals;
this.mode = Schedule.Always.mode;
return;
}
if (flag || scheduleInterval.EndTime == this.intervals[i].EndTime)
{
scheduleInterval = new ScheduleInterval((this.intervals[i].Length > this.intervals[i].EndTime - scheduleInterval.StartTime) ? this.intervals[i].StartTime : scheduleInterval.StartTime, this.intervals[i].EndTime);
}
else if (flag2)
{
scheduleInterval = new ScheduleInterval((scheduleInterval.Length > scheduleInterval.EndTime - this.intervals[i].StartTime) ? scheduleInterval.StartTime : this.intervals[i].StartTime, scheduleInterval.EndTime);
}
else if (scheduleInterval.StartTime < this.intervals[i].StartTime && num == -1)
{
num = i;
list.Add(scheduleInterval);
list.Add(this.intervals[i]);
}
else
{
list.Add(this.intervals[i]);
}
}
if (num == -1)
{
list.Add(scheduleInterval);
}
else if (scheduleInterval.StartTime > scheduleInterval.EndTime)
{
list.RemoveAt(0);
list.Add(scheduleInterval);
}
this.intervals = list.ToArray();
this.mode = ScheduleMode.ScheduledTimes;
return;
}
}
static Schedule()
{
ScheduleInterval[] array = new ScheduleInterval[168];
for (int i = 0; i < 7; i++)
{
DayOfWeek startDay = (DayOfWeek)i;
DayOfWeek endDay = (DayOfWeek)i;
for (int j = 0; j < 24; j++)
{
array[i * 24 + j] = new ScheduleInterval(startDay, j, 0, endDay, j, 15);
array[i * 24 + j] = new ScheduleInterval(startDay, j, 30, endDay, j, 45);
}
}
Schedule.EveryHalfHour = Schedule.CreateCustomSchedule(LocalizedDescriptionAttribute.FromEnum(typeof(CustomScheduleName), CustomScheduleName.EveryHalfHour), array);
ScheduleInterval[] array2 = new ScheduleInterval[168];
for (int k = 0; k < 7; k++)
{
DayOfWeek startDay2 = (DayOfWeek)k;
DayOfWeek endDay2 = (DayOfWeek)k;
for (int l = 0; l < 24; l++)
{
array2[k * 24 + l] = new ScheduleInterval(startDay2, l, 0, endDay2, l, 15);
}
}
Schedule.EveryHour = Schedule.CreateCustomSchedule(LocalizedDescriptionAttribute.FromEnum(typeof(CustomScheduleName), CustomScheduleName.EveryHour), array2);
ScheduleInterval[] array3 = new ScheduleInterval[84];
for (int m = 0; m < 7; m++)
{
DayOfWeek startDay3 = (DayOfWeek)m;
DayOfWeek endDay3 = (DayOfWeek)m;
for (int n = 0; n < 12; n++)
{
array3[m * 12 + n] = new ScheduleInterval(startDay3, n * 2, 0, endDay3, n * 2, 15);
}
}
Schedule.EveryTwoHours = Schedule.CreateCustomSchedule(LocalizedDescriptionAttribute.FromEnum(typeof(CustomScheduleName), CustomScheduleName.EveryTwoHours), array3);
ScheduleInterval[] array4 = new ScheduleInterval[42];
for (int num = 0; num < 7; num++)
{
DayOfWeek startDay4 = (DayOfWeek)num;
DayOfWeek endDay4 = (DayOfWeek)num;
for (int num2 = 0; num2 < 6; num2++)
{
array4[num * 6 + num2] = new ScheduleInterval(startDay4, num2 * 4, 0, endDay4, num2 * 4, 15);
}
}
Schedule.EveryFourHours = Schedule.CreateCustomSchedule(LocalizedDescriptionAttribute.FromEnum(typeof(CustomScheduleName), CustomScheduleName.EveryFourHours), array4);
Schedule.DailyFrom8AMTo5PMAtWeekDays = Schedule.CreateCustomSchedule(LocalizedDescriptionAttribute.FromEnum(typeof(CustomScheduleName), CustomScheduleName.DailyFrom8AMTo5PMAtWeekDays), new ScheduleInterval[]
{
new ScheduleInterval(DayOfWeek.Monday, 8, 0, DayOfWeek.Monday, 17, 0),
new ScheduleInterval(DayOfWeek.Tuesday, 8, 0, DayOfWeek.Tuesday, 17, 0),
new ScheduleInterval(DayOfWeek.Wednesday, 8, 0, DayOfWeek.Wednesday, 17, 0),
new ScheduleInterval(DayOfWeek.Thursday, 8, 0, DayOfWeek.Thursday, 17, 0),
new ScheduleInterval(DayOfWeek.Friday, 8, 0, DayOfWeek.Friday, 17, 0)
});
Schedule.DailyFrom9AMTo5PMAtWeekDays = Schedule.CreateCustomSchedule(LocalizedDescriptionAttribute.FromEnum(typeof(CustomScheduleName), CustomScheduleName.DailyFrom9AMTo5PMAtWeekDays), new ScheduleInterval[]
{
new ScheduleInterval(DayOfWeek.Monday, 9, 0, DayOfWeek.Monday, 17, 0),
new ScheduleInterval(DayOfWeek.Tuesday, 9, 0, DayOfWeek.Tuesday, 17, 0),
new ScheduleInterval(DayOfWeek.Wednesday, 9, 0, DayOfWeek.Wednesday, 17, 0),
new ScheduleInterval(DayOfWeek.Thursday, 9, 0, DayOfWeek.Thursday, 17, 0),
new ScheduleInterval(DayOfWeek.Friday, 9, 0, DayOfWeek.Friday, 17, 0)
});
Schedule.DailyFrom9AMTo6PMAtWeekDays = Schedule.CreateCustomSchedule(LocalizedDescriptionAttribute.FromEnum(typeof(CustomScheduleName), CustomScheduleName.DailyFrom9AMTo6PMAtWeekDays), new ScheduleInterval[]
{
new ScheduleInterval(DayOfWeek.Monday, 9, 0, DayOfWeek.Monday, 18, 0),
new ScheduleInterval(DayOfWeek.Tuesday, 9, 0, DayOfWeek.Tuesday, 18, 0),
new ScheduleInterval(DayOfWeek.Wednesday, 9, 0, DayOfWeek.Wednesday, 18, 0),
new ScheduleInterval(DayOfWeek.Thursday, 9, 0, DayOfWeek.Thursday, 18, 0),
new ScheduleInterval(DayOfWeek.Friday, 9, 0, DayOfWeek.Friday, 18, 0)
});
Schedule.DailyFrom8AMTo12PMAnd1PMTo5PMAtWeekDays = Schedule.CreateCustomSchedule(LocalizedDescriptionAttribute.FromEnum(typeof(CustomScheduleName), CustomScheduleName.DailyFrom8AMTo12PMAnd1PMTo5PMAtWeekDays), new ScheduleInterval[]
{
new ScheduleInterval(DayOfWeek.Monday, 8, 0, DayOfWeek.Monday, 12, 0),
new ScheduleInterval(DayOfWeek.Tuesday, 8, 0, DayOfWeek.Tuesday, 12, 0),
new ScheduleInterval(DayOfWeek.Wednesday, 8, 0, DayOfWeek.Wednesday, 12, 0),
new ScheduleInterval(DayOfWeek.Thursday, 8, 0, DayOfWeek.Thursday, 12, 0),
new ScheduleInterval(DayOfWeek.Friday, 8, 0, DayOfWeek.Friday, 12, 0),
new ScheduleInterval(DayOfWeek.Monday, 13, 0, DayOfWeek.Monday, 17, 0),
new ScheduleInterval(DayOfWeek.Tuesday, 13, 0, DayOfWeek.Tuesday, 17, 0),
new ScheduleInterval(DayOfWeek.Wednesday, 13, 0, DayOfWeek.Wednesday, 17, 0),
new ScheduleInterval(DayOfWeek.Thursday, 13, 0, DayOfWeek.Thursday, 17, 0),
new ScheduleInterval(DayOfWeek.Friday, 13, 0, DayOfWeek.Friday, 17, 0)
});
Schedule.DailyFrom9AMTo12PMAnd1PMTo6PMAtWeekDays = Schedule.CreateCustomSchedule(LocalizedDescriptionAttribute.FromEnum(typeof(CustomScheduleName), CustomScheduleName.DailyFrom9AMTo12PMAnd1PMTo6PMAtWeekDays), new ScheduleInterval[]
{
new ScheduleInterval(DayOfWeek.Monday, 9, 0, DayOfWeek.Monday, 12, 0),
new ScheduleInterval(DayOfWeek.Tuesday, 9, 0, DayOfWeek.Tuesday, 12, 0),
new ScheduleInterval(DayOfWeek.Wednesday, 9, 0, DayOfWeek.Wednesday, 12, 0),
new ScheduleInterval(DayOfWeek.Thursday, 9, 0, DayOfWeek.Thursday, 12, 0),
new ScheduleInterval(DayOfWeek.Friday, 9, 0, DayOfWeek.Friday, 12, 0),
new ScheduleInterval(DayOfWeek.Monday, 13, 0, DayOfWeek.Monday, 18, 0),
new ScheduleInterval(DayOfWeek.Tuesday, 13, 0, DayOfWeek.Tuesday, 18, 0),
new ScheduleInterval(DayOfWeek.Wednesday, 13, 0, DayOfWeek.Wednesday, 18, 0),
new ScheduleInterval(DayOfWeek.Thursday, 13, 0, DayOfWeek.Thursday, 18, 0),
new ScheduleInterval(DayOfWeek.Friday, 13, 0, DayOfWeek.Friday, 18, 0)
});
}
public Operation RepeatOperation <Service>(string uniqueOpId, IUserContext principal, Expression <Action <Service> > opInvocation, ScheduleInterval interval) => Operation.Try(() =>
{
//Cache all necessary contextual data
var json = JsonConvert.SerializeObject(new SerializableUserContext
{
_currentUserRoles = principal.CurrentUserRoles().ToList(),
_currentUserLogon = principal.CurrentUserLogon(),
_currentUser = principal.CurrentUser()
});
//persist the user context
_connection.SetRangeInHash($"{RecurrentJobKeyPrefix}::{uniqueOpId}", Enumerate(CustomJobProperty_UserContext.ValuePair(json)));
switch (interval)
{
case ScheduleInterval.Daily: RecurringJob.AddOrUpdate(uniqueOpId, opInvocation, Cron.Daily()); break;
case ScheduleInterval.Hourly: RecurringJob.AddOrUpdate(uniqueOpId, opInvocation, Cron.Hourly()); break;
case ScheduleInterval.Minutely: RecurringJob.AddOrUpdate(uniqueOpId, opInvocation, Cron.Minutely()); break;
case ScheduleInterval.Monthly: RecurringJob.AddOrUpdate(uniqueOpId, opInvocation, Cron.Monthly()); break;
case ScheduleInterval.Weekly: RecurringJob.AddOrUpdate(uniqueOpId, opInvocation, Cron.Weekly()); break;
case ScheduleInterval.Yearly: RecurringJob.AddOrUpdate(uniqueOpId, opInvocation, Cron.Yearly()); break;
default: throw new Exception("unknown interval");
}
});
private static ScheduleInterval[] NormalizeIntervals(ScheduleInterval[] intervals)
{
return(ScheduleInterval.GetIntervalsFromWeekBitmap(ScheduleInterval.GetWeekBitmapFromIntervals(intervals)));
}
public void Init()
{
instance = new ScheduleInterval();
}
/// <summary>
/// Sets data to database.
/// </summary>
protected void btnOK_Click(object sender, EventArgs e)
{
// Check 'configure' permission
if (!CMSContext.CurrentUser.IsAuthorizedPerResource("cms.newsletter", "configure"))
{
RedirectToCMSDeskAccessDenied("cms.newsletter", "configure");
}
// Validate base inputs (newsletter display name, code name, sender name, sender e-mail)
string errorMessage = new Validator().NotEmpty(txtNewsletterDisplayName.Text.Trim(), GetString("general.requiresdisplayname")).NotEmpty(txtNewsletterName.Text.Trim(), GetString("Newsletter_Edit.ErrorEmptyName")).NotEmpty(txtNewsletterSenderName.Text.Trim(), GetString("Newsletter_Edit.ErrorEmptySenderName")).NotEmpty(txtNewsletterSenderEmail.Text.Trim(), GetString("Newsletter_Edit.ErrorEmptySenderEmail")).IsEmail(txtNewsletterSenderEmail.Text.Trim(), GetString("Newsletter_Edit.ErrorEmailFormat")).IsCodeName(txtNewsletterName.Text.Trim(), GetString("general.invalidcodename")).Result;
if (String.IsNullOrEmpty(errorMessage))
{
if (String.IsNullOrEmpty((string)subscriptionTemplate.Value))
{
// No subscription template selected
lblSubscriptionError.Visible = true;
return;
}
if (String.IsNullOrEmpty((string)unsubscriptionTemplate.Value))
{
// No unsubscription template selected
lblUnsubscriptionError.Visible = true;
return;
}
if ((radTemplateBased.Checked) && (String.IsNullOrEmpty((string)issueTemplate.Value)))
{
// No issue template selected for template based newsletter
lblIssueError.Visible = true;
return;
}
if ((radDynamic.Checked) && (String.IsNullOrEmpty(txtNewsletterDynamicURL.Text.Trim())))
{
// Dynamic URL cannot be empty
ShowError(GetString("menuitem_edit.errorpageurlempty"));
return;
}
if ((radDynamic.Checked) && (chkSchedule.Checked) && (!ScheduleInterval.CheckOneDayMinimum()))
{
// Problem occurred while setting schedule interval for dynamic newsletter
ShowError(GetString("Newsletter_Edit.NoDaySelected"));
return;
}
if ((radDynamic.Checked) && (chkSchedule.Checked) && (SchedulingHelper.DecodeInterval(ScheduleInterval.ScheduleInterval).StartTime == DateTime.MinValue))
{
ShowError(GetString("Newsletter.IncorrectDate"));
return;
}
// Newsletter code name must to be unique per site...
NewsletterInfo newsletterObj = NewsletterInfoProvider.GetNewsletterInfo(txtNewsletterName.Text.Trim(), CMSContext.CurrentSiteID);
// If newsletter code name is unique...
if (newsletterObj == null)
{
// Create new item -> insert
newsletterObj = new NewsletterInfo();
newsletterObj.NewsletterDisplayName = txtNewsletterDisplayName.Text.Trim();
newsletterObj.NewsletterName = txtNewsletterName.Text.Trim();
int selectedValue = ValidationHelper.GetInteger(subscriptionTemplate.Value, 0);
if (selectedValue != 0)
{
newsletterObj.NewsletterSubscriptionTemplateID = selectedValue;
}
else
{
ShowError(GetString("Newsletter_Edit.NoSubscriptionTemplateSelected"));
return;
}
selectedValue = ValidationHelper.GetInteger(unsubscriptionTemplate.Value, 0);
if (selectedValue != 0)
{
newsletterObj.NewsletterUnsubscriptionTemplateID = selectedValue;
}
else
{
ShowError(GetString("Newsletter_Edit.NoUnsubscriptionTemplateSelected"));
return;
}
newsletterObj.NewsletterSenderName = txtNewsletterSenderName.Text.Trim();
newsletterObj.NewsletterSenderEmail = txtNewsletterSenderEmail.Text.Trim();
if (radDynamic.Checked)
{
newsletterObj.NewsletterDynamicURL = txtNewsletterDynamicURL.Text.Trim();
newsletterObj.NewsletterType = NewsletterType.Dynamic;
}
else
{
selectedValue = ValidationHelper.GetInteger(issueTemplate.Value, 0);
if (selectedValue != 0)
{
newsletterObj.NewsletterTemplateID = selectedValue;
}
else
{
ShowError(GetString("Newsletter_Edit.NoEmailTemplateSelected"));
return;
}
newsletterObj.NewsletterType = NewsletterType.TemplateBased;
}
newsletterObj.NewsletterSiteID = CMSContext.CurrentSiteID;
newsletterObj.NewsletterGUID = Guid.NewGuid();
newsletterObj.NewsletterLogActivity = true;
newsletterObj.NewsletterEnableResending = true;
try
{
// Create new newsletter
NewsletterInfoProvider.SetNewsletterInfo(newsletterObj);
if (radDynamic.Checked)
{
if (chkSchedule.Checked)
{
// Create new task to schedule the dynamic newsletter
TaskInfo task = new TaskInfo();
task.TaskAssemblyName = "CMS.Newsletter";
task.TaskClass = "CMS.Newsletter.DynamicNewsletterSender";
task.TaskDisplayName = GetString("DynamicNewsletter.TaskName") + newsletterObj.NewsletterDisplayName;
task.TaskEnabled = true;
task.TaskInterval = ScheduleInterval.ScheduleInterval;
task.TaskLastResult = string.Empty;
task.TaskName = "DynamicNewsletter." + ValidationHelper.GetCodeName(newsletterObj.NewsletterName, "_");
task.TaskSiteID = CMSContext.CurrentSiteID;
task.TaskNextRunTime = SchedulingHelper.GetNextTime(task.TaskInterval, new DateTime(), new DateTime());
task.TaskData = newsletterObj.NewsletterGUID.ToString();
// Set task for processing in external service
task.TaskAllowExternalService = true;
task.TaskUseExternalService = (SchedulingHelper.UseExternalService && NewsletterHelper.UseExternalServiceForDynamicNewsletters(CMSContext.CurrentSiteName));
task.TaskType = ScheduledTaskTypeEnum.System;
TaskInfoProvider.SetTaskInfo(task);
newsletterObj.NewsletterDynamicScheduledTaskID = task.TaskID;
NewsletterInfoProvider.SetNewsletterInfo(newsletterObj);
}
}
URLHelper.Redirect("Newsletter_Frameset.aspx?newsletterid=" + ValidationHelper.GetString(newsletterObj.NewsletterID, null) + "&saved=1");
}
catch (Exception ex)
{
ShowError(GetString(ex.Message));
}
}
else
{
ShowError(GetString("Newsletter_Edit.NewsletterNameExists"));
}
}
else
{
ShowError(errorMessage);
}
}
public byte[] ToByteArray()
{
return(ScheduleInterval.GetWeekBitmapFromIntervals(this.intervals));
}
protected static object GetSingleProperty(object prop, Type type)
{
if (prop == null)
{
return(null);
}
object obj = null;
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
obj = MockObjectCreator.GetSingleProperty(prop, type.GetGenericArguments()[0]);
}
else if (type == typeof(ADObjectId) && prop is PSObject)
{
obj = new ADObjectId(((PSObject)prop).Members["DistinguishedName"].Value.ToString(), new Guid(((PSObject)prop).Members["ObjectGuid"].Value.ToString()));
}
else if (type == typeof(EnhancedTimeSpan))
{
obj = EnhancedTimeSpan.Parse(prop.ToString());
}
else if (type == typeof(Unlimited <EnhancedTimeSpan>))
{
obj = Unlimited <EnhancedTimeSpan> .Parse(prop.ToString());
}
else if (type == typeof(ByteQuantifiedSize))
{
obj = ByteQuantifiedSize.Parse(prop.ToString());
}
else if (type == typeof(Unlimited <ByteQuantifiedSize>))
{
obj = Unlimited <ByteQuantifiedSize> .Parse(prop.ToString());
}
else if (type == typeof(Unlimited <int>))
{
obj = Unlimited <int> .Parse(prop.ToString());
}
else if (type == typeof(ProxyAddress))
{
obj = ProxyAddress.Parse(prop.ToString());
}
else if (type == typeof(SmtpAddress))
{
obj = new SmtpAddress(prop.ToString());
}
else if (type == typeof(SmtpDomain))
{
obj = SmtpDomain.Parse(prop.ToString());
}
else if (type == typeof(CountryInfo))
{
obj = CountryInfo.Parse(prop.ToString());
}
else if (type == typeof(SharingPolicyDomain))
{
obj = SharingPolicyDomain.Parse(prop.ToString());
}
else if (type == typeof(ApprovedApplication))
{
obj = ApprovedApplication.Parse(prop.ToString());
}
else if (type == typeof(SmtpDomainWithSubdomains))
{
obj = SmtpDomainWithSubdomains.Parse(prop.ToString());
}
else if (type == typeof(UMLanguage))
{
obj = UMLanguage.Parse(prop.ToString());
}
else if (type == typeof(UMSmartHost))
{
obj = UMSmartHost.Parse(prop.ToString());
}
else if (type == typeof(ScheduleInterval))
{
obj = ScheduleInterval.Parse(prop.ToString());
}
else if (type == typeof(NumberFormat))
{
obj = NumberFormat.Parse(prop.ToString());
}
else if (type == typeof(DialGroupEntry))
{
obj = DialGroupEntry.Parse(prop.ToString());
}
else if (type == typeof(CustomMenuKeyMapping))
{
obj = CustomMenuKeyMapping.Parse(prop.ToString());
}
else if (type == typeof(HolidaySchedule))
{
obj = HolidaySchedule.Parse(prop.ToString());
}
else if (type == typeof(UMTimeZone))
{
obj = UMTimeZone.Parse(prop.ToString());
}
else if (type == typeof(ServerVersion))
{
obj = ServerVersion.ParseFromSerialNumber(prop.ToString());
}
else if (type == typeof(X509Certificate2))
{
obj = new X509Certificate2(((PSObject)prop).Members["RawData"].Value as byte[]);
}
else if (type == typeof(LocalizedString))
{
obj = new LocalizedString(prop.ToString());
}
else if (type == typeof(ExchangeObjectVersion))
{
obj = ExchangeObjectVersion.Parse(prop.ToString());
}
else if (type == typeof(bool))
{
obj = bool.Parse(prop.ToString());
}
else if (type == typeof(SecurityPrincipalIdParameter))
{
obj = new SecurityPrincipalIdParameter(prop.ToString());
}
else if (type == typeof(ActiveDirectoryAccessRule))
{
obj = (prop as ActiveDirectoryAccessRule);
}
else if (type == typeof(ObjectId))
{
string text = prop.ToString();
if (!ADObjectId.IsValidDistinguishedName(text) && text.Contains("/"))
{
text = MockObjectCreator.ConvertDNFromTreeStructure(text);
}
obj = new ADObjectId(text);
}
else if (type.IsEnum)
{
try
{
obj = Enum.Parse(type, prop.ToString());
}
catch (ArgumentException)
{
obj = Enum.GetValues(type).GetValue(0);
}
}
return(obj ?? prop);
}
public Operation RepeatOperation <Service>(string uniqueOpId, Expression <Action <Service> > opInvocation, ScheduleInterval interval) => RepeatOperation(uniqueOpId, _userContext, opInvocation, interval);
