public async Task <IActionResult> PutSchedulePlan(int id, SchedulePlan schedulePlan)
{
if (id != schedulePlan.ScheduleId)
{
return(BadRequest());
}
_context.Entry(schedulePlan).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SchedulePlanExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult Detail(int Id)
{
IEnumerable <SchedulePlan> schedulePlan = GetDataFromAPI("http://localhost:64648/api/AirportSchedule/", "GetAllSchedulePlan");
SchedulePlan element = schedulePlan.Where(x => x.Id == Id).First();
return(View(element));
}
public SchedulePlanOperatorTransaction(SchedulePlan plan)
{
_plan = plan;
if (_plan.TodayItem != null)
{
_costTime = _plan.TodayItem.CostTime;
}
}
public UCScedulePlanOperator(SchedulePlan plan)
: base(plan)
{
_tabbedStatus = UCTabbedStatus.SaveEnable;
InitializeComponent();
_sPlan = plan;
_transaction = new SchedulePlanOperatorTransaction(_sPlan);
InitialData();
}
public ActionResult EditSchedulePlan(SchedulePlan setPlan)
{
if (!SessionManager.checkCurrentUserType(UserType.MAINTENANCE_PERSON))
{
return(new HttpStatusCodeResult(403));
}
return(View());
}
private SqlParameter[] ConstructParameters(SchedulePlan plan)
{
SqlParameter[] parameters = new SqlParameter[] { new SqlParameter(Constant.ParameterID, plan.ID),
new SqlParameter(Constant.ParameterStartIndex, plan.StartIndex),
new SqlParameter(Constant.ParameterEndIndex, plan.EndIndex),
new SqlParameter(Constant.ParameterWeekDayWorkload, plan.WeekDayWorkload),
new SqlParameter(Constant.ParameterWeekendWorkload, plan.WeekendWorkload),
new SqlParameter(Constant.ParameterBuffer, plan.Buffer) };
return(parameters);
}
public async Task <IActionResult> Create([Bind("GroupId")] SchedulePlan schedulePlan)
{
if (ModelState.IsValid)
{
_context.Add(schedulePlan);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Edit), new { id = schedulePlan.Id }));
}
return(await Index());
}
public void UpdateScheduleTag(SchedulePlan schedulePlan)
{
using (var nctxs = ContextRegistry.NamedContextsFor(this.GetType()))
{
using (var session = DocumentStoreLocator.ContextualResolve())
{
var currentSchedule = session.Load <SchedulePlan>(schedulePlan.Id);
currentSchedule.Tags = schedulePlan.Tags;
session.SaveChanges();
}
}
}
protected override void CreatePlan(SqlConnection connection, SqlTransaction transaction, Plan plan)
{
base.CreatePlan(connection, transaction, plan);
SchedulePlan tempPlan = plan as SchedulePlan;
_connectionManager.RetryExecute(
() =>
{
SqlParameter[] parameters = ConstructParameters(tempPlan);
SqlHelper.ExecuteNonQuery(connection, transaction, Constant.ProcCreateSchedulePlan, parameters);
});
}
public static int GetStandardWorkingTimeByProductId_SpecificationId(string ProductId, string SpecificationId)
{
MOProductSpecification ps = SchedulePlan.GetEntity().MOProductSpecification.Where(p => p.ProductId == ProductId && p.SpecificationId == SpecificationId).FirstOrDefault();
if (ps != null && ps.StandardWorkingTime != null)
{
return((int)ps.StandardWorkingTime);
}
else
{
return(0);
}
}
protected override void UpdatePlan(SqlConnection connection, SqlTransaction transaction, Plan plan)
{
base.UpdatePlan(connection, transaction, plan);
SchedulePlan tempPlan = plan as SchedulePlan;
ConnectionManager.Instance.RetryExecute(
() =>
{
SqlParameter[] parameters = ConstructParameters(tempPlan);
SqlHelper.ExecuteNonQuery(connection, transaction, Constant.ProcUpdateSchedulePlan, parameters);
_scheduleItemDal.InsertOrUpdateScheduleItem(connection, transaction, tempPlan.TodayItem);
});
}
public Lok.Unik.ModelCommon.Client.SchedulePlan SaveSchedule(SchedulePlan schedule)
{
using (var nctxs = ContextRegistry.NamedContextsFor(this.GetType()))
{
using (var session = DocumentStoreLocator.ContextualResolve())
{
schedule.Tags.Add(new TagManager().AddDefault <SchedulePlan>(schedule.Name, schedule.Id.ToString()));
session.Store(schedule);
session.SaveChanges();
return(schedule);
}
}
}
public async Task <IActionResult> Approve(int id, bool students, bool teachers, bool advisers)
{
if (SchedulePlanExists(id))
{
SchedulePlan schedulePlan = await _context.SchedulePlans.FindAsync(id);
String name = User.Identity.Name;
User user = await _userManager.FindByNameAsync(name);
schedulePlan.Approve(user.SecondName + " " + user.FirstName[0] + "." + user.MiddleName?[0] +".", DateTime.Now);
_context.Update(schedulePlan);
await _context.SaveChangesAsync();
await MailingAsync(id, students, teachers, advisers);
return(RedirectToAction(nameof(Index)));
}
return(NotFound());
}
public async Task <ActionResult <SchedulePlan> > PostSchedulePlan(SchedulePlan schedulePlan)
{
_context.SchedulePlan.Add(schedulePlan);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (SchedulePlanExists(schedulePlan.ScheduleId))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtAction("GetSchedulePlan", new { id = schedulePlan.ScheduleId }, schedulePlan));
}
public void SetSchedulePlans()
{
DateTime utcNow = DateTime.UtcNow;
#region << StartTasksOnStartDate >>
{
Guid checkBotSchedulePlanId = new Guid("6765D758-FB63-478F-B714-5B153AB9A758");
string planName = "Start tasks on start_date";
SchedulePlan checkBotSchedulePlan = ScheduleManager.Current.GetSchedulePlan(checkBotSchedulePlanId);
if (checkBotSchedulePlan == null)
{
checkBotSchedulePlan = new SchedulePlan();
checkBotSchedulePlan.Id = checkBotSchedulePlanId;
checkBotSchedulePlan.Name = planName;
checkBotSchedulePlan.Type = SchedulePlanType.Daily;
checkBotSchedulePlan.StartDate = new DateTime(utcNow.Year, utcNow.Month, utcNow.Day, 0, 10, 0, DateTimeKind.Utc);
checkBotSchedulePlan.EndDate = null;
checkBotSchedulePlan.ScheduledDays = new SchedulePlanDaysOfWeek()
{
ScheduledOnMonday = true,
ScheduledOnTuesday = true,
ScheduledOnWednesday = true,
ScheduledOnThursday = true,
ScheduledOnFriday = true,
ScheduledOnSaturday = true,
ScheduledOnSunday = true
};
checkBotSchedulePlan.IntervalInMinutes = 1440;
checkBotSchedulePlan.StartTimespan = 0;
checkBotSchedulePlan.EndTimespan = 1440;
checkBotSchedulePlan.JobTypeId = new Guid("3D18B8D8-74B8-45B1-B121-9582F7B8A4F4");
checkBotSchedulePlan.JobAttributes = null;
checkBotSchedulePlan.Enabled = true;
checkBotSchedulePlan.LastModifiedBy = null;
ScheduleManager.Current.CreateSchedulePlan(checkBotSchedulePlan);
}
}
#endregion
}
/// <summary>
/// Erzeugt eine Planungsinstanz basierend auf den aktuell bekannten Aufzeichnungen.
/// </summary>
/// <returns>Der gewünschte Plan.</returns>
private SchedulePlan CreateSchedulePlan()
{
// Create
var plan = new SchedulePlan( m_Resources );
// Report
var resources = plan.Resources.ToDictionary( r => r.Resource, ReferenceComparer<IScheduleResource>.Default );
// Merge in each schedule
foreach (var recording in m_Recordings)
{
// Attach to the resource
var resource = recording.Resource;
var resourcePlan = resources[resource];
// Check mode
if (recording.Source == null)
{
// Try to reserve
if (!resourcePlan.Reserve( recording.Time.End ))
return null;
// Next
continue;
}
// Attach to the timing
SuggestedPlannedTime planned = recording.Time;
// Try add
if (!resourcePlan.Add( recording, planned, DateTime.MinValue ))
return null;
// Must not start late
if (planned.Planned.Start != recording.Time.Start)
return null;
}
// Report
return plan;
}
private void SetSchedulePlans()
{
DateTime utcNow = DateTime.UtcNow;
#region << StartTasksOnStartDate >>
{
Guid checkBotSchedulePlanId = new Guid("8f410aca-a537-4c3f-b49b-927670534c07");
string planName = "Start tasks to process SMTP email queue";
SchedulePlan checkBotSchedulePlan = ScheduleManager.Current.GetSchedulePlan(checkBotSchedulePlanId);
if (checkBotSchedulePlan == null)
{
checkBotSchedulePlan = new SchedulePlan();
checkBotSchedulePlan.Id = checkBotSchedulePlanId;
checkBotSchedulePlan.Name = planName;
checkBotSchedulePlan.Type = SchedulePlanType.Interval;
checkBotSchedulePlan.StartDate = new DateTime(utcNow.Year, utcNow.Month, utcNow.Day, 0, 10, 0, DateTimeKind.Utc);
checkBotSchedulePlan.EndDate = null;
checkBotSchedulePlan.ScheduledDays = new SchedulePlanDaysOfWeek()
{
ScheduledOnMonday = true,
ScheduledOnTuesday = true,
ScheduledOnWednesday = true,
ScheduledOnThursday = true,
ScheduledOnFriday = true,
ScheduledOnSaturday = true,
ScheduledOnSunday = true
};
checkBotSchedulePlan.IntervalInMinutes = 10;
checkBotSchedulePlan.StartTimespan = 0;
checkBotSchedulePlan.EndTimespan = 1440;
checkBotSchedulePlan.JobTypeId = new Guid("9b301dca-6c81-40dd-887c-efd31c23bd77");
checkBotSchedulePlan.JobAttributes = null;
checkBotSchedulePlan.Enabled = true;
checkBotSchedulePlan.LastModifiedBy = null;
ScheduleManager.Current.CreateSchedulePlan(checkBotSchedulePlan);
}
}
#endregion
}
public override void Execute()
{
try
{
_plan = new SchedulePlan(_executeDate);
if (!ChooseName())
{
return;
}
_plan.Name = Name;
_plan.Details = Details;
_plan.SetParameter(StartIndex, EndIndex, WeekDayWorkload, WeekendWorkload, Buffer);
IPlanManager _planManager = ManagerFactory.GetPlanManager(_plan);
_planManager.CreatePlan(_plan);
AddMessage("Save successed!", MessageType.Success);
}
catch (Exception ex)
{
AddMessage(ex.Message, MessageType.Error);
}
}
public static void SetSchedulePlans()
{
DateTime utcNow = DateTime.UtcNow;
#region << Search Index >>
{
Guid searchSchedulePlanId = new Guid("5E170FB5-5DE8-4984-909A-24F4ED6AC091");
SchedulePlan checkBotSchedulePlan = ScheduleManager.Current.GetSchedulePlan(searchSchedulePlanId);
if (checkBotSchedulePlan == null)
{
checkBotSchedulePlan = new SchedulePlan();
checkBotSchedulePlan.Id = searchSchedulePlanId;
checkBotSchedulePlan.Name = "Search Index";
checkBotSchedulePlan.Type = SchedulePlanType.Interval;
checkBotSchedulePlan.StartDate = new DateTime(utcNow.Year, utcNow.Month, utcNow.Day, 0, 0, 2, DateTimeKind.Utc);
checkBotSchedulePlan.EndDate = null;
checkBotSchedulePlan.ScheduledDays = new SchedulePlanDaysOfWeek()
{
ScheduledOnMonday = true,
ScheduledOnTuesday = true,
ScheduledOnWednesday = true,
ScheduledOnThursday = true,
ScheduledOnFriday = true,
ScheduledOnSaturday = true,
ScheduledOnSunday = true
};
checkBotSchedulePlan.IntervalInMinutes = 60;
checkBotSchedulePlan.StartTimespan = 0;
checkBotSchedulePlan.EndTimespan = 0;
checkBotSchedulePlan.JobTypeId = new Guid("4E02D675-D02A-4211-837E-46C99A4CDE07");
checkBotSchedulePlan.JobAttributes = null;
checkBotSchedulePlan.Enabled = true;
checkBotSchedulePlan.LastModifiedBy = null;
ScheduleManager.Current.CreateSchedulePlan(checkBotSchedulePlan);
}
}
#endregion
}
private static OutputSchedulePlan OutputSchedulePlanConvert(SchedulePlan src)
{
if (src == null)
{
return(null);
}
OutputSchedulePlan outSchedulePlan = new OutputSchedulePlan();
outSchedulePlan.Id = src.Id;
outSchedulePlan.Name = src.Name;
outSchedulePlan.Type = src.Type;
outSchedulePlan.StartDate = src.StartDate;
outSchedulePlan.EndDate = src.EndDate;
outSchedulePlan.ScheduledDays = src.ScheduledDays;
outSchedulePlan.IntervalInMinutes = src.IntervalInMinutes;
if (src.StartTimespan.HasValue)
{
var startTimespan = new DateTime(1900, 1, 1, 0, 0, 0, DateTimeKind.Utc);
outSchedulePlan.StartTimespan = startTimespan.AddMinutes(src.StartTimespan.Value);
}
if (src.EndTimespan.HasValue)
{
var endTimespan = new DateTime(1900, 1, 1, 0, 0, 0, DateTimeKind.Utc);
outSchedulePlan.EndTimespan = endTimespan.AddMinutes(src.EndTimespan.Value);
}
outSchedulePlan.LastTriggerTime = src.LastTriggerTime;
outSchedulePlan.NextTriggerTime = src.NextTriggerTime;
outSchedulePlan.JobTypeId = src.JobTypeId;
outSchedulePlan.JobAttributes = src.JobAttributes;
outSchedulePlan.Enabled = src.Enabled;
outSchedulePlan.LastStartedJobId = src.LastStartedJobId;
outSchedulePlan.CreatedOn = src.CreatedOn;
outSchedulePlan.LastModifiedBy = src.LastModifiedBy;
outSchedulePlan.LastModifiedOn = src.LastModifiedOn;
return(outSchedulePlan);
}
/// <summary>
/// Gibt einen Plan aus.
/// </summary>
/// <param name="plan">Der zu verwendende Plan.</param>
/// <returns>Alle Aufzeichnungen, geordnet erst nach Zeit und dann nach der Priorität des Gerätes.</returns>
private IEnumerable<ScheduleInfo> Dump( SchedulePlan plan )
{
// Skip
if (plan == null)
yield break;
#if !SILVERLIGHT
// Dump decryption allocation
if (SchedulerTrace.TraceVerbose)
foreach (var decryption in plan.DecryptionCounters.Values)
if (decryption.IsEnabled)
Trace.TraceInformation( Properties.SchedulerResources.Trace_Decryption, decryption );
#endif
// Artifical dump
foreach (var info in plan.GetRecordings())
if (!m_ForbiddenDefinitions.Contains( info.Definition.UniqueIdentifier ))
{
#if !SILVERLIGHT
// Trace
if (SchedulerTrace.TraceInfo)
{
// Check type
var definition = info.Definition as IRecordingDefinition;
// Report
Trace.TraceInformation
(
info.StartsLate ? Properties.SchedulerResources.Trace_LateItem : Properties.SchedulerResources.Trace_NormalItem,
info.Resource,
(definition == null) ? null : definition.Source,
info.Time.Start,
info.Time.Duration
);
}
#endif
// Report
yield return info;
}
}
/// <summary>
/// Erzeugt eine passende Planungskomponente.
/// </summary>
/// <param name="excludeActiveRecordings">Gesetzt um alle bereits aktiven Aufzeichnungen auszublenden.</param>
/// <returns>Die zur aktuellen Reservierung passende Planungskomponente.</returns>
public RecordingScheduler CreateScheduler( bool excludeActiveRecordings = true )
{
// Time to create plan
if (m_CurrentPlan == null)
if ((m_CurrentPlan = CreateSchedulePlan()) == null)
throw new NotSupportedException( "CreateScheduler" );
// Create exclusion map
var alreadyActive = new HashSet<Guid>( excludeActiveRecordings ? m_Recordings.Select( r => r.UniqueIdentifier ) : Enumerable.Empty<Guid>() );
// Process
return new RecordingScheduler( m_Resources, alreadyActive, () => m_CurrentPlan, m_PlanComparer );
}
/// <summary>
/// Aktiviert eine Aufzeichnung auf einem Gerät.
/// </summary>
/// <param name="resource">Eines der verwalteten Geräte.</param>
/// <param name="source">Optional eine Quelle, die auf dem Gerät angesteuert werden kann.</param>
/// <param name="scheduleIdentifier">Die eindeutige Kennung der Aufzeichnung.</param>
/// <param name="scheduleName">Der Anzeigename der Aufzeichnung.</param>
/// <param name="plannedStart">Der ursprüngliche Start der Aufzeichnung in UTC / GMT Notation.</param>
/// <param name="currentEnd">Das aktuelle Ende der Aufzeichnung in UTC / GMT Notation.</param>
/// <returns>Gesetzt, wenn die Aufzeichnung auf dem gewünschten Gerät aktiviert werden kann.</returns>
/// <exception cref="ArgumentNullException">Es wurde kein Gerät angegeben.</exception>
/// <exception cref="ArgumentException">Das Gerät ist nicht bekannt oder kann die Quelle nicht empfangen.</exception>
/// <exception cref="ArgumentOutOfRangeException">Die Laufzeit der Aufzeichnung ist nicht positiv.</exception>
public bool Start( IScheduleResource resource, IScheduleSource source, Guid scheduleIdentifier, string scheduleName, DateTime plannedStart, DateTime currentEnd )
{
// Validate
if (resource == null)
throw new ArgumentNullException( "resource" );
if (!m_Resources.Contains( resource ))
throw new ArgumentException( resource.Name, "resource" );
if (plannedStart >= currentEnd)
throw new ArgumentOutOfRangeException( "currentEnd" );
if (m_Recordings.Any( r => r.UniqueIdentifier == scheduleIdentifier ))
throw new ArgumentException( "resource" );
// Create helper entry
m_Recordings.Add( new ResourceAllocationInformation( resource, source, scheduleIdentifier, scheduleName, plannedStart, currentEnd - plannedStart ) );
// May require cleanup
try
{
// Create the new plan
var plan = CreateSchedulePlan();
// Did it
if (plan != null)
{
// Remember as current
m_CurrentPlan = plan;
// Report
return true;
}
}
catch
{
// Cleanup
m_Recordings.RemoveAt( m_Recordings.Count - 1 );
// Report
throw;
}
// Cleanup
m_Recordings.RemoveAt( m_Recordings.Count - 1 );
// Add to list
return false;
}
public static DateTime GetWorkTime(DateTime startTime, string ventureId)
{
WorkCenterCalendar noWorkCalender = SchedulePlan.GetEntity().WorkCenterCalendar.Where(p => DbFunctions.TruncateTime(p.NoWorkBeginDate) <= startTime && DbFunctions.TruncateTime(p.NoWorkEndDate) >= startTime).FirstOrDefault();
DateTime workTime;
if (noWorkCalender != null)
{
workTime = (DateTime)noWorkCalender.NoWorkEndDate;
}
else
{
workTime = startTime;
}
List <Venture_Shift> vfList = SchedulePlan.GetEntity().Venture_Shift.Where(p => p.VentureId == ventureId).ToList();
if (!vfList.Any())
{
Venture v = SchedulePlan.GetEntity().Venture.Where(p => p.VentureId == ventureId).FirstOrDefault();
throw new Exception(v.VentureName + "(" + v.VentureId + ")" + "经营体与工厂日历关系未维护！");
}
var shiftIdList = vfList.Select(p => p.ShiftId).ToList();
var shiftList = SchedulePlan.GetEntity().Shift.Where(p => shiftIdList.Contains(p.ShiftId)).ToList();
var minTimeFrom = shiftList.Max(p => p.TimeFrom);
Shift shift = shiftList.Where(p => p.TimeFrom == minTimeFrom).FirstOrDefault();
if (shift == null)
{
throw new Exception("工厂日历未维护！");
}
string[] minsecond = shift.TimeFrom.Split(new char[] { ':' });
DateTime workStartTime = new DateTime(startTime.Year, startTime.Month, startTime.Day, int.Parse(minsecond[0]), int.Parse(minsecond[1]), 0);
DateTime workEndTime = workStartTime.AddMinutes(Convert.ToDouble(shift.TimeRange));
if (workTime < workStartTime || workTime > workEndTime)
{
workTime = workStartTime.AddDays(1);
noWorkCalender = SchedulePlan.GetEntity().WorkCenterCalendar.Where(p => DbFunctions.TruncateTime(p.NoWorkBeginDate) >= workTime || DbFunctions.TruncateTime(p.NoWorkEndDate) <= workTime).FirstOrDefault();
if (noWorkCalender != null)
{
TimeSpan?ts = noWorkCalender.NoWorkEndDate - noWorkCalender.NoWorkBeginDate;
int day = ((TimeSpan)ts).Days;
workTime = workStartTime.AddDays(day + 1);
}
}
//return
return(workTime);
}
/// <summary>
/// Beendet eine Aufzeichnung auf einem Gerät.
/// </summary>
/// <param name="scheduleIdentifier">Die eindeutige Kennung der Aufzeichnung.</param>
public void Stop( Guid scheduleIdentifier )
{
// Locate and validate
var index = this.FindIndex( scheduleIdentifier );
// Keep current recording settings
var recording = m_Recordings[index];
// Remove it
m_Recordings.RemoveAt( index );
// Create a new plan
try
{
// Get the plan - should NEVER fail or we are in BIG trouble
var plan = CreateSchedulePlan();
if (plan == null)
throw new InvalidOperationException( "Stop" );
// Remember the new situation
m_CurrentPlan = plan;
}
catch
{
// Recover
m_Recordings.Insert( index, recording );
// Forward
throw;
}
}
private static SchedulePlan SchedulePlanConvert(DataRow src)
{
if (src == null)
{
return(null);
}
SchedulePlan schedulePlan = new SchedulePlan();
schedulePlan.Id = (Guid)src["id"];
schedulePlan.Name = (string)src["name"];
schedulePlan.Type = (SchedulePlanType)src["type"];
if (src["start_date"] != DBNull.Value)
{
schedulePlan.StartDate = (DateTime)src["start_date"];
}
if (src["end_date"] != DBNull.Value)
{
schedulePlan.EndDate = (DateTime)src["end_date"];
}
schedulePlan.ScheduledDays = JsonConvert.DeserializeObject <SchedulePlanDaysOfWeek>((string)src["schedule_days"]);
if (src["interval_in_minutes"] != DBNull.Value)
{
schedulePlan.IntervalInMinutes = (int)src["interval_in_minutes"];
}
if (src["start_timespan"] != DBNull.Value)
{
schedulePlan.StartTimespan = (int)src["start_timespan"];
}
if (src["end_timespan"] != DBNull.Value)
{
schedulePlan.EndTimespan = (int)src["end_timespan"];
}
if (src["last_trigger_time"] != DBNull.Value)
{
schedulePlan.LastTriggerTime = (DateTime)src["last_trigger_time"];
}
if (src["next_trigger_time"] != DBNull.Value)
{
schedulePlan.NextTriggerTime = (DateTime)src["next_trigger_time"];
}
schedulePlan.JobTypeId = (Guid)src["job_type_id"];
if (JobManager.JobTypes.Any(t => t.Id == schedulePlan.JobTypeId))
{
schedulePlan.JobType = JobManager.JobTypes.FirstOrDefault(t => t.Id == schedulePlan.JobTypeId);
}
if (!string.IsNullOrWhiteSpace(src["job_attributes"].ToString()))
{
schedulePlan.JobAttributes = JsonConvert.DeserializeObject <ExpandoObject>((string)src["job_attributes"]);
}
schedulePlan.Enabled = (bool)src["enabled"];
if (src["last_started_job_id"] != DBNull.Value)
{
schedulePlan.LastStartedJobId = (Guid)src["last_started_job_id"];
}
schedulePlan.CreatedOn = (DateTime)src["created_on"];
if (src["last_modified_by"] != DBNull.Value)
{
schedulePlan.LastModifiedBy = (Guid)src["last_modified_by"];
}
schedulePlan.LastModifiedOn = (DateTime)src["last_modified_on"];
return(schedulePlan);
}
private static SchedulePlan SchedulePlanConvert(DataRow src)
{
if (src == null)
{
return(null);
}
JsonSerializerSettings settings = new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.All
};
SchedulePlan schedulePlan = new SchedulePlan();
schedulePlan.Id = (Guid)src["id"];
schedulePlan.Name = (string)src["name"];
schedulePlan.Type = (SchedulePlanType)src["type"];
if (src["start_date"] != DBNull.Value)
{
schedulePlan.StartDate = DateTime.SpecifyKind((DateTime)src["start_date"], DateTimeKind.Utc);
}
if (src["end_date"] != DBNull.Value)
{
schedulePlan.EndDate = DateTime.SpecifyKind((DateTime)src["end_date"], DateTimeKind.Utc);
}
schedulePlan.ScheduledDays = JsonConvert.DeserializeObject <SchedulePlanDaysOfWeek>((string)src["schedule_days"], settings);
if (src["interval_in_minutes"] != DBNull.Value)
{
schedulePlan.IntervalInMinutes = (int)src["interval_in_minutes"];
}
if (src["start_timespan"] != DBNull.Value)
{
schedulePlan.StartTimespan = (int)src["start_timespan"];
}
if (src["end_timespan"] != DBNull.Value)
{
schedulePlan.EndTimespan = (int)src["end_timespan"];
}
if (src["last_trigger_time"] != DBNull.Value)
{
schedulePlan.LastTriggerTime = DateTime.SpecifyKind((DateTime)src["last_trigger_time"], DateTimeKind.Utc);
}
if (src["next_trigger_time"] != DBNull.Value)
{
schedulePlan.NextTriggerTime = DateTime.SpecifyKind((DateTime)src["next_trigger_time"], DateTimeKind.Utc);
}
schedulePlan.JobTypeId = (Guid)src["job_type_id"];
if (JobManager.JobTypes.Any(t => t.Id == schedulePlan.JobTypeId))
{
schedulePlan.JobType = JobManager.JobTypes.FirstOrDefault(t => t.Id == schedulePlan.JobTypeId);
}
//else
// throw new Exception($"JobType with id='{schedulePlan.JobTypeId}' not found.");
if (!string.IsNullOrWhiteSpace(src["job_attributes"].ToString()))
{
schedulePlan.JobAttributes = JsonConvert.DeserializeObject <ExpandoObject>((string)src["job_attributes"], settings);
}
schedulePlan.Enabled = (bool)src["enabled"];
if (src["last_started_job_id"] != DBNull.Value)
{
schedulePlan.LastStartedJobId = (Guid)src["last_started_job_id"];
}
schedulePlan.CreatedOn = DateTime.SpecifyKind((DateTime)src["created_on"], DateTimeKind.Utc);
if (src["last_modified_by"] != DBNull.Value)
{
schedulePlan.LastModifiedBy = (Guid)src["last_modified_by"];
}
schedulePlan.LastModifiedOn = DateTime.SpecifyKind((DateTime)src["last_modified_on"], DateTimeKind.Utc);
return(schedulePlan);
}
public void SetSchedulePlans()
{
DateTime utcNow = DateTime.UtcNow;
#region << Sample Job Plan >>
//{
// Guid checkBotSchedulePlanId = new Guid("AC3D460F-77BD-44B6-A7C5-B52A37A0C846");
// string planName = "Sample Job Plan";
// SchedulePlan checkBotSchedulePlan = ScheduleManager.Current.GetSchedulePlan(checkBotSchedulePlanId);
// if (checkBotSchedulePlan == null)
// {
// checkBotSchedulePlan = new SchedulePlan();
// checkBotSchedulePlan.Id = checkBotSchedulePlanId;
// checkBotSchedulePlan.Name = planName;
// checkBotSchedulePlan.Type = SchedulePlanType.Daily;
// checkBotSchedulePlan.StartDate = new DateTime(utcNow.Year, utcNow.Month, utcNow.Day, 0, 0, 2, DateTimeKind.Utc);
// checkBotSchedulePlan.EndDate = null;
// checkBotSchedulePlan.ScheduledDays = new SchedulePlanDaysOfWeek()
// {
// ScheduledOnMonday = true,
// ScheduledOnTuesday = true,
// ScheduledOnWednesday = true,
// ScheduledOnThursday = true,
// ScheduledOnFriday = true,
// ScheduledOnSaturday = true,
// ScheduledOnSunday = true
// };
// checkBotSchedulePlan.IntervalInMinutes = 1440;
// checkBotSchedulePlan.StartTimespan = 0;
// checkBotSchedulePlan.EndTimespan = 1440;
// checkBotSchedulePlan.JobTypeId = new Guid("559c557a-0fd3-4235-b061-117197154ca5");
// checkBotSchedulePlan.JobAttributes = null;
// checkBotSchedulePlan.Enabled = true;
// checkBotSchedulePlan.LastModifiedBy = null;
// ScheduleManager.Current.CreateSchedulePlan(checkBotSchedulePlan);
// }
//}
#endregion
#region << Clear job and error logs Job Plan>>
{
Guid logsSchedulePlanId = new Guid("8CC1DF20-0967-4635-B44A-45FD90819105");
SchedulePlan logsSchedulePlan = ScheduleManager.Current.GetSchedulePlan(logsSchedulePlanId);
if (logsSchedulePlan == null)
{
logsSchedulePlan = new SchedulePlan();
logsSchedulePlan.Id = logsSchedulePlanId;
logsSchedulePlan.Name = "Clear job and error logs.";
logsSchedulePlan.Type = SchedulePlanType.Daily;
logsSchedulePlan.StartDate = new DateTime(utcNow.Year, utcNow.Month, utcNow.Day, 0, 0, 2, DateTimeKind.Utc);
logsSchedulePlan.EndDate = null;
logsSchedulePlan.ScheduledDays = new SchedulePlanDaysOfWeek()
{
ScheduledOnMonday = true,
ScheduledOnTuesday = true,
ScheduledOnWednesday = true,
ScheduledOnThursday = true,
ScheduledOnFriday = true,
ScheduledOnSaturday = true,
ScheduledOnSunday = true
};
logsSchedulePlan.IntervalInMinutes = 1440;
logsSchedulePlan.StartTimespan = 0;
logsSchedulePlan.EndTimespan = 1440;
logsSchedulePlan.JobTypeId = new Guid("99D9A8BB-31E6-4436-B0C2-20BD6AA23786");
logsSchedulePlan.JobAttributes = null;
logsSchedulePlan.Enabled = true;
logsSchedulePlan.LastModifiedBy = null;
ScheduleManager.Current.CreateSchedulePlan(logsSchedulePlan);
}
}
#endregion
}
/// <summary>
/// Verändert eine Aufzeichnung.
/// </summary>
/// <param name="scheduleIdentifier">Die eindeutige Kennung der Aufzeichnung.</param>
/// <param name="newEnd">Der neue Endzeitpunkt der Aufzeichnung.</param>
/// <returns>Gesetzt, wenn die Veränderung möglich ist.</returns>
public bool Modify( Guid scheduleIdentifier, DateTime newEnd )
{
// Locate and validate
var index = this.FindIndex( scheduleIdentifier );
// Keep current recording settings
var recording = m_Recordings[index];
// Validate
if (newEnd <= recording.Time.Start)
throw new ArgumentOutOfRangeException( "newEnd" );
// Remove it
m_Recordings[index] = new ResourceAllocationInformation( recording.Resource, recording.Source, recording.UniqueIdentifier, recording.Name, recording.Time.Start, newEnd - recording.Time.Start );
// Create a new plan
try
{
// Try to apply the change
var plan = CreateSchedulePlan();
if (plan != null)
{
// Remember the new situation
m_CurrentPlan = plan;
// Confirm
return true;
}
}
catch
{
// Recover
m_Recordings[index] = recording;
// Forward
throw;
}
// Recover
m_Recordings[index] = recording;
// Back to normal
return false;
}
