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