public async Task <Command> Handle(Command request, CancellationToken cancellationToken)
{
var user = await _context.UserProfiles.FirstOrDefaultAsync(x => x.Email == request.UserName, cancellationToken);
var status = await _context.MyTaskStatuses.FirstOrDefaultAsync(s => s.Id == request.Status.Id, cancellationToken);
if (user == null)
{
return(null);
}
var myTask = _mapperWrapper.Map <Command, MyTask>(request);
myTask.UserProfile = user;
myTask.UserProfileId = user.Id;
myTask.Status = status;
_context.Tasks.Add(myTask);
await _context.SaveChangesAsync(cancellationToken);
var result = _mapperWrapper.Map <MyTask, AddMyTask.Command>(myTask);
myTask.UserProfileId = 0;
return(result);
}
public SettingsModel GetByUserId(int id)
{
_logger.LogInformation("Start method GetByUserId in settings service");
var settings = _queryableDbProvider.Set <Settings>().Include(x => x.User).FirstOrDefault(x => x.UserId == id);
var settingsModels = _mapperWrapper.Map <Settings, SettingsModel>(settings);
_logger.LogInformation("Method GetByUserId is complete");
return(settingsModels);
}
public List <DepartmentViewModel> GetAll()
{
_logger.LogInformation("Start method GetAllAsync in DepartmentController");
var departmentModels = _departmentService.GetAll();
_logger.LogInformation("Map department model to department view model");
var models = _mapperWrapper.Map <List <DepartmentModel>, List <DepartmentViewModel> >(departmentModels).ToList();
_logger.LogInformation("Mappings is complete");
_logger.LogInformation("Method GetAllAsync in DepartmentController is complete");
return(models);
}
public void Init()
{
_employeeDetailsViewModel.EmployeeViewModel = new EmployeeViewModel
{
Id = 1,
DepartmentId = 1,
};
_employeeDetailsViewModel.CurrentEmployeeViewModel = new EmployeeViewModel
{
Id = 1,
DepartmentId = 1,
};
A.CallTo(() => _mapperWrapper.Map <EmployeeViewModel, EmployeeModel>(A <EmployeeViewModel> .Ignored))
.ReturnsLazily(
(EmployeeViewModel employeeViewModel) => new EmployeeModel
{
Id = employeeViewModel.Id,
DepartmentId = employeeViewModel.DepartmentId,
});
A.CallTo(() => _mapperWrapper.Map(A <EmployeeModel> .Ignored, A <EmployeeViewModel> .Ignored)).Invokes(
(EmployeeModel original, EmployeeViewModel copy) =>
{
copy.Id = original.Id;
copy.DepartmentId = original.DepartmentId;
});
A.CallTo(() => _employeeService.CreateAsync(A <EmployeeModel> .Ignored)).ReturnsLazily(
(EmployeeModel employeeModel) => employeeModel);
A.CallTo(() => _mapperWrapper.Map(A <EmployeeViewModel> .Ignored, A <EmployeeViewModel> .Ignored))
.Invokes(
(EmployeeViewModel original, EmployeeViewModel copy) =>
{
copy.Id = original.Id;
copy.DepartmentId = original.DepartmentId;
});
A.CallTo(() => _mapperWrapper.Map <EmployeeViewModel, EmployeeViewModel>(A <EmployeeViewModel> .Ignored))
.ReturnsLazily(
(EmployeeViewModel employeeViewModel) => new EmployeeViewModel
{
Id = employeeViewModel.Id,
DepartmentId = employeeViewModel.DepartmentId
});
_employeeDetailsViewModel.UpdateEmployeeHandler += () => _eventTrigger = true;
}
public void Init()
{
var employeeModels = new List <EmployeeModel>
{
new EmployeeModel
{
DepartmentId = 2,
DepartmentName = "DepartmentName1"
},
new EmployeeModel
{
DepartmentId = 2,
DepartmentName = "DepartmentName2"
}
};
A.CallTo(() => _departmentService.GetByDepartmentIdAsync(A <int> .Ignored)).Returns(new DepartmentModel
{
Id = 2,
Name = "Name1"
});
A.CallTo(() => _employeeService.GetByDepartmentIdAsync(A <int> .Ignored))
.ReturnsLazily((int id) => employeeModels.Where(x => x.DepartmentId == id).ToList());
A.CallTo(() => _mapperWrapper.Map <EmployeeModel, EmployeeViewModel>(A <EmployeeModel> .Ignored))
.ReturnsLazily(
(EmployeeModel employeeModel) => new EmployeeViewModel
{
DepartmentId = employeeModel.DepartmentId,
DepartmentName = employeeModel.DepartmentName
});
A.CallTo(() =>
_mapperWrapper.Map <List <EmployeeModel>, List <EmployeeViewModel> >(A <List <EmployeeModel> > .Ignored))
.ReturnsLazily(
(List <EmployeeModel> employees) =>
{
var list = new List <EmployeeViewModel>();
employees.ForEach(x => list.Add(_mapperWrapper.Map <EmployeeModel, EmployeeViewModel>(x)));
return(list);
});
A.CallTo(() => _resourceManagerService.GetString(A <string> .Ignored)).ReturnsLazily((string local) => local);
}
protected override Model Handle(Command request)
{
var entity = _context.UserProfiles.FirstOrDefault(x => x.Email == request.UserName);
if (entity != null)
{
entity.FirstName = request.FirstName;
entity.LastName = request.LastName;
}
else
{
entity = _mapperWrapper.Map <Command, UserProfile>(request);
_context.UserProfiles.Add(entity);
}
_context.SaveChanges();
return(_mapperWrapper.Map <UserProfile, Model>(entity));
}
public void Create(DepartmentModel departmentModel)
{
var department = _mapperWrapper.Map <DepartmentModel, Department>(departmentModel);
_updateDbProvider.Add(department);
}
public void AutoMapper_ConvertFromEmployeeModel_EmployeeViewModel_Correct()
{
var employeeViewModel = _mapperWrapper.Map <EmployeeModel, EmployeeViewModel>(_employeeModel);
AssertPropertyValue(_employeeModel, employeeViewModel);
}
public EmployeeModel GetById(int employeeId)
{
var employee = _queryableDbProvider.Set <Employee>().Include(x => x.Department).FirstOrDefault(x => x.Id == employeeId);
return(_mapperWrapper.Map <Employee, EmployeeModel>(employee));
}
public Task <IdentityResult> CreateAsync(UserModel user, CancellationToken cancellationToken)
{
_updateDbProvider.Add(_mapperWrapper.Map <UserModel, User>(user));
return(Task.FromResult(IdentityResult.Success));
}
public EmployeeViewModel GetById(int id)
{
return(_mapperWrapper.Map <EmployeeModel, EmployeeViewModel>(_employeeService.GetById(id)));
}