public async Task <CommandResult> Handle(RecalculateExecutionScheduleCommand request, CancellationToken cancellationToken)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
ExecutionSchedule schedule = await _entitiesRepository.GetFirstOrDefaultAsync <ExecutionSchedule>(st => st.Name == request.Name);
if (schedule == null)
{
throw new InvalidExecutionScheduleException("Execution Schedule with name " + request.Name + " is invalid.");
}
var executionScheduleLock = await _node.Handle(new RequestDataShard()
{
Type = schedule.ShardType,
ObjectId = schedule.Id,
CreateLock = true,
LockTimeoutMs = 10000
});
ExecutionSchedule existingValue;
if (executionScheduleLock.IsSuccessful && executionScheduleLock.AppliedLocked)
{
existingValue = (ExecutionSchedule)executionScheduleLock.Data;
existingValue.UpdateJournal(new Domain.Entities.JournalEntries.JournalEntry()
{
CreatedOn = DateTime.UtcNow,
Updates = new List <Domain.ValueObjects.Update>()
{
new Update()
{
Type = UpdateType.Override,
FieldName = "nextrun",
Value = SchedulerUtility.NextOccurence(existingValue.Schedule, DateTime.UtcNow)
}
}
});
var result = await _node.Handle(new AddShardWriteOperation()
{
Operation = ConsensusCore.Domain.Enums.ShardOperationOptions.Update,
WaitForSafeWrite = true,
Data = existingValue,
RemoveLock = true
});
}
stopwatch.Stop();
return(new CommandResult <ExecutionSchedule>()
{
ObjectRefId = schedule.Id.ToString(),
ElapsedMs = stopwatch.ElapsedMilliseconds,
Type = CommandResultTypes.Update,
Result = schedule
});
}
private void ReservationStateTester(int resourceId, int reserverClientId, int currentClientId, int inviteeClientId, int activityId, DateTime beginDateTime, int duration, bool inlab, bool canDelete, bool canModify)
{
var now = DateTime.Now;
DateTime endDateTime = beginDateTime.AddMinutes(duration);
IReservationItem rsv = GetMockReservation(123456, resourceId, reserverClientId, activityId, beginDateTime, endDateTime, null, null);
ReservationStateArgs args = GetReservationStateArgs(rsv, currentClientId, inviteeClientId, inlab, now);
ReservationState state = ReservationStateUtility.Create(now).GetReservationState(args);
bool actual;
actual = SchedulerUtility.CanDeleteReservation(state, args, now);
Assert.AreEqual(canDelete, actual);
actual = SchedulerUtility.CanModifyReservation(state, args, now);
Assert.AreEqual(canModify, actual);
}
public void ProcessRequest(HttpContext context)
{
HttpContextBase ctx = new HttpContextWrapper(context);
SchedulerContextHelper helper = GetContextHelper(ctx);
string command = GetCommand(ctx);
ViewType currentView = GetView(ctx);
ctx.SetCurrentViewType(currentView);
IClient currentUser = helper.CurrentUser();
string redirectUrl;
var util = SchedulerUtility.Create(Provider);
helper.AppendLog($"ReservationController.ProcessRequest: url = {ctx.Request.Url}");
try
{
ctx.Session.Remove("ErrorMessage");
if (command == "ReservationAction")
{
redirectUrl = GetReservationAction(ctx);
}
else
{
IReservationItem rsv;
IResource res;
switch (command)
{
case "ChangeHourRange":
string range = ctx.Request.QueryString["Range"];
helper.AppendLog($"ReservationController.ProcessRequest: range = {range}");
if (range == "FullDay")
{
ctx.SetDisplayDefaultHours(false);
}
else
{
ctx.SetDisplayDefaultHours(true);
}
redirectUrl = util.GetReservationViewReturnUrl(currentView);
break;
case "NewReservation":
var canCreate = CanCreateNewReservation(ctx);
helper.AppendLog($"ReservationController.ProcessRequest: canCreate = {canCreate}");
if (canCreate)
{
redirectUrl = SchedulerUtility.GetReservationReturnUrl(ctx.Request.SelectedPath(), ctx.Request.SelectedLocationPath(), 0, ctx.Request.SelectedDate(), GetReservationTime(ctx), currentView);
}
else
{
redirectUrl = util.GetReservationViewReturnUrl(currentView);
}
break;
case "ModifyReservation":
rsv = helper.GetReservationWithInvitees();
res = helper.GetResourceTreeItemCollection().GetResource(rsv.ResourceID);
var currentDate = ctx.Request.SelectedDate();
var currentTime = GetReservationTime(ctx);
redirectUrl = SchedulerUtility.GetReservationReturnUrl(PathInfo.Create(res), ctx.Request.SelectedLocationPath(), rsv.ReservationID, currentDate, currentTime, currentView);
break;
case "DeleteReservation":
rsv = helper.GetReservationWithInvitees();
Reservations.Create(Provider, DateTime.Now).Delete(rsv, currentUser.ClientID);
redirectUrl = util.GetReservationViewReturnUrl(currentView);
break;
default:
throw new NotImplementedException($"Command not implemented: {command}");
}
}
}
catch (Exception ex)
{
string errmsg = ex.Message;
ctx.Session["ErrorMessage"] = errmsg;
helper.AppendLog($"ReservationController.ProcessRequest: errmsg = {errmsg}");
try
{
redirectUrl = util.GetReservationViewReturnUrl(currentView);
}
catch
{
redirectUrl = string.Empty;
}
}
if (string.IsNullOrEmpty(redirectUrl))
{
redirectUrl = "~";
}
helper.AppendLog($"ReservationController.ProcessRequest: redirectUrl = {redirectUrl}");
ctx.Response.Redirect(redirectUrl);
}
public string GetReservationAction(HttpContextBase context)
{
SchedulerContextHelper helper = GetContextHelper(context);
context.Session.Remove("ActiveReservationMessage");
context.Session.Remove("ShowStartConfirmationDialog");
var now = DateTime.Now;
var util = Reservations.Create(Provider, now);
var requestedState = GetReservationState(context);
var rsv = helper.GetReservation();
var res = helper.GetResource(rsv.ResourceID);
var client = helper.GetReservationClient(rsv);
var args = ReservationStateArgs.Create(rsv, client, now);
var state = ReservationStateUtility.Create(now).GetReservationState(args);
var currentView = GetView(context);
var currentUser = context.CurrentUser(Provider);
bool confirm = false;
int reservationId = 0;
helper.AppendLog($"ReservationController.GetReservationAction: reservationId = {rsv.ReservationID}, requestedState = {requestedState}, state = {state}, currentView = {currentView}");
switch (requestedState)
{
case ReservationState.StartOnly:
case ReservationState.StartOrDelete:
// If there are previous unended reservations, then ask for confirmation
var endable = Provider.Scheduler.Reservation.SelectEndableReservations(rsv.ResourceID);
if (endable.Count() > 0)
{
var endableReservations = string.Join(",", endable.Select(x => x.ReservationID));
context.Session["ActiveReservationMessage"] = $"[Previous ReservationID: {endableReservations}, Current ReservationID: {rsv.ReservationID}]";
confirm = true;
reservationId = rsv.ReservationID;
}
else
{
util.Start(rsv, helper.GetReservationClient(rsv), currentUser.ClientID);
}
break;
case ReservationState.Endable:
// End reservation
if (state == ReservationState.Endable)
{
util.End(rsv, DateTime.Now, currentUser.ClientID);
}
else
{
string actualBeginDateTime = rsv.ActualBeginDateTime.HasValue ? rsv.ActualBeginDateTime.Value.ToString("yyyy-MM-dd HH:mm:ss") : "null";
throw new InvalidOperationException($"ReservationID {rsv.ReservationID} state is {state}, not Endable. ActualBeginDateTime: {actualBeginDateTime}");
}
break;
case ReservationState.PastSelf:
if (currentView == ViewType.DayView || currentView == ViewType.WeekView)
{
context.SetWeekStartDate(rsv.BeginDateTime.Date);
}
return(SchedulerUtility.GetReturnUrl("ReservationRunNotes.aspx", PathInfo.Create(res), context.Request.SelectedLocationPath(), rsv.ReservationID, context.Request.SelectedDate()));
case ReservationState.Other:
case ReservationState.Invited:
case ReservationState.PastOther:
return(SchedulerUtility.GetReturnUrl("Contact.aspx", PathInfo.Create(res), context.Request.SelectedLocationPath(), rsv.ReservationID, context.Request.SelectedDate()));
default:
// invalid state detected!
// throw new NotImplementedException($"ReservationState = {state} is not implemented");
context.Session["ErrorMessage"] = $"The current reservation state, {state}, is invalid. No actions are defined for this state. [RequestedState = {requestedState}, ReservationID = {reservationId}]";
var vars = new Dictionary <string, object>
{
["current state"] = state,
["requested state"] = requestedState,
["reservationId"] = reservationId,
["tool_engineer"] = args.IsToolEngineer,
["inlab"] = args.IsInLab,
["reserver"] = args.IsReserver,
["invited"] = args.IsInvited,
["authorized"] = args.IsAuthorized,
["before_mct"] = args.IsBeforeMinCancelTime(),
["startable"] = args.IsStartable()
};
helper.SendDebugEmail("ReservationController.GetReservationAction", "Invalid state detected!", "Invalid state detected!", vars);
return(SchedulerUtility.Create(Provider).GetReservationViewReturnUrl(currentView, false, reservationId));
}
string result = SchedulerUtility.Create(Provider).GetReservationViewReturnUrl(currentView, confirm, reservationId);
return(result);
}
/// <summary>
/// Gets http authentication.
/// </summary>
/// <returns>PSHttpJobAuthenticationParams instance.</returns>
private PSHttpJobAuthenticationParams GetAuthenticationParams()
{
if (!string.IsNullOrWhiteSpace(this.HttpAuthenticationType))
{
var jobAuthentication = new PSHttpJobAuthenticationParams()
{
HttpAuthType = this.HttpAuthenticationType,
ClientCertPfx = string.IsNullOrWhiteSpace(this.JobDynamicParameters.ClientCertificatePfx) ? null : SchedulerUtility.GetCertData(this.ResolvePath(JobDynamicParameters.ClientCertificatePfx), JobDynamicParameters.ClientCertificatePassword),
ClientCertPassword = this.JobDynamicParameters.ClientCertificatePassword,
Username = this.JobDynamicParameters.BasicUsername,
Password = this.JobDynamicParameters.BasicPassword,
Secret = this.JobDynamicParameters.OAuthSecret,
Tenant = this.JobDynamicParameters.OAuthTenant,
Audience = this.JobDynamicParameters.OAuthAudience,
ClientId = this.JobDynamicParameters.OAuthClientId
};
return(jobAuthentication);
}
return(null);
}
public async Task <CommandResult> Handle(UpdateExecutionScheduleCommand request, CancellationToken cancellationToken)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
ExecutionSchedule schedule = await _entitiesRepository.GetFirstOrDefaultAsync <ExecutionSchedule>(st => st.Name == request.Name);
if (schedule == null)
{
throw new InvalidExecutionScheduleException("Execution Schedule with name " + request.Name + " is invalid.");
}
if (request.Schedule != null)
{
foreach (var scheduleString in request.Schedule)
{
var isValid = SchedulerUtility.IsValidScheduleString(scheduleString);
if (!isValid)
{
throw new InvalidExecutionScheduleException("Schedule " + scheduleString + " is invalid.");
}
}
}
var executionScheduleLock = await _node.Handle(new RequestDataShard()
{
Type = schedule.ShardType,
ObjectId = schedule.Id,
CreateLock = true
});
ExecutionSchedule existingValue;
List <Update> updates = new List <Update>();
if (request.IsDisabled != null && schedule.IsDisabled != request.IsDisabled)
{
updates.Add(new Update()
{
Type = UpdateType.Override,
FieldName = "isdisabled",
Value = request.IsDisabled
});
}
if (request.Schedule != null && schedule.Schedule != request.Schedule)
{
updates.Add(new Update()
{
Type = UpdateType.Override,
FieldName = "nextrun",
Value = SchedulerUtility.NextOccurence(request.Schedule, DateTime.UtcNow)
});
updates.Add(new Update()
{
Type = UpdateType.Override,
FieldName = "schedule",
Value = request.Schedule
});
}
if (request.Description != null && schedule.Description != request.Description)
{
updates.Add(new Update()
{
Type = UpdateType.Override,
FieldName = "description",
Value = request.Description
});
}
if (executionScheduleLock.IsSuccessful && executionScheduleLock.AppliedLocked && updates.Count > 0)
{
existingValue = (ExecutionSchedule)executionScheduleLock.Data;
existingValue.UpdateJournal(new Domain.Entities.JournalEntries.JournalEntry()
{
CreatedOn = DateTime.UtcNow,
Updates = updates
});
var result = await _node.Handle(new AddShardWriteOperation()
{
Operation = ConsensusCore.Domain.Enums.ShardOperationOptions.Update,
WaitForSafeWrite = true,
Data = existingValue,
RemoveLock = true
});
}
stopwatch.Stop();
return(new CommandResult <ExecutionSchedule>()
{
ObjectRefId = schedule.Id.ToString(),
ElapsedMs = stopwatch.ElapsedMilliseconds,
Type = CommandResultTypes.Update,
Result = schedule
});
}
public async Task <CommandResult> Handle(CreateExecutionScheduleCommand request, CancellationToken cancellationToken)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
ExecutionSchedule schedule = await _entitiesRepository.GetFirstOrDefaultAsync <ExecutionSchedule>(st => st.Name == request.Name);
if (schedule != null)
{
throw new InvalidExecutionScheduleException("Execution Schedule with name " + request.Name + " is invalid.");
}
ExecutionTemplate template = await _entitiesRepository.GetFirstOrDefaultAsync <ExecutionTemplate>(st => st.Name == request.ExecutionTemplateName);
if (template == null)
{
throw new InvalidExecutionScheduleException("Execution Template with name " + request.ExecutionTemplateName + " is invalid.");
}
foreach (var scheduleString in request.Schedule)
{
var isValid = SchedulerUtility.IsValidScheduleString(scheduleString);
if (!isValid)
{
throw new InvalidExecutionScheduleException("Schedule " + scheduleString + " is invalid.");
}
}
var executionSchedule = new ExecutionSchedule(
Guid.NewGuid(),
request.Name,
request.ExecutionTemplateName,
request.Description,
request.CreatedBy,
request.Schedule,
SchedulerUtility.NextOccurence(request.Schedule)
);
var executionScheduleResponse = await _node.Handle(new AddShardWriteOperation()
{
Data = executionSchedule,
WaitForSafeWrite = true,
Operation = ConsensusCore.Domain.Enums.ShardOperationOptions.Create
});
if (request.RunImmediately)
{
await _mediator.Send(new ExecuteExecutionTemplateCommand()
{
CreatedBy = request.CreatedBy,
ExecutionScheduleId = executionSchedule.Id,
Name = executionSchedule.ExecutionTemplateName
});
}
stopwatch.Stop();
return(new CommandResult <ExecutionSchedule>()
{
ObjectRefId = executionSchedule.Id.ToString(),
ElapsedMs = stopwatch.ElapsedMilliseconds,
Type = CommandResultTypes.Create,
Result = executionSchedule
});
}
public void CanShowLabCleanWarning()
{
bool isLabCleanTime;
DateTime beginDateTime;
DateTime endDateTime;
using (StartUnitOfWork())
{
// Monday
beginDateTime = DateTime.Parse("2020-09-14 08:00:00");
endDateTime = DateTime.Parse("2020-09-14 10:00:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsTrue(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-14 07:00:00");
endDateTime = DateTime.Parse("2020-09-14 08:00:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsFalse(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-14 07:00:00");
endDateTime = DateTime.Parse("2020-09-14 08:30:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsFalse(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-14 07:00:00");
endDateTime = DateTime.Parse("2020-09-14 08:35:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsTrue(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-14 10:15:00");
endDateTime = DateTime.Parse("2020-09-14 11:15:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsFalse(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-14 10:10:00");
endDateTime = DateTime.Parse("2020-09-14 11:15:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsTrue(isLabCleanTime);
// Thursday
beginDateTime = DateTime.Parse("2020-09-17 08:00:00");
endDateTime = DateTime.Parse("2020-09-17 10:00:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsTrue(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-17 07:00:00");
endDateTime = DateTime.Parse("2020-09-17 08:00:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsFalse(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-17 07:00:00");
endDateTime = DateTime.Parse("2020-09-17 08:30:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsFalse(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-17 07:00:00");
endDateTime = DateTime.Parse("2020-09-17 08:35:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsTrue(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-17 10:15:00");
endDateTime = DateTime.Parse("2020-09-17 11:15:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsFalse(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-17 10:10:00");
endDateTime = DateTime.Parse("2020-09-17 11:15:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsTrue(isLabCleanTime);
// Wednesday
beginDateTime = DateTime.Parse("2020-09-16 07:00:00");
endDateTime = DateTime.Parse("2020-09-16 19:00:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsFalse(isLabCleanTime);
// Multi-day
beginDateTime = DateTime.Parse("2020-09-16 23:00:00");
endDateTime = DateTime.Parse("2020-09-17 08:35:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsTrue(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-16 23:00:00");
endDateTime = DateTime.Parse("2020-09-17 08:30:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsFalse(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-18 23:00:00");
endDateTime = DateTime.Parse("2020-09-21 08:35:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsTrue(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-18 23:00:00");
endDateTime = DateTime.Parse("2020-09-21 08:30:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsFalse(isLabCleanTime);
// Holiday
beginDateTime = DateTime.Parse("2020-09-08 07:00:00");
endDateTime = DateTime.Parse("2020-09-08 08:35:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsTrue(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-08 10:10:00");
endDateTime = DateTime.Parse("2020-09-09 08:00:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsTrue(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-08 10:15:00");
endDateTime = DateTime.Parse("2020-09-09 08:00:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsFalse(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-06 08:15:00");
endDateTime = DateTime.Parse("2020-09-07 10:00:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsFalse(isLabCleanTime);
beginDateTime = DateTime.Parse("2020-09-07 08:0:00");
endDateTime = DateTime.Parse("2020-09-07 11:00:00");
isLabCleanTime = SchedulerUtility.Create(Provider).ShowLabCleanWarning(beginDateTime, endDateTime);
Assert.IsFalse(isLabCleanTime);
}
}
