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)); }