public async Task <EmployeeDetailsDto> GetById(int id)
{
using var connection = await this.db.Open();
SqlCommand command = new SqlCommand("sp_GetById", connection);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.Add("@Id", SqlDbType.Int).Value = id;
var data = command.ExecuteReader();
EmployeeDetailsDto employee = new EmployeeDetailsDto();
while (data.Read())
{
employee.EmployeeID = (int)data["EmployeeID"];
employee.FullName = (string)data["FullName"];
employee.Salary = (decimal)data["Salary"];
employee.DepartamentName = (string)data["DepartamentName"];
employee.HireDate = Convert.ToDateTime(data["HireDate"]).ToString("dd/MM/yyyy");
}
return(employee);
}
public async Task <EmployeeDetailsDto> GetDetailsByIdAsync(long employeeId)
{
string cacheKey = EmployeeCacheKeys.GetDetailsKey(employeeId);
EmployeeDetailsDto employeeDetails = await _distributedCache.GetAsync <EmployeeDetailsDto>(cacheKey);
if (employeeDetails == null)
{
Expression <Func <Employee, EmployeeDetailsDto> > selectExp = e => new EmployeeDetailsDto
{
EmployeeId = e.Id,
EmployeeName = e.Name,
DepartmentId = e.DepartmentId,
DepartmentName = e.Department.Name,
DateOfBirth = e.DateOfBirth,
Email = e.Email,
PhoneNumber = e.PhoneNumber,
IsActive = e.IsActive,
CreatedAtUtc = e.CreatedAtUtc,
LastModifiedAtUtc = e.LastModifiedAtUtc
};
employeeDetails = await _repository.GetByIdAsync(employeeId, selectExp);
await _distributedCache.SetAsync <EmployeeDetailsDto>(cacheKey, employeeDetails);
}
return(employeeDetails);
}
public async Task <IActionResult> GetEmployeeDetails(int employeeId)
{
EmployeeDetailsDto employeeDetailsDto = await _employeeService.GetEmployeeDetailsAsync(employeeId);
EmployeeDetailsModel employeeDetailsModel = _mapper.Map <EmployeeDetailsModel>(employeeDetailsDto);
return(Ok(employeeDetailsModel));
}
public async Task <EmployeeDetailsDto> GetDetailsByIdAsync(int employeeId)
{
employeeId.ThrowIfNotPositive(nameof(employeeId));
EmployeeDetailsDto employeeDetailsDto = await _employeeCacheRepository.GetDetailsByIdAsync(employeeId);
return(employeeDetailsDto);
}
public virtual void UpdateDataEmp(EmployeeDetailsDto newEmployee, Company newcompany)
{
//PersonType = newintern.PersonType;
FName = newEmployee.Firstname;
LName = newEmployee.Lastname;
DateOfBirth = newEmployee.BirthDate;
Company = newcompany;
//Salary.Amount = newcontractor.Salary;
WorkExp = newEmployee.WorkExp;
Role = newEmployee.Role;
Department = newEmployee.Department;
}
public async Task <IActionResult> Delete(string id, EmployeeDetailsDto collection)
{
try
{
await _mendelCoreServices.DeleteEmployee(id);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public async Task <ActionResult <EmployeeDetailsDto> > GetDetailsById(int employeeId)
{
try
{
EmployeeDetailsDto employeeDetailsDto = await _employeeService.GetDetailsByIdAsync(employeeId);
return(employeeDetailsDto);
}
catch (Exception exception)
{
await _exceptionLogger.LogAsync(exception);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
internal void ConvertToDto(EmployeeDetailsDto newEmployee)
{
newEmployee.Id = Id;
newEmployee.PersonType = PersonType;
newEmployee.Firstname = Firstname;
newEmployee.Lastname = Firstname;
newEmployee.BirthDate = BirthDate;
newEmployee.City = City;
newEmployee.Street = Street;
newEmployee.Salary = Salary;
newEmployee.WorkExp = WorkExp;
newEmployee.CompanyId = CompanyId;
newEmployee.Department = Department;
newEmployee.Role = Role;
}
public async Task UpdateEmployeeRecord(EmployeeDetailsDto employee)
{
var entity = new Employee()
{
UpdatedDate = DateTime.Now,
DepartmentId = employee.DepartmentId,
Email = employee.Email,
FirstName = employee.FirstName,
LastName = employee.LastName,
Number = employee.Number,
Title = employee.Title,
TaxId = employee.TaxId
};
await _employeeRepository.Update(entity);
}
public void UpdateEmployee(Person currentEmployee, EmployeeDetailsDto newEmployee, Company newCompany, Salary currentSalary)
{
using (var transaction = _session.BeginTransaction())
{
try
{
var employee = (Employee)currentEmployee;
employee.UpdateDataEmp(newEmployee, newCompany);
currentSalary.ChangeSalary(newEmployee.Salary);
transaction.Commit();
}
catch (Exception ex)
{
Logger.Logger.AddToLog("PersonRepository | UpdateIntern | {0}", ex);
transaction.Rollback();
}
}
}
public async Task <string> CreateEmployeeRecord(EmployeeDetailsDto employee)
{
var entity = new Employee()
{
CreatedDate = DateTime.Now,
Email = employee.Email,
FirstName = employee.FirstName,
LastName = employee.LastName,
Number = employee.Number,
Title = employee.Title,
TaxId = employee.TaxId,
DepartmentId = employee.DepartmentId
};
var id = await _employeeRepository.Add(entity);
return(id);
}
public ActionResult EditEmployee(long id, EmployeeModel editedEmployee)
{
if (ModelState.IsValid)
{
var newEmployee = new EmployeeDetailsDto();
editedEmployee.ConvertToDto(newEmployee);
var currentEmployee = PersonRepository.GetItemById <Employee>(id);
var currentAddress = AddressRepository.GetItemById <Address>(currentEmployee.Address.Id);
AddressRepository.UpdateAddress(currentAddress, editedEmployee.City, editedEmployee.Street);
var newCompany = CompanyRepository.GetItemById <Company>(newEmployee.CompanyId);
var currentsalary = PersonRepository.GetItemById <Salary>(currentEmployee.Salary.Id);
PersonRepository.UpdateEmployee(currentEmployee, newEmployee, newCompany, currentsalary);
var pers = PersonRepository.GetAllFirstAndLastNames();
return(PartialView("WorkerList", pers));
}
return(PartialView(editedEmployee));
}
public async Task <EmployeeDetailsDto> GetEmployeeDetailsAsync(int employeeId)
{
Expression <Func <Employee, EmployeeDetailsDto> > selectExpression = e => new EmployeeDetailsDto
{
EmployeeId = e.EmployeeId,
EmployeeName = e.EmployeeName,
DepartmentId = e.DepartmentId,
DepartmentName = e.Department.DepartmentName,
DateOfBirth = e.DateOfBirth,
Email = e.Email,
PhoneNumber = e.PhoneNumber,
IsActive = e.IsActive,
CreatedAtUtc = e.CreatedAtUtc,
LastModifiedAtUtc = e.LastModifiedAtUtc
};
EmployeeDetailsDto employeeDetailsDto = await _unitOfWork.Repository <Employee>()
.GetProjectedEntityByIdAsync(employeeId, selectExpression);
return(employeeDetailsDto);
}
public async Task <ActionResult> DeleteEmployee(int employeeId)
{
try
{
EmployeeDetailsDto employee = await _employeeService.GetDetailsByIdAsync(employeeId);
if (employee == null)
{
ModelState.AddModelError(nameof(employeeId), "The Employee does not exist.");
return(BadRequest(ModelState));
}
await _employeeService.DeleteAsync(employeeId);
return(Ok());
}
catch (Exception exception)
{
await _exceptionLogger.LogAsync(exception);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <IActionResult> Create(EmployeeDetailsDto collection)
{
await _mendelCoreServices.CreateEmployeeRecord(collection);
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Details(EmployeeDetailsDto model)
{
await _mendelCoreServices.UpdateEmployeeRecord(model);
return(RedirectToAction(nameof(Index)));
}