/// <summary>
/// Creates from domain model.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="objectMapper">The object mapper.</param>
/// <returns></returns>
public static Repository.User CreateFromDomainModel(Model.Entities.User user, IObjectMapperAdapter objectMapper)
{
if (user is Model.Entities.Student)
{
return(objectMapper.Map <Model.Entities.Student, Student>((Model.Entities.Student)user));
}
else if (user is Model.Entities.Staff)
{
return(objectMapper.Map <Model.Entities.Staff, Staff>((Model.Entities.Staff)user));
}
else
{
return(objectMapper.Map <Model.Entities.User, User>(user));
}
}
/// <summary>
/// Creates from view model model.
/// </summary>
/// <param name="asset">The user.</param>
/// <param name="objectMapper">The object mapper.</param>
/// <returns></returns>
public static User CreateFromViewModelModel(UserViewModel user, IObjectMapperAdapter objectMapper)
{
if (user is StudentViewModel)
{
return(objectMapper.Map <StudentViewModel, Student>((StudentViewModel)user));
}
else if (user is StaffViewModel)
{
return(objectMapper.Map <StaffViewModel, Staff>((StaffViewModel)user));
}
else
{
return(objectMapper.Map <UserViewModel, User>(user));
}
}
/// <summary>
/// Creates the user entity.
/// </summary>
/// <param name="user">The user.</param>
/// <returns></returns>
public static Model.Entities.User CreateFromDataModel(User user, IObjectMapperAdapter objectMapper)
{
if (user is Student)
{
return(objectMapper.Map <Student, Model.Entities.Student>((Student)user));
}
else if (user is Staff)
{
return(objectMapper.Map <Staff, Model.Entities.Staff>((Staff)user));
}
else
{
return(objectMapper.Map <User, Model.Entities.User>(user));
}
}
public void GetMethodToProperty(IObjectMapperAdapter adapter)
{
adapter.CreateMap <ClassWithGetValueMethod, ClassWithValue>();
var source = new ClassWithGetValueMethod("ABC");
var result = adapter.Map <ClassWithValue>(source);
Assert.Equal(source.GetValue(), result.Value);
}
public void PropertyToSetMethod(IObjectMapperAdapter adapter)
{
adapter.CreateMap<ClassWithValue, ClassWithSetValue>();
var source = new ClassWithValue { Value = "ABC" };
var result = adapter.Map<ClassWithSetValue>(source);
Assert.Equal(source.Value, result.GetValue());
}
public void NameBasedUnflattening(IObjectMapperAdapter adapter)
{
adapter.CreateMap<ClassWithNestedValue, ClassWithNested<ClassWithValue>>();
var source = new ClassWithNestedValue { NestedValue = "ABC" };
var result = adapter.Map<ClassWithNested<ClassWithValue>>(source);
Assert.Equal(source.NestedValue, result.Nested.Value);
}
public void MethodToProperty(IObjectMapperAdapter adapter)
{
adapter.CreateMap<ClassWithValueAsMethod, ClassWithValue>();
var source = new ClassWithValueAsMethod("ABC");
var result = adapter.Map<ClassWithValue>(source);
Assert.Equal(source.Value(), result.Value);
}
public void Simple(IObjectMapperAdapter mapper)
{
mapper.CreateMap<Wrapper<string>, ImmutableWrapper<string>>();
var source = new Wrapper<string> { Value = "X" };
var result = mapper.Map<ImmutableWrapper<string>>(source);
Assert.Equal("X", result.Value);
}
public void NameBasedUnflattening(IObjectMapperAdapter adapter)
{
adapter.CreateMap <ClassWithNestedName, ClassWithNested <ClassWithName> >();
var source = new ClassWithNestedName {
NestedName = "ABC"
};
var result = adapter.Map <ClassWithNested <ClassWithName> >(source);
Assert.Equal(source.NestedName, result.Nested.Name);
}
public void PropertyToSetMethod(IObjectMapperAdapter adapter)
{
adapter.CreateMap <ClassWithValue, ClassWithSetValue>();
var source = new ClassWithValue {
Value = "ABC"
};
var result = adapter.Map <ClassWithSetValue>(source);
Assert.Equal(source.Value, result.GetValue());
}
public void NameBasedFlattening(IObjectMapperAdapter adapter)
{
adapter.CreateMap <ClassWithNested <ClassWithValue>, ClassWithNestedValue>();
var source = new ClassWithNested <ClassWithValue> {
Nested = { Value = "ABC" }
};
var result = adapter.Map <ClassWithNestedValue>(source);
Assert.Equal(source.Nested.Value, result.NestedValue);
}
public void DictionaryEntryToProperty(IObjectMapperAdapter mapper)
{
mapper.CreateMap<Dictionary<string, object>, Wrapper<string>>();
var source = new Dictionary<string, object> { { "Value", "ABC" } };
var result = mapper.Map<Wrapper<string>>(source);
Assert.NotNull(result);
Assert.Equal("ABC", result.Value);
}
public void PropertyToDictionaryEntry(IObjectMapperAdapter mapper)
{
mapper.CreateMap<Wrapper<string>, Dictionary<string, object>>();
var source = new Wrapper<string> { Value = "ABC" };
var result = mapper.Map<Dictionary<string, object>>(source);
Assert.NotNull(result);
Assert.Contains(new KeyValuePair<string, object>("Value", "ABC"), result);
}
/// <summary>
/// Creates from domain model.
/// </summary>
/// <param name="asset">The asset.</param>
/// <param name="objectMapper">The object mapper.</param>
/// <returns></returns>
public static Repository.Asset CreateFromDomainModel(Model.Entities.Asset asset, IObjectMapperAdapter objectMapper)
{
if (asset is Model.Entities.Video)
{
return(objectMapper.Map <Model.Entities.Video, Video>((Model.Entities.Video)asset));
}
else if (asset is Model.Entities.Document)
{
return(objectMapper.Map <Model.Entities.Document, Document>((Model.Entities.Document)asset));
}
else if (asset is Model.Entities.Image)
{
return(objectMapper.Map <Model.Entities.Image, Image>((Model.Entities.Image)asset));
}
else
{
return(objectMapper.Map <Model.Entities.Asset, Asset>(asset));
}
}
/// <summary>
/// Creates from domain model.
/// </summary>
/// <param name="asset">The user.</param>
/// <param name="objectMapper">The object mapper.</param>
/// <returns></returns>
public static UserViewModel CreateFromDomainModel(User user, IObjectMapperAdapter objectMapper)
{
if (user is Student)
{
StudentViewModel student = objectMapper.Map <Student, StudentViewModel>((Student)user);
student.Courses = CreateStudentCourses((Student)user, objectMapper);
return(student);
}
else if (user is Staff)
{
StaffViewModel staff = objectMapper.Map <Staff, StaffViewModel>((Staff)user);
staff.Courses = CreateStaffCourses((Staff)user, objectMapper);
return(staff);
}
else
{
return(objectMapper.Map <User, UserViewModel>(user));
}
}
/// <summary>
/// Creates from view model model.
/// </summary>
/// <param name="asset">The asset.</param>
/// <param name="objectMapper">The object mapper.</param>
/// <returns></returns>
public static Asset CreateFromViewModelModel(AssetViewModel asset, IObjectMapperAdapter objectMapper)
{
if (asset is VideoViewModel)
{
return(objectMapper.Map <VideoViewModel, Video>((VideoViewModel)asset));
}
else if (asset is DocumentViewModel)
{
return(objectMapper.Map <DocumentViewModel, Document>((DocumentViewModel)asset));
}
else if (asset is ImageViewModel)
{
return(objectMapper.Map <ImageViewModel, Image>((ImageViewModel)asset));
}
else
{
return(objectMapper.Map <AssetViewModel, Asset>(asset));
}
}
/// <summary>
/// Creates from domain model.
/// </summary>
/// <param name="asset">The asset.</param>
/// <param name="objectMapper">The object mapper.</param>
/// <returns></returns>
public static AssetViewModel CreateFromDomainModel(Asset asset, IObjectMapperAdapter objectMapper)
{
if (asset is Video)
{
return(objectMapper.Map <Video, VideoViewModel>((Video)asset));
}
else if (asset is Document)
{
return(objectMapper.Map <Document, DocumentViewModel>((Document)asset));
}
else if (asset is Image)
{
return(objectMapper.Map <Image, ImageViewModel>((Image)asset));
}
else
{
return(objectMapper.Map <Asset, AssetViewModel>(asset));
}
}
/// <summary>
/// Creates the asset entity.
/// </summary>
/// <param name="asset">The asset.</param>
/// <returns></returns>
public static Model.Entities.Asset CreateFromDataModel(Asset asset, IObjectMapperAdapter objectMapper)
{
if (asset is Video)
{
return(objectMapper.Map <Video, Model.Entities.Video>((Video)asset));
}
else if (asset is Document)
{
return(objectMapper.Map <Document, Model.Entities.Document>((Document)asset));
}
else if (asset is Image)
{
return(objectMapper.Map <Image, Model.Entities.Image>((Image)asset));
}
else
{
return(objectMapper.Map <Asset, Model.Entities.Asset>(asset));
}
}
public void Simple(IObjectMapperAdapter mapper)
{
mapper.CreateMap <Wrapper <string>, ImmutableWrapper <string> >();
var source = new Wrapper <string> {
Value = "X"
};
var result = mapper.Map <ImmutableWrapper <string> >(source);
Assert.Equal("X", result.Value);
}
private static void AssertEnumMappingWorksFor <TSource, TTarget>(IObjectMapperAdapter mapper, TSource sourceValue, TTarget expectedValue)
{
mapper.CreateMap <Wrapper <TSource>, Wrapper <TTarget> >();
var source = new Wrapper <TSource> {
Value = sourceValue
};
var result = mapper.Map <Wrapper <TTarget> >(source);
Assert.Equal(expectedValue, result.Value);
}
public void DictionaryEntryToProperty(IObjectMapperAdapter mapper)
{
mapper.CreateMap <Dictionary <string, object>, Wrapper <string> >();
var source = new Dictionary <string, object> {
{ "Value", "ABC" }
};
var result = mapper.Map <Wrapper <string> >(source);
Assert.NotNull(result);
Assert.Equal("ABC", result.Value);
}
public void PropertyToDictionaryEntry(IObjectMapperAdapter mapper)
{
mapper.CreateMap <Wrapper <string>, Dictionary <string, object> >();
var source = new Wrapper <string> {
Value = "ABC"
};
var result = mapper.Map <Dictionary <string, object> >(source);
Assert.NotNull(result);
Assert.Contains(new KeyValuePair <string, object>("Value", "ABC"), result);
}
public void ExpandoObjectToClass(IObjectMapperAdapter mapper)
{
mapper.CreateMap<dynamic, Wrapper<string>>();
dynamic source = new ExpandoObject();
source.Value = "ABC";
var result = mapper.Map<Wrapper<string>>((object)source);
Assert.NotNull(result);
Assert.Equal("ABC", result.Value);
}
/// <summary>
/// Creates the course view models.
/// </summary>
/// <param name="courses">The courses.</param>
/// <param name="objectMapper">The object mapper.</param>
/// <returns></returns>
public static List <ModuleViewModel> CreateModuleViewModels(List <Module> modules, IObjectMapperAdapter objectMapper)
{
List <ModuleViewModel> moduleModels = new List <ModuleViewModel>();
foreach (Module moduleItem in modules)
{
ModuleViewModel moduleViewModel = objectMapper.Map <Model.Entities.Module, ModuleViewModel>(moduleItem);
moduleModels.Add(moduleViewModel);
}
return(moduleModels);
}
/// <summary>
/// Creates the course view models.
/// </summary>
/// <param name="course">The course.</param>
/// <param name="objectMapper">The object mapper.</param>
/// <returns></returns>
public static ModuleViewModel CreateModuleViewModels(Module module, IObjectMapperAdapter objectMapper)
{
ModuleViewModel moduleViewModel = objectMapper.Map <Model.Entities.Module, ModuleViewModel>(module);
moduleViewModel.Quizzes = new List <QuizzesViewModel>();
moduleViewModel.Units = new List <UnitViewModel>();
foreach (ModuleQuiz moduleQuizItem in module.ModuleQuizs)
{
if (moduleQuizItem.Quiz != null)
{
moduleViewModel.Quizzes.Add(objectMapper.Map <Model.Entities.Quiz, QuizzesViewModel>(moduleQuizItem.Quiz));
}
}
foreach (Unit unitItem in module.Units)
{
moduleViewModel.Units.Add(objectMapper.Map <Model.Entities.Unit, UnitViewModel>(unitItem));
}
return(moduleViewModel);
}
/// <summary>
/// Creates the student assignment submission view model.
/// </summary>
/// <param name="assignment">The assignment.</param>
/// <param name="studentId">The student id.</param>
/// <param name="objectMapper">The object mapper.</param>
/// <returns></returns>
public static AssignmentSubmissionViewModel CreateStudentAssignmentSubmissionViewModel(Assignment assignment, int studentId, IObjectMapperAdapter objectMapper)
{
AssignmentSubmissionViewModel model = null;
if (assignment != null)
{
foreach (Submission submissionItem in assignment.Submissions)
{
if (submissionItem.StudentId == studentId)
{
model = objectMapper.Map <Model.Entities.Submission, AssignmentSubmissionViewModel>(submissionItem);
break;
}
}
// If no submission exists, create a new one
if (model == null)
{
model = new AssignmentSubmissionViewModel();
}
//Set Assignment properties on Model
model.StudentId = studentId;
model.AssignmentId = assignment.Id;
model.Instructions = assignment.Instructions;
model.DaysDue = assignment.DaysDue;
model.DaysLeft = assignment.DaysLeft;
model.Priority = (int)assignment.Priority;
if (model.Status == 0)
{
model.Status = (int)SubmissionStatusType.New;
}
model.PointsPossible = assignment.PointsPossible;
model.Title = assignment.Title;
model.AssignmentUploads = objectMapper.Map <Model.Entities.BaseFile, BaseFileViewModel>(assignment.FileUploads.ToList());
}
return(model);
}
public void ExpandoObjectToClass(IObjectMapperAdapter mapper)
{
mapper.CreateMap <dynamic, Wrapper <string> >();
dynamic source = new ExpandoObject();
source.Value = "ABC";
var result = mapper.Map <Wrapper <string> >((object)source);
Assert.NotNull(result);
Assert.Equal("ABC", result.Value);
}
private static void AssertNullableMappingWorksFor <TSource, TTarget>(IObjectMapperAdapter mapper, TSource sourceValue, TTarget expectedValue, TTarget targetValue = default(TTarget))
{
mapper.CreateMap <Wrapper <TSource>, Wrapper <TTarget> >();
var source = new Wrapper <TSource> {
Value = sourceValue
};
WrapperStatic <TTarget> .NextValueAfterConstructor = targetValue;
var result = mapper.Map <Wrapper <TTarget> >(source);
Assert.Equal(expectedValue, result.Value);
}
private static void AssertListMappingWorksFor <TSourceCollection, TTargetCollection>(IObjectMapperAdapter mapper, TSourceCollection sourceValue, TTargetCollection expectedValue)
where TSourceCollection : IEnumerable <int>
where TTargetCollection : IEnumerable <int>
{
mapper.CreateMap <Wrapper <TSourceCollection>, Wrapper <TTargetCollection> >();
var source = new Wrapper <TSourceCollection> {
Value = sourceValue
};
var result = mapper.Map <Wrapper <TTargetCollection> >(source);
Assert.NotNull(result.Value);
Assert.Equal(expectedValue.ToArray(), result.Value.ToArray());
}
private static void AssertListMappingWorksFor <TSourceCollection, TExposedTargetCollection, TActualTargetCollection>(IObjectMapperAdapter mapper, TSourceCollection sourceValue)
where TSourceCollection : IEnumerable <int>
where TExposedTargetCollection : IEnumerable <int>
where TActualTargetCollection : TExposedTargetCollection, new()
{
mapper.CreateMap <Wrapper <TSourceCollection>, WrapperWithReadOnly <TExposedTargetCollection, TActualTargetCollection> >();
var source = new Wrapper <TSourceCollection> {
Value = sourceValue
};
var result = mapper.Map <WrapperWithReadOnly <TExposedTargetCollection, TActualTargetCollection> >(source);
Assert.NotNull(result.Value);
Assert.Equal(sourceValue.ToArray(), result.Value.ToArray());
}
/// <summary>
/// Creates the course view models.
/// </summary>
/// <param name="courses">The courses.</param>
/// <param name="objectMapper">The object mapper.</param>
/// <returns></returns>
public static List <CourseViewModel> CreateCourseViewModels(List <Course> courses, IObjectMapperAdapter objectMapper)
{
List <CourseViewModel> courseModels = new List <CourseViewModel>();
foreach (Course courseItem in courses)
{
objectMapper.CreateMap <Model.Entities.CourseModule, CourseModuleViewModel>();
CourseViewModel courseViewModel = objectMapper.Map <Model.Entities.Course, CourseViewModel>(courseItem);
courseViewModel.Modules = new List <ModuleViewModel>();
foreach (CourseModule courseModuleItem in courseItem.CourseModules)
{
if (courseModuleItem.Module != null)
{
courseViewModel.Modules.Add(objectMapper.Map <Model.Entities.Module, ModuleViewModel>(courseModuleItem.Module));
}
}
if (courseItem.Department != null)
{
courseViewModel.DepartmentName = courseItem.Department.Name;
}
if (courseItem.StaffCourses != null && courseItem.StaffCourses.Count > 0)
{
foreach (var staffModel in courseItem.StaffCourses)
{
courseViewModel.StaffUsers = courseViewModel.StaffUsers + staffModel.Staff.FirstName;
}
}
courseViewModel.StudentCount = courseItem.CourseRegistrations.Count;
courseModels.Add(courseViewModel);
}
return(courseModels);
}
/// <summary>
/// Creates the staff courses.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="objectMapper">The object mapper.</param>
/// <returns></returns>
private static List <CourseViewModel> CreateStaffCourses(Staff user, IObjectMapperAdapter objectMapper)
{
List <CourseViewModel> courses = new List <CourseViewModel>();
if (user != null && user.StaffCourses != null)
{
foreach (var staffCourses in user.StaffCourses)
{
if (staffCourses.Course != null)
{
courses.Add(objectMapper.Map <Course, CourseViewModel>(staffCourses.Course));
}
}
}
return(courses);
}
/// <summary>
/// Gets or sets the create student courses.
/// </summary>
/// <value>The create student courses.</value>
private static List <CourseViewModel> CreateStudentCourses(Student user, IObjectMapperAdapter objectMapper)
{
List <CourseViewModel> courses = new List <CourseViewModel>();
if (user != null && user.CourseRegistrations != null)
{
foreach (var courseRegistration in user.CourseRegistrations)
{
if (courseRegistration.Course != null)
{
courses.Add(objectMapper.Map <Course, CourseViewModel>(courseRegistration.Course));
}
}
}
return(courses);
}
/// <summary>
/// Creates the course view models.
/// </summary>
/// <param name="course">The course.</param>
/// <param name="objectMapper">The object mapper.</param>
/// <returns></returns>
public static CourseViewModel CreateCourseViewModels(Course course, IObjectMapperAdapter objectMapper)
{
CourseViewModel courseViewModel = objectMapper.Map <Model.Entities.Course, CourseViewModel>(course);
courseViewModel.Modules = new List <ModuleViewModel> ();
foreach (CourseModule courseModuleItem in course.CourseModules)
{
if (courseModuleItem.Module != null)
{
courseViewModel.Modules.Add(ModuleViewModelFactory.CreateModuleViewModels(courseModuleItem.Module, objectMapper));
//courseViewModel.Modules.Add(objectMapper.Map<Model.Entities.Module, ModuleViewModel>(courseModuleItem.Module));
}
}
return(courseViewModel);
}
/// <summary>
/// Creates the quiz view model.
/// </summary>
/// <param name="quiz">The quiz.</param>
/// <param name="objectMapper">The object mapper.</param>
/// <returns></returns>
public static QuizzesViewModel CreateFromDomainModel(Quiz quiz, IObjectMapperAdapter objectMapper)
{
QuizzesViewModel viewmodel = objectMapper.Map <Model.Entities.Quiz, QuizzesViewModel>(quiz);
if (viewmodel != null)
{
Module quizModule = null;
try
{
quizModule = quiz.ModuleQuizs.FirstOrDefault().Module;
}
catch (Exception)
{
}
if (quizModule != null)
{
viewmodel.ModuleId = quizModule.Id;
viewmodel.ModuleTitle = quizModule.Title;
viewmodel.CourseId = quizModule.Course_Id;
}
}
return(viewmodel);
}
private static void AssertListMappingWorksFor <TSourceCollection, TTargetCollection>(IObjectMapperAdapter mapper)
where TSourceCollection : IEnumerable <int>
where TTargetCollection : IEnumerable <int>
{
var sourceValue = new[] { 5 }.AsEnumerable();
if (typeof(TSourceCollection) == typeof(ISet <int>))
{
sourceValue = new HashSet <int> {
5
}
}
;
mapper.CreateMap <Wrapper <TSourceCollection>, Wrapper <TTargetCollection> >();
var source = new Wrapper <TSourceCollection> {
Value = (TSourceCollection)sourceValue
};
var result = mapper.Map <Wrapper <TTargetCollection> >(source);
Assert.NotNull(result.Value);
Assert.Equal(sourceValue.ToArray(), result.Value.ToArray());
}