/// <summary>
/// Creates a requirement from a ViewModel.
/// </summary>
/// <param name="vm"></param>
/// <returns></returns>
public static Requirement CreateRequirement(RequirementViewModel vm)
{
if (vm == null)
{
return(null);
}
Requirement requirement = new Requirement(vm.Id)
{
LastEditDate = vm.LastEditDate,
LastEditBy = vm.LastEditBy,
RowVersion = vm.RowVersion
};
if (vm.CertificateType != null)
{
requirement.CertificateType = CertificateTypeViewModel.CreateCertificateType(vm.CertificateType);
requirement.CertificateTypeId = requirement.CertificateType.Id;
}
if (vm.Task != null)
{
requirement.Task = TaskViewModel.CreateTask(vm.Task);
requirement.TaskId = requirement.Task.Id;
}
return(requirement);
}
/// <summary>
/// Create a ViewModel from a Task.
/// </summary>
/// <param name="task"></param>
/// <returns></returns>
public static TaskViewModel CreateVm(Task task)
{
if (task == null)
{
return(null);
}
TaskViewModel vm = new TaskViewModel
{
Id = task.Id,
Name = task.Name,
Category = CategoryViewModel.CreateVm(task.Category),
Color = task.Color,
Description = task.Description,
LastEditDate = task.LastEditDate,
LastEditBy = task.LastEditBy,
RowVersion = task.RowVersion
};
if (task.Instruction != null)
{
vm.Instruction = DocumentViewModel.CreateVm(task.Instruction);
}
vm.Requirements = new List <RequirementViewModel>();
if (task.Requirements != null)
{
foreach (Requirement requirement in task.Requirements)
{
vm.Requirements.Add(RequirementViewModel.CreateVm(requirement));
}
}
return(vm);
}
/// <summary>
/// Creates a ViewModel from a Requirement.
/// </summary>
/// <param name="requirement"></param>
/// <returns></returns>
public static RequirementViewModel CreateVm(Requirement requirement)
{
if (requirement == null)
{
return(null);
}
RequirementViewModel vm = new RequirementViewModel
{
Id = requirement.Id,
LastEditDate = requirement.LastEditDate,
LastEditBy = requirement.LastEditBy,
RowVersion = requirement.RowVersion
};
if (requirement.CertificateType != null)
{
vm.CertificateType = CertificateTypeViewModel.CreateVm(requirement.CertificateType);
}
if (requirement.Task != null)
{
vm.Task = TaskViewModel.CreateVm(requirement.Task);
}
return(vm);
}
/// <summary>
/// Create a Task from a ViewModel.
/// </summary>
/// <param name="taskViewModel"></param>
/// <returns></returns>
public static Task CreateTask(TaskViewModel taskViewModel)
{
if (taskViewModel == null)
{
return(null);
}
Task task = new Task(taskViewModel.Id)
{
Name = taskViewModel.Name,
Color = taskViewModel.Color,
Description = taskViewModel.Description,
LastEditDate = taskViewModel.LastEditDate,
LastEditBy = taskViewModel.LastEditBy,
RowVersion = taskViewModel.RowVersion
};
if (taskViewModel.Category != null)
{
task.CategoryId = taskViewModel.Category.Id;
task.Category = CategoryViewModel.CreateCategory(taskViewModel.Category);
}
task.Requirements = new List <Requirement>();
if (taskViewModel.Requirements != null)
{
foreach (RequirementViewModel requirement in taskViewModel.Requirements)
{
task.Requirements.Add(RequirementViewModel.CreateRequirement(requirement));
}
}
if (taskViewModel.Instruction == null)
{
return(task);
}
task.Instruction = DocumentViewModel.CreateDocument(taskViewModel.Instruction);
task.InstructionId = taskViewModel.Instruction.Id;
return(task);
}
