private static void UpdateReservationHistory(AssetInventoryContext context, AssetReservation reservation)
{
ReservationHistory history = context.ReservationHistory
.OrderByDescending(n => n.ReservationHistoryId)
.FirstOrDefault(n => n.AssetId == reservation.AssetId && n.Start == reservation.Start);
if (history != null && DateTime.Now < history.End)
{
history.End = DateTime.Now;
}
}
public void UpdateEntity(AssetReservation item)
{
item.AssetId = AssetId;
item.End = DateTime.Parse(End);
item.AssetReservationId = ReservationId;
item.ReservedBy = ReservedBy;
item.ReservedFor = ReservedFor;
item.SessionId = SessionId;
item.Start = DateTime.Parse(Start);
item.Notes = Notes;
item.CreatedBy = CreatedBy;
Received = Received;
}
/// <summary>
/// Commits this instance.
/// </summary>
private void Commit()
{
using (new BusyCursor())
{
foreach (var item in _deletedItems)
{
var reservation = _context.AssetReservations.FirstOrDefault(x => x.AssetId.Equals(item.AssetId) && x.AssetReservationId.Equals(item.ReservationId));
if (reservation != null)
{
_context.ReservationHistory.Add(new ReservationHistory(reservation));
_context.AssetReservations.Remove(reservation);
}
}
foreach (var item in _reservations.Where(x => x.Historical == false))
{
switch (item.State)
{
case EntityState.Added:
var email = UserPrincipal.Current.EmailAddress;
var addedEntity = new AssetReservation
{
AssetReservationId = SequentialGuid.NewGuid(),
AssetId = item.AssetId,
ReservedBy = item.ReservedBy,
ReservedFor = item.ReservedFor,
Start = DateTime.Parse(item.Start),
End = item.End.Equals(Resources.Permanent) ? _maxDateTime : DateTime.Parse(item.End),
Received = DateTime.Now,
Notify = AssetReservationExpirationNotify.DoNotNotify,
CreatedBy = email
};
_context.AssetReservations.Add(addedEntity);
break;
case EntityState.Modified:
var modifedEntity = _context.AssetReservations.FirstOrDefault(x => x.AssetId.Equals(item.AssetId));
if (modifedEntity != null)
{
item.UpdateEntity(modifedEntity);
}
break;
}
}
_context.SaveChanges();
_deletedItems.Clear();
}
}
private static void SendExpirationNotification(ExpirationNotifier notifier, AssetReservation reservation)
{
try
{
MailAddress recipient = new MailAddress(reservation.NotificationRecipient);
string reservationText = (reservation.End < DateTime.Now ? Resource.ExpiredReservationText : Resource.ExpiringReservationText);
string subject = string.Format(reservationText, reservation.AssetId);
string body = string.Format(Resource.ReservationEmailBody, subject, reservation.End.ToString("f"));
notifier.SendNotification(recipient, subject, body);
}
catch (FormatException)
{
LogWarn($"Ignoring invalid notification recipient: {reservation.NotificationRecipient}");
}
}
private void CreateReservations(Asset asset, string sessionId, string reservationKey, DateTime requestedStart, DateTime requestedEnd)
{
// Find any reservations that overlap with the requested time
List <AssetReservation> overlappingReservations = asset.Reservations.Where(n => n.End > requestedStart && n.Start < requestedEnd).OrderBy(n => n.Start).ToList();
// Track two items: first, whether we have started creating a reservation so far;
// second, the time from which we are trying to create/extend the reservation period
bool obtainedAnyReservation = false;
DateTime currentTime = requestedStart;
// Walk through the requested time period, using existing reservations where possible and creating new reservations in the blank spaces
for (int i = 0; i < overlappingReservations.Count; i++)
{
AssetReservation nextExistingReservation = overlappingReservations[i];
// Check to see if there is a blank space before the next existing reservation - if so, fill it in
if (nextExistingReservation.Start > currentTime.AddMilliseconds(10))
{
CreateReservation(asset, sessionId, currentTime, nextExistingReservation.Start);
obtainedAnyReservation = true;
}
// Check to see if we can use the existing reservation for this session
if (nextExistingReservation.ReservedFor.EqualsIgnoreCase(reservationKey) && string.IsNullOrEmpty(nextExistingReservation.SessionId))
{
nextExistingReservation.SessionId = sessionId;
currentTime = nextExistingReservation.End;
obtainedAnyReservation = true;
}
else if (!obtainedAnyReservation)
{
// Still haven't found a block to reserve, so reset the cursor to after this reservation and keep looking
currentTime = nextExistingReservation.End;
}
else
{
// We have created a partial reservation, but have now reached a point where we cannot extend it further
return;
}
}
// Reserve the last block after the existing reservation, if needed.
// (If there were no other reservations to begin with, this will reserve the entire requested time.)
if (requestedEnd > currentTime.AddMilliseconds(10))
{
CreateReservation(asset, sessionId, currentTime, requestedEnd);
}
}
public AssetReservationLocal(AssetReservation reservation)
{
Historical = false;
AssetId = reservation.AssetId;
//End = reservation.End.ToString("{0:dd-MMM-yyyy HH:mm:ss}");
End = reservation.End.ToString();
ReservationId = reservation.AssetReservationId;
ReservedBy = reservation.ReservedBy;
ReservedFor = reservation.ReservedFor;
SessionId = reservation.SessionId;
//Start = reservation.Start.ToString("{0:dd-MMM-yyyy HH:mm:ss}"); ;
Start = reservation.Start.ToString();
Notes = reservation.Notes;
CreatedBy = reservation.CreatedBy;
Received = reservation.Received;
State = EntityState.Unchanged;
}
private AssetReservation CreateReservation(Asset asset, string sessionId, DateTime requestedStart, DateTime requestedEnd)
{
// If we're at the end of the day, kick the start time over to the next day
if (requestedStart.TimeOfDay > new TimeSpan(0, 23, 59, 59, 995))
{
requestedStart = requestedStart.AddMilliseconds(10).Date;
}
AssetReservation newReservation = new AssetReservation
{
AssetReservationId = SequentialGuid.NewGuid(),
ReservedBy = _requester,
ReservedFor = sessionId,
Start = requestedStart,
End = requestedEnd,
Received = DateTime.Now,
SessionId = sessionId,
CreatedBy = _requester,
Notify = AssetReservationExpirationNotify.DoNotNotify
};
asset.Reservations.Add(newReservation);
return(newReservation);
}
