public IDataResult <List <EmployeeDTO> > GetAll()
{
return(new DataResult <List <EmployeeDTO> >()
{
Data = Repo.GetAll().Result.Select(e => Mapper.Map(e)).ToList(),
Message = ResponseMessageType.None,
ResponseStatusType = ResponseStatusType.Successed
});
}
public IActionResult SaveEmployee(EmployeeModel employeeModel)
{
if (ModelState.IsValid == false)
{
return(Content("Model is invalid"));
}
EmployeeMapper mapper = new EmployeeMapper();
Employee employee = mapper.Map(employeeModel);
//ERROR: employee.Creator = CurrentUser;
if (employee.Id != 0)
{
DB.EmployeeRepository.Update(employee);
}
else
{
DB.EmployeeRepository.Add(employee);
}
TempData["Message"] = "Saved successfully";
return(RedirectToAction("Index"));
}
public ActionResult Edit(EmployeeViewModel employee)
{
if (ModelState.IsValid)
{
switch (employee.EditMode)
{
case EditState.UpdateEmployeeAndUser:
_unitOfWork.Employee_List.UpdateWithUser(EmployeeMapper.Map(employee),
_unitOfWork.Person_List.GetRoleNameForUserId(User.Identity.GetUserId()));
this.Ok();
return(RedirectToAction("Index", "Employee", null));
case EditState.UpdateEmployeeCreateUser:
_unitOfWork.Employee_List.UpdateAndCreateUser(EmployeeMapper.Map(employee),
_unitOfWork.Person_List.GetRoleNameForUserId(User.Identity.GetUserId()), employee.Password);
this.Ok();
return(RedirectToAction("Index", "Employee", null));
case EditState.UpdateEmployee:
_unitOfWork.Employee_List.Update(EmployeeMapper.Map(employee));
this.Ok();
return(RedirectToAction("Index", "Employee", null));
default:
break;
}
}
Forbidden();
return(Content(GenerateError()));
}
public async Task <IActionResult> Post([FromBody] EmployeeSaveRequestDto dto)
{
var employee = EmployeeMapper.Map(dto);
await _employeeCreator.CreateAsync(employee);
return(Ok());
}
public async Task <IActionResult> Put(int id, [FromBody] EmployeeSaveRequestDto dto)
{
var employee = EmployeeMapper.Map(dto);
await _employeeUpdater.UpdateAsync(id, employee);
return(Ok());
}
public override void Execute(object parameter)
{
List <Employee> employees = DB.EmployeeRepository.Get();
List <EmployeeModel> employeeModels = new List <EmployeeModel>();
EmployeeMapper employeeMapper = new EmployeeMapper();
for (int i = 0; i < employees.Count; i++)
{
Employee employee = employees[i];
EmployeeModel employeeModel = employeeMapper.Map(employee);
employeeModel.No = i + 1;
employeeModels.Add(employeeModel);
}
Enumeration.Enumerate(employeeModels);
EmployeeViewModel employeeViewModel = new EmployeeViewModel();
employeeViewModel.AllEmployees = employeeModels;
employeeViewModel.Employees = new ObservableCollection <EmployeeModel>(employeeModels);
EmployeesControl employeesControl = new EmployeesControl();
employeesControl.DataContext = employeeViewModel;
MainWindow mainWindow = (MainWindow)mainViewModel.Window;
mainWindow.GrdCenter.Children.Clear();
mainWindow.GrdCenter.Children.Add(employeesControl);
}
public async Task UpdateEmployeeAsync(Employee employee)
{
var employeeDb = EmployeeMapper.Map(employee);
defaultDbContext.EmployeeDbs.Update(employeeDb);
await defaultDbContext.SaveChangesAsync().ConfigureAwait(false);
}
public void IdIsMapped()
{
Guid id = Guid.NewGuid();
source = new Application.Employee(id, "lastName", "firstName", "title", null, false);
destination = sut.Map(source);
Assert.AreEqual(id, destination.Id);
}
// GET: Employee
public async Task <IActionResult> Index(string searchString)
{
try
{
IEnumerable <EmployeeDto> employeeDtos = await _employeeService.GetChosenEmployees(searchString);
return(View(EmployeeMapper.Map(employeeDtos)));
}
catch (Exception)
{
ErrorViewModel model = new ErrorViewModel {
RequestId = "Søgningen kunne ikke gennemføres"
};
return(View("Error", model));
}
}
public IActionResult Index(string sortBy)
{
var model = new HomeIndexViewModel();
var posts = this._postService.GetAll();
var employees = EmployeeMapper.Map(_employeeService.GetAll().ToList(), _userManager.Users.ToList());
model.Posts = posts.ToList();
model.Employees = employees;
if (sortBy == "up")
{
model.Posts.Sort(new SortPosts());
}
else if (sortBy == "down")
{
model.Posts.Sort(new SortPostsDown());
}
return(View(model));
}
public async Task <IResult <EmployeeDto> > GetByIdAsync(int id)
{
try
{
var result = await _employeeRepository.GetByIdAsync(id);
if (result == null)
{
throw new ValidationException($"Id : {id} does not exist.");
}
return(await Result <EmployeeDto> .SuccessAsync(EmployeeMapper.Map(result)));
}
catch (Exception ex)
{
_logger.Log(LogLevel.Error, ex, $"Error when calling EmployeeService.GetByIdAsync({id})");
throw;
}
}
public IActionResult GetEmployee(int id)
{
if (id != 0)
{
Employee employee = DB.EmployeeRepository.Get(id);
if (employee == null)
{
return(Content("Filial tapılmadı"));
}
EmployeeMapper mapper = new EmployeeMapper();
EmployeeModel model = mapper.Map(employee);
return(View(model));
}
return(View(new EmployeeModel()));
}
public IActionResult Index()
{
ViewBag.Message = TempData["Message"];
List <Employee> employees = DB.EmployeeRepository.Get();
ViewModel <EmployeeModel> viewModel = new ViewModel <EmployeeModel>();
EmployeeMapper employeeMapper = new EmployeeMapper();
foreach (var employee in employees)
{
var employeeModel = employeeMapper.Map(employee);
viewModel.Models.Add(employeeModel);
}
Enumeration <EmployeeModel> .Enumerate(viewModel.Models);
return(View(viewModel));
}
public ActionResult Create(EmployeeViewModel employee)
{
if (ModelState.IsValid)
{
if (employee.CreateUser)
{
_unitOfWork.Employee_List.AddWithUser(EmployeeMapper.Map(employee),
_unitOfWork.Person_List.GetRoleNameForUserId(User.Identity.GetUserId()),
employee.Password);
}
else
{
_unitOfWork.Employee_List.Add(EmployeeMapper.Map(employee));
}
Ok();
return(RedirectToAction("Index", "Employee", null));
}
Forbidden();
return(Content(GenerateError()));
}
public override void Execute(object parameter)
{
//TODO: Validate
EmployeeMapper employeeMapper = new EmployeeMapper();
Employee employee = employeeMapper.Map(employeeAddViewModel.CurrentEmployee);
employee.Creator = Kernel.CurrentUser;
if (employee.Id != 0)
{
DB.EmployeeRepository.Update(employee);
}
else
{
DB.EmployeeRepository.Add(employee);
}
MessageBox.Show(UIMessages.OperationSuccessMessage, "Information", MessageBoxButton.OK, MessageBoxImage.Information);
employeeAddViewModel.CurrentWindow.Close();
}
public override void Execute(object parameter)
{
SureDialogViewModel sureViewModel = new SureDialogViewModel
{
DialogText = UIMessages.DeleteSureMessage
};
SureDialog dialog = new SureDialog
{
DataContext = sureViewModel
};
dialog.ShowDialog();
if (dialog.DialogResult == true)
{
EmployeeMapper mapper = new EmployeeMapper();
Employee employee = mapper.Map(employeeViewModel.CurrentEmployee);
employee.IsDeleted = true;
employee.Creator = Kernel.CurrentUser;
DB.EmployeeRepository.Update(employee);
int no = employeeViewModel.SelectedEmployee.No;
employeeViewModel.Employees.Remove(employeeViewModel.SelectedEmployee);
List <EmployeeModel> employeeModelList = employeeViewModel.Employees.ToList();
Enumeration.Enumerate(employeeModelList, no - 1);
employeeViewModel.AllEmployees = employeeModelList;
employeeViewModel.UpdateDataFiltered();
employeeViewModel.SelectedEmployee = null;
employeeViewModel.CurrentEmployee = new EmployeeModel();
MessageBox.Show(UIMessages.OperationSuccessMessage, "Information", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
//-----------------------------
public async Task <IActionResult> Create([Bind("Id,Name,Phone,Salary,Active")] EmployeeViewModel employeeViewModel)
{
try
{
if (ModelState.IsValid)
{
await _employeeService.AddAsync(EmployeeMapper.Map(employeeViewModel)).ConfigureAwait(false);
return(RedirectToAction(nameof(Index)));
//_context.Add(employeeViewModel);
//await _context.SaveChangesAsync();
//return RedirectToAction(nameof(Index));
}
return(View(employeeViewModel));
}
catch (Exception)
{
ErrorViewModel model = new ErrorViewModel {
RequestId = "Medarbejderen kunne ikke oprettes"
};
return(View("Error", model));
}
}
public PersonnelWithContractDetails Details(int id, string deductionCode, int?fromYear, int?toYear)
{
var detailsRecord = (from employee in _context.AcctEmployee
join personnel in _context.AcctPersonnel on employee.Ssnumber equals personnel.Ssnumber
join jobCodeRecord in _context.AcctPayrollJobCodes on employee.JobCode equals jobCodeRecord.JobCode into employeeJobCode
from jobCode in employeeJobCode.DefaultIfEmpty()
where employee.Id == id
select new
{
Peronnel = PersonnelMapper.Map(personnel),
Contract = EmployeeMapper.Map(employee),
JobCode = (jobCode == null) ? null : JobCodeMapper.Map(jobCode)
}
).SingleOrDefault();
if (detailsRecord != null)
{
var deductions = _context.AcctEmployeeMiscDeductions.Where(t => t.EmployeeNumber == detailsRecord.Contract.PersonNumber &&
(string.IsNullOrWhiteSpace(deductionCode) || t.MiscCode == deductionCode.Trim()) &&
(fromYear == null || t.MiscYear.Value >= fromYear.Value) &&
(toYear == null || t.MiscYear.Value <= toYear.Value))
.OrderBy(t => t.MiscYear)
.Select(DeductionMapper.Map)
.ToList();
var ytdHistories = _context.AcctEmployeeYtdhistory.Where(t => t.Ssnumber == detailsRecord.Contract.SSNumber &&
(fromYear == null || t.Year.Value >= fromYear.Value) &&
(toYear == null || t.Year.Value <= toYear.Value))
.OrderBy(t => t.Year)
.Select(YtdHistoryMapper.Map)
.ToList();
return(EmployeeMapper.Map(detailsRecord.Peronnel, detailsRecord.Contract, detailsRecord.JobCode, deductions, ytdHistories));
}
else
{
return(null);
}
}
public override void Execute(object parameter)
{
EmployeeAddWindow employeeAddWindow = new EmployeeAddWindow();
EmployeeAddViewModel employeeAddViewModel = new EmployeeAddViewModel
{
CurrentEmployee = employeeViewModel.CurrentEmployee,
CurrentWindow = employeeAddWindow
};
employeeAddWindow.DataContext = employeeAddViewModel;
employeeAddWindow.WindowStyle = System.Windows.WindowStyle.None;
employeeAddWindow.AllowsTransparency = true;
employeeAddWindow.WindowStartupLocation = System.Windows.WindowStartupLocation.CenterScreen;
employeeAddWindow.ShowDialog();
List <Employee> employees = DB.EmployeeRepository.Get();
List <EmployeeModel> employeeModels = new List <EmployeeModel>();
EmployeeMapper employeeMapper = new EmployeeMapper();
for (int i = 0; i < employees.Count; i++)
{
Employee employee = employees[i];
EmployeeModel employeeModel = employeeMapper.Map(employee);
employeeModels.Add(employeeModel);
}
Enumeration.Enumerate(employeeModels);
employeeViewModel.AllEmployees = employeeModels;
employeeViewModel.Employees = new ObservableCollection <EmployeeModel>(employeeModels);
employeeViewModel.CurrentEmployee = new EmployeeModel();
}
public IEnumerable <EmployeeDto> GetFilteredCustomers(string searchString)
{
return(_employeeService.GetFilteredEmployees(searchString).Select(a => EmployeeMapper.Map(a)));
}
public IEnumerable <EmployeeDto> GetEmployees()
{
IEnumerable <Entities.Employee> employees = _employeeRepository.GetEmployees();
return(_employeeMapper.Map(employees));
}
public IEnumerable <EmployeeQueryModel> GetAll()
{
IEnumerable <EmployeeEntity> employeeEntityList = _employeeStore.GetAll();
return(_employeeMapper.Map(employeeEntityList));
}
public async Task <Employee> GetEmployeeAsync(int id)
{
var employeeDb = await defaultDbContext.EmployeeDbs.FindAsync(id).ConfigureAwait(false);
return(EmployeeMapper.Map(employeeDb));
}
public async Task <ActionResult <EmployeeResponseDto> > Get(string name)
{
var result = await _employeeReader.GetByNameAsync(name);
return(EmployeeMapper.Map(result));
}
public IEnumerable <EmployeeDto> Get()
{
return(_employeeService.GetAll().Select(a => EmployeeMapper.Map(a)));
}
public async Task <ActionResult <EmployeeResponseDto> > EmployeeWithMaxSum()
{
var result = await _salaryReader.GetEmployeeWithMaxSalaryAsync();
return(EmployeeMapper.Map(result));
}
//[ApiVersion("1.1")]
public EmployeeDto Get(int id)
{
return(EmployeeMapper.Map(_employeeService.Get(id)));
}
public void Put(int id, [FromBody] EmployeeDto value)
{
_employeeService.Update(EmployeeMapper.Map(value));
}
public void Post([FromBody] EmployeeDto value)
{
_employeeService.Create(EmployeeMapper.Map(value));
}
