public async Task <AddEmployeeResponse> Handle(AddEmployeeRequest request, CancellationToken cancellationToken)
{
if (request.AuthenticatorRole == AppRole.Employee)
{
return(new AddEmployeeResponse()
{
Error = new ErrorModel(ErrorType.Unauthorized)
});
}
var employeeQuery = new GetUserQuery <Employee>()
{
Login = request.Login
};
var availableManager = await queryExecutor.Execute(employeeQuery);
if (availableManager != null)
{
return(new AddEmployeeResponse()
{
Error = new ErrorModel(ErrorType.Conflict)
});
}
var query = new GetCompanyQuery()
{
Id = request.CompanyId,
CompanyId = request.AuthenticatorCompanyId
};
var company = await queryExecutor.Execute(query);
if (company == null)
{
return(new AddEmployeeResponse
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var auth = passwordHasher.Hash(request.Password);
request.Password = auth[0];
request.Salt = auth[1];
var employee = mapper.Map <Employee>(request);
employee.Board = new Board();
var command = new AddEmployeeCommand()
{
Parameter = employee
};
var employeeFromDb = await commandExecutor.Execute(command);
employeeFromDb.Company.EmployeesList = null;
employeeFromDb.Company.Manager = null;
return(new AddEmployeeResponse()
{
Data = mapper.Map <EmployeeDto>(employeeFromDb)
});
}
public EmployeeViewModel(IEmployeeRepository employeeRepository, ISubdivisionRepository subdivisionRepository)
{
AddEmployeeCommand = new AddEmployeeCommand(this);
DeleteEmployeeCommand = new DeleteEmployeeCommand(this, employeeRepository);
SaveEmployeesCommand = new SaveEmployeesCommand(this, employeeRepository);
RefreshEmployeesCommand = new RefreshEmployeesCommand(this, employeeRepository, subdivisionRepository);
RefreshEmployeesCommand.Execute(null);
}
public IActionResult AddEmployee([FromBody] EmployeeDto employeeDto)
{
EnsureArg.IsNotNull(employeeDto);
var command = new AddEmployeeCommand(employeeDto);
CommandDispatcher.Execute(command);
return(NoContent());
}
public MainViewModel(IEmployeeRepository employeeRepository)
{
EmployeeRepository = employeeRepository;
Add = new AddEmployeeCommand(this);
Save = new SaveEmployeeCommand(this);
Delete = new DeleteEmployeeCommand(this);
Next = new SelectNextCommand(this);
Prev = new SelectPreviosCommand(this);
LoadPeople().Await(HandleException);
}
public string DispatchCommand(string[] commandParams, IServiceProvider serviceProvider)
{
string commandName = commandParams[0];
var commandArg = commandParams.Skip(1).ToArray();
string result = string.Empty;
switch (commandName)
{
case "AddEmployee":
var addEmployee = new AddEmployeeCommand(serviceProvider.GetService <EmployeeService>());
result = addEmployee.Execute(commandArg);
break;
case "SetBirthday":
var setBirthday = new SetBirthdayCommand(serviceProvider.GetService <EmployeeService>());
result = setBirthday.Execute(commandArg);
break;
case "SetAddress":
var setAddress = new SetAddressCommand(serviceProvider.GetService <EmployeeService>());
result = setAddress.Execute(commandArg);
break;
case "EmployeeInfo":
var employeeInfo = new EmployeeInfoCommand(serviceProvider.GetService <EmployeeService>());
result = employeeInfo.Execute(commandArg);
break;
case "EmployeePersonalInfo":
var employeePersonalInfo = new EmployeePersonalInfoCommand(serviceProvider.GetService <EmployeeService>());
result = employeePersonalInfo.Execute(commandArg);
break;
case "SetManager":
var setManager = new SetManagerCommand(serviceProvider.GetService <EmployeeService>());
result = setManager.Execute(commandArg);
break;
case "ManagerInfo":
var managerInfo = new ManagerInfoCommand(serviceProvider.GetService <EmployeeService>());
result = managerInfo.Execute(commandArg);
break;
case "ListEmployeesOlderThan":
var olderThan = new ListEmployeesOlderThanCommand(serviceProvider.GetService <EmployeeService>());
result = olderThan.Execute(commandArg);
break;
default: throw new InvalidOperationException("Invalid command!");
}
return(result);
}
public async Task <AddEmployeeResponse> AddEmployee(AddEmployeeCommand command)
{
var response = await _mediator.Send(command);
if (Notification.HasNotification())
{
return(null);
}
return(response);
}
public async Task <ActionResult <Result> > AddEmployee([FromBody] AddEmployeeCommand command)
{
var result = await Mediator.Send(command);
if (!result.Succeeded)
{
return(BadRequest(result));
}
return(Ok(result));
}
public void SetupTest()
{
this.addEmployeeUnderTest = new AddEmployeeCommand();
this.addEmployeeUnderTest.CanExecuteChanged += (object sender, EventArgs e) => { Console.WriteLine("CanExecuteChanged"); };
EmployeeDB.Instance = Substitute.For <IEmployeeDB>();
AddNewEmployeeViewModel.Instance = Substitute.For <IAddNewEmployeeViewModel>();
AddNewEmployeeViewModel.Instance.NewEmployee().Returns(new NewEmployee());
ClientDialogViewModel.Instance = Substitute.For <IClientDialogViewModel>();
}
public void OneSetUp()
{
viewProjectsCommand = new ViewProjectsCommand();
addEmployeeCommand = new AddEmployeeCommand();
changePasswordCommand = new ChangePasswordCommand();
editPersonalDataCommand = new EditPersonalDataCommand();
sendRequestCompanyViewCommand = new SendRequestCompanyViewCommand();
viewWorkersCommand = new ViewWorkersCommand();
workingHoursCommand = new WorkingHoursCommand();
logOutCommand = new LogOutCommand();
signInCommand = new SignInCommand();
defineUserStoriesCommand = new DefineUserStoriesCommand();
createProjectCommand = new CreateProjectCommand();
showCompaniesCommand = new ShowCompaniesCommand();
sendRequestProjectViewCommand = new SendRequestProjectViewCommand();
markProjectFinishedCommand = new MarkProjectFinishedCommand();
loadedCommand = new LoadedCommand();
editPositionCommand = new EditPositionCommand();
clientDialogViewModelUnderTest = new ClientDialogViewModel();
clientDialogViewModelUnderTest.AddEmployeeCommand = addEmployeeCommand;
clientDialogViewModelUnderTest.ChangePasswordCommand = changePasswordCommand;
clientDialogViewModelUnderTest.CreateProjectCommand = createProjectCommand;
clientDialogViewModelUnderTest.DefineUserStoriesCommand = defineUserStoriesCommand;
clientDialogViewModelUnderTest.EditPersonalDataCommand = editPersonalDataCommand;
clientDialogViewModelUnderTest.EditPositionCommand = editPositionCommand;
clientDialogViewModelUnderTest.ErrorMessage = "";
clientDialogViewModelUnderTest.LoadedCommand = loadedCommand;
clientDialogViewModelUnderTest.LogInUser = new LogInUser();
clientDialogViewModelUnderTest.LogOutCommand = logOutCommand;
clientDialogViewModelUnderTest.MarkProjectFinishedCommand = markProjectFinishedCommand;
clientDialogViewModelUnderTest.SendRequestCompanyViewCommand = sendRequestCompanyViewCommand;
clientDialogViewModelUnderTest.SendRequestProjectViewCommand = sendRequestProjectViewCommand;
clientDialogViewModelUnderTest.ShowCompaniesCommand = showCompaniesCommand;
clientDialogViewModelUnderTest.SignInCommand = signInCommand;
clientDialogViewModelUnderTest.ViewProjectsCommand = viewProjectsCommand;
clientDialogViewModelUnderTest.ViewWorkersCommand = viewWorkersCommand;
clientDialogViewModelUnderTest.Resources = new ObservableCollection <Employee>();
clientDialogViewModelUnderTest.PrResources = new ObservableCollection <Project>();
clientDialogViewModelUnderTest.EmpResource = new ObservableCollection <Employee>();
clientDialogViewModelUnderTest.OcResources = new ObservableCollection <OutsourcingCompany>();
clientDialogViewModelUnderTest.UsResources = new ObservableCollection <UserStory>();
LogInUser nov = clientDialogViewModelUnderTest.LogInUser;
string str = clientDialogViewModelUnderTest.ErrorMessage;
ObservableCollection <Employee> res1 = clientDialogViewModelUnderTest.Resources;
ObservableCollection <Project> res2 = clientDialogViewModelUnderTest.PrResources;
ObservableCollection <Employee> res3 = clientDialogViewModelUnderTest.EmpResource;
ObservableCollection <OutsourcingCompany> res4 = clientDialogViewModelUnderTest.OcResources;
ObservableCollection <UserStory> res5 = clientDialogViewModelUnderTest.UsResources;
}
public async Task <IActionResult> AddEmployee([FromBody] Employee employee)
{
_logger.Debug("Add new employee");
var command = new AddEmployeeCommand
{
Employee = employee
};
await _mediator.Send(command);
return(Ok());
}
public ActionResult Create(EmployeeViewModel employeeViewModel)
{
if (ModelState.IsValid)
{
var addEmployeeCommand = new AddEmployeeCommand();
Mapper.CreateMap<EmployeeViewModel, AddEmployeeCommand>().BeforeMap((s, d) => d.Password = s.ConfirmPassword);
Mapper.Map(employeeViewModel, addEmployeeCommand);
CommandProcessor.Process<AddEmployeeCommand, CommandResult>(addEmployeeCommand, ModelState);
if (!ModelState.IsValid)
return View();
return this.RedirectToAction(c => c.Index(null, null));
}
return View();
}
private Employee GetEmployeeFromCommand(AddEmployeeCommand command)
{
var birthDate = DateTime.UtcNow.AddYears(-30).Date;
var startDate = DateTime.UtcNow.AddYears(-1).Date;
return(new Employee
{
FirstName = "Awesome",
LastName = "Developer",
EmailAddress = "*****@*****.**",
IsAdmin = true,
PasswordHash = "secret",
StartDate = startDate,
BirthDate = birthDate
});
}
public async Task <IActionResult> AddEmployee([FromBody] AddEmployeeCommand command)
{
try
{
if (ModelState.IsValid)
{
var response = await _mediator.Send(command);
return(StatusCode(response.ResponseStatusCode, response.Value));
}
return(StatusCode(StatusCodes.Status400BadRequest));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex));
}
}
public override void Initialize(object parameter)
{
base.Initialize();
var companyID = (int)parameter;
IsBusy = true;
CompanyEditUoW.GetCompanyEdit(companyID,
(o, e) =>
{
IsBusy = false;
if (HasNoException(e))
{
Statuses = e.Object.Statuses;
Model = e.Object.Company;
AddEmployeeCommand.RaiseCanExecuteChanged();
}
});
}
// constructor
public EmployeeViewModel()
{
dbConnectionString = Properties.Settings.Default.DBConnectionString;
// initialize button enable logic
bCanDelete = false;
bCanAdd = true;
bCanEdit = false;
bCanUpdate = false;
bCanCancel = false;
// initialize control commands
AddEmployee = new AddEmployeeCommand(this);
EditEmployee = new EditEmployeeCommand(this);
UpdateEmployee = new UpdateEmployeeCommand(this);
DeleteEmployee = new DeleteEmployeeCommand(this);
CancelChanges = new CancelChangesCommand(this);
// retrieve employee list and populate DataGrid control
FillDataGrid();
SelectedItem = -1;
OnPropertyChanged("SelectedItem");
}
public async Task <ActionResult> Post([FromBody] AddEmployeeCommand command)
{
await Mediator.Send(command);
return(NoContent());
}
public async Task <AddEmployeeCommandResponse> AddEmployee([FromBody] AddEmployeeCommand employee)
{
return(await _mediator.Send(employee));
}
public async Task <IActionResult> Post(AddEmployeeCommand command)
{
await _mediator.Send(command);
return(Ok());
}
public async Task <IActionResult> AddEmployee([FromBody] AddEmployeeCommand command)
{
return(Ok(await Mediator.Send(command)));
}
public async Task <IActionResult> CreateAsync([FromBody] AddEmployeeCommand command)
{
var response = await _employeeAppService.AddEmployee(command);
return(CreateResponseOnPost(response, RouteResponseConsts.Employee));
}
public async Task <object> AddEmployeeAsync(AddEmployeeCommand command)
{
Employee employee = this.GetEmployeeFromCommand(command);
return(await this.session.SaveAsync(employee));
}
public async Task <IActionResult> Add([FromBody] AddEmployeeCommand request)
{
return(Ok(await _mediator.Send(request)));
}
