/// <summary>
/// Create a Certificate from a ViewModel.
/// </summary>
/// <param name="certificateViewModel"></param>
/// <returns></returns>
public static Certificate CreateCertificate(CertificateViewModel certificateViewModel)
{
if (certificateViewModel == null)
{
return(null);
}
Certificate certificate = new Certificate(certificateViewModel.Id)
{
DateIssued = certificateViewModel.DateIssued,
DateExpired = certificateViewModel.DateExpired,
LastEditBy = certificateViewModel.LastEditBy,
LastEditDate = certificateViewModel.LastEditDate,
RowVersion = certificateViewModel.RowVersion
};
if (certificateViewModel.Person != null)
{
certificate.Person = PersonViewModel.CreatePerson(certificateViewModel.Person);
certificate.PersonId = certificate.Person.Id;
}
if (certificateViewModel.CertificateType == null)
{
return(certificate);
}
certificate.CertificateType =
CertificateTypeViewModel.CreateCertificateType(certificateViewModel.CertificateType);
certificate.CertificateTypeId = certificate.CertificateType.Id;
return(certificate);
}
/// <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>
/// Creates a ViewModel from a certifiacte.
/// </summary>
/// <param name="certificate"></param>
/// <returns></returns>
public static CertificateViewModel CreateVm(Certificate certificate)
{
if (certificate == null)
{
return(null);
}
CertificateViewModel vm = new CertificateViewModel
{
DateIssued = certificate.DateIssued,
DateExpired = certificate.DateExpired,
Id = certificate.Id,
LastEditBy = certificate.LastEditBy,
LastEditDate = certificate.LastEditDate,
RowVersion = certificate.RowVersion
};
if (certificate.Person != null)
{
vm.Person = PersonViewModel.CreateVmFromPerson(certificate.Person);
}
if (certificate.CertificateType != null)
{
vm.CertificateType = CertificateTypeViewModel.CreateVm(certificate.CertificateType);
}
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>
/// Creates a CertificateType from a ViewModel
/// </summary>
/// <param name="certificateTypeViewModel"></param>
/// <returns></returns>
public static CertificateType CreateCertificateType(CertificateTypeViewModel certificateTypeViewModel)
{
if (certificateTypeViewModel == null)
{
return(null);
}
return(new CertificateType(certificateTypeViewModel.Id)
{
Name = certificateTypeViewModel.Name,
Level = certificateTypeViewModel.Level,
LastEditBy = certificateTypeViewModel.LastEditBy,
LastEditDate = certificateTypeViewModel.LastEditDate,
RowVersion = certificateTypeViewModel.RowVersion
});
}
