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>
/// Adds an alert resolution <see cref="Altask.Data.Model.Occurrence"/>.
/// </summary>
/// <param name="schedule"></param>
/// <returns>Returns a <see cref="Altask.Data.EntityResult"/> indicating success or failure.</returns>
public virtual async Task <ActionResult> AddAlertResolution(AlertResolution model)
{
ThrowIfDisposed();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
model.Date = model.Date.LessSeconds();
var assetEntity = await Context.Assets.FindAsync(model.AssetId);
if (assetEntity == null)
{
return(BadRequest(ErrorDescriber.DoesNotExist("Asset")));
}
var userEntity = await Context.Users.FindAsync(model.UserId);
if (userEntity == null)
{
return(BadRequest(ErrorDescriber.DoesNotExist("User")));
}
var assetLogEntity = await Context.AssetLogs.FindAsync(model.AssetLogId);
if (assetLogEntity == null)
{
return(BadRequest(ErrorDescriber.DoesNotExist("Asset Log")));
}
var taskTypeEntity = await Context.TaskTypes.FirstOrDefaultAsync(t => t.Name == "Adhoc");
if (taskTypeEntity == null)
{
return(BadRequest(ErrorDescriber.DefaultError("The Adhoc task type does not exist.")));
}
var scheduleAssetType = await Context.ScheduleAssetTypes.FirstOrDefaultAsync(sat => sat.Name == "Primary");
if (scheduleAssetType == null)
{
return(BadRequest(ErrorDescriber.DefaultError("The Primary schedule asset type does not exist.")));
}
var scheduleUserType = await Context.ScheduleUserTypes.FirstOrDefaultAsync(sut => sut.Name == "Primary");
if (scheduleUserType == null)
{
return(BadRequest(ErrorDescriber.DefaultError("The Primary schedule user type does not exist.")));
}
var newTask = Context.Tasks.Add(new Data.Model.Task()
{
Active = true,
TaskCategoryId = model.TaskCategoryId,
Description = model.Description,
FormId = model.FormId,
IdleTimeout = model.IdleTimeout,
Name = model.Name,
TaskTypeId = taskTypeEntity.Id
});
var newSchedule = new Data.Model.Schedule()
{
Active = true,
AnyTime = false,
AsEarlyAsFrequency = model.AsEarlyAsFrequency,
AsEarlyAsN = model.AsEarlyAsN,
EndsAfter = 1,
Frequency = "One-Time",
Name = model.Name,
StartsOn = model.Date
};
newSchedule.Assets.Add(new Data.Model.ScheduleAsset()
{
AssetId = assetEntity.Id,
ScheduleAssetTypeId = scheduleAssetType.Id
});
newSchedule.Users.Add(new Data.Model.ScheduleUser()
{
UserId = userEntity.Id,
ScheduleUserTypeId = scheduleUserType.Id
});
newTask.Schedules.Add(newSchedule);
Context.Tasks.Add(newTask);
var result = await Context.SaveChangesAsync();
if (result.Succeeded)
{
SignalRHub.NotifyTaskCreate(ClientId, newTask.ToDto());
var result0 = await AddSingleOccurrence(newTask, newSchedule, assetEntity.Id, userEntity.Id, model.Date);
if (result0.Succeeded)
{
var newAssetLogResolution = new AssetLogResolution()
{
AssetLogId = assetLogEntity.Id,
OccurrenceId = result0.Entity.OccurrenceId,
TaskId = newTask.Id
};
Context.AssetLogResolutions.Add(newAssetLogResolution);
var result1 = await Context.SaveChangesAsync();
await Context.Entry(newAssetLogResolution).Reference(alr => alr.Occurrence).LoadAsync();
if (result.Succeeded)
{
SignalRHub.NotifyAssetLogResolutionCreate(ClientId, newAssetLogResolution.ToDto());
return(Ok(new { assetLogResolution = newAssetLogResolution.ToDto(), instance = result0.Entity }));
}
return(BadRequest(result1));
}
return(BadRequest(result0.Errors.ToArray()));
}
else
{
return(BadRequest(result));
}
}
/// <summary>
/// Adds a one-time <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> AddOneTime(OneTimeOccurrence model)
{
ThrowIfDisposed();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
model.Date = model.Date.LessSeconds();
List <Data.Model.User> userEntities = new List <Data.Model.User>();
List <Data.Model.Asset> assetEntities = new List <Data.Model.Asset>();
if (model.AssetIds != null && model.AssetIds.Count > 0)
{
foreach (var assetId in model.AssetIds)
{
var assetEntity = await Context.Assets.FirstOrDefaultAsync(a => a.Id == assetId);
if (assetEntity != null)
{
assetEntities.Add(assetEntity);
}
}
}
if (model.UserIds != null && model.UserIds.Count > 0)
{
foreach (var userId in model.UserIds)
{
var userEntity = await Context.Users.FirstOrDefaultAsync(u => u.Id == userId);
if (userEntity != null)
{
userEntities.Add(userEntity);
}
}
}
if (userEntities.Count == 0 && assetEntities.Count == 0)
{
return(BadRequest(ErrorDescriber.DefaultError("At least one valid user or asset must be assigned to the task.")));
}
var taskTypeEntity = await Context.TaskTypes.FirstOrDefaultAsync(t => t.Name == "Adhoc");
if (taskTypeEntity == null)
{
return(BadRequest(ErrorDescriber.DefaultError("The Adhoc task type does not exist.")));
}
var scheduleAssetType = await Context.ScheduleAssetTypes.FirstOrDefaultAsync(sat => sat.Name == "Primary");
if (scheduleAssetType == null)
{
return(BadRequest(ErrorDescriber.DefaultError("The Primary schedule asset type does not exist.")));
}
var scheduleUserType = await Context.ScheduleUserTypes.FirstOrDefaultAsync(sut => sut.Name == "Primary");
if (scheduleUserType == null)
{
return(BadRequest(ErrorDescriber.DefaultError("The Primary schedule user type does not exist.")));
}
var newTask = Context.Tasks.Add(new Data.Model.Task()
{
Active = true,
TaskCategoryId = model.TaskCategoryId,
Description = model.Description,
FormId = model.FormId,
IdleTimeout = model.IdleTimeout,
Name = model.Name,
TaskTypeId = taskTypeEntity.Id
});
var newSchedule = new Data.Model.Schedule()
{
Active = true,
AnyTime = false,
AsEarlyAsFrequency = model.AsEarlyAsFrequency,
AsEarlyAsN = model.AsEarlyAsN,
EndsAfter = 1,
Frequency = "One-Time",
Name = model.Name,
StartsOn = model.Date
};
foreach (var asset in assetEntities)
{
newSchedule.Assets.Add(new Data.Model.ScheduleAsset()
{
AssetId = asset.Id,
ScheduleAssetTypeId = scheduleAssetType.Id
});
}
foreach (var user in userEntities)
{
newSchedule.Users.Add(new Data.Model.ScheduleUser()
{
UserId = user.Id,
ScheduleUserTypeId = scheduleUserType.Id
});
}
newTask.Schedules.Add(newSchedule);
Context.Tasks.Add(newTask);
var result = await Context.SaveChangesAsync();
List <TaskInstance> instances = new List <TaskInstance>();
if (result.Succeeded)
{
if (assetEntities.Count > 0)
{
foreach (var asset in assetEntities)
{
if (userEntities.Count > 0)
{
foreach (var user in userEntities)
{
var result0 = await AddSingleOccurrence(newTask, newSchedule, asset.Id, user.Id, model.Date);
if (result0.Succeeded)
{
instances.Add(result0.Entity);
}
}
}
else
{
var result0 = await AddSingleOccurrence(newTask, newSchedule, asset.Id, null, model.Date);
if (result0.Succeeded)
{
instances.Add(result0.Entity);
}
}
}
}
else if (userEntities.Count > 0)
{
foreach (var user in userEntities)
{
var result0 = await AddSingleOccurrence(newTask, newSchedule, null, user.Id, model.Date);
if (result0.Succeeded)
{
instances.Add(result0.Entity);
}
}
}
return(Ok(new { instances = instances }));
}
else
{
return(BadRequest(result));
}
}
