public async Task <ActionResult> Create(AddEmployeeDto employeeDto) { if (ModelState.IsValid) { var userManager = HttpContext.GetOwinContext().GetUserManager <ApplicationUserManager>(); var employee = new ApplicationUser { Id = Guid.NewGuid().ToString(), UserName = employeeDto.Email, Email = employeeDto.Email, EmployeeInfo = new EmployeeInfo() { Receive = employeeDto.Receive, Stow = employeeDto.Stow, Pick = employeeDto.Pick, Pack = employeeDto.Pack, Ship = employeeDto.Ship, } }; var result = await userManager.CreateAsync(employee, employeeDto.Password); if (result.Succeeded) { userManager.AddToRole(employee.Id, "Employee"); return(RedirectToAction("Details", new { id = employee.Id })); } AddErrors(result); } return(View(employeeDto)); }
public ActionResult Create(AddEmployeeDto addEmployeeDto) { Employee employee = new Employee() { Name = addEmployeeDto.Name }; EmployeeRepository.AddEmployee(employee); BackgroundJob.Enqueue(() => AddNewEvent(employee.Name)); return(Redirect("/")); }
public async Task <ActionResult <Employee> > AddEmployee(AddEmployeeDto employee) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var domainEmployee = _mapper.Map <Employee>(employee); var addedEmployee = await _employeeHandler.AddEmployee(domainEmployee); return(CreatedAtAction(nameof(GetEmployeeWithDetails), new { id = addedEmployee.Id }, addedEmployee)); }
public ResponseDto <AddEmployeeDto> AddEmployeeData() { var pageLoadService = _iocContext.Resolve <IPageLoad>(); var responseDto = new ResponseDto <AddEmployeeDto>(); AddEmployeeDto data = new AddEmployeeDto(); data.Bands = pageLoadService.GetBand(); data.Designation = pageLoadService.GetDesignation(); responseDto.Data = data ?? null; return(responseDto); }
public async Task <ServiceResponse <List <GetEmployeeDto> > > AddEmployee(AddEmployeeDto newEmployee) { ServiceResponse <List <GetEmployeeDto> > serviceResponse = new ServiceResponse <List <GetEmployeeDto> >(); Employee employee = this.mapper.Map <Employee>(newEmployee); await this.context.Employees.AddAsync(employee); await this.context.SaveChangesAsync(); serviceResponse.Data = (this.context.Employees.Select(c => this.mapper.Map <GetEmployeeDto>(c))).ToList(); return(serviceResponse); }
public async Task <IActionResult> Post([FromBody] AddEmployeeDto item) { try { if (item == null) { return(BadRequest()); } var contact = new Contact() { FirstName = item.FirstName, LastName = item.LastName, Phone = item.Phone, MobilePhone = item.MobilePhone, Email = item.Email, OfficialEmail = item.OfficialEmail, PhysicalStreet = item.Street, PhysicalState = item.State, PhysicalCity = item.City, PhysicalZipCode = item.ZipCode, PhysicalCountry = item.Country }; var emp = new Employee() { ContactId = contact.Id, EmployeeTypeId = item.EmployeeTypeId, DesignationId = item.DesignationId, IsUnderProbation = item.IsUnderProbation, EmployeeStatusId = item.EmployeeStatusId, HiredAt = DateTime.Now, ABAAccountName = item.ABAAccountName, ABAAccountNumber = item.ABAAccountName, Remarks = item.Remarks }; _context.Contacts.Add(contact); emp.Contact = contact; _context.Employees.Add(emp); await _context.SaveChangesAsync(); return(Ok(emp.Id)); } catch (Exception e) { _logger.LogError("API_ERR | POST_EMPLOYEE | item: {0} | ERR: {1}", JsonConvert.SerializeObject(item), e.StackTrace.ToString()); return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public async Task AddEmployee_InvalidEmployeePassed_ReturnsBadRequest() { var employee = new AddEmployeeDto() { FirstName = "Jonas", LastName = "Mant" }; _controller.ModelState.AddModelError("Gender", "Required"); var badResponse = await _controller.AddEmployee(employee); Assert.That(badResponse.Result, Is.TypeOf(typeof(BadRequestObjectResult))); }
public async Task <ServiceResponse <List <GetEmployeeDto> > > Add(AddEmployeeDto newEmployee) { var response = new ServiceResponse <List <GetEmployeeDto> >(); try { var converted = _mapper.Map <Employee>(newEmployee); var account = new Account { Amount = Calculator.TotalPaidYearly(26, 2000), CreatedDate = DateTime.Now }; await _context.Accounts.AddAsync(account); converted.Account = account; foreach (var dependent in newEmployee.Dependents) { var newDependent = new Dependent { FirstName = dependent.FirstName, MiddleName = dependent.MiddleName, LastName = dependent.LastName, Relationship = dependent.Relationship }; await _context.Dependents.AddAsync(newDependent); converted.Dependents.Add(newDependent); } await _context.Employees.AddAsync(converted); await _context.SaveChangesAsync(); response.Data = _context.Employees.Select(e => _mapper.Map <GetEmployeeDto>(e)).ToList(); } catch (Exception ex) { response.Success = false; response.Message = ex.Message; } return(response); }
public String AddEmployee(AddEmployeeDto addEmployeeDto) { DAL.employee em = new DAL.employee(); em.Name = addEmployeeDto.Name; em.Password = addEmployeeDto.Password; DAL.employee em1 = DbContext.employee.Where(n => n.Name == addEmployeeDto.Name && n.Password == addEmployeeDto.Password).SingleOrDefault(); if (em == em1) { return("Deja exista"); } DbContext.employee.Add(em); DbContext.SaveChanges(); return("adaugat"); }
public async Task <IActionResult> CreateEmployee(AddEmployeeDto model) { try { var employee = _mapper.Map <Employee>(model); if (!await _manager.CreateEmployee(employee)) { return(Ok(new JsonMessageResult("创建失败!", 0, 0))); } return(CreatedAtAction(nameof(GetEmployee), new { employee.Id }, employee)); } catch (Exception e) { _logger.LogError(e, e.Message); return(Ok(new JsonMessageResult(e.Message, 0, 0))); } }
public async Task AddEmployee_ValidEmployeePassed_ReturnsCreatedResponse() { var employee = new AddEmployeeDto() { FirstName = "Tom", LastName = "Hardy", Bio = null, DOB = DateTime.Now, Email = "*****@*****.**", Gender = "Male", Phone = "623466", EmployeeTypeId = 1 }; var createdResponse = await _controller.AddEmployee(employee); Assert.That(createdResponse.Result, Is.TypeOf(typeof(CreatedAtActionResult))); }
public async Task <ServiceResponse <GetEmployeeDto> > AddEmployee(AddEmployeeDto newEmployee) { try { var position = await _dbContext.Positions.FirstOrDefaultAsync(x => x.Id == newEmployee.PositionId); //Check Position if (position is null) { return(ResponseResult.Failure <GetEmployeeDto>("Position not found")); } var department = await _dbContext.Departments.FirstOrDefaultAsync(x => x.Id == newEmployee.DepartmentId); //Check Department if (department is null) { return(ResponseResult.Failure <GetEmployeeDto>("Department not found")); } //assign value var employee_new = new Employee { Name = newEmployee.Name, LastName = newEmployee.LastName, PositionId = newEmployee.PositionId, DepartmentId = newEmployee.DepartmentId }; //insert database _dbContext.Employees.Add(employee_new); await _dbContext.SaveChangesAsync(); //mapper Dto and return var dto = _mapper.Map <GetEmployeeDto>(employee_new); _log.LogInformation($"Add employee Success"); return(ResponseResult.Success(dto, "Success")); } catch (Exception ex) { _log.LogError(ex.Message); return(ResponseResult.Failure <GetEmployeeDto>(ex.Message)); } }
public async Task <IActionResult> AddEmployee(AddEmployeeDto newEmployee) { return(Ok(await _comService.AddEmployee(newEmployee))); }
public void AddEmployee(AddEmployeeDto addEmployeeDto) { var employee = new Employee(addEmployeeDto.Name, addEmployeeDto.LastName, addEmployeeDto.Email); officeRepository.AddEmployee(addEmployeeDto.OfficeId, employee); }
public ActionResult Create() { var addEmployeeDto = new AddEmployeeDto(); return(View(addEmployeeDto)); }
public IActionResult AddEmployee(AddEmployeeDto value) { officeAppService.AddEmployee(value); return(Ok()); }
public async Task <IActionResult> AddNewInstance([FromBody] AddEmployeeDto newInstance) { if (!ModelState.IsValid) { return(BadRequest()); } if (newInstance.ParentId.HasValue) //dodavanje postojecem nodu u stablu { //dohvati roditelja nove instance Employee parent = await _context.Employees.FindAsync(newInstance.ParentId.Value); if (parent is null) //roditelj ne postoji { return(NotFound()); } //dohvati zadnje dodano dijete danog roditelja var lastAddedItemOfParent = await _context.Employees .Where(x => x.HierarchyId.GetAncestor(1) == parent.HierarchyId) .OrderByDescending(x => x.HierarchyId) .FirstOrDefaultAsync(); //kreiraj novu instancu koristenjem HierarchyId roditelja i zadnjeg djeteta (ako postoji) var newInstnace = new Employee { Name = newInstance.Name, //Treba poceti sa HierarchyId roditelja i treba biti veci od zadnjeg djeteta //tipa ako roditelj pocinje sa 3, a zadnje dodano dijete je 3/1, onda ce novo dijete imati 3/2 HierarchyId = parent.HierarchyId.GetDescendant(lastAddedItemOfParent?.HierarchyId ?? null, null) }; //dodaj u kolekciju i spremi u bazu _context.Employees.Add(newInstnace); await _context.SaveChangesAsync(); //NewChild treba imati veci HierarchyId od LastAddedChild u slucaju da je LastAddedChild != null //Ako je LastAddedChild null znaci da je dodano prvo dijete za danog roditelja return(Ok(new { LastAddedChild = (lastAddedItemOfParent != null) ? new EmployeeDto { Id = lastAddedItemOfParent.Id, Hierarchy = lastAddedItemOfParent.HierarchyId.ToString(), Level = lastAddedItemOfParent.HierarchyId.GetLevel(), Name = lastAddedItemOfParent.Name } : null, NewChild = new EmployeeDto { Id = newInstnace.Id, Hierarchy = newInstnace.HierarchyId.ToString(), Level = newInstnace.HierarchyId.GetLevel(), Name = newInstnace.Name } })); } else { //dohvati zadnje dodano dijete na prvoj razini var lastItemInCurrentLevel = _context.Employees .Where(x => x.HierarchyId.GetLevel() == 1) .OrderByDescending(x => x.HierarchyId) .FirstOrDefault(); if (lastItemInCurrentLevel is null) //dodajemo prvi root element { var newInstnace = new Employee { Name = newInstance.Name, HierarchyId = HierarchyId.Parse("/1/") }; _context.Employees.Add(newInstnace); await _context.SaveChangesAsync(); return(Ok(new EmployeeDto { Id = newInstnace.Id, Hierarchy = newInstnace.HierarchyId.ToString(), Level = newInstnace.HierarchyId.GetLevel(), Name = newInstnace.Name })); } //DRUGI SOLUTION //Kao root moguce je koristiti primary key novog dodanog elementa (losa praksa) //Tipa ako je primary key 10 onda ce HierarchyId biti /10/ i brojevi nece ici redom //postoji vec root element i dodajemo novog //nije ni ovo dobro rjesenje. Ako dode do dva zahtjeva u isto vrijeme jedan ce proci a jedan nece var nextHierarchyId = lastItemInCurrentLevel.HierarchyId.GetNextRootId(); var newInstnace2 = new Employee { Name = newInstance.Name, HierarchyId = HierarchyId.Parse($"/{nextHierarchyId}/") }; _context.Employees.Add(newInstnace2); await _context.SaveChangesAsync(); return(Ok(new EmployeeDto { Id = newInstnace2.Id, Hierarchy = newInstnace2.HierarchyId.ToString(), Level = newInstnace2.HierarchyId.GetLevel(), Name = newInstnace2.Name })); } }
public async Task <IActionResult> AddEmployee([FromBody] AddEmployeeDto newEmployee) { return(Ok(await _employeeService.Add(newEmployee))); }