/// <summary>
/// Maps all the non-primary key and tracking properties of a <see cref='Altask.Data.Dto.Occurrence'/> object to a <see cref='Altask.Data.Model.Occurrence'/> object.
/// </summary>
public static Altask.Data.Model.Occurrence FromDto(this Altask.Data.Model.Occurrence model, Altask.Data.Dto.Occurrence entity)
{
model.TaskId = entity.TaskId;
model.ScheduleId = entity.ScheduleId;
model.AssetId = entity.AssetId;
model.UserId = entity.UserId;
model.FormModel = entity.FormModel;
model.XmlResults = entity.XmlResults;
model.AsEarlyAsDate = entity.AsEarlyAsDate;
model.Date = entity.Date;
model.Dismissed = entity.Dismissed;
model.DismissedBy = entity.DismissedBy;
model.DismissedOn = entity.DismissedOn;
model.Started = entity.Started;
model.StartedBy = entity.StartedBy;
model.StartedOn = entity.StartedOn;
model.StoppedBy = entity.StoppedBy;
model.StoppedOn = entity.StoppedOn;
model.ResumedBy = entity.ResumedBy;
model.ResumedOn = entity.ResumedOn;
model.Completed = entity.Completed;
model.CompletedBy = entity.CompletedBy;
model.CompletedOn = entity.CompletedOn;
model.TimeSpent = entity.TimeSpent;
return(model);
}
private async Task <EntityResult <TaskInstance> > AddSingleOccurrence(Data.Model.Task task, Data.Model.Schedule scheduleEntity, int?assetId, int?userId, DateTime date)
{
date = date.LessSeconds();
Context.Entry(task).Reference(t => t.Form).Load();
var newOccurrence = new Altask.Data.Model.Occurrence()
{
AsEarlyAsDate = date,
Date = date,
FormModel = task.Form.PublishedModel,
TaskId = task.Id,
TimeSpent = 0,
ScheduleId = scheduleEntity.Id,
};
var assetEntity = await Context.Assets.FindAsync(assetId);
if (assetEntity != null)
{
newOccurrence.AssetId = assetEntity.Id;
}
var userEntity = await Context.Users.FindAsync(userId);
if (userEntity != null)
{
newOccurrence.UserId = userEntity.Id;
}
if (assetEntity == null && userEntity == null)
{
return(EntityResult <TaskInstance> .Failed(ErrorDescriber.DefaultError("An occurrence must have either and asset or user associated to it.")));
}
newOccurrence.Logs.Add(new Data.Model.OccurrenceLog()
{
Type = "Created"
});
Context.Occurrences.Add(newOccurrence);
BeforeCreate(newOccurrence, newOccurrence.ToDto());
var result = await Context.SaveChangesAsync();
if (result.Succeeded)
{
await AfterCreateAsync(newOccurrence, true);
var instance = TaskInstance.FromSchedule(task, newOccurrence.Date, scheduleEntity).MergeOccurrence(newOccurrence);
SignalRHub.NotifyOccurrenceCreate(null, instance, newOccurrence.ToDto());
return(EntityResult <TaskInstance> .Succeded(instance));
}
else
{
return(EntityResult <TaskInstance> .Failed(result.Errors.ToArray()));
}
}
/// <summary>
/// Maps a <see cref='Altask.Data.Model.Occurrence'/> object to a <see cref='Altask.Data.Dto.Occurrence'/> object.
/// </summary>
/// <param name="includeLogs">Indicates whether to load any logs associated with the object when mapping.</param>
public static Altask.Data.Dto.Occurrence ToDto(this Altask.Data.Model.Occurrence entity, bool includeLogs = false)
{
var dto = new Altask.Data.Dto.Occurrence();
dto.Id = entity.Id;
dto.TaskId = entity.TaskId;
dto.ScheduleId = entity.ScheduleId;
dto.AssetId = entity.AssetId;
dto.UserId = entity.UserId;
dto.FormModel = entity.FormModel;
dto.XmlResults = entity.XmlResults;
dto.AsEarlyAsDate = entity.AsEarlyAsDate;
dto.Date = entity.Date;
dto.Dismissed = entity.Dismissed;
dto.DismissedBy = entity.DismissedBy;
dto.DismissedOn = entity.DismissedOn;
dto.Started = entity.Started;
dto.StartedBy = entity.StartedBy;
dto.StartedOn = entity.StartedOn;
dto.StoppedBy = entity.StoppedBy;
dto.StoppedOn = entity.StoppedOn;
dto.ResumedBy = entity.ResumedBy;
dto.ResumedOn = entity.ResumedOn;
dto.Completed = entity.Completed;
dto.CompletedBy = entity.CompletedBy;
dto.CompletedOn = entity.CompletedOn;
dto.TimeSpent = entity.TimeSpent;
dto.CreatedBy = entity.CreatedBy;
dto.CreatedOn = entity.CreatedOn;
dto.UpdatedBy = entity.UpdatedBy;
dto.UpdatedOn = entity.UpdatedOn;
if (entity.Asset != null)
{
dto.Asset = entity.Asset.ToDto();
}
if (entity.Schedule != null)
{
dto.Schedule = entity.Schedule.ToDto();
}
if (entity.Task != null)
{
dto.Task = entity.Task.ToDto();
}
if (entity.User != null)
{
dto.User = entity.User.ToDto();
}
dto.Logs = new List <Altask.Data.Dto.OccurrenceLog>();
if (includeLogs)
{
if (entity.Logs != null)
{
foreach (var item in entity.Logs)
{
dto.Logs.Add(item.ToDto());
}
}
}
return(dto);
}
/// <summary>
/// Adds an <see cref="Altask.Data.Model.Occurrence"/> based on the <see cref="Altask.Data.Model.Schedule"/>.
/// </summary>
/// <param name="schedule"></param>
/// <returns>Returns a <see cref="Altask.Data.EntityResult"/> indicating success or failure.</returns>
public virtual async Task <ActionResult> AddAndStart(long scheduleId, int?assetId, int?userId, DateTime date, int startedByUserId)
{
date = date.LessSeconds();
ThrowIfDisposed();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var scheduleEntity = await Context.Schedules.FindAsync(scheduleId);
if (scheduleEntity == null)
{
return(BadRequest(ErrorDescriber.DoesNotExist("Schedule")));
}
if (scheduleEntity.EndsOn.HasValue && scheduleEntity.EndsOn.Value < DateTime.Now)
{
return(BadRequest(ErrorDescriber.DefaultError("No more occurrences can be created for the associated Schedule. The Schedule has ended.")));
}
if (scheduleEntity.EndsAfter.HasValue)
{
var pastOccurrences = await Context.Occurrences.Where(o => o.ScheduleId == scheduleEntity.Id && o.Date != date).ToListAsync();
if (pastOccurrences.Count == scheduleEntity.EndsAfter.Value)
{
return(BadRequest(ErrorDescriber.DefaultError("Not more occurrences can be created for the associated Schedule. The maximum number of occurrences have been created.")));
}
}
var taskEntity = await Context.Tasks.FindAsync(scheduleEntity.TaskId);
await Context.Entry(taskEntity).Reference(t => t.Form).LoadAsync();
if (taskEntity == null)
{
return(BadRequest(ErrorDescriber.DoesNotExistFor("Task", "Schedule")));
}
var startedByEntity = await Context.Users.FindAsync(startedByUserId);
if (startedByEntity == null)
{
return(BadRequest(ErrorDescriber.DoesNotExist("User")));
}
date = date.Date.Add(scheduleEntity.StartsOn.TimeOfDay).LessSeconds();
var occurrenceEntity = await Context.Occurrences.FirstOrDefaultAsync(o => o.ScheduleId == scheduleEntity.Id && o.Date == date &&
(assetId.HasValue ? (userId.HasValue ? o.AssetId == assetId && o.UserId == userId : o.AssetId == assetId && o.UserId == null) :
(userId.HasValue ? o.UserId == userId && o.AssetId == null : o.AssetId == null && o.UserId == null)));
if (occurrenceEntity != null)
{
if (!occurrenceEntity.Started.GetValueOrDefault(false))
{
occurrenceEntity.Started = true;
occurrenceEntity.StartedBy = startedByEntity.UserName;
occurrenceEntity.StartedOn = DateTime.Now;
occurrenceEntity.TimeSpent = 0;
occurrenceEntity.Logs.Add(new Data.Model.OccurrenceLog()
{
Type = "Started"
});
Context.Entry(occurrenceEntity).State = EntityState.Modified;
var result = await Context.SaveChangesAsync();
if (result.Succeeded)
{
await AfterUpdateAsync(occurrenceEntity);
var instance = TaskInstance.FromSchedule(taskEntity, occurrenceEntity.Date, scheduleEntity).MergeOccurrence(occurrenceEntity);
SignalRHub.NotifyOccurrenceCreate(null, instance, occurrenceEntity.ToDto());
return(Ok(new { instance = instance }));
}
else
{
return(BadRequest(result));
}
}
var existing = TaskInstance.FromSchedule(taskEntity, occurrenceEntity.Date, scheduleEntity).MergeOccurrence(occurrenceEntity);
SignalRHub.NotifyOccurrenceCreate(null, existing, occurrenceEntity.ToDto());
return(Ok(new { instance = existing }));
}
else
{
var newOccurrence = new Altask.Data.Model.Occurrence()
{
Date = date,
FormModel = taskEntity.Form.PublishedModel,
Started = true,
StartedBy = startedByEntity.UserName,
StartedOn = DateTime.Now,
TaskId = taskEntity.Id,
TimeSpent = 0,
ScheduleId = scheduleEntity.Id
};
var assetEntity = await Context.Assets.FindAsync(assetId);
if (assetEntity != null)
{
newOccurrence.AssetId = assetEntity.Id;
}
var userEntity = await Context.Users.FindAsync(userId);
if (userEntity != null)
{
newOccurrence.UserId = userEntity.Id;
}
if (assetEntity == null && userEntity == null)
{
return(BadRequest(ErrorDescriber.DefaultError("An occurrence must have either and asset or user associated to it.")));
}
newOccurrence.Logs.Add(new Data.Model.OccurrenceLog()
{
Type = "Created"
});
newOccurrence.Logs.Add(new Data.Model.OccurrenceLog()
{
Type = "Started"
});
Context.Occurrences.Add(newOccurrence);
BeforeCreate(newOccurrence, newOccurrence.ToDto());
var result = await Context.SaveChangesAsync();
if (result.Succeeded)
{
await AfterCreateAsync(newOccurrence);
var instance = TaskInstance.FromSchedule(taskEntity, newOccurrence.Date, scheduleEntity).MergeOccurrence(newOccurrence);
SignalRHub.NotifyOccurrenceCreate(null, instance, newOccurrence.ToDto());
return(Ok(new { instance = instance }));
}
else
{
return(BadRequest(result));
}
}
}
