void HandleSchedules(GXAmiSchedule schedule, GXEventsItem e)
{
ulong mask = (ulong)((int)e.Target << 16 | (int)e.Action);
//Find is anyone interested from this data collector event.
foreach (GXSession it in Sessions)
{
foreach (GXEvent e1 in it.NotifyClients)
{
if (e1.UserID != 0 && (mask & e1.Mask) != 0)
{
//Notify only super admin or if user has access to this data collector.
if (e1.SuperAdmin)//TODO: || GXDeviceGroupService.CanUserAccessDeviceGroup(Db, e1.UserID, group.Id))
{
e1.Rows.Add(e);
it.Received.Set();
}
}
/* TODO:
* //Notify DC that Schedule is added.
* else if (e.Action == Actions.Edit && e.Target == ActionTargets.Trace &&
* e1.DataCollectorGuid == schedule.datac)
* {
* e1.Rows.Add(e);
* it.Received.Set();
* }
* */
}
}
}
/// <summary>
/// Selete selected schedules.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public GXScheduleDeleteResponse Post(GXScheduleDeleteRequest request)
{
IAuthSession s = this.GetSession(false);
int id = Convert.ToInt32(s.Id);
if (id == 0)
{
throw new ArgumentException("Remove failed. Invalid session ID.");
}
if (!GuruxAMI.Server.GXBasicAuthProvider.CanUserEdit(s))
{
throw new ArgumentException("Remove not allowed.");
}
List <GXEventsItem> events = new List <GXEventsItem>();
bool superAdmin = GuruxAMI.Server.GXBasicAuthProvider.IsSuperAdmin(s);
lock (Db)
{
foreach (ulong it in request.Schedules)
{
if (it == 0)
{
throw new ArgumentException("ID is required");
}
//Only super admin or creator can remove schedule.
//TODO:
#if !SS4
GXAmiSchedule schedule = Db.QueryById <GXAmiSchedule>(it);
#else
GXAmiSchedule schedule = Db.SingleById <GXAmiSchedule>(it);
#endif
if (request.Permanently)
{
Db.DeleteById <GXAmiSchedule>(it);
}
else
{
schedule.Removed = DateTime.Now.ToUniversalTime();
Db.UpdateOnly(schedule, p => p.Removed, p => p.Id == it);
}
events.Add(new GXEventsItem(ActionTargets.Schedule, Actions.Remove, schedule));
}
}
AppHost host = this.ResolveService <AppHost>();
host.SetEvents(Db, this.Request, id, events);
return(new GXScheduleDeleteResponse());
}
/// <summary>
/// Schedule is added or edit.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public GXScheduleUpdateResponse Post(GXScheduleUpdateRequest request)
{
List <GXEventsItem> events = new List <GXEventsItem>();
IAuthSession s = this.GetSession(false);
long adderId = Convert.ToInt64(s.Id);
lock (Db)
{
using (var trans = Db.OpenTransaction(IsolationLevel.ReadCommitted))
{
//Add new schedules.
foreach (GXAmiSchedule it in request.Schedules)
{
if (string.IsNullOrEmpty(it.Name))
{
throw new ArgumentException("Invalid name.");
}
//If new schedule.
if (it.Id == 0)
{
//All date times are saved to DB in universal time.
it.Added = DateTime.Now.ToUniversalTime();
if (it.TransactionStartTime != null)
{
it.TransactionStartTime = it.TransactionStartTime.Value.ToUniversalTime();
}
if (it.TransactionEndTime != null)
{
it.TransactionEndTime = it.TransactionEndTime.Value.ToUniversalTime();
}
if (it.ScheduleStartTime != null)
{
it.ScheduleStartTime = it.ScheduleStartTime.Value.ToUniversalTime();
}
if (it.ScheduleEndTime != null)
{
it.ScheduleEndTime = it.ScheduleEndTime.Value.ToUniversalTime();
}
if (it.NextRunTine != null)
{
it.NextRunTine = it.NextRunTine.Value.ToUniversalTime();
}
if (it.LastRunTime != null)
{
it.LastRunTime = it.LastRunTime.Value.ToUniversalTime();
}
Db.Insert(it);
#if !SS4
it.Id = (ulong)Db.GetLastInsertId();
#else
it.Id = Db.LastInsertId();
#endif
//Restore date times back to local time.
it.Added = it.Added.ToLocalTime();
if (it.TransactionStartTime != null)
{
it.TransactionStartTime = it.TransactionStartTime.Value.ToLocalTime();
}
if (it.TransactionEndTime != null)
{
it.TransactionEndTime = it.TransactionEndTime.Value.ToLocalTime();
}
if (it.ScheduleStartTime != null)
{
it.ScheduleStartTime = it.ScheduleStartTime.Value.ToLocalTime();
}
if (it.ScheduleEndTime != null)
{
it.ScheduleEndTime = it.ScheduleEndTime.Value.ToLocalTime();
}
if (it.NextRunTine != null)
{
it.NextRunTine = it.NextRunTine.Value.ToLocalTime();
}
if (it.LastRunTime != null)
{
it.LastRunTime = it.LastRunTime.Value.ToLocalTime();
}
events.Add(new GXEventsItem(ActionTargets.Schedule, Actions.Add, it));
}
else //Update schedule.
{
//Get Added time.
#if !SS4
GXAmiSchedule orig = Db.GetById <GXAmiSchedule>(it.Id);
#else
GXAmiSchedule orig = Db.SingleById <GXAmiSchedule>(it.Id);
#endif
it.Added = orig.Added;
it.TransactionStartTime = orig.TransactionStartTime;
it.TransactionEndTime = orig.TransactionEndTime;
it.ScheduleStartTime = orig.ScheduleStartTime;
it.ScheduleEndTime = orig.ScheduleEndTime;
it.NextRunTine = orig.NextRunTine;
it.LastRunTime = orig.LastRunTime;
Db.Update(it);
events.Add(new GXEventsItem(ActionTargets.Schedule, Actions.Edit, it));
}
//Delete all targets first.
Db.Delete <GXAmiScheduleTarget>(q => q.ScheduleId == it.Id);
//Add targets.
foreach (GXAmiScheduleTarget t in it.Targets)
{
t.ScheduleId = it.Id;
Db.Insert <GXAmiScheduleTarget>(t);
}
}
trans.Commit();
}
}
AppHost host = this.ResolveService <AppHost>();
host.SetEvents(Db, this.Request, adderId, events);
return(new GXScheduleUpdateResponse(request.Schedules));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="client"></param>
/// <param name="scheduleItem"></param>
public GXAmiScheduleEditorDlg(GXAmiClient client, GXAmiSchedule schedule)
{
Client = client;
InitializeComponent();
m_ScheduleItem = schedule;
if (System.Globalization.DateTimeFormatInfo.CurrentInfo.FirstDayOfWeek == DayOfWeek.Sunday)
{
Point TmpLoc = new Point(DaySunCb.Location.X, DaySunCb.Location.Y);
DaySunCb.Location = DayMonCb.Location;
DayMonCb.Location = DayTueCb.Location;
DayTueCb.Location = DayWedCb.Location;
DayWedCb.Location = DayThuCb.Location;
DayThuCb.Location = DayFriCb.Location;
DayFriCb.Location = DaySatCb.Location;
DaySatCb.Location = TmpLoc;
}
FillEnums();
UpdateResouces();
NameTb.Text = m_ScheduleItem.Name;
if (m_ScheduleItem.TransactionStartTime != null)
{
TransactionStartTimeTp.Value = m_ScheduleItem.TransactionStartTime.Value;
}
else
{
TransactionStartTimeTp.Checked = false;
}
if (m_ScheduleItem.TransactionEndTime != null)
{
TransactionEndTimeTp.Value = m_ScheduleItem.TransactionEndTime.Value;
}
//Has to be done to uncheck, known issue in .NET
TransactionEndTimeTp.Checked = true; //Has to be done to uncheck, known issue in .NET
TransactionEndTimeTp.Checked = m_ScheduleItem.TransactionEndTime != null;
if (m_ScheduleItem.TransactionEndTime != null)
{
TransactionEndTimeTp.Value = m_ScheduleItem.TransactionEndTime.Value;
}
if (m_ScheduleItem.TransactionCount == 0)
{
TransactionCountCb.Checked = false;
TransactionCountTb.Text = "";
}
else
{
TransactionCountCb.Checked = true;
TransactionCountTb.Text = m_ScheduleItem.TransactionCount.ToString();
}
UpdateFrequencyTp.Value = new DateTime(((long)m_ScheduleItem.UpdateInterval) * 10000000 + UpdateFrequencyTp.MinDate.Ticks);
RepeatModeCb.SelectedItem = ScheduleRepeatToString(m_ScheduleItem.RepeatMode);
DayOfMonthTb.Text = m_ScheduleItem.DayOfMonth.ToString();
IntervalTb.Text = m_ScheduleItem.Interval.ToString();
ActionCb.SelectedItem = ScheduleActionToString(m_ScheduleItem.Action);
if (m_ScheduleItem.ScheduleStartTime != null)
{
ScheduleStartDateTp.Value = m_ScheduleItem.ScheduleStartTime.Value;
}
if (m_ScheduleItem.ScheduleEndTime != null)
{
ScheduleEndDateTp.Value = m_ScheduleItem.ScheduleEndTime.Value;
}
ScheduleEndDateTp.Checked = true; //Has to be done to uncheck, known issue in .NET
ScheduleEndDateTp.Checked = m_ScheduleItem.ScheduleEndTime != null;
UpdateTargetCheckTree();
ErrorWaitTimeTp.Value = new DateTime(ErrorWaitTimeTp.MinDate.Ticks + ((long)m_ScheduleItem.FailWaitTime) * 10000);
//ErrorWaitTimeTp.Value. = m_ScheduleItem.FailWaitTime/1000.0;
ErrorTryCountTb.Text = m_ScheduleItem.FailTryCount.ToString();
ConnectionDelayTimeTp.Value = new DateTime(ConnectionDelayTimeTp.MinDate.Ticks + ((long)m_ScheduleItem.ConnectionDelayTime) * 10000);
MaxThreadCountTb.Text = m_ScheduleItem.MaxThreadCount.ToString();
//ConnectionFailWaitTimeTb.Text = Convert.ToString(m_ScheduleItem.ConnectionFailWaitTime/1000.0);
ConnectionFailWaitTimeTp.Value = new DateTime(ConnectionFailWaitTimeTp.MinDate.Ticks + ((long)m_ScheduleItem.ConnectionFailWaitTime) * 10000);
ConnectionFailTryCountTb.Text = m_ScheduleItem.ConnectionFailTryCount.ToString();
if (m_ScheduleItem.DayOfWeeks == null)
{
DayMonCb.Checked = DayTueCb.Checked = DayWedCb.Checked = DayThuCb.Checked = DayFriCb.Checked = DaySatCb.Checked = DaySunCb.Checked = false;
}
else
{
System.Collections.Generic.List<DayOfWeek> list = new System.Collections.Generic.List<DayOfWeek>();
list.AddRange(m_ScheduleItem.DayOfWeeks);
DayMonCb.Checked = list.Contains(DayOfWeek.Monday);
DayTueCb.Checked = list.Contains(DayOfWeek.Tuesday);
DayWedCb.Checked = list.Contains(DayOfWeek.Wednesday);
DayThuCb.Checked = list.Contains(DayOfWeek.Thursday);
DayFriCb.Checked = list.Contains(DayOfWeek.Friday);
DaySatCb.Checked = list.Contains(DayOfWeek.Saturday);
DaySunCb.Checked = list.Contains(DayOfWeek.Sunday);
}
OKBtn.Enabled = (m_ScheduleItem.Status & ScheduleState.Run) == 0;
}
public GXScheduleResponse(GXAmiSchedule[] schedules)
{
this.Schedules = schedules;
}
void Client_OnSchedulesAdded(object sender, GXAmiSchedule[] schedules)
{
if (this.InvokeRequired)
{
this.BeginInvoke(new SchedulesAddedEventHandler(OnSchedulesAdded), sender, schedules);
}
else
{
OnSchedulesAdded(sender, schedules);
}
}
private bool SetScheduleTarget(GXAmiSchedule scheduleItem, TreeNode deviceListNode)
{
List<GXAmiScheduleTarget> targets = new List<GXAmiScheduleTarget>();
foreach (TreeNode it in deviceListNode.Nodes)
{
if (it.Checked)
{
targets.Add(new GXAmiScheduleTarget(scheduleItem, TargetType.Device, (it.Tag as GuruxAMI.Common.GXAmiDevice).Id));
}
}
scheduleItem.Targets = targets.ToArray();
return targets.Count != 0;
}
void OnSchedulesUpdated(object sender, GXAmiSchedule[] schedules)
{
try
{
lock (ScheduleToListViewItem)
{
foreach (GXAmiSchedule it in schedules)
{
ListViewItem li = ScheduleToListViewItem[it.Id];
li.Tag = it;
li.SubItems[0].Text = it.Name;
li.SubItems[1].Text = GXAmiScheduleEditorDlg.ScheduleRepeatToString(it.RepeatMode);
//Next run time
if (it.NextRunTine > DateTime.MinValue)
{
li.SubItems[2].Text = it.NextRunTine.ToString();
}
else
{
li.SubItems[2].Text = string.Empty;
}
//Last run time
if (it.LastRunTime > DateTime.MinValue)
{
li.SubItems[3].Text = it.LastRunTime.ToString();
}
else
{
li.SubItems[3].Text = string.Empty;
}
//Progress
li.SubItems[3].Text = string.Empty;
}
}
}
catch (Exception ex)
{
GXCommon.ShowError(this.ParentComponent, Gurux.DeviceSuite.Properties.Resources.GuruxDeviceSuiteTxt, ex);
}
}
void OnSchedulesAdded(object sender, GXAmiSchedule[] schedules)
{
try
{
lock (ScheduleToListViewItem)
{
foreach (GXAmiSchedule it in schedules)
{
AddScheduleItem(it);
}
}
}
catch (Exception ex)
{
GXCommon.ShowError(this.ParentComponent, Gurux.DeviceSuite.Properties.Resources.GuruxDeviceSuiteTxt, ex);
}
}
/// <summary>
/// Add new Schedule.
/// </summary>
public void NewSchedule()
{
try
{
GXAmiSchedule schedule = new GXAmiSchedule();
schedule.ScheduleStartTime = DateTime.Now;
GXAmiScheduleEditorDlg dlg = new GXAmiScheduleEditorDlg(Client, schedule);
dlg.ShowDialog(ParentComponent);
}
catch (Exception ex)
{
GXCommon.ShowError(this.ParentComponent, Gurux.DeviceSuite.Properties.Resources.GuruxDeviceSuiteTxt, ex);
}
}
void OnSchedulesStateChanged(object sender, GXAmiSchedule[] schedules)
{
try
{
lock (ScheduleToListViewItem)
{
foreach (GXAmiSchedule it in schedules)
{
ListViewItem li = ScheduleToListViewItem[it.Id];
UpdateScheduleImage(li, it.Status);
}
}
}
catch (Exception ex)
{
GXCommon.ShowError(this.ParentComponent, Gurux.DeviceSuite.Properties.Resources.GuruxDeviceSuiteTxt, ex);
}
}
private void AddScheduleItem(GXAmiSchedule item)
{
ListViewItem it = new ListViewItem(item.Name);
it.SubItems.Add(GXAmiScheduleEditorDlg.ScheduleRepeatToString(item.RepeatMode));
//Next run time
if (item.NextRunTine > DateTime.MinValue)
{
it.SubItems.Add(item.NextRunTine.ToString());
}
else
{
it.SubItems.Add(string.Empty);
}
//Last run time
if (item.LastRunTime > DateTime.MinValue)
{
it.SubItems.Add(item.LastRunTime.ToString());
}
else
{
it.SubItems.Add(string.Empty);
}
//Progress
it.SubItems.Add(string.Empty);
it.Tag = item;
UpdateScheduleImage(it, item.Status);
Schedules.Items.Add(it);
ScheduleToListViewItem[item.Id] = it;
}
/// <summary>
/// Schedule is started or stopped.
/// </summary>
/// <param name="sender"></param>
/// <param name="schedules"></param>
void Client_OnSchedulesStateChanged(object sender, GXAmiSchedule[] schedules)
{
//Update schedule state.
lock (Schedules)
{
GXAmiDevice device = new GXAmiDevice();
foreach (GXAmiSchedule it in schedules)
{
if (Schedules[it.Id].Status != it.Status)
{
Schedules[it.Id].Status = it.Status;
if (it.Status == ScheduleState.Run)
{
foreach (GXAmiScheduleTarget t in Schedules[it.Id].Targets)
{
if (t.TargetType == TargetType.Device)
{
device.Id = t.TargetID;
Client.Read(device);
}
}
}
else if (it.Status == ScheduleState.Start)
{
System.Collections.Generic.IDictionary<string, object> data = new Dictionary<string, object>();
data.Add(new KeyValuePair<string, object>("Client", Client));
//Target is added by ID because devices can be added or removed from it.
data.Add(new KeyValuePair<string, object>("Target", it.Id));
JobKey id = new JobKey(it.Name + it.Id.ToString(), it.Name + it.Id.ToString());
IJobDetail job = JobBuilder.Create(typeof(GXScheduleJob)).WithIdentity(new JobKey(it.Name + it.Id.ToString(), it.Name + it.Id.ToString()))
.WithIdentity(id)
.SetJobData(new JobDataMap(data))
.Build();
ITrigger t = GetTrigger(it);
m_sched.ScheduleJob(job, t);
}
else if (it.Status == ScheduleState.End)
{
if ((it.Status & ScheduleState.Run) != 0)
{
it.Status = ScheduleState.None;
m_sched.DeleteJob(new JobKey(it.Name + it.Id.ToString(), it.Name + it.Id.ToString()));
}
}
}
}
}
if (m_ScheduleStateChanged != null)
{
m_ScheduleStateChanged(sender, schedules);
}
}
/// <summary>
///
/// </summary>
/// <remarks>
/// see more: http://www.cronmaker.com/
/// </remarks>
/// <returns></returns>
internal ITrigger GetTrigger(GXAmiSchedule schedule)
{
string format = null;
DateTime end;
ITrigger trigger = null;
if (schedule.RepeatMode == ScheduleRepeat.Once)
{
trigger = (ITrigger)TriggerBuilder.Create()
.StartNow()
.EndAt(DateTime.Now)
.Build();
}
else if (schedule.RepeatMode == ScheduleRepeat.Second)
{
format = "0/" + schedule.Interval.ToString() + " * * * * ?";
}
else if (schedule.RepeatMode == ScheduleRepeat.Minute)
{
format = "0 0/" + schedule.Interval.ToString() + " * * * ?";
}
else if (schedule.RepeatMode == ScheduleRepeat.Hour)
{
format = "0 0 0/" + schedule.Interval.ToString() + " * * ?";
}
else if (schedule.RepeatMode == ScheduleRepeat.Day)
{
format = string.Format("{3} {2} {1} 1/{0} * ?",
schedule.Interval,
schedule.TransactionStartTime.Value.Hour,
schedule.TransactionStartTime.Value.Minute,
schedule.TransactionStartTime.Value.Second);
}
else if (schedule.RepeatMode == ScheduleRepeat.Week)
{
end = DateTime.MaxValue;
if (schedule.ScheduleEndTime != null)
{
end = new DateTime(schedule.ScheduleEndTime.Value.Year, schedule.ScheduleEndTime.Value.Month,
schedule.ScheduleEndTime.Value.Day, schedule.TransactionEndTime.Value.Hour,
schedule.TransactionEndTime.Value.Minute, schedule.TransactionEndTime.Value.Second);
}
List<string> days = new List<string>();
foreach (DayOfWeek it in schedule.DayOfWeeks)
{
days.Add(it.ToString().Substring(0, 3).ToUpper());
}
string tmp = string.Format("{3} {2} {1} ? * {0}, *",
string.Join(",", days.ToArray()),
schedule.TransactionStartTime.Value.Hour,
schedule.TransactionStartTime.Value.Minute,
schedule.TransactionStartTime.Value.Second);
IScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule(tmp);
trigger = (ITrigger)TriggerBuilder.Create()
.WithIdentity(schedule.Name)
.WithSchedule(scheduleBuilder)
.Build();
}
else if (schedule.RepeatMode == ScheduleRepeat.Month)
{
string tmp = string.Format("0 {2} {1} {0} 1/{3} ? *",
schedule.DayOfMonth,
schedule.TransactionStartTime.Value.Hour,
schedule.TransactionStartTime.Value.Minute,
schedule.Interval);
IScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule(tmp);
trigger = (ITrigger)TriggerBuilder.Create()
.WithIdentity(schedule.Name)
.WithSchedule(scheduleBuilder)
.Build();
}
if (trigger == null)
{
end = DateTime.MaxValue;
if (schedule.ScheduleEndTime != null)
{
end = new DateTime(schedule.ScheduleEndTime.Value.Year, schedule.ScheduleEndTime.Value.Month,
schedule.ScheduleEndTime.Value.Day, schedule.TransactionEndTime.Value.Hour,
schedule.TransactionEndTime.Value.Minute, schedule.TransactionEndTime.Value.Second);
}
IScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule(format);//.InTimeZone(TimeZoneInfo.Local);
trigger = (ITrigger)TriggerBuilder.Create()
.WithIdentity(schedule.Name)
.WithSchedule(scheduleBuilder)
.Build();
}
return trigger;
}
/// <summary>
/// New schedule item is added.
/// </summary>
/// <param name="sender"></param>
/// <param name="schedules"></param>
void Client_OnSchedulesAdded(object sender, GXAmiSchedule[] schedules)
{
lock (Schedules)
{
foreach (GXAmiSchedule it in schedules)
{
Schedules.Add(it.Id, it);
}
}
if (m_ScheduleAdded != null)
{
m_ScheduleAdded(sender, schedules);
}
}
/// <summary>
/// Schedule item is updated.
/// </summary>
/// <param name="sender"></param>
/// <param name="schedules"></param>
void Client_OnSchedulesUpdated(object sender, GXAmiSchedule[] schedules)
{
lock (Schedules)
{
foreach (GXAmiSchedule it in schedules)
{
Schedules[it.Id] = it;
}
}
if (m_SchedulesUpdated != null)
{
m_SchedulesUpdated(sender, schedules);
}
}
